rails 0.14.2 → 0.14.3

data/lib/commands/process/reaper.rb

@@ -32,7 +32,7 @@ class ProgramProcess
     #   ProgramProcess.find_by_keyword("basecamp")
     def find_by_keyword(keyword)
       process_lines_with_keyword(keyword).split("\n").collect { |line|
-        next if line.include?("inq") || line.include?("ps -ax") || line.include?("grep")
+        next if line =~ /inq|ps axww|grep|spawn-fcgi|spawner|reaper/
         pid, *command = line.split
         new(pid, command.join(" "))
       }.compact
@@ -40,7 +40,7 @@ class ProgramProcess
 
     private
       def process_lines_with_keyword(keyword)
-        `ps -ax -o 'pid command' | grep #{keyword}`
+        `ps axww -o 'pid command' | grep #{keyword}`
       end
   end
 
@@ -127,4 +127,4 @@ ARGV.options do |opts|
   opts.parse!
 end
 
-ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])
+ProgramProcess.process_keywords(OPTIONS[:action], OPTIONS[:dispatcher])

data/lib/commands/server.rb

@@ -1,59 +1,28 @@
-require 'webrick'
-require 'optparse'
+require 'active_support'
 
-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
-}
-
-ARGV.options do |opts|
-  script_name = File.basename($0)
-  opts.banner = "Usage: ruby #{script_name} [options]"
-
-  opts.separator ""
-
-  opts.on("-p", "--port=port", Integer,
-          "Runs Rails on the specified port.",
-          "Default: 3000") { |OPTIONS[:port]| }
-  opts.on("-b", "--binding=ip", String,
-          "Binds Rails to the specified ip.",
-          "Default: 0.0.0.0") { |OPTIONS[:ip]| }
-  opts.on("-e", "--environment=name", String,
-          "Specifies the environment to run this server under (test/development/production).",
-          "Default: development") { |OPTIONS[:environment]| }
-  opts.on("-m", "--mime-types=filename", String,
-                  "Specifies an Apache style mime.types configuration file to be used for mime types",
-                  "Default: none") { |mime_types_file| OPTIONS[:mime_types] = WEBrick::HTTPUtils::load_mime_types(mime_types_file) }
-
-  opts.on("-d", "--daemon",
-          "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
-          ) { OPTIONS[:server_type] = WEBrick::Daemon }
-
-  opts.on("-c", "--charset=charset", String,
-          "Set default charset for output.",
-          "Default: UTF-8") { |OPTIONS[:charset]| }
-
-  opts.separator ""
-
-  opts.on("-h", "--help",
-          "Show this help message.") { puts opts; exit }
-
-  opts.parse!
+begin
+  require_library_or_gem 'fcgi'
+rescue Exception
+  # FCGI not available
 end
 
-ENV["RAILS_ENV"] = OPTIONS[:environment]
-RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
-
-require RAILS_ROOT + "/config/environment"
-require 'webrick_server'
+server = case ARGV.first
+  when "lighttpd"
+    ARGV.shift
+  when "webrick"
+    ARGV.shift
+  else
+    if RUBY_PLATFORM !~ /mswin/ && !silence_stderr { `lighttpd -version` }.blank? && defined?(FCGI)
+      "lighttpd"
+    else
+      "webrick"
+    end
+end
 
-OPTIONS['working_directory'] = File.expand_path(RAILS_ROOT)
+if server == "webrick"
+  puts "=> Booting WEBrick..."
+else
+  puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
+end
 
-puts "=> Rails application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
-puts "=> Ctrl-C to shutdown server; call with --help for options" if OPTIONS[:server_type] == WEBrick::SimpleServer
-DispatchServlet.dispatch(OPTIONS)
+require "commands/servers/#{server}"

data/lib/commands/servers/lighttpd.rb

@@ -0,0 +1,56 @@
+unless RUBY_PLATFORM !~ /mswin/ && !silence_stderr { `lighttpd -version` }.blank?
+  puts "PROBLEM: Lighttpd is not available on your system (or not in your path)"
+  exit 1
+end
+
+unless defined?(FCGI)
+  puts "PROBLEM: Lighttpd requires that the FCGI Ruby bindings are installed on the system"
+  exit 1
+end
+
+def tail_f(input)
+  loop do
+    line = input.gets
+    yield line if line
+    if input.eof?
+      sleep 1
+      input.seek(input.tell)
+    end
+  end
+end
+
+config_file = "#{RAILS_ROOT}/config/lighttpd.conf"
+
+unless File.exist?(config_file)
+  require 'fileutils'
+  source = File.expand_path(File.join(File.dirname(__FILE__),
+     "..", "..", "..", "configs", "lighttpd.conf"))
+  puts "=> #{config_file} not found, copying from #{source}"
+  FileUtils.cp source, config_file
+end
+
+port = IO.read(config_file).scan(/^server.port\s*=\s*(\d+)/).first rescue 3000
+puts "=> Rails application started on http://0.0.0.0:#{port}"
+
+if ARGV.first == "-d"
+  puts "=> Configure in config/lighttpd.conf"
+  detach = true
+else
+  puts "=> Call with -d to detach (requires absolute paths in config/lighttpd.conf)"
+  puts "=> Ctrl-C to shutdown server (see config/lighttpd.conf for options)"
+  detach = false
+
+  Process.detach(fork do
+    begin
+      File.open("#{RAILS_ROOT}/log/#{RAILS_ENV}.log", 'r') do |log|
+        log.seek(0, IO::SEEK_END)
+        tail_f(log) {|line| puts line}
+      end
+    rescue Exception
+    end
+    exit
+  end)
+end
+
+trap(:INT) {exit}
+`lighttpd #{!detach ? "-D " : ""}-f #{config_file}`

data/lib/commands/servers/webrick.rb

@@ -0,0 +1,59 @@
+require 'webrick'
+require 'optparse'
+
+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
+}
+
+ARGV.options do |opts|
+  script_name = File.basename($0)
+  opts.banner = "Usage: ruby #{script_name} [options]"
+
+  opts.separator ""
+
+  opts.on("-p", "--port=port", Integer,
+          "Runs Rails on the specified port.",
+          "Default: 3000") { |OPTIONS[:port]| }
+  opts.on("-b", "--binding=ip", String,
+          "Binds Rails to the specified ip.",
+          "Default: 0.0.0.0") { |OPTIONS[:ip]| }
+  opts.on("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |OPTIONS[:environment]| }
+  opts.on("-m", "--mime-types=filename", String,
+                  "Specifies an Apache style mime.types configuration file to be used for mime types",
+                  "Default: none") { |mime_types_file| OPTIONS[:mime_types] = WEBrick::HTTPUtils::load_mime_types(mime_types_file) }
+
+  opts.on("-d", "--daemon",
+          "Make Rails run as a Daemon (only works if fork is available -- meaning on *nix)."
+          ) { OPTIONS[:server_type] = WEBrick::Daemon }
+
+  opts.on("-c", "--charset=charset", String,
+          "Set default charset for output.",
+          "Default: UTF-8") { |OPTIONS[:charset]| }
+
+  opts.separator ""
+
+  opts.on("-h", "--help",
+          "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+ENV["RAILS_ENV"] = OPTIONS[:environment]
+RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
+
+require RAILS_ROOT + "/config/environment"
+require 'webrick_server'
+
+OPTIONS['working_directory'] = File.expand_path(RAILS_ROOT)
+
+puts "=> Rails application started on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+puts "=> Ctrl-C to shutdown server; call with --help for options" if OPTIONS[:server_type] == WEBrick::SimpleServer
+DispatchServlet.dispatch(OPTIONS)

data/lib/dispatcher.rb

@@ -26,19 +26,24 @@
 # 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.
-    def dispatch(cgi = CGI.new, session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, output = $stdout)
-      begin
+    # 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)
+      if cgi ||= new_cgi(output)
         request, response = ActionController::CgiRequest.new(cgi, session_options), ActionController::CgiResponse.new(cgi)
         prepare_application
         ActionController::Routing::Routes.recognize!(request).process(request, response).out(output)
-      rescue Object => exception
+      end
+    rescue Object => exception
+      failsafe_response(output, '500 Internal Server Error') do
         ActionController::Base.process_with_exception(request, response, exception).out(output)
-      ensure
-        reset_after_dispatch
       end
+    ensure
+      # Do not give a failsafe response here.
+      reset_after_dispatch
     end
 
     # Reset the application by clearing out loaded controllers, views, actions,
@@ -51,8 +56,15 @@ class Dispatcher
       Dependencies.remove_subclasses_for(ActiveRecord::Base, ActiveRecord::Observer, ActionController::Base)
       Dependencies.remove_subclasses_for(ActionMailer::Base) if defined?(ActionMailer::Base)
     end
-    
+
     private
+      # 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
         ActionController::Routing::Routes.reload if Dependencies.load?
         prepare_breakpoint
@@ -72,5 +84,15 @@ class Dispatcher
       rescue
         nil
       end
+
+      # If the block raises, send status code as a last-ditch response.
+      def failsafe_response(output, status)
+        yield
+      rescue Object
+        begin
+          output.write "Status: #{status}\r\n"
+        rescue Object
+        end
+      end
   end
 end

data/lib/fcgi_handler.rb

@@ -6,7 +6,7 @@ require 'rbconfig'
 class RailsFCGIHandler
   SIGNALS = {
     'HUP'  => :reload,
-    'TERM' => :exit,
+    'TERM' => :exit_now,
     'USR1' => :exit,
     'USR2' => :restart
   }
@@ -117,6 +117,11 @@ class RailsFCGIHandler
       dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
     end
 
+    def exit_now_handler(signal)
+      dispatcher_log :info, "asked to terminate immediately"
+      exit
+    end
+
     def exit_handler(signal)
       dispatcher_log :info, "asked to terminate ASAP"
       @when_ready = :exit

data/lib/initializer.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'set'
 
 RAILS_ENV = (ENV['RAILS_ENV'] || 'development').dup unless defined?(RAILS_ENV)
 
@@ -22,7 +23,10 @@ module Rails
   class Initializer
     # The Configuration instance used by this Initializer instance.
     attr_reader :configuration
-    
+
+    # The set of loaded plugins.
+    attr_reader :loaded_plugins
+
     # Runs the initializer. By default, this will invoke the #process method,
     # which simply executes all of the initialization routines. Alternately,
     # you can specify explicitly which initialization routine you want:
@@ -40,8 +44,9 @@ module Rails
     # instance.
     def initialize(configuration)
       @configuration = configuration
+      @loaded_plugins = Set.new
     end
-    
+
     # Sequentially step through all of the available initialization routines,
     # in order:
     #
@@ -87,6 +92,8 @@ module Rails
       # could overwrite anything set from the defaults/global through
       # the individual base class configurations.
       load_environment
+      
+      load_framework_info
 
       load_plugins
     end
@@ -113,31 +120,24 @@ module Rails
       configuration.frameworks.each { |framework| require(framework.to_s) }
     end
     
-    # Loads all plugins in the <tt>vendor/plugins</tt> directory. Each
-    # subdirectory of <tt>vendor/plugins</tt> is inspected as follows:
+    # Loads Rails::Version and Rails::Info.
+    # TODO: Make this work via dependencies.rb/const_missing instead.
+    def load_framework_info
+      require 'rails_info'
+    end
+
+    # Loads all plugins in <tt>config.plugin_paths</tt>.  <tt>plugin_paths</tt>
+    # defaults to <tt>vendor/plugins</tt> but may also be set to a list of
+    # paths, such as
+    #   config.plugin_paths = ['lib/plugins', 'vendor/plugins']
     #
-    # * if the directory has a +lib+ subdirectory, add it to the load path
-    # * if the directory contains an <tt>init.rb</tt> file, read it in and
-    #   eval it.
+    # Each plugin discovered in <tt>plugin_paths</tt> is initialized:
+    # * add its +lib+ directory, if present, to the beginning of the load path
+    # * evaluate <tt>init.rb</tt> if present
     #
     # After all plugins are loaded, duplicates are removed from the load path.
     def load_plugins
-      config = configuration
-
-      Dir.glob("#{configuration.plugins_path}/*") do |directory|
-        next if File.basename(directory)[0] == ?. || !File.directory?(directory)
-
-        if File.directory?("#{directory}/lib")
-          $LOAD_PATH.unshift "#{directory}/lib"
-        end
-
-        if File.exist?("#{directory}/init.rb")
-          silence_warnings do
-            eval(IO.read("#{directory}/init.rb"), binding)
-          end
-        end
-      end
-
+      find_plugins(configuration.plugin_paths).each { |path| load_plugin path }
       $LOAD_PATH.uniq!
     end
 
@@ -252,8 +252,65 @@ module Rails
         end
       end
     end
+
+    protected
+      # Return a list of plugin paths within base_path.  A plugin path is
+      # a directory that contains either a lib directory or an init.rb file.
+      # This recurses into directories which are not plugin paths, so you
+      # may organize your plugins which the plugin path.
+      def find_plugins(*base_paths)
+        base_paths.flatten.inject([]) do |plugins, base_path|
+          Dir.glob(File.join(base_path, '*')).each do |path|
+            if plugin_path?(path)
+              plugins << path
+            elsif File.directory?(path)
+              plugins += find_plugins(path)
+            end
+          end
+          plugins
+        end
+      end
+
+      def plugin_path?(path)
+        File.directory?(path) and (File.directory?(File.join(path, 'lib')) or File.file?(File.join(path, 'init.rb')))
+      end
+
+      # Load the plugin at <tt>path</tt> unless already loaded.
+      #
+      # Each plugin is initialized:
+      # * add its +lib+ directory, if present, to the beginning of the load path
+      # * evaluate <tt>init.rb</tt> if present
+      #
+      # Returns <tt>true</tt> if the plugin is successfully loaded or
+      # <tt>false</tt> if it is already loaded (similar to Kernel#require).
+      # Raises <tt>LoadError</tt> if the plugin is not found.
+      def load_plugin(directory)
+        name = File.basename(directory)
+        return false if loaded_plugins.include?(name)
+
+        # Catch nonexistent and empty plugins.
+        raise LoadError, "No such plugin: #{directory}" unless plugin_path?(directory)
+
+        lib_path  = File.join(directory, 'lib')
+        init_path = File.join(directory, 'init.rb')
+        has_lib   = File.directory?(lib_path)
+        has_init  = File.file?(init_path)
+
+        # Add lib to load path.
+        $LOAD_PATH.unshift(lib_path) if has_lib
+        
+        # Allow plugins to reference the current configuration object
+        config = configuration 
+
+        # Evaluate init.rb.
+        silence_warnings { eval(IO.read(init_path), binding) } if has_init
+
+        # Add to set of loaded plugins.
+        loaded_plugins << name
+        true
+      end
   end
-  
+
   # The Configuration class holds all the parameters for the Initializer and
   # ships with defaults that suites most Rails applications. But it's possible
   # to overwrite everything. Usually, you'll create an Configuration file
@@ -331,6 +388,10 @@ module Rails
     # any method of +nil+. Set to +false+ for the standard Ruby behavior.
     attr_accessor :whiny_nils
     
+    # The path to the root of the plugins directory. By default, it is in
+    # <tt>vendor/plugins</tt>.
+    attr_accessor :plugin_paths
+
     # Create a new Configuration instance, initialized with the default
     # values.
     def initialize
@@ -343,8 +404,9 @@ module Rails
       self.cache_classes                = default_cache_classes
       self.breakpoint_server            = default_breakpoint_server
       self.whiny_nils                   = default_whiny_nils
+      self.plugin_paths                 = default_plugin_paths
       self.database_configuration_file  = default_database_configuration_file
-      
+
       for framework in default_frameworks
         self.send("#{framework}=", OrderedOptions.new)
       end
@@ -360,15 +422,9 @@ module Rails
     # The path to the current environment's file (development.rb, etc.). By
     # default the file is at <tt>config/environments/#{environment}.rb</tt>.
     def environment_path
-      "#{RAILS_ROOT}/config/environments/#{environment}.rb"
+      "#{root_path}/config/environments/#{environment}.rb"
     end
 
-    # The path to the root of the plugins directory. By default, it is in
-    # <tt>vendor/plugins</tt>.
-    def plugins_path
-      "#{RAILS_ROOT}/vendor/plugins"
-    end
-    
     # Return the currently selected environment. By default, it returns the
     # value of the +RAILS_ENV+ constant.
     def environment
@@ -376,25 +432,30 @@ module Rails
     end
 
     private
+      def root_path
+        ::RAILS_ROOT
+      end
+
       def default_frameworks
         [ :active_record, :action_controller, :action_view, :action_mailer, :action_web_service ]
       end
     
       def default_load_paths
-        paths = ["#{RAILS_ROOT}/test/mocks/#{environment}"]
+        paths = ["#{root_path}/test/mocks/#{environment}"]
 
         # Then model subdirectories.
         # TODO: Don't include .rb models as load paths
-        paths.concat(Dir["#{RAILS_ROOT}/app/models/[_a-z]*"])
-        paths.concat(Dir["#{RAILS_ROOT}/components/[_a-z]*"])
+        paths.concat(Dir["#{root_path}/app/models/[_a-z]*"])
+        paths.concat(Dir["#{root_path}/components/[_a-z]*"])
 
         # Followed by the standard includes.
         # TODO: Don't include dirs for frameworks that are not used
         paths.concat %w(
           app 
           app/models 
-          app/controllers 
-          app/helpers 
+          app/controllers
+          app/helpers
+          app/services
           app/apis 
           components 
           config 
@@ -407,11 +468,11 @@ module Rails
           vendor/rails/activerecord/lib
           vendor/rails/actionmailer/lib
           vendor/rails/actionwebservice/lib
-        ).map { |dir| "#{RAILS_ROOT}/#{dir}" }.select { |dir| File.directory?(dir) }
+        ).map { |dir| "#{root_path}/#{dir}" }.select { |dir| File.directory?(dir) }
       end
 
       def default_log_path
-        File.join(RAILS_ROOT, 'log', "#{environment}.log")
+        File.join(root_path, 'log', "#{environment}.log")
       end
       
       def default_log_level
@@ -419,15 +480,15 @@ module Rails
       end
       
       def default_database_configuration_file
-        File.join(RAILS_ROOT, 'config', 'database.yml')
+        File.join(root_path, 'config', 'database.yml')
       end
       
       def default_view_path
-        File.join(RAILS_ROOT, 'app', 'views')
+        File.join(root_path, 'app', 'views')
       end
       
       def default_controller_paths
-        [ File.join(RAILS_ROOT, 'app', 'controllers'), File.join(RAILS_ROOT, 'components') ]
+        [ File.join(root_path, 'app', 'controllers'), File.join(root_path, 'components') ]
       end
       
       def default_dependency_mechanism
@@ -445,6 +506,10 @@ module Rails
       def default_whiny_nils
         false
       end
+
+      def default_plugin_paths
+        ["#{root_path}/vendor/plugins"]
+      end
   end
 end