class Thor::Command
def formatted_usage(klass, namespace = true, subcommand = false)
Returns the formatted usage by injecting given required arguments
def formatted_usage(klass, namespace = true, subcommand = false) if ancestor_name formatted = "#{ancestor_name} ".dup # add space elsif namespace namespace = klass.namespace formatted = "#{namespace.gsub(/^(default)/, '')}:".dup end formatted ||= "#{klass.namespace.split(':').last} ".dup if subcommand formatted ||= "".dup Array(usage).map do |specific_usage| formatted_specific_usage = formatted formatted_specific_usage += required_arguments_for(klass, specific_usage) # Add required options formatted_specific_usage += " #{required_options}" # Strip and go! formatted_specific_usage.strip end.join("\n") end
def handle_argument_error?(instance, error, caller)
def handle_argument_error?(instance, error, caller) not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && begin saned = sans_backtrace(error.backtrace, caller) saned.empty? || saned.size == 1 end end
def handle_no_method_error?(instance, error, caller)
def handle_no_method_error?(instance, error, caller) not_debugging?(instance) && error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/ end
def hidden?
def hidden? false end
def initialize(name, description, long_description, usage, options = nil)
def initialize(name, description, long_description, usage, options = nil) super(name.to_s, description, long_description, usage, options || {}) end
def initialize_copy(other) #:nodoc:
def initialize_copy(other) #:nodoc: super(other) self.options = other.options.dup if other.options end
def local_method?(instance, name)
def local_method?(instance, name) methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false) !(methods & [name.to_s, name.to_sym]).empty? end
def not_debugging?(instance)
def not_debugging?(instance) !(instance.class.respond_to?(:debugging) && instance.class.debugging) end
def private_method?(instance)
def private_method?(instance) !(instance.private_methods & [name.to_s, name.to_sym]).empty? end
def public_method?(instance) #:nodoc:
Given a target, checks if this class name is a public method.
def public_method?(instance) #:nodoc: !(instance.public_methods & [name.to_s, name.to_sym]).empty? end
def required_arguments_for(klass, usage)
def required_arguments_for(klass, usage) if klass && !klass.arguments.empty? usage.to_s.gsub(/^#{name}/) do |match| match << " " << klass.arguments.map(&:usage).compact.join(" ") end else usage.to_s end end
def required_options
def required_options @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(" ") end
def run(instance, args = [])
By default, a command invokes a method in the thor class. You can change this
def run(instance, args = []) arity = nil if private_method?(instance) instance.class.handle_no_command_error(name) elsif public_method?(instance) arity = instance.method(name).arity instance.__send__(name, *args) elsif local_method?(instance, :method_missing) instance.__send__(:method_missing, name.to_sym, *args) else instance.class.handle_no_command_error(name) end rescue ArgumentError => e handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e) rescue NoMethodError => e handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (raise e) end
def sans_backtrace(backtrace, caller) #:nodoc:
def sans_backtrace(backtrace, caller) #:nodoc: saned = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) || (frame =~ %r{^kernel/} && RUBY_ENGINE =~ /rbx/) } saned - caller end