class Hippo_eyeDoc::TransactionSets::Base

Attributes

components[RW]
identifier[RW]
GE[RW]
GS[RW]
IEA[RW]
ISA[RW]
parent[RW]
sequences[RW]
values[RW]

Public Class Methods

add_component(klass, options={}) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 20
def add_component(klass, options={})
  components << Component.new(options.merge(:klass => klass, :sequence => components.length))
end
Also aliased as: segment, loop
grouped_components() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 27
def grouped_components
  @grouped_components ||= build_grouped_components
end
loop(klass, options={})
Alias for: add_component
loop_name(id) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 16
def loop_name(id)
  @identifier = id
end
new(options = {}) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 53
def initialize(options = {})
  @parent = options[:parent]
  @ISA    = options[:ISA]
  @GS     = options[:GS]
  @GE     = options[:GE]
  @IEA    = options[:IEA]

  super

  populate(options[:segments]) if options[:segments]
end
segment(klass, options={})
Alias for: add_component

Private Class Methods

build_grouped_components() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 31
def build_grouped_components
  output     = []
  last_entry = nil

  components.each do |component|
    if component.segment?
      output << [] if last_entry != :segment
      output.last << component
      last_entry = :segment
    else
      output << component
      last_entry = :transaction_set
    end
  end

  output
end

Public Instance Methods

ancestors() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 166
def ancestors
  if parent
    [parent, parent.ancestors].flatten
  else
    []
  end
end
get_component(identifier, sequence = nil) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 189
def get_component(identifier, sequence = nil)
  if sequence.nil?
    sequence = 0
  else
    sequence = sequence.to_i - 1
  end

  self.class.components.select do |c|
    c.identifier == identifier
  end[sequence]
end
get_component_by_name(name, sequence = nil) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 201
def get_component_by_name(name, sequence = nil)
  sequence =  if sequence.nil?
                0
              else
                sequence.to_i - 1
              end

  self.class.components.select do |c|
    if name.class == Regexp
      c.options[:name] =~ name
    else
      c.options[:name] == name
    end
  end[sequence]
end
increment(segment_identifier) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 144
def increment(segment_identifier)
  @sequences ||= Hash.new(0)

  @sequences[segment_identifier] += 1
end
method_missing(method_name, *args) { |values| ... } click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 217
def method_missing(method_name, *args)
  component = if method_name == :find_by_name
                get_component_by_name(args[0], args[1])
              else
                component_name, component_sequence = method_name.to_s.split('_')
                get_component(component_name, component_sequence)
              end

  if component.nil?
    raise Hippo_eyeDoc::Exceptions::InvalidSegment.new "Invalid segment specified: '#{method_name.to_s}'."
  end

  values[component.sequence] ||= component.initialize_component(self)

  yield values[component.sequence] if block_given?

  values[component.sequence]
end
populate(segments) click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 65
def populate(segments)
  grouped_components = self.class.grouped_components

  grouped_components.each_with_index do |component, component_index|
    if component.class == Array
      # segments
      starting_segment_count = segments.count
      ending_segment_count   = 0

      while starting_segment_count > ending_segment_count
        starting_segment_count = segments.count

        component.each do |individual_component|
          segment = segments.first

          break unless segment
          next unless individual_component.valid?(segment)
          next unless individual_component.conditions_match?(self, segment)

          segment.parent = self

          if individual_component.repeating?
            values[individual_component.sequence] ||= individual_component.initialize_component(self)
            values[individual_component.sequence] << segment
          else
            values[individual_component.sequence] = segment
          end

          segments.delete(segment)
        end

        ending_segment_count = segments.count
      end
    else
      # loops
      while true do
        initial_segment = segments.first

        break unless initial_segment
        break unless component.valid?(initial_segment)
        break unless component.conditions_match?(self, initial_segment)

        component_matches_found  = []
        starting_index = component.repeating? ? component_index : component_index + 1

        grouped_components.slice(starting_index, grouped_components.length - starting_index).each do |next_component|
          index =  segments.find_index do |segment|
                      if segment == segments.first
                        false
                      elsif next_component.class == Array
                         next_component.any?{|subcomponent| subcomponent.valid?(segment)}
                      else
                        next_component.valid?(segment)
                      end
                    end

          component_matches_found << index if index
        end

        child_segments = segments.slice!(0, component_matches_found.min || segments.length)
        values[component.sequence] ||= component.initialize_component(self)
        if component.repeating?
          values[component.sequence].build {|comp| comp.populate(child_segments) }
        else
          values[component.sequence].populate(child_segments)
        end
      end
    end
  end

  unless segments.empty?
    raise Hippo_eyeDoc::Exceptions::ParseError.new "Remaining Segments for #{self.class.identifier} after parsing was completed. Segments remaining: \n" + segments.map(&:to_s).join("\n")
  end
end
segment?() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 150
def segment?
  false
end
segment_count() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 162
def segment_count
  segments.count
end
segments() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 158
def segments
  values.values.collect(&:segments).flatten
end
to_a()
Alias for: to_ary
to_ary() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 174
def to_ary
  nil
end
Also aliased as: to_a
to_s() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 179
def to_s
  output = ''

  values.sort.each do |sequence, component|
    output += component.to_s
  end

  output
end
transaction_set?() click to toggle source
# File lib/hippo_eyeDoc/transaction_sets/base.rb, line 154
def transaction_set?
  true
end