gm_x12 1.6.0

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
+
+  #
+  # 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
+  
+  #
+  # Class indicating the absence 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,94 @@
+#--
+#     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
+  
+  #
+  # 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
+      rendered = @content || ''
+      rendered = rendered.ljust(@min_length) if @required
+      rendered
+    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,96 @@
+#--
+#     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_helper(str, yield_loop_name, block)
+      # puts "#{$count}: parse for #{name}" if name == yield_loop_name
+      $count ||=0
+      # $count+=1 if name == yield_loop_name
+      # return nil if name == yield_loop_name && (($count+=1) > 2)
+      #puts "Parsing loop #{name}: "+str
+      current_location = str
+      nodes.each{|node|
+        match_location = node.parse(current_location, yield_loop_name, block)
+        current_location = match_location if match_location
+      } 
+      if str == current_location
+        return nil
+      else
+        self.parsed_str = str[0..-current_location.length-1]
+        block.call(self) if yield_loop_name && name == yield_loop_name
+        return current_location
+      end
+    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
+
+  
+    # Formats a printable string containing the loops element's content 
+    # added to provide compatability with ruby > 2.0.0 
+    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 # Loop
+end # X12

data/lib/x12/parser.rb

@@ -0,0 +1,133 @@
+#--
+#     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: 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
+      $count = 0
+
+      # 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, yield_loop_name=nil, &block)
+      raise "Must provide a block if you specify a yield_loop_name" if yield_loop_name && !block
+      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, yield_loop_name, block)
+      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,114 @@
+#--
+#     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 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_helper(str, yield_loop_name, block)
+      s = str
+      # puts "Parsing segment #{name} from #{s[0..10]} with regexp [#{regexp.source}]"
+      quick_match = s.start_with?("#{name}#{field_separator}")
+      puts "#{name} #{s[0..10]} with regexp [#{regexp.source}] matched #{quick_match ? s[0..10] : 'nothing'}"
+
+      return nil unless quick_match
+      m = regexp.match(s)
+      s = m.post_match
+      self.parsed_str = m[0]
+      #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 looping 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