rails_csi 2.3.5.p6

data/lib/rails/vendor_gem_source_index.rb

@@ -0,0 +1,140 @@
+require 'rubygems'
+require 'yaml'
+
+module Rails
+
+  class VendorGemSourceIndex
+    # VendorGemSourceIndex acts as a proxy for the Gem source index, allowing
+    # gems to be loaded from vendor/gems. Rather than the standard gem repository format,
+    # vendor/gems contains unpacked gems, with YAML specifications in .specification in
+    # each gem directory.
+    include Enumerable
+
+    attr_reader :installed_source_index
+    attr_reader :vendor_source_index
+
+    @@silence_spec_warnings = false
+
+    def self.silence_spec_warnings
+      @@silence_spec_warnings
+    end
+
+    def self.silence_spec_warnings=(v)
+      @@silence_spec_warnings = v
+    end
+
+    def initialize(installed_index, vendor_dir=Rails::GemDependency.unpacked_path)
+      @installed_source_index = installed_index
+      @vendor_dir = vendor_dir
+      refresh!
+    end
+
+    def refresh!
+      # reload the installed gems
+      @installed_source_index.refresh!
+      vendor_gems = {}
+
+      # handle vendor Rails gems - they are identified by having loaded_from set to ""
+      # we add them manually to the list, so that other gems can find them via dependencies
+      Gem.loaded_specs.each do |n, s|
+        next unless s.loaded_from.empty?
+        vendor_gems[s.full_name] = s
+      end
+
+      # load specifications from vendor/gems
+      Dir[File.join(Rails::GemDependency.unpacked_path, '*')].each do |d|
+        dir_name = File.basename(d)
+        dir_version = version_for_dir(dir_name)
+        spec = load_specification(d)
+        if spec
+          if spec.full_name != dir_name
+            # mismatched directory name and gem spec - produced by 2.1.0-era unpack code
+            if dir_version
+              # fix the spec version - this is not optimal (spec.files may be wrong)
+              # but it's better than breaking apps. Complain to remind users to get correct specs.
+              # use ActiveSupport::Deprecation.warn, as the logger is not set yet
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has a mismatched specification file."+
+                           " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+              spec.version = dir_version
+            else
+              $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems is not in a versioned directory"+
+                           "(should be #{spec.full_name}).") unless @@silence_spec_warnings
+              # continue, assume everything is OK
+            end
+          end
+        else
+          # no spec - produced by early-2008 unpack code
+          # emulate old behavior, and complain.
+          $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems has no specification file."+
+                       " Run 'rake gems:refresh_specs' to fix this.") unless @@silence_spec_warnings
+          if dir_version
+            spec = Gem::Specification.new
+            spec.version = dir_version
+            spec.require_paths = ['lib']
+            ext_path = File.join(d, 'ext')
+            spec.require_paths << 'ext' if File.exist?(ext_path)
+            spec.name = /^(.*)-[^-]+$/.match(dir_name)[1]
+            files = ['lib']
+            # set files to everything in lib/
+            files += Dir[File.join(d, 'lib', '*')].map { |v| v.gsub(/^#{d}\//, '') }
+            files += Dir[File.join(d, 'ext', '*')].map { |v| v.gsub(/^#{d}\//, '') } if ext_path
+            spec.files = files
+          else
+            $stderr.puts("config.gem: Unpacked gem #{dir_name} in vendor/gems not in a versioned directory."+
+                         " Giving up.") unless @@silence_spec_warnings
+            next
+          end
+        end
+        spec.loaded_from = File.join(d, '.specification')
+        # finally, swap out full_gem_path
+        # it would be better to use a Gem::Specification subclass, but the YAML loads an explicit class
+        class << spec
+          def full_gem_path
+            path = File.join installation_path, full_name
+            return path if File.directory? path
+            File.join installation_path, original_name
+          end
+        end
+        vendor_gems[File.basename(d)] = spec
+      end
+      @vendor_source_index = Gem::SourceIndex.new(vendor_gems)
+    end
+
+    def version_for_dir(d)
+      matches = /-([^-]+)$/.match(d)
+      Gem::Version.new(matches[1]) if matches
+    end
+
+    def load_specification(gem_dir)
+      spec_file = File.join(gem_dir, '.specification')
+      YAML.load_file(spec_file) if File.exist?(spec_file)
+    end
+
+    def find_name(*args)
+      @installed_source_index.find_name(*args) + @vendor_source_index.find_name(*args)
+    end
+
+    def search(*args)
+      # look for vendor gems, and then installed gems - later elements take priority
+      @installed_source_index.search(*args) + @vendor_source_index.search(*args)
+    end
+
+    def each(&block)
+      @vendor_source_index.each(&block)
+      @installed_source_index.each(&block)
+    end
+
+    def add_spec(spec)
+      @vendor_source_index.add_spec spec
+    end
+
+    def remove_spec(spec)
+      @vendor_source_index.remove_spec spec
+    end
+
+    def size
+      @vendor_source_index.size + @installed_source_index.size
+    end
+
+  end
+end

data/lib/rails/version.rb

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

data/lib/rails_generator.rb

@@ -0,0 +1,43 @@
+#--
+# 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/lib/rails_generator/base.rb

@@ -0,0 +1,266 @@
+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/
+  #     components/
+  #       controller/
+  #         controller_generator.rb
+  #         templates/
+  #           controller.rb
+  #           functional_test.rb
+  #           helper.rb
+  #           view.html.erb
+  #
+  # 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-explanatory 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
+
+      def after_generate
+      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 = (!defined?(ActiveRecord::Base) || 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
+          @table_name.gsub! '/', '_'
+        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