module Thor::Base
def self.shell
it will use a colored log, otherwise it will use a basic one without color.
Returns the shell used in all Thor classes. If you are in a Unix platform
def self.shell @shell ||= if ENV['THOR_SHELL'] && ENV['THOR_SHELL'].size > 0 Thor::Shell.const_get(ENV['THOR_SHELL']) elsif ((RbConfig::CONFIG['host_os'] =~ /mswin|mingw/) && !(ENV['ANSICON'])) Thor::Shell::Basic else Thor::Shell::Color end end
def self.shell=(klass)
Sets the shell used in all Thor classes.
def self.shell=(klass) @shell = klass end
def included(base) #:nodoc:
def included(base) #:nodoc: base.send :extend, ClassMethods base.send :include, Invocation base.send :include, Shell end
def initialize(args=[], options={}, config={})
config
access, magic predicates (options.skip?) and then frozen.
The hash given is converted to a hash with indifferent
options
respective accessors declared with argument.
args
==== Parameters
It should be done by the parser.
Notice that it does not check if all required arguments were supplied.
other for configuration.
It receives arguments in an Array and two hashes, one for options and
def initialize(args=[], 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. if options.is_a?(Array) command_options = config.delete(:command_options) # hook for start parse_options = parse_options.merge(command_options) if command_options array_options, hash_options = options, {} else # Handle the case where the class was explicitly instantiated # with pre-parsed options. array_options, hash_options = [], options end # Let 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. stop_on_unknown = self.class.stop_on_unknown_option? config[:current_command] opts = Thor::Options.new(parse_options, hash_options, stop_on_unknown) self.options = opts.parse(array_options) self.options = config[:class_options].merge(self.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 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 = Thor::Arguments.new(self.class.arguments) thor_args.parse(to_parse).each { |k,v| __send__("#{k}=", v) } @args = thor_args.remaining end
def register_klass_file(klass) #:nodoc:
class and the file on Thor::Base. This is the method responsable for it.
Whenever a class inherits from Thor or Thor::Group, we should track the
def register_klass_file(klass) #:nodoc: file = caller[1].match(/(.*):\d+/)[1] Thor::Base.subclasses << klass unless Thor::Base.subclasses.include?(klass) file_subclasses = Thor::Base.subclass_files[File.expand_path(file)] file_subclasses << klass unless file_subclasses.include?(klass) end
def subclass_files
Hash[path
==== Returns
Returns the files where the subclasses are kept.
def subclass_files @subclass_files ||= Hash.new{ |h,k| h[k] = [] } end
def subclasses
Array[Class]
==== Returns
Returns the classes that inherits from Thor or Thor::Group.
def subclasses @subclasses ||= [] end