PD_x12 1.3.1

data/lib/x12/composite.rb

@@ -0,0 +1,37 @@
+#--
+#     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: Composite.rb 35 2008-11-13 18:33:44Z ikk $
+  #
+  # Class implementing a composite field.
+
+  class Composite < Base
+
+    # Make a printable representation of the composite
+    def inspect
+      "Composite "+super.inspect
+    end
+  end
+end

data/lib/x12/empty.rb

@@ -0,0 +1,43 @@
+#--
+#     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: Empty.rb 35 2008-11-13 18:33:44Z ikk $
+  #
+  # 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
+    def to_s
+      ''
+    end
+
+  end # Empty
+end # X12

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,78 @@
+#--
+#     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: Loop.rb 59 2009-03-19 22:32:13Z ikk $
+  #
+  # 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
+
+  end # Loop
+end # X12

data/lib/x12/parser.rb

@@ -0,0 +1,151 @@
+#--
+#     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
+      @dir_name = Dir.pwd + "/misc/" 
+      file_name = @dir_name + file_name
+      
+      
+      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
+      #puts "Reading definition from #{file_name}"
+
+      # Read and parse the definition
+      str = File.open(file_name, '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,107 @@
+#--
+#     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
+
+  end # Segment
+end # X12