Find me in app/views/<%= file_name %>/<%= action %>.rhtml
diff --git a/railties/generators/generate.rb b/railties/generators/generate.rb new file mode 100755 index 0000000000000000000000000000000000000000..8f2f1497d659fb0688717dbeceb46df1c2158043 --- /dev/null +++ b/railties/generators/generate.rb @@ -0,0 +1,41 @@ +#!/usr/local/bin/ruby +require File.dirname(__FILE__) + '/../config/environment' +require 'rails_generator' + +unless ARGV.empty? + begin + name = ARGV.shift + Rails::Generator.instance(name, ARGV).generate + rescue Rails::Generator::UsageError => e + puts e.message + end +else + builtin_generators = Rails::Generator.builtin_generators.join(', ') + contrib_generators = Rails::Generator.contrib_generators.join(', ') + + $stderr.puts <| <%%= column.human_name %> | +<%% end %> +|||
|---|---|---|---|
| <%%=h <%= singular_name %>[column.name] %> | + <%% end %> +<%%= link_to 'Show', :action => 'show<%= suffix %>', :id => <%= singular_name %>.id %> | +<%%= link_to 'Edit', :action => 'edit<%= suffix %>', :id => <%= singular_name %>.id %> | +<%%= link_to 'Destroy', :action => 'destroy<%= suffix %>', :id => <%= singular_name %>.id %> | +
+ <%%= column.human_name %>: <%%= @<%= singular_name %>[column.name] %> +
+<%% end %> + +<%%= link_to 'Edit', :action => 'edit<%= suffix %>', :id => @<%= singular_name %>.id %> | +<%%= link_to 'Back', :action => 'list<%= suffix %>' %> diff --git a/railties/generators/templates/controller.erb b/railties/generators/templates/controller.erb deleted file mode 100644 index 600f5d2c59dd95614f3ba6c2265be51c58e38358..0000000000000000000000000000000000000000 --- a/railties/generators/templates/controller.erb +++ /dev/null @@ -1,19 +0,0 @@ -class <%= class_name %>Controller < AbstractApplicationController - helper :<%= file_name %> -<% if options[:scaffold] -%> - model :<%= file_name %> - scaffold :<%= options[:scaffold] %> - - <%- for action in actions -%> - #def <%= action %> - #end - - <%- end -%> -<% else -%> - <%- for action in actions -%> - def <%= action %> - end - - <%- end -%> -<% end -%> -end diff --git a/railties/generators/templates/controller_view.rhtml b/railties/generators/templates/controller_view.rhtml deleted file mode 100644 index d8a310df507dcec4807b671f90cfb2e03b841a1c..0000000000000000000000000000000000000000 --- a/railties/generators/templates/controller_view.rhtml +++ /dev/null @@ -1,10 +0,0 @@ - - - -Find me in app/views/<%= file_name %>/<%= action %>.rhtml
- - diff --git a/railties/lib/rails_generator.rb b/railties/lib/rails_generator.rb new file mode 100644 index 0000000000000000000000000000000000000000..9e64f5f4c5c30b23da48f56da01c6404127aef7e --- /dev/null +++ b/railties/lib/rails_generator.rb @@ -0,0 +1,175 @@ +require 'fileutils' + +module Rails + module Generator + class GeneratorError < StandardError; end + class UsageError < GeneratorError; end + + CONTRIB_ROOT = "#{RAILS_ROOT}/script/generators" + BUILTIN_ROOT = "#{File.dirname(__FILE__)}/../generators" + DEFAULT_SEARCH_PATHS = [CONTRIB_ROOT, BUILTIN_ROOT] + + class << self + def instance(name, args = [], search_paths = DEFAULT_SEARCH_PATHS) + # RAILS_ROOT constant must be set. + unless Object.const_get(:RAILS_ROOT) + raise GeneratorError, "RAILS_ROOT must be set. Did you require 'config/environment'?" + end + + # Force canonical name. + name = Inflector.underscore(name.downcase) + + # Search for filesystem path to requested generator. + unless path = find_generator_path(name, search_paths) + raise GeneratorError, "#{name} generator not found." + end + + # Check for templates directory. + template_root = "#{path}/templates" + unless File.directory?(template_root) + raise GeneratorError, "missing template directory #{template_root}" + end + + # Require class file according to naming convention. + require "#{path}/#{name}_generator.rb" + + # Find class according to naming convention. Allow Nesting::In::Modules. + class_name = Inflector.classify("#{name}_generator") + unless klass = find_generator_class(name) + raise GeneratorError, "no #{class_name} class defined in #{path}/#{name}_generator.rb" + end + + # Instantiate and return generator. + klass.new(template_root, RAILS_ROOT, search_paths, args) + end + + + def builtin_generators + generators([BUILTIN_ROOT]) + end + + def contrib_generators + generators([CONTRIB_ROOT]) + end + + def generators(search_paths) + generator_paths(search_paths).keys.uniq.sort + end + + # Find all generator paths. + def generator_paths(search_paths) + @paths ||= {} + unless @paths[search_paths] + paths = Hash.new { |h,k| h[k] = [] } + search_paths.each do |path| + Dir["#{path}/[a-z]*"].each do |dir| + paths[File.basename(dir)] << dir if File.directory?(dir) + end + end + @paths[search_paths] = paths + end + @paths[search_paths] + end + + def find_generator_path(name, search_paths) + generator_paths(search_paths)[name].first + end + + # Find all generator classes. + def generator_classes + classes = Hash.new { |h,k| h[k] = [] } + class_re = /([^:]+)Generator$/ + ObjectSpace.each_object(Class) do |object| + if md = class_re.match(object.name) and object < Rails::Generator::Base + classes[Inflector.underscore(md.captures.first)] << object + end + end + classes + end + + def find_generator_class(name) + generator_classes[name].first + end + end + + + # Talk about generators. + class Base + attr_reader :template_root, :destination_root, :args, :options, + :class_name, :singular_name, :plural_name + + alias_method :file_name, :singular_name + alias_method :table_name, :plural_name + + def self.generator_name + Inflector.underscore(name.gsub('Generator', '')) + end + + def initialize(template_root, destination_root, search_paths, args) + @template_root, @destination_root = template_root, destination_root + usage if args.empty? + @search_paths, @original_args = search_paths, args.dup + @class_name, @singular_name, @plural_name = inflect_names(args.shift) + @options = extract_options!(args) + @args = args + end + + protected + # Look up another generator with the same arguments. + def generator(name) + Rails::Generator.instance(name, @original_args, @search_paths) + end + + # Generate a file for a Rails application using an ERuby template. + # Looks up and evalutes a template by name and writes the result + # to a file relative to +destination_root+. The template + # is evaluated in the context of the optional eval_binding argument. + # + # The ERB template uses explicit trim mode to best control the + # proliferation of whitespace in generated code. <%- trims leading + # whitespace; -%> trims trailing whitespace including one newline. + def template(template_name, destination_path, eval_binding = nil) + # Determine full paths for source and destination files. + template_path = find_template_path(template_name) + destination_path = File.join(destination_root, destination_path) + + # Create destination directories. + FileUtils.mkdir_p(File.dirname(destination_path)) + + # Render template and write result. + eval_binding ||= binding + contents = ERB.new(File.read(template_path), nil, '-').result(eval_binding) + File.open(destination_path, 'w') { |file| file.write(contents) } + end + + def usage + raise UsageError.new, File.read(usage_path) + end + + private + def find_template_path(template_name) + name, path = template_name.split('/', 2) + if path.nil? + File.join(template_root, name) + elsif generator_path = Rails::Generator.find_generator_path(name, @search_paths) + File.join(generator_path, 'templates', path) + end + end + + def inflect_names(name) + camel = Inflector.camelize(Inflector.underscore(name)) + under = Inflector.underscore(camel) + plural = Inflector.pluralize(under) + [camel, under, plural] + end + + def extract_options!(args) + if args.last.is_a?(Hash) then args.pop else {} end + end + + def usage_path + "#{template_root}/../USAGE" + end + end + end +end diff --git a/railties/test/generators/missing_class/missing_class_generator.rb b/railties/test/generators/missing_class/missing_class_generator.rb new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/railties/test/rails_generator_test.rb b/railties/test/rails_generator_test.rb new file mode 100644 index 0000000000000000000000000000000000000000..b63840d3387ae9d363207412bf7dc68283f36d80 --- /dev/null +++ b/railties/test/rails_generator_test.rb @@ -0,0 +1,95 @@ +$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib" +RAILS_ROOT = File.dirname(__FILE__) + +require File.dirname(__FILE__) + '/../../activerecord/lib/active_record/support/inflector' +require 'rails_generator' +require 'test/unit' + + +class RailsGeneratorTest < Test::Unit::TestCase + BUILTINS = %w(controller mailer model scaffold) + + def test_instance_builtins + BUILTINS.each do |name| + object = nil + assert_nothing_raised { object = Rails::Generator.instance(name, ['foo']) } + assert_not_nil object + assert_match /#{name.capitalize}Generator/, object.class.name + assert_respond_to object, :generate + end + end + + def test_instance_without_rails_root + old_verbose, $VERBOSE = $VERBOSE, nil + old_rails_root = Object.const_get(:RAILS_ROOT) + begin + Object.const_set(:RAILS_ROOT, nil) + assert_raise(Rails::Generator::GeneratorError) { + Rails::Generator.instance('model', ['name']) + } + ensure + Object.const_set(:RAILS_ROOT, old_rails_root) + $VERBOSE = old_verbose + end + end + + def test_instance_not_found + assert_raise(Rails::Generator::GeneratorError) { + Rails::Generator.instance('foobar') + } + end + + def test_instance_missing_templates + assert_raise(Rails::Generator::GeneratorError) { + Rails::Generator.instance('missing_templates') + } + end + + def test_instance_missing_generator + assert_raise(LoadError) { + Rails::Generator.instance('missing_generator') + } + end + + def test_instance_missing_class + assert_raise(Rails::Generator::GeneratorError) { + Rails::Generator.instance('missing_class') + } + end + + def test_builtin_generators + assert_nothing_raised { + assert_equal [], Rails::Generator.builtin_generators - BUILTINS + } + end + + def test_generator_name + assert_equal 'model', Rails::Generator.instance('model', ['name']).class.generator_name + end + + def test_generator_usage + assert_raise(Rails::Generator::UsageError) { + assert_equal 'model', Rails::Generator.instance('model') + } + end + + def test_generator_vars + model = Rails::Generator.instance('model', ['model']) + assert_equal "#{Rails::Generator::BUILTIN_ROOT}/model/templates", model.template_root + assert_equal RAILS_ROOT, model.destination_root + assert_equal 'Model', model.class_name + assert_equal 'model', model.singular_name + assert_equal 'models', model.plural_name + assert_equal model.singular_name, model.file_name + assert_equal model.plural_name, model.table_name + assert_equal [], model.args + end + + def test_generator_generator + assert_nothing_raised { + model = Rails::Generator.instance('model', ['name']) + mailer = model.send(:generator, 'mailer') + assert_equal 'mailer', mailer.class.generator_name + } + end +end