Semintelligent

Using Pry with Padrino

Pry is a really powerful replacement for IRB – I love using it with Rails. I recently started working with Padrino and of course had to have it working there as well.

Pry will read and execute a .pryrc file that exists in the current directory as it boots – here is my Padrino specific .pryrc file – it boots your app just like you’d get in Rails using Pry:

`

load %{./config/boot.rb}
load %{./config/database.rb}
load %{./config/apps.rb}

require 'padrino-core/cli/console'
require 'padrino-core/cli/adapter'
require 'padrino-core/cli/base'
require 'padrino-core/cli/rake'
require 'padrino-core/cli/rake_tasks'

def app
  Padrino.application
end

def start( server = :puma )
  puts %{Type Ctrl-C to background server}
  Padrino.run! server: server
rescue Exception => e
  puts %{Problem starting server: #{ e.to_s }}
end

def stop
  puts %{Stopping server}
  threads = Thread.list
  threads.shift
  threads.each { |t| Thread.kill t }
end

def save_to( file, contents )
  File.open( file, %{w} ) { |f| f.puts contents }
end

`

Flavorrific published a monkey patch that extends Object with a deep freeze method that freezes child arrays and hashes of a data structure so that they aren’t accidentally changed (for example, configuration data from YAML).

I have extended his work in the following ways:

• Attributes of child objects are frozen as well
• Accesses to non-existent hash and array keys throw an IndexError.

class Object

 # Define a deep_freeze method in Object (based on code posted by flavorrific
 # http://flavoriffic.blogspot.com/2008/08/freezing-deep-ruby-data-structures.html)
 # that will call freeze on the top-level object instance the method is 
 # called on in as well as any child object instances contained in the
 # parent. This patch will also raise an IndexError if keys from    
 # ‘deeply frozen’ Hashes or Arrays are accessed that do not exist.

def deep_freeze

   #  String doesn’t support each
  if (self.class != String) && (self.respond_to? :each)
    each { |v|
      v.deep_freeze if v.respond_to?(:deep_freeze)
    }
  end

  #  Deep freeze instance variable values
  if self.kind_of? Object
    self.instance_variables.each { |v|
      iv = self.instance_variable_get(v)
      iv.deep_freeze
      self.instance_variable_set(v, iv)
    }
  end

  if self.kind_of? Hash
    instance_eval(<<-EOF)
      def default(key)
        raise IndexError, “Frozen hash: key ‘\#{key}’ does not exist!”
      end
    EOF
  end

  #  Prevent user from accessing array elements that do not exist.  
  if self.kind_of? Array
    instance_eval(<<-EOF)

      def at(index)
          self.fetch(index)
      end

      def [](arg1, arg2 = nil)

        results = Array.new

        if ! arg2.nil?
          #  Start index and end index given
          arg1.upto(arg1 + arg2) { |index|
            results << self.fetch(index)
          }
        else
          if arg1.kind_of? Range
            #  Range passed in
            arg1.each { |index|
              results << self.fetch(index)
            }
          else
            results << self.fetch(arg1)
          end

        end

        results

      end
    EOF

    end

    #  Freeze the current structure
    freeze

  end

end

http://confluence.atlassian.com/display/DISC/Confluence4r

I added a gemspec for the package to the bottom of the page if you want to build it as a gem in-house.

— Max Schubert