mirror of
https://github.com/rails/rails.git
synced 2022-11-09 12:12:34 -05:00
420 lines
15 KiB
Ruby
420 lines
15 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
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 #{$0} #{(ARGV | ['--dev']).join(" ")}`"
|
|
exit
|
|
end
|
|
|
|
module Rails
|
|
module Generators
|
|
class Error < Thor::Error # :nodoc:
|
|
end
|
|
|
|
class Base < Thor::Group
|
|
include Thor::Actions
|
|
include Rails::Generators::Actions
|
|
|
|
class_option :skip_namespace, type: :boolean, default: false,
|
|
desc: "Skip namespace (affects only isolated engines)"
|
|
class_option :skip_collision_check, type: :boolean, default: false,
|
|
desc: "Skip collision check"
|
|
|
|
add_runtime_options!
|
|
strict_args_position!
|
|
|
|
def self.exit_on_failure? # :nodoc:
|
|
false
|
|
end
|
|
|
|
# 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
|
|
|
|
@desc ||= if usage_path
|
|
ERB.new(File.read(usage_path)).result(binding)
|
|
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.delete_suffix("_generator").sub(/:generators:/, ":")
|
|
end
|
|
|
|
# Convenience method to hide this generator from the available ones when
|
|
# running rails generator command.
|
|
def self.hide!
|
|
Rails::Generators.hide_namespace(namespace)
|
|
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:
|
|
#
|
|
# bin/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: +:in+ 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 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 look up at:
|
|
#
|
|
# "test_unit:controller", "test_unit"
|
|
#
|
|
# Similarly, if you want it to also look up in the rails namespace, you
|
|
# just need to provide the +:in+ 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 you do not want
|
|
# to use any test framework, you can do:
|
|
#
|
|
# bin/rails generate controller Account --skip-test-framework
|
|
#
|
|
# Or similarly:
|
|
#
|
|
# bin/rails generate controller Account --no-test-framework
|
|
#
|
|
# ==== Boolean hooks
|
|
#
|
|
# In some cases, you may 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:
|
|
#
|
|
# bin/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 class 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|
|
|
unless class_options.key?(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
|
|
|
|
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.
|
|
#
|
|
# 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
|
|
return unless default_generator_root
|
|
path = File.join(default_generator_root, "templates")
|
|
path if File.exist?(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
|
|
__dir__
|
|
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.end_with?("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
|
|
|
|
private
|
|
# Check whether the given class names are already taken by user
|
|
# application or Ruby on Rails.
|
|
def class_collisions(*class_names)
|
|
return unless behavior == :invoke
|
|
return if options.skip_collision_check?
|
|
return if options.force?
|
|
|
|
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
|
|
last = extract_last_module(nesting)
|
|
|
|
if last && last.const_defined?(last_name.camelize, false)
|
|
raise Error, "The name '#{class_name}' is either already used in your application " \
|
|
"or reserved by Ruby on Rails. Please choose an alternative or use --skip-collision-check " \
|
|
"or --force to skip this check and run this generator again."
|
|
end
|
|
end
|
|
end
|
|
|
|
# Takes in an array of nested modules and extracts the last module
|
|
def extract_last_module(nesting) # :doc:
|
|
nesting.inject(Object) do |last_module, nest|
|
|
break unless last_module.const_defined?(nest, false)
|
|
last_module.const_get(nest)
|
|
end
|
|
end
|
|
|
|
# Wrap block with namespace of current application
|
|
# if namespace exists and is not skipped
|
|
def module_namespacing(&block) # :doc:
|
|
content = capture(&block)
|
|
content = wrap_with_namespace(content) if namespaced?
|
|
concat(content)
|
|
end
|
|
|
|
def indent(content, multiplier = 2) # :doc:
|
|
spaces = " " * multiplier
|
|
content.each_line.map { |line| line.blank? ? line : "#{spaces}#{line}" }.join
|
|
end
|
|
|
|
def wrap_with_namespace(content) # :doc:
|
|
content = indent(content).chomp
|
|
"module #{namespace.name}\n#{content}\nend\n"
|
|
end
|
|
|
|
def namespace # :doc:
|
|
Rails::Generators.namespace
|
|
end
|
|
|
|
def namespaced? # :doc:
|
|
!options[:skip_namespace] && namespace
|
|
end
|
|
|
|
def namespace_dirs
|
|
@namespace_dirs ||= namespace.name.split("::").map(&:underscore)
|
|
end
|
|
|
|
def namespaced_path # :doc:
|
|
@namespaced_path ||= namespace_dirs.join("/")
|
|
end
|
|
|
|
# Use Rails default banner.
|
|
def self.banner # :doc:
|
|
"rails generate #{namespace.delete_prefix("rails:")} #{arguments.map(&:usage).join(' ')} [options]".gsub(/\s+/, " ")
|
|
end
|
|
|
|
# Sets the base_name taking into account the current class namespace.
|
|
def self.base_name # :doc:
|
|
@base_name ||= if base = name.to_s.split("::").first
|
|
base.underscore
|
|
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 # :doc:
|
|
@generator_name ||= if generator = name.to_s.split("::").last
|
|
generator.delete_suffix!("Generator")
|
|
generator.underscore
|
|
end
|
|
end
|
|
|
|
# Returns the default value for the option name given doing a lookup in
|
|
# Rails::Generators.options.
|
|
def self.default_value_for_option(name, options) # :doc:
|
|
default_for_option(Rails::Generators.options, name, options, options[:default])
|
|
end
|
|
|
|
# Returns default aliases for the option name given doing a lookup in
|
|
# Rails::Generators.aliases.
|
|
def self.default_aliases_for_option(name, options) # :doc:
|
|
default_for_option(Rails::Generators.aliases, name, options, options[:aliases])
|
|
end
|
|
|
|
# Returns default for the option name given doing a lookup in config.
|
|
def self.default_for_option(config, name, options, default) # :doc:
|
|
if generator_name && (c = config[generator_name.to_sym]) && c.key?(name)
|
|
c[name]
|
|
elsif base_name && (c = config[base_name.to_sym]) && 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 = 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! # :doc:
|
|
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
|
|
|
|
def self.usage_path # :doc:
|
|
paths = [
|
|
source_root && File.expand_path("../USAGE", source_root),
|
|
default_generator_root && File.join(default_generator_root, "USAGE")
|
|
]
|
|
paths.compact.detect { |path| File.exist? path }
|
|
end
|
|
|
|
def self.default_generator_root # :doc:
|
|
path = File.expand_path(File.join(base_name, generator_name), base_root)
|
|
path if File.exist?(path)
|
|
end
|
|
end
|
|
end
|
|
end
|