mirror of
https://github.com/rails/rails.git
synced 2022-11-09 12:12:34 -05:00
45e60283e7
If you have existing Metals, you have a few options: * if your metal behaves like a middleware, add it to the middleware stack via config.middleware.use. You can use methods on the middleware stack to control exactly where it should go * if it behaves like a Rack endpoint, you can link to it in the router. This will result in more optimal routing time, and allows you to remove code in your endpoint that matches specific URLs in favor of the more powerful handling in the router itself. For the future, you can use ActionController::Metal to get a very fast controller with the ability to opt-in to specific controller features without paying the penalty of the full controller stack. Since Rails 3 is closer to Rack, the Metal abstraction is no longer needed.
375 lines
13 KiB
Ruby
375 lines
13 KiB
Ruby
begin
|
|
require 'thor/group'
|
|
rescue LoadError
|
|
puts "Thor is not available.\nIf you ran this command from a git checkout " \
|
|
"of Rails, please make sure thor is installed,\nand run this command " \
|
|
"as `ruby /path/to/rails myapp --dev`"
|
|
exit
|
|
end
|
|
|
|
require 'rails/generators/actions'
|
|
|
|
module Rails
|
|
module Generators
|
|
class Error < Thor::Error
|
|
end
|
|
|
|
class Base < Thor::Group
|
|
include Thor::Actions
|
|
include Rails::Generators::Actions
|
|
|
|
add_runtime_options!
|
|
|
|
# Returns the source root for this generator using default_source_root as default.
|
|
def self.source_root(path=nil)
|
|
@_source_root = path if path
|
|
@_source_root ||= default_source_root
|
|
end
|
|
|
|
# Tries to get the description from a USAGE file one folder above the source
|
|
# root otherwise uses a default description.
|
|
def self.desc(description=nil)
|
|
return super if description
|
|
usage = source_root && File.expand_path("../USAGE", source_root)
|
|
|
|
@desc ||= if usage && File.exist?(usage)
|
|
File.read(usage)
|
|
else
|
|
"Description:\n Create #{base_name.humanize.downcase} files for #{generator_name} generator."
|
|
end
|
|
end
|
|
|
|
# Convenience method to get the namespace from the class name. It's the
|
|
# same as Thor default except that the Generator at the end of the class
|
|
# is removed.
|
|
def self.namespace(name=nil)
|
|
return super if name
|
|
@namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':')
|
|
end
|
|
|
|
# Invoke a generator based on the value supplied by the user to the
|
|
# given option named "name". A class option is created when this method
|
|
# is invoked and you can set a hash to customize it.
|
|
#
|
|
# ==== Examples
|
|
#
|
|
# module Rails::Generators
|
|
# class ControllerGenerator < Base
|
|
# hook_for :test_framework, :aliases => "-t"
|
|
# end
|
|
# end
|
|
#
|
|
# The example above will create a test framework option and will invoke
|
|
# a generator based on the user supplied value.
|
|
#
|
|
# For example, if the user invoke the controller generator as:
|
|
#
|
|
# rails generate controller Account --test-framework=test_unit
|
|
#
|
|
# The controller generator will then try to invoke the following generators:
|
|
#
|
|
# "rails:test_unit", "test_unit:controller", "test_unit"
|
|
#
|
|
# Notice that "rails:generators:test_unit" could be loaded as well, what
|
|
# Rails looks for is the first and last parts of the namespace. This is what
|
|
# allows any test framework to hook into Rails as long as it provides any
|
|
# of the hooks above.
|
|
#
|
|
# ==== Options
|
|
#
|
|
# The first and last part used to find the generator to be invoked are
|
|
# guessed based on class invokes hook_for, as noticed in the example above.
|
|
# This can be customized with two options: :base and :as.
|
|
#
|
|
# Let's suppose you are creating a generator that needs to invoke the
|
|
# controller generator from test unit. Your first attempt is:
|
|
#
|
|
# class AwesomeGenerator < Rails::Generators::Base
|
|
# hook_for :test_framework
|
|
# end
|
|
#
|
|
# The lookup in this case for test_unit as input is:
|
|
#
|
|
# "test_unit:awesome", "test_unit"
|
|
#
|
|
# Which is not the desired the lookup. You can change it by providing the
|
|
# :as option:
|
|
#
|
|
# class AwesomeGenerator < Rails::Generators::Base
|
|
# hook_for :test_framework, :as => :controller
|
|
# end
|
|
#
|
|
# And now it will lookup at:
|
|
#
|
|
# "test_unit:controller", "test_unit"
|
|
#
|
|
# Similarly, if you want it to also lookup in the rails namespace, you just
|
|
# need to provide the :base value:
|
|
#
|
|
# class AwesomeGenerator < Rails::Generators::Base
|
|
# hook_for :test_framework, :in => :rails, :as => :controller
|
|
# end
|
|
#
|
|
# And the lookup is exactly the same as previously:
|
|
#
|
|
# "rails:test_unit", "test_unit:controller", "test_unit"
|
|
#
|
|
# ==== Switches
|
|
#
|
|
# All hooks come with switches for user interface. If the user don't want
|
|
# to use any test framework, he can do:
|
|
#
|
|
# rails generate controller Account --skip-test-framework
|
|
#
|
|
# Or similarly:
|
|
#
|
|
# rails generate controller Account --no-test-framework
|
|
#
|
|
# ==== Boolean hooks
|
|
#
|
|
# In some cases, you want to provide a boolean hook. For example, webrat
|
|
# developers might want to have webrat available on controller generator.
|
|
# This can be achieved as:
|
|
#
|
|
# Rails::Generators::ControllerGenerator.hook_for :webrat, :type => :boolean
|
|
#
|
|
# Then, if you want, webrat to be invoked, just supply:
|
|
#
|
|
# rails generate controller Account --webrat
|
|
#
|
|
# The hooks lookup is similar as above:
|
|
#
|
|
# "rails:generators:webrat", "webrat:generators:controller", "webrat"
|
|
#
|
|
# ==== Custom invocations
|
|
#
|
|
# You can also supply a block to hook_for to customize how the hook is
|
|
# going to be invoked. The block receives two arguments, an instance
|
|
# of the current class and the klass to be invoked.
|
|
#
|
|
# For example, in the resource generator, the controller should be invoked
|
|
# with a pluralized class name. But by default it is invoked with the same
|
|
# name as the resource generator, which is singular. To change this, we
|
|
# can give a block to customize how the controller can be invoked.
|
|
#
|
|
# hook_for :resource_controller do |instance, controller|
|
|
# instance.invoke controller, [ instance.name.pluralize ]
|
|
# end
|
|
#
|
|
def self.hook_for(*names, &block)
|
|
options = names.extract_options!
|
|
in_base = options.delete(:in) || base_name
|
|
as_hook = options.delete(:as) || generator_name
|
|
|
|
names.each do |name|
|
|
defaults = if options[:type] == :boolean
|
|
{ }
|
|
elsif [true, false].include?(default_value_for_option(name, options))
|
|
{ :banner => "" }
|
|
else
|
|
{ :desc => "#{name.to_s.humanize} to be invoked", :banner => "NAME" }
|
|
end
|
|
|
|
unless class_options.key?(name)
|
|
class_option(name, defaults.merge!(options))
|
|
end
|
|
|
|
hooks[name] = [ in_base, as_hook ]
|
|
invoke_from_option(name, options, &block)
|
|
end
|
|
end
|
|
|
|
# Remove a previously added hook.
|
|
#
|
|
# ==== Examples
|
|
#
|
|
# remove_hook_for :orm
|
|
#
|
|
def self.remove_hook_for(*names)
|
|
remove_invocation(*names)
|
|
|
|
names.each do |name|
|
|
hooks.delete(name)
|
|
end
|
|
end
|
|
|
|
# Make class option aware of Rails::Generators.options and Rails::Generators.aliases.
|
|
def self.class_option(name, options={}) #:nodoc:
|
|
options[:desc] = "Indicates when to generate #{name.to_s.humanize.downcase}" unless options.key?(:desc)
|
|
options[:aliases] = default_aliases_for_option(name, options)
|
|
options[:default] = default_value_for_option(name, options)
|
|
super(name, options)
|
|
end
|
|
|
|
# Returns the default source root for a given generator. This is used internally
|
|
# by rails to set its generators source root. If you want to customize your source
|
|
# root, you should use source_root.
|
|
def self.default_source_root
|
|
return unless base_name && generator_name
|
|
path = File.expand_path(File.join(base_name, generator_name, 'templates'), base_root)
|
|
path if File.exists?(path)
|
|
end
|
|
|
|
# Returns the base root for a common set of generators. This is used to dynamically
|
|
# guess the default source root.
|
|
def self.base_root
|
|
File.dirname(__FILE__)
|
|
end
|
|
|
|
# Cache source root and add lib/generators/base/generator/templates to
|
|
# source paths.
|
|
def self.inherited(base) #:nodoc:
|
|
super
|
|
|
|
# Invoke source_root so the default_source_root is set.
|
|
base.source_root
|
|
|
|
if base.name && base.name !~ /Base$/
|
|
Rails::Generators.subclasses << base
|
|
|
|
Rails::Generators.templates_path.each do |path|
|
|
if base.name.include?('::')
|
|
base.source_paths << File.join(path, base.base_name, base.generator_name)
|
|
else
|
|
base.source_paths << File.join(path, base.generator_name)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
# Check whether the given class names are already taken by user
|
|
# application or Ruby on Rails.
|
|
#
|
|
def class_collisions(*class_names) #:nodoc:
|
|
return unless behavior == :invoke
|
|
|
|
class_names.flatten.each do |class_name|
|
|
class_name = class_name.to_s
|
|
next if class_name.strip.empty?
|
|
|
|
# Split the class from its module nesting
|
|
nesting = class_name.split('::')
|
|
last_name = nesting.pop
|
|
|
|
# Hack to limit const_defined? to non-inherited on 1.9
|
|
extra = []
|
|
extra << false unless Object.method(:const_defined?).arity == 1
|
|
|
|
# Extract the last Module in the nesting
|
|
last = nesting.inject(Object) do |last, nest|
|
|
break unless last.const_defined?(nest, *extra)
|
|
last.const_get(nest)
|
|
end
|
|
|
|
if last && last.const_defined?(last_name.camelize, *extra)
|
|
raise Error, "The name '#{class_name}' is either already used in your application " <<
|
|
"or reserved by Ruby on Rails. Please choose an alternative and run " <<
|
|
"this generator again."
|
|
end
|
|
end
|
|
end
|
|
|
|
# Use Rails default banner.
|
|
#
|
|
def self.banner
|
|
"rails generate #{generator_name} #{self.arguments.map{ |a| a.usage }.join(' ')} [options]"
|
|
end
|
|
|
|
# Sets the base_name taking into account the current class namespace.
|
|
#
|
|
def self.base_name
|
|
@base_name ||= begin
|
|
if base = name.to_s.split('::').first
|
|
base.underscore
|
|
end
|
|
end
|
|
end
|
|
|
|
# Removes the namespaces and get the generator name. For example,
|
|
# Rails::Generators::ModelGenerator will return "model" as generator name.
|
|
#
|
|
def self.generator_name
|
|
@generator_name ||= begin
|
|
if generator = name.to_s.split('::').last
|
|
generator.sub!(/Generator$/, '')
|
|
generator.underscore
|
|
end
|
|
end
|
|
end
|
|
|
|
# Return the default value for the option name given doing a lookup in
|
|
# Rails::Generators.options.
|
|
#
|
|
def self.default_value_for_option(name, options)
|
|
default_for_option(Rails::Generators.options, name, options, options[:default])
|
|
end
|
|
|
|
# Return default aliases for the option name given doing a lookup in
|
|
# Rails::Generators.aliases.
|
|
#
|
|
def self.default_aliases_for_option(name, options)
|
|
default_for_option(Rails::Generators.aliases, name, options, options[:aliases])
|
|
end
|
|
|
|
# Return default for the option name given doing a lookup in config.
|
|
#
|
|
def self.default_for_option(config, name, options, default)
|
|
if generator_name and c = config[generator_name.to_sym] and c.key?(name)
|
|
c[name]
|
|
elsif base_name and c = config[base_name.to_sym] and c.key?(name)
|
|
c[name]
|
|
elsif config[:rails].key?(name)
|
|
config[:rails][name]
|
|
else
|
|
default
|
|
end
|
|
end
|
|
|
|
# Keep hooks configuration that are used on prepare_for_invocation.
|
|
#
|
|
def self.hooks #:nodoc:
|
|
@hooks ||= from_superclass(:hooks, {})
|
|
end
|
|
|
|
# Prepare class invocation to search on Rails namespace if a previous
|
|
# added hook is being used.
|
|
#
|
|
def self.prepare_for_invocation(name, value) #:nodoc:
|
|
return super unless value.is_a?(String) || value.is_a?(Symbol)
|
|
|
|
if value && constants = self.hooks[name]
|
|
value = name if TrueClass === value
|
|
Rails::Generators.find_by_namespace(value, *constants)
|
|
elsif klass = Rails::Generators.find_by_namespace(value)
|
|
klass
|
|
else
|
|
super
|
|
end
|
|
end
|
|
|
|
# Small macro to add ruby as an option to the generator with proper
|
|
# default value plus an instance helper method called shebang.
|
|
#
|
|
def self.add_shebang_option!
|
|
class_option :ruby, :type => :string, :aliases => "-r", :default => Thor::Util.ruby_command,
|
|
:desc => "Path to the Ruby binary of your choice", :banner => "PATH"
|
|
|
|
no_tasks {
|
|
define_method :shebang do
|
|
@shebang ||= begin
|
|
command = if options[:ruby] == Thor::Util.ruby_command
|
|
"/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
|
|
else
|
|
options[:ruby]
|
|
end
|
|
"#!#{command}"
|
|
end
|
|
end
|
|
}
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|