rails 2.3.18 → 7.1.3.4

data/lib/performance_test_help.rb

@@ -1,5 +0,0 @@
-require 'action_controller/performance_test'
-
-ActionController::Base.perform_caching = true
-ActiveSupport::Dependencies.mechanism = :require
-Rails.logger.level = ActiveSupport::BufferedLogger::INFO

data/lib/rails/backtrace_cleaner.rb

@@ -1,54 +0,0 @@
-module Rails
-  class BacktraceCleaner < ActiveSupport::BacktraceCleaner
-    ERB_METHOD_SIG = /:in `_run_erb_.*/
-
-    RAILS_GEMS   = %w( actionpack activerecord actionmailer activesupport activeresource rails )
-
-    VENDOR_DIRS  = %w( vendor/rails )
-    SERVER_DIRS  = %w( lib/mongrel bin/mongrel
-                       lib/passenger bin/passenger-spawn-server
-                       lib/rack )
-    RAILS_NOISE  = %w( script/server )
-    RUBY_NOISE   = %w( rubygems/custom_require benchmark.rb )
-
-    ALL_NOISE    = VENDOR_DIRS + SERVER_DIRS + RAILS_NOISE + RUBY_NOISE
-
-    def initialize
-      super
-      add_filter   { |line| line.sub("#{RAILS_ROOT}/", '') }
-      add_filter   { |line| line.sub(ERB_METHOD_SIG, '') }
-      add_filter   { |line| line.sub('./', '/') } # for tests
-
-      add_gem_filters
-
-      add_silencer { |line| ALL_NOISE.any? { |dir| line.include?(dir) } }
-      add_silencer { |line| RAILS_GEMS.any? { |gem| line =~ /^#{gem} / } }
-      add_silencer { |line| line =~ %r(vendor/plugins/[^\/]+/lib) }
-    end
-    
-    
-    private
-      def add_gem_filters
-        Gem.path.each do |path|
-          # http://gist.github.com/30430
-          add_filter { |line| line.sub(/(#{path})\/gems\/([a-z]+)-([0-9.]+)\/(.*)/, '\2 (\3) \4')}
-        end
-
-        vendor_gems_path = Rails::GemDependency.unpacked_path.sub("#{RAILS_ROOT}/",'')
-        add_filter { |line| line.sub(/(#{vendor_gems_path})\/([a-z]+)-([0-9.]+)\/(.*)/, '\2 (\3) [v] \4')}
-      end
-  end
-
-  # For installing the BacktraceCleaner in the test/unit
-  module BacktraceFilterForTestUnit #:nodoc:
-    def self.included(klass)
-      klass.send :alias_method_chain, :filter_backtrace, :cleaning
-    end
-
-    def filter_backtrace_with_cleaning(backtrace, prefix=nil)
-      backtrace = filter_backtrace_without_cleaning(backtrace, prefix)
-      backtrace = backtrace.first.split("\n") if backtrace.size == 1
-      Rails.backtrace_cleaner.clean(backtrace)
-    end
-  end
-end

data/lib/rails/gem_builder.rb

@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'rubygems/installer'
-
-module Rails
-  
-  # this class hijacks the functionality of Gem::Installer by overloading its 
-  # initializer to only provide the information needed by 
-  # Gem::Installer#build_extensions (which happens to be what we have)
-  class GemBuilder < Gem::Installer
-
-    def initialize(spec, gem_dir)
-      @spec    = spec
-      @gem_dir = gem_dir
-    end
-
-    # silence the underlying builder
-    def say(message)
-    end
-
-  end
-end

data/lib/rails/gem_dependency.rb

@@ -1,317 +0,0 @@
-require 'rails/vendor_gem_source_index'
-
-module Gem
-  def self.source_index=(index)
-    @@source_index = index
-  end
-end
-
-module Rails
-  class GemDependency < Gem::Dependency
-    attr_accessor :lib, :source, :dep
-
-    def self.unpacked_path
-      @unpacked_path ||= File.join(RAILS_ROOT, 'vendor', 'gems')
-    end
-
-    @@framework_gems = {}
-
-    def self.add_frozen_gem_path
-      @@paths_loaded ||= begin
-        source_index = Rails::VendorGemSourceIndex.new(Gem.source_index)
-        Gem.clear_paths
-        Gem.source_index = source_index
-        # loaded before us - we can't change them, so mark them
-        Gem.loaded_specs.each do |name, spec|
-          @@framework_gems[name] = spec
-        end
-        true
-      end
-    end
-
-    def self.from_directory_name(directory_name, load_spec=true)
-      directory_name_parts = File.basename(directory_name).split('-')
-      
-      version = directory_name_parts.find { |s| s.match(/^\d(\.\d|\.\w+)*$/) }
-      name    = directory_name_parts[0..directory_name_parts.index(version)-1].join('-') if version
-      
-      result = self.new(name, :version => version)
-      spec_filename = File.join(directory_name, '.specification')
-      if load_spec
-        raise "Missing specification file in #{File.dirname(spec_filename)}. Perhaps you need to do a 'rake gems:refresh_specs'\?" unless File.exists?(spec_filename)
-        spec = YAML::load_file(spec_filename)
-        result.specification = spec
-      end
-      result
-    rescue ArgumentError => e
-      raise "Unable to determine gem name and version from '#{directory_name}'"
-    end
-
-    def initialize(name, options = {})
-      require 'rubygems' unless Object.const_defined?(:Gem)
-
-      if options[:requirement]
-        req = options[:requirement]
-      elsif options[:version]
-        req = Gem::Requirement.create(options[:version])
-      else
-        req = Gem::Requirement.default
-      end
-
-      @lib      = options[:lib]
-      @source   = options[:source]
-      @loaded   = @frozen = @load_paths_added = false
-
-      super(name, req)
-    end
-
-    def add_load_paths
-      self.class.add_frozen_gem_path
-      return if @loaded || @load_paths_added
-      if framework_gem?
-        @load_paths_added = @loaded = @frozen = true
-        return
-      end
-
-      begin
-        dep = Gem::Dependency.new(name, requirement)
-        spec = Gem.source_index.find { |_,s| s.satisfies_requirement?(dep) }.last
-        spec.activate           # a way that exists
-      rescue
-        gem self.name, self.requirement # <  1.8 unhappy way
-      end
-
-      @spec = Gem.loaded_specs[name]
-      @frozen = @spec.loaded_from.include?(self.class.unpacked_path) if @spec
-      @load_paths_added = true
-    rescue Gem::LoadError
-    end
-
-    def dependencies
-      return [] if framework_gem?
-      return [] unless installed?
-      specification.dependencies.reject do |dependency|
-        dependency.type == :development
-      end.map do |dependency|
-        GemDependency.new(dependency.name, :requirement => (dependency.respond_to?(:requirement) ? dependency.requirement : dependency.version_requirements))
-      end
-    end
-
-    def specification
-      # code repeated from Gem.activate. Find a matching spec, or the currently loaded version.
-      # error out if loaded version and requested version are incompatible.
-      @spec ||= begin
-        matches = Gem.source_index.search(self)
-        matches << @@framework_gems[name] if framework_gem?
-        if Gem.loaded_specs[name] then
-          # This gem is already loaded.  If the currently loaded gem is not in the
-          # list of candidate gems, then we have a version conflict.
-          existing_spec = Gem.loaded_specs[name]
-          unless matches.any? { |spec| spec.version == existing_spec.version } then
-            raise Gem::Exception,
-                  "can't activate #{@dep}, already activated #{existing_spec.full_name}"
-          end
-          # we're stuck with it, so change to match
-          version_requirements = Gem::Requirement.create("=#{existing_spec.version}")
-          existing_spec
-        else
-          # new load
-          matches.last
-        end
-      end
-    end
-
-    def specification=(s)
-      @spec = s
-    end
-
-    def built?
-      return false unless frozen?
-
-      if vendor_gem?
-        specification.extensions.each do |ext|
-          makefile = File.join(unpacked_gem_directory, File.dirname(ext), 'Makefile')
-          return false unless File.exists?(makefile)
-        end
-      end
-
-      true
-    end
-
-    def framework_gem?
-      @@framework_gems.has_key?(name)
-    end
-
-    def frozen?
-      @frozen ||= vendor_rails? || vendor_gem?
-    end
-
-    def installed?
-      Gem.loaded_specs.keys.include?(name)
-    end
-
-    def load_paths_added?
-      # always try to add load paths - even if a gem is loaded, it may not
-      # be a compatible version (ie random_gem 0.4 is loaded and a later spec
-      # needs >= 0.5 - gem 'random_gem' will catch this and error out)
-      @load_paths_added
-    end
-
-    def loaded?
-      @loaded ||= begin
-        if vendor_rails?
-          true
-        elsif specification.nil?
-          false
-        else
-          # check if the gem is loaded by inspecting $"
-          # specification.files lists all the files contained in the gem
-          gem_files = specification.files
-          # select only the files contained in require_paths - typically in bin and lib
-          require_paths_regexp = Regexp.new("^(#{specification.require_paths*'|'})/")
-          gem_lib_files = gem_files.select { |f| require_paths_regexp.match(f) }
-          # chop the leading directory off - a typical file might be in
-          # lib/gem_name/file_name.rb, but it will be 'require'd as gem_name/file_name.rb
-          gem_lib_files.map! { |f| f.split('/', 2)[1] }
-          # if any of the files from the above list appear in $", the gem is assumed to
-          # have been loaded
-          !(gem_lib_files & $").empty?
-        end
-      end
-    end
-
-    def vendor_rails?
-      Gem.loaded_specs.has_key?(name) && Gem.loaded_specs[name].loaded_from.empty?
-    end
-
-    def vendor_gem?
-      specification && File.exists?(unpacked_gem_directory)
-    end
-
-    def build(options={})
-      require 'rails/gem_builder'
-      return if specification.nil?
-      if options[:force] || !built?
-        return unless File.exists?(unpacked_specification_filename)
-        spec = YAML::load_file(unpacked_specification_filename)
-        Rails::GemBuilder.new(spec, unpacked_gem_directory).build_extensions
-        puts "Built gem: '#{unpacked_gem_directory}'"
-      end
-      dependencies.each { |dep| dep.build(options) }
-    end
-
-    def install
-      unless installed?
-        cmd = "#{gem_command} #{install_command.join(' ')}"
-        puts cmd
-        puts %x(#{cmd})
-      end
-    end
-
-    def load
-      return if @loaded || @load_paths_added == false
-      require(@lib || name) unless @lib == false
-      @loaded = true
-    rescue LoadError
-      puts $!.to_s
-      $!.backtrace.each { |b| puts b }
-    end
-
-    def refresh
-      Rails::VendorGemSourceIndex.silence_spec_warnings = true
-      real_gems = Gem.source_index.installed_source_index
-      exact_dep = Gem::Dependency.new(name, "= #{specification.version}")
-      matches = real_gems.search(exact_dep)
-      installed_spec = matches.first
-      if frozen?
-        if installed_spec
-          # we have a real copy
-          # get a fresh spec - matches should only have one element
-          # note that there is no reliable method to check that the loaded
-          # spec is the same as the copy from real_gems - Gem.activate changes
-          # some of the fields
-          real_spec = Gem::Specification.load(matches.first.loaded_from)
-          write_specification(real_spec)
-          puts "Reloaded specification for #{name} from installed gems."
-        else
-          # the gem isn't installed locally - write out our current specs
-          write_specification(specification)
-          puts "Gem #{name} not loaded locally - writing out current spec."
-        end
-      else
-        if framework_gem?
-          puts "Gem directory for #{name} not found - check if it's loading before rails."
-        else
-          puts "Something bad is going on - gem directory not found for #{name}."
-        end
-      end
-    end
-
-    def unpack(options={})
-      unless frozen? || framework_gem?
-        FileUtils.mkdir_p unpack_base
-        Dir.chdir unpack_base do
-          Gem::GemRunner.new.run(unpack_command)
-        end
-        # Gem.activate changes the spec - get the original
-        real_spec = Gem::Specification.load(specification.loaded_from)
-        write_specification(real_spec)
-      end
-      dependencies.each { |dep| dep.unpack(options) } if options[:recursive]
-    end
-
-    def write_specification(spec)
-      # copy the gem's specification into GEMDIR/.specification so that
-      # we can access information about the gem on deployment systems
-      # without having the gem installed
-      File.open(unpacked_specification_filename, 'w') do |file|
-        file.puts spec.to_yaml
-      end
-    end
-
-    def ==(other)
-      Gem::Dependency === other.class &&
-        self.name == other.name && self.requirement == other.requirement
-    end
-    alias_method :eql?, :"=="
-
-    private
-
-      def gem_command
-        case RUBY_PLATFORM
-          when /win32/
-            'gem.bat'
-          when /java/
-            'jruby -S gem'
-          else
-            'gem'
-        end
-      end
-
-      def install_command
-        cmd = %w(install) << name
-        cmd << "--version" << %("#{requirement.to_s}") if requirement
-        cmd << "--source"  << @source  if @source
-        cmd
-      end
-
-      def unpack_command
-        cmd = %w(unpack) << name
-        cmd << "--version" << "= "+specification.version.to_s if requirement
-        cmd
-      end
-
-      def unpack_base
-        Rails::GemDependency.unpacked_path
-      end
-
-      def unpacked_gem_directory
-        File.join(unpack_base, specification.full_name)
-      end
-
-      def unpacked_specification_filename
-        File.join(unpacked_gem_directory, '.specification')
-      end
-
-  end
-end

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