railties 3.0.0.beta4 → 3.0.0.rc

data/lib/rails/application/routes_reloader.rb

@@ -1,46 +0,0 @@
-module Rails
-  class Application
-    class RoutesReloader
-      attr_reader :paths
-
-      def initialize
-        @paths, @last_change_at = [], nil
-      end
-
-      def changed_at
-        routes_changed_at = nil
-
-        paths.each do |path|
-          config_changed_at = File.stat(path).mtime
-
-          if routes_changed_at.nil? || config_changed_at > routes_changed_at
-            routes_changed_at = config_changed_at
-          end
-        end
-
-        routes_changed_at
-      end
-
-      def reload!
-        routes = Rails::Application.routes
-        routes.disable_clear_and_finalize = true
-
-        routes.clear!
-        paths.each { |path| load(path) }
-        ActiveSupport.on_load(:action_controller) { routes.finalize! }
-
-        nil
-      ensure
-        routes.disable_clear_and_finalize = false
-      end
-
-      def reload_if_changed
-        current_change_at = changed_at
-        if @last_change_at != current_change_at
-          @last_change_at = current_change_at
-          reload!
-        end
-      end
-    end
-  end
-end

data/lib/rails/log_subscriber.rb

@@ -1,115 +0,0 @@
-require 'active_support/core_ext/class/inheritable_attributes'
-require 'active_support/notifications'
-
-module Rails
-  # Rails::LogSubscriber is an object set to consume ActiveSupport::Notifications
-  # on initialization with solely purpose of logging. The log subscriber dispatches
-  # notifications to a regirested object based on its given namespace.
-  #
-  # An example would be ActiveRecord log subscriber responsible for logging queries:
-  #
-  #   module ActiveRecord
-  #     class Railtie
-  #       class LogSubscriber < Rails::LogSubscriber
-  #         def sql(event)
-  #           "#{event.payload[:name]} (#{event.duration}) #{event.payload[:sql]}"
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # It's finally registed as:
-  #
-  #   Rails::LogSubscriber.add :active_record, ActiveRecord::Railtie::LogSubscriber.new
-  #
-  # So whenever a "sql.active_record" notification arrive to Rails::LogSubscriber,
-  # it will properly dispatch the event (ActiveSupport::Notifications::Event) to
-  # the sql method.
-  #
-  # This is useful because it avoids spanning several log subscribers just for logging
-  # purposes(which slows down the main thread). Besides of providing a centralized
-  # facility on top of Rails.logger.
-  #
-  # Log subscriber also has some helpers to deal with logging and automatically flushes
-  # all logs when the request finishes (via action_dispatch.callback notification).
-  class LogSubscriber
-    mattr_accessor :colorize_logging
-    self.colorize_logging = true
-
-    # Embed in a String to clear all previous ANSI sequences.
-    CLEAR      = "\e[0m"
-    BOLD       = "\e[1m"
-
-    # Colors
-    BLACK      = "\e[30m"
-    RED        = "\e[31m"
-    GREEN      = "\e[32m"
-    YELLOW     = "\e[33m"
-    BLUE       = "\e[34m"
-    MAGENTA    = "\e[35m"
-    CYAN       = "\e[36m"
-    WHITE      = "\e[37m"
-
-    def self.add(namespace, log_subscriber, notifier = ActiveSupport::Notifications)
-      log_subscribers << log_subscriber
-      @flushable_loggers = nil
-
-      log_subscriber.public_methods(false).each do |event|
-        notifier.subscribe("#{event}.#{namespace}") do |*args|
-          next if log_subscriber.logger.nil?
-
-          begin
-            log_subscriber.send(event, ActiveSupport::Notifications::Event.new(*args))
-          rescue Exception => e
-            Rails.logger.error "Could not log #{args[0].inspect} event. #{e.class}: #{e.message}"
-          end
-        end
-      end
-    end
-
-    def self.log_subscribers
-      @log_subscribers ||= []
-    end
-
-    def self.flushable_loggers
-      @flushable_loggers ||= begin
-        loggers = log_subscribers.map(&:logger)
-        loggers.uniq!
-        loggers.select { |l| l.respond_to?(:flush) }
-      end
-    end
-
-    # Flush all log_subscribers' logger.
-    def self.flush_all!
-      flushable_loggers.each(&:flush)
-    end
-
-    # By default, we use the Rails.logger for logging.
-    def logger
-      Rails.logger
-    end
-
-  protected
-
-    %w(info debug warn error fatal unknown).each do |level|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{level}(*args, &block)
-          return unless logger
-          logger.#{level}(*args, &block)
-        end
-      METHOD
-    end
-
-    # Set color by using a string or one of the defined constants. If a third
-    # option is set to true, it also adds bold to the string. This is based
-    # on Highline implementation and it automatically appends CLEAR to the end
-    # of the returned String.
-    #
-    def color(text, color, bold=false)
-      return text unless colorize_logging
-      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
-      bold  = bold ? BOLD : ""
-      "#{bold}#{color}#{text}#{CLEAR}"
-    end
-  end
-end

data/lib/rails/log_subscriber/test_helper.rb

@@ -1,97 +0,0 @@
-require 'rails/log_subscriber'
-
-module Rails
-  class LogSubscriber
-    # Provides some helpers to deal with testing log subscribers by setting up
-    # notifications. Take for instance ActiveRecord subscriber tests:
-    #
-    #   class SyncLogSubscriberTest < ActiveSupport::TestCase
-    #     include Rails::LogSubscriber::TestHelper
-    #     Rails::LogSubscriber.add(:active_record, ActiveRecord::Railties::LogSubscriber.new)
-    # 
-    #     def test_basic_query_logging
-    #       Developer.all
-    #       wait
-    #       assert_equal 1, @logger.logged(:debug).size
-    #       assert_match /Developer Load/, @logger.logged(:debug).last
-    #       assert_match /SELECT \* FROM "developers"/, @logger.logged(:debug).last
-    #     end
-    # 
-    #     class SyncLogSubscriberTest < ActiveSupport::TestCase
-    #       include Rails::LogSubscriber::SyncTestHelper
-    #       include LogSubscriberTest
-    #     end
-    # 
-    #     class AsyncLogSubscriberTest < ActiveSupport::TestCase
-    #       include Rails::LogSubscriber::AsyncTestHelper
-    #       include LogSubscriberTest
-    #     end
-    #   end
-    #
-    # All you need to do is to ensure that your log subscriber is added to Rails::Subscriber,
-    # as in the second line of the code above. The test helpers is reponsible for setting
-    # up the queue, subscriptions and turning colors in logs off.
-    #
-    # The messages are available in the @logger instance, which is a logger with limited
-    # powers (it actually do not send anything to your output), and you can collect them
-    # doing @logger.logged(level), where level is the level used in logging, like info,
-    # debug, warn and so on.
-    #
-    module TestHelper
-      def setup
-        @logger   = MockLogger.new
-        @notifier = ActiveSupport::Notifications::Notifier.new(queue)
-
-        Rails::LogSubscriber.colorize_logging = false
-
-        set_logger(@logger)
-        ActiveSupport::Notifications.notifier = @notifier
-      end
-
-      def teardown
-        set_logger(nil)
-        ActiveSupport::Notifications.notifier = nil
-      end
-
-      class MockLogger
-        attr_reader :flush_count
-
-        def initialize
-          @flush_count = 0
-          @logged = Hash.new { |h,k| h[k] = [] }
-        end
-
-        def method_missing(level, message)
-          @logged[level] << message
-        end
-
-        def logged(level)
-          @logged[level].compact.map { |l| l.to_s.strip }
-        end
-
-        def flush
-          @flush_count += 1
-        end
-      end
-
-      # Wait notifications to be published.
-      def wait
-        @notifier.wait
-      end
-
-      # Overwrite if you use another logger in your log subscriber:
-      #
-      #   def logger
-      #     ActiveRecord::Base.logger = @logger
-      #   end
-      #
-      def set_logger(logger)
-        Rails.logger = logger
-      end
-
-      def queue
-        ActiveSupport::Notifications::Fanout.new
-      end
-    end
-  end
-end

data/lib/rails/webrick_server.rb

@@ -1,156 +0,0 @@
-# Donated by Florian Gross
-
-require 'webrick'
-require 'cgi'
-require 'stringio'
-require 'dispatcher'
-
-include WEBrick
-
-class CGI #:nodoc:
-  def stdinput
-    @stdin || $stdin
-  end
-  
-  def env_table
-    @env_table || ENV
-  end
-  
-  def initialize(type = "query", table = nil, stdin = nil)
-    @env_table, @stdin = table, stdin
-
-    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
-      Apache.request.setup_cgi_env
-    end
-
-    extend QueryExtension
-    @multipart = false
-    if defined?(CGI_PARAMS)
-      warn "do not use CGI_PARAMS and CGI_COOKIES"
-      @params = CGI_PARAMS.dup
-      @cookies = CGI_COOKIES.dup
-    else
-      initialize_query()  # set @params, @cookies
-    end
-    @output_cookies = nil
-    @output_hidden = nil
-  end
-end
-
-# A custom dispatch servlet for use with WEBrick. It dispatches requests
-# (using the Rails Dispatcher) to the appropriate controller/action. By default,
-# it restricts WEBrick to a managing a single Rails request at a time, but you
-# can change this behavior by setting ActionController::Base.allow_concurrency
-# to true.
-class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
-  # Start the WEBrick server with the given options, mounting the
-  # DispatchServlet at <tt>/</tt>.
-  def self.dispatch(options = {})
-    Socket.do_not_reverse_lookup = true # patch for OS X
-
-    params = { :Port        => options[:port].to_i,
-               :ServerType  => options[:server_type],
-               :BindAddress => options[:ip] }
-    params[:MimeTypes] = options[:mime_types] if options[:mime_types]
-
-    server = WEBrick::HTTPServer.new(params)
-    server.mount('/', DispatchServlet, options)
-
-    trap("INT") { server.shutdown }
-    server.start
-  end
-
-  def initialize(server, options) #:nodoc:
-    @server_options = options
-    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
-    # Change to the Rails.root, since Webrick::Daemon.start does a Dir::cwd("/")
-    # OPTIONS['working_directory'] is an absolute path of the Rails.root, set in railties/lib/commands/servers/webrick.rb
-    Dir.chdir(OPTIONS['working_directory']) if defined?(OPTIONS) && File.directory?(OPTIONS['working_directory'])
-    super
-  end
-
-  def service(req, res) #:nodoc:
-    unless handle_file(req, res)
-      unless handle_dispatch(req, res)
-        raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
-      end
-    end
-  end
-
-  def handle_file(req, res) #:nodoc:
-    begin
-      req = req.dup
-      path = req.path.dup
-
-      # Add .html if the last path piece has no . in it
-      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
-      path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
-
-      req.instance_variable_set(:@path_info, path) # Set the modified path...
-
-      @file_handler.send(:service, req, res)      
-      return true
-    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
-      res.set_error(err)
-      return true
-    rescue => err
-      return false
-    end
-  end
-
-  def handle_dispatch(req, res, origin = nil) #:nodoc:
-    data = StringIO.new
-    Dispatcher.dispatch(
-      CGI.new("query", create_env_table(req, origin), StringIO.new(req.body || "")), 
-      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
-      data
-    )
-
-    header, body = extract_header_and_body(data)
-
-    set_charset(header)
-    assign_status(res, header)
-    res.cookies.concat(header.delete('set-cookie') || [])
-    header.each { |key, val| res[key] = val.join(", ") }
-    
-    res.body = body
-    return true
-  rescue => err
-    p err, err.backtrace
-    return false
-  end
-  
-  private
-    def create_env_table(req, origin)
-      env = req.meta_vars.clone
-      env.delete "SCRIPT_NAME"
-      env["QUERY_STRING"] = req.request_uri.query
-      env["REQUEST_URI"]  = origin if origin
-      return env
-    end
-    
-    def extract_header_and_body(data)
-      data.rewind
-      data = data.read
-
-      raw_header, body = *data.split(/^[\xd\xa]{2}/on, 2)
-      header = WEBrick::HTTPUtils::parse_header(raw_header)
-      
-      return header, body
-    end
-    
-    def set_charset(header)
-      ct = header["content-type"]
-      if ct.any? { |x| x =~ /^text\// } && ! ct.any? { |x| x =~ /charset=/ }
-        ch = @server_options[:charset] || "UTF-8"
-        ct.find { |x| x =~ /^text\// } << ("; charset=" + ch)
-      end
-    end
-
-    def assign_status(res, header)
-      if /^(\d+)/ =~ header['status'][0]
-        res.status = $1.to_i
-        header.delete('status')
-      end
-    end
-end