Methods

Thor::Invocation

Public Instance Methods

invoke(name=nil, task=nil, args=nil, opts=nil, config=nil) click to toggle source

Receives a name and invokes it. The name can be a string (either “task” or “namespace:task”), a Thor::Task, a Class or a Thor instance. If the task cannot be guessed by name, it can also be supplied as second argument.

You can also supply the arguments, options and configuration values for the task to be invoked, if none is given, the same values used to initialize the invoker are used to initialize the invoked.

Examples

  class A < Thor
    def foo
      invoke :bar
      invoke "b:hello", ["José"]
    end

    def bar
      invoke "b:hello", ["José"]
    end
  end

  class B < Thor
    def hello(name)
      puts "hello #{name}"
    end
  end

You can notice that the method “foo” above invokes two tasks: “bar”, which belongs to the same class and “hello” which belongs to the class B.

By using an invocation system you ensure that a task is invoked only once. In the example above, invoking “foo” will invoke “b:hello” just once, even if it’s invoked later by “bar” method.

When class A invokes class B, all arguments used on A initialization are supplied to B. This allows lazy parse of options. Let’s suppose you have some rspec tasks:

  class Rspec < Thor::Group
    class_option :mock_framework, :type => :string, :default => :rr

    def invoke_mock_framework
      invoke "rspec:#{options[:mock_framework]}"
    end
  end

As you noticed, it invokes the given mock framework, which might have its own options:

  class Rspec::RR < Thor::Group
    class_option :style, :type => :string, :default => :mock
  end

Since it’s not rspec concern to parse mock framework options, when RR is invoked all options are parsed again, so RR can extract only the options that it’s going to use.

If you want Rspec::RR to be initialized with its own set of options, you have to do that explicitely:

  invoke "rspec:rr", [], :style => :foo

Besides giving an instance, you can also give a class to invoke:

  invoke Rspec::RR, [], :style => :foo
     # File lib/thor/invocation.rb, line 95
 95:     def invoke(name=nil, task=nil, args=nil, opts=nil, config=nil)
 96:       task, args, opts, config = nil, task, args, opts if task.nil? || task.is_a?(Array)
 97:       args, opts, config = nil, args, opts if args.is_a?(Hash)
 98: 
 99:       object, task    = _prepare_for_invocation(name, task)
100:       klass, instance = _initialize_klass_with_initializer(object, args, opts, config)
101: 
102:       method_args = []
103:       current = @_invocations[klass]
104: 
105:       iterator = proc do |_, task|
106:         unless current.include?(task.name)
107:           current << task.name
108:           task.run(instance, method_args)
109:         end
110:       end
111: 
112:       if task
113:         args ||= []
114:         method_args = args[Range.new(klass.arguments.size, -1)] || []
115:         iterator.call(nil, task)
116:       else
117:         klass.all_tasks.map(&iterator)
118:       end
119:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.