authorails 1.0.0

data/lib/commands/runner.rb

@@ -0,0 +1,48 @@
+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/
+    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'
+
+if code_or_file.nil?
+  $stderr.puts "Run '#{$0} -h' for help."
+  exit 1
+elsif File.exists?(code_or_file)
+  eval(File.read(code_or_file))
+else
+  eval(code_or_file)
+end

data/lib/commands/server.rb

@@ -0,0 +1,39 @@
+require 'active_support'
+require 'fileutils'
+
+begin
+  require_library_or_gem 'fcgi'
+rescue Exception
+  # FCGI not available
+end
+
+begin
+  require_library_or_gem 'mongrel'
+rescue Exception
+  # Mongrel not available
+end
+
+server = case ARGV.first
+  when "lighttpd", "mongrel", "webrick"
+    ARGV.shift
+  else
+    if defined?(Mongrel)
+      "mongrel"
+    elsif RUBY_PLATFORM !~ /(:?mswin|mingw)/ && !silence_stderr { `lighttpd -version` }.blank? && defined?(FCGI)
+      "lighttpd"
+    else
+      "webrick"
+    end
+end
+
+case server
+  when "webrick"
+    puts "=> Booting WEBrick..."
+  when "lighttpd"
+    puts "=> Booting lighttpd (use 'script/server webrick' to force WEBrick)"
+  when "mongrel"
+    puts "=> Booting Mongrel (use 'script/server webrick' to force WEBrick)"
+end
+
+%w(cache pids sessions sockets).each { |dir_to_make| FileUtils.mkdir_p(File.join(RAILS_ROOT, 'tmp', dir_to_make)) }
+require "commands/servers/#{server}"

data/lib/commands/servers/base.rb

@@ -0,0 +1,19 @@
+def tail(log_file)
+  cursor = File.size(log_file)
+  last_checked = Time.now
+  tail_thread = Thread.new do
+    File.open(log_file, 'r') do |f|
+      loop do
+        f.seek cursor
+        if f.mtime > last_checked
+          last_checked = f.mtime
+          contents = f.read
+          cursor += contents.length
+          print contents
+        end
+        sleep 1
+      end
+    end
+  end
+  tail_thread
+end

data/lib/commands/servers/lighttpd.rb

@@ -0,0 +1,94 @@
+require 'rbconfig'
+require 'commands/servers/base'
+
+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
+
+require 'initializer'
+configuration = Rails::Initializer.run(:initialize_logger).configuration
+default_config_file = config_file = Pathname.new("#{RAILS_ROOT}/config/lighttpd.conf").cleanpath
+
+require 'optparse'
+
+detach = false
+command_line_port = nil
+
+ARGV.options do |opt|
+  opt.on("-p", "--port=port", "Changes the server.port number in the config/lighttpd.conf") { |port| command_line_port = port }
+  opt.on('-c', "--config=#{config_file}", 'Specify a different lighttpd config file.') { |path| config_file = path }
+  opt.on('-h', '--help', 'Show this message.') { puts opt; exit 0 }
+  opt.on('-d', '-d', 'Call with -d to detach') { detach = true; puts "=> Configuration in config/lighttpd.conf" }
+  opt.parse!
+end
+
+unless File.exist?(config_file)
+  if config_file != default_config_file
+    puts "=> #{config_file} not found."
+    exit 1
+  end
+
+  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
+
+# open the config/lighttpd.conf file and add the current user defined port setting to it
+if command_line_port
+  File.open(config_file, 'r+') do |config|
+    lines = config.readlines
+
+    lines.each do |line|
+      line.gsub!(/^\s*server.port\s*=\s*(\d+)/, "server.port = #{command_line_port}")
+    end
+
+    config.rewind
+    config.print(lines)
+    config.truncate(config.pos)
+  end
+end
+
+config = IO.read(config_file)
+default_port, default_ip = 3000, '0.0.0.0'
+port = config.scan(/^\s*server.port\s*=\s*(\d+)/).first rescue default_port
+ip   = config.scan(/^\s*server.bind\s*=\s*"([^"]+)"/).first rescue default_ip
+puts "=> Rails application starting on http://#{ip || default_ip}:#{port || default_port}"
+
+tail_thread = nil
+
+if !detach
+  puts "=> Call with -d to detach"
+  puts "=> Ctrl-C to shutdown server (see config/lighttpd.conf for options)"
+  detach = false
+  tail_thread = tail(configuration.log_path)
+end
+
+trap(:INT) { exit }
+
+begin
+  `rake tmp:sockets:clear` # Needed if lighttpd crashes or otherwise leaves FCGI sockets around
+  `lighttpd #{!detach ? "-D " : ""}-f #{config_file}`
+ensure
+  unless detach
+    tail_thread.kill if tail_thread
+    puts 'Exiting'
+  
+    # Ensure FCGI processes are reaped
+    silence_stream(STDOUT) do
+      ARGV.replace ['-a', 'kill']
+      require 'commands/process/reaper'
+    end
+
+    `rake tmp:sockets:clear` # Remove sockets on clean shutdown
+  end
+end

data/lib/commands/servers/mongrel.rb

@@ -0,0 +1,65 @@
+require 'rbconfig'
+require 'commands/servers/base'
+
+unless defined?(Mongrel)
+  puts "PROBLEM: Mongrel is not available on your system (or not in your path)"
+  exit 1
+end
+
+require 'optparse'
+
+OPTIONS = {
+  :port        => 3000,
+  :ip          => "0.0.0.0",
+  :environment => (ENV['RAILS_ENV'] || "development").dup,
+  :detach      => 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("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |v| OPTIONS[:environment] = v }
+
+  opts.separator ""
+
+  opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+
+  opts.parse!
+end
+
+puts "=> Rails application starting on http://#{OPTIONS[:ip]}:#{OPTIONS[:port]}"
+
+parameters = [ 
+  "start", 
+  "-p", OPTIONS[:port].to_s, 
+  "-a", OPTIONS[:ip].to_s, 
+  "-e", OPTIONS[:environment],
+  "-P", "#{RAILS_ROOT}/tmp/pids/mongrel.pid"
+]
+
+if OPTIONS[:detach]
+  `mongrel_rails #{parameters.join(" ")} -d`
+else
+  ENV["RAILS_ENV"] = OPTIONS[:environment]
+  RAILS_ENV.replace(OPTIONS[:environment]) if defined?(RAILS_ENV)
+
+  require 'initializer'
+  Rails::Initializer.run(:initialize_logger)
+
+  puts "=> Call with -d to detach"
+  puts "=> Ctrl-C to shutdown server"
+  tail_thread = tail(Pathname.new("#{File.expand_path(RAILS_ROOT)}/log/#{RAILS_ENV}.log").cleanpath)
+
+  trap(:INT) { exit }
+
+  begin
+    silence_warnings { ARGV = parameters }
+    load("mongrel_rails")
+  ensure
+    tail_thread.kill if tail_thread
+    puts 'Exiting'
+  end
+end

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") { |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("-e", "--environment=name", String,
+          "Specifies the environment to run this server under (test/development/production).",
+          "Default: development") { |v| OPTIONS[:environment] = v }
+  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") { |v| OPTIONS[:charset] = v }
+
+  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/commands/update.rb

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,27 @@
+require 'action_controller/integration'
+
+# work around the at_exit hook in test/unit, which kills IRB
+Test::Unit.run = true
+
+# 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.reset_application!
+end

data/lib/console_sandbox.rb

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

data/lib/console_with_helpers.rb

@@ -0,0 +1,23 @@
+class Module
+  def include_all_modules_from(parent_module)
+    parent_module.constants.each do |const|
+      mod = parent_module.const_get(const)
+      if mod.class == Module
+        send(:include, mod)
+        include_all_modules_from(mod)
+      end
+    end
+  end
+end
+
+def helper
+  @helper_proxy ||= Object.new 
+end
+
+require 'application'
+
+class << helper 
+  include_all_modules_from ActionView
+end
+
+@controller = ApplicationController.new

data/lib/dispatcher.rb

@@ -0,0 +1,173 @@
+#--
+# Copyright (c) 2004-2006 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.
+#++
+
+# 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 LoadError nil
+        controller ||= 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)