123456789_123456789_123456789_123456789_123456789_

Class: Bundler::Thor::Command

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Subclasses:
DynamicCommand, HiddenCommand
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, Struct
Instance Chain:
self, Struct
Inherits: Struct
  • Object
Defined in: lib/bundler/vendor/thor/lib/thor/command.rb

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(name, description, long_description, usage, options = nil) ⇒ Command

[ GitHub ] 

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 5



def initialize(name, description, long_description, usage, options = nil)
  super(name.to_s, description, long_description, usage, options || {})
end


  







Instance Attribute Details



  

    #ancestor_name   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  








  

    #description   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  








  

    #hidden?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 14



def hidden?
  false
end


  








  

    #long_description   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  








  

    #name   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  








  

    #options   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  








  

    #usage   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 2



class Command < Struct.new(:name, :description, :long_description, :usage, :options, :ancestor_name)


  







Instance Method Details



  

    #formatted_usage(klass, namespace = true, subcommand = false)  
  



  

    

Returns the formatted usage by injecting given required arguments and required options into the given usage.


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 41



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


  








  

    #handle_argument_error?(instance, error, caller)  ⇒ Boolean  (protected)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 105



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


  








  

    #handle_no_method_error?(instance, error, caller)  ⇒ Boolean  (protected)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 112



def handle_no_method_error?(instance, error, caller)
  not_debugging?(instance) &&
    error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
end


  








  

    #initialize_copy(other)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 9



def initialize_copy(other) #:nodoc:
  super(other)
  self.options = other.options.dup if other.options
end


  








  

    #local_method?(instance, name)  ⇒ Boolean  (protected)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 95



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


  








  

    #not_debugging?(instance)  ⇒ Boolean  (protected)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 78



def not_debugging?(instance)
  !(instance.class.respond_to?(:debugging) && instance.class.debugging)
end


  








  

    #private_method?(instance)  ⇒ Boolean  (protected)
  



  

    
  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 91



def private_method?(instance)
  !(instance.private_methods & [name.to_s, name.to_sym]).empty?
end


  








  

    #public_method?(instance)  ⇒ Boolean  (protected)
  

  

    This method is for internal use only.
  



  

    

Given a target, checks if this class name is a public method.


  





  


  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 87



def public_method?(instance) #:nodoc:
  !(instance.public_methods & [name.to_s, name.to_sym]).empty?
end


  








  

    #required_arguments_for(klass, usage)   (protected)
  



  

    

Add usage with required arguments


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 68



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


  








  

    #required_options   (protected)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 82



def required_options
  @required_options ||= options.map { |_, o| o.usage if o.required? }.compact.sort.join(" ")
end


  








  

    #run(instance, args = [])  
  



  

    

By default, a command invokes a method in the thor class. You can change this implementation to create custom commands.


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 20



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


  








  

    #sans_backtrace(backtrace, caller)   (protected)
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/command.rb', line 100



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