class Rootage::Item

‘Item` is an atomic unit of Rootage, for holding infomations and processes.

Public Instance Methods

assign(name=self.key, &block) click to toggle source

Define an assignment process. This assigns the result value of the block to model. This is same as action excluding model assignment.

@param name [Symbol]

key name for model

@yieldparam val [Object]

normalized option value
# File lib/rootage/core.rb, line 47
def assign(name=self.key, &block)
  self.processes << Proc.new do |scenario, args|
    catch(:rootage_process_failure) do
      res = get_process_context_class(scenario).new(scenario).instance_exec(*args, &block)
      if name
        scenario.model[name] = res
      end
    end
  end
end
condition(&block) click to toggle source

Define a condition. This is a process simply, but quits the action halfway if it fails.

@yieldparam val [Object]

arbitrary value, this is passed from #execute
# File lib/rootage/core.rb, line 63
def condition(&block)
  self.processes << Proc.new do |scenario, args|
    res = catch(:rootage_process_failure) do
      get_process_context_class(scenario).new(scenario).instance_exec(*args, &block)
      true
    end
    throw :rootage_item_stop unless res
  end
end
copy() click to toggle source

Copy the object. This is shallow copy, but arrays are cloned.

@return [Item]

copied object
# File lib/rootage/core.rb, line 92
def copy
  self.class.new.tap do |obj|
    self.each_pair do |key, val|
      obj.set(key => (val.is_a?(Array) or val.is_a?(Hash)) ? val.clone : val)
    end
  end
end
exception(*exceptions, &block) click to toggle source

Define an exception handler.

@param exceptions [Array<Class>]

exception classes that handler should handle, that is assumed `StandardError` if empty

@yieldparam e [Exception]

raised exception object

@yieldparam args [Array]

arbitrary objects
# File lib/rootage/core.rb, line 81
def exception(*exceptions, &block)
  if exceptions.empty?
    exceptions = [StandardError]
  end
  self.exception_handlers << ExceptionHandler.new(exceptions, block)
end
execute(scenario, *args) click to toggle source

Execute the action.

@param scenario [Scenario]

scenario

@param args [Array]

arbitrary objects, this is passed to process's block

@return [void]

# File lib/rootage/core.rb, line 107
def execute(scenario, *args)
  catch(:rootage_item_stop) do
    processes.each {|block| self.instance_exec(scenario, args, &block)}
  end
rescue Exception => e
  catch(:rootage_item_stop) do
    if exception_handlers.find do |handler|
        catch(:rootage_process_failure) do
          handler.try_to_handle(get_process_context_class(scenario).new(scenario), e, args)
        end
      end
    else
      raise
    end
  end
end
key() click to toggle source

Return the key of model.

# File lib/rootage/core.rb, line 125
def key
  (key_name || name).to_sym
end
process(&block) click to toggle source

Define a process that is executed just after pre-process. This is used for setting values excluding command model, for example global values.

@yieldparam val [Object]

arbitrary value, this is passed from #execute
# File lib/rootage/core.rb, line 32
def process(&block)
  self.processes << Proc.new do |scenario, args|
    catch(:rootage_process_failure) do
      get_process_context_class(scenario).new(scenario).instance_exec(*args, &block)
    end
  end
end

Private Instance Methods

get_process_context_class(scenario) click to toggle source
# File lib/rootage/core.rb, line 131
def get_process_context_class(scenario)
  process_context_class || scenario.process_context_class
end