rails 2.3.18 → 7.1.3.4

data/lib/rails_generator/generators/components/scaffold/templates/view_edit.html.erb

@@ -1,18 +0,0 @@
-<h1>Editing <%= singular_name %></h1>
-
-<%% form_for(@<%= singular_name %>) do |f| %>
-  <%%= f.error_messages %>
-
-<% for attribute in attributes -%>
-  <p>
-    <%%= f.label :<%= attribute.name %> %><br />
-    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
-  </p>
-<% end -%>
-  <p>
-    <%%= f.submit 'Update' %>
-  </p>
-<%% end %>
-
-<%%= link_to 'Show', @<%= singular_name %> %> |
-<%%= link_to 'Back', <%= plural_name %>_path %>

data/lib/rails_generator/generators/components/scaffold/templates/view_index.html.erb

@@ -1,24 +0,0 @@
-<h1>Listing <%= plural_name %></h1>
-
-<table>
-  <tr>
-<% for attribute in attributes -%>
-    <th><%= attribute.column.human_name %></th>
-<% end -%>
-  </tr>
-
-<%% @<%= plural_name %>.each do |<%= singular_name %>| %>
-  <tr>
-<% for attribute in attributes -%>
-    <td><%%=h <%= singular_name %>.<%= attribute.name %> %></td>
-<% end -%>
-    <td><%%= link_to 'Show', <%= singular_name %> %></td>
-    <td><%%= link_to 'Edit', edit_<%= singular_name %>_path(<%= singular_name %>) %></td>
-    <td><%%= link_to 'Destroy', <%= singular_name %>, :confirm => 'Are you sure?', :method => :delete %></td>
-  </tr>
-<%% end %>
-</table>
-
-<br />
-
-<%%= link_to 'New <%= singular_name %>', new_<%= singular_name %>_path %>

data/lib/rails_generator/generators/components/scaffold/templates/view_new.html.erb

@@ -1,17 +0,0 @@
-<h1>New <%= singular_name %></h1>
-
-<%% form_for(@<%= singular_name %>) do |f| %>
-  <%%= f.error_messages %>
-
-<% for attribute in attributes -%>
-  <p>
-    <%%= f.label :<%= attribute.name %> %><br />
-    <%%= f.<%= attribute.field_type %> :<%= attribute.name %> %>
-  </p>
-<% end -%>
-  <p>
-    <%%= f.submit 'Create' %>
-  </p>
-<%% end %>
-
-<%%= link_to 'Back', <%= plural_name %>_path %>

data/lib/rails_generator/generators/components/scaffold/templates/view_show.html.erb

@@ -1,10 +0,0 @@
-<% for attribute in attributes -%>
-<p>
-  <b><%= attribute.column.human_name %>:</b>
-  <%%=h @<%= singular_name %>.<%= attribute.name %> %>
-</p>
-
-<% end -%>
-
-<%%= link_to 'Edit', edit_<%= singular_name %>_path(@<%= singular_name %>) %> |
-<%%= link_to 'Back', <%= plural_name %>_path %>

data/lib/rails_generator/generators/components/session_migration/USAGE

@@ -1,10 +0,0 @@
-Description:
-    Creates a migration to add the sessions table used by the Active Record
-    session store. Pass the migration name, either CamelCased or under_scored,
-    as an argument.
-
-Example:
-    `./script/generate session_migration CreateSessionTable`
-
-    With 4 existing migrations, this creates the AddSessionTable migration
-    in db/migrate/005_add_session_table.rb

data/lib/rails_generator/generators/components/session_migration/session_migration_generator.rb

@@ -1,18 +0,0 @@
-class SessionMigrationGenerator < Rails::Generator::NamedBase
-  def initialize(runtime_args, runtime_options = {})
-    runtime_args << 'add_session_table' if runtime_args.empty?
-    super
-  end
-
-  def manifest
-    record do |m|
-      m.migration_template 'migration.rb', 'db/migrate',
-        :assigns => { :session_table_name => default_session_table_name }
-    end
-  end
-
-  protected
-    def default_session_table_name
-      ActiveRecord::Base.pluralize_table_names ? 'session'.pluralize : 'session'
-    end
-end

data/lib/rails_generator/generators/components/session_migration/templates/migration.rb

@@ -1,16 +0,0 @@
-class <%= class_name %> < ActiveRecord::Migration
-  def self.up
-    create_table :<%= session_table_name %> do |t|
-      t.string :session_id, :null => false
-      t.text :data
-      t.timestamps
-    end
-
-    add_index :<%= session_table_name %>, :session_id
-    add_index :<%= session_table_name %>, :updated_at
-  end
-
-  def self.down
-    drop_table :<%= session_table_name %>
-  end
-end

data/lib/rails_generator/lookup.rb

@@ -1,249 +0,0 @@
-require 'pathname'
-
-require File.dirname(__FILE__) + '/spec'
-
-class Object
-  class << self
-    # Lookup missing generators using const_missing.  This allows any
-    # generator to reference another without having to know its location:
-    # RubyGems, ~/.rails/generators, and RAILS_ROOT/generators.
-    def lookup_missing_generator(class_id)
-      if md = /(.+)Generator$/.match(class_id.to_s)
-        name = md.captures.first.demodulize.underscore
-        Rails::Generator::Base.lookup(name).klass
-      else
-        const_missing_before_generators(class_id)
-      end
-    end
-
-    unless respond_to?(:const_missing_before_generators)
-      alias_method :const_missing_before_generators, :const_missing
-      alias_method :const_missing, :lookup_missing_generator
-    end
-  end
-end
-
-# User home directory lookup adapted from RubyGems.
-def Dir.user_home
-  if ENV['HOME']
-    ENV['HOME']
-  elsif ENV['USERPROFILE']
-    ENV['USERPROFILE']
-  elsif ENV['HOMEDRIVE'] and ENV['HOMEPATH']
-    "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
-  else
-    File.expand_path '~'
-  end
-end
-
-
-module Rails
-  module Generator
-
-    # Generator lookup is managed by a list of sources which return specs
-    # describing where to find and how to create generators.  This module
-    # provides class methods for manipulating the source list and looking up
-    # generator specs, and an #instance wrapper for quickly instantiating
-    # generators by name.
-    #
-    # A spec is not a generator:  it's a description of where to find
-    # the generator and how to create it.  A source is anything that
-    # yields generators from #each.  PathSource and GemGeneratorSource are provided.
-    module Lookup
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.use_component_sources!
-      end
-
-      # Convenience method to instantiate another generator.
-      def instance(generator_name, args, runtime_options = {})
-        self.class.instance(generator_name, args, runtime_options)
-      end
-
-      module ClassMethods
-        # The list of sources where we look, in order, for generators.
-        def sources
-          read_inheritable_attribute(:sources) or use_component_sources!
-        end
-
-        # Add a source to the end of the list.
-        def append_sources(*args)
-          sources.concat(args.flatten)
-          invalidate_cache!
-        end
-
-        # Add a source to the beginning of the list.
-        def prepend_sources(*args)
-          write_inheritable_array(:sources, args.flatten + sources)
-          invalidate_cache!
-        end
-
-        # Reset the source list.
-        def reset_sources
-          write_inheritable_attribute(:sources, [])
-          invalidate_cache!
-        end
-
-        # Use application generators (app, ?).
-        def use_application_sources!
-          reset_sources
-          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/applications")
-        end
-
-        # Use component generators (model, controller, etc).
-        # 1.  Rails application.  If RAILS_ROOT is defined we know we're
-        #     generating in the context of a Rails application, so search
-        #     RAILS_ROOT/generators.
-        # 2.  Look in plugins, either for generators/ or rails_generators/ 
-        #     directories within each plugin
-        # 3.  User home directory.  Search ~/.rails/generators.
-        # 4.  RubyGems.  Search for gems named *_generator, and look for 
-        #     generators within any RubyGem's 
-        #     /rails_generators/<generator_name>_generator.rb file.
-        # 5.  Builtins.  Model, controller, mailer, scaffold, and so on.
-        def use_component_sources!
-          reset_sources
-          if defined? ::RAILS_ROOT
-            sources << PathSource.new(:lib, "#{::RAILS_ROOT}/lib/generators")
-            sources << PathSource.new(:vendor, "#{::RAILS_ROOT}/vendor/generators")
-            Rails.configuration.plugin_paths.each do |path|
-              relative_path = Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(::RAILS_ROOT))
-              sources << PathSource.new(:"plugins (#{relative_path})", "#{path}/*/**/{,rails_}generators")
-            end
-          end
-          sources << PathSource.new(:user, "#{Dir.user_home}/.rails/generators")
-          if Object.const_defined?(:Gem)
-            sources << GemGeneratorSource.new
-            sources << GemPathSource.new
-          end
-          sources << PathSource.new(:builtin, "#{File.dirname(__FILE__)}/generators/components")
-        end
-
-        # Lookup knows how to find generators' Specs from a list of Sources.
-        # Searches the sources, in order, for the first matching name.
-        def lookup(generator_name)
-          @found ||= {}
-          generator_name = generator_name.to_s.downcase
-          @found[generator_name] ||= cache.find { |spec| spec.name == generator_name }
-          unless @found[generator_name] 
-            chars = generator_name.scan(/./).map{|c|"#{c}.*?"}
-            rx = /^#{chars}$/
-            gns = cache.select{|spec| spec.name =~ rx }
-            @found[generator_name] ||= gns.first if gns.length == 1
-            raise GeneratorError, "Pattern '#{generator_name}' matches more than one generator: #{gns.map{|sp|sp.name}.join(', ')}" if gns.length > 1
-          end
-          @found[generator_name] or raise GeneratorError, "Couldn't find '#{generator_name}' generator"
-        end
-
-        # Convenience method to lookup and instantiate a generator.
-        def instance(generator_name, args = [], runtime_options = {})
-          lookup(generator_name).klass.new(args, full_options(runtime_options))
-        end
-
-        private
-          # Lookup and cache every generator from the source list.
-          def cache
-            @cache ||= sources.inject([]) { |cache, source| cache + source.to_a }
-          end
-
-          # Clear the cache whenever the source list changes.
-          def invalidate_cache!
-            @cache = nil
-          end
-      end
-    end
-
-    # Sources enumerate (yield from #each) generator specs which describe
-    # where to find and how to create generators.  Enumerable is mixed in so,
-    # for example, source.collect will retrieve every generator.
-    # Sources may be assigned a label to distinguish them.
-    class Source
-      include Enumerable
-
-      attr_reader :label
-      def initialize(label)
-        @label = label
-      end
-
-      # The each method must be implemented in subclasses.
-      # The base implementation raises an error.
-      def each
-        raise NotImplementedError
-      end
-
-      # Return a convenient sorted list of all generator names.
-      def names
-        map { |spec| spec.name }.sort
-      end
-    end
-
-
-    # PathSource looks for generators in a filesystem directory.
-    class PathSource < Source
-      attr_reader :path
-
-      def initialize(label, path)
-        super label
-        @path = path
-      end
-
-      # Yield each eligible subdirectory.
-      def each
-        Dir["#{path}/[a-z]*"].each do |dir|
-          if File.directory?(dir)
-            yield Spec.new(File.basename(dir), dir, label)
-          end
-        end
-      end
-    end
-
-    class AbstractGemSource < Source
-      def initialize
-        super :RubyGems
-      end
-    end
-
-    # GemGeneratorSource hits the mines to quarry for generators.  The latest versions
-    # of gems named *_generator are selected.
-    class GemGeneratorSource < AbstractGemSource
-      # Yield latest versions of generator gems.
-      def each
-        dependency = Gem::Dependency.new(/_generator$/, Gem::Requirement.default)
-        Gem::cache.search(dependency).inject({}) { |latest, gem|
-          hem = latest[gem.name]
-          latest[gem.name] = gem if hem.nil? or gem.version > hem.version
-          latest
-        }.values.each { |gem|
-          yield Spec.new(gem.name.sub(/_generator$/, ''), gem.full_gem_path, label)
-        }
-      end
-    end
-
-    # GemPathSource looks for generators within any RubyGem's /rails_generators/<generator_name>_generator.rb file.
-    class GemPathSource < AbstractGemSource
-      # Yield each generator within rails_generator subdirectories.
-      def each
-        generator_full_paths.each do |generator|
-          yield Spec.new(File.basename(generator).sub(/_generator.rb$/, ''), File.dirname(generator), label)
-        end
-      end
-
-      private
-        def generator_full_paths
-          @generator_full_paths ||=
-            Gem::cache.inject({}) do |latest, name_gem|
-              name, gem = name_gem
-              hem = latest[gem.name]
-              latest[gem.name] = gem if hem.nil? or gem.version > hem.version
-              latest
-            end.values.inject([]) do |mem, gem|
-              Dir[gem.full_gem_path + '/{rails_,}generators/**/*_generator.rb'].each do |generator|
-                mem << generator
-              end
-              mem
-            end
-        end
-    end
-
-  end
-end

data/lib/rails_generator/manifest.rb

@@ -1,53 +0,0 @@
-module Rails
-  module Generator
-
-    # Manifest captures the actions a generator performs.  Instantiate
-    # a manifest with an optional target object, hammer it with actions,
-    # then replay or rewind on the object of your choice.
-    #
-    # Example:
-    #   manifest = Manifest.new { |m|
-    #     m.make_directory '/foo'
-    #     m.create_file '/foo/bar.txt'
-    #   }
-    #   manifest.replay(creator)
-    #   manifest.rewind(destroyer)
-    class Manifest
-      attr_reader :target
-
-      # Take a default action target.  Yield self if block given.
-      def initialize(target = nil)
-        @target, @actions = target, []
-        yield self if block_given?
-      end
-
-      # Record an action.
-      def method_missing(action, *args, &block)
-        @actions << [action, args, block]
-      end
-
-      # Replay recorded actions.
-      def replay(target = nil)
-        send_actions(target || @target, @actions)
-      end
-
-      # Rewind recorded actions.
-      def rewind(target = nil)
-        send_actions(target || @target, @actions.reverse)
-      end
-
-      # Erase recorded actions.
-      def erase
-        @actions = []
-      end
-
-      private
-        def send_actions(target, actions)
-          actions.each do |method, args, block|
-            target.send(method, *args, &block)
-          end
-        end
-    end
-
-  end
-end

data/lib/rails_generator/options.rb

@@ -1,150 +0,0 @@
-require 'optparse'
-
-module Rails
-  module Generator
-    module Options
-      def self.included(base)
-        base.extend(ClassMethods)
-        class << base
-          if respond_to?(:inherited)
-            alias_method :inherited_without_options, :inherited
-          end
-          alias_method :inherited, :inherited_with_options
-        end
-      end
-
-      module ClassMethods
-        def inherited_with_options(sub)
-          inherited_without_options(sub) if respond_to?(:inherited_without_options)
-          sub.extend(Rails::Generator::Options::ClassMethods)
-        end
-
-        def mandatory_options(options = nil)
-          if options
-            write_inheritable_attribute(:mandatory_options, options)
-          else
-            read_inheritable_attribute(:mandatory_options) or write_inheritable_attribute(:mandatory_options, {})
-          end
-        end
-
-        def default_options(options = nil)
-          if options
-            write_inheritable_attribute(:default_options, options)
-          else
-            read_inheritable_attribute(:default_options) or write_inheritable_attribute(:default_options, {})
-          end
-        end
-
-        # Merge together our class options.  In increasing precedence:
-        #   default_options   (class default options)
-        #   runtime_options   (provided as argument)
-        #   mandatory_options (class mandatory options)
-        def full_options(runtime_options = {})
-          default_options.merge(runtime_options).merge(mandatory_options)
-        end
-
-      end
-
-      # Each instance has an options hash that's populated by #parse.
-      def options
-        @options ||= {}
-      end
-      attr_writer :options
-
-      protected
-        # Convenient access to class mandatory options.
-        def mandatory_options
-          self.class.mandatory_options
-        end
-
-        # Convenient access to class default options.
-        def default_options
-          self.class.default_options
-        end
-
-        # Merge together our instance options.  In increasing precedence:
-        #   default_options   (class default options)
-        #   options           (instance options)
-        #   runtime_options   (provided as argument)
-        #   mandatory_options (class mandatory options)
-        def full_options(runtime_options = {})
-          self.class.full_options(options.merge(runtime_options))
-        end
-
-        # Parse arguments into the options hash.  Classes may customize
-        # parsing behavior by overriding these methods:
-        #   #banner                 Usage: ./script/generate [options]
-        #   #add_options!           Options:
-        #                             some options..
-        #   #add_general_options!   General Options:
-        #                             general options..
-        def parse!(args, runtime_options = {})
-          self.options = {}
-
-          @option_parser = OptionParser.new do |opt|
-            opt.banner = banner
-            add_options!(opt)
-            add_general_options!(opt)
-            opt.parse!(args)
-          end
-
-          return args
-        ensure
-          self.options = full_options(runtime_options)
-        end
-
-        # Raise a usage error.  Override usage_message to provide a blurb
-        # after the option parser summary.
-        def usage(message = usage_message)
-          raise UsageError, "#{@option_parser}\n#{message}"
-        end
-
-        def usage_message
-          ''
-        end
-
-        # Override with your own usage banner.
-        def banner
-          "Usage: #{$0} [options]"
-        end
-
-        # Override to add your options to the parser:
-        #   def add_options!(opt)
-        #     opt.on('-v', '--verbose') { |value| options[:verbose] = value }
-        #   end
-        def add_options!(opt)
-        end
-
-        # Adds general options like -h and --quiet.  Usually don't override.
-        def add_general_options!(opt)
-          opt.separator ''
-          opt.separator 'Rails Info:'
-          opt.on('-v', '--version', 'Show the Rails version number and quit.')
-          opt.on('-h', '--help', 'Show this help message and quit.') { |v| options[:help] = v }
-
-          opt.separator ''
-          opt.separator 'General Options:'
-
-          opt.on('-p', '--pretend', 'Run but do not make any changes.') { |v| options[:pretend] = v }
-          opt.on('-f', '--force', 'Overwrite files that already exist.') { options[:collision] = :force }
-          opt.on('-s', '--skip', 'Skip files that already exist.') { options[:collision] = :skip }
-          opt.on('-q', '--quiet', 'Suppress normal output.') { |v| options[:quiet] = v }
-          opt.on('-t', '--backtrace', 'Debugging: show backtrace on errors.') { |v| options[:backtrace] = v }
-          opt.on('-c', '--svn', 'Modify files with subversion. (Note: svn must be in path)') do
-            options[:svn] = {}
-            `svn status`.each_line do |line|
-              options[:svn][line.chomp[7..-1]] = true
-            end
-          end
-          opt.on('-g', '--git', 'Modify files with git. (Note: git must be in path)') do
-            options[:git] = {:new => {}, :modified => {}}
-            `git status`.each_line do |line|
-              options[:git][:new][line.chomp[14..-1]] = true if line =~ /new file:/
-              options[:git][:modified][line.chomp[14..-1]] = true if line =~ /modified:/
-            end
-          end
-        end
-
-    end
-  end
-end

data/lib/rails_generator/scripts/destroy.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/../scripts'
-
-module Rails::Generator::Scripts
-  class Destroy < Base
-    mandatory_options :command => :destroy
-
-    protected
-    def usage_message
-      usage = "\nInstalled Generators\n"
-      Rails::Generator::Base.sources.each do |source|
-        label = source.label.to_s.capitalize
-        names = source.names
-        usage << "  #{label}: #{names.join(', ')}\n" unless names.empty?
-      end
-
-      usage << <<end_blurb
-
-script/generate command. For instance, 'script/destroy migration CreatePost'
-will delete the appropriate XXX_create_post.rb migration file in db/migrate,
-while 'script/destroy scaffold Post' will delete the posts controller and
-views, post model and migration, all associated tests, and the map.resources
-:posts line in config/routes.rb.
-
-For instructions on finding new generators, run script/generate.
-end_blurb
-      return usage
-    end
-  end
-end

data/lib/rails_generator/scripts/generate.rb

@@ -1,7 +0,0 @@
-require File.dirname(__FILE__) + '/../scripts'
-
-module Rails::Generator::Scripts
-  class Generate < Base
-    mandatory_options :command => :create
-  end
-end

data/lib/rails_generator/scripts/update.rb

@@ -1,12 +0,0 @@
-require File.dirname(__FILE__) + '/../scripts'
-
-module Rails::Generator::Scripts
-  class Update < Base
-    mandatory_options :command => :update
-
-    protected
-      def banner
-        "Usage: #{$0} [options] scaffold"
-      end
-  end
-end