--- /dev/null
+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
+
+ 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
+ @table_name.gsub! '/', '_'
+ 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
projects / depot.git / blobdiff