123456789_123456789_123456789_123456789_123456789_

Module: Bundler::Thor::Base

Relationships & Source Files
Namespace Children
Modules:
ClassMethods
Extension / Inclusion / Inheritance Descendants
Included In:
::Bundler::CLI, ::Bundler::CLI::Config, ::Bundler::CLI::Plugin, ::Bundler::Thor, Group, Runner
Defined in: lib/bundler/vendor/thor/lib/thor/base.rb,
lib/bundler/vendor/thor/lib/thor/shell.rb

Class Attribute Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Class Attribute Details

.shell (rw)

Returns the shell used in all ::Bundler::Thor classes. If you are in a Unix platform it will use a colored log, otherwise it will use a basic one without color.

[ GitHub ] 

  


# File 'lib/bundler/vendor/thor/lib/thor/shell.rb', line 11



def shell
  @shell ||= if ENV["THOR_SHELL"] && !ENV["THOR_SHELL"].empty?
    Bundler::Thor::Shell.const_get(ENV["THOR_SHELL"])
  elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
    Bundler::Thor::Shell::Basic
  else
    Bundler::Thor::Shell::Color
  end
end


  








  

    .shell=(value)   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/shell.rb', line 6



attr_writer :shell


  







Class Method Details



  

    .included(base)  
  

  

    This method is for internal use only.
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 116



def included(base) #:nodoc:
  super(base)
  base.extend ClassMethods
  base.send :include, Invocation
  base.send :include, Shell
end


  








  

    .register_klass_file(klass)  
  

  

    This method is for internal use only.
  



  

    

Whenever a class inherits from ::Bundler::Thor or Group, we should track the class and the file on Base. This is the method responsible for it.


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 144



def register_klass_file(klass) #:nodoc:
  file = caller[1].match(/(.*):\d+/)[1]
  Bundler::Thor::Base.subclasses << klass unless Bundler::Thor::Base.subclasses.include?(klass)

  file_subclasses = Bundler::Thor::Base.subclass_files[File.expand_path(file)]
  file_subclasses << klass unless file_subclasses.include?(klass)
end


  








  

    .subclass_files  
  



  

    

Returns the files where the subclasses are kept.



Returns



Hash[path<String> => Class]


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 137



def subclass_files
  @subclass_files ||= Hash.new { |h, k| h[k] = [] }
end


  








  

    .subclasses  
  



  

    

Returns the classes that inherits from ::Bundler::Thor or Group.



Returns



Array


  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 128



def subclasses
  @subclasses ||= []
end


  







Instance Attribute Details



  

    #args   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 35



attr_accessor :options, :parent_options, :args


  








  

    #options   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 35



attr_accessor :options, :parent_options, :args


  








  

    #parent_options   (rw)
  

  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 35



attr_accessor :options, :parent_options, :args


  







Instance Method Details



  

    #initialize(args = [], local_options = {}, config = {})  
  



  

    

It receives arguments in an Array and two hashes, one for options and other for configuration.



Notice that it does not check if all required arguments were supplied. It should be done by the parser.



Parameters


args<Array>



An array of objects. The objects are applied to their respective accessors declared with argument.


options<Hash>



An options hash that will be available as self.options. The hash given is converted to a hash with indifferent access, magic predicates (options.skip?) and then frozen.


config<Hash>



Configuration for this ::Bundler::Thor class.




  



  [ GitHub ]


  

  


# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 53



def initialize(args = [], local_options = {}, config = {})
  parse_options = self.class.class_options

  # The start method splits inbound arguments at the first argument
  # that looks like an option (starts with - or --). It then calls
  # new, passing in the two halves of the arguments Array as the
  # first two parameters.

  command_options = config.delete(:command_options) # hook for start
  parse_options = parse_options.merge(command_options) if command_options

  if local_options.is_a?(Array)
    array_options = local_options
    hash_options = {}
  else
    # Handle the case where the class was explicitly instantiated
    # with pre-parsed options.
    array_options = []
    hash_options = local_options
  end

  # Let Bundler::Thor::Options parse the options first, so it can remove
  # declared options from the array. This will leave us with
  # a list of arguments that weren't declared.
  current_command = config[:current_command]
  stop_on_unknown = self.class.stop_on_unknown_option? current_command

  # Give a relation of options.
  # After parsing, Bundler::Thor::Options check whether right relations are kept
  relations = if current_command.nil?
    {exclusive_option_names: [], at_least_one_option_names: []}
  else
    current_command.options_relation
  end

  self.class.class_exclusive_option_names.map { |n| relations[:exclusive_option_names] << n }
  self.class.class_at_least_one_option_names.map { |n| relations[:at_least_one_option_names] << n }

  disable_required_check = self.class.disable_required_check? current_command

  opts = Bundler::Thor::Options.new(parse_options, hash_options, stop_on_unknown, disable_required_check, relations)

  self.options = opts.parse(array_options)
  self.options = config[:class_options].merge(options) if config[:class_options]

  # If unknown options are disallowed, make sure that none of the
  # remaining arguments looks like an option.
  opts.check_unknown! if self.class.check_unknown_options?(config)

  # Add the remaining arguments from the options parser to the
  # arguments passed in to initialize. Then remove any positional
  # arguments declared using #argument (this is primarily used
  # by Bundler::Thor::Group). Tis will leave us with the remaining
  # positional arguments.
  to_parse  = args
  to_parse += opts.remaining unless self.class.strict_args_position?(config)

  thor_args = Bundler::Thor::Arguments.new(self.class.arguments)
  thor_args.parse(to_parse).each { |k, v| __send__("#{k}=", v) }
  @args = thor_args.remaining
end