rails 2.3.18 → 3.0.0

data/lib/commands/runner.rb

@@ -1,54 +0,0 @@
-require 'optparse'
-
-options = { :environment => (ENV['RAILS_ENV'] || "development").dup }
-code_or_file = nil
-
-ARGV.clone.options do |opts|
-  script_name = File.basename($0)
-  opts.banner = "Usage: #{$0} [options] ('Some.ruby(code)' or a filename)"
-
-  opts.separator ""
-
-  opts.on("-e", "--environment=name", String,
-          "Specifies the environment for the runner to operate under (test/development/production).",
-          "Default: development") { |v| options[:environment] = v }
-
-  opts.separator ""
-
-  opts.on("-h", "--help",
-          "Show this help message.") { $stderr.puts opts; exit }
-
-  if RUBY_PLATFORM !~ /(:?mswin|mingw)/
-    opts.separator ""
-    opts.separator "You can also use runner as a shebang line for your scripts like this:"
-    opts.separator "-------------------------------------------------------------"
-    opts.separator "#!/usr/bin/env #{File.expand_path($0)}"
-    opts.separator ""
-    opts.separator "Product.find(:all).each { |p| p.price *= 2 ; p.save! }"
-    opts.separator "-------------------------------------------------------------"
-  end
-
-  opts.order! { |o| code_or_file ||= o } rescue retry
-end
-
-ARGV.delete(code_or_file)
-
-ENV["RAILS_ENV"] = options[:environment]
-RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
-
-require RAILS_ROOT + '/config/environment'
-
-begin
-  if code_or_file.nil?
-    $stderr.puts "Run '#{$0} -h' for help."
-    exit 1
-  elsif File.exist?(code_or_file)
-    eval(File.read(code_or_file), nil, code_or_file)
-  else
-    eval(code_or_file)
-  end
-ensure
-  if defined? Rails
-    Rails.logger.flush if Rails.logger.respond_to?(:flush)
-  end
-end

data/lib/commands/server.rb

@@ -1,114 +0,0 @@
-require 'active_support'
-require 'action_controller'
-
-require 'fileutils'
-require 'optparse'
-
-# TODO: Push Thin adapter upstream so we don't need worry about requiring it
-begin
-  require_library_or_gem 'thin'
-rescue Exception
-  # Thin not available
-end
-
-options = {
-  :Port        => 3000,
-  :Host        => "0.0.0.0",
-  :environment => (ENV['RAILS_ENV'] || "development").dup,
-  :config      => RAILS_ROOT + "/config.ru",
-  :detach      => false,
-  :debugger    => false,
-  :path        => nil
-}
-
-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[:Host] = v }
-  opts.on("-c", "--config=file", String,
-          "Use custom rackup configuration file") { |v| options[:config] = 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 }
-  opts.on("-P", "--path=/path", String, "Runs Rails app mounted at a specific path.", "Default: /") { |v| options[:path] = v }
-
-  opts.separator ""
-
-  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
-
-  opts.parse!
-end
-
-server = Rack::Handler.get(ARGV.first) rescue nil
-unless server
-  begin
-    server = Rack::Handler::Mongrel
-  rescue LoadError => e
-    server = Rack::Handler::WEBrick
-  end
-end
-
-puts "=> Booting #{ActiveSupport::Inflector.demodulize(server)}"
-puts "=> Rails #{Rails.version} application starting on http://#{options[:Host]}:#{options[:Port]}#{options[:path]}"
-
-%w(cache pids sessions sockets).each do |dir_to_make|
-  FileUtils.mkdir_p(File.join(RAILS_ROOT, 'tmp', dir_to_make))
-end
-
-if options[:detach]
-  Process.daemon
-  pid = "#{RAILS_ROOT}/tmp/pids/server.pid"
-  File.open(pid, 'w'){ |f| f.write(Process.pid) }
-  at_exit { File.delete(pid) if File.exist?(pid) }
-end
-
-ENV["RAILS_ENV"] = options[:environment]
-RAILS_ENV.replace(options[:environment]) if defined?(RAILS_ENV)
-
-if File.exist?(options[:config])
-  config = options[:config]
-  if config =~ /\.ru$/
-    cfgfile = File.read(config)
-    if cfgfile[/^#\\(.*)/]
-      opts.parse!($1.split(/\s+/))
-    end
-    inner_app = eval("Rack::Builder.new {( " + cfgfile + "\n )}.to_app", nil, config)
-  else
-    require config
-    inner_app = Object.const_get(File.basename(config, '.rb').capitalize)
-  end
-else
-  require RAILS_ROOT + "/config/environment"
-  inner_app = ActionController::Dispatcher.new
-end
-
-if options[:path].nil?
-  map_path = "/"
-else
-  ActionController::Base.relative_url_root = options[:path]
-  map_path = options[:path]
-end
-
-app = Rack::Builder.new {
-  use Rails::Rack::LogTailer unless options[:detach]
-  use Rails::Rack::Debugger if options[:debugger]
-  map map_path do
-    use Rails::Rack::Static 
-    run inner_app
-  end
-}.to_app
-
-puts "=> Call with -d to detach"
-
-trap(:INT) { exit }
-
-puts "=> Ctrl-C to shutdown server"
-
-begin
-  server.run(app, options.merge(:AccessLog => []))
-ensure
-  puts 'Exiting'
-end

data/lib/commands/update.rb

@@ -1,4 +0,0 @@
-require "#{RAILS_ROOT}/config/environment"
-require 'rails_generator'
-require 'rails_generator/scripts/update'
-Rails::Generator::Scripts::Update.new.run(ARGV)

data/lib/console_app.rb

@@ -1,30 +0,0 @@
-require 'active_support/test_case'
-require 'action_controller'
-
-# work around the at_exit hook in test/unit, which kills IRB
-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.
-def app(create=false)
-  @app_integration_instance = nil if create
-  @app_integration_instance ||= new_session do |sess|
-    sess.host! "www.example.com"
-  end
-end
-
-# create a new session. If a block is given, the new session will be yielded
-# to the block before being returned.
-def new_session
-  session = ActionController::Integration::Session.new
-  yield session if block_given?
-  session
-end
-
-#reloads the environment
-def reload!
-  puts "Reloading..."
-  Dispatcher.cleanup_application
-  Dispatcher.reload_application
-  true
-end

data/lib/console_sandbox.rb

@@ -1,6 +0,0 @@
-ActiveRecord::Base.connection.increment_open_transactions
-ActiveRecord::Base.connection.begin_db_transaction
-at_exit do
-  ActiveRecord::Base.connection.rollback_db_transaction
-  ActiveRecord::Base.connection.decrement_open_transactions
-end

data/lib/console_with_helpers.rb

@@ -1,5 +0,0 @@
-def helper
-  @helper ||= ApplicationController.helpers
-end
-
-@controller = ApplicationController.new

data/lib/dispatcher.rb

@@ -1,24 +0,0 @@
-#--
-# Copyright (c) 2004-2010 David Heinemeier Hansson
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-require 'action_controller/dispatcher'
-Dispatcher = ActionController::Dispatcher

data/lib/fcgi_handler.rb

@@ -1,239 +0,0 @@
-require 'fcgi'
-require 'logger'
-require 'dispatcher'
-require 'rbconfig'
-
-class RailsFCGIHandler
-  SIGNALS = {
-    'HUP'     => :reload,
-    'INT'     => :exit_now,
-    'TERM'    => :exit_now,
-    'USR1'    => :exit,
-    'USR2'    => :restart
-  }
-  GLOBAL_SIGNALS = SIGNALS.keys - %w(USR1)
-
-  attr_reader :when_ready
-
-  attr_accessor :log_file_path
-  attr_accessor :gc_request_period
-
-  # Initialize and run the FastCGI instance, passing arguments through to new.
-  def self.process!(*args, &block)
-    new(*args, &block).process!
-  end
-
-  # Initialize the FastCGI instance with the path to a crash log
-  # detailing unhandled exceptions (default RAILS_ROOT/log/fastcgi.crash.log)
-  # and the number of requests to process between garbage collection runs
-  # (default nil for normal GC behavior.)  Optionally, pass a block which
-  # takes this instance as an argument for further configuration.
-  def initialize(log_file_path = nil, gc_request_period = nil)
-    self.log_file_path = log_file_path || "#{RAILS_ROOT}/log/fastcgi.crash.log"
-    self.gc_request_period = gc_request_period
-
-    # Yield for additional configuration.
-    yield self if block_given?
-
-    # Safely install signal handlers.
-    install_signal_handlers
-
-    @app = Dispatcher.new
-
-    # Start error timestamp at 11 seconds ago.
-    @last_error_on = Time.now - 11
-  end
-
-  def process!(provider = FCGI)
-    mark_features!
-
-    dispatcher_log :info, 'starting'
-    process_each_request provider
-    dispatcher_log :info, 'stopping gracefully'
-
-  rescue Exception => error
-    case error
-    when SystemExit
-      dispatcher_log :info, 'stopping after explicit exit'
-    when SignalException
-      dispatcher_error error, 'stopping after unhandled signal'
-    else
-      # Retry if exceptions occur more than 10 seconds apart.
-      if Time.now - @last_error_on > 10
-        @last_error_on = Time.now
-        dispatcher_error error, 'retrying after unhandled exception'
-        retry
-      else
-        dispatcher_error error, 'stopping after unhandled exception within 10 seconds of the last'
-      end
-    end
-  end
-
-  protected
-    def process_each_request(provider)
-      request = nil
-
-      catch :exit do
-        provider.each do |request|
-          process_request(request)
-
-          case when_ready
-            when :reload
-              reload!
-            when :restart
-              close_connection(request)
-              restart!
-            when :exit
-              close_connection(request)
-              throw :exit
-          end
-        end
-      end
-    rescue SignalException => signal
-      raise unless signal.message == 'SIGUSR1'
-      close_connection(request)
-    end
-
-    def process_request(request)
-      @processing, @when_ready = true, nil
-      gc_countdown
-
-      with_signal_handler 'USR1' do
-        begin
-          ::Rack::Handler::FastCGI.serve(request, @app)
-        rescue SignalException, SystemExit
-          raise
-        rescue Exception => error
-          dispatcher_error error, 'unhandled dispatch error'
-        end
-      end
-    ensure
-      @processing = false
-    end
-
-    def logger
-      @logger ||= Logger.new(@log_file_path)
-    end
-
-    def dispatcher_log(level, msg)
-      time_str = Time.now.strftime("%d/%b/%Y:%H:%M:%S")
-      logger.send(level, "[#{time_str} :: #{$$}] #{msg}")
-    rescue Exception => log_error  # Logger errors
-      STDERR << "Couldn't write to #{@log_file_path.inspect}: #{msg}\n"
-      STDERR << "  #{log_error.class}: #{log_error.message}\n"
-    end
-
-    def dispatcher_error(e, msg = "")
-      error_message =
-        "Dispatcher failed to catch: #{e} (#{e.class})\n" +
-        "  #{e.backtrace.join("\n  ")}\n#{msg}"
-      dispatcher_log(:error, error_message)
-    end
-
-    def install_signal_handlers
-      GLOBAL_SIGNALS.each { |signal| install_signal_handler(signal) }
-    end
-
-    def install_signal_handler(signal, handler = nil)
-      if SIGNALS.include?(signal) && self.class.method_defined?(name = "#{SIGNALS[signal]}_handler")
-        handler ||= method(name).to_proc
-
-        begin
-          trap(signal, handler)
-        rescue ArgumentError
-          dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
-        end
-      else
-        dispatcher_log :warn, "Ignoring unsupported signal #{signal}."
-      end
-    end
-
-    def with_signal_handler(signal)
-      install_signal_handler(signal)
-      yield
-    ensure
-      install_signal_handler(signal, 'DEFAULT')
-    end
-
-    def exit_now_handler(signal)
-      dispatcher_log :info, "asked to stop immediately"
-      exit
-    end
-
-    def exit_handler(signal)
-      dispatcher_log :info, "asked to stop ASAP"
-      if @processing
-        @when_ready = :exit
-      else
-        throw :exit
-      end
-    end
-
-    def reload_handler(signal)
-      dispatcher_log :info, "asked to reload ASAP"
-      if @processing
-        @when_ready = :reload
-      else
-        reload!
-      end
-    end
-
-    def restart_handler(signal)
-      dispatcher_log :info, "asked to restart ASAP"
-      if @processing
-        @when_ready = :restart
-      else
-        restart!
-      end
-    end
-
-    def restart!
-      config       = ::Config::CONFIG
-      ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
-      command_line = [ruby, $0, ARGV].flatten.join(' ')
-
-      dispatcher_log :info, "restarted"
-
-      # close resources as they won't be closed by
-      # the OS when using exec
-      logger.close rescue nil
-      Rails.logger.close rescue nil
-
-      exec(command_line)
-    end
-
-    def reload!
-      run_gc! if gc_request_period
-      restore!
-      @when_ready = nil
-      dispatcher_log :info, "reloaded"
-    end
-
-    # Make a note of $" so we can safely reload this instance.
-    def mark_features!
-      @features = $".clone
-    end
-
-    def restore!
-      $".replace @features
-      Dispatcher.reset_application!
-      ActionController::Routing::Routes.reload
-    end
-
-    def run_gc!
-      @gc_request_countdown = gc_request_period
-      GC.enable; GC.start; GC.disable
-    end
-
-    def gc_countdown
-      if gc_request_period
-        @gc_request_countdown ||= gc_request_period
-        @gc_request_countdown -= 1
-        run_gc! if @gc_request_countdown <= 0
-      end
-    end
-
-    def close_connection(request)
-      request.finish if request
-    end
-end