pd_x12 1.4.0

data/lib/x12/field.rb

@@ -0,0 +1,92 @@
+#--
+#     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
+#++
+#
+module X12
+
+  # $Id: Field.rb 90 2009-05-13 19:51:27Z ikk $
+  #
+  # 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
+    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
+      @content || ''
+    end # render
+
+    # 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 # simple_regexp
+
+    # 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 # case
+    end # str_regexp
+
+  end
+end

data/lib/x12/loop.rb

@@ -0,0 +1,85 @@
+#--
+#     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
+#++
+#
+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 # parse
+
+    # 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 # render
+    
+    # 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 # Loop
+end # X12

data/lib/x12/parser.rb

@@ -0,0 +1,146 @@
+#--
+#     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 "rexml/document"
+require 'pp'
+
+module X12
+
+  # $Id: Parser.rb 89 2009-05-13 19:36:20Z ikk $
+  #
+  # 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',
+                 ]
+
+    # 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 # initialize
+
+    # 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 # parse
+
+    # 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 # factory
+
+    private
+
+    # Recursively scan the loop and instantiate fields' definitions for all its
+    # segments
+    def process_loop(loop)
+      loop.nodes.each{|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
+
+    # 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 # Parser
+end

data/lib/x12/segment.rb

@@ -0,0 +1,115 @@
+#--
+#     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
+#++
+#
+module X12
+
+  # $Id: Segment.rb 82 2009-05-13 18:07:22Z ikk $
+  #
+  # Implements a segment containing fields or composites
+    
+  class Segment < Base
+
+    # Parses this segment out of a string, puts the match into value, returns the rest of the string - nil
+    # if cannot parse
+    def parse(str)
+      s = str
+      #puts "Parsing segment #{name} from #{s} with regexp [#{regexp.source}]"
+      m = regexp.match(s)
+      #puts "Matched #{m ? m[0] : 'nothing'}"
+      
+      return nil unless m
+
+      s = m.post_match
+      self.parsed_str = m[0]
+      s = do_repeats(s)
+
+      #puts "Parsed segment "+self.inspect
+      return s
+    end # parse
+
+    # Render all components of this segment as string suitable for EDI
+    def render
+      self.to_a.inject(''){|repeat_str, i|
+        if i.repeats.begin < 1 and !i.has_content?
+          # Skip optional empty segments
+          repeat_str
+        else
+          # Have to render no matter how empty
+          repeat_str += i.name+i.nodes.reverse.inject(''){|nodes_str, j|
+            field = j.render
+            (j.required or nodes_str != '' or field != '') ? field_separator+field+nodes_str : nodes_str
+          } + segment_separator
+        end
+      }
+    end # render
+
+    # Returns a regexp that matches this particular segment
+    def regexp
+      unless @regexp
+        if self.nodes.find{|i| i.type =~ /^".+"$/ }
+          # It's a very special regexp if there are constant fields
+          re_str = self.nodes.inject("^#{name}#{Regexp.escape(field_separator)}"){|s, i|
+            field_re = i.simple_regexp(field_separator, segment_separator)+Regexp.escape(field_separator)+'?'
+            field_re = "(#{field_re})?" unless i.required
+            s+field_re
+          } + Regexp.escape(segment_separator)
+          @regexp = Regexp.new(re_str)
+        else
+          # Simple match
+          @regexp = Regexp.new("^#{name}#{Regexp.escape(field_separator)}[^#{Regexp.escape(segment_separator)}]*#{Regexp.escape(segment_separator)}")
+        end
+        #puts sprintf("%s %p", name, @regexp)
+      end
+      @regexp
+    end
+
+    # Finds a field in the segment. Returns EMPTY if not found.
+    def find_field(str)
+      #puts "Finding field [#{str}] in #{self.class} #{name}"
+      # If there is such a field to begin with
+      field_num = nil
+      self.nodes.each_index{|i|
+        field_num = i if str == self.nodes[i].name
+      }
+      return EMPTY if field_num.nil?
+      #puts field_num
+
+      # Parse the segment if not parsed already
+      unless @fields
+        @fields = self.to_s.chop.split(Regexp.new(Regexp.escape(field_separator)))
+        self.nodes.each_index{|i| self.nodes[i].content = @fields[i+1] }
+      end
+      #puts self.nodes[field_num].inspect
+      return self.nodes[field_num]
+    end
+
+    # provides loopong through multiple segments within the loop
+    def each
+      res = self.to_a
+      0.upto(res.length - 1) do |x|
+        yield res[x]
+      end
+    end
+
+  end # Segment
+end # X12

data/lib/x12/table.rb

@@ -0,0 +1,44 @@
+#--
+#     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
+#++
+#
+module X12
+
+  # $Id: Table.rb 35 2008-11-13 18:33:44Z ikk $
+  #
+  # This just a named hash to store validation tables.
+
+  class Table < Hash
+    attr_reader :name
+
+    # Create a new table with given name and hash content.
+    def initialize(name, name_values)
+      @name = name       
+      self.merge!(name_values)
+    end
+
+    # Return a printable string representing this table
+    def inspect
+      "Table #{name} -- #{super.inspect}"
+    end
+  end
+end

data/lib/x12/version.rb

@@ -0,0 +1,3 @@
+module X12
+  VERSION = "1.4.0"
+end

data/lib/x12/xmldefinitions.rb

@@ -0,0 +1,175 @@
+#--
+#     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 "rexml/document"
+
+module X12
+
+  # $Id: XMLDefinitions.rb 90 2009-05-13 19:51:27Z ikk $
+  #
+  # A class for parsing X12 message definition expressed in XML format.
+
+  class XMLDefinitions < Hash
+
+    # Parse definitions out of XML file
+    def initialize(str)
+      doc = REXML::Document.new(str)
+      definitions = doc.root.name =~ /^Definition$/i ? doc.root.elements.to_a : [doc.root]      
+      
+      definitions.each { |element|
+        #puts element.name
+        syntax_element = case element.name
+                         when /table/i     
+                           parse_table(element)
+                         when /segment/i 
+                           parse_segment(element)
+                         when /composite/i 
+                           parse_composite(element)
+                         when /loop/i
+                           parse_loop(element)
+                         end
+        self[syntax_element.class] ||= {}
+        self[syntax_element.class][syntax_element.name]=syntax_element
+      }
+    end # initialize
+
+    private
+
+    def parse_boolean(s)
+      return case s
+             when nil
+               false
+             when "" 
+               false
+             when /(^y(es)?$)|(^t(rue)?$)|(^1$)/i 
+               true
+             when /(^no?$)|(^f(alse)?$)|(^0$)/i 
+               false
+             else
+               nil
+             end # case
+    end #parse_boolean
+
+    def parse_type(s)
+      return case s
+             when nil
+               'string'
+             when /^C.+$/ 
+               s
+             when /^i(nt(eger)?)?$/i
+               'int'
+             when /^l(ong)?$/i
+               'long'
+             when /^d(ouble)?$/i
+               'double'
+             when /^s(tr(ing)?)?$/i
+               'string'
+             else
+               nil
+             end # case
+    end #parse_type
+
+    def parse_int(s)
+      return case s
+             when nil then 0
+             when /^\d+$/ then s.to_i
+             when /^inf(inite)?$/ then 999999
+             else
+               nil
+             end # case
+    end #parse_int
+
+    def parse_attributes(e)
+      throw Exception.new("No name attribute found for : #{e.inspect}")          unless name = e.attributes["name"] 
+      throw Exception.new("Cannot parse attribute 'min' for: #{e.inspect}")      unless min = parse_int(e.attributes["min"])
+      throw Exception.new("Cannot parse attribute 'max' for: #{e.inspect}")      unless max = parse_int(e.attributes["max"])
+      throw Exception.new("Cannot parse attribute 'type' for: #{e.inspect}")     unless type = parse_type(e.attributes["type"])
+      throw Exception.new("Cannot parse attribute 'required' for: #{e.inspect}") if (required = parse_boolean(e.attributes["required"])).nil?
+      
+      validation = e.attributes["validation"]
+      min = 1 if required and min < 1
+      max = 999999 if max == 0
+
+      return name, min, max, type, required, validation
+    end # parse_attributes
+
+    def parse_field(e)
+      name, min, max, type, required, validation = parse_attributes(e)
+
+      # FIXME - for compatibility with d12 - constants are stored in attribute 'type' and are enclosed in
+      # double quotes
+      const_field =  e.attributes["const"]
+      if(const_field)
+        type = "\"#{const_field}\""
+      end
+
+      Field.new(name, type, required, min, max, validation)
+    end # parse_field
+
+    def parse_table(e)
+      name, min, max, type, required, validation = parse_attributes(e)
+
+      content = e.get_elements("Entry").inject({}) {|t, entry|
+        t[entry.attributes["name"]] = entry.attributes["value"]
+        t
+      }
+      Table.new(name, content)
+    end
+
+    def parse_segment(e)
+      name, min, max, type, required, validation = parse_attributes(e)
+
+      fields = e.get_elements("Field").inject([]) {|f, field|
+        f << parse_field(field)
+      }
+      Segment.new(name, fields, Range.new(min, max))
+    end
+
+    def parse_composite(e)
+      name, min, max, type, required, validation = parse_attributes(e)
+
+      fields = e.get_elements("Field").inject([]) {|f, field|
+        f << parse_field(field)
+      }
+      Composite.new(name, fields)
+    end
+
+    def parse_loop(e)
+      name, min, max, type, required, validation = parse_attributes(e)
+
+      components = e.elements.to_a.inject([]){|r, element|
+        r << case element.name
+             when /loop/i
+               parse_loop(element)
+             when /segment/i
+               parse_segment(element)
+             else
+               throw Exception.new("Cannot recognize syntax for: #{element.inspect} in loop #{e.inspect}")
+             end # case
+      }
+      Loop.new(name, components, Range.new(min, max))
+    end
+
+  end # Parser
+end