rails 0.8.5 → 0.9.0

data/lib/breakpoint_client.rb

@@ -0,0 +1,167 @@
+require 'breakpoint'
+require 'optparse'
+require 'timeout'
+
+options = {
+  :ClientURI  => nil,
+  :ServerURI  => "druby://localhost:42531",
+  :RetryDelay => 1,
+  :Verbose    => false
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = [
+    "Usage: ruby #{script_name} [options] [server uri]",
+    "",
+    "This tool lets you connect to a breakpoint service ",
+    "which was started via Breakpoint.activate_drb.",
+    "",
+    "The server uri defaults to druby://localhost:42531"
+  ].join("\n")
+
+  opts.separator ""
+
+  opts.on("-c", "--client-uri=uri",
+    "Run the client on the specified uri.",
+    "This can be used to specify the port",
+    "that the client uses to allow for back",
+    "connections from the server.",
+    "Default: Find a good URI automatically.",
+    "Example: -c druby://localhost:12345"
+  ) { |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]| }
+
+  opts.on("-R", "--retry-delay=delay", Integer,
+    "Automatically try to reconnect to the",
+    "server after delay seconds when the",
+    "connection failed or timed out.",
+    "A value of 0 disables automatical",
+    "reconnecting completely.",
+    "Default: 10"
+  ) { |options[:RetryDelay]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+    "Show this help message."
+  ) { puts opts; exit }
+
+  opts.parse!
+end
+
+options[:ServerURI] = ARGV[0] if ARGV[0]
+
+puts "Waiting for initial breakpoint..."
+
+loop do
+  DRb.start_service(options[:ClientURI])
+
+  begin
+    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
+
+    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
+      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]
+
+      loop do
+        begin
+          service.ping
+        rescue DRb::DRbConnError => error
+          puts "Server exited. Closing connection..." if options[:Verbose]
+          break
+        end
+
+        sleep(0.5)
+      end
+    ensure
+      service.unregister_handler
+    end
+  rescue Exception => error
+    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]
+      retry
+    else
+      raise
+    end
+  end
+end

data/lib/dispatcher.rb

@@ -21,26 +21,57 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'breakpoint'
+
 class Dispatcher
-  DEFAULT_SESSION_OPTIONS = { "database_manager" => CGI::Session::PStore, "prefix" => "ruby_sess.", "session_path" => "/" }
+  def self.dispatch(cgi = CGI.new, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS)
+    Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI)) if defined?(BREAKPOINT_SERVER_PORT)
 
-  def self.dispatch(cgi = CGI.new, session_options = DEFAULT_SESSION_OPTIONS, error_page = nil)
     begin
       request  = ActionController::CgiRequest.new(cgi, session_options)
       response = ActionController::CgiResponse.new(cgi)
+      
+      controller_name, module_name = controller_name(request.parameters), module_name(request.parameters)
 
-      controller_name = request.parameters["controller"].gsub(/[^_a-zA-Z0-9]/, "").untaint
+      require_dependency("application")
+      require_dependency(controller_path(controller_name, module_name))
 
-      require "#{Inflector.underscore(controller_name)}_controller"
-      Object.const_get("#{Inflector.camelize(controller_name)}Controller").process(request, response).out
-    rescue Exception => e
-      begin
-        ActionController::Base.logger.info "\n\nException throw during dispatch: #{e.message}\n#{e.backtrace.join("\n")}"
-      rescue Exception
-        # Couldn't log error
+      controller_class(controller_name).process(request, response).out
+    rescue Object => exception
+      ActionController::Base.process_with_exception(request, response, exception).out
+    ensure
+      if ActionController::Base.reload_dependencies
+        Object.send(:remove_const, "ApplicationController") if Object.const_defined?(:ApplicationController)
+        Object.send(:remove_const, controller_class_name(controller_name)) if Object.const_defined?(controller_class_name(controller_name))
+        ActiveRecord::Base.reset_associations_loaded
+        ActiveRecord::Base.reset_column_information_and_inheritable_attributes_for_all_subclasses
       end
       
-      if error_page then cgi.out{ IO.readlines(error_page) } else raise e end
+      Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
+    end
+  end
+  
+  def self.controller_path(controller_name, module_name = nil)
+    if module_name
+      "#{module_name}/#{Inflector.underscore(controller_name)}_controller"
+    else
+      "#{Inflector.underscore(controller_name)}_controller"
     end
   end
-end
+  
+  def self.controller_class(controller_name)
+    Object.const_get(controller_class_name(controller_name))
+  end
+  
+  def self.controller_class_name(controller_name)
+    "#{Inflector.camelize(controller_name)}Controller"
+  end
+  
+  def self.controller_name(parameters)
+    parameters["controller"].gsub(/[^_a-zA-Z0-9]/, "").untaint
+  end
+  
+  def self.module_name(parameters)
+    parameters["module"].gsub(/[^_a-zA-Z0-9]/, "").untaint if parameters["module"]
+  end
+end

data/lib/rails_generator.rb

@@ -0,0 +1,175 @@
+require 'fileutils'
+
+module Rails
+  module Generator
+    class GeneratorError < StandardError; end
+    class UsageError < GeneratorError; end
+
+    CONTRIB_ROOT = "#{RAILS_ROOT}/script/generators"
+    BUILTIN_ROOT = "#{File.dirname(__FILE__)}/../generators"
+    DEFAULT_SEARCH_PATHS = [CONTRIB_ROOT, BUILTIN_ROOT]
+
+    class << self
+      def instance(name, args = [], search_paths = DEFAULT_SEARCH_PATHS)
+        # RAILS_ROOT constant must be set.
+        unless Object.const_get(:RAILS_ROOT)
+          raise GeneratorError, "RAILS_ROOT must be set.  Did you require 'config/environment'?"
+        end
+
+        # Force canonical name.
+        name = Inflector.underscore(name.downcase)
+
+        # Search for filesystem path to requested generator.
+        unless path = find_generator_path(name, search_paths)
+          raise GeneratorError, "#{name} generator not found."
+        end
+
+        # Check for templates directory.
+        template_root = "#{path}/templates"
+        unless File.directory?(template_root)
+          raise GeneratorError, "missing template directory #{template_root}"
+        end
+
+        # Require class file according to naming convention.
+        require "#{path}/#{name}_generator.rb"
+
+        # Find class according to naming convention.  Allow Nesting::In::Modules.
+        class_name = Inflector.classify("#{name}_generator")
+        unless klass = find_generator_class(name)
+          raise GeneratorError, "no #{class_name} class defined in #{path}/#{name}_generator.rb"
+        end
+
+        # Instantiate and return generator.
+        klass.new(template_root, RAILS_ROOT, search_paths, args)
+      end
+
+
+      def builtin_generators
+        generators([BUILTIN_ROOT])
+      end
+
+      def contrib_generators
+        generators([CONTRIB_ROOT])
+      end
+
+      def generators(search_paths)
+        generator_paths(search_paths).keys.uniq.sort
+      end
+
+      # Find all generator paths.
+      def generator_paths(search_paths)
+        @paths ||= {}
+        unless @paths[search_paths]
+          paths = Hash.new { |h,k| h[k] = [] }
+          search_paths.each do |path|
+            Dir["#{path}/[a-z]*"].each do |dir|
+              paths[File.basename(dir)] << dir if File.directory?(dir)
+            end
+          end
+          @paths[search_paths] = paths
+        end
+        @paths[search_paths]
+      end
+
+      def find_generator_path(name, search_paths)
+        generator_paths(search_paths)[name].first
+      end
+
+      # Find all generator classes.
+      def generator_classes
+        classes = Hash.new { |h,k| h[k] = [] }
+        class_re = /([^:]+)Generator$/
+        ObjectSpace.each_object(Class) do |object|
+          if md = class_re.match(object.name) and object < Rails::Generator::Base
+            classes[Inflector.underscore(md.captures.first)] << object
+          end
+        end
+        classes
+      end
+
+      def find_generator_class(name)
+        generator_classes[name].first
+      end
+    end
+
+
+    # Talk about generators.
+    class Base
+      attr_reader :template_root, :destination_root, :args, :options,
+                  :class_name, :singular_name, :plural_name
+
+      alias_method :file_name,  :singular_name
+      alias_method :table_name, :plural_name
+
+      def self.generator_name
+        Inflector.underscore(name.gsub('Generator', ''))
+      end
+
+      def initialize(template_root, destination_root, search_paths, args)
+        @template_root, @destination_root = template_root, destination_root
+        usage if args.empty?
+        @search_paths, @original_args = search_paths, args.dup
+        @class_name, @singular_name, @plural_name = inflect_names(args.shift)
+        @options = extract_options!(args)
+        @args = args
+      end
+
+      protected
+        # Look up another generator with the same arguments.
+        def generator(name)
+          Rails::Generator.instance(name, @original_args, @search_paths)
+        end
+
+        # Generate a file for a Rails application using an ERuby template.
+        # Looks up and evalutes a template by name and writes the result
+        # to a file relative to +destination_root+.  The template
+        # is evaluated in the context of the optional eval_binding argument.
+        #
+        # The ERB template uses explicit trim mode to best control the
+        # proliferation of whitespace in generated code.  <%- trims leading
+        # whitespace; -%> trims trailing whitespace including one newline.
+        def template(template_name, destination_path, eval_binding = nil)
+          # Determine full paths for source and destination files.
+          template_path     = find_template_path(template_name)
+          destination_path  = File.join(destination_root, destination_path)
+
+          # Create destination directories.
+          FileUtils.mkdir_p(File.dirname(destination_path))
+
+          # Render template and write result.
+          eval_binding ||= binding
+          contents = ERB.new(File.read(template_path), nil, '-').result(eval_binding)
+          File.open(destination_path, 'w') { |file| file.write(contents) }
+        end
+
+        def usage
+          raise UsageError.new, File.read(usage_path)
+        end
+
+      private
+        def find_template_path(template_name)
+          name, path = template_name.split('/', 2)
+          if path.nil?
+            File.join(template_root, name)
+          elsif generator_path = Rails::Generator.find_generator_path(name, @search_paths)
+            File.join(generator_path, 'templates', path)
+          end
+        end
+
+        def inflect_names(name)
+          camel  = Inflector.camelize(Inflector.underscore(name))
+          under  = Inflector.underscore(camel)
+          plural = Inflector.pluralize(under)
+          [camel, under, plural]
+        end
+
+        def extract_options!(args)
+          if args.last.is_a?(Hash) then args.pop else {} end
+        end
+
+        def usage_path
+          "#{template_root}/../USAGE"
+        end
+    end
+  end
+end

data/lib/webrick_server.rb

@@ -7,6 +7,8 @@ require 'stringio'
 include WEBrick
 
 class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
+  REQUEST_MUTEX = Mutex.new
+
   def self.dispatch(options = {})
     Socket.do_not_reverse_lookup = true # patch for OS X
 
@@ -24,14 +26,19 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
   end
 
   def do_GET(req, res)
-    unless handle_index(req, res)
-      unless handle_dispatch(req, res)
-        unless handle_file(req, res)
-          unless handle_mapped(req, res)
-            raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+    begin
+      unless handle_index(req, res)
+        unless handle_dispatch(req, res)
+          unless handle_file(req, res)
+            REQUEST_MUTEX.lock
+            unless handle_mapped(req, res)
+              raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
+            end
           end
         end
       end
+    ensure
+      REQUEST_MUTEX.unlock if REQUEST_MUTEX.locked?
     end
   end
 
@@ -42,7 +49,7 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
       if @server_options[:index_controller]
         res.set_redirect WEBrick::HTTPStatus::MovedPermanently, "/#{@server_options[:index_controller]}/"
       else
-        res.set_redirect WEBrick::HTTPStatus::MovedPermanently, "/_doc/index.html"
+        res.set_redirect WEBrick::HTTPStatus::MovedPermanently, "/_doc/"
       end
 
       return true
@@ -59,15 +66,13 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
       res.set_error(err)
       return true
     rescue => err
-      p err
       return false
     end
   end
 
   def handle_mapped(req, res)
-    parsed_ok, controller, action, id = DispatchServlet.parse_uri(req.request_uri.path)
-    if parsed_ok
-      query = "controller=#{controller}&action=#{action}&id=#{id}"
+    if mappings = DispatchServlet.parse_uri(req.request_uri.path)
+      query = mappings.collect { |pair| "#{pair.first}=#{pair.last}" }.join("&")
       query << "&#{req.request_uri.query}" if req.request_uri.query
       origin = req.request_uri.path + "?" + query
       req.request_uri.path = "/dispatch.rb"
@@ -86,43 +91,19 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
     env["REQUEST_URI"] = origin if origin
     
     data = nil
-    if @server_options[:cache_classes]
-      old_stdin, old_stdout = $stdin, $stdout
-      $stdin, $stdout = StringIO.new(req.body || ""), StringIO.new
+    $old_stdin, $old_stdout = $stdin, $stdout
+    $stdin, $stdout = StringIO.new(req.body || ""), StringIO.new
 
-      begin
-        require 'cgi'
-        CGI.send(:define_method, :env_table) { env }
+    begin
+      require 'cgi'
+      CGI.send(:define_method, :env_table) { env }
 
-        load File.join(@server_options[:server_root], "dispatch.rb")
+      load File.join(@server_options[:server_root], "dispatch.rb")
 
-        $stdout.rewind
-        data = $stdout.read
-      ensure
-        $stdin, $stdout = old_stdin, old_stdout
-      end
-    else
-      begin
-        require 'rbconfig'
-        ruby_interpreter = Config::CONFIG['ruby_install_name'] || 'ruby'
-      rescue Object
-        ruby_interpreter = 'ruby'
-      end
-      
-      dispatch_rb_path = File.expand_path(File.join(@server_options[:server_root], "dispatch.rb"))
-      IO.popen(ruby_interpreter, "rb+") do |ruby|
-        ruby.puts <<-END
-          require 'cgi'
-          require 'stringio'
-          env = #{env.inspect}
-          CGI.send(:define_method, :env_table) { env }
-          $stdin = StringIO.new(#{(req.body || "").inspect})
-    
-          eval "load '#{dispatch_rb_path}'", binding, #{dispatch_rb_path.inspect}
-        END
-        ruby.close_write
-        data = ruby.read
-      end
+      $stdout.rewind
+      data = $stdout.read
+    ensure
+      $stdin, $stdout = $old_stdin, $old_stdout
     end
 
     raw_header, body = *data.split(/^[\xd\xa]+/on, 2)
@@ -141,18 +122,33 @@ class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
   end
   
   def self.parse_uri(path)
-    component = /([-_a-zA-Z0-9]+)/
+    component, id = /([-_a-zA-Z0-9]+)/, /([0-9]+)/
 
     case path.sub(%r{^/(?:fcgi|mruby|cgi)/}, "/")
       when %r{^/#{component}/?$} then
-        [true, $1, "index", nil]
-      when %r{^/#{component}/#{component}/?$} then
-        [true, $1, $2, nil]
-      when %r{^/#{component}/#{component}/#{component}/?$} then
-        [true, $1, $2, $3]
+        { :controller => $1, :action => "index" }
+      when %r{^/#{component}/#{component}$} then
+        { :controller => $1, :action => $2 }
+      when %r{^/#{component}/#{component}/#{id}$} then
+        { :controller => $1, :action => $2, :id => $3 }
+
+      when %r{^/#{component}/#{component}/$} then
+        { :module => $1, :controller => $2, :action => "index" }
+      when %r{^/#{component}/#{component}/#{component}$} then
+        if DispatchServlet.modules(component).include?($1)
+          { :module => $1, :controller => $2, :action => $3 }
+        else
+          { :controller => $1, :action => $2, :id => $3 }
+        end
+      when %r{^/#{component}/#{component}/#{component}/#{id}$} then
+        { :module => $1, :controller => $2, :action => $3, :id => $4 }
       else
-        [false, nil, nil, nil]
+        false
     end
+  end  
+
+  def self.modules(module_pattern = '[^.]+')
+    path = RAILS_ROOT + '/app/controllers'
+    Dir.entries(path).grep(/^#{module_pattern}$/).find_all {|e| File.directory?("#{path}/#{e}")}
   end
-  
 end