tcd_x12 1.6.0

data/example/factory.rb

@@ -0,0 +1,93 @@
+#--
+#     This file is part of the X12Parser library that provides tools to
+#     manipulate X12 messages using Ruby native syntax.
+#
+#     http://x12parser.rubyforge.org
+#
+#     Copyright (C) 2008 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+
+require 'x12'
+
+# Read message definition and create an actual parser
+# by compiling .d12 file
+parser = X12::Parser.new('misc/997single.xml')
+
+# Make a new 997 message
+r = parser.factory('997')
+
+#
+# Set various fields as desired
+#
+
+# Set fields directly
+r.ST.TransactionSetIdentifierCode = 997
+r.ST.TransactionSetControlNumber  = '2878'
+
+# Set fields inside a segment (AK1 in this case)
+r.AK1 { |ak1|
+  ak1.FunctionalIdentifierCode = 'HS'
+  ak1.GroupControlNumber       = 293328532
+}
+
+# Set fields deeply inside a segment inside
+# nested loops (L1000/L1010/AK4 in this case)
+r.L1000.L1010.AK4.DataElementSyntaxErrorCode = 55
+r.L1000.AK2.TransactionSetIdentifierCode     = 270
+
+# Set nested loops
+r.L1000.L1010 {|l|
+  l.AK3 {|s|
+    s.SegmentIdCode      = 'NM1'
+    s.LoopIdentifierCode = 'L1000D'
+  }
+  l.AK4 {|s|
+    s.CopyOfBadDataElement = 'Bad element'
+  }
+}
+
+# Add loop repeats
+r.L1000.repeat {|l1000|
+  (0..1).each {|loop_repeat| # Two repeats of the loop L1010
+    l1000.L1010.repeat {|l1010|
+      l1010.AK3 {|s|
+        s.SegmentIdCode                   = 'DMG'
+        s.SegmentPositionInTransactionSet = 0
+        s.LoopIdentifierCode              = 'L1010'
+        s.SegmentSyntaxErrorCode          = 22
+      } if loop_repeat == 0 # AK3 only in the first repeat of L1010
+      (0..1).each {|ak4_repeat| # Two repeats of the segment AK4
+        l1010.AK4.repeat {|s|
+          s.PositionInSegment          = loop_repeat
+          s.DataElementSyntaxErrorCode = ak4_repeat
+        } # s
+      } # ak4_repeat
+    } # l1010
+  } # loop_repeat
+
+  l1000.AK5{|a|
+    a.TransactionSetAcknowledgmentCode = 666
+    a.TransactionSetSyntaxErrorCode4   = 999
+  } # a
+} # l1000
+
+# Print the message as a string -> ST*997*2878~AK1*HS*293328532~
+# AK2*270*~AK3*NM1**L1000D~AK4***55*Bad element~AK5*~AK3*DMG*0*
+# L1010*22~AK4*0**0~AK4*0**1~AK4*1**0~AK4*1**1~AK5*666****999~
+# AK9****~SE**~
+puts r.render

data/example/parse.rb

@@ -0,0 +1,58 @@
+#--
+#     This file is part of the X12Parser library that provides tools to
+#     manipulate X12 messages using Ruby native syntax.
+#
+#     http://x12parser.rubyforge.org 
+#     
+#     Copyright (C) 2008 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+
+require 'x12'
+
+# Read message definition and create an actual parser
+# by compiling .d12 file
+parser = X12::Parser.new('misc/997single.xml')
+
+# Define a test message to parse
+m997='ST*997*2878~AK1*HS*293328532~AK2*270*307272179~'\
+'AK3*NM1*8*L1010_0*8~AK4*0:0*66*1~AK4*0:1*66*1~AK4*0:2*'\
+'66*1~AK3*NM1*8*L1010_1*8~AK4*1:0*66*1~AK4*1:1*66*1~AK3*'\
+'NM1*8*L1010_2*8~AK4*2:0*66*1~AK5*R*5~AK9*R*1*1*0~SE*8*2878~'
+
+# Parse the message
+r = parser.parse('997', m997)
+r.show
+
+# Access components of the message as desired
+
+# Whole ST segment: -> ST*997*2878~
+puts r.ST
+
+# One filed, Group Control Number of AK1 -> 293328532
+puts r.AK1.GroupControlNumber
+
+# Individual loop, namely, third L1010 subloop of
+# L1000 loop: -> AK3*NM1*8*L1010_2*8~AK4*2:0*66*1~
+puts r.L1000.L1010[2]
+
+# First encounter of Data Element Reference Number of the 
+# first L1010 sub-loop of L1000 loop -> 66
+puts r.L1000.L1010.AK4.DataElementReferenceNumber
+
+# Number of L1010 sub-loops in L1000 loop -> 3
+puts r.L1000.L1010.size

data/lib/x12/base.rb

@@ -0,0 +1,187 @@
+module X12
+
+  # Base class for Segment, Composite, and Loop.
+  # Contains setable segment_separator, field_separator, and composite_separator fields.
+  class Base
+
+    attr_reader   :name, :repeats
+    attr_accessor :segment_separator, :field_separator, :composite_separator, :next_repeat, :parsed_str, :nodes
+
+    # Creates a new base element with a given name, array of sub-elements, and array of repeats if any.
+    def initialize(name, arr, repeats = nil)
+      @nodes = arr
+      @name = name
+      @repeats = repeats
+      @next_repeat = nil # Next repeat of the same element, if any
+      @parsed_str = nil
+
+      @segment_separator   = '~'
+      @field_separator     = '*'
+      @composite_separator = ':'
+
+      # puts "Created #{name} #{object_id} #{self.class}  "
+    end
+
+    # Formats a printable string containing the base element's content.
+    # @return [String]
+    def inspect
+      "#{self.class.to_s.sub(/^.*::/, '')} (#{name}) #{repeats} #{super.inspect[1..-2]} =<#{parsed_str}, #{next_repeat.inspect}> ".gsub(/\\*\"/, '"')
+    end
+
+    # Prints a tree-like representation of the element.
+    def show(ind = '')
+      count = 0
+      self.to_a.each{|i|
+        # puts "#{ind}#{i.name} #{i.object_id} #{i.super.object_id} [#{count}]: #{i.parsed_str} #{i.super.class}"
+        puts "#{ind}#{i.name} [#{count}]: #{i.to_s.sub(/^(.{30})(.*?)(.{30})$/, '\1...\3')}"
+        # Force parsing a segment
+        if i.is_a?(X12::Segment) && i.nodes[0]
+          i.find_field(i.nodes[0].name)
+        end
+        i.nodes.each{|j|
+          case
+          when j.is_a?(X12::Base)  then j.show(ind + '  ')
+          when j.is_a?(X12::Field) then puts "#{ind}  #{j.name} -> '#{j}'"
+          end
+        }
+        count += 1
+      }
+    end
+
+    # Try to parse the current element one more time if required. Returns the rest of the string
+    # or the same string if no more repeats are found or required.
+    def do_repeats(s)
+      if self.repeats.end > 1
+        possible_repeat = self.dup
+        p_s = possible_repeat.parse(s)
+        if p_s
+          s = p_s
+          self.next_repeat = possible_repeat
+        end
+      end
+      s
+    end
+
+    # Empty out the current element.
+    def set_empty!
+      @next_repeat = nil
+      @parsed_str = nil
+      self
+    end
+
+    # Make a deep copy of the element.
+    def dup
+      n = clone
+      n.set_empty!
+      n.nodes = n.nodes.dup
+      n.nodes.each_index{|i|
+        n.nodes[i] = n.nodes[i].dup
+        n.nodes[i].set_empty!
+      }
+      # puts "Duped #{self.class} #{self.name} #{self.object_id} #{super.object_id} -> #{n.name} #{n.super.object_id} #{n.object_id} "
+      n
+    end
+
+    # Recursively find a sub-element, which also has to be of type Base.
+    def find(e)
+      # puts "Finding [#{e}] in #{self.class} #{name}"
+      case self
+        when X12::Loop
+        # Breadth first
+        res = nodes.find { |i| e == i.name }
+        return res if res
+        # Depth now
+        nodes.each{ |i|
+          res = i.find(e) if i.is_a?(X12::Loop)
+          return res unless res.nil? or EMPTY == res # otherwise keep looping
+        }
+        when X12::Segment
+        return find_field(e).to_s
+      end
+      return EMPTY
+    end
+
+    # Present self and all repeats as an array with self being #0.
+    def to_a
+      res = [self]
+      nr = self.next_repeat
+      while nr
+        res << nr
+        nr = nr.next_repeat
+      end
+      res
+    end
+
+    # Returns a parsed string representation of the element.
+    # @return [String]
+    def to_s
+      @parsed_str || ''
+    end
+
+    # The main method implementing Ruby-like access methods for nested elements.
+    def method_missing(meth, *args, &block)
+      str = meth.id2name
+      str = str[1..str.length] if str =~ /^_\d+$/ # to avoid pure number names like 270, 997, etc.
+      # puts "Missing #{str}"
+      if str =~ /=$/
+        # Assignment
+        str.chop!
+        # puts str
+        case self
+        when X12::Segment
+          res = find_field(str)
+          throw Exception.new("No field '#{str}' in segment '#{self.name}'") if EMPTY == res
+          res.content = args[0].to_s
+          # puts res.inspect
+        else
+          throw Exception.new("Illegal assignment to #{meth} of #{self.class}")
+        end
+      else
+        # Retrieval
+        res = find(str)
+        yield res if block_given?
+        res
+      end
+    end
+
+    # The main method implementing Ruby-like access methods for repeating elements.
+    def [](*args)
+      # puts "squares #{args.inspect}"
+      return self.to_a[args[0]] || EMPTY
+    end
+
+    # Yields to accompanying block passing self as a parameter.
+    def with(&block)
+      if block_given?
+        yield self
+      else
+        throw Exception.new("Method 'with' requires a block.")
+      end
+    end
+
+    # Returns number of repeats.
+    # @return [Integer]
+    def size
+      return self.to_a.size
+    end
+
+    # Check if any of the fields has been set yet.
+    def has_content?
+      self.nodes.find{ |i| i.has_content? }
+    end
+
+    # Adds a repeat to a segment or loop. Returns a new segment/loop or self if empty.
+    def repeat
+      res = if self.has_content? # Do not repeat an empty segment
+              last_repeat = self.to_a[-1]
+              last_repeat.next_repeat = last_repeat.dup
+            else
+              self
+            end
+      yield res if block_given?
+      res
+    end
+
+  end
+
+end

data/lib/x12/composite.rb

@@ -0,0 +1,10 @@
+module X12
+  # Class implementing a composite field.
+  class Composite < Base
+    # Make a printable representation of the composite.
+    # @return [String]
+    def inspect
+      return "Composite #{super.inspect}"
+    end
+  end
+end

data/lib/x12/empty.rb

@@ -0,0 +1,14 @@
+module X12
+  # Class indicating the absense of any X12 element, be it loop, segment, or anything else like that.
+  class Empty < Base
+    # Create a new empty
+    def initialize
+      super(nil, [])
+    end
+    # Returns an empty string
+    # @return [String]
+    def to_s
+      return ''
+    end
+  end
+end

data/lib/x12/field.rb

@@ -0,0 +1,70 @@
+module X12
+  
+  # Class to represent a segment field. Please note, it's not a descendant of Base.
+  class Field
+    attr_reader :name, :type, :required, :min_length, :max_length, :validation
+    attr_writer :content
+
+    # Create a new field with given parameters
+    def initialize(name, type, required, min_length, max_length, validation)
+      @name       = name
+      @type       = type
+      @required   = required
+      @min_length = min_length.to_i
+      @max_length = max_length.to_i
+      @validation = validation
+      @content = nil
+    end
+
+    # Returns printable string with field's content
+    # @return [String]
+    def inspect
+      "Field #{name}|#{type}|#{required}|#{min_length}-#{max_length}|#{validation} <#{@content}>"
+    end
+
+    # Synonym for 'render'
+    def to_s
+      render
+    end
+
+    def render
+      unless @content
+        @content = $1 if self.type =~ /"(.*)"/ # If it's a constant
+      end
+      rendered = @content || ''
+      rendered = rendered.ljust(@min_length) if @required
+      rendered
+    end
+
+    # Check if it's been set yet and it's not a constant
+    def has_content?
+      !@content.nil? && ('"'+@content+'"' != self.type)
+    end
+
+    # Erase the content
+    def set_empty!
+      @content = nil
+    end
+
+    # Returns simplified string regexp for this field, takes field separator and segment separator as arguments
+    def simple_regexp(field_sep, segment_sep)
+      case self.type
+      when /"(.*)"/ then $1
+      else "[^#{Regexp.escape(field_sep)}#{Regexp.escape(segment_sep)}]*"
+      end # case
+    end
+
+    # Returns proper validating string regexp for this field, takes field separator and segment separator as arguments
+    def proper_regexp(field_sep, segment_sep)
+      case self.type
+      when 'I'      then "\\d{#{@min_length},#{@max_length}}"
+      when 'S'      then "[^#{Regexp.escape(field_sep)}#{Regexp.escape(segment_sep)}]{#{@min_length},#{@max_length}}"
+      when /C.*/    then "[^#{Regexp.escape(field_sep)}#{Regexp.escape(segment_sep)}]{#{@min_length},#{@max_length}}"
+      when /"(.*)"/ then $1
+      else "[^#{Regexp.escape(field_sep)}#{Regexp.escape(segment_sep)}]*"
+      end
+    end
+
+  end
+  
+end

data/lib/x12/loop.rb

@@ -0,0 +1,69 @@
+module X12
+
+  # Implements nested loops of segments.
+  class Loop < Base
+
+#     def regexp
+#       @regexp ||=
+#         Regexp.new(inject(''){|s, i|
+#                      puts i.class
+#                      s += case i
+#                           when X12::Segment: "(#{i.regexp.source}){#{i.repeats.begin},#{i.repeats.end}}"
+#                           when X12::Loop:    "(.*?)"
+#                           else
+#                             ''
+#                           end
+#                    })
+#     end
+
+    # Parse a string and fill out internal structures with the pieces of it.
+    # Returns  an unparsed portion of the string or the original string if nothing was parsed out.
+    def parse(str)
+      # puts "Parsing loop #{name}: "+str
+      s = str
+      nodes.each{|i|
+        m = i.parse(s)
+        s = m if m
+      }
+      if str == s
+        return nil
+      else
+        self.parsed_str = str[0..-s.length-1]
+        s = do_repeats(s)
+      end
+      # puts 'Parsed loop '+self.inspect
+      return s
+    end
+
+    # Render all components of this loop as string suitable for EDI.
+    def render
+      if self.has_content?
+        self.to_a.inject(''){|loop_str, i|
+          loop_str += i.nodes.inject(''){|nodes_str, j|
+            nodes_str += j.render
+          }
+        }
+      else
+        ''
+      end
+    end
+
+
+    # Formats a printable string containing the loops element's content
+    # added to provide compatability with ruby > 2.0.0.
+    # @return [String]
+    def inspect
+      "#{self.class.to_s.sub(/^.*::/, '')} (#{name}) #{repeats} =<#{parsed_str}, #{next_repeat.inspect}> ".gsub(/\\*\"/, '"')
+    end
+
+    # Provides looping through repeats of a message.
+    def each
+      res = self.to_a
+      0.upto(res.length - 1) do |x|
+        yield res[x]
+      end
+    end
+
+  end
+
+end

data/lib/x12/parser.rb

@@ -0,0 +1,117 @@
+module X12
+
+  # Main class for creating X12 parsers and factories.
+  class Parser
+
+    # These constitute prohibited file names under Microsoft
+    MS_DEVICES = [
+      'CON',
+      'PRN',
+      'AUX',
+      'CLOCK$',
+      'NUL',
+      'COM1',
+      'LPT1',
+      'LPT2',
+      'LPT3',
+      'COM2',
+      'COM3',
+      'COM4',
+    ].freeze
+
+    # Creates a parser out of a definition.
+    def initialize(file_name)
+      save_definition = @x12_definition
+
+      # Deal with Microsoft devices
+      # get the current working directory
+      base_name = File.basename(file_name, '.xml')
+      if MS_DEVICES.find { |i| i == base_name }
+        file_name = File.join(File.dirname, "#{base_name}_.xml")
+      end
+      file_location = File.join(File.dirname(__FILE__), '../../misc', file_name)
+
+      # Read and parse the definition
+      str = File.open(file_location, 'r').read
+      # @dir_name = File.dirname(File.expand_path(file_name)) # to look up other files if needed
+      @x12_definition = X12::XMLDefinitions.new(str)
+
+      # Populate fields in all segments found in all the loops
+      @x12_definition[X12::Loop].each_pair{ |k, v|
+        # puts "Populating definitions for loop #{k}"
+        process_loop(v)
+      } if @x12_definition[X12::Loop]
+
+      # Merge the newly parsed definition into a saved one, if any.
+      if save_definition
+        @x12_definition.keys.each { |t|
+          save_definition[t] ||= {}
+          @x12_definition[t].keys.each { |u|
+            save_definition[t][u] = @x12_definition[t][u]
+          }
+          @x12_definition = save_definition
+        }
+      end
+
+      # puts PP.pp(self, '')
+    end
+
+    # Parse a loop of a given name out of a string.
+    # Throws an exception if the loop name is not defined.
+    def parse(loop_name, str)
+      loop = @x12_definition[X12::Loop][loop_name]
+      # puts "Loops to parse #{@x12_definition[X12::Loop].keys}"
+      throw Exception.new("Cannot find a definition for loop #{loop_name}") unless loop
+      loop = loop.dup
+      loop.parse(str)
+      return loop
+    end
+
+    # Make an empty loop to be filled out with information.
+    def factory(loop_name)
+      loop = @x12_definition[X12::Loop][loop_name]
+      throw Exception.new("Cannot find a definition for loop #{loop_name}") unless loop
+      loop = loop.dup
+      return loop
+    end
+
+    private
+
+    # Recursively scan the loop and instantiate fields' definitions for all its segments.
+    def process_loop(loop)
+      loop.nodes.each do |i|
+        case i
+          when X12::Loop then process_loop(i)
+          when X12::Segment then process_segment(i) unless i.nodes.size > 0
+          else return
+        end
+      end
+    end
+
+    # Instantiate segment's fields as previously defined
+    def process_segment(segment)
+      # puts "Trying to process segment #{segment.inspect}"
+      unless @x12_definition[X12::Segment] && @x12_definition[X12::Segment][segment.name]
+        # Try to find it in a separate file if missing from the @x12_definition structure
+        initialize(segment.name+'.xml')
+        segment_definition = @x12_definition[X12::Segment][segment.name]
+        throw Exception.new("Cannot find a definition for segment #{segment.name}") unless segment_definition
+      else
+        segment_definition = @x12_definition[X12::Segment][segment.name]
+      end
+      segment_definition.nodes.each_index { |i|
+        segment.nodes[i] = segment_definition.nodes[i]
+        # Make sure we have the validation table if any for this field. Try to read one in if missing.
+        table = segment.nodes[i].validation
+        if table
+          unless @x12_definition[X12::Table] && @x12_definition[X12::Table][table]
+            initialize(table + '.xml')
+            throw Exception.new("Cannot find a definition for table #{table}") unless @x12_definition[X12::Table] && @x12_definition[X12::Table][table]
+          end
+        end
+      }
+    end
+
+  end
+
+end