diff options
Diffstat (limited to 'railties/lib/generators/base.rb')
| -rw-r--r-- | railties/lib/generators/base.rb | 357 |
1 files changed, 357 insertions, 0 deletions
diff --git a/railties/lib/generators/base.rb b/railties/lib/generators/base.rb new file mode 100644 index 0000000000..0d2d165741 --- /dev/null +++ b/railties/lib/generators/base.rb @@ -0,0 +1,357 @@ +require 'generators/actions' + +module Rails + module Generators + DEFAULTS = { + :fixture => true, + :force_plural => false, + :helper => true, + :layout => true, + :migration => true, + :orm => 'active_record', + :resource_controller => 'controller', + :scaffold_controller => 'scaffold_controller', + :singleton => false, + :stylesheets => true, + :test_framework => 'test_unit', + :template_engine => 'erb', + :timestamps => true + } + + ALIASES = { + :actions => '-a', + :fixture_replacement => '-r', + :orm => '-o', + :resource_controller => '-c', + :scaffold_controller => '-c', + :stylesheets => '-y', + :test_framework => '-t', + :template_engine => '-e' + } + + class Error < Thor::Error + end + + class Base < Thor::Group + include Rails::Generators::Actions + include Thor::Actions + + # Automatically sets the source root based on the class name. + # + def self.source_root + @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), base_name, generator_name, 'templates')) + 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 = File.expand_path(File.join(source_root, "..", "USAGE")) + + @desc ||= if 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$/, '') + 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 + # + # class ControllerGenerator < Rails::Generators::Base + # hook_for :test_framework, :aliases => "-t" + # 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: + # + # ruby script/generate controller Account --test-framework=test_unit + # + # The controller generator will then try to invoke the following generators: + # + # "rails:generators:test_unit", "test_unit:generators:controller", "test_unit" + # + # In this case, the "test_unit:generators:controller" is available and is + # invoked. This allows any test framework to hook into Rails as long as it + # provides any of the hooks above. + # + # Finally, if the user don't want to use any test framework, he can do: + # + # ruby script/generate controller Account --skip-test-framework + # + # Or similarly: + # + # ruby script/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: + # + # ruby script/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 parameters, 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. 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! + as = options.fetch(:as, generator_name) + verbose = options.fetch(:verbose, :white) + + names.each do |name| + defaults = if options[:type] == :boolean + { } + elsif [true, false].include?(options.fetch(:default, DEFAULTS[name])) + { :banner => "" } + else + { :desc => "#{name.to_s.humanize} to be invoked", :banner => "NAME" } + end + + class_option name, defaults.merge!(options) + invocations << [ name, base_name, as ] + invocation_blocks[name] = block if block_given? + + # hook_for :test_framework + # + # ==== Generates + # + # def hook_for_test_framework + # return unless options[:test_framework] + # + # klass_name = options[:test_framework] + # klass_name = :test_framework if TrueClass === klass_name + # klass = Rails::Generators.find_by_namespace(klass_name, "rails", "model") + # + # if klass + # say_status :invoke, options[:test_framework], :white + # shell.padding += 1 + # if block = self.class.invocation_blocks[:test_framework] + # block.call(self, klass) + # else + # invoke klass + # end + # shell.padding -= 1 + # else + # say "Could not find and invoke '#{klass_name}'" + # end + # end + # + class_eval <<-METHOD, __FILE__, __LINE__ + def hook_for_#{name} + return unless options[#{name.inspect}] + + klass_name = options[#{name.inspect}] + klass_name = #{name.inspect} if TrueClass === klass_name + klass = Rails::Generators.find_by_namespace(klass_name, #{base_name.inspect}, #{as.inspect}) + + if klass + say_status :invoke, klass_name, #{verbose.inspect} + shell.padding += 1 + if block = self.class.invocation_blocks[#{name.inspect}] + block.call(self, klass) + else + invoke klass + end + shell.padding -= 1 + else + say "Could not find and invoke '\#{klass_name}'." + end + end + METHOD + end + end + + # Remove a previously added hook. + # + # ==== Examples + # + # remove_hook_for :orm + # + def self.remove_hook_for(*names) + names.each do |name| + remove_class_option name + remove_task name + invocations.delete_if { |i| i[0] == name } + invocation_blocks.delete(name) + end + end + + # Make class option aware of DEFAULTS and 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] = ALIASES[name] unless options.key?(:aliases) + options[:default] = DEFAULTS[name] unless options.key?(:default) + super(name, options) + end + + protected + + # 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 + + 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 + "#{$0} #{generator_name} #{self.arguments.map(&:usage).join(' ')} [options]" + end + + # Sets the base_name taking into account the current class namespace. + # + def self.base_name + @base_name ||= self.name.split('::').first.underscore + end + + # Removes the namespaces and get the generator name. For example, + # Rails::Generators::MetalGenerator will return "metal" as generator name. + # + def self.generator_name + @generator_name ||= begin + klass_name = self.name.split('::').last + klass_name.sub!(/Generator$/, '') + klass_name.underscore + end + end + + # Stores invocations for this class merging with superclass values. + # + def self.invocations #:nodoc: + @invocations ||= from_superclass(:invocations, []) + end + + # Stores invocation blocks used on hook_for and invoke_if. + # + def self.invocation_blocks #:nodoc: + @invocation_blocks ||= from_superclass(:invocation_blocks, {}) + end + + # Overwrite class options help to allow invoked generators options to be + # shown recursively when invoking a generator. + # + def self.class_options_help(shell, ungrouped_name=nil, extra_group=nil) + group_options = Thor::CoreExt::OrderedHash.new + + get_options_from_invocations(group_options, class_options) do |klass| + klass.send(:get_options_from_invocations, group_options, class_options) + end + + group_options.merge!(extra_group) if extra_group + super(shell, ungrouped_name, group_options) + end + + # Get invocations array and merge options from invocations. Those + # options are added to group_options hash. Options that already exists + # in base_options are not added twice. + # + def self.get_options_from_invocations(group_options, base_options) + invocations.each do |args| + name, base, generator = args + option = class_options[name] + + klass_name = option.type == :boolean ? name : option.default + next unless klass_name + + klass = Rails::Generators.find_by_namespace(klass_name, base, generator) + next unless klass + + human_name = klass_name.to_s.classify + group_options[human_name] ||= [] + + group_options[human_name] += klass.class_options.values.select do |option| + base_options[option.name.to_sym].nil? && option.group.nil? && + !group_options.values.flatten.any? { |i| i.name == option.name } + end + + yield klass if block_given? + 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 |