rails 2.3.18 → 3.0.0

data/lib/rails/plugin/loader.rb

@@ -1,198 +0,0 @@
-require "rails/plugin"
-
-module Rails
-  class Plugin
-    class Loader
-      attr_reader :initializer
-
-      # Creates a new Plugin::Loader instance, associated with the given
-      # Rails::Initializer. This default implementation automatically locates
-      # all plugins, and adds all plugin load paths, when it is created. The plugins
-      # are then fully loaded (init.rb is evaluated) when load_plugins is called.
-      #
-      # It is the loader's responsibility to ensure that only the plugins specified
-      # in the configuration are actually loaded, and that the order defined
-      # is respected.
-      def initialize(initializer)
-        @initializer = initializer
-      end
-
-      # Returns the plugins to be loaded, in the order they should be loaded.
-      def plugins
-        @plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
-      end
-
-      # Returns the plugins that are in engine-form (have an app/ directory)
-      def engines
-        @engines ||= plugins.select(&:engine?)
-      end
-
-      # Returns all the plugins that could be found by the current locators.
-      def all_plugins
-        @all_plugins ||= locate_plugins
-        @all_plugins
-      end
-
-      def load_plugins
-        plugins.each do |plugin|
-          plugin.load(initializer)
-          register_plugin_as_loaded(plugin)
-        end
-
-        configure_engines
-
-        ensure_all_registered_plugins_are_loaded!
-      end
-
-      # Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
-      # added *after* the application's <tt>lib</tt> directory, to ensure that an application
-      # can always override code within a plugin.
-      #
-      # Plugin load paths are also added to Dependencies.autoload_paths, and Dependencies.autoload_once_paths.
-      def add_plugin_load_paths
-        plugins.each do |plugin|
-          plugin.load_paths.each do |path|
-            $LOAD_PATH.insert(application_lib_index + 1, path)
-
-            ActiveSupport::Dependencies.autoload_paths << path
-
-            unless configuration.reload_plugins?
-              ActiveSupport::Dependencies.autoload_once_paths << path
-            end
-          end
-        end
-
-        $LOAD_PATH.uniq!
-      end
-
-      def engine_metal_paths
-        engines.collect(&:metal_path)
-      end
-
-      protected
-        def configure_engines
-          if engines.any?
-            add_engine_routing_configurations
-            add_engine_locales
-            add_engine_controller_paths
-            add_engine_view_paths
-          end
-        end
-
-        def add_engine_routing_configurations
-          engines.select(&:routed?).collect(&:routing_file).each do |routing_file|
-            ActionController::Routing::Routes.add_configuration_file(routing_file)
-          end
-        end
-
-        def add_engine_locales
-          # reverse it such that the last engine can overwrite translations from the first, like with routes
-          locale_files = engines.select(&:localized?).collect(&:locale_files).reverse.flatten
-          I18n.load_path += locale_files - I18n.load_path
-        end
-
-        def add_engine_controller_paths
-          ActionController::Routing.controller_paths += engines.collect(&:controller_path)
-        end
-
-        def add_engine_view_paths
-          # reverse it such that the last engine can overwrite view paths from the first, like with routes
-          paths = ActionView::PathSet.new(engines.collect(&:view_path).reverse)
-          ActionController::Base.view_paths.concat(paths)
-          ActionMailer::Base.view_paths.concat(paths) if configuration.frameworks.include?(:action_mailer)
-        end
-
-        # The locate_plugins method uses each class in config.plugin_locators to
-        # find the set of all plugins available to this Rails application.
-        def locate_plugins
-          configuration.plugin_locators.map do |locator|
-            locator.new(initializer).plugins
-          end.flatten
-          # TODO: sorting based on config.plugins
-        end
-
-        def register_plugin_as_loaded(plugin)
-          initializer.loaded_plugins << plugin
-        end
-
-        def configuration
-          initializer.configuration
-        end
-
-        def should_load?(plugin)
-          # uses Plugin#name and Plugin#valid?
-          enabled?(plugin) && plugin.valid?
-        end
-
-        def order_plugins(plugin_a, plugin_b)
-          if !explicit_plugin_loading_order?
-            plugin_a <=> plugin_b
-          else
-            if !explicitly_enabled?(plugin_a) && !explicitly_enabled?(plugin_b)
-              plugin_a <=> plugin_b
-            else
-              effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
-            end
-          end
-        end
-
-        def effective_order_of(plugin)
-          if explicitly_enabled?(plugin)
-            registered_plugin_names.index(plugin.name)
-          else
-            registered_plugin_names.index('all')
-          end
-        end
-
-        def application_lib_index
-          $LOAD_PATH.index(File.join(RAILS_ROOT, 'lib')) || 0
-        end
-
-        def enabled?(plugin)
-          !explicit_plugin_loading_order? || registered?(plugin)
-        end
-
-        def explicit_plugin_loading_order?
-          !registered_plugin_names.nil?
-        end
-
-        def registered?(plugin)
-          explicit_plugin_loading_order? && registered_plugins_names_plugin?(plugin)
-        end
-
-        def explicitly_enabled?(plugin)
-          !explicit_plugin_loading_order? || explicitly_registered?(plugin)
-        end
-
-        def explicitly_registered?(plugin)
-          explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
-        end
-
-        def registered_plugins_names_plugin?(plugin)
-          registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
-        end
-
-        # The plugins that have been explicitly listed with config.plugins. If this list is nil
-        # then it means the client does not care which plugins or in what order they are loaded,
-        # so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
-        # non empty, we load the named plugins in the order specified.
-        def registered_plugin_names
-          configuration.plugins ? configuration.plugins.map(&:to_s) : nil
-        end
-
-        def loaded?(plugin_name)
-          initializer.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
-        end
-
-        def ensure_all_registered_plugins_are_loaded!
-          if explicit_plugin_loading_order?
-            if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
-              missing_plugins = configuration.plugins - (plugins.map{|p| p.name.to_sym} + [:all])
-              raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence(:locale => :en)}"
-            end
-          end
-        end
-
-    end
-  end
-end

data/lib/rails/plugin/locator.rb

@@ -1,100 +0,0 @@
-module Rails
-  class Plugin
-    
-    # The Plugin::Locator class should be subclasses to provide custom plugin-finding
-    # abilities to Rails (i.e. loading plugins from Gems, etc). Each subclass should implement
-    # the <tt>located_plugins</tt> method, which return an array of Plugin objects that have been found.
-    class Locator
-      include Enumerable
-      
-      attr_reader :initializer
-      
-      def initialize(initializer)
-        @initializer = initializer
-      end
-      
-      # This method should return all the plugins which this Plugin::Locator can find
-      # These will then be used by the current Plugin::Loader, which is responsible for actually
-      # loading the plugins themselves
-      def plugins
-        raise "The `plugins' method must be defined by concrete subclasses of #{self.class}"
-      end
-      
-      def each(&block)
-        plugins.each(&block)
-      end
-      
-      def plugin_names
-        plugins.map(&:name)
-      end
-    end
-    
-    # The Rails::Plugin::FileSystemLocator will try to locate plugins by examining the directories
-    # in the paths given in configuration.plugin_paths. Any plugins that can be found are returned
-    # in a list. 
-    #
-    # The criteria for a valid plugin in this case is found in Rails::Plugin#valid?, although
-    # other subclasses of Rails::Plugin::Locator can of course use different conditions.
-    class FileSystemLocator < Locator
-      
-      # Returns all the plugins which can be loaded in the filesystem, under the paths given
-      # by configuration.plugin_paths.
-      def plugins
-        initializer.configuration.plugin_paths.flatten.inject([]) do |plugins, path|
-          plugins.concat locate_plugins_under(path)
-          plugins
-        end.flatten
-      end
-          
-      private
-      
-        # Attempts to create a plugin from the given path. If the created plugin is valid?
-        # (see Rails::Plugin#valid?) then the plugin instance is returned; otherwise nil.
-        def create_plugin(path)
-          plugin = Rails::Plugin.new(path)
-          plugin.valid? ? plugin : nil
-        end
-
-        # This starts at the base path looking for valid plugins (see Rails::Plugin#valid?).
-        # Since plugins can be nested arbitrarily deep within an unspecified number of intermediary 
-        # directories, this method runs recursively until it finds a plugin directory, e.g.
-        #
-        #     locate_plugins_under('vendor/plugins/acts/acts_as_chunky_bacon')
-        #     => <Rails::Plugin name: 'acts_as_chunky_bacon' ... >
-        #
-        def locate_plugins_under(base_path)
-           Dir.glob(File.join(base_path, '*')).sort.inject([]) do |plugins, path|
-            if plugin = create_plugin(path)
-              plugins << plugin
-            elsif File.directory?(path)
-              plugins.concat locate_plugins_under(path)
-            end
-            plugins
-          end
-        end
-    end
-
-    # The GemLocator scans all the loaded RubyGems, looking for gems with
-    # a <tt>rails/init.rb</tt> file.
-    class GemLocator < Locator
-      def plugins
-        gem_index = initializer.configuration.gems.inject({}) { |memo, gem| memo.update gem.specification => gem }
-        specs     = gem_index.keys
-        specs    += Gem.loaded_specs.values.select do |spec|
-          spec.loaded_from && # prune stubs
-            File.exist?(File.join(spec.full_gem_path, "rails", "init.rb"))
-        end
-        specs.compact!
-
-        require "rubygems/dependency_list"
-
-        deps = Gem::DependencyList.new
-        deps.add(*specs) unless specs.empty?
-
-        deps.dependency_order.collect do |spec|
-          Rails::GemPlugin.new(spec, gem_index[spec])
-        end
-      end
-    end
-  end
-end

data/lib/rails/rack.rb

@@ -1,8 +0,0 @@
-module Rails
-  module Rack
-    autoload :Debugger, "rails/rack/debugger"
-    autoload :LogTailer, "rails/rack/log_tailer"
-    autoload :Metal, "rails/rack/metal"
-    autoload :Static, "rails/rack/static"
-  end
-end

data/lib/rails/rack/debugger.rb

@@ -1,23 +0,0 @@
-module Rails
-  module Rack
-    class Debugger
-      def initialize(app)
-        @app = app
-
-        ARGV.clear # clear ARGV so that script/server options aren't passed to IRB
-
-        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
-
-      def call(env)
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/rails/rack/log_tailer.rb

@@ -1,35 +0,0 @@
-module Rails
-  module Rack
-    class LogTailer
-      EnvironmentLog = "#{File.expand_path(Rails.root)}/log/#{Rails.env}.log"
-
-      def initialize(app, log = nil)
-        @app = app
-
-        path = Pathname.new(log || EnvironmentLog).cleanpath
-        @cursor = ::File.size(path)
-        @last_checked = Time.now.to_f
-
-        @file = ::File.open(path, 'r')
-      end
-
-      def call(env)
-        response = @app.call(env)
-        tail_log
-        response
-      end
-
-      def tail_log
-        @file.seek @cursor
-
-        mod = @file.mtime.to_f
-        if mod > @last_checked
-          contents = @file.read
-          @last_checked = mod
-          @cursor += contents.size
-          $stdout.print contents
-        end
-      end
-    end
-  end
-end

data/lib/rails/rack/metal.rb

@@ -1,51 +0,0 @@
-require 'active_support/ordered_hash'
-
-module Rails
-  module Rack
-    class Metal
-      NotFoundResponse = [404, {}, []].freeze
-      NotFound = lambda { NotFoundResponse }
-
-      cattr_accessor :metal_paths
-      self.metal_paths = ["#{Rails.root}/app/metal"]
-      cattr_accessor :requested_metals
-
-      def self.metals
-        matcher = /#{Regexp.escape('/app/metal/')}(.*)\.rb\Z/
-        metal_glob = metal_paths.map{ |base| "#{base}/**/*.rb" }
-        all_metals = {}
-
-        metal_glob.each do |glob|
-          Dir[glob].sort.map do |file|
-            file = file.match(matcher)[1]
-            all_metals[file.camelize] = file
-          end
-        end
-
-        load_list = requested_metals || all_metals.keys
-
-        load_list.map do |requested_metal|
-          if metal = all_metals[requested_metal]
-            require_dependency metal
-            requested_metal.constantize
-          end
-        end.compact
-      end
-
-      def initialize(app)
-        @app = app
-        @metals = ActiveSupport::OrderedHash.new
-        self.class.metals.each { |app| @metals[app] = true }
-        freeze
-      end
-
-      def call(env)
-        @metals.keys.each do |app|
-          result = app.call(env)
-          return result unless result[0].to_i == 404
-        end
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/rails/rack/static.rb

@@ -1,46 +0,0 @@
-require 'rack/utils'
-
-module Rails
-  module Rack
-    class Static
-      FILE_METHODS = %w(GET HEAD).freeze
-
-      def initialize(app)
-        @app = app
-        @file_server = ::Rack::File.new(File.join(RAILS_ROOT, "public"))
-      end
-
-      def call(env)
-        path        = env['PATH_INFO'].chomp('/')
-        method      = env['REQUEST_METHOD']
-
-        if FILE_METHODS.include?(method)
-          if file_exist?(path)
-            return @file_server.call(env)
-          else
-            cached_path = directory_exist?(path) ? "#{path}/index" : path
-            cached_path += ::ActionController::Base.page_cache_extension
-
-            if file_exist?(cached_path)
-              env['PATH_INFO'] = cached_path
-              return @file_server.call(env)
-            end
-          end
-        end
-
-        @app.call(env)
-      end
-
-      private
-        def file_exist?(path)
-          full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
-          File.file?(full_path) && File.readable?(full_path)
-        end
-
-        def directory_exist?(path)
-          full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
-          File.directory?(full_path) && File.readable?(full_path)
-        end
-    end
-  end
-end