rails 1.2.6 → 2.0.0

data/html/robots.txt

@@ -1 +1,5 @@
-# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/lib/commands/console.rb

@@ -10,16 +10,23 @@ OptionParser.new do |opt|
 end
 
 libs =  " -r irb/completion"
-libs << " -r #{RAILS_ROOT}/config/environment"
+libs << %( -r "#{RAILS_ROOT}/config/environment")
 libs << " -r console_app"
 libs << " -r console_sandbox" if options[:sandbox]
 libs << " -r console_with_helpers"
 
-ENV['RAILS_ENV'] = ARGV.first || ENV['RAILS_ENV'] || 'development'
+ENV['RAILS_ENV'] = case ARGV.first
+  when "p": "production"
+  when "d": "development"
+  when "t": "test"
+  else
+    ARGV.first || ENV['RAILS_ENV'] || 'development'
+end
+
 if options[:sandbox]
-  puts "Loading #{ENV['RAILS_ENV']} environment in sandbox."
-  puts "Any modifications you make will be rolled back on exit."
+  puts "Loading #{ENV['RAILS_ENV']} environment in sandbox (Rails #{Rails::VERSION::STRING})"
+  puts "Any modifications you make will be rolled back on exit"
 else
-  puts "Loading #{ENV['RAILS_ENV']} environment."
+  puts "Loading #{ENV['RAILS_ENV']} environment (Rails #{Rails::VERSION::STRING})"
 end
 exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/commands/performance/request.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+require 'config/environment'
+require 'application'
+require 'action_controller/request_profiler'
+
+ActionController::RequestProfiler.run(ARGV)

data/lib/commands/plugin.rb

@@ -91,7 +91,7 @@ class RailsEnvironment
     unless plugin.nil?
       plugin.install
     else
-      puts "plugin not found: #{name_uri_or_plugin}"
+      puts "Plugin not found: #{name_uri_or_plugin}"
     end
   end
  
@@ -239,10 +239,10 @@ class Plugin
 
     def install_using_http(options = {})
       root = rails_env.root
-      mkdir_p "#{root}/vendor/plugins"
-      Dir.chdir "#{root}/vendor/plugins" do
+      mkdir_p "#{root}/vendor/plugins/#{@name}"
+      Dir.chdir "#{root}/vendor/plugins/#{@name}" do
         puts "fetching from '#{uri}'" if $verbose
-        fetcher = RecursiveHTTPFetcher.new(uri)
+        fetcher = RecursiveHTTPFetcher.new(uri, -1)
         fetcher.quiet = true if options[:quiet]
         fetcher.fetch
       end
@@ -515,7 +515,7 @@ module Commands
         o.on(         "--local", 
                       "List locally installed plugins.") {|@local| @remote = false}
         o.on(         "--remote",
-                      "List remotely availabled plugins. This is the default behavior",
+                      "List remotely available plugins. This is the default behavior",
                       "unless --local is provided.") {|@remote|}
       end
     end
@@ -765,8 +765,9 @@ module Commands
       args.each do |name|
         ::Plugin.find(name).install(install_method, @options)
       end
-    rescue
+    rescue StandardError => e
       puts "Plugin not found: #{args.inspect}"
+      puts e.inspect if $verbose
       exit 1
     end
   end
@@ -853,7 +854,8 @@ end
  
 class RecursiveHTTPFetcher
   attr_accessor :quiet
-  def initialize(urls_to_fetch, cwd = ".")
+  def initialize(urls_to_fetch, level = 1, cwd = ".")
+    @level = level
     @cwd = cwd
     @urls_to_fetch = urls_to_fetch.to_a
     @quiet = false
@@ -884,7 +886,8 @@ class RecursiveHTTPFetcher
     links = []
     contents.scan(/href\s*=\s*\"*[^\">]*/i) do |link|
       link = link.sub(/href="/i, "")
-      next if link =~ /^http/i || link =~ /^\./
+      next if link =~ /svnindex.xsl$/
+      next if link =~ /^(\w*:|)\/\// || link =~ /^\./
       links << File.join(base_url, link)
     end
     links
@@ -906,12 +909,14 @@ class RecursiveHTTPFetcher
   end
   
   def fetch_dir(url)
-    push_d(File.basename(url))
+    @level += 1
+    push_d(File.basename(url)) if @level > 0
     open(url) do |stream|
       contents =  stream.read
       fetch(links(url, contents))
     end
-    pop_d
+    pop_d if @level > 0
+    @level -= 1
   end
 end
 

data/lib/commands/process/spawner.rb

@@ -65,6 +65,14 @@ class MongrelSpawner < Spawner
       "-c #{OPTIONS[:rails_root]} " +
       "-l #{OPTIONS[:rails_root]}/log/mongrel.log"
 
+    # Add prefix functionality to spawner's call to mongrel_rails
+    # Digging through monrel's project subversion server, the earliest
+    # Tag that has prefix implemented in the bin/mongrel_rails file
+    # is 0.3.15 which also happens to be the earilest tag listed.
+    # References: http://mongrel.rubyforge.org/svn/tags
+    if Mongrel::Const::MONGREL_VERSION.to_f >=0.3 && !OPTIONS[:prefix].nil?
+      cmd = cmd + " --prefix #{OPTIONS[:prefix]}"
+    end
     system(cmd)
   end
   
@@ -114,14 +122,15 @@ end
 OPTIONS = {
   :environment => "production",
   :spawner     => '/usr/bin/env spawn-fcgi',
-  :dispatcher  => File.expand_path(RAILS_ROOT + '/public/dispatch.fcgi'),
-  :pids        => File.expand_path(RAILS_ROOT + "/tmp/pids"),
-  :rails_root  => File.expand_path(RAILS_ROOT),
+  :dispatcher  => File.expand_path(RELATIVE_RAILS_ROOT + '/public/dispatch.fcgi'),
+  :pids        => File.expand_path(RELATIVE_RAILS_ROOT + "/tmp/pids"),
+  :rails_root  => File.expand_path(RELATIVE_RAILS_ROOT),
   :process     => "dispatch",
   :port        => 8000,
   :address     => '0.0.0.0',
   :instances   => 3,
-  :repeat      => nil
+  :repeat      => nil,
+  :prefix      => nil
 }
 
 ARGV.options do |opts|
@@ -182,6 +191,7 @@ ARGV.options do |opts|
   opts.on("-i", "--instances=number", Integer, "Number of instances (default: #{OPTIONS[:instances]})")            { |v| OPTIONS[:instances] = v }
   opts.on("-r", "--repeat=seconds",   Integer, "Repeat spawn attempts every n seconds (default: off)")             { |v| OPTIONS[:repeat] = v }
   opts.on("-e", "--environment=name", String,  "test|development|production (default: #{OPTIONS[:environment]})")  { |v| OPTIONS[:environment] = v }
+  opts.on("-P", "--prefix=path",      String,  "URL prefix for Rails app. [Used only with Mongrel > v0.3.15]: (default: #{OPTIONS[:prefix]})")         { |v| OPTIONS[:prefix] = v }
   opts.on("-n", "--process=name",     String,  "default: #{OPTIONS[:process]}")                                    { |v| OPTIONS[:process] = v }
   opts.on("-s", "--spawner=path",     String,  "default: #{OPTIONS[:spawner]}")                                    { |v| OPTIONS[:spawner] = v }
   opts.on("-d", "--dispatcher=path",  String,  "default: #{OPTIONS[:dispatcher]}") { |dispatcher| OPTIONS[:dispatcher] = File.expand_path(dispatcher) }

data/lib/commands/servers/base.rb

@@ -17,3 +17,15 @@ def tail(log_file)
   end
   tail_thread
 end
+
+def start_debugger
+  begin
+    require_library_or_gem 'ruby-debug'
+    Debugger.start
+    Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
+    puts "=> Debugger enabled"
+  rescue Exception
+    puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
+    exit
+  end
+end

data/lib/commands/servers/mongrel.rb

@@ -12,13 +12,15 @@ OPTIONS = {
   :port        => 3000,
   :ip          => "0.0.0.0",
   :environment => (ENV['RAILS_ENV'] || "development").dup,
-  :detach      => false
+  :detach      => false,
+  :debugger    => false
 }
 
 ARGV.clone.options do |opts|
   opts.on("-p", "--port=port", Integer, "Runs Rails on the specified port.", "Default: 3000") { |v| OPTIONS[:port] = v }
   opts.on("-b", "--binding=ip", String, "Binds Rails to the specified ip.", "Default: 0.0.0.0") { |v| OPTIONS[:ip] = v }
   opts.on("-d", "--daemon", "Make server run as a Daemon.") { OPTIONS[:detach] = true }
+  opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { OPTIONS[:debugger] = true }
   opts.on("-e", "--environment=name", String,
           "Specifies the environment to run this server under (test/development/production).",
           "Default: development") { |v| OPTIONS[:environment] = v }
@@ -46,6 +48,8 @@ else
   ENV["RAILS_ENV"] = OPTIONS[:environment]
   RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
 
+  start_debugger if OPTIONS[:debugger]
+
   require 'initializer'
   Rails::Initializer.run(:initialize_logger)
 

data/lib/commands/servers/webrick.rb

@@ -1,14 +1,17 @@
 require 'webrick'
 require 'optparse'
+require 'commands/servers/base'
 
 OPTIONS = {
-  :port            => 3000,
-  :ip              => "0.0.0.0",
-  :environment     => (ENV['RAILS_ENV'] || "development").dup,
-  :server_root     => File.expand_path(RAILS_ROOT + "/public/"),
-  :server_type     => WEBrick::SimpleServer,
-  :charset         => "UTF-8",
-  :mime_types      => WEBrick::HTTPUtils::DefaultMimeTypes
+  :port         => 3000,
+  :ip           => "0.0.0.0",
+  :environment  => (ENV['RAILS_ENV'] || "development").dup,
+  :server_root  => File.expand_path(RAILS_ROOT + "/public/"),
+  :server_type  => WEBrick::SimpleServer,
+  :charset      => "UTF-8",
+  :mime_types   => WEBrick::HTTPUtils::DefaultMimeTypes,
+  :debugger     => false
+  
 }
 
 ARGV.options do |opts|
@@ -34,6 +37,8 @@ ARGV.options do |opts|
           "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
           ) { OPTIONS[:server_type] = WEBrick::Daemon }
 
+  opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { OPTIONS[:debugger] = true }
+
   opts.on("-c", "--charset=charset", String,
           "Set default charset for output.",
           "Default: UTF-8") { |v| OPTIONS[:charset] = v }
@@ -46,6 +51,8 @@ ARGV.options do |opts|
   opts.parse!
 end
 
+start_debugger if OPTIONS[:debugger]
+
 ENV["RAILS_ENV"] = OPTIONS[:environment]
 RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
 

data/lib/console_app.rb

@@ -1,7 +1,7 @@
 require 'action_controller/integration'
 
 # work around the at_exit hook in test/unit, which kills IRB
-Test::Unit.run = true
+Test::Unit.run = true if Test::Unit.respond_to?(:run=)
 
 # reference the global "app" instance, created on demand. To recreate the
 # instance, pass a non-false value as the parameter.
@@ -23,5 +23,8 @@ end
 #reloads the environment
 def reload!
   puts "Reloading..."
-  Dispatcher.reset_application!
+  dispatcher = ActionController::Dispatcher.new($stdout)
+  dispatcher.cleanup_application(true)
+  dispatcher.prepare_application(true)
+  true
 end

data/lib/console_with_helpers.rb

@@ -10,8 +10,10 @@ class Module
   end
 end
 
-def helper
-  @helper_proxy ||= Object.new 
+def helper(*helper_names)
+  returning @helper_proxy ||= Object.new do |helper|
+    helper_names.each { |h| helper.extend "#{h}_helper".classify.constantize }
+  end
 end
 
 require 'application'
@@ -21,3 +23,4 @@ class << helper
 end
 
 @controller = ApplicationController.new
+helper :application rescue nil

data/lib/dispatcher.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2006 David Heinemeier Hansson
+# Copyright (c) 2004-2007 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -20,153 +20,5 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
-
-# This class provides an interface for dispatching a CGI (or CGI-like) request
-# to the appropriate controller and action. It also takes care of resetting
-# the environment (when Dependencies.load? is true) after each request.
-class Dispatcher
-  
-  class << self
-
-    # Dispatch the given CGI request, using the given session options, and
-    # emitting the output via the given output.  If you dispatch with your
-    # own CGI object be sure to handle the exceptions it raises on multipart
-    # requests (EOFError and ArgumentError).
-    def dispatch(cgi = nil, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
-      controller = nil
-      if cgi ||= new_cgi(output)
-        request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
-        prepare_application
-        controller = ActionController::Routing::Routes.recognize(request)
-        controller.process(request, response).out(output)
-      end
-    rescue Exception => exception  # errors from CGI dispatch
-      failsafe_response(output, '500 Internal Server Error', exception) do
-        controller ||= (ApplicationController rescue ActionController::Base)
-        controller.process_with_exception(request, response, exception).out(output)
-      end
-    ensure
-      # Do not give a failsafe response here.
-      reset_after_dispatch
-    end
-
-    # Reset the application by clearing out loaded controllers, views, actions,
-    # mailers, and so forth. This allows them to be loaded again without having
-    # to restart the server (WEBrick, FastCGI, etc.).
-    def reset_application!
-      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-
-      Dependencies.clear
-      ActiveSupport::Deprecation.silence do # TODO: Remove after 1.2
-        Class.remove_class(*Reloadable.reloadable_classes)
-      end
-        
-      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-    end
-    
-    # Add a preparation callback. Preparation callbacks are run before every
-    # request in development mode, and before the first request in production
-    # mode.
-    # 
-    # An optional identifier may be supplied for the callback. If provided,
-    # to_prepare may be called again with the same identifier to replace the
-    # existing callback. Passing an identifier is a suggested practice if the
-    # code adding a preparation block may be reloaded.
-    def to_prepare(identifier = nil, &block)
-      unless identifier.nil?
-        callback = preparation_callbacks.detect { |ident, _| ident == identifier }
-
-        if callback # Already registered: update the existing callback
-          callback[-1] = block
-          return
-        end
-      end
-
-      preparation_callbacks << [identifier, block]
-
-      return
-    end
-
-    private
-
-      attr_accessor :preparation_callbacks, :preparation_callbacks_run
-      alias_method :preparation_callbacks_run?, :preparation_callbacks_run
-      
-      # CGI.new plus exception handling.  CGI#read_multipart raises EOFError
-      # if body.empty? or body.size != Content-Length and raises ArgumentError
-      # if Content-Length is non-integer.
-      def new_cgi(output)
-        failsafe_response(output, '400 Bad Request') { CGI.new }
-      end
-
-      def prepare_application
-        if Dependencies.load?
-          ActionController::Routing::Routes.reload
-          self.preparation_callbacks_run = false
-        end
-
-        prepare_breakpoint
-        require_dependency 'application' unless Object.const_defined?(:ApplicationController)
-        ActiveRecord::Base.verify_active_connections! if defined?(ActiveRecord)
-        run_preparation_callbacks
-      end
-
-      def reset_after_dispatch
-        reset_application! if Dependencies.load?
-        Breakpoint.deactivate_drb if defined?(BREAKPOINT_SERVER_PORT)
-      end
-
-      def prepare_breakpoint
-        return unless defined?(BREAKPOINT_SERVER_PORT)
-        require 'breakpoint'
-        Breakpoint.activate_drb("druby://localhost:#{BREAKPOINT_SERVER_PORT}", nil, !defined?(FastCGI))
-        true
-      rescue
-        nil
-      end
-
-      def run_preparation_callbacks
-        return if preparation_callbacks_run?
-        preparation_callbacks.each { |_, callback| callback.call }
-        self.preparation_callbacks_run = true
-      end
-
-      # If the block raises, send status code as a last-ditch response.
-      def failsafe_response(output, status, exception = nil)
-        yield
-      rescue Exception  # errors from executed block
-        begin
-          output.write "Status: #{status}\r\n"
-          
-          if exception
-            message    = exception.to_s + "\r\n" + exception.backtrace.join("\r\n")
-            error_path = File.join(RAILS_ROOT, 'public', '500.html')
-
-            if defined?(RAILS_DEFAULT_LOGGER) && !RAILS_DEFAULT_LOGGER.nil?
-              RAILS_DEFAULT_LOGGER.fatal(message)
-
-              output.write "Content-Type: text/html\r\n\r\n"
-
-              if File.exists?(error_path)
-                output.write(IO.read(error_path))
-              else
-                output.write("<html><body><h1>Application error (Rails)</h1></body></html>")
-              end
-            else
-              output.write "Content-Type: text/plain\r\n\r\n"
-              output.write(message)
-            end
-          end
-        rescue Exception  # Logger or IO errors
-        end
-      end
-  end
-  
-  self.preparation_callbacks = []
-  self.preparation_callbacks_run = false
-  
-end
-
-Dispatcher.to_prepare :activerecord_instantiate_observers do
-  ActiveRecord::Base.instantiate_observers
-end if defined?(ActiveRecord)
+require 'action_controller/dispatcher'
+Dispatcher = ActionController::Dispatcher