hippo 0.2.1 → 0.2.2

data/CHANGELOG

@@ -1,3 +1,19 @@
+0.2.2 - 2012/01/25
+  * Fix issue with segment parsing.  Make sure to set each segments parent
+    properly once we identify that it belongs in the particular transaction
+    set.  (This allows traversing via segment.parent.parent.)
+  * Add ancestors method to TransactionSet::Base,TransactionSet::RepeatingComponent,
+    and Segments::Base which returns an array containing each ancestor (parent)
+    from the current segment to the outermost containing element.
+  * Fix issue causing non-required fields to be blank filled.
+  * Refactor Field#string_value and Field#formatted_value to handle more situations.
+  * Add segments method to TransactionSet::Base,TransactionSet::RepeatingComponent,
+    and Segments::Base which returns a flattened array of segments within each
+    container.  (Segment::Base simply returns [self].)
+  * Refactor TransactionSet::Base#segment_count to use new segments array.
+  * Add shortcut methods to Hippo::Parser for parse_file and parse_string.  Now they
+    can be called without creating an instance of Parser. (i.e Hippo::Parser.parse_string(s))
+  * Fix issue causing access to empty composite fields to throw an error ([] for NilClass).
 0.2.1 - 2012/01/21
   * Fix issue preventing fixed width segments from printing
     properly. (Non set fields on ISA were empty not padded.)

data/README.md

@@ -40,45 +40,45 @@ guide please review [test/test_hipaa_837.rb](/promedical/hippo/blob/master/test/
 Below is a small sample of how to create a transaction set.
 
 ```ruby
-    ts = Hippo::TransactionSets::HIPAA_837::Base.new
-
-    ts.ST do |st|
-      st.TransactionSetControlNumber        = '0021'
-      st.ImplementationConventionReference  = '005010X222A1'
-    end
-
-    ts.BHT do |bht|
-      bht.TransactionSetPurposeCode = '00'
-      bht.ReferenceIdentification   = '244579'
-      bht.Date                      = '20061015'
-      bht.Time                      = '1023'
-      bht.TransactionTypeCode       = 'CH'
-    end
-
-    ts.L1000A do |l1000a|
-      l1000a.NM1 do |nm1|
-        nm1.EntityTypeQualifier        = '2'
-        nm1.NameLastOrOrganizationName = 'PREMIER BILLING SERVICE'
-        nm1.IdentificationCode         = 'TGJ23'
-      end
-
-      l1000a.PER do |per|
-        per.Name                            = 'JERRY'
-        per.CommunicationNumberQualifier_01 = 'TE'
-        per.CommunicationNumber_01          = '3055552222'
-        per.CommunicationNumberQualifier_02 = 'EX'
-        per.CommunicationNumber_02          = '231'
-      end
-    end
-
-    puts ts.to_s
-
-    # Below is the output of ts.to_s (split onto separate lines for readability)
-    #
-    # ST*837*0021*005010X222A1~
-    # BHT*0019*00*244579*20061015*1023*CH~
-    # NM1*41*2*PREMIER BILLING SERVICE*****46*TGJ23~
-    # PER*IC*JERRY*TE*3055552222*EX*231~
+ts = Hippo::TransactionSets::HIPAA_837::Base.new
+
+ts.ST do |st|
+  st.TransactionSetControlNumber        = '0021'
+  st.ImplementationConventionReference  = '005010X222A1'
+end
+
+ts.BHT do |bht|
+  bht.TransactionSetPurposeCode = '00'
+  bht.ReferenceIdentification   = '244579'
+  bht.Date                      = '20061015'
+  bht.Time                      = '1023'
+  bht.TransactionTypeCode       = 'CH'
+end
+
+ts.L1000A do |l1000a|
+  l1000a.NM1 do |nm1|
+    nm1.EntityTypeQualifier        = '2'
+    nm1.NameLastOrOrganizationName = 'PREMIER BILLING SERVICE'
+    nm1.IdentificationCode         = 'TGJ23'
+  end
+
+  l1000a.PER do |per|
+    per.Name                            = 'JERRY'
+    per.CommunicationNumberQualifier_01 = 'TE'
+    per.CommunicationNumber_01          = '3055552222'
+    per.CommunicationNumberQualifier_02 = 'EX'
+    per.CommunicationNumber_02          = '231'
+  end
+end
+
+puts ts.to_s
+
+# Below is the output of ts.to_s (split onto separate lines for readability)
+#
+# ST*837*0021*005010X222A1~
+# BHT*0019*00*244579*20061015*1023*CH~
+# NM1*41*2*PREMIER BILLING SERVICE*****46*TGJ23~
+# PER*IC*JERRY*TE*3055552222*EX*231~
 ```
 
 Transaction Set/Loop and Segment DSL
@@ -86,76 +86,76 @@ Transaction Set/Loop and Segment DSL
 Transaction Sets/Loops and Segments are defined with a very straight forward DSL.
 
 ```ruby
-    module Hippo::Segments
-      class TestSimpleSegment < Hippo::Segments::Base
-        segment_identifier 'TSS'
-
-        field :name => 'Field1'
-        field :name => 'Field2'
-        field :name => 'Field3'
-        field :name => 'Field4'
-        field :name => 'CommonName'
-        field :name => 'CommonName'
-        field :name => 'DateField',     :datatype => :date
-        field :name => 'TimeField',     :datatype => :time
-        field :name => 'IntegerField',  :datatype => :integer
-        field :name => 'DecimalField',  :datatype => :decimal
-      end
-
-      class TestCompoundSegment < Hippo::Segments::Base
-        segment_identifier 'TCS'
-
-        composite_field 'CompositeField' do
-          field :name => 'Field1'
-          field :name => 'Field2'
-          field :name => 'Field3'
-          field :name => 'CompositeCommonName'
-        end
-
-        composite_field 'CompositeField' do
-          field :name => 'Field4'
-          field :name => 'Field5'
-          field :name => 'Field6'
-          field :name => 'CompositeCommonName'
-        end
-
-        field :name => 'Field7'
-      end
+module Hippo::Segments
+  class TestSimpleSegment < Hippo::Segments::Base
+    segment_identifier 'TSS'
+
+    field :name => 'Field1'
+    field :name => 'Field2'
+    field :name => 'Field3'
+    field :name => 'Field4'
+    field :name => 'CommonName'
+    field :name => 'CommonName'
+    field :name => 'DateField',     :datatype => :date
+    field :name => 'TimeField',     :datatype => :time
+    field :name => 'IntegerField',  :datatype => :integer
+    field :name => 'DecimalField',  :datatype => :decimal
+  end
+
+  class TestCompoundSegment < Hippo::Segments::Base
+    segment_identifier 'TCS'
+
+    composite_field 'CompositeField' do
+      field :name => 'Field1'
+      field :name => 'Field2'
+      field :name => 'Field3'
+      field :name => 'CompositeCommonName'
+    end
+
+    composite_field 'CompositeField' do
+      field :name => 'Field4'
+      field :name => 'Field5'
+      field :name => 'Field6'
+      field :name => 'CompositeCommonName'
     end
 
-    module Hippo::TransactionSets
-      module Test
-        class Base < Hippo::TransactionSets::Base
-
-          segment Hippo::Segments::TestSimpleSegment,
-                    :name           => 'Test Simple Segment #1',
-                    :minimum        => 1,
-                    :maximum        => 5,
-                    :position       => 50,
-                    :defaults => {
-                      'TSS01' => 'Blah'
-                    }
-
-          segment Hippo::Segments::TestCompoundSegment,
-                    :name           => 'Test Compound Segment #2',
-                    :minimum        => 1,
-                    :maximum        => 1,
-                    :position       => 100,
-                    :defaults => {
-                      'Field7' => 'Preset Field 7'
-                    }
-
-          segment Hippo::Segments::TestSimpleSegment,
-                    :name           => 'Test Simple Segment #3',
-                    :minimum        => 1,
-                    :maximum        => 1,
-                    :position       => 50,
-                    :defaults => {
-                      'TSS01' => 'Last Segment'
-                    }
-        end
-      end
+    field :name => 'Field7'
+  end
+end
+
+module Hippo::TransactionSets
+  module Test
+    class Base < Hippo::TransactionSets::Base
+
+      segment Hippo::Segments::TestSimpleSegment,
+                :name           => 'Test Simple Segment #1',
+                :minimum        => 1,
+                :maximum        => 5,
+                :position       => 50,
+                :defaults => {
+                  'TSS01' => 'Blah'
+                }
+
+      segment Hippo::Segments::TestCompoundSegment,
+                :name           => 'Test Compound Segment #2',
+                :minimum        => 1,
+                :maximum        => 1,
+                :position       => 100,
+                :defaults => {
+                  'Field7' => 'Preset Field 7'
+                }
+
+      segment Hippo::Segments::TestSimpleSegment,
+                :name           => 'Test Simple Segment #3',
+                :minimum        => 1,
+                :maximum        => 1,
+                :position       => 50,
+                :defaults => {
+                  'TSS01' => 'Last Segment'
+                }
     end
+  end
+end
 ```
 
 Quick Guide to Populating a Transaction Set
@@ -166,14 +166,14 @@ the fields.
 To create a transaction set simple choose the set you want and call new on it's Base class.
 
 ```ruby
-    ts = Hippo::TransactionSets::Test::Base.new
+ts = Hippo::TransactionSets::Test::Base.new
 ```
 
 The segments can be accessed directly from the created transaction set using the segment
 identifier.
 
 ```ruby
-    ts.TCS
+ts.TCS
 ```
 
 Since the TSS segment can be repeated we must call #build to generate a new
@@ -181,13 +181,13 @@ instance for each repeat. (You will be returned the first instance each time if
 do not call #build.)
 
 ```ruby
-    tss = ts.TSS.build
+tss = ts.TSS.build
 
-    # or
+# or
 
-    ts.TSS.build do |tss|
-      # do something here...
-    end
+ts.TSS.build do |tss|
+  # do something here...
+end
 ```
 
 The code above produces the following string output (notice how the values from
@@ -195,7 +195,7 @@ The code above produces the following string output (notice how the values from
 that the segments were declared):
 
 ```ruby
-    # ts.to_s => 'TSS*Blah~TCS***Preset Field 7~'
+# ts.to_s => 'TSS*Blah~TCS***Preset Field 7~'
 ```
 
 You can set the field values on a given segment a few different ways.
@@ -204,18 +204,18 @@ First you must access the segment that the field belongs to. You can
 either access the fields directly on the segment or use the block syntax.
 
 ```ruby
-    # this is one way to populate the fields
-    ts.TCS.Field1 = 'Foo'
-    ts.TSS.Field2 = 'Bar'
-
-    # this is another way
-    ts.TCS do |tcs|
-      tcs.Field1 = 'Foo'
-    end
-
-    ts.TSS do |tss|
-      tss.Field2 = 'Bar'
-    end
+# this is one way to populate the fields
+ts.TCS.Field1 = 'Foo'
+ts.TSS.Field2 = 'Bar'
+
+# this is another way
+ts.TCS do |tcs|
+  tcs.Field1 = 'Foo'
+end
+
+ts.TSS do |tss|
+  tss.Field2 = 'Bar'
+end
 ```
 
 Once you have access to the segment you can set the field values by either
@@ -224,12 +224,12 @@ field name is used more than once in a segment or if you are accessing a
 composite field you can optionally pass the index of the field to access.
 
 ```ruby
-    ts.TCS do |tcs|
-      tcs.Field1    = 'Foo'     # use the field name
-      tcs.TCS01_01  = 'Bar'     # use shorthand notation:
-                                #   TCS01 refers to the first field within the current segment
-                                #   _01 refers to the first field within the composite field
-    end
+ts.TCS do |tcs|
+  tcs.Field1    = 'Foo'     # use the field name
+  tcs.TCS01_01  = 'Bar'     # use shorthand notation:
+                            #   TCS01 refers to the first field within the current segment
+                            #   _01 refers to the first field within the composite field
+end
 ```
 
 If you read the transaction set declaration from above you will notice that the TSS segment
@@ -239,11 +239,11 @@ but if you need to access the second instance of TSS in the transaction set you
 TSS_02 instead.
 
 ```ruby
-    ts.TCS.Field1     = 'Foo'
-    ts.TSS.Field2     = 'Bar'
-    ts.TSS_02.Field2  = 'Baz'
+ts.TCS.Field1     = 'Foo'
+ts.TSS.Field2     = 'Bar'
+ts.TSS_02.Field2  = 'Baz'
 
-    # ts.to_s => 'TSS*Blah*Bar~TCS*Foo**Preset Field 7~TSS*Last Segment*Baz~'
+# ts.to_s => 'TSS*Blah*Bar~TCS*Foo**Preset Field 7~TSS*Last Segment*Baz~'
 ```
 
 Obviously, this could get somewhat tedious when operating on a TransactionSet with many segments
@@ -252,25 +252,25 @@ on the name provided in the TransactionSet definition.  You can either pass the
 a Regexp to search with.
 
 ```ruby
-    ts.find_by_name('Test Simple Segment #1') do |tss|
-      tss.Field2 = 'Baz'
-    end
+ts.find_by_name('Test Simple Segment #1') do |tss|
+  tss.Field2 = 'Baz'
+end
 
-    # which is essentially equivilent (because the search occurs in order of declaration)
-    ts.find_by_name(/Segment/) do |tss|
-      tss.Field2 = 'Baz'
-    end
+# which is essentially equivilent (because the search occurs in order of declaration)
+ts.find_by_name(/Segment/) do |tss|
+  tss.Field2 = 'Baz'
+end
 
-    # ts.to_s => 'TSS*Blah*Baz~'
+# ts.to_s => 'TSS*Blah*Baz~'
 ```
 
 The same technique can be used to reference fields within a segment that have the same name.
 
 ```ruby
-    ts.TSS.CommonName = 'Value1'
-    ts.TSS.CommonName_02 = 'Value2'
+ts.TSS.CommonName = 'Value1'
+ts.TSS.CommonName_02 = 'Value2'
 
-    # ts.to_s => 'TSS*Blah*Bar***Value1*Value2~TCS*Foo**Preset Field 7~TSS*Last Segment*Baz~'
+# ts.to_s => 'TSS*Blah*Bar***Value1*Value2~TCS*Foo**Preset Field 7~TSS*Last Segment*Baz~'
 ```
 
 Type Conversion
@@ -286,40 +286,72 @@ with a valid value for that particular data type.
 Just a few examples using the type conversion:
 
 ```ruby
-    seg = Hippo::Segments::TSS.new    # Please review definition from above.
-
-    # Date fields:
-    seg.DateField = Date.new(2012, 01, 20)
-    seg.DateField = "20120120"
-    seg.DateField = Time.new(2012, 01, 20, 10, 15, 20)
-
-    # all of these formats result in the same internal representation
-    puts seg.DateField.inspect # => #<Date: 2012-01-20 ((2455947j,0s,0n),+0s,2299161j)>
-
-    # To set the field back to a blank/empty value simply assign it to nil
-    seg.DateField = nil
-
-    # Time fields:
-    seg.TimeField = "0120"      # => 1:20 am       (HHMM)
-    seg.TimeField = "012023"    # => 1:20:23 am    (HHMMSS)
-    seg.TimeField = "01202322"  # => 1:20:23.22 am (HHMMSSDD)
-    seg.TimeField = Time.now
-
-    # Integer fields:
-    seg.IntegerField = "10"     # => 10
-    seg.IntegerField = 10       # => 10
-    seg.IntegerField = "10blah" # => 10
-
-    # Decimal fields:
-    seg.DecimalField = "123.45"   # => #<BigDecimal:7fe83c315750,'0.12345E3',18(18)>
-    seg.DecimalField = 123.45     # => #<BigDecimal:7fe83c315750,'0.12345E3',18(18)>
-    seg.DecimalField = 123        # => #<BigDecimal:7fe83b9dd4f8,'0.123E3',9(18)>
-    seg.DecimalField = 123.0      # => #<BigDecimal:7fe83b9dd4f8,'0.123E3',9(18)>
+seg = Hippo::Segments::TSS.new    # Please review definition from above.
+
+# Date fields:
+seg.DateField = Date.new(2012, 01, 20)
+seg.DateField = "20120120"
+seg.DateField = Time.new(2012, 01, 20, 10, 15, 20)
+
+# all of these formats result in the same internal representation
+puts seg.DateField.inspect # => #<Date: 2012-01-20 ((2455947j,0s,0n),+0s,2299161j)>
+
+# To set the field back to a blank/empty value simply assign it to nil
+seg.DateField = nil
+
+# Time fields:
+seg.TimeField = "0120"      # => 1:20 am       (HHMM)
+seg.TimeField = "012023"    # => 1:20:23 am    (HHMMSS)
+seg.TimeField = "01202322"  # => 1:20:23.22 am (HHMMSSDD)
+seg.TimeField = Time.now
+
+# Integer fields:
+seg.IntegerField = "10"     # => 10
+seg.IntegerField = 10       # => 10
+seg.IntegerField = "10blah" # => 10
+
+# Decimal fields:
+seg.DecimalField = "123.45"   # => #<BigDecimal:7fe83c315750,'0.12345E3',18(18)>
+seg.DecimalField = 123.45     # => #<BigDecimal:7fe83c315750,'0.12345E3',18(18)>
+seg.DecimalField = 123        # => #<BigDecimal:7fe83b9dd4f8,'0.123E3',9(18)>
+seg.DecimalField = 123.0      # => #<BigDecimal:7fe83b9dd4f8,'0.123E3',9(18)>
 ```
 
 __Please Note__: Due to issues with floating point representation of currency values we have
 chosen to use BigDecimal internally to store all fields with a decimal datatype.
 
+Hierarchy Traversal
+-------------------
+
+There are times with a given transaction set that you may start with a given segment but need
+to traverse up to a higher level loop/transaction set container.  The best example of this is
+when dealing with 997 or 999 acknowledgments.  If there are errors in your original transmission
+they are reported on the 997 and 999 as the segment number in error.  We need to then take that
+errored segment and figure out more context.
+
+The first thing we have to do is find the segment in error.  The 999 contains this in the IK3
+segment of the 2100 - AK2/IK3 loop. Then we need to access those segments in the original
+transmitted file.  Finally, we need to access an ancestor that gives enough context to resolve
+the error.
+
+Here is a quick example:
+
+```ruby
+ts_999 = Hippo::Parser.parse_file('location/to/999/file.999')
+ts_837 = Hippo::Parser.parse_file('location/to/837/file.837')
+
+# first lets get the index of all of the errored segments
+error_indexes = ts_999.L2000AK2.map{|l| l.L2100AK2.map{|m| m.IK3.IK303}}.flatten
+# or
+error_indexes = ts_999.segments.select{|s| s.class.to_s =~ /IK3/}.collect{|s| s.IK303}
+
+# now lets find those segments in the file being confirmed
+errored_segments = ts_837.segments.values_at(error_indexes)
+
+# and finally lets find the claim that they belong to
+errored_claims  = errored_segments.collect{|s| s.ancestors.select{|a| a.class.to_s =~ /L2000B/}}.flatten
+```
+
 For more example please review the test suite.
 
 License

data/lib/hippo/field.rb

@@ -21,7 +21,7 @@ module Hippo
       when :decimal then BigDecimal.new(value.to_s)
       when :date    then parse_date(value)
       when :time    then parse_time(value)
-      else value.to_s.strip
+      else parse_string(value)
       end
     end
 
@@ -31,31 +31,51 @@ module Hippo
       case datatype
       when :binary  then value
       when :integer then value.to_s.rjust(minimum, '0')
-      when :decimal then
-        value ||= BigDecimal.new('0')
-
-        value.to_s('F').sub(/\.0\z/,'').rjust(minimum, '0')
-      when :date
-        value ||= Date.today
-
-        if maximum == 6
-          value.strftime('%y%m%d')
-        else
-          value.strftime('%Y%m%d')
-        end
-      when :time
-        value ||= Time.now
-
-        if maximum == 4 || value.sec == 0
-          value.strftime('%H%M')
-        else
-          value.strftime('%H%M%S')
-        end
-      else value.to_s.ljust(minimum)
+      when :decimal then generate_decimal(value)
+      when :date    then generate_date(value)
+      when :time    then generate_time(value)
+      else generate_string(value)
+      end
+    end
+
+    def generate_string(value)
+      if required
+        value.to_s.ljust(minimum)
+      else
+        value.to_s
+      end
+    end
+
+    def parse_string(value)
+      if value.to_s.empty? && !required
+        nil
+      else
+        value.to_s.strip
+      end
+    end
+
+    def generate_decimal(value)
+      value ||= BigDecimal.new('0')
+
+      value.to_s('F').sub(/\.0\z/,'').rjust(minimum, '0')
+    end
+
+    def generate_time(value)
+      value ||= Time.now
+
+      if maximum == 4 || value.sec == 0
+        value.strftime('%H%M')
+      else
+        value.strftime('%H%M%S')
       end
     end
 
     def parse_time(value)
+      if value == ''
+        invalid! if required
+        return nil
+      end
+
       case value.class.to_s
       when 'Time' then value
       when 'String'
@@ -73,7 +93,22 @@ module Hippo
       invalid!
     end
 
+    def generate_date(value)
+      value ||= Date.today
+
+      if maximum == 6
+        value.strftime('%y%m%d')
+      else
+        value.strftime('%Y%m%d')
+      end
+    end
+
     def parse_date(value)
+      if value == ''
+        invalid! if required
+        return nil
+      end
+
       case value.class.to_s
       when "Date" then value
       when "Time" then value.to_date
@@ -81,7 +116,8 @@ module Hippo
         format =  case value
                   when /\A\d{6}\z/ then '%y%m%d'
                   when /\A\d{8}\z/ then '%Y%m%d'
-                  else invalid!
+                  else
+                    invalid!
                   end
 
         Date.parse(value, format)

data/lib/hippo/parser/transaction_set.rb

@@ -17,7 +17,7 @@ module Hippo
         end
       end
 
-      def segments
+      def parsed_segments
         @segments ||= @unparsed_data.split(@segment_separator).collect do |segment_string|
           segment = Hippo::Segments.const_get(segment_string.split(@field_separator).first).new(:parent => self)
 
@@ -25,14 +25,16 @@ module Hippo
         end
       end
 
-      def read(input)
+      def read(input = nil)
+        input ||= ''
+
         @unparsed_data = input.gsub(/[\a\e\f\n\r\t\v]/,'')
         parse_separators(@unparsed_data)
       end
 
       def parse(input)
         read(input)
-        populate(segments)
+        populate(parsed_segments)
         self
       end
     end

data/lib/hippo/parser.rb

@@ -6,6 +6,16 @@ module Hippo
     include Hippo::Separator
     include TransactionSet
 
+    def self.parse_file(input)
+      parser = new
+      parser.parse_string(input)
+    end
+
+    def self.parse_string(input)
+      parser = new
+      parser.parse_string(input)
+    end
+
     def initialize
       super
     end
@@ -13,10 +23,10 @@ module Hippo
     def initialize_transaction_set(index)
       {
         :segments  => [],
-        :ISA       => find_first_segment(segments[0,index + 1], 'ISA', true),
-        :GS        => find_first_segment(segments[0,index + 1], 'GS', true),
-        :GE        => find_first_segment(segments[index + 1, segments.length - index + 1], 'GE'),
-        :IEA       => find_first_segment(segments[index + 1, segments.length - index + 1], 'IEA')
+        :ISA       => find_first_segment(parsed_segments[0,index + 1], 'ISA', true),
+        :GS        => find_first_segment(parsed_segments[0,index + 1], 'GS', true),
+        :GE        => find_first_segment(parsed_segments[index + 1, parsed_segments.length - index + 1], 'GE'),
+        :IEA       => find_first_segment(parsed_segments[index + 1, parsed_segments.length - index + 1], 'IEA')
       }
     end
 
@@ -24,7 +34,7 @@ module Hippo
       raw_transaction_sets  = []
       inside_transaction    = false
 
-      segments.each_with_index do |segment, index|
+      parsed_segments.each_with_index do |segment, index|
         if segment.identifier == 'ST'
           raw_transaction_sets << initialize_transaction_set(index)
 

data/lib/hippo/segments/base.rb

@@ -49,6 +49,7 @@ module Hippo::Segments
 
       def segment_identifier(id)
         @identifier = id
+        @fields     = []
       end
 
       def segment_fixed_width
@@ -58,11 +59,27 @@ module Hippo::Segments
 
     attr_accessor :values, :parent
 
-    # make totaling segment counts easier...
+    def segments
+      [self]
+    end
+
     def segment_count
-      1
+      segments.count
     end
 
+    def ancestors
+      if parent
+        parent.ancestors.flatten
+      else
+        []
+      end
+    end
+
+    def to_ary
+      nil
+    end
+    alias :to_a :to_ary
+
     def initialize(options = {})
       @parent = options.delete(:parent)
 
@@ -151,6 +168,7 @@ module Hippo::Segments
         end
       else
         if field.composite
+          self.values[field.composite_sequence] ||= {}
           self.values[field.composite_sequence][field.sequence]
         else
           self.values[field.sequence]

data/lib/hippo/transaction_sets/base.rb

@@ -47,6 +47,8 @@ module Hippo::TransactionSets
             break unless segment
             break unless component.valid?(segment)
 
+            segment.parent = self
+
             if component.repeating?
               values[component.sequence] ||= component.initialize_component(self)
               values[component.sequence] << segment
@@ -99,9 +101,26 @@ module Hippo::TransactionSets
       @sequences[segment_identifier] += 1
     end
 
+    def segments
+      values.values.collect(&:segments).flatten
+    end
+
     def segment_count
-      values.values.map(&:segment_count).inject(&:+)
+      segments.count
+    end
+
+    def ancestors
+      if parent
+        [parent, parent.ancestors].flatten
+      else
+        []
+      end
+    end
+
+    def to_ary
+      nil
     end
+    alias :to_a :to_ary
 
     def to_s
       output = ''

data/lib/hippo/transaction_sets/repeating_component.rb

@@ -20,10 +20,22 @@ module Hippo::TransactionSets
       self.map(&:to_s).join
     end
 
+    def segments
+      return [] unless self.length != 0
+
+      self.map(&:segments).flatten
+    end
+
     def segment_count
-      return 0 unless self.length != 0
+      segments.length
+    end
 
-      self.map(&:segment_count).inject(&:+)
+    def ancestors
+      if parent
+        parent.ancestors.flatten
+      else
+        []
+      end
     end
 
     def method_missing(method_name, *args, &block)

data/lib/hippo/version.rb

@@ -1,3 +1,3 @@
 module Hippo
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/samples/200823.EDI

@@ -0,0 +1,22 @@
+ISA*00*          *00*          *ZZ*592015694      *ZZ*B9820          *120119*1701*^*00501*000000001*0*P*:~
+GS*FA*09102*B9820*20120119*170146*1*X*005010X231A1~
+ST*999*0001*005010X231A1~
+AK1*HC*155*005010X222A1~
+AK2*837*0002*005010X222A1~
+IK5*A~
+AK9*A*1*1*1~
+SE*6*0001~
+GE*1*1~
+IEA*1*000000001~
+ISA*00*          *00*          *ZZ*592015694      *ZZ*B9820          *120119*1703*^*00501*000000001*0*P*:~
+GS*FA*09102*B9820*20120119*170300*1*X*005010X231A1~
+ST*999*0001*005010X231A1~
+AK1*HC*156*005010X222A1~
+AK2*837*0002*005010X222A1~
+IK3*N4*5074*2010*8~
+IK4*3*26*2~
+IK5*R*5~
+AK9*R*1*1*0~
+SE*8*0001~
+GE*1*1~
+IEA*1*000000001~

data/test/test_segments_base.rb

@@ -175,4 +175,10 @@ class TestSegmentsBase < MiniTest::Unit::TestCase
 
     assert_equal "ISA*00*          *00*          *ZZ*593208085      *ZZ*OVERRIDE       *#{Date.today.strftime('%y%m%d')}*#{Time.now.strftime('%H%M')}*^*00501*000012345*1*T*:~", isa.to_s
   end
+
+  def test_access_empty_composite_returns_nil
+    seg = Hippo::Segments::TCS.new
+
+    assert_equal nil, seg.TCS01_01
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hippo
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-21 00:00:00.000000000 Z
+date: 2012-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70214345868980 !ruby/object:Gem::Requirement
+  requirement: &2182290180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70214345868980
+  version_requirements: *2182290180
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70214345868480 !ruby/object:Gem::Requirement
+  requirement: &2182289680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70214345868480
+  version_requirements: *2182289680
 description: HIPAA Transaction Set Generator/Parser
 email:
 - robertj@promedicalinc.com
@@ -262,6 +262,7 @@ files:
 - samples/005010X222A1_commercial_health_insurance.edi
 - samples/005010X231A1_01.edi
 - samples/005010X231A1_02.edi
+- samples/200823.EDI
 - test/test_helper.rb
 - test/test_hipaa_835.rb
 - test/test_hipaa_837.rb