rails 0.9.4.1 → 0.9.5

data/CHANGELOG

@@ -1,3 +1,24 @@
+*0.9.5* (January 25th, 2005)
+
+* Fixed dependency reloading by switching to a remove_const approach where all Active Records, Active Record Observers, and Action Controllers are reloading by undefining their classes. This enables you to remove methods in all three types and see the change reflected immediately and it fixes #539. This also means that only those three types of classes will benefit from the const_missing and reloading approach. If you want other classes (like some in lib/) to reload, you must use require_dependency to do it.
+
+* Added Florian Gross' latest version of Breakpointer and friends that fixes a variaty of bugs #441 [Florian Gross]
+
+* Fixed skeleton Rakefile to work with sqlite3 out of the box #521 [rasputnik]
+
+* Fixed that script/breakpointer didn't get the Ruby path rewritten as the other scripts #523 [brandt@kurowski.net]
+
+* Fixed handling of syntax errors in models that had already been succesfully required once in the current interpreter
+
+* Fixed that models that weren't referenced in associations weren't being reloaded in the development mode by reinstating the reload
+
+* Fixed that generate scaffold would produce bad functional tests
+
+* Fixed that FCGI can also display SyntaxErrors
+
+* Upgraded to Active Record 1.6.0, Action Pack 1.4.0
+
+
 *0.9.4.1* (January 18th, 2005)
 
 * Added 5-second timeout to WordNet alternatives on creating reserved-word models #501 [Marcel Molina]

data/Rakefile

@@ -9,7 +9,7 @@ require 'rbconfig'
 
 PKG_BUILD       = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME        = 'rails'
-PKG_VERSION     = '0.9.4.1' + PKG_BUILD
+PKG_VERSION     = '0.9.5' + PKG_BUILD
 PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
 PKG_DESTINATION = ENV["RAILS_PKG_DESTINATION"] || "../#{PKG_NAME}"
 
@@ -218,7 +218,9 @@ end
 
 task :copy_gem_environment do
   cp "environments/shared_for_gem.rb", "#{PKG_DESTINATION}/config/environment.rb"
-  cp "bin/breakpointer_for_gem", "#{PKG_DESTINATION}/script/breakpointer"
+  dest_file = File.join(PKG_DESTINATION, 'script', 'breakpointer')
+  copy_with_rewritten_ruby_path(File.join('bin', 'breakpointer_for_gem'), dest_file)
+  chmod 0755, dest_file
 end
 
 
@@ -245,8 +247,8 @@ spec = Gem::Specification.new do |s|
   EOF
 
   s.add_dependency('rake', '>= 0.4.15')
-  s.add_dependency('activerecord', '>= 1.5.1')
-  s.add_dependency('actionpack', '>= 1.3.1')
+  s.add_dependency('activerecord', '>= 1.6.0')
+  s.add_dependency('actionpack', '>= 1.4.0')
   s.add_dependency('actionmailer', '>= 0.6.1')
 
   s.has_rdoc = false

data/fresh_rakefile

@@ -73,40 +73,52 @@ end
 
 desc "Recreate the test databases from the development structure"
 task :clone_structure_to_test => [ :db_structure_dump, :purge_test_database ] do
-  if ActiveRecord::Base.configurations["test"]["adapter"] == "mysql"
-    ActiveRecord::Base.establish_connection(:test)
-    ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-    IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
-      ActiveRecord::Base.connection.execute(table)
-    end
-  elsif ActiveRecord::Base.configurations["test"]["adapter"] == "postgresql"
-    `psql -U #{ActiveRecord::Base.configurations["test"]["username"]} -f db/#{RAILS_ENV}_structure.sql #{ActiveRecord::Base.configurations["test"]["database"]}`
-  elsif ActiveRecord::Base.configurations["test"]["adapter"] == "sqlite"
-    `sqlite #{ActiveRecord::Base.configurations["test"]["dbfile"]} < db/#{RAILS_ENV}_structure.sql`
+  abcs = ActiveRecord::Base.configurations
+  case abcs["test"]["adapter"]
+    when  "mysql"
+      ActiveRecord::Base.establish_connection(:test)
+      ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
+        ActiveRecord::Base.connection.execute(table)
+      end
+    when  "postgresql"
+      `psql -U #{abcs["test"]["username"]} -f db/#{RAILS_ENV}_structure.sql #{abcs["test"]["database"]}`
+    when "sqlite", "sqlite3"
+      `#{abcs[RAILS_ENV]["adapter"]} #{abcs["test"]["dbfile"]} < db/#{RAILS_ENV}_structure.sql`
+    else 
+      raise "Unknown database adapter '#{abcs["test"]["adapter"]}'"
   end
 end
 
 desc "Dump the database structure to a SQL file"
 task :db_structure_dump do
-  if ActiveRecord::Base.configurations[RAILS_ENV]["adapter"] == "mysql"
-    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[RAILS_ENV])
-    File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-  elsif ActiveRecord::Base.configurations[RAILS_ENV]["adapter"] == "postgresql"
-    `pg_dump -U #{ActiveRecord::Base.configurations[RAILS_ENV]["username"]} -s -f db/#{RAILS_ENV}_structure.sql #{ActiveRecord::Base.configurations[RAILS_ENV]["database"]}`
-  elsif ActiveRecord::Base.configurations[RAILS_ENV]["adapter"] == "sqlite"
-    `sqlite #{ActiveRecord::Base.configurations[RAILS_ENV]["dbfile"]} .schema > db/#{RAILS_ENV}_structure.sql`
+  abcs = ActiveRecord::Base.configurations
+  case abcs[RAILS_ENV]["adapter"] 
+    when "mysql"
+      ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
+      File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+    when  "postgresql"
+      `pg_dump -U #{abcs[RAILS_ENV]["username"]} -s -f db/#{RAILS_ENV}_structure.sql #{abcs[RAILS_ENV]["database"]}`
+    when "sqlite", "sqlite3"
+      `#{abcs[RAILS_ENV]["adapter"]} #{abcs[RAILS_ENV]["dbfile"]} .schema > db/#{RAILS_ENV}_structure.sql`
+    else 
+      raise "Unknown database adapter '#{abcs["test"]["adapter"]}'"
   end
 end
 
-desc "Drop the test database and bring it back again"
+desc "Empty the test database"
 task :purge_test_database do
-  if ActiveRecord::Base.configurations["test"]["adapter"] == "mysql"
-    ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[RAILS_ENV])
-    ActiveRecord::Base.connection.recreate_database(ActiveRecord::Base.configurations["test"]["database"])
-  elsif ActiveRecord::Base.configurations["test"]["adapter"] == "postgresql"
-    `dropdb -U #{ActiveRecord::Base.configurations["test"]["username"]} #{ActiveRecord::Base.configurations["test"]["database"]}`
-    `createdb -U #{ActiveRecord::Base.configurations["test"]["username"]}  #{ActiveRecord::Base.configurations["test"]["database"]}`
-  elsif ActiveRecord::Base.configurations["test"]["adapter"] == "sqlite"
-    File.delete(ActiveRecord::Base.configurations["test"]["dbfile"]) if File.exist?(ActiveRecord::Base.configurations["test"]["dbfile"])
+  abcs = ActiveRecord::Base.configurations
+  case abcs["test"]["adapter"]
+    when "mysql"
+      ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
+      ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
+    when "postgresql"
+      `dropdb -U #{abcs["test"]["username"]} #{abcs["test"]["database"]}`
+      `createdb -U #{abcs["test"]["username"]}  #{abcs["test"]["database"]}`
+    when "sqlite","sqlite3"
+      File.delete(abcs["test"]["dbfile"]) if File.exist?(abcs["test"]["dbfile"])
+    else 
+      raise "Unknown database adapter '#{abcs["test"]["adapter"]}'"
   end
 end

data/generators/scaffold/scaffold_generator.rb

@@ -9,16 +9,16 @@ class ScaffoldGenerator < Rails::Generator::Base
     template "fixtures.yml", "test/fixtures/#{table_name}.yml"
 
     @controller_class_name = args.empty? ? Inflector.pluralize(class_name) : args.shift.sub(/^[a-z]?/) { |m| m.capitalize }
-    controller_name        = Inflector.underscore(@controller_class_name)
+    @controller_name        = Inflector.underscore(@controller_class_name)
 
     # Controller class, functional test, helper, and views.
-    template "controller.rb", "app/controllers/#{controller_name}_controller.rb"
-    template "functional_test.rb", "test/functional/#{controller_name}_controller_test.rb"
-    template "controller/helper.rb", "app/helpers/#{controller_name}_helper.rb"
+    template "controller.rb", "app/controllers/#{@controller_name}_controller.rb"
+    template "functional_test.rb", "test/functional/#{@controller_name}_controller_test.rb"
+    template "controller/helper.rb", "app/helpers/#{@controller_name}_helper.rb"
 
     # Layout and stylesheet.
-    unless File.file?("app/views/layouts/#{controller_name}.rhtml")
-      template "layout.rhtml", "app/views/layouts/#{controller_name}.rhtml"
+    unless File.file?("app/views/layouts/#{@controller_name}.rhtml")
+      template "layout.rhtml", "app/views/layouts/#{@controller_name}.rhtml"
     end
     unless File.file?("public/stylesheets/scaffold.css")
       template "style.css", "public/stylesheets/scaffold.css"
@@ -26,13 +26,13 @@ class ScaffoldGenerator < Rails::Generator::Base
 
     # Scaffolded views.
     scaffold_views.each do |action|
-      template "view_#{action}.rhtml", "app/views/#{controller_name}/#{action}.rhtml"
+      template "view_#{action}.rhtml", "app/views/#{@controller_name}/#{action}.rhtml"
     end
 
     # Unscaffolded views.
     unscaffolded_actions.each do |action|
       template "controller/view.rhtml",
-               "app/views/#{controller_name}/#{action}.rhtml",
+               "app/views/#{@controller_name}/#{action}.rhtml",
                binding
     end
   end

data/generators/scaffold/templates/functional_test.rb

@@ -1,14 +1,14 @@
 require File.dirname(__FILE__) + '/../test_helper'
-require '<%= file_name %>_controller'
+require '<%= @controller_name %>_controller'
 
 # Re-raise errors caught by the controller.
-class <%= class_name %>Controller; def rescue_action(e) raise e end; end
+class <%= @controller_class_name %>Controller; def rescue_action(e) raise e end; end
 
-class <%= class_name %>ControllerTest < Test::Unit::TestCase
+class <%= @controller_class_name %>ControllerTest < Test::Unit::TestCase
   fixtures :<%= table_name %>
 
   def setup
-    @controller = <%= class_name %>Controller.new
+    @controller = <%= @controller_class_name %>Controller.new
     @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
   end
 

data/lib/binding_of_caller.rb

@@ -1,85 +1,83 @@
-begin
-  require 'simplecc'
-rescue LoadError
-  class Continuation #:nodoc:
-    def self.create(*args, &block)
-      cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-      result ||= args
-      return *[cc, *result]
-    end
-  end
-end
-
-class Binding #:nodoc:
-  # This method returns the binding of the method that called your
-  # method. It will raise an Exception when you're not inside a method.
-  #
-  # It's used like this:
-  #   def inc_counter(amount = 1)
-  #     Binding.of_caller do |binding|
-  #       # Create a lambda that will increase the variable 'counter'
-  #       # in the caller of this method when called.
-  #       inc = eval("lambda { |arg| counter += arg }", binding)
-  #       # We can refer to amount from inside this block safely.
-  #       inc.call(amount)
-  #     end
-  #     # No other statements can go here. Put them inside the block.
-  #   end
-  #   counter = 0
-  #   2.times { inc_counter }
-  #   counter # => 2
-  #
-  # Binding.of_caller must be the last statement in the method.
-  # This means that you will have to put everything you want to
-  # do after the call to Binding.of_caller into the block of it.
-  # This should be no problem however, because Ruby has closures.
-  # If you don't do this an Exception will be raised. Because of
-  # the way that Binding.of_caller is implemented it has to be
-  # done this way.
-  def self.of_caller(&block)
-    old_critical = Thread.critical
-    Thread.critical = true
-    count = 0
-    cc, result, error, extra_data = Continuation.create(nil, nil)
-    error.call if error
-
-    tracer = lambda do |*args|
-      type, context, extra_data = args[0], args[4], args
-      if type == "return"
-        count += 1
-        # First this method and then calling one will return --
-        # the trace event of the second event gets the context
-        # of the method which called the method that called this
-        # method.
-        if count == 2
-          # It would be nice if we could restore the trace_func
-          # that was set before we swapped in our own one, but
-          # this is impossible without overloading set_trace_func
-          # in current Ruby.
-          set_trace_func(nil)
-          cc.call(eval("binding", context), nil, extra_data)
-        end
-      elsif type == "line" then
-        nil
-      elsif type == "c-return" and extra_data[3] == :set_trace_func then
-        nil
-      else
-        set_trace_func(nil)
-        error_msg = "Binding.of_caller used in non-method context or " +
-          "trailing statements of method using it aren't in the block."
-        cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
-      end
-    end
-
-    unless result
-      set_trace_func(tracer)
-      return nil
-    else
-      Thread.critical = old_critical
-      case block.arity
-        when 1 then yield(result)
-        else yield(result, extra_data)        
-      end
-    end
-  end
-end
+begin
+  require 'simplecc'
+rescue LoadError
+  class Continuation; end # :nodoc: # for RDoc
+  def Continuation.create(*args, &block) # :nodoc:
+    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+    result ||= args
+    return *[cc, *result]
+  end
+end
+
+class Binding; end # for RDoc
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter(amount = 1)
+#     Binding.of_caller do |binding|
+#       # Create a lambda that will increase the variable 'counter'
+#       # in the caller of this method when called.
+#       inc = eval("lambda { |arg| counter += arg }", binding)
+#       # We can refer to amount from inside this block safely.
+#       inc.call(amount)
+#     end
+#     # No other statements can go here. Put them inside the block.
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# Binding.of_caller must be the last statement in the method.
+# This means that you will have to put everything you want to
+# do after the call to Binding.of_caller into the block of it.
+# This should be no problem however, because Ruby has closures.
+# If you don't do this an Exception will be raised. Because of
+# the way that Binding.of_caller is implemented it has to be
+# done this way.
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type == "line" then
+      nil
+    elsif type == "c-return" and extra_data[3] == :set_trace_func then
+      nil
+    else
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)        
+    end
+  end
+end

data/lib/breakpoint.rb

@@ -21,6 +21,9 @@ require 'drb'
 require 'drb/acl'
 
 module Breakpoint
+  id = %q$Id: breakpoint.rb 41 2005-01-22 20:22:10Z flgr $
+  Version = id.split(" ")[2].to_i
+
   extend self
 
   # This will pop up an interactive ruby session at a
@@ -114,10 +117,10 @@ module Breakpoint
     end
   end
 
-  module CommandBundle #:nodoc:
+  module CommandBundle
     # Proxy to a Breakpoint client. Lets you directly execute code
     # in the context of the client.
-    class Client#:nodoc:
+    class Client
       def initialize(eval_handler) # :nodoc:
         @eval_handler = eval_handler
       end
@@ -133,15 +136,23 @@ module Breakpoint
       end
 
       # Will execute the specified statement at the client.
-      def method_missing(method, *args)
-        if args.empty?
-          result = eval("#{method}")
+      def method_missing(method, *args, &block)
+        if args.empty? and not block
+          result = eval "#{method}"
         else
-          result = eval("#{method}(*Marshal.load(#{Marshal.dump(args).inspect}))")
-        end
-
-        unless [true, false, nil].include?(result)
-          result.extend(DRbUndumped) if result
+          # This is a bit ugly. The alternative would be using an
+          # eval context instead of an eval handler for executing
+          # the code at the client. The problem with that approach
+          # is that we would have to handle special expressions
+          # like "self", "nil" or constants ourself which is hard.
+          remote = eval %{
+            result = lambda { |block, *args| #{method}(*args, &block) }
+            def result.call_with_block(*args, &block)
+              call(block, *args)
+            end
+            result
+          }
+          remote.call_with_block(*args, &block)
         end
 
         return result
@@ -175,6 +186,7 @@ module Breakpoint
     #   client.File.open("temp.txt", "w") { |f| f.puts "Hello" } 
     def client()
       if Breakpoint.use_drb? then
+        sleep(0.5) until Breakpoint.drb_service.eval_handler
         Client.new(Breakpoint.drb_service.eval_handler)
       else
         Client.new(lambda { |code| eval(code, TOPLEVEL_BINDING) })
@@ -205,7 +217,7 @@ module Breakpoint
   # These exceptions will be raised on failed asserts
   # if Breakpoint.asserts_cause_exceptions is set to
   # true.
-  class FailedAssertError < RuntimeError#:nodoc:
+  class FailedAssertError < RuntimeError
   end
 
   # This asserts that the block evaluates to true.
@@ -279,7 +291,7 @@ module Breakpoint
       @collision_handler.call
     end
 
-    def ping; end
+    def ping() end
 
     def add_breakpoint(context, message)
       workspace = IRB::WorkSpace.new(context)
@@ -290,31 +302,7 @@ module Breakpoint
       @handler.call(workspace, message)
     end
 
-    def register_handler(&block)
-      @handler = block
-    end
-
-    def unregister_handler
-      @handler = nil
-    end
-
-    attr_reader :eval_handler
-
-    def register_eval_handler(&block)
-      @eval_handler = block
-    end
-
-    def unregister_eval_handler
-      @eval_handler = lambda { }
-    end
-
-    def register_collision_handler(&block)
-      @collision_handler = block
-    end
-
-    def unregister_collision_handler
-      @collision_handler = lambda { }
-    end
+    attr_accessor :handler, :eval_handler, :collision_handler
   end
 
   # Will run Breakpoint in DRb mode. This will spawn a server
@@ -359,7 +347,8 @@ module Breakpoint
   #
   # Detailed information about running DRb through firewalls is
   # available at http://www.rubygarden.org/ruby?DrbTutorial
-  def activate_drb(uri = nil, allowed_hosts = ['localhost', '127.0.0.1', '::1'], ignore_collisions = false) #:nodoc:
+  def activate_drb(uri = nil, allowed_hosts = ['localhost', '127.0.0.1', '::1'],
+    ignore_collisions = false)
 
     return false if @use_drb
 
@@ -402,7 +391,7 @@ module Breakpoint
   end
 
   # Deactivates a running Breakpoint service.
-  def deactivate_drb #:nodoc:
+  def deactivate_drb
     @service.stop_service unless @service.nil?
     @service = nil
     @use_drb = false
@@ -411,7 +400,7 @@ module Breakpoint
 
   # Returns true when Breakpoints are used over DRb.
   # Breakpoint.activate_drb causes this to be true.
-  def use_drb? #:nodoc:
+  def use_drb?
     @use_drb == true
   end
 end
@@ -440,7 +429,11 @@ module IRB # :nodoc:
     @CONF[:MAIN_CONTEXT] = irb.context
 
     old_sigint = trap("SIGINT") do
-      irb.signal_handle
+      begin
+        irb.signal_handle
+      rescue RubyLex::TerminateLineInput
+        # ignored
+      end
     end
     
     catch(:IRB_EXIT) do
@@ -464,7 +457,7 @@ module IRB # :nodoc:
     end
   end
 
-  class Context#:nodoc:
+  class Context
     alias :old_evaluate :evaluate
     def evaluate(line, line_no)
       if line.chomp == "exit" then
@@ -475,7 +468,7 @@ module IRB # :nodoc:
     end
   end
 
-  class WorkSpace#:nodoc:
+  class WorkSpace
     alias :old_evaluate :evaluate
 
     def evaluate(*args)
@@ -493,7 +486,7 @@ module IRB # :nodoc:
     end
   end
 
-  module InputCompletor#:nodoc:
+  module InputCompletor
     def self.eval(code, context, *more)
       # Big hack, this assumes that InputCompletor
       # will only call eval() when it wants code
@@ -504,9 +497,9 @@ module IRB # :nodoc:
 end
 
 module DRb # :nodoc:
-  class DRbObject#:nodoc:
-    undef :inspect
-    undef :clone
+  class DRbObject
+    undef :inspect if method_defined?(:inspect)
+    undef :clone if method_defined?(:clone)
   end
 end
 
@@ -522,4 +515,4 @@ def assert(&block)
   Binding.of_caller do |context|
     Breakpoint.assert(context, &block)
   end
-end
+end

data/lib/breakpoint_client.rb

@@ -2,17 +2,18 @@ require 'breakpoint'
 require 'optparse'
 require 'timeout'
 
-options = {
+Options = {
   :ClientURI  => nil,
   :ServerURI  => "druby://localhost:42531",
-  :RetryDelay => 1,
+  :RetryDelay => 3,
+  :Permanent  => true,
   :Verbose    => false
 }
 
 ARGV.options do |opts|
   script_name = File.basename($0)
   opts.banner = [
-    "Usage: ruby #{script_name} [options] [server uri]",
+    "Usage: ruby #{script_name} [Options] [server uri]",
     "",
     "This tool lets you connect to a breakpoint service ",
     "which was started via Breakpoint.activate_drb.",
@@ -29,18 +30,13 @@ ARGV.options do |opts|
     "connections from the server.",
     "Default: Find a good URI automatically.",
     "Example: -c druby://localhost:12345"
-  ) { |options[:ClientURI]| }
+  ) { |Options[:ClientURI]| }
 
   opts.on("-s", "--server-uri=uri",
     "Connect to the server specified at the",
     "specified uri.",
     "Default: druby://localhost:42531"
-  ) { |options[:ServerURI]| }
-
-  opts.on("-v", "--verbose",
-    "Report all connections and disconnections",
-    "Default: false"
-  ) { |options[:Verbose]| }
+  ) { |Options[:ServerURI]| }
 
   opts.on("-R", "--retry-delay=delay", Integer,
     "Automatically try to reconnect to the",
@@ -49,124 +45,149 @@ ARGV.options do |opts|
     "A value of 0 disables automatical",
     "reconnecting completely.",
     "Default: 10"
-  ) { |options[:RetryDelay]| }
+  ) { |Options[:RetryDelay]| }
+
+  opts.on("-P", "--[no-]permanent",
+    "Run the breakpoint client in permanent mode.",
+    "This means that the client will keep continue",
+    "running even after the server has closed the",
+    "connection. Useful for example in Rails."
+  ) { |Options[:Permanent]| }
+
+  opts.on("-V", "--[no-]verbose",
+    "Run the breakpoint client in verbose mode.",
+    "Will produce more messages, for example between",
+    "individual breakpoints. This might help in seeing",
+    "that the breakpoint client is still alive, but adds",
+    "quite a bit of clutter."
+  ) { |Options[:Verbose]| }
 
   opts.separator ""
 
   opts.on("-h", "--help",
     "Show this help message."
   ) { puts opts; exit }
+  opts.on("-v", "--version",
+    "Display the version information."
+  ) do
+    id = %q$Id: breakpoint_client.rb 40 2005-01-22 20:05:00Z flgr $
+    puts id.sub("Id: ", "")
+    puts "(Breakpoint::Version = #{Breakpoint::Version})"
+    exit
+  end
 
   opts.parse!
 end
 
-options[:ServerURI] = ARGV[0] if ARGV[0]
+Options[:ServerURI] = ARGV[0] if ARGV[0]
 
-$running = true
+module Handlers
+  extend self
 
-trap("INT"){$running = false}
+  def breakpoint_handler(workspace, message)
+    puts message
+    IRB.start(nil, nil, workspace)
+
+    puts ""
+    if Options[:Verbose] then
+      puts "Resumed execution. Waiting for next breakpoint...", ""
+    end
+  end
+
+  def eval_handler(code)
+    result = eval(code, TOPLEVEL_BINDING)
+    if result then
+      DRbObject.new(result)
+    else
+      result
+    end
+  end
 
-puts "Waiting for initial breakpoint..."
+  def collision_handler()
+    msg = [
+      "  *** Breakpoint service collision ***",
+      "  Another Breakpoint service tried to use the",
+      "  port already occupied by this one. It will",
+      "  keep waiting until this Breakpoint service",
+      "  is shut down.",
+      "  ",
+      "  If you are using the Breakpoint library for",
+      "  debugging a Rails or other CGI application",
+      "  this likely means that this Breakpoint",
+      "  session belongs to an earlier, outdated",
+      "  request and should be shut down via 'exit'."
+    ].join("\n")
+
+    if RUBY_PLATFORM["win"] then
+      # This sucks. Sorry, I'm not doing this because
+      # I like funky message boxes -- I need to do this
+      # because on Windows I have no way of displaying
+      # my notification via puts() when gets() is still
+      # being performed on STDIN. I have not found a
+      # better solution.
+      begin
+        require 'tk'
+        root = TkRoot.new { withdraw }
+        Tk.messageBox('message' => msg, 'type' => 'ok')
+        root.destroy
+      rescue Exception
+        puts "", msg, ""
+      end
+    else
+      puts "", msg, ""
+    end
+  end
+end
+
+# Used for checking whether we are currently in the reconnecting loop.
+reconnecting = false
 
 loop do
-  DRb.start_service(options[:ClientURI])
+  DRb.start_service(Options[:ClientURI])
 
   begin
-    service = DRbObject.new(nil, options[:ServerURI])
+    service = DRbObject.new(nil, Options[:ServerURI])
 
     begin
-      timeout(10) { service.ping }
-    rescue Timeout::Error, DRb::DRbConnError
-      if options[:Verbose]
-        puts "",
-          "  *** Breakpoint service didn't respond to ping request ***",
-          "  This likely happened because of a misconfigured ACL (see the",
-          "  documentation of Breakpoint.activate_drb, note that by default",
-          "  you can only connect to a remote Breakpoint service via a SSH",
-          "  tunnel), but might also be caused by an extremely slow connection.",
-          ""
-        end
-      raise
-    end
+      service.eval_handler = Handlers.method(:eval_handler)
+      service.collision_handler = Handlers.method(:collision_handler)
+      service.handler = Handlers.method(:breakpoint_handler)
 
-    begin
-      service.register_eval_handler do |code|
-        result = eval(code, TOPLEVEL_BINDING)
-        if result
-          DRbObject.new(result)
-        else
-          result
-        end
-      end 
-
-      service.register_collision_handler do
-        msg = [
-          "  *** Breakpoint service collision ***",
-          "  Another Breakpoint service tried to use the",
-          "  port already occupied by this one. It will",
-          "  keep waiting until this Breakpoint service",
-          "  is shut down.",
-          "  ",
-          "  If you are using the Breakpoint library for",
-          "  debugging a Rails or other CGI application",
-          "  this likely means that this Breakpoint",
-          "  session belongs to an earlier, outdated",
-          "  request and should be shut down via 'exit'."
-        ].join("\n")
-
-        if RUBY_PLATFORM["win"] then
-          # This sucks. Sorry, I'm not doing this because
-          # I like funky message boxes -- I need to do this
-          # because on Windows I have no way of displaying
-          # my notification via puts() when gets() is still
-          # being performed on STDIN. I have not found a
-          # better solution.
-          begin
-            require 'tk'
-            root = TkRoot.new { withdraw }
-            Tk.messageBox('message' => msg, 'type' => 'ok')
-            root.destroy
-          rescue Exception
-            puts "", msg, ""
-          end
-        else
-          puts "", msg, ""
-        end
+      reconnecting = false
+      if Options[:Verbose] then
+        puts "Connection established. Waiting for breakpoint...", ""
       end
 
-      service.register_handler do |workspace, message|
-        puts message
-        IRB.start(nil, nil, workspace)
-        puts "", "Resumed execution. Waiting for next breakpoint...", ""
-      end
-
-      puts "Connection established. Waiting for breakpoint...", "" if options[:Verbose]
-
-      while $running
+      loop do
         begin
           service.ping
         rescue DRb::DRbConnError => error
-          puts "Server exited. Closing connection..." if options[:Verbose]
+          puts "Server exited. Closing connection...", ""
+          exit! unless Options[:Permanent]
           break
         end
 
         sleep(0.5)
       end
     ensure
-      service.unregister_handler
+      service.eval_handler = nil
+      service.collision_handler = nil
+      service.handler = nil
     end
   rescue Exception => error
-    break unless $running
-    if options[:RetryDelay] > 0 then
-      puts "No connection to breakpoint service at #{options[:ServerURI]}:", "  (#{error.inspect})" if options[:Verbose]
-      error.backtrace if $DEBUG
-
-      puts "  Reconnecting in #{options[:RetryDelay]} seconds..." if options[:Verbose]
- 
-      sleep options[:RetryDelay]
+    if Options[:RetryDelay] > 0 then
+      if not reconnecting then
+        reconnecting = true
+        puts "No connection to breakpoint service at #{Options[:ServerURI]} " +
+           "(#{error.class})"
+        puts error.backtrace if $DEBUG
+        puts "Tries to connect will be made every #{Options[:RetryDelay]} seconds..."
+      end
+
+      sleep Options[:RetryDelay]
       retry
     else
       raise
     end
   end
-end
+end

data/lib/dispatcher.rb

@@ -34,30 +34,29 @@ class Dispatcher
     
         controller_name, module_name = controller_name(request.parameters), module_name(request.parameters)
 
-        require_dependency("application")
-        require_dependency(controller_path(controller_name, module_name))
+        require_or_load("application")
+        require_or_load(controller_path(controller_name, module_name))
 
         controller_class(controller_name).process(request, response).out
       rescue Object => exception
         ActionController::Base.process_with_exception(request, response, exception).out
       ensure
-        reset_application(controller_name) if Dependencies.mechanism == :load
+        reset_application if Dependencies.load?
         Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
       end
     end
     
     private
-      def reset_application(controller_name)
-        ActiveRecord::Base.reset_column_information_and_inheritable_attributes_for_all_subclasses
+      def reset_application
         Dependencies.clear
-        remove_class_hierarchy(controller_class(controller_name), ActionController::Base)
+        Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
       end
-
+    
       def controller_path(controller_name, module_name = nil)
         if module_name
-          "#{module_name}/#{Inflector.underscore(controller_name)}_controller"
+          "#{module_name}/#{controller_name.underscore}_controller"
         else
-          "#{Inflector.underscore(controller_name)}_controller"
+          "#{controller_name.underscore}_controller"
         end
       end
 
@@ -66,22 +65,15 @@ class Dispatcher
       end
 
       def controller_class_name(controller_name)
-        "#{Inflector.camelize(controller_name)}Controller"
+        "#{controller_name.camelize}Controller"
       end
 
       def controller_name(parameters)
-        parameters["controller"].gsub(/[^_a-zA-Z0-9]/, "").untaint
+        parameters["controller"].downcase.gsub(/[^_a-zA-Z0-9]/, "").untaint
       end
 
       def module_name(parameters)
-        parameters["module"].gsub(/[^_a-zA-Z0-9]/, "").untaint if parameters["module"]
-      end
-
-      def remove_class_hierarchy(klass, until_superclass)
-        while klass
-          Object.send(:remove_const, "#{klass}".intern)
-          klass = (klass.superclass unless until_superclass == klass.superclass)
-        end
+        parameters["module"].downcase.gsub(/[^_a-zA-Z0-9]/, "").untaint if parameters["module"]
       end
   end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.4
 specification_version: 1
 name: rails
 version: !ruby/object:Gem::Version 
-  version: 0.9.4.1
-date: 2005-01-18
+  version: 0.9.5
+date: 2005-01-25
 summary: "Web-application framework with template engine, control-flow layer, and ORM."
 require_paths: 
   - lib
@@ -138,7 +138,7 @@ dependencies:
         - 
           - ">="
           - !ruby/object:Gem::Version 
-            version: 1.5.1
+            version: 1.6.0
       version: 
   - !ruby/object:Gem::Dependency 
     name: actionpack
@@ -148,7 +148,7 @@ dependencies:
         - 
           - ">="
           - !ruby/object:Gem::Version 
-            version: 1.3.1
+            version: 1.4.0
       version: 
   - !ruby/object:Gem::Dependency 
     name: actionmailer