groovenauts-thor 0.19.1

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,135 @@
1
+ class Thor
2
+ class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)
3
+ FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
4
+
5
+ def initialize(name, description, long_description, usage, options = nil)
6
+ super(name.to_s, description, long_description, usage, options || {})
7
+ end
8
+
9
+ def initialize_copy(other) #:nodoc:
10
+ super(other)
11
+ self.options = other.options.dup if other.options
12
+ end
13
+
14
+ def hidden?
15
+ false
16
+ end
17
+
18
+ # By default, a command invokes a method in the thor class. You can change this
19
+ # implementation to create custom commands.
20
+ def run(instance, args = [])
21
+ arity = nil
22
+
23
+ if private_method?(instance)
24
+ instance.class.handle_no_command_error(name)
25
+ elsif public_method?(instance)
26
+ arity = instance.method(name).arity
27
+ instance.__send__(name, *args)
28
+ elsif local_method?(instance, :method_missing)
29
+ instance.__send__(:method_missing, name.to_sym, *args)
30
+ else
31
+ instance.class.handle_no_command_error(name)
32
+ end
33
+ rescue ArgumentError => e
34
+ handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
35
+ rescue NoMethodError => e
36
+ handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (fail e)
37
+ end
38
+
39
+ # Returns the formatted usage by injecting given required arguments
40
+ # and required options into the given usage.
41
+ def formatted_usage(klass, namespace = true, subcommand = false)
42
+ if ancestor_name
43
+ formatted = "#{ancestor_name} " # add space
44
+ elsif namespace
45
+ namespace = klass.namespace
46
+ formatted = "#{namespace.gsub(/^(default)/, '')}:"
47
+ end
48
+ formatted ||= "#{klass.namespace.split(':').last} " if subcommand
49
+
50
+ formatted ||= ""
51
+
52
+ # Add usage with required arguments
53
+ formatted << if klass && !klass.arguments.empty?
54
+ usage.to_s.gsub(/^#{name}/) do |match|
55
+ match << " " << klass.arguments.map { |a| a.usage }.compact.join(" ")
56
+ end
57
+ else
58
+ usage.to_s
59
+ end
60
+
61
+ # Add required options
62
+ formatted << " #{required_options}"
63
+
64
+ # Strip and go!
65
+ formatted.strip
66
+ end
67
+
68
+ protected
69
+
70
+ def not_debugging?(instance)
71
+ !(instance.class.respond_to?(:debugging) && instance.class.debugging)
72
+ end
73
+
74
+ def required_options
75
+ @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(" ")
76
+ end
77
+
78
+ # Given a target, checks if this class name is a public method.
79
+ def public_method?(instance) #:nodoc:
80
+ !(instance.public_methods & [name.to_s, name.to_sym]).empty?
81
+ end
82
+
83
+ def private_method?(instance)
84
+ !(instance.private_methods & [name.to_s, name.to_sym]).empty?
85
+ end
86
+
87
+ def local_method?(instance, name)
88
+ methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
89
+ !(methods & [name.to_s, name.to_sym]).empty?
90
+ end
91
+
92
+ def sans_backtrace(backtrace, caller) #:nodoc:
93
+ saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ /^kernel\// && RUBY_ENGINE =~ /rbx/) }
94
+ saned - caller
95
+ end
96
+
97
+ def handle_argument_error?(instance, error, caller)
98
+ not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && begin
99
+ saned = sans_backtrace(error.backtrace, caller)
100
+ # Ruby 1.9 always include the called method in the backtrace
101
+ saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
102
+ end
103
+ end
104
+
105
+ def handle_no_method_error?(instance, error, caller)
106
+ not_debugging?(instance) &&
107
+ error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
108
+ end
109
+ end
110
+ Task = Command # rubocop:disable ConstantName
111
+
112
+ # A command that is hidden in help messages but still invocable.
113
+ class HiddenCommand < Command
114
+ def hidden?
115
+ true
116
+ end
117
+ end
118
+ HiddenTask = HiddenCommand # rubocop:disable ConstantName
119
+
120
+ # A dynamic command that handles method missing scenarios.
121
+ class DynamicCommand < Command
122
+ def initialize(name, options = nil)
123
+ super(name.to_s, "A dynamically-generated command", name.to_s, name.to_s, options)
124
+ end
125
+
126
+ def run(instance, args = [])
127
+ if (instance.methods & [name.to_s, name.to_sym]).empty?
128
+ super
129
+ else
130
+ instance.class.handle_no_command_error(name)
131
+ end
132
+ end
133
+ end
134
+ DynamicTask = DynamicCommand # rubocop:disable ConstantName
135
+ end
@@ -0,0 +1,77 @@
1
+ class Thor
2
+ module CoreExt #:nodoc:
3
+ # A hash with indifferent access and magic predicates.
4
+ #
5
+ # hash = Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
6
+ #
7
+ # hash[:foo] #=> 'bar'
8
+ # hash['foo'] #=> 'bar'
9
+ # hash.foo? #=> true
10
+ #
11
+ class HashWithIndifferentAccess < ::Hash #:nodoc:
12
+ def initialize(hash = {})
13
+ super()
14
+ hash.each do |key, value|
15
+ self[convert_key(key)] = value
16
+ end
17
+ end
18
+
19
+ def [](key)
20
+ super(convert_key(key))
21
+ end
22
+
23
+ def []=(key, value)
24
+ super(convert_key(key), value)
25
+ end
26
+
27
+ def delete(key)
28
+ super(convert_key(key))
29
+ end
30
+
31
+ def values_at(*indices)
32
+ indices.map { |key| self[convert_key(key)] }
33
+ end
34
+
35
+ def merge(other)
36
+ dup.merge!(other)
37
+ end
38
+
39
+ def merge!(other)
40
+ other.each do |key, value|
41
+ self[convert_key(key)] = value
42
+ end
43
+ self
44
+ end
45
+
46
+ # Convert to a Hash with String keys.
47
+ def to_hash
48
+ Hash.new(default).merge!(self)
49
+ end
50
+
51
+ protected
52
+
53
+ def convert_key(key)
54
+ key.is_a?(Symbol) ? key.to_s : key
55
+ end
56
+
57
+ # Magic predicates. For instance:
58
+ #
59
+ # options.force? # => !!options['force']
60
+ # options.shebang # => "/usr/lib/local/ruby"
61
+ # options.test_framework?(:rspec) # => options[:test_framework] == :rspec
62
+ #
63
+ def method_missing(method, *args, &block)
64
+ method = method.to_s
65
+ if method =~ /^(\w+)\?$/
66
+ if args.empty?
67
+ !!self[$1]
68
+ else
69
+ self[$1] == args.first
70
+ end
71
+ else
72
+ self[method]
73
+ end
74
+ end
75
+ end
76
+ end
77
+ end
@@ -0,0 +1,10 @@
1
+ class IO #:nodoc:
2
+ class << self
3
+ def binread(file, *args)
4
+ fail ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
5
+ File.open(file, "rb") do |f|
6
+ f.read(*args)
7
+ end
8
+ end unless method_defined? :binread
9
+ end
10
+ end
@@ -0,0 +1,129 @@
1
+ class Thor
2
+ module CoreExt
3
+ class OrderedHash < ::Hash
4
+ if RUBY_VERSION < "1.9"
5
+ def initialize(*args, &block)
6
+ super
7
+ @keys = []
8
+ end
9
+
10
+ def initialize_copy(other)
11
+ super
12
+ # make a deep copy of keys
13
+ @keys = other.keys
14
+ end
15
+
16
+ def []=(key, value)
17
+ @keys << key unless key?(key)
18
+ super
19
+ end
20
+
21
+ def delete(key)
22
+ if key? key
23
+ index = @keys.index(key)
24
+ @keys.delete_at index
25
+ end
26
+ super
27
+ end
28
+
29
+ def delete_if
30
+ super
31
+ sync_keys!
32
+ self
33
+ end
34
+
35
+ alias_method :reject!, :delete_if
36
+
37
+ def reject(&block)
38
+ dup.reject!(&block)
39
+ end
40
+
41
+ def keys
42
+ @keys.dup
43
+ end
44
+
45
+ def values
46
+ @keys.map { |key| self[key] }
47
+ end
48
+
49
+ def to_hash
50
+ self
51
+ end
52
+
53
+ def to_a
54
+ @keys.map { |key| [key, self[key]] }
55
+ end
56
+
57
+ def each_key
58
+ return to_enum(:each_key) unless block_given?
59
+ @keys.each { |key| yield(key) }
60
+ self
61
+ end
62
+
63
+ def each_value
64
+ return to_enum(:each_value) unless block_given?
65
+ @keys.each { |key| yield(self[key]) }
66
+ self
67
+ end
68
+
69
+ def each
70
+ return to_enum(:each) unless block_given?
71
+ @keys.each { |key| yield([key, self[key]]) }
72
+ self
73
+ end
74
+
75
+ def each_pair
76
+ return to_enum(:each_pair) unless block_given?
77
+ @keys.each { |key| yield(key, self[key]) }
78
+ self
79
+ end
80
+
81
+ alias_method :select, :find_all
82
+
83
+ def clear
84
+ super
85
+ @keys.clear
86
+ self
87
+ end
88
+
89
+ def shift
90
+ k = @keys.first
91
+ v = delete(k)
92
+ [k, v]
93
+ end
94
+
95
+ def merge!(other_hash)
96
+ if block_given?
97
+ other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
98
+ else
99
+ other_hash.each { |k, v| self[k] = v }
100
+ end
101
+ self
102
+ end
103
+
104
+ alias_method :update, :merge!
105
+
106
+ def merge(other_hash, &block)
107
+ dup.merge!(other_hash, &block)
108
+ end
109
+
110
+ # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
111
+ def replace(other)
112
+ super
113
+ @keys = other.keys
114
+ self
115
+ end
116
+
117
+ def inspect
118
+ "#<#{self.class} #{super}>"
119
+ end
120
+
121
+ private
122
+
123
+ def sync_keys!
124
+ @keys.delete_if { |k| !key?(k) }
125
+ end
126
+ end
127
+ end
128
+ end
129
+ end
data/lib/thor/error.rb ADDED
@@ -0,0 +1,32 @@
1
+ class Thor
2
+ # Thor::Error is raised when it's caused by wrong usage of thor classes. Those
3
+ # errors have their backtrace suppressed and are nicely shown to the user.
4
+ #
5
+ # Errors that are caused by the developer, like declaring a method which
6
+ # overwrites a thor keyword, it SHOULD NOT raise a Thor::Error. This way, we
7
+ # ensure that developer errors are shown with full backtrace.
8
+ class Error < StandardError
9
+ end
10
+
11
+ # Raised when a command was not found.
12
+ class UndefinedCommandError < Error
13
+ end
14
+ UndefinedTaskError = UndefinedCommandError # rubocop:disable ConstantName
15
+
16
+ class AmbiguousCommandError < Error
17
+ end
18
+ AmbiguousTaskError = AmbiguousCommandError # rubocop:disable ConstantName
19
+
20
+ # Raised when a command was found, but not invoked properly.
21
+ class InvocationError < Error
22
+ end
23
+
24
+ class UnknownArgumentError < Error
25
+ end
26
+
27
+ class RequiredArgumentMissingError < InvocationError
28
+ end
29
+
30
+ class MalformattedArgumentError < InvocationError
31
+ end
32
+ end
data/lib/thor/group.rb ADDED
@@ -0,0 +1,281 @@
1
+ require "thor/base"
2
+
3
+ # Thor has a special class called Thor::Group. The main difference to Thor class
4
+ # is that it invokes all commands at once. It also include some methods that allows
5
+ # invocations to be done at the class method, which are not available to Thor
6
+ # commands.
7
+ class Thor::Group # rubocop:disable ClassLength
8
+ class << self
9
+ # The description for this Thor::Group. If none is provided, but a source root
10
+ # exists, tries to find the USAGE one folder above it, otherwise searches
11
+ # in the superclass.
12
+ #
13
+ # ==== Parameters
14
+ # description<String>:: The description for this Thor::Group.
15
+ #
16
+ def desc(description = nil)
17
+ if description
18
+ @desc = description
19
+ else
20
+ @desc ||= from_superclass(:desc, nil)
21
+ end
22
+ end
23
+
24
+ # Prints help information.
25
+ #
26
+ # ==== Options
27
+ # short:: When true, shows only usage.
28
+ #
29
+ def help(shell)
30
+ shell.say "Usage:"
31
+ shell.say " #{banner}\n"
32
+ shell.say
33
+ class_options_help(shell)
34
+ shell.say desc if desc
35
+ end
36
+
37
+ # Stores invocations for this class merging with superclass values.
38
+ #
39
+ def invocations #:nodoc:
40
+ @invocations ||= from_superclass(:invocations, {})
41
+ end
42
+
43
+ # Stores invocation blocks used on invoke_from_option.
44
+ #
45
+ def invocation_blocks #:nodoc:
46
+ @invocation_blocks ||= from_superclass(:invocation_blocks, {})
47
+ end
48
+
49
+ # Invoke the given namespace or class given. It adds an instance
50
+ # method that will invoke the klass and command. You can give a block to
51
+ # configure how it will be invoked.
52
+ #
53
+ # The namespace/class given will have its options showed on the help
54
+ # usage. Check invoke_from_option for more information.
55
+ #
56
+ def invoke(*names, &block) # rubocop:disable MethodLength
57
+ options = names.last.is_a?(Hash) ? names.pop : {}
58
+ verbose = options.fetch(:verbose, true)
59
+
60
+ names.each do |name|
61
+ invocations[name] = false
62
+ invocation_blocks[name] = block if block_given?
63
+
64
+ class_eval <<-METHOD, __FILE__, __LINE__
65
+ def _invoke_#{name.to_s.gsub(/\W/, "_")}
66
+ klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
67
+
68
+ if klass
69
+ say_status :invoke, #{name.inspect}, #{verbose.inspect}
70
+ block = self.class.invocation_blocks[#{name.inspect}]
71
+ _invoke_for_class_method klass, command, &block
72
+ else
73
+ say_status :error, %(#{name.inspect} [not found]), :red
74
+ end
75
+ end
76
+ METHOD
77
+ end
78
+ end
79
+
80
+ # Invoke a thor class based on the value supplied by the user to the
81
+ # given option named "name". A class option must be created before this
82
+ # method is invoked for each name given.
83
+ #
84
+ # ==== Examples
85
+ #
86
+ # class GemGenerator < Thor::Group
87
+ # class_option :test_framework, :type => :string
88
+ # invoke_from_option :test_framework
89
+ # end
90
+ #
91
+ # ==== Boolean options
92
+ #
93
+ # In some cases, you want to invoke a thor class if some option is true or
94
+ # false. This is automatically handled by invoke_from_option. Then the
95
+ # option name is used to invoke the generator.
96
+ #
97
+ # ==== Preparing for invocation
98
+ #
99
+ # In some cases you want to customize how a specified hook is going to be
100
+ # invoked. You can do that by overwriting the class method
101
+ # prepare_for_invocation. The class method must necessarily return a klass
102
+ # and an optional command.
103
+ #
104
+ # ==== Custom invocations
105
+ #
106
+ # You can also supply a block to customize how the option is going to be
107
+ # invoked. The block receives two parameters, an instance of the current
108
+ # class and the klass to be invoked.
109
+ #
110
+ def invoke_from_option(*names, &block) # rubocop:disable MethodLength
111
+ options = names.last.is_a?(Hash) ? names.pop : {}
112
+ verbose = options.fetch(:verbose, :white)
113
+
114
+ names.each do |name|
115
+ unless class_options.key?(name)
116
+ fail ArgumentError, "You have to define the option #{name.inspect} " <<
117
+ "before setting invoke_from_option."
118
+ end
119
+
120
+ invocations[name] = true
121
+ invocation_blocks[name] = block if block_given?
122
+
123
+ class_eval <<-METHOD, __FILE__, __LINE__
124
+ def _invoke_from_option_#{name.to_s.gsub(/\W/, "_")}
125
+ return unless options[#{name.inspect}]
126
+
127
+ value = options[#{name.inspect}]
128
+ value = #{name.inspect} if TrueClass === value
129
+ klass, command = self.class.prepare_for_invocation(#{name.inspect}, value)
130
+
131
+ if klass
132
+ say_status :invoke, value, #{verbose.inspect}
133
+ block = self.class.invocation_blocks[#{name.inspect}]
134
+ _invoke_for_class_method klass, command, &block
135
+ else
136
+ say_status :error, %(\#{value} [not found]), :red
137
+ end
138
+ end
139
+ METHOD
140
+ end
141
+ end
142
+
143
+ # Remove a previously added invocation.
144
+ #
145
+ # ==== Examples
146
+ #
147
+ # remove_invocation :test_framework
148
+ #
149
+ def remove_invocation(*names)
150
+ names.each do |name|
151
+ remove_command(name)
152
+ remove_class_option(name)
153
+ invocations.delete(name)
154
+ invocation_blocks.delete(name)
155
+ end
156
+ end
157
+
158
+ # Overwrite class options help to allow invoked generators options to be
159
+ # shown recursively when invoking a generator.
160
+ #
161
+ def class_options_help(shell, groups = {}) #:nodoc:
162
+ get_options_from_invocations(groups, class_options) do |klass|
163
+ klass.send(:get_options_from_invocations, groups, class_options)
164
+ end
165
+ super(shell, groups)
166
+ end
167
+
168
+ # Get invocations array and merge options from invocations. Those
169
+ # options are added to group_options hash. Options that already exists
170
+ # in base_options are not added twice.
171
+ #
172
+ def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
173
+ invocations.each do |name, from_option|
174
+ value = if from_option
175
+ option = class_options[name]
176
+ option.type == :boolean ? name : option.default
177
+ else
178
+ name
179
+ end
180
+ next unless value
181
+
182
+ klass, _ = prepare_for_invocation(name, value)
183
+ next unless klass && klass.respond_to?(:class_options)
184
+
185
+ value = value.to_s
186
+ human_name = value.respond_to?(:classify) ? value.classify : value
187
+
188
+ group_options[human_name] ||= []
189
+ group_options[human_name] += klass.class_options.values.select do |class_option|
190
+ base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
191
+ !group_options.values.flatten.any? { |i| i.name == class_option.name }
192
+ end
193
+
194
+ yield klass if block_given?
195
+ end
196
+ end
197
+
198
+ # Returns commands ready to be printed.
199
+ def printable_commands(*)
200
+ item = []
201
+ item << banner
202
+ item << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : "")
203
+ [item]
204
+ end
205
+ alias_method :printable_tasks, :printable_commands
206
+
207
+ def handle_argument_error(command, error, args, arity) #:nodoc:
208
+ msg = "#{basename} #{command.name} takes #{arity} argument"
209
+ msg << "s" if arity > 1
210
+ msg << ", but it should not."
211
+ fail error, msg
212
+ end
213
+
214
+ protected
215
+
216
+ # The method responsible for dispatching given the args.
217
+ def dispatch(command, given_args, given_opts, config) #:nodoc:
218
+ if Thor::HELP_MAPPINGS.include?(given_args.first)
219
+ help(config[:shell])
220
+ return
221
+ end
222
+
223
+ args, opts = Thor::Options.split(given_args)
224
+ opts = given_opts || opts
225
+
226
+ instance = new(args, opts, config)
227
+ yield instance if block_given?
228
+
229
+ if command
230
+ instance.invoke_command(all_commands[command])
231
+ else
232
+ instance.invoke_all
233
+ end
234
+ end
235
+
236
+ # The banner for this class. You can customize it if you are invoking the
237
+ # thor class by another ways which is not the Thor::Runner.
238
+ def banner
239
+ "#{basename} #{self_command.formatted_usage(self, false)}"
240
+ end
241
+
242
+ # Represents the whole class as a command.
243
+ def self_command #:nodoc:
244
+ Thor::DynamicCommand.new(namespace, class_options)
245
+ end
246
+ alias_method :self_task, :self_command
247
+
248
+ def baseclass #:nodoc:
249
+ Thor::Group
250
+ end
251
+
252
+ def create_command(meth) #:nodoc:
253
+ commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
254
+ true
255
+ end
256
+ alias_method :create_task, :create_command
257
+ end
258
+
259
+ include Thor::Base
260
+
261
+ protected
262
+
263
+ # Shortcut to invoke with padding and block handling. Use internally by
264
+ # invoke and invoke_from_option class methods.
265
+ def _invoke_for_class_method(klass, command = nil, *args, &block) #:nodoc:
266
+ with_padding do
267
+ if block
268
+ case block.arity
269
+ when 3
270
+ block.call(self, klass, command)
271
+ when 2
272
+ block.call(self, klass)
273
+ when 1
274
+ instance_exec(klass, &block)
275
+ end
276
+ else
277
+ invoke klass, command, *args
278
+ end
279
+ end
280
+ end
281
+ end