class Substation::Chain::Definition

Encapsulates an ordered list of {Processor} instances to be used within an instance of {Chain}

Constants

EMPTY

An empty instance

Attributes

name[R]

The name of the chain

@return [Symbol]

@api private

processors[R]

The processors used in this instance

@return [Enumerable<#call>]

@api private

Public Class Methods

new(name, processors) click to toggle source

Initialize a new instance

@param [Enumerable<#call>] processors

the processors to be used within this instance

@return [undefined]

@api private

# File lib/substation/chain/definition.rb, line 36
def initialize(name, processors)
  @name, @processors = name, []
  processors.each(&method(:<<))
end

Public Instance Methods

<<(processor) click to toggle source

Append processor to {#processors}

@param [#call] processor

the processor to append

@return [self]

@api private

# File lib/substation/chain/definition.rb, line 49
def <<(processor)
  raise_duplicate_processor_error([processor]) if include?(processor)
  processors << processor
  self
end
prepend(other) click to toggle source

Returns a new instance with other's processors prepended

@param [Definition] other

the definition to prepend

@return [Definition]

@api private

# File lib/substation/chain/definition.rb, line 85
def prepend(other)
  duplicates = processors & other.processors
  raise_duplicate_processor_error(duplicates) if duplicates.any?
  self.class.new(name, other.processors | processors)
end
replace_failure_chain(processor_name, failure_chain) click to toggle source

Replace the failure chain of the processor identified by name

@param [Symbol] processor_name

the name of the processor

@param [Chain] failure_chain

the failure chain to use in the replaced processor

@return [self]

@api private

# File lib/substation/chain/definition.rb, line 71
def replace_failure_chain(processor_name, failure_chain)
  idx = fetch(processor_name)
  processors[idx] = processors.at(idx).with_failure_chain(failure_chain)
  self
end

Private Instance Methods

fetch(processor_name) click to toggle source

Return the index for a processor with the given name

@param [Symbol] name

the processor's name

@return [Integer]

@raise [UnknownProcessor]

@api private

# File lib/substation/chain/definition.rb, line 103
def fetch(processor_name)
  idx = processors.index {|processor| processor.name.equal?(processor_name)}
  idx or raise(UnknownProcessor.new(processor_name))
end
raise_duplicate_processor_error(dupes) click to toggle source

Raise {DuplicateProcessorError} with a message tailored for dupes

@param [Processor, Array<Processor>] dupes

one or many duplicate processors

@raise [DuplicateProcessorError]

@api private

# File lib/substation/chain/definition.rb, line 116
def raise_duplicate_processor_error(dupes)
  raise DuplicateProcessorError.new(dupes)
end