Remove old versions of Rails

2 files changed, 0 insertions, 228 deletions

diff --git a/vendor/rails-2.0.2/railties/lib/rails/plugin/loader.rb b/vendor/rails-2.0.2/railties/lib/rails/plugin/loader.rb
deleted file mode 100644
index 438afa4d3..000000000
--- a/vendor/rails-2.0.2/railties/lib/rails/plugin/loader.rb
+++ /dev/null
@@ -1,150 +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 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
-        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.load_paths, and Dependencies.load_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)
-            Dependencies.load_paths      << path
-            Dependencies.load_once_paths << path
-          end
-        end
-        $LOAD_PATH.uniq!
-      end      
-      
-      protected
-      
-        # 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 { |locator|
-            locator.new(initializer).plugins
-          }.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 + [:all])
-              raise LoadError, "Could not locate the following plugins: #{missing_plugins.to_sentence}"
-            end
-          end
-        end
-  
-    end
-  end
-end
\ No newline at end of file
diff --git a/vendor/rails-2.0.2/railties/lib/rails/plugin/locator.rb b/vendor/rails-2.0.2/railties/lib/rails/plugin/locator.rb
deleted file mode 100644
index b27e904b1..000000000
--- a/vendor/rails-2.0.2/railties/lib/rails/plugin/locator.rb
+++ /dev/null
@@ -1,78 +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
-    # the 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, '*')).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
-  end
-end
\ No newline at end of file