- A
- B
- D
- G
- H
- N
- R
- S
- U
- Thor::Actions
- Rails::Generators::Actions
Returns the base root for a common set of generators. This is used to dynamically guess the default source root.
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.
Tries to get the description from a USAGE file one folder above the source root otherwise uses a default description.
# File railties/lib/rails/generators/base.rb, line 33 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
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_framework:awesome", "test_framework"
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_framework:controller", "test_framework"
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_framework", "test_framework:controller", "test_framework"
Switches
All hooks come with switches for user interface. If you do not want to use any test framework, you can do:
rails generate controller Account --skip-test-framework
Or similarly:
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:
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
# File railties/lib/rails/generators/base.rb, line 160 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 default_value_for_option(name, options).in?([true, false]) { :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
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.
Remove a previously added hook.
Examples
remove_hook_for :orm
Returns the source root for this generator using ::default_source_root as default.
Small macro to add ruby as an option to the generator with proper default value plus an instance helper method called shebang.
# File railties/lib/rails/generators/base.rb, line 357 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
Sets the ::base_name taking into account the current class namespace.
Return default aliases for the option name given doing a lookup in Rails::Generators.aliases.
Return default for the option name given doing a lookup in config.
# File railties/lib/rails/generators/base.rb, line 320 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
Return the default value for the option name given doing a lookup in Rails::Generators.options.
Removes the namespaces and get the generator name. For example, Rails::Generators::ModelGenerator will return “model” as generator name.