1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
|
require 'generators/actions'
module Rails
module Generators
DEFAULTS = {
:fixture => true,
:helper => true,
:migration => true,
:orm => 'active_record',
:test_framework => 'test_unit',
:template_engine => 'erb',
:timestamps => true
}
ALIASES = {
:fixture_replacement => '-r',
:helper => '-l',
:orm => '-o',
: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, although type and
# default values cannot be given.
#
# ==== 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
#
def self.hook_for(*names)
default_options = names.extract_options!
verbose = default_options.key?(:verbose) ? default_options[:verbose] : :blue
invocations.concat(names)
names.each do |name|
options = default_options.dup
options[:desc] ||= "#{name.to_s.humanize} to be invoked"
options[:banner] ||= "NAME"
options[:aliases] ||= ALIASES[name]
class_option name, options.merge!(:type => :default, :default => DEFAULTS[name])
class_eval <<-METHOD, __FILE__, __LINE__
def invoke_for_#{name}
return unless options[#{name.inspect}]
klass = Rails::Generators.find_by_namespace(options[#{name.inspect}],
self.class.base_name, self.class.generator_name)
if klass
say_status :invoke, options[#{name.inspect}], #{verbose.inspect}
invoke klass
else
say "Could not find and invoke '\#{options[#{name.inspect}]}'."
end
end
METHOD
end
end
# Invoke a generator with the given name if the user requires it. The
# difference to hook_for is that the class option here is boolean
# and the generator invoked is not based on user input.
#
# A class option is created when this method is invoked and you can set
# a hash to customize it, although type and default values cannot be
# given.
#
# ==== Examples
#
# class ControllerGenerator < Rails::Generators::Base
# invoke_if :webrat, :aliases => "-w"
# end
#
# The example above will create a helper option and will be invoked
# when the user requires so:
#
# ruby script/generate controller Account --webrat
#
# The controller generator will then try to invoke the following generators:
#
# "rails:generators:webrat", "webrat:generators:controller", "webrat"
#
def self.invoke_if(*names)
default_options = names.extract_options!
verbose = default_options.key?(:verbose) ? default_options[:verbose] : :blue
invocations.concat(names)
names.each do |name|
conditional_class_option name, default_options.dup
class_eval <<-METHOD, __FILE__, __LINE__
def invoke_if_#{name}
return unless options[#{name.inspect}]
klass = Rails::Generators.find_by_namespace(#{name.inspect},
self.class.base_name, self.class.generator_name)
if klass
say_status :invoke, #{name.inspect}, #{verbose.inspect}
invoke klass
else
say "Could not find and invoke '#{name}'."
end
end
METHOD
end
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
# Creates a conditional class option with type boolean, default value
# lookup and default description.
#
def self.conditional_class_option(name, options={})
options[:desc] ||= "Indicates when to generate #{name.to_s.humanize.downcase}"
class_option name, options.merge!(:type => :boolean, :default => DEFAULTS[name] || false)
end
# Overwrite class options help to allow invoked generators options to be
# shown when invoking a generator. Only first level options and options
# that belongs to the default group are shown.
#
def self.class_options_help(shell, ungrouped_name=nil, extra_group=nil)
klass_options = Thor::CoreExt::OrderedHash.new
invocations.each do |name|
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_name, generator_name)
next unless klass
human_name = klass_name.to_s.classify
klass_options[human_name] ||= []
klass_options[human_name] += klass.class_options.values.select do |option|
class_options[option.human_name.to_sym].nil? && option.group.nil?
end
end
klass_options.merge!(extra_group) if extra_group
super(shell, ungrouped_name, klass_options)
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!
require 'rbconfig'
default = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
class_option :ruby, :type => :string, :aliases => "-r", :default => default,
:desc => "Path to the Ruby binary of your choice", :banner => "PATH"
class_eval <<-METHOD, __FILE__, __LINE__
protected
def shebang
"#!\#{options[:ruby] || "/usr/bin/env ruby"}"
end
METHOD
end
end
end
end
|