edi4r 0.9.4.1

data/data/edifact/untdid/IDSD.d01b.csv

@@ -0,0 +1,75 @@
+AAI;ACCOMMODATION ALLOCATION INFORMATION;010;E997;M;20;
+ADI;HEALTH CARE CLAIM ADJUDICATION INFORMATION;010;E206;M;3;020;E021;C;3;030;1229;C;1;040;E017;C;15;050;6060;C;3;060;E030;C;15;070;9620;C;4;080;5389;C;1;090;E507;C;1;100;9639;C;1;110;5482;C;1;
+ADS;ADDRESS;010;E817;C;1;020;E001;C;1;030;3164;C;1;040;3251;C;1;050;3207;C;1;060;E819;C;1;070;E517;C;1;
+ALS;ADDITIONAL LOCATION INFORMATION;010;3227;M;1;020;E975;M;99;030;6000;C;1;040;6002;C;1;
+APD;ADDITIONAL TRANSPORT DETAILS;010;E961;C;1;020;E962;C;2;030;E963;C;1;040;E964;C;1;050;E965;C;10;
+ASD;SERVICE DETAILS;010;E959;M;9;020;E013;C;99;030;2160;C;1;
+ATI;TOUR INFORMATION;010;E993;C;1;020;E994;C;99;
+ATR;ATTRIBUTE;010;9017;M;1;020;E003;M;1;
+BLI;BILLABLE INFORMATION;010;5004;C;3;020;E029;C;9;030;E507;C;9;040;7402;C;5;050;9607;C;3;060;E028;C;9;
+CLT;CLEAR TERMINATE INFORMATION;010;1229;M;1;020;1225;C;2;030;4440;C;1;
+CMN;COMMISSION INFORMATION;010;E002;M;9;
+CNX;CONNECTION DETAILS;010;E999;C;9;
+CNY;COUNTRY INFORMATION;010;3207;M;1;020;E013;C;2;030;2031;C;2;040;6345;C;1;050;3453;C;9;
+CON;CONTACT INFORMATION;010;E966;C;20;
+CRI;CONSUMER REFERENCE INFORMATION;010;E967;M;20;
+CUR;CURRENCIES;010;E504;C;1;020;E504;C;1;030;5402;C;1;040;6341;C;1;
+DAV;DAILY AVAILABILITY;010;7037;M;1;020;E009;M;31;
+DIS;DISCOUNT INFORMATION;010;E998;M;20;
+DNT;DENTAL INFORMATION;010;7402;C;1;020;7383;C;5;030;9647;C;5;040;6060;C;6;050;4405;C;1;
+DTI;DATE AND TIME INFORMATION;010;E013;M;9;020;E014;C;99;
+ERI;APPLICATION ERROR INFORMATION;010;E901;M;1;
+FRM;FOLLOW-UP ACTION;010;7402;M;1;020;9013;M;7;030;1229;C;1;
+FRQ;FREQUENCY;010;E520;M;99;
+FTI;FREQUENT TRAVELLER INFORMATION;010;E970;M;9;
+HDI;HARDWARE DEVICE INFORMATION;010;3148;C;1;020;3413;C;1;030;1511;C;1;040;E003;C;9;
+HDR;HEADER INFORMATION;010;4405;M;1;020;E013;M;4;030;1154;C;1;040;4440;C;1;050;7135;C;2;060;3453;C;1;
+ICI;INSURANCE COVER INFORMATION;010;E016;M;1;020;E017;C;5;
+IFT;INTERACTIVE FREE TEXT;010;E971;C;1;020;4440;C;99;
+ITC;INSTITUTIONAL CLAIM;010;E027;M;1;020;6060;M;4;030;E026;M;1;040;9447;M;1;050;E025;C;9;
+ITD;INFORMATION TYPE DATA;010;9601;C;1;020;3453;C;1;030;9603;C;10;040;1503;C;1;
+ITM;ITEM NUMBER;010;E212;C;99;
+LKP;LEVEL INDICATION;010;E778;M;1;
+LNG;LANGUAGE;010;3455;M;1;020;E033;C;1;
+MAP;MESSAGE APPLICATION PRODUCT INFORMATION;010;E022;C;1;020;3036;C;1;030;E031;C;1;
+MES;MEASUREMENTS;010;E175;M;9;
+MOV;CAR DELIVERY INSTRUCTION;010;E995;C;1;020;6350;C;1;030;3453;C;1;
+MSD;MESSAGE ACTION DETAILS;010;E972;C;1;020;4343;C;5;030;E206;C;5;
+NAA;NAME AND ADDRESS;010;3035;M;1;020;E082;C;1;030;3124;C;5;040;E080;C;1;050;3042;C;1;060;3164;C;1;070;3229;C;1;080;3251;C;1;090;3207;C;1;
+NME;NAME;010;E012;M;9;
+NUN;NUMBER OF UNITS;010;E523;M;9;
+ODI;ORIGIN AND DESTINATION DETAILS;010;3225;C;2;020;1050;C;2;
+ODS;ADDITIONAL PRODUCT DETAILS;010;9605;M;1;020;E015;M;999;
+ORG;ORIGINATOR OF REQUEST DETAILS;010;E973;C;1;020;E974;C;1;030;E975;C;1;040;3036;C;1;050;3457;C;1;060;E976;C;1;070;3503;C;1;
+OTI;OTHER INSURANCE;010;E206;M;5;020;9645;M;1;030;E507;C;2;040;5267;C;10;050;5004;C;4;060;E030;C;15;070;4497;C;1;080;9143;C;1;090;9607;C;1;
+PDT;PRODUCT INFORMATION;010;7133;C;1;020;E996;C;26;
+PLI;PRODUCT LOCATION INFORMATION;010;E008;M;99;
+PMT;PAYMENT INFORMATION;010;E977;C;99;020;E978;C;99;
+POP;PERIOD OF OPERATION;010;E013;M;1;020;2160;C;1;030;4405;C;1;
+POR;LOCATION AND/OR RELATED TIME INFORMATION;010;E517;M;1;020;E362;C;2;030;E992;C;2;040;3227;C;1;050;1050;C;1;
+POS;POINT OF SALE INFORMATION;010;E032;C;999;020;E975;C;999;
+PRD;PRODUCT IDENTIFICATION;010;E989;C;9;020;3036;C;6;
+PRE;PRICE DETAILS;010;E018;C;20;020;5213;C;1;
+PRO;PROMOTIONS;010;E019;M;20;
+PRT;PARTY INFORMATION;010;3035;M;1;020;E206;C;9;030;2000;C;3;040;E023;C;1;
+PSI;SERVICE INFORMATION;010;7402;M;4;020;E507;C;5;030;E021;C;1;040;6060;C;2;050;5004;C;5;060;5030;C;4;070;9039;C;1;080;5267;C;1;090;4183;C;9;100;E024;C;1;
+QTI;QUANTITY;010;E035;M;9;
+RCI;RESERVATION CONTROL INFORMATION;010;E979;C;99;
+RFR;REFERENCE;010;E506;M;1;
+RLS;RELATIONSHIP;010;9141;M;1;020;E941;C;1;
+RPI;QUANTITY AND ACTION DETAILS;010;E958;M;9;
+RTC;RATE TYPES;010;5263;M;99;
+RTI;RATE DETAILS;010;E011;M;99;
+RUL;RULE INFORMATION;010;E004;C;99;020;E005;C;9;030;E006;C;9;
+SDT;SELECTION DETAILS;010;E010;M;99;
+SER;FACILITY INFORMATION;010;E965;C;99;020;1229;C;1;030;6350;C;1;040;E013;C;99;050;2160;C;1;
+SSR;SPECIAL REQUIREMENT DETAILS;010;E980;M;1;020;E981;C;999;
+TCE;TIME AND CERTAINTY;010;2380;C;1;020;E946;C;1;
+TDI;TRAVELLER DOCUMENT INFORMATION;010;E968;M;1;020;E969;C;1;030;3500;C;1;040;3460;C;99;
+TFF;TARIFF INFORMATION;010;E982;C;99;020;E983;C;99;030;E984;C;99;
+TIF;TRAVELLER INFORMATION;010;E985;M;1;020;E986;C;99;
+TIZ;TIME ZONE INFORMATION;010;E034;M;1;
+TRF;TRAFFIC RESTRICTION DETAILS;010;E007;M;5;
+TVL;TRAVEL PRODUCT INFORMATION;010;E987;C;1;020;E975;C;2;030;E988;C;1;040;E989;C;1;050;E990;C;1;060;1082;C;1;070;7365;C;1;
+TXS;TAXES;010;E020;M;99;
+VEH;VEHICLE;010;8053;C;1;020;E991;C;1;030;E211;C;1;040;6314;C;1;050;E992;C;1;060;1145;C;1;

data/lib/edi4r.rb

@@ -0,0 +1,928 @@
+=begin rdoc
+:main:README
+:title:edi4r
+
+= UN/EDIFACT module
+
+An API to parse and create UN/EDIFACT and other EDI data
+* Abstract classes are maintained in this file.
+* See other files in edi4r/ for specific EDI syntax standards.
+
+$Id: edi4r.rb,v 1.6 2006/08/01 11:12:39 werntges Exp $
+
+:include: ../AuthorCopyright
+
+== Background
+
+We anticipate to support several EDI syntax standards with this module:
+
+ C  Name		Description
+ ===========================================================================
+ A  ANSI ASC X.12	the U.S. EDI standard; a precursor of UN/EDIFACT
+ E  UN/EDIFACT 		the global EDI standard under the auspices of the UNO
+ G  GENCOD		an early French EDI standard, consumer goods branch
+ I  SAP IDoc		not an EDI standard, but a very popular in-house format
+ S  SEDAS		an early Austrian/German EDI standard, see GENCOD
+ T  Tradacoms		the British EDI standard; a precursor of UN/EDIFACT
+ X  XML			(DTDs / Schemas still to be supplied)
+
+Our focus will be on UN/EDIFACT, the only global EDI standard we have
+that is independent of industry branches.
+
+Terms used will be borrowed from EDIFACT and applied to the other 
+syntax standards whenever possible.
+
+A, E, and T are technically related in that they employ a compact
+data representation based on a hierarchy of separator characters.
+G and S as well as I are fixed-record formats, X is a markup syntax.
+
+== Data model
+
+We use the EDIFACT model as the name-giving, most general model.
+Other EDI standards might not support all features.
+
+The basic unit exchanged between trading partners is the "Interchange".
+An interchange consists of an envelope and content. Content is
+either a sequence of messages or a sequence of message groups.
+Message groups - if used - comprise a (group level) envelope and
+a sequence of messages.
+
+A message is a sequence of segments (sometimes also called records).
+A segment consists of a sequence of data elements (aka. fields), 
+either simple ones (DE) or composites (CDE). 
+Composites are sequences of simple data elements.
+
+Hence:
+
+ Interchange > [ MsgGroup > ] Message > Segment > [ CDE > ] DE
+
+Syntax related information is maintained at the top (i.e. interchange) level.
+Lower-level objects like segments and DEs are aware of their syntax context
+through attibute "root", even though this context originates at the 
+interchange level.
+
+Lower levels may add information. E.g. a message may add its message type,
+or a segment its hierarchy level, and its segment group - depending
+on the syntax standard in use.
+
+This basic structure is always maintained, even in cases like SAP IDocs
+where the Interchange level is just an abstraction.
+
+Note that this data model describes the data as they are parsed or built,
+essentially lists of lists or strings. In contrast, EDI documents
+frequently publish specifications in a hierarchical way, using terms like
+"segment group", "instance", "level" and alike.
+Here we regard such information as metadata, or additional properties
+which may or may not apply or be required.
+
+=== Example
+
+You can build a valid EDIFACT interchange simply by adding
+messages and segments - just follow your specifications.
+
+However, if you want this Ruby module to *validate* your result, 
+the metadata are required. Similarly, in order to map from EDIFACT to
+other formats, accessing inbound segments though their hierarchical
+representation is much more convenient than processing them linearly.
+
+== EDI Class hierarchy (overview)
+
+EDI_Object::    Collection, DE
+Collection::    Collection_HT, Collection_S
+Collection_HT:: Interchange, MsgGroup, Message
+Collection_S::  Segment, CDE
+=end
+
+# To-do list:
+#   validate	- add still more functionality, e.g. codelists
+#   charset	- check for valid chars in more charsets
+#   NDB		- support codelists
+#   (much more, including general cleanup & tuning ...)
+
+require 'enumerator'
+
+BEGIN {
+  require 'pathname'
+# 'realpath' fails on Windows platforms!
+# ENV['EDI_NDB_PATH'] = Pathname.new(__FILE__).dirname.parent.realpath + 'data'
+  pdir = Pathname.new(__FILE__).dirname.parent
+  ENV['EDI_NDB_PATH'] =  File.expand_path(pdir) + File::Separator + 'data'
+}
+
+require "edi4r/standards"
+require "edi4r/diagrams"
+
+
+module EDI
+
+  #########################################################################
+  #
+  # Basic (abstract) class: Makes sure that all derived
+  # EDI objects have at least following attributes:
+  #
+  # +parent+:: Reference to parent EDI object (a +Collection+)
+  # +root+::   Reference to root   EDI object (typically an +Interchange+)
+  # +name+::   The name of this instance (a +String+ object)
+  #
+  # Caveat:: Setters are used only internally during message construction.
+  #          Avoid using them!
+
+
+  class Object
+    attr_accessor :parent, :root, :name
+
+    def initialize (parent, root, name)
+      @parent, @root, @name = parent, root, name
+    end
+  end
+
+
+  #########################################################################
+  #
+  # A simple utility class that fills a need not covered by "zlib".
+  #
+  # It is stripped to the essentials needed here internally.
+  # Not recommended for general use! The overhead of starting 
+  # "bzcat" processes all the time is considerable, binding to a library
+  # similar to 'zib' for the BZIP2 format would give much better results.
+
+  class Bzip2Reader
+    attr_accessor :path
+
+    def initialize( hnd )
+      @path = hnd.path
+      @pipe = IO.popen("bzcat #@path",'r' )
+    end
+
+    def read( len=0 )
+      len==0 ? @pipe.read : @pipe.read( len )
+    end
+
+    def rewind
+      @pipe.close
+      @pipe = IO.popen("bzcat #@path",'r' )
+    end
+
+    def close
+      @pipe.close
+    end
+  end
+
+  #########################################################################
+  #
+  # An EDI collection instance behaves like a simplified array.
+  # In addition, it permits access to its elements through their names.
+  # This implies that only objects with a +name+ may be stored,
+  # i.e. derivatives of EDI::Object.
+
+  class Collection < EDI::Object
+
+    def initialize( parent, root, name )
+      super
+      @a = []
+    end
+
+
+    def root= (rt)
+      super( rt )
+      each {|obj| obj.root = rt }
+    end
+
+
+    # Similar to Array#push(), but automatically setting obj's
+    # parent and root to self and self's root. Returns obj.
+    def add( obj )
+      push obj
+      obj.parent = self
+      obj.root = self.root
+      obj
+    end
+
+    alias append add
+
+
+    def ==(obj)
+      self.object_id == obj.object_id
+    end
+
+    # Delegate to array:
+    #   index, each, find_all, length, size, first, last
+    def index(obj);   @a.index(obj);   end
+    def each(&b);     @a.each(&b);     end
+    def find_all(&b); @a.find_all(&b); end
+    def size;         @a.size;         end
+    def length;       @a.length;       end
+    def first;        @a.first;        end
+    def last;         @a.last;         end
+
+    # The element reference operator [] supports two access modes:
+    # Array-like:: Return indexed element when passing an integer
+    # By name::    Return array of element(s) whose name(s) match given string
+    def [](i)
+      lookup(i)
+    end
+
+
+    # This implementation of +inspect()+ is very verbose in that it
+    # inspects also all contained objects in a recursive manner.
+    #
+    # indent::  String offset to use for indentation / pretty-printing
+    # symlist:: Array of getter names (passed as symbols) whose values are
+    #           to be listed. Note that :name is included automatically.
+
+    def inspect( indent='', symlist=[] )
+      headline = indent + self.name+': ' + symlist.map do |sym|
+        "#{sym} = #{(s=send(sym)).nil? ? 'nil' : s.to_s}"
+      end.join(', ') + "\n"
+      headline << @header.inspect(indent+'  ') if @header
+      s = @a.inject( headline ){|s,obj| s << obj.inspect(indent+'  ')}
+      @trailer ? s << @trailer.inspect(indent+'  ') : s
+    end
+
+
+    # Returns an array of names of all included objects in proper sequence;
+    # primarily for internal use.
+
+    def names
+      @a.collect {|e| e.name}
+    end
+
+
+    # Helper method: Turns e.g. "EDI::E::Interchange" into "Interchange".
+    # For internal use only!
+
+    def normalized_class_name # :nodoc:
+      if self.class.to_s !~ /^(\w*::)?(\w::)(\w+)?$/
+        raise "Cannot normalize class name: #{self.class.to_s}"
+      end
+      $3
+    end
+
+
+    private
+
+    # push: Similar to Array#push, except that it requires objects
+    #       with getter :name
+    #       Low-level method, avoid. Use "add" instead.
+
+    def push( obj )
+      raise TypeError unless obj.is_a? EDI::Object # obj.respond_to? :name
+      @a << obj
+    end
+
+
+    alias << push
+
+
+    def lookup(i)
+      if i.is_a?(Integer)
+        @a[i]
+      else
+        @a.find_all {|x| x.name == i}
+      end
+    end
+
+    # Here we perform the "magic" that provides us with dynamically
+    # "generated" getters and setters for just those DE and CDE
+    # available in the given Collection_S instance.
+    #
+    # UN/EDIFACT examples:
+    #  d3055, d1004=(value), cC105, a7174[1].value
+
+    def method_missing(sym, *par)
+      if sym.id2name =~ /^([acds])(\w+)(=)?/
+        rc = lookup($2)
+        if rc.is_a? Array
+          if rc.size==1
+            rc = rc.first
+          elsif rc.size==0
+            return super
+          end
+        end
+        if $3
+          # Setter
+          raise TypeError, "Can't assign to array #$2" if rc.is_a? Array
+          raise TypeError, "Can only assign to a DE value" if $1 != 'd'
+          rc.value = par[0]
+        else
+          # Getter
+          return rc.value if rc.is_a? DE and $1 == 'd'
+          return rc if rc.is_a? CDE      and $1 == 'c'
+          return rc if rc.is_a? Segment  and $1 == 's'
+          err_msg =  "Method prefix '#$1' not matching result '#{rc.class}'!"
+          raise TypeError, err_msg unless rc.is_a? Array
+          # Don't let whole DEs be overwritten - enforce usage of "value":
+          rc.freeze
+          return rc if $1 == 'a'
+          raise TypeError,"Array found - use 'a#$2[i]' to access component i"
+        end
+      else
+        super
+      end
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # A collection with header and trailer, common to Interchange, MsgGroup, 
+  # and Message. Typically, header and trailer are Segment instances.
+  #
+  class Collection_HT < Collection
+    attr_accessor :header, :trailer # make private or protected?
+
+    def root= (rt)
+      super( rt )
+      @header.root = rt if @header
+      @trailer.root = rt if @trailer
+    end
+
+
+    # Experimental: Ignore content of header / trailer,
+    # regard object as empty when nothing "add"ed to it.
+
+    def empty?
+      @a.empty?
+    end
+
+
+    def validate( err_count=0 )
+      err_count += @header.validate if @header
+      err_count += @trailer.validate if @trailer
+      each {|obj| err_count += obj.validate}
+      err_count
+    end
+
+
+    def to_s( postfix='' )
+      s = @header ? @header.to_s+postfix : ''
+      each {|obj| s << (obj.is_a?(Segment) ? obj.to_s+postfix : obj.to_s)}
+      s << @trailer.to_s+postfix if @trailer
+      s
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # A "segment-like" collection, base class of Segment and CDE
+  #
+  class Collection_S < Collection
+    attr_accessor :status, :rep, :maxrep
+
+
+    def initialize(parent, name, status=nil)
+      @status = status
+      super( parent, parent.root, name)
+    end
+
+
+    def validate( err_count=0 )
+      location = "#{parent.name} - #{@name}"
+      if empty?
+        if required?
+          warn "#{location}: Empty though mandatory!"
+          err_count += 1
+        end
+      else
+        if rep && maxrep && rep > maxrep
+          warn "#{location}: Too often repeated: #{rep} > #{maxrep}!"
+          err_count += 1
+        end
+        each {|obj| err_count += obj.validate}
+      end
+      err_count
+    end
+
+
+    def fmt_of_DE(id) # :nodoc:
+      @parent.fmt_of_DE(id)
+    end
+
+
+    def each_BCDS(id, &b) # :nodoc:
+      @parent.each_BCDS(id, &b)
+    end
+
+
+    # Returns +true+ if all contained elements are empty.
+
+    def empty?
+      empty = true
+      each {|obj| empty &= obj.empty? } # DE or CDE
+      empty
+    end
+
+
+    # Returns +true+ if this segment or CDE is mandatory / required
+    # according to its defining "Diagram".
+
+    def required?
+      @status == 'M' or @status == 'R'
+    end
+
+
+    def inspect( indent='', symlist=[] )
+      symlist += [:status, :rep, :maxrep]
+      super
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # Base class of all interchanges
+  #
+  class Interchange < Collection_HT
+
+    attr_accessor :output_mode
+    attr_reader :syntax, :version, :output_mode, :illegal_charset_pattern
+
+    # Abstract class - don't instantiate directly
+    #
+    def initialize( user_par=nil )
+      super( nil, self, 'Interchange' )
+      @illegal_charset_pattern = /^$/ # Default: Never match a non-empty string
+      @content = nil # nil if empty, :messages, or :groups
+    end
+
+    # Auto-detect file content, optionally decompress, return an 
+    # Interchange object of the sub-class that matches the (unzipped) content.
+    #
+    # This is a convenience method.
+    # When you know the file contents, consider a direct call to
+    # Interchange::E::parse etc.
+    #
+    # NOTES:
+    # * Make sure to <tt>require 'zlib'</tt> when applying this method
+    #   to gzipped files.
+    # * BZIP2 is indirectly supported by calling "bzcat". Make sure that
+    #   "bzcat" is available when applying this method to *.bz2 files.
+    # * Do not pass $stdin to this method - we could not "rewind" it!
+
+    def Interchange.parse( hnd, auto_validate=true )
+      case rc=Interchange.detect( hnd )
+      when 'BZ': Interchange.parse( EDI::Bzip2Reader.new( hnd ) ) # see "peek"
+      when 'GZ': Interchange.parse( Zlib::GzipReader.new( hnd ) )
+      when 'E':  EDI::E::Interchange.parse( hnd, auto_validate )
+      when 'I':  EDI::I::Interchange.parse( hnd, auto_validate )
+      when 'XE': EDI::E::Interchange.parse_xml( REXML::Document.new(hnd) )
+      when 'XI': EDI::I::Interchange.parse_xml( REXML::Document.new(hnd) )
+      else raise "#{rc}: Unsupported format key - don\'t know how to proceed!"
+      end
+    end
+
+    # Auto-detect file content, optionally decompress, return an 
+    # empty Interchange object of that sub-class with only the header filled.
+    #
+    # This is a convenience method.
+    # When you know the file contents, consider a direct call to
+    # Interchange::E::peek etc.
+    #
+    # NOTES: See Interchange.parse
+
+    def Interchange.peek( hnd=$stdin)
+      case rc=Interchange.detect( hnd )
+        # Does not exist yet!
+#      when 'BZ': Interchange.peek( Zlib::Bzip2Reader.new( hnd ) )
+        # Temporary substitute, Unix/Linux only, low performance:
+      when 'BZ': Interchange.peek( EDI::Bzip2Reader.new( hnd ) )
+
+      when 'GZ': Interchange.peek( Zlib::GzipReader.new( hnd ) )
+      when 'E':  EDI::E::Interchange.peek( hnd )
+      when 'I':  EDI::I::Interchange.peek( hnd )
+      when 'XE': EDI::E::Interchange.peek_xml( REXML::Document.new(hnd) )
+      when 'XI': EDI::I::Interchange.peek_xml( REXML::Document.new(hnd) )
+      else raise "#{rc}: Unsupported format key - don\'t know how to proceed!"
+      end
+    end
+
+    # Auto-detect the given file format & content, return format key
+    #
+    # Convenience method, intended for internal use only
+    # 
+    def Interchange.detect( hnd ) # :nodoc:
+      buf = hnd.read( 256 )
+      #
+      # NOTE: "rewind" fails when applied to $stdin!
+      # If you really need to read from $stdin, call Interchange::E::parse()
+      # and Interchange::E::peek() etc. directly to bypass auto-detection
+      hnd.rewind
+
+      re  = /(<\?xml.*?)?DOCTYPE\s+Interchange.*?\<Interchange\s+.*?standard\_key\s*=\s*(['"])(.)\2/m
+      case buf
+      when /^(UNA......)?\r?\n?U[IN]B.UNO[A-Z].[1-4]/: 'E'  # UN/EDIFACT
+      when /^EDI_DC/: 'I'  # SAP IDoc
+      when re : 'X'+$3     # XML, Doctype = Interchange, syntax standard key (E, I, ...) postfix
+      when /^\037\213/: 'GZ' # gzip
+      when /^\037\235/: 'Z'  # compress
+      when /^\037\036/: 'z'  # pack
+      when /^BZh[0-\377]/:  'BZ' # bzip2
+      else; "?? (stream starts with: #{buf[0..15]})"
+      end
+    end
+
+
+    def fmt_of_DE(id) # :nodoc:
+      de = @basedata.de(id)
+      de.nil? ? nil : de.format
+    end
+
+
+    def each_BCDS(id, &b) # :nodoc:
+      begin
+        @basedata.each_BCDS(id, &b )
+      rescue EDILookupError # NoMethodError
+        raise "Lookup failure for BCDS entry id '#{id}'"
+      end
+    end
+
+
+    # Add either Message objects or MsgGroup objects to an interchange;
+    # mixing both types raises a TypeError.
+
+    def add( obj, auto_validate=true )
+      err_msg = "Added object must also be a "
+      if obj.is_a? Message
+        @content = :messages unless @content
+        raise TypeError, err_msg+"'Message'" if @content != :messages
+      elsif obj.is_a? MsgGroup
+        @content = :groups unless @content
+        raise TypeError, err_msg+"'MsgGroup'" if @content != :groups
+      else
+	raise TypeError, "Only Message or MsgGroup allowed here"
+      end
+      obj.validate if auto_validate
+      super( obj )
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # A "MsgGroup" is a special "Collection with header and trailer"
+  # It collects "Message" objects and is only rarely used.
+
+
+  class MsgGroup < Collection_HT
+
+    def initialize(p, user_par = nil)
+      super(p, p.root, 'MsgGroup')
+      # ...
+    end
+
+
+    def fmt_of_DE(id) # :nodoc:
+      @parent.fmt_of_DE(id)
+    end
+
+
+    def each_BCDS(id, &b) # :nodoc:
+      @parent.each_BCDS(id, &b)
+    end
+
+    # Add only Message objects to a message group!
+
+    def add (msg)
+      raise "Only Messages allowed here" unless msg.is_a? Message
+      super
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # A "Message" is a special "Collection with header and trailer"
+  # It collects "Segment" objects.
+
+  class Message < Collection_HT
+
+#    @@msgCounter = 1
+
+    def initialize( p, user_par=nil )
+      super(p, p.root, 'Message')
+    end
+
+
+    def fmt_of_DE(id) # :nodoc:
+      de = @maindata.de(id)
+      return @parent.fmt_of_DE(id) if de.nil?
+      de.format
+    end
+
+
+    def each_BCDS(id, &b) # :nodoc:
+      begin
+        @maindata.each_BCDS(id, &b )
+      rescue EDILookupError
+        @parent.each_BCDS(id, &b)
+      end
+    end
+
+
+    # Add only Segment objects to a message!
+
+    def add (seg)
+      raise "Only Segments allowed here" unless seg.is_a? Segment
+      super
+    end
+
+  end
+
+
+  #########################################################################
+  #
+  # A "Segment" is a special Collection of type "S" (segment-like),
+  # similar to "CDE". Special Segment attributes are:
+  # +sg_name+:: The name of its segment group (optional)
+  # +level+::   The segment's hierarchy level, an integer
+
+
+  class Segment < Collection_S
+
+    attr_reader :sg_name, :level
+
+    # Returns true if segment is a TNode (i.e. a trigger segment).
+    # Note that only TNodes may have descendants.
+
+    def is_tnode?
+      @tnode
+    end
+
+    # Returns array of all segments that have the current segment
+    # as ancestor.
+
+    def descendants
+      self['descendant::*']
+    end
+
+    # Returns array of all segments with the current segment
+    # as ancestor, including the current segment.
+    # For trigger segments, this method returns all segments
+    # of one instance of the corresponding segment group.
+
+    def descendants_and_self
+      self['descendant-or-self::*']
+    end
+
+    # Returns all child elements of the current segment.
+
+    def children
+      self['child::*']
+    end
+
+    # Returns the current segment and all of its child elements.
+    # Useful e.g. to deal with one instance of a segment group
+    # without traversing included segment groups.
+
+    def children_and_self
+      self['child-or-self::*']
+    end
+
+
+    # Access by XPath expression (support is very limited currently)
+    # or by name of the dependent component. Pass them as strings.
+    #
+    # Used internally - try to avoid at user level!
+    # Currently supported XPath expressions:
+    #
+    # - descendant::*
+    # - descendant-or-self::*
+    # - child::*
+    # - child-or-self::*
+
+    def []( xpath_expr )
+      return super( xpath_expr ) if xpath_expr.is_a? Integer
+
+      msg_unsupported = "Unsupported XPath expression: #{xpath_expr}" 
+
+      case xpath_expr
+
+      when /\A(descendant|child)(-or-self)?::(.*)/
+        return xpath_matches($1, $2, $3, msg_unsupported)
+
+        # Currently no real path, no predicate available supported
+      when /\//, /\[/, /\]/
+        raise IndexError, msg_unsupported
+
+      when /child::(\w+)/ # ignore & accept default axis "child"
+        return super( $1 )
+
+      when /::/ # No other axes supported for now
+        raise IndexError, msg_unsupported
+
+      else # assume simple element name
+        return super( xpath_expr )
+      end
+    end
+
+
+    def inspect( indent='', symlist=[] )
+      symlist += [:sg_name, :level]
+      super
+    end
+
+
+    # Update attributes with information from a corresponding node instance
+
+    def update_with( ni ) # :nodoc:
+      return nil if ni.name != @name # Names must match; consider a raise!
+      @status, @maxrep, @sg_name, @rep, @index, @level, @tnode = ni.status,\
+      ni.maxrep, ni.sg_name, ni.inst_cnt, ni.index, ni.level, ni.is_tnode?
+      self
+    end
+
+    private 
+
+    def add (obj)
+      raise "Only DE or CDE allowed here" unless obj.is_a? DE or obj.is_a? CDE
+      super( obj )
+    end
+
+    def xpath_matches( axis, or_self, element, msg_unsupported )
+      raise IndexError, msg_unsupported if element != '*'
+      results = []
+      results << self if or_self
+      child_mode = (axis=='child')
+      return results unless self.is_tnode?
+      
+      # Now add all segments in self's "tail"
+      msg = parent
+      index = msg.index(self)
+      raise IndexError, "#{name} not found in own message?!" unless index
+      loop do
+        index += 1
+        seg = msg[index]
+        next  if child_mode and seg.level > level+1 # other descendants
+        break if seg.level <= level
+        results << seg
+      end
+      results
+    end
+  end
+
+
+  #########################################################################
+  #
+  # Composite data element, primarily used in the EDIFACT context.
+  # A "CDE" is a special Collection of type "S" (segment-like),
+  # similar to "Segment".
+  #
+  class CDE < Collection_S
+
+    private
+
+    # Add a DE 
+
+    def add( obj )
+      raise "Only DE allowed here" unless obj.is_a? DE
+      super
+    end
+
+  end
+
+  #########################################################################
+  #
+  # A basic data element. Its content is accessible through methods +value+
+  # and <tt>value=</tt>. Allowed contents is described by attribute +format+.
+  #
+  # Note that values are usually Strings, or Numerics when the format indicates
+  # a numeric value. Other objects are conceivable, as long as they
+  # maintain a reasonable +to_s+ for their representation.
+  #
+  # The external representation of the (abstract) value may further depend on 
+  # rules of the unterlying EDI standard. E.g., UN/EDIFACT comes with a set
+  # of reserved characters and an escaping mechanism.
+
+  class DE < EDI::Object
+    attr_accessor :value
+    attr_reader :format, :status
+
+    def initialize( p, name, status, fmt )
+      @parent, @root, @name, @format, @status = p, p.root, name, fmt, status
+      raise "#{location}: 'nil' is not an allowed format." if fmt.nil?
+      raise "#{location}: 'nil' is not an allowed status." if status.nil?
+      @value = nil
+    end
+
+
+    def to_s
+      str = self.value
+      return str if str.is_a? String
+      str = str.to_s; len = str.length
+      return str unless format =~ /n(\d+)/ && len != (fixlen=$1.to_i)
+      raise "#{location}: Too long (#{l}) for fmt #{format}" if len > fixlen
+      '0' * (fixlen - len) + str
+    end
+
+
+    def inspect( indent='' )
+      indent + self.name+': ' + [:value, :format, :status].map do |sym|
+        "#{sym} = #{(s=send(sym)).nil? ? 'nil' : s.to_s}"
+      end.join(', ') + "\n"
+    end
+
+  
+    # Performs various validation checks and returns the number of
+    # issues found (plus the value of +err_count+):
+    #
+    # - empty while mandatory?
+    # - character set limitations violated?
+    # - various format restrictions violated?
+
+    def validate( err_count=0 )
+      location = "DE #{parent.name}/#{@name}"
+      if empty?
+        if required?
+          warn "#{location}: Empty though mandatory!"
+          err_count += 1
+        end
+      else
+        #
+        # Charset check
+        #
+        if (pos = (value =~ root.illegal_charset_pattern))# != nil
+          warn "#{location}: Illegal character: #{value[pos].chr}"
+          err_count += 1
+        end
+        #
+        # Format check, raise error if not consistent!
+        #
+        if @format =~ /^(a|n|an)(..)?(\d+)$/
+          _a_n_an, _upto, _size = $1, $2, $3
+          case _a_n_an
+
+          when 'n'
+            strval = value.to_s
+            re = Regexp.new('^(-)?(\d+)([.,]\d+)?$')
+            md = re.match strval
+            if md.nil?
+              raise "#{location}: '#{strval}' - not matching format #@format"
+#              warn "#{strval} - not matching format #@format"
+#              err_count += 1
+            end
+
+            len = strval.length
+            # Sign char does not go into length count:
+            len -= 1 if md[1]=='-'
+            # Decimal char does not go into length count:
+            len -= 1 if not md[3].nil?
+            # len -= 1 if (md[1]=='-' and md[3]) || (md[1] != '' and not md[3])
+            break if not required? and len == 0
+            if len > _size.to_i
+#            if _upto.nil? and len != _size.to_i or len > _size.to_i
+              warn "Context in #{location}: #{_a_n_an}, #{_upto}, #{_size}; #{md[1]}, #{md[2]}, #{md[3]}"
+              warn "Length # mismatch in #{location}: #{len} vs. #{_size}"
+              err_count += 1
+              #            warn "  (strval was: '#{strval}')"
+            end
+            if md[1] =~/^0+/
+              warn "#{strval} contains leading zeroes"
+              err_count += 1
+            end
+            if md[3] and md[3]=~ /.0+$/
+              warn "#{strval} contains trailing decimal sign/zeroes"
+              err_count += 1
+            end
+
+          when 'a', 'an'
+#            len = value.is_a?(Numeric) ? value.to_s.length : value.length
+            len = value.to_s.length
+            if _upto.nil? and len != $3.to_i or len > $3.to_i
+              warn "Length mismatch in #{location}: #{len} vs. #{_size}"
+              err_count += 1
+            end
+          else
+            raise "#{location}: Illegal format prefix #{_a_n_an}"
+            # err_count += 1
+          end
+
+        else
+          warn "#{location}: Illegal format: #{@format}!"
+          err_count += 1
+        end
+      end
+      err_count
+    end
+
+
+    # Returns +true+ if value is not +nil+. 
+    # Note that assigning an empty string to a DE makes it "not empty".
+    def empty?
+      @value == nil
+    end
+
+
+    # Returns +true+ if this is a required / mandatory segment.
+    def required?
+      @status == 'M' or @status == 'R'
+    end
+
+  end
+
+end # module EDI