backlog 0.0.2 → 0.0.3

data/vendor/rails/railties/lib/rails/plugin/loader.rb

@@ -1,123 +0,0 @@
-module Rails
-  module Plugin
-    class Loader
-      include Comparable
-      attr_reader :initializer, :directory, :name
-  
-      class << self
-        def load(*args)
-          new(*args).load
-        end
-      end
-  
-      def initialize(initializer, directory)
-        @initializer = initializer
-        @directory   = directory
-        @name        = File.basename(directory)
-      end
-  
-      def load
-        return false if loaded?
-        report_nonexistant_or_empty_plugin!
-        add_to_load_path!
-        register_plugin_as_loaded
-        evaluate
-        true
-      end
-  
-      def loaded?
-        initializer.loaded_plugins.include?(name)
-      end
-  
-      def plugin_path?
-        File.directory?(directory) && (has_lib_directory? || has_init_file?)
-      end
-      
-      def enabled?
-        !explicit_plugin_loading_order? || registered?
-      end
-        
-      def registered?
-        explicit_plugin_loading_order? && registered_plugins.include?(name)
-      end
-      
-      def plugin_does_not_exist!(plugin_name = name)
-        raise LoadError, "Can not find the plugin named: #{plugin_name}"
-      end
-      
-      private
-        # 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_plugins
-          config.plugins
-        end
-        
-        def explicit_plugin_loading_order?
-          !registered_plugins.nil?
-        end
-        
-        def report_nonexistant_or_empty_plugin!
-          plugin_does_not_exist! unless plugin_path?
-        end
-        
-        def lib_path
-          File.join(directory, 'lib')
-        end
-  
-        def init_path
-          File.join(directory, 'init.rb')
-        end
-  
-        def has_lib_directory?
-          File.directory?(lib_path)
-        end
-  
-        def has_init_file?
-          File.file?(init_path)
-        end
-  
-        def add_to_load_path!
-          # Add lib to load path *after* the application lib, to allow
-          # application libraries to override plugin libraries.
-          if has_lib_directory?
-            application_lib_index = $LOAD_PATH.index(application_library_path) || 0
-            $LOAD_PATH.insert(application_lib_index + 1, lib_path)
-            Dependencies.load_paths      << lib_path
-            Dependencies.load_once_paths << lib_path
-          end
-        end
-      
-        def application_library_path
-          File.join(RAILS_ROOT, 'lib')
-        end
-  
-        # Allow plugins to reference the current configuration object
-        def config
-          initializer.configuration
-        end
-  
-        def register_plugin_as_loaded
-          initializer.loaded_plugins << name
-        end
-  
-        # Evaluate in init.rb
-        def evaluate
-          silence_warnings { eval(IO.read(init_path), binding, init_path)} if has_init_file?
-        end
-      
-        def <=>(other_plugin_loader)
-          if explicit_plugin_loading_order?
-            if non_existent_plugin = [self, other_plugin_loader].detect {|plugin| !registered_plugins.include?(plugin.name)}
-              plugin_does_not_exist!(non_existent_plugin.name)
-            end
-            
-            registered_plugins.index(name) <=> registered_plugins.index(other_plugin_loader.name)
-          else
-            name <=> other_plugin_loader.name
-          end
-        end
-    end
-  end
-end

data/vendor/rails/railties/lib/rails/plugin/locator.rb

@@ -1,59 +0,0 @@
-module Rails
-  module Plugin
-    class Locator
-      include Enumerable
-      attr_reader :initializer
-      
-      def initialize(initializer)
-        @initializer = initializer
-      end
-      
-      def plugins
-        located_plugins.select(&:enabled?).sort
-      end
-      
-      def each(&block)
-        plugins.each(&block)
-      end
-      
-      def plugin_names
-        plugins.map(&:name)
-      end
-      
-      private
-        def located_plugins
-          raise "The `located_plugins' method must be defined by concrete subclasses of #{self.class}"
-        end
-    end
-    
-    class FileSystemLocator < Locator
-        private
-          def located_plugins
-            initializer.configuration.plugin_paths.flatten.inject([]) do |plugins, path|
-              plugins.concat locate_plugins_under(path)
-              plugins
-            end.flatten
-          end
-
-          # This starts at the base path looking for directories that pass the plugin_path? test of the Plugin::Loader.
-          # 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')
-          #     => 'acts_as_chunky_bacon' 
-          def locate_plugins_under(base_path)
-             Dir.glob(File.join(base_path, '*')).inject([]) do |plugins, path|
-              plugin_loader = initializer.configuration.plugin_loader.new(initializer, path)
-              if plugin_loader.plugin_path? && plugin_loader.enabled?
-                plugins << plugin_loader
-              elsif File.directory?(path)
-                plugins.concat locate_plugins_under(path)
-              end
-              plugins
-            end
-          end
-    end
-  end
-end

data/vendor/rails/railties/lib/rails/version.rb

@@ -1,9 +0,0 @@
-module Rails
-  module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 3
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end

data/vendor/rails/railties/lib/rails_generator.rb

@@ -1,43 +0,0 @@
-#--
-# Copyright (c) 2004 Jeremy Kemper
-#
-# 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.
-#++
-
-$:.unshift(File.dirname(__FILE__))
-$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
-
-begin
-  require 'active_support'  
-rescue LoadError
-  require 'rubygems'
-  gem 'activesupport'
-end
-
-require 'rails_generator/base'
-require 'rails_generator/lookup'
-require 'rails_generator/commands'
-
-Rails::Generator::Base.send(:include, Rails::Generator::Lookup)
-Rails::Generator::Base.send(:include, Rails::Generator::Commands)
-
-# Set up a default logger for convenience.
-require 'rails_generator/simple_logger'
-Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(STDOUT)

data/vendor/rails/railties/lib/rails_generator/base.rb

@@ -1,261 +0,0 @@
-require File.dirname(__FILE__) + '/options'
-require File.dirname(__FILE__) + '/manifest'
-require File.dirname(__FILE__) + '/spec'
-require File.dirname(__FILE__) + '/generated_attribute'
-
-module Rails
-  # Rails::Generator is a code generation platform tailored for the Rails
-  # web application framework.  Generators are easily invoked within Rails
-  # applications to add and remove components such as models and controllers.
-  # New generators are easy to create and may be distributed as RubyGems,
-  # tarballs, or Rails plugins for inclusion system-wide, per-user, 
-  # or per-application.
-  #
-  # For actual examples see the rails_generator/generators directory in the
-  # Rails source (or the +railties+ directory if you have frozen the Rails
-  # source in your application).
-  #
-  # Generators may subclass other generators to provide variations that
-  # require little or no new logic but replace the template files.
-  #
-  # For a RubyGem, put your generator class and templates in the +lib+
-  # directory. For a Rails plugin, make a +generators+ directory at the 
-  # root of your plugin.
-  #
-  # The layout of generator files can be seen in the built-in 
-  # +controller+ generator:
-  #   
-  #   generators/
-  #     controller/
-  #       controller_generator.rb
-  #       templates/
-  #         controller.rb
-  #         functional_test.rb
-  #         helper.rb
-  #         view.rhtml
-  #
-  # The directory name (+controller+) matches the name of the generator file
-  # (controller_generator.rb) and class (+ControllerGenerator+). The files
-  # that will be copied or used as templates are stored in the +templates+
-  # directory.
-  #
-  # The filenames of the templates don't matter, but choose something that
-  # will be self-explatatory since you will be referencing these in the 
-  # +manifest+ method inside your generator subclass.
-  #
-  # 
-  module Generator
-    class GeneratorError < StandardError; end
-    class UsageError < GeneratorError; end
-
-
-    # The base code generator is bare-bones.  It sets up the source and
-    # destination paths and tells the logger whether to keep its trap shut.
-    #
-    # It's useful for copying files such as stylesheets, images, or 
-    # javascripts.
-    #
-    # For more comprehensive template-based passive code generation with
-    # arguments, you'll want Rails::Generator::NamedBase. 
-    #
-    # Generators create a manifest of the actions they perform then hand
-    # the manifest to a command which replays the actions to do the heavy
-    # lifting (such as checking for existing files or creating directories
-    # if needed). Create, destroy, and list commands are included.  Since a
-    # single manifest may be used by any command, creating new generators is
-    # as simple as writing some code templates and declaring what you'd like
-    # to do with them.
-    #
-    # The manifest method must be implemented by subclasses, returning a
-    # Rails::Generator::Manifest.  The +record+ method is provided as a
-    # convenience for manifest creation.  Example:
-    #
-    #   class StylesheetGenerator < Rails::Generator::Base
-    #     def manifest
-    #       record do |m|
-    #         m.directory('public/stylesheets')
-    #         m.file('application.css', 'public/stylesheets/application.css')
-    #       end
-    #     end
-    #   end
-    #
-    # See Rails::Generator::Commands::Create for a list of methods available
-    # to the manifest.
-    class Base
-      include Options
-
-      # Declare default options for the generator.  These options
-      # are inherited to subclasses.
-      default_options :collision => :ask, :quiet => false
-
-      # A logger instance available everywhere in the generator.
-      cattr_accessor :logger
-
-      # Every generator that is dynamically looked up is tagged with a
-      # Spec describing where it was found.
-      class_inheritable_accessor :spec
-
-      attr_reader :source_root, :destination_root, :args
-
-      def initialize(runtime_args, runtime_options = {})
-        @args = runtime_args
-        parse!(@args, runtime_options)
-
-        # Derive source and destination paths.
-        @source_root = options[:source] || File.join(spec.path, 'templates')
-        if options[:destination]
-          @destination_root = options[:destination]
-        elsif defined? ::RAILS_ROOT
-          @destination_root = ::RAILS_ROOT
-        end
-
-        # Silence the logger if requested.
-        logger.quiet = options[:quiet]
-
-        # Raise usage error if help is requested.
-        usage if options[:help]
-      end
-
-      # Generators must provide a manifest.  Use the +record+ method to create
-      # a new manifest and record your generator's actions.
-      def manifest
-        raise NotImplementedError, "No manifest for '#{spec.name}' generator."
-      end
-
-      # Return the full path from the source root for the given path.
-      # Example for source_root = '/source':
-      #   source_path('some/path.rb') == '/source/some/path.rb'
-      #
-      # The given path may include a colon ':' character to indicate that
-      # the file belongs to another generator.  This notation allows any
-      # generator to borrow files from another.  Example:
-      #   source_path('model:fixture.yml') = '/model/source/path/fixture.yml'
-      def source_path(relative_source)
-        # Check whether we're referring to another generator's file.
-        name, path = relative_source.split(':', 2)
-
-        # If not, return the full path to our source file.
-        if path.nil?
-          File.join(source_root, name)
-
-        # Otherwise, ask our referral for the file.
-        else
-          # FIXME: this is broken, though almost always true.  Others'
-          # source_root are not necessarily the templates dir.
-          File.join(self.class.lookup(name).path, 'templates', path)
-        end
-      end
-
-      # Return the full path from the destination root for the given path.
-      # Example for destination_root = '/dest':
-      #   destination_path('some/path.rb') == '/dest/some/path.rb'
-      def destination_path(relative_destination)
-        File.join(destination_root, relative_destination)
-      end
-
-      protected
-        # Convenience method for generator subclasses to record a manifest.
-        def record
-          Rails::Generator::Manifest.new(self) { |m| yield m }
-        end
-
-        # Override with your own usage banner.
-        def banner
-          "Usage: #{$0} #{spec.name} [options]"
-        end
-
-        # Read USAGE from file in generator base path.
-        def usage_message
-          File.read(File.join(spec.path, 'USAGE')) rescue ''
-        end
-    end
-
-
-    # The base generator for named components: models, controllers, mailers,
-    # etc.  The target name is taken as the first argument and inflected to
-    # singular, plural, class, file, and table forms for your convenience.
-    # The remaining arguments are aliased to +actions+ as an array for 
-    # controller and mailer convenience.
-    #
-    # Several useful local variables and methods are populated in the 
-    # +initialize+ method. See below for a list of Attributes and
-    # External Aliases available to both the manifest and to all templates.    
-    #
-    # If no name is provided, the generator raises a usage error with content
-    # optionally read from the USAGE file in the generator's base path.
-    #
-    # For example, the +controller+ generator takes the first argument as 
-    # the name of the class and subsequent arguments as the names of
-    # actions to be generated:
-    #
-    #   ./script/generate controller Article index new create
-    #
-    # See Rails::Generator::Base for a discussion of manifests, 
-    # Rails::Generator::Commands::Create for methods available to the manifest,
-    # and Rails::Generator for a general discussion of generators.
-    class NamedBase < Base
-      attr_reader   :name, :class_name, :singular_name, :plural_name, :table_name
-      attr_reader   :class_path, :file_path, :class_nesting, :class_nesting_depth
-      alias_method  :file_name,  :singular_name
-      alias_method  :actions, :args
-
-      def initialize(runtime_args, runtime_options = {})
-        super
-
-        # Name argument is required.
-        usage if runtime_args.empty?
-
-        @args = runtime_args.dup
-        base_name = @args.shift
-        assign_names!(base_name)
-      end
-
-      protected
-        # Override with your own usage banner.
-        def banner
-          "Usage: #{$0} #{spec.name} #{spec.name.camelize}Name [options]"
-        end
-    
-        def attributes
-          @attributes ||= @args.collect do |attribute|
-            Rails::Generator::GeneratedAttribute.new(*attribute.split(":"))
-          end
-        end
-
-
-      private
-        def assign_names!(name)
-          @name = name
-          base_name, @class_path, @file_path, @class_nesting, @class_nesting_depth = extract_modules(@name)
-          @class_name_without_nesting, @singular_name, @plural_name = inflect_names(base_name)
-          @table_name = ActiveRecord::Base.pluralize_table_names ? plural_name : singular_name
-          if @class_nesting.empty?
-            @class_name = @class_name_without_nesting
-          else
-            @table_name = @class_nesting.underscore << "_" << @table_name
-            @class_name = "#{@class_nesting}::#{@class_name_without_nesting}"
-          end
-        end
-
-        # Extract modules from filesystem-style or ruby-style path:
-        #   good/fun/stuff
-        #   Good::Fun::Stuff
-        # produce the same results.
-        def extract_modules(name)
-          modules = name.include?('/') ? name.split('/') : name.split('::')
-          name    = modules.pop
-          path    = modules.map { |m| m.underscore }
-          file_path = (path + [name.underscore]).join('/')
-          nesting = modules.map { |m| m.camelize }.join('::')
-          [name, path, file_path, nesting, modules.size]
-        end
-
-        def inflect_names(name)
-          camel  = name.camelize
-          under  = camel.underscore
-          plural = under.pluralize
-          [camel, under, plural]
-        end
-    end
-  end
-end