In Files

Thor::Base::ClassMethods

Attributes

debugging[RW]

Public Instance Methods

all_tasks() click to toggle source

Returns the tasks for this Thor class and all subclasses.

Returns

OrderedHash

An ordered hash with tasks names as keys and Thor::Task objects as values.

# File lib/thor/base.rb, line 294
def all_tasks
  @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
  @all_tasks.merge(tasks)
end
argument(name, options={}) click to toggle source

Adds an argument to the class and creates an attr_accessor for it.

Arguments are different from options in several aspects. The first one is how they are parsed from the command line, arguments are retrieved from position:

thor task NAME

Instead of:

thor task --name=NAME

Besides, arguments are used inside your code as an accessor (self.argument), while options are all kept in a hash (self.options).

Finally, arguments cannot have type :default or :boolean but can be optional (supplying :optional => :true or :required => false), although you cannot have a required argument after a non-required argument. If you try it, an error is raised.

Parameters

name<Symbol>

The name of the argument.

options<Hash>

Described below.

Options

:desc - Description for the argument. :required - If the argument is required or not. :optional - If the argument is optional or not. :type - The type of the argument, can be :string, :hash, :array, :numeric. :default - Default value for this argument. It cannot be required and have default values. :banner - String to show on usage notes.

Errors

ArgumentError

Raised if you supply a required argument after a non required one.

# File lib/thor/base.rb, line 160
def argument(name, options={})
  is_thor_reserved_word?(name, :argument)
  no_tasks { attr_accessor name }

  required = if options.key?(:optional)
    !options[:optional]
  elsif options.key?(:required)
    options[:required]
  else
    options[:default].nil?
  end

  remove_argument name

  arguments.each do |argument|
    next if argument.required?
    raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
                         "the non-required argument #{argument.human_name.inspect}."
  end if required

  arguments << Thor::Argument.new(name, options[:desc], required, options[:type],
                                        options[:default], options[:banner])
end
arguments() click to toggle source

Returns this class arguments, looking up in the ancestors chain.

Returns

Array

# File lib/thor/base.rb, line 189
def arguments
  @arguments ||= from_superclass(:arguments, [])
end
check_unknown_options!() click to toggle source

If you want to raise an error for unknown options, call check_unknown_options! This is disabled by default to allow dynamic invocations.

# File lib/thor/base.rb, line 113
def check_unknown_options!
  @check_unknown_options = true
end
class_option(name, options={}) click to toggle source

Adds an option to the set of class options

Parameters

name<Symbol>

The name of the argument.

options<Hash>

Described below.

Options

:desc - Description for the argument. :required - If the argument is required or not. :default - Default value for this argument. :group - The group for this options. Use by class options to output options in different levels. :aliases - Aliases for this option. :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean. :banner - String to show on usage notes.

# File lib/thor/base.rb, line 223
def class_option(name, options={})
  build_option(name, options, class_options)
end
class_options(options=nil) click to toggle source

Adds a bunch of options to the set of class options.

class_options :foo => false, :bar => :required, :baz => :string

If you prefer more detailed declaration, check class_option.

Parameters

Hash[Symbol => Object]

# File lib/thor/base.rb, line 202
def class_options(options=nil)
  @class_options ||= from_superclass(:class_options, {})
  build_options(options, @class_options) if options
  @class_options
end
group(name=nil) click to toggle source

Defines the group. This is used when thor list is invoked so you can specify that only tasks from a pre-defined group will be shown. Defaults to standard.

Parameters

name<String|Symbol>

# File lib/thor/base.rb, line 269
def group(name=nil)
  case name
    when nil
      @group ||= from_superclass(:group, 'standard')
    else
      @group = name.to_s
  end
end
namespace(name=nil) click to toggle source

Sets the namespace for the Thor or Thor::Group class. By default the namespace is retrieved from the class name. If your Thor class is named Scripts::MyScript, the help method, for example, will be called as:

thor scripts:my_script -h

If you change the namespace:

namespace :my_scripts

You change how your tasks are invoked:

thor my_scripts -h

Finally, if you change your namespace to default:

namespace :default

Your tasks can be invoked with a shortcut. Instead of:

thor :my_task
# File lib/thor/base.rb, line 369
def namespace(name=nil)
  case name
  when nil
    @namespace ||= Thor::Util.namespace_from_thor_class(self)
  else
    @namespace = name.to_s
  end
end
no_tasks() click to toggle source

All methods defined inside the given block are not added as tasks.

So you can do:

class MyScript < Thor
  no_tasks do
    def this_is_not_a_task
    end
  end
end

You can also add the method and remove it from the task list:

class MyScript < Thor
  def this_is_not_a_task
  end
  remove_task :this_is_not_a_task
end
# File lib/thor/base.rb, line 340
def no_tasks
  @no_tasks = true
  yield
ensure
  @no_tasks = false
end
public_task(*names) click to toggle source

Allows to use private methods from parent in child classes as tasks.

Paremeters

names<Array>:: Method names to be used as tasks

Examples

public_task :foo
public_task :foo, :bar, :baz
# File lib/thor/base.rb, line 405
def public_task(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end"
  end
end
remove_argument(*names) click to toggle source

Removes a previous defined argument. If :undefine is given, undefine accessors as well.

Paremeters

names<Array>

Arguments to be removed

Examples

remove_argument :foo
remove_argument :foo, :bar, :baz, :undefine => true
# File lib/thor/base.rb, line 238
def remove_argument(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}

  names.each do |name|
    arguments.delete_if { |a| a.name == name.to_s }
    undef_method name, "#{name}=" if options[:undefine]
  end
end
remove_class_option(*names) click to toggle source

Removes a previous defined class option.

Paremeters

names<Array>

Class options to be removed

Examples

remove_class_option :foo
remove_class_option :foo, :bar, :baz
# File lib/thor/base.rb, line 257
def remove_class_option(*names)
  names.each do |name|
    class_options.delete(name)
  end
end
remove_task(*names) click to toggle source

Removes a given task from this Thor class. This is usually done if you are inheriting from another class and don't want it to be available anymore.

By default it only remove the mapping to the task. But you can supply :undefine => true to undefine the method from the class as well.

Parameters

name<Symbol|String>

The name of the task to be removed

options<Hash>

You can give :undefine => true if you want tasks the method to be undefined from the class as well.

# File lib/thor/base.rb, line 311
def remove_task(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}

  names.each do |name|
    tasks.delete(name.to_s)
    all_tasks.delete(name.to_s)
    undef_method name if options[:undefine]
  end
end
start(given_args=ARGV, config={}) click to toggle source

Parses the task and options from the given args, instantiate the class and invoke the task. This method is used when the arguments must be parsed from an array. If you are inside Ruby and want to use a Thor class, you can simply initialize it:

script = MyScript.new(args, options, config)
script.invoke(:task, first_arg, second_arg, third_arg)
# File lib/thor/base.rb, line 386
def start(given_args=ARGV, config={})
  self.debugging = given_args.delete("--debug")
  config[:shell] ||= Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Thor::Error => e
  debugging ? (raise e) : config[:shell].error(e.message)
  exit(1) if exit_on_failure?
end
tasks() click to toggle source

Returns the tasks for this Thor class.

Returns

OrderedHash

An ordered hash with tasks names as keys and Thor::Task objects as values.

# File lib/thor/base.rb, line 284
def tasks
  @tasks ||= Thor::CoreExt::OrderedHash.new
end

Protected Instance Methods

basename() click to toggle source

The basename of the program invoking the thor class.

# File lib/thor/base.rb, line 553
def basename
  File.basename($0).split(' ').first
end
exit_on_failure?() click to toggle source

A flag that makes the process exit with status 1 if any error happens.

# File lib/thor/base.rb, line 546
def exit_on_failure?
  false
end
from_superclass(method, default=nil) click to toggle source

Retrieves a value from superclass. If it reaches the baseclass, returns default.

# File lib/thor/base.rb, line 536
def from_superclass(method, default=nil)
  if self == baseclass || !superclass.respond_to?(method, true)
    default
  else
    value = superclass.send(method)
    value.dup if value
  end
end
inherited(klass) click to toggle source

Everytime someone inherits from a Thor class, register the klass and file into baseclass.

# File lib/thor/base.rb, line 510
def inherited(klass)
  Thor::Base.register_klass_file(klass)
end
method_added(meth) click to toggle source

Fire this callback whenever a method is added. Added methods are tracked as tasks by invoking the create_task method.

# File lib/thor/base.rb, line 516
def method_added(meth)
  meth = meth.to_s

  if meth == "initialize"
    initialize_added
    return
  end

  # Return if it's not a public instance method
  return unless public_instance_methods.include?(meth) ||
                public_instance_methods.include?(meth.to_sym)

  return if @no_tasks || !create_task(meth)

  is_thor_reserved_word?(meth, :task)
  Thor::Base.register_klass_file(self)
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.