REX12 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74edc4cb8982b9426d2c97b67495eb2d0dda6b8f
-  data.tar.gz: dd6178322ddf0fe3642937607c595f55fac96aa7
+  metadata.gz: c77556e632df1d2847e884f9d04c400824821c50
+  data.tar.gz: cafe395798bdf26ab40f7e82321c78aab1091ab7
 SHA512:
-  metadata.gz: 00f1778963481c83eeb234510718d4c6397fa22eeb1a0453186bf244b7c4efa0b4dbd84729e03b28c282dca12e2f841800ede8a72612df4a594bd1fae4f3a1bd
-  data.tar.gz: f6b4e7a3b970eecf9299b6060b9d6784241490e7260476e7783c1cc061b6fa1e099700404858c5f212d5b833d96c854e5ce0177bf59e93a949d2e7078e4f935e
+  metadata.gz: 29c7443111f823fe2c72d2a2715870745ef174c41681be3317455b4c438366885e785712fb780ab0e18b13736dbf63d7c3503361fe53bf8eb8fb65e3eefa7f8a
+  data.tar.gz: 7525a909eee3c42cf34d035084698376f09be22f77c6a680d4b4183ef5a5844ec4d30873248497de7d2a36e47a9001607233a8e763e619737b954a3b0b8170f4

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 .ruby-gemset
 .ruby-version
+.byebug_history

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/README.md

@@ -2,7 +2,7 @@
 
 # REX12
 
-This gem helps read files or text in the ASNI X.12 format.
+A simple gem to read EDI data in the ASNI X.12 format.
 
 
 ## Installation
@@ -15,7 +15,7 @@ gem 'rex12'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -23,17 +23,48 @@ Or install it yourself as:
 
 ## Usage
 
-Array form:
+To simply read all data from an EDI data file into a REX12::Document...
+
+*NOTE - All public REX12 methods for parsing EDI data (REX12#document, REX12#each_segment, and REX12#each_transaction) can receive a string path, a Pathname, an IO, or Tempfile object as the means for supplying your EDI data to the methods*
 
 ```ruby
 require 'rex12'
 
-sgements = REX12::Document.read('myfilepath.edi')
-some_date = segments.find {|seg| seg.segment_type=='DTM' && seg.elements[1].value=='056'}
-if some_date
-  puts some_date.elements[2].value
-else
-  puts "This is not the date you're looking for"
+document = REX12.document 'path/to/file.edi'
+
+# yielded segments are of type REX12::Segment
+document.segments.each do |segment|
+  if segment.isa_segment?
+    # Print out the sender from the ISA segment
+    puts "Reading an EDI document from '#{segment[8]}'"
+  else
+    if segment.segment_type == "DTM"
+      # Look for a specific date
+      if segment[1] == "056"
+        puts "Sender sent an '056' date of #{segment[2]}"
+      else
+        puts "This is not the date you're looking for."
+      end
+    end
+  end
+end
+```
+
+To get each individual transaction (.ie each individual unit defined between ST - SE segment pairs) yielded to your code:
+
+```ruby
+File.open("/path/to/file.edi", "r") do |file|
+  REX12.each_transaction(file) do |transaction|
+    # transaction is type REX12::Transaction
+    edi_type = transaction.segments[0][1]
+    if edi_type == "850"
+      process_purchase_order(transaction)
+    elsif edi_type == "856"
+      process_shipment(transaction)
+    else
+      puts "Not sure what to do with #{edi_type} documents."
+    end
+  end
 end
 ```
 
@@ -41,7 +72,11 @@ end
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Releases (Repository Owners Only)
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/lib/REX12/version.rb

@@ -1,3 +1,3 @@
 module REX12
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/rex12.rb

@@ -4,7 +4,89 @@ require "rex12/element"
 require "rex12/segment"
 require "rex12/document"
 require 'rex12/transaction'
+require 'rex12/element_with_subelements'
+require 'rex12/isa_segment'
+require 'rex12/parser'
+require 'rex12/subelement'
 
 module REX12
-  # Your code goes here...
+
+  # Reads EDI data from the given IO object or file path and returns or yields an enumerator returning every "transaction" in the EDI data.
+  #
+  # @param [String, IO] - If a String, expected to be the path to a file that can be read. If IO, needs to be able to be read from AND be able to be rewound.
+  #
+  # @return [Enumerator<REX12::Transaction>] - If no block given, returns an Enumerator for iterating over the Transactions in the file
+  # @yield [REX12::Transaction] - Progressively yields each transaction in the given EDI data.
+  def self.each_transaction file_or_io
+    val = nil
+    with_io(file_or_io) do |io| 
+      if block_given?
+        val = parser.each_transaction io, &Proc.new
+      else
+        val = parser.each_transaction io
+      end
+    end
+    val
+  end
+
+  # Reads EDI data from the given IO object or file path and returns or yields each EDI segement encountered in the data.
+  # The ISA segment is returned/yielded as a specialized REX12::IsaSegment subclass of REX12::Segment.
+  #
+  # Example:
+  # 
+  # REX12.each_segment("path/to/file.edi") do |segment|
+  #   if segment.isa_segment?
+  #     # Do something w/ the ISA
+  #   else 
+  #     # Do something w/ some other segment type
+  #   end
+  # end
+  #
+  #
+  #
+  # @param [String, IO] - If a String, expected to be the path to a file that can be read.  If IO, needs to be able to be read from AND be able to be rewound.
+  #
+  # @return [Enumerator<REX12::Segment>] - If no block given, returns an Enumerator for iterating over the Segements in the file
+  # @yield [REX12::Segment] - Progressively yields each segment in the given EDI data.
+  def self.each_segment file_or_io
+    val = nil
+    with_io(file_or_io) do |io| 
+      if block_given?
+        val = parser.each_segment io, &Proc.new
+      else
+        val = parser.each_segment io
+      end
+    end
+    val
+  end
+
+  # Reads EDI data from the given IO object or file path and returns a REX12::Document representing every segment from the given datasource.
+  # 
+  # @return [REX12::Document] - a REX12 object representing an ordered enumeration of all the segments in the given data source.
+  def self.document file_or_io
+    val = nil
+    with_io(file_or_io) do |io| 
+      val = parser.document io
+    end
+    val
+  end
+
+  def self.parser
+    REX12::Parser.new
+  end
+
+  def self.with_io file_or_io
+    # If we got an actual IO or Tempfile, then use them as given, else we'll assume the 
+    # value is a path and
+    if REX12::Parser.required_io_methods.map {|m| file_or_io.respond_to?(m) }.all?
+      yield file_or_io
+    else
+      path = file_or_io.respond_to?(:path) ? file_or_io.path : file_or_io.to_s
+
+      File.open(path, "r") {|f| yield f }
+    end
+  end
+  
+
+  private_class_method :parser, :with_io
 end

data/lib/rex12/document.rb

@@ -1,119 +1,25 @@
-# methods for reading a full EDI file
+# Represents a full (raw) EDI file.
 #
 # currently, the full text of the file is read into memory,
 # but if you use the block form of the methods, then the subsequent ruby objects
 # are created within the block loops so they can be garbage collected
 module REX12; class Document
 
-  # Parse the EDI document from file
-  #
-  # @return (see #parse)
-  def self.read path_or_io
-    if block_given?
-      parse(file_text(path_or_io)) {|s| yield s}
-      return nil
-    else
-      return parse(file_text(path_or_io))
-    end
+  def initialize segments
+    @segments = segments.freeze
   end
 
-  # Parse the EDI document from text or IO object
-  #
-  # @return [Array<REX12::Segment>,nil] all segments or nil for block form
-  def self.parse text
-    validate_isa(text)
-    element_separator = text[3]
-    segment_terminator = determine_segment_terminator(text)
-    sub_element_separator = text[104]
-    r = []
-
-    text.split(segment_terminator).each_with_index do |seg_text,pos|
-      next if seg_text.length == 0
-      seg = REX12::Segment.new(seg_text,element_separator,sub_element_separator,pos)
-      if block_given?
-        yield seg
-      else
-        r << seg
-      end
-    end
-
+  def segments
     if block_given?
+      @segments.each {|segment| yield segment}
       return nil
     else
-      return r
+      @segments.to_enum { @segments.length }
     end
   end
 
-  # Parses the EDI document from text or IO object, returning or yielding every transaction from the 
-  # document.
-  #
-  # @return [Array<REX12::Transaction>,nil] all transactions or nil for block form
-  def self.each_transaction text
-    isa = nil
-    current_gs = nil
-    current_segments = []
-    transactions = []
-
-    parse(text) do |segment|
-      segment_type = segment.segment_type
-      case segment_type
-      when "ISA"
-        isa = segment
-      when "GS"
-        current_gs = segment
-      when "IEA", "GE"
-        # Do nothing, we don't care about the trailer segments
-      else
-        current_segments << segment
-
-        # If we found the transaction trailer, it means we can take all the current segments we have and process them
-        if segment_type == "SE"
-          transaction = REX12::Transaction.new(isa, current_gs, current_segments)
-
-          if block_given? 
-            yield transaction
-          else
-            transactions << transaction
-          end
-
-          current_gs = nil
-          current_segments = []
-        end
-      end
-    end
-
-    block_given? ? nil : transactions
+  def [] x
+    @segments[x]
   end
 
-  def self.determine_segment_terminator text
-    # Technically, allowing multi-character terminators is not valid EDI, but you 
-    # see it happen ALL the time with EDI that's been hand editted from a client (especially on Windows).
-    # It's a valid enough use-case that we're accounting for it.
-
-    # no segement terminator, just CRLF
-    return "\r\n" if text[105..106]=="\r\n"
-    # no segement terminator, just CR or LF
-    return text[105] if ["\r","\n"].include?(text[105])
-    # segment terminator without CR or LF
-    return text[105] if text[106]=='G'
-    # segment terminator with CRLF
-    return text[105..107] if text[106..107]=="\r\n"
-    return text[105..106] if ["\r","\n"].include?(text[106]) && text[107]=="G"
-    raise REX12::ParseError, "Invalid ISA / GS segements. Could not determine segment terminator."
-  end
-  private_class_method :determine_segment_terminator
-
-  def self.validate_isa text
-    raise REX12::ParseError, "EDI file must be at least 191 characters to include a valid envelope." unless text.length > 191
-    str = text[0..2]
-    raise REX12::ParseError, "First 3 characters must be ISA. They were '#{str}'." unless str=='ISA'
-    return
-  end
-  private_class_method :validate_isa
-
-  # Allow reading from an object that responds to #read or assume the given param is a string file path and read with IO
-  def self.file_text path_or_io
-    path_or_io.respond_to?(:read) ? path_or_io.read : IO.read(path_or_io)
-  end
-  private_class_method :file_text
 end; end

data/lib/rex12/element.rb

@@ -9,25 +9,26 @@ module REX12; class Element
   # @param value [String] base text value of the element
   # @param sub_element_separator [String] character that should be used to split sub elements
   # @param position [Integer] zero based position of this element in its parent segment
-  def initialize value, sub_element_separator, position
-    @value = value
-    @sub_element_separator = sub_element_separator
-    @position = position
+  def initialize value, position
+    @value = value.freeze
+    @position = position.freeze
   end
 
   # @return [true, false] does the element have sub elements
   def sub_elements?
-    @value.index(@sub_element_separator) ? true : false
+    false
   end
 
-  # Get all sub elements as an array or yield them to a block
-  # @return [Array<String>, nil]
-  def sub_elements
-    r = @value.split(@sub_element_separator)
-    if block_given?
-      r.each {|se| yield se}
-      return nil
-    end
-    return r
+  def to_s
+    value
   end
+
+  protected
+    def value= v
+      @value = v
+    end
+
+    def position= pos
+      @position = pos
+    end
 end; end

data/lib/rex12/element_with_subelements.rb

@@ -0,0 +1,40 @@
+module REX12; class ElementWithSubElements < REX12::Element
+
+  attr_reader :sub_element_separator
+
+  def initialize sub_elements, position, separator
+    super(nil, position)
+    @sub_elements = sub_elements.freeze
+    @sub_element_separator = separator
+  end
+
+  # @return [true, false] does the element have sub elements
+  def sub_elements?
+    true
+  end
+
+  # Get all sub elements as an array or yield them to a block
+  # @return [Array<SubElement>, nil]
+  def sub_elements
+    if block_given?
+      @sub_elements.each {|se| yield se }
+      return nil
+    end
+
+    return @sub_elements.to_enum { @sub_elements.length }
+  end
+
+  def sub_element index
+    @sub_elements[index]
+  end
+
+  def to_s
+    @sub_elements.map(&:to_s).join(@sub_element_separator)
+  end
+
+  def [](index)
+    sub_el = sub_element(index)
+    sub_el.nil? ? nil : sub_el.value
+  end
+
+end; end

data/lib/rex12/isa_segment.rb

@@ -0,0 +1,17 @@
+module REX12; class IsaSegment < Segment
+  attr_reader :segment_terminator
+  attr_reader :element_delimiter
+  attr_reader :sub_element_separator
+
+  def initialize elements, position, segment_terminator, element_delimiter, sub_element_separator
+    super(elements, position)
+    @segment_terminator = segment_terminator.freeze
+    @element_delimiter = element_delimiter.freeze
+    @sub_element_separator = sub_element_separator.freeze
+  end
+
+  def isa_segment?
+    true
+  end
+
+end; end;

data/lib/rex12/parse_error.rb

@@ -1,12 +1,4 @@
 # Raised when there is an error parsing the syntax of the document
 module REX12; class ParseError < StandardError
-  # REX12::Segment that was being parsed when error was generated (may be nil)
-  attr_reader :segment
-  # REX12::Element that was being parsed when error was generated (may be nil)
-  attr_reader :element
-  def initialize message, segment=nil, element=nil
-    super(message)
-    @segment = segment
-    @element = element
-  end
+  
 end; end

data/lib/rex12/parser.rb

@@ -0,0 +1,235 @@
+# This classes sole purpose is to read an IO object containing EDI text and turn
+# it into the REX12 component classes.
+#
+module REX12; class Parser
+
+  # Reads EDI data from the given IO object and returns a REX12::Document
+  # model of the whole EDI file
+  def document io
+    REX12::Document.new(each_segment(io).to_a)
+  end
+
+  # Reads EDI data from the given IO object and returns an enumeration of the EDI segments as REX12::Segment objects.
+  # If a block is given, segments will be yielded.
+
+  # NOTE: The ISA line will be returned as a specialized REX12::IsaSegment class, which subclasses REX12::Segment
+  def each_segment io
+    metadata = parse_metadata io
+    segments = []
+    each_line(io, metadata) do |line_counter, segment|
+      if block_given? 
+        yield segment
+      else
+        segments << segment
+      end
+    end
+
+    block_given? ? nil : segments.to_enum { segments.length }
+  end
+
+  # Reads EDI data from the received IO object.
+  # If a block is given, yields all REX12::Transaction objects read from the EDI in sequence
+  # If no block is given, an Enumerator of REX12::Transactions is returned
+  def each_transaction io
+    metadata = parse_metadata io
+
+    # At this point we can read through the io "line" by "line" utilizing the segment_terminator as the linefeed character
+    # I'm not exactly sure what to use as the max line length here, so I'm just going to basically negate it by using 
+    # a value of 1 million
+    isa_segment = nil
+    gs_segment = nil
+    segments = []
+    transactions = []
+    each_line(io, metadata) do |line_counter, segment|
+      
+      if metadata.segment_markers[:isa] == segment.segment_type
+        isa_segment = segment
+        next
+      end
+
+      case segment.segment_type
+      when metadata.segment_markers[:gs]
+        gs_segment = segment
+      when metadata.segment_markers[:iea], metadata.segment_markers[:ge]
+        # Do nothing, we don't care about the trailer segments if we're procssing the data transaction by 
+        # transaction...they do nothing for us except act as potential checksums for segment counts..which 
+        # we're not bothering with
+      else
+        next if segment.segment_type.nil?
+
+        segments << segment
+
+        if segment.segment_type == metadata.segment_markers[:se]
+          transaction = REX12::Transaction.new(isa_segment, gs_segment, segments)
+
+          if block_given?
+            yield transaction
+          else
+            transactions << transaction
+          end
+
+          segments = []
+        end
+      end
+    end
+    
+    block_given? ? nil : transactions.to_enum { transactions.length }
+  end
+
+  class DocumentMetadata
+
+    attr_reader :encoding, :segment_markers, :segment_terminator, :element_delimiter, :sub_element_separator
+
+    def initialize encoding, segment_markers, segment_terminator, element_delimiter, sub_element_separator
+      @encoding = encoding
+      @segment_markers = segment_markers.freeze
+      @segment_terminator = segment_terminator.freeze
+      @element_delimiter = element_delimiter.freeze
+      @sub_element_separator = sub_element_separator.freeze
+    end
+
+  end
+
+  def self.required_io_methods
+    [:pos, :rewind, :readchar, :each_line]
+  end
+
+  private
+
+    def each_line io, metadata
+      line_counter = -1
+      isa_seen = false
+      io.each_line(metadata.segment_terminator, 1_000_000).each do |segment_line|
+        next if segment_line.length == 0
+
+        line_counter += 1
+
+        # Strip the segment terminator off the line before we parse it
+        segment_line = segment_line[0..-(1 + metadata.segment_terminator.length)]
+
+        segment = (parse_edi_line(segment_line, line_counter, metadata))
+
+        if metadata.segment_markers[:isa] == segment.segment_type
+          raise "Invalid EDI.  Only 1 ISA segment is allow per EDI file." if isa_seen
+          isa_seen = false
+        end
+
+        yield line_counter, segment
+      end
+      nil
+    end
+
+    def parse_edi_line segment_line, line_counter, metadata
+      # Handle isa segments a little different
+      if segment_line.start_with?(metadata.segment_markers[:isa])
+        isa_segment = parse_isa(segment_line, line_counter, metadata)
+      else    
+        segment = parse_line(segment_line, line_counter, metadata)
+      end
+    end
+
+    def parse_line line, line_counter, metadata
+      elements = []
+      # Ruby's split function by default compresses elements together if there are no trailing positions, we don't want this here
+      # we want every position accounted for...hence the -1 argument as the limit value
+      # .ie NOT 'SLN*1****'.split('*') -> ["SLN", "1"] ---- We want ["SLN", "1", "", "", "", ""]
+      line.split(metadata.element_delimiter, -1).each_with_index do |element, index|  
+        split_element = element.split(metadata.sub_element_separator, -1)
+        if split_element.length > 1
+          sub_elements = []
+          split_element.each_with_index {|v, x| sub_elements << REX12::SubElement.new(v, x) }
+
+          elements << REX12::ElementWithSubElements.new(sub_elements, index, metadata.sub_element_separator)
+        else
+          elements << REX12::Element.new(element, index)
+        end
+      end
+
+      REX12::Segment.new elements, line_counter
+    end
+
+    def parse_isa line, line_counter, metadata
+      elements = []
+      split_segment = line.split(metadata.element_delimiter, -1)
+      split_segment.each_with_index do |element, index| 
+        # There's no subelements in the isa
+        elements << REX12::Element.new(element, index)
+      end
+
+      REX12::IsaSegment.new elements, line_counter, metadata.segment_terminator, metadata.element_delimiter, metadata.sub_element_separator
+    end
+
+    def parse_metadata io
+      # Record the initial position so we can rewind back to it
+      initial_position = io.pos
+
+      # Read out 107 chars from the io object to determine ISA data
+      isa_chars = []
+
+      # Use readchar instead of bytes so that we're letting the IO stream handle any character
+      # encoding for us
+
+      106.times { isa_chars << io.readchar }
+
+      encoding = isa_chars[0].encoding
+      segment_markers = encoded_segment_markers(encoding)
+      # We should have a full isa segment now, interrogate it to determine the segment terminator, element separator and subelement separator
+      raise REX12::ParseError, "Invalid EDI.  All EDI documents must start with an ISA segment." unless isa_chars[0..2].join == segment_markers[:isa]
+
+      element_delimiter = isa_chars[3]
+      segment_terminator = determine_segment_terminator(encoding, isa_chars, segment_markers, io)
+      sub_element_separator = isa_chars[104]      
+
+      io.pos = initial_position
+
+      return REX12::Parser::DocumentMetadata.new(encoding, segment_markers, segment_terminator, element_delimiter, sub_element_separator)
+    rescue EOFError
+      raise REX12::ParseError, "Invalid EDI.  All EDI documents must start with an ISA segment that is exactly 107 characters long - including the segment terminator."
+    end
+
+    def encoded_segment_markers document_encoding
+      {
+        isa: "ISA".encode(document_encoding), 
+        gs: "GS".encode(document_encoding), 
+        iea: "IEA".encode(document_encoding), 
+        ge: "GE".encode(document_encoding),
+        st: "ST".encode(document_encoding),
+        se: "SE".encode(document_encoding)
+      }
+    end
+
+    def determine_segment_terminator encoding, isa_chars, markers, io
+      # Technically, allowing multi-character terminators is not valid EDI, but you 
+      # see it happen ALL the time with EDI that's been hand editted from a client where \r\n is utilized.
+      # It's a valid enough use-case that we're accounting specifically for a terminator character and/or cr/lfs
+      terminator = isa_chars[105]
+
+      raise REX12::ParseError, "Invalid EDI.  All EDI documents have a segment terminator character at position 106 of the ISA segment." if terminator.nil?
+
+      next_char = io.readchar
+
+      # If there's a single character terminator and the next char is the start of the GS segment, then everything is copacetic
+      # and no need to continue looking for more terminator characters
+      return terminator if markers[:gs][0] == next_char
+
+      cr = "\r".encode(encoding)
+      lf = "\n".encode(encoding)
+
+      if next_char == cr || next_char == lf
+        terminator << next_char
+
+        # The only valid char at this point we'll accept as part of the terminator is a linefeed
+        next_char = io.readchar
+        if next_char == lf
+          terminator << next_char
+        else 
+          raise REX12::ParseError, "Invalid ISA segment.  Could not determine segment terminator." unless markers[:gs][0] == next_char
+        end
+      elsif markers[:gs][0] != next_char
+        raise REX12::ParseError, "Invalid ISA segment.  Could not determine segment terminator."
+      end
+
+      terminator
+    end
+
+end; end;

data/lib/rex12/segment.rb

@@ -1,36 +1,38 @@
 module REX12; class Segment
-  # @return [String] raw text of segment
-  attr_reader :value
-
   # @return [Integer] zero based position in file
   attr_reader :position
 
-  def initialize value, element_separator, sub_element_separator, position
-    @value = value
-    @position = position
-    make_elements(value,element_separator,sub_element_separator)
+  def initialize elements, position
+    @segment_elements = elements.freeze
+    @position = position.freeze
   end
 
   # @return [Array<REX12::Element>, nil] get all elements as array or yield to block
   def elements
     if block_given?
-      @elements.each {|el| yield el}
+      @segment_elements.each {|el| yield el}
       return nil
+    else
+      @segment_elements.to_enum { @segment_elements.length }
     end
-    # making a fresh array so nobody can screw with the internals of the class
-    @elements.clone
+  end
+
+  def element index
+    @segment_elements[index]
   end
 
   # @return [String] text representation of first element (like: ISA or REF)
   def segment_type
-    @elements.first.value
+    self[0]
   end
 
-  def make_elements value, element_separator, sub_element_separator
-    @elements = []
-    value.split(element_separator).each_with_index do |str,pos|
-      @elements << REX12::Element.new(str,sub_element_separator,pos)
-    end
+  def [](index)
+    el = element(index)
+    el.nil? ? nil : el.value
   end
-  private :make_elements
+
+  def isa_segment?
+    false
+  end
+
 end; end

data/lib/rex12/subelement.rb

@@ -0,0 +1,14 @@
+module REX12; class SubElement
+
+  attr_reader :value
+  attr_reader :position
+
+  def initialize value, position
+    @value = value.freeze
+    @position = position.freeze
+  end
+
+  def to_s
+    value
+  end
+end; end;

data/rex12.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "yard", "~> 0.9"
+  spec.add_development_dependency "byebug", "~> 9.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: REX12
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Brian Glick
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2017-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
 description: Read ANSI X.12 files
 email:
 - brian@brian-glick.com
@@ -87,8 +101,12 @@ files:
 - lib/rex12.rb
 - lib/rex12/document.rb
 - lib/rex12/element.rb
+- lib/rex12/element_with_subelements.rb
+- lib/rex12/isa_segment.rb
 - lib/rex12/parse_error.rb
+- lib/rex12/parser.rb
 - lib/rex12/segment.rb
+- lib/rex12/subelement.rb
 - lib/rex12/transaction.rb
 - rex12.gemspec
 homepage: https://github.com/Vandegrift/rex12