Namespace
Methods
F
H
I
L
N
P
S
Constants
DEFAULT_ALIASES = { rails: { actions: '-a', orm: '-o', javascripts: '-j', javascript_engine: '-je', resource_controller: '-c', scaffold_controller: '-c', stylesheets: '-y', stylesheet_engine: '-se', template_engine: '-e', test_framework: '-t' }, test_unit: { fixture_replacement: '-r', } }
 
DEFAULT_OPTIONS = { rails: { assets: true, force_plural: false, helper: true, integration_tool: nil, javascripts: true, javascript_engine: :js, orm: false, resource_controller: :controller, resource_route: true, scaffold_controller: :scaffold_controller, stylesheets: true, stylesheet_engine: :css, test_framework: false, template_engine: :erb } }
 
RAILS_DEV_PATH = File.expand_path("../../../../../..", File.dirname(__FILE__))
 

We need to store the RAILS_DEV_PATH in a constant, otherwise the path can change in Ruby 1.8.7 when we FileUtils.cd.

RESERVED_NAMES = %w[application destroy plugin runner test]
 
Class Public methods
fallbacks()

Hold configured generators fallbacks. If a plugin developer wants a generator group to fallback to another group in case of missing generators, they can add a fallback.

For example, shoulda is considered a test_framework and is an extension of test_unit. However, most part of shoulda generators are similar to test_unit ones.

Shoulda then can tell generators to search for test_unit generators when some of them are not available by adding a fallback:

Rails::Generators.fallbacks[:shoulda] = :test_unit
# File railties/lib/rails/generators.rb, line 98
def self.fallbacks
  @fallbacks ||= {}
end
help(command = 'generate')

Show help message with available generators.

# File railties/lib/rails/generators.rb, line 211
def self.help(command = 'generate')
  puts "Usage: rails #{command} GENERATOR [args] [options]"
  puts
  puts "General options:"
  puts "  -h, [--help]     # Print generator's options and usage"
  puts "  -p, [--pretend]  # Run but do not make any changes"
  puts "  -f, [--force]    # Overwrite files that already exist"
  puts "  -s, [--skip]     # Skip files that already exist"
  puts "  -q, [--quiet]    # Suppress status output"
  puts
  puts "Please choose a generator below."
  puts

  print_generators
end
hidden_namespaces()

Returns an array of generator namespaces that are hidden. Generator namespaces may be hidden for a variety of reasons. Some are aliased such as “rails:migration” and can be invoked with the shorter “migration”, others are private to other generators such as “css:scaffold”.

# File railties/lib/rails/generators.rb, line 173
def self.hidden_namespaces
  @hidden_namespaces ||= begin
    orm      = options[:rails][:orm]
    test     = options[:rails][:test_framework]
    template = options[:rails][:template_engine]
    css      = options[:rails][:stylesheet_engine]

    [
      "rails",
      "resource_route",
      "#{orm}:migration",
      "#{orm}:model",
      "#{test}:controller",
      "#{test}:helper",
      "#{test}:integration",
      "#{test}:mailer",
      "#{test}:model",
      "#{test}:scaffold",
      "#{test}:view",
      "#{template}:controller",
      "#{template}:scaffold",
      "#{template}:mailer",
      "#{css}:scaffold",
      "#{css}:assets",
      "css:assets",
      "css:scaffold"
    ]
  end
end
hide_namespace(*namespaces)
Alias for: hide_namespaces
hide_namespaces(*namespaces)
Also aliased as: hide_namespace
# File railties/lib/rails/generators.rb, line 204
def hide_namespaces(*namespaces)
  hidden_namespaces.concat(namespaces)
end
invoke(namespace, args=ARGV, config={})

Receives a namespace, arguments and the behavior to invoke the generator. It's used as the default entry point for generate, destroy and update commands.

# File railties/lib/rails/generators.rb, line 153
def self.invoke(namespace, args=ARGV, config={})
  names = namespace.to_s.split(':')
  if klass = find_by_namespace(names.pop, names.any? && names.join(':'))
    args << "--help" if args.empty? && klass.arguments.any? { |a| a.required? }
    klass.start(args, config)
  else
    options     = sorted_groups.map(&:last).flatten
    suggestions = options.sort_by {|suggested| levenshtein_distance(namespace.to_s, suggested) }.first(3)
    msg =  "Could not find generator '#{namespace}'. "
    msg << "Maybe you meant #{ suggestions.map {|s| "'#{s}'"}.to_sentence(last_word_connector: " or ") }\n"
    msg << "Run `rails generate --help` for more options."
    puts msg
  end
end
no_color!()

Remove the color from output.

# File railties/lib/rails/generators.rb, line 103
def self.no_color!
  Thor::Base.shell = Thor::Shell::Basic
end
print_generators()
# File railties/lib/rails/generators.rb, line 232
def self.print_generators
  sorted_groups.each { |b, n| print_list(b, n) }
end
public_namespaces()
# File railties/lib/rails/generators.rb, line 227
def self.public_namespaces
  lookup!
  subclasses.map { |k| k.namespace }
end
sorted_groups()
# File railties/lib/rails/generators.rb, line 236
def self.sorted_groups
  namespaces = public_namespaces
  namespaces.sort!
  groups = Hash.new { |h,k| h[k] = [] }
  namespaces.each do |namespace|
    base = namespace.split(':').first
    groups[base] << namespace
  end
  rails = groups.delete("rails")
  rails.map! { |n| n.sub(/^rails:/, '') }
  rails.delete("app")
  rails.delete("plugin")

  hidden_namespaces.each { |n| groups.delete(n.to_s) }

  [["rails", rails]] + groups.sort.to_a
end
subclasses()

Track all generators subclasses.

# File railties/lib/rails/generators.rb, line 108
def self.subclasses
  @subclasses ||= []
end
Class Protected methods
levenshtein_distance(str1, str2)

This code is based directly on the Text gem implementation Returns a value representing the “cost” of transforming str1 into str2

# File railties/lib/rails/generators.rb, line 258
def self.levenshtein_distance str1, str2
  s = str1
  t = str2
  n = s.length
  m = t.length

  return m if (0 == n)
  return n if (0 == m)

  d = (0..m).to_a
  x = nil

  str1.each_char.each_with_index do |char1,i|
    e = i+1

    str2.each_char.each_with_index do |char2,j|
      cost = (char1 == char2) ? 0 : 1
      x = [
           d[j+1] + 1, # insertion
           e + 1,      # deletion
           d[j] + cost # substitution
          ].min
      d[j] = e
      e = x
    end

    d[m] = x
  end

  return x
end