class Rails::Generators::Base

Parent:
Thor::Group
Included modules:
Rails::Generators::Actions

Public Class Methods

base_root() Show source
# File railties/lib/rails/generators/base.rb, line 217
def self.base_root
  File.dirname(__FILE__)
end

Returns the base root for a common set of generators. This is used to dynamically guess the default source root.

default_source_root() Show source
# File railties/lib/rails/generators/base.rb, line 208
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 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.

desc(description=nil) Show source
# File railties/lib/rails/generators/base.rb, line 30
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

Tries to get the description from a USAGE file one folder above the source root otherwise uses a default description.

Calls superclass method
hide!() Show source
# File railties/lib/rails/generators/base.rb, line 50
def self.hide!
  Rails::Generators.hide_namespace self.namespace
end

Convenience method to hide this generator from the available ones when running rails generator command.

hook_for(*names, &block) Show source
# File railties/lib/rails/generators/base.rb, line 163
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

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: :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 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 :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:

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
namespace(name=nil) Show source
# File railties/lib/rails/generators/base.rb, line 43
def self.namespace(name=nil)
  return super if name
  @namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':')
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.

Calls superclass method
remove_hook_for(*names) Show source
# File railties/lib/rails/generators/base.rb, line 189
def self.remove_hook_for(*names)
  remove_invocation(*names)

  names.each do |name|
    hooks.delete(name)
  end
end

Remove a previously added hook.

remove_hook_for :orm
source_root(path=nil) Show source
# File railties/lib/rails/generators/base.rb, line 23
def self.source_root(path=nil)
  @_source_root = path if path
  @_source_root ||= default_source_root
end

Returns the source root for this generator using ::default_source_root as default.

Protected Class Methods

add_shebang_option!() Show source
# File railties/lib/rails/generators/base.rb, line 346
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

Small macro to add ruby as an option to the generator with proper default value plus an instance helper method called shebang.

banner() Show source

Use Rails default banner.

base_name() Show source
# File railties/lib/rails/generators/base.rb, line 280
def self.base_name
  @base_name ||= begin
    if base = name.to_s.split('::').first
      base.underscore
    end
  end
end

Sets the ::base_name taking into account the current class namespace.

default_aliases_for_option(name, options) Show source
# File railties/lib/rails/generators/base.rb, line 307
def self.default_aliases_for_option(name, options)
  default_for_option(Rails::Generators.aliases, name, options, options[:aliases])
end

Return default aliases for the option name given doing a lookup in Rails::Generators.aliases.

default_for_option(config, name, options, default) Show source
# File railties/lib/rails/generators/base.rb, line 312
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 default for the option name given doing a lookup in config.

default_generator_root() Show source
# File railties/lib/rails/generators/base.rb, line 372
def self.default_generator_root
  path = File.expand_path(File.join(base_name, generator_name), base_root)
  path if File.exist?(path)
end
default_value_for_option(name, options) Show source
# File railties/lib/rails/generators/base.rb, line 301
def self.default_value_for_option(name, options)
  default_for_option(Rails::Generators.options, name, options, options[:default])
end

Returns the default value for the option name given doing a lookup in Rails::Generators.options.

generator_name() Show source
# File railties/lib/rails/generators/base.rb, line 290
def self.generator_name
  @generator_name ||= begin
    if generator = name.to_s.split('::').last
      generator.sub!(/Generator$/, '')
      generator.underscore
    end
  end
end

Removes the namespaces and get the generator name. For example, Rails::Generators::ModelGenerator will return “model” as generator name.

usage_path() Show source
# File railties/lib/rails/generators/base.rb, line 364
def self.usage_path
  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

Protected Instance Methods

extract_last_module(nesting) Show source
# File railties/lib/rails/generators/base.rb, line 267
def extract_last_module(nesting)
  nesting.inject(Object) do |last_module, nest|
    break unless last_module.const_defined?(nest, false)
    last_module.const_get(nest)
  end
end

Takes in an array of nested modules and extracts the last module

© 2004–2018 David Heinemeier Hansson
Licensed under the MIT License.