edifact_converter 2.0.13

data/lib/edifact_converter/xml/xftx_parser.rb

@@ -0,0 +1,153 @@
+require 'edifact_converter/xml'
+
+module EdifactConverter::XML
+
+  class XftxParser
+
+    attr_accessor :paragraphs, :code, :xftx
+
+    def self.parse(xftx_node)
+      self.new(xftx_node).transform_xftx
+    end
+
+    def initialize(xftx_node)
+      self.paragraphs = [Paragraph.new]
+      self.xftx = xftx_node
+    end
+
+    def transform_xftx
+      self.code = xftx.children[0].children[0].text
+      transform_content xftx.children[3].children[0]
+      pack_paragraphs
+      to_ftx
+    end
+
+    def transform_content(subelm)
+      subelm.children.each do |node|
+        case node.node_type
+        when Nokogiri::XML::Node::TEXT_NODE
+          paragraphs.last.add_text node.text
+        when Nokogiri::XML::Node::ELEMENT_NODE
+          transform_element node
+        end
+      end
+    end
+
+    def transform_element(element)
+      case element.name
+      when 'Break'
+        paragraphs.last.add_break
+        return
+      when 'Space'
+        paragraphs.last.add_text ' '
+        return
+      when 'Center'
+        set_alignment(Paragraph::CENTER) { transform_content element }
+      when 'Right'
+        set_alignment(Paragraph::RIGHT) { transform_content element }
+      when 'Bold'
+        set_style(Paragraph::BOLD) { transform_content element }
+      when 'Italic'
+        set_style(Paragraph::ITALIC) { transform_content element }
+      when 'Underline'
+        set_style(Paragraph::UNDERLINE) { transform_content element }
+      when 'FixedFont'
+        set_font(Paragraph::MONOSPACE) { transform_content element }
+      else
+        throw RuntimeError "Unknown xftx #{element.name}"
+      end
+    end
+
+    def set_alignment(alignment)
+      push_paragraph do |previous, paragraph|
+        paragraph.format = alignment
+        paragraph.add_break unless previous.end_breaks?
+        yield
+        paragraphs.last.add_break
+      end
+    end
+
+    def set_font(font)
+      push_paragraph do |previous, paragraph|
+        paragraph.font = font
+        yield
+      end
+    end
+
+    def set_style(style)
+      push_paragraph do |previous, paragraph|
+        paragraph.format = style
+        yield
+      end
+    end
+
+    def push_paragraph
+      previous = paragraphs.last
+      paragraphs << current = previous.empty_copy
+      yield previous, current
+      paragraphs << previous.empty_copy
+    end
+
+    def pack_paragraphs
+      paragraphs.reject! { |paragraph| paragraph.empty? }
+      paragraphs.inject(nil) do |previous, current|
+        if previous and not(previous.texts?)
+          previous.content.delete_if do |elm|
+            current.add_start_break elm
+            true
+          end
+        end
+      end
+      paragraphs.reject! { |paragraph| paragraph.empty? }
+    end
+
+    def to_s
+      text = "#{code}:\n"
+      paragraphs.each do |paragraph|
+        text << paragraph.to_s
+      end
+      text
+    end
+
+    FTXElm = Struct.new(:code, :format, :texts) do
+      def insert_before(node)
+        ftx =  Nokogiri::XML::Node.new "FTX", node.document
+        Nokogiri::XML::Builder.with(ftx) do |xml|
+          xml.Elm { xml.SubElm code }
+          xml.Elm { xml.SubElm format }
+          xml.Elm
+          xml.Elm {
+            texts.each do |text|
+              xml.SubElm text
+            end
+          }
+        end
+        node.add_previous_sibling ftx
+      end
+    end
+
+    def to_ftx()
+      ftxs = []
+      paragraphs.delete_if do |paragraph|
+        next_paragraph = paragraphs[1]
+        texts = paragraph.to_subelms(paragraphs[1])
+        texts.each_slice(5) do |content|
+          if content.size < 5 and next_paragraph
+            while content.size < 5 and next_paragraph.start_breaks?
+              content << "."
+              next_paragraph.remove_start_break
+            end
+          end
+          ftxs << FTXElm.new(code, paragraph.ftx_format, content)
+        end
+        true
+      end
+      ftxs.each do |ftx|
+        ftx.insert_before(xftx)
+      end
+      xftx.remove
+    end
+
+  end
+
+end

data/lib/edifact_converter/xml.rb

@@ -0,0 +1,137 @@
+require 'edifact_converter'
+require 'edifact_converter/xml/paragraph'
+require 'edifact_converter/xml/xftx_parser.rb'
+
+module EdifactConverter
+
+  module XML
+
+    def self.xml_to_xml11(xml, properties)
+      xml = parse_xml(xml, properties)
+      if xml.nil? or xml.root.nil?
+        properties[:errors] << EdifactConverter::Message.new(text: "Mangel fuldt XML dokument, konvertering stoppet", source: :xml)
+        return
+      end
+      properties[:namespace] = xml.root.namespace && xml.root.namespace.href
+      rules = EdifactConverter::Configuration.xml_rules(properties[:namespace])
+      if rules.nil?
+        properties[:errors] << EdifactConverter::Message.new(text: "Ingen regler for konverteringen af #{properties[:namespace]}", source: :xml)
+        return nil
+      end
+      schema_validate(xml, rules.schema, properties)
+      xml11 = rules.from_xml.transform(xml)
+      xml11.encoding = "ISO-8859-1"
+      extract_errors(xml11, properties)
+      process_xftxs xml11, properties
+    end
+
+    def self.xml11_to_xml(xml11, properties)
+      xml11 = parse_xml(xml11, properties)
+      return unless xml11 and xml11.root
+      properties[:type] = nil
+      properties[:version] = nil
+      unless properties[:type]
+        type = xml11.xpath("/Edifact/Brev[1]/UNH[1]/Elm[2]/SubElm[1]")
+        properties[:type] = type && type.text
+      end
+      unless properties[:version]
+        version = xml11.xpath("/Edifact/Brev[1]/UNH[1]/Elm[2]/SubElm[5]")
+        properties[:version] = version && version.text
+      end
+      rules = EdifactConverter::Configuration.xml_rules(properties[:type], properties[:version])
+      if rules.nil?
+        properties[:errors] << EdifactConverter::Message.new(text: "Ingen regler for konverteringen af #{properties[:type]} - #{properties[:version]}", source: :xml)
+        return nil
+      end
+      xml = rules.to_xml.transform(xml11)
+      xml.encoding = "ISO-8859-1"
+      extract_errors(xml, properties, :edifact)
+      schema_validate(xml, rules.schema, properties)
+      xml
+    end
+
+    def self.extract_errors(xml, properties, source = :xml)
+      xml.xpath("//*[local-name() = 'FEJL']").each do |error|
+        position = EDI2XML11::Position.new error['linie'], error['position']
+        properties[:errors] << Message.new(position: position, text: error.content.strip, source: source)
+        error.remove
+      end
+    end
+
+    def self.schema_validate(xml, schema, properties)
+      schema.validate(xml).each do |error|
+        properties[:errors] << EdifactConverter::Message.from_syntax_error(error)
+      end
+    end
+
+    def self.process_xftxs(xml, properties)
+      xml.xpath("//XFTX").each do |xftx|
+        xftx.name = "GFTX"
+        xftx.children.each_slice(4) do |elms|
+          new_xftx = Nokogiri::XML::Node.new "XFTX", xml
+          elms.each { |elm| elm.parent = new_xftx }
+          xftx << new_xftx
+        end
+      end
+      xml.xpath("//XFTX").each do |xftx|
+        XftxParser.parse xftx
+      end
+      process_gftxs xml, properties
+      xml.xpath("//S12").each do |s12|
+        split_group s12, properties
+      end
+      xml
+    end
+
+    def self.parse_xml(xmlstr, properties)
+      if xmlstr && xmlstr.is_a?(String)
+        xmlstr = Nokogiri::XML(xmlstr) { |config| config.nonet }
+        xmlstr.errors.each do |error|
+          properties[:errors] << EdifactConverter::Message.from_syntax_error(error)
+        end
+        xmlstr
+      else
+        xmlstr
+      end
+    end
+
+    def self.process_gftxs(xml, properties)
+      xml.xpath("//GFTX").each do |gftx|
+        max = gftx['maxOccurs']
+        max = (max && max.to_i) || Float::INFINITY
+        max = Float::INFINITY if gftx.parent['maxOccurs']
+        if gftx.children.size > max
+          properties[:errors] << EdifactConverter::Message.new(
+            text: "Too many FTXs in segmentgroup #{gftx.parent.name}. Max allowed is #{max}, needs #{gftx.children.size} FTX."
+          )
+        end
+        gftx.children.each do |ftx|
+          gftx.before ftx
+        end
+        gftx.remove
+      end
+    end
+
+    def self.split_group(group, properties)
+      max = group['maxOccurs']
+      max = (max && max.to_i) || Float::INFINITY
+      ftxs = group.xpath("FTX")
+      ftxs.each { |ftx| ftx.unlink }
+      ftxgroups = ftxs.each_slice(10).to_a
+      if ftxgroups.size > max
+        properties[:errors] << EdifactConverter::Message.new(
+          text: "Too many FTXs in segmentgroup #{group.name}. Max allowed is #{max * 10}, needs #{ftxs.size} FTXs."
+        )
+      end
+      previous = group.previous_element
+      group.unlink
+      ftxgroups.reverse.each do |ftxs|
+        new_group = group.dup
+        ftxs.each { |ftx| new_group << ftx }
+        previous.add_next_sibling new_group
+      end
+    end
+
+  end
+
+end

data/lib/edifact_converter/xml112edi/checksum_handler.rb

@@ -0,0 +1,42 @@
+require 'edifact_converter/xml112edi'
+
+module EdifactConverter::XML112EDI
+
+	class ChecksumHandler < EdifactConverter::EmptyHandler
+
+		attr_accessor :segments, :letters, :inside_UNT, :inside_UNZ
+
+		def startDocument
+			self.segments = self.letters = 0
+			super
+		end
+
+		def startSegment(name, position = nil)
+			case name
+			when 'UNH'
+				self.letters += 1
+				self.segments = 0
+			when 'UNT'
+				self.inside_UNT = true
+			when 'UNZ'
+				self.inside_UNZ = true
+			end
+			self.segments += 1 unless name == 'OBJ'
+			super
+		end
+
+		def value(text)
+			if inside_UNT
+				super(segments) 
+			elsif inside_UNZ
+				super(letters) 
+			else 
+				super
+			end
+			self.inside_UNT = false
+			self.inside_UNZ = false
+		end
+
+	end
+
+end

data/lib/edifact_converter/xml112edi/edi_handler.rb

@@ -0,0 +1,86 @@
+require 'edifact_converter/xml112edi'
+require 'base64'
+require 'securerandom'
+
+module EdifactConverter::XML112EDI
+
+  class EdiHandler < EdifactConverter::EmptyHandler
+
+    attr_accessor :linebreak,
+      :edifact,
+      :first_value,
+      :processing_binary,
+      :binary
+
+    alias :first_value? :first_value
+    alias :processing_binary? :processing_binary
+
+    def edifact
+      @edifact ||= StringIO.new('ISO-8859-1')
+    end
+
+    def initialize(nexthandler = nil)
+      self.linebreak = "\n" if EdifactConverter::Configuration.format_edi
+      super
+    end
+
+    def startDocument
+      self.edifact = nil
+      binary.clear
+      edifact.write("UNA:+.? '#{linebreak}")
+    end
+
+    def startSegment(name, position = nil)
+      if name == "OBJ"
+        self.processing_binary = true
+      else
+        edifact.write(name)
+      end
+    end
+
+    def startElement
+      unless processing_binary?
+        edifact.write('+')
+        self.first_value = true
+      end
+    end
+
+    def value(text)
+      if processing_binary?
+        id = binary_id
+        binary[id] = text
+        text = id
+      elsif first_value
+        self.first_value = false
+      else
+        edifact.write(':') unless first_value?
+      end
+      edifact.write text.to_s.gsub(/([\?:\'\+])/,'?\1')
+    end
+
+    def endSegment
+      if processing_binary?
+        self.processing_binary = false
+      else
+        edifact.write("'#{linebreak}")
+      end
+    end
+
+    def binary?
+      binary.any?
+    end
+
+    def binary
+      @binary ||= {}
+    end
+
+    private
+
+    def binary_id
+      "@@BINARY#{SecureRandom.uuid}@@"
+    end
+
+
+  end
+
+end

data/lib/edifact_converter/xml112edi/segment_checks.rb

@@ -0,0 +1,42 @@
+require 'edifact_converter/xml112edi'
+
+module EdifactConverter::XML112EDI
+
+  class SegmentChecks
+    def is_segment(nodeset)
+      (nodeset.first.name =~ /\p{Upper}{3}/) == 0
+    end
+
+    def is_segmentgroup(nodeset)
+      (nodeset.first.name =~ /S[0-9]{2}/) == 0
+    end
+
+    def valid_elms(nodeset)
+      nodeset.each do |elm|
+        elm.children = pop_last_empty(elm.children)
+      end
+      pop_last_empty nodeset
+    end
+
+    def escape_subelms(nodeset)
+      nodeset.each do |elm|
+        elm.content = escape_text elm.text unless elm['base64']
+      end
+    end
+
+    private
+
+    def pop_last_empty(nodeset)
+      while nodeset.size > 0 && nodeset.last.children.size == 0
+        nodeset.pop
+      end
+      nodeset
+    end
+
+    def escape_text(text)
+      text.gsub(/[\+\'\:\?]/) {|s| "?#{s}"} 
+    end
+
+  end
+  
+end

data/lib/edifact_converter/xml112edi/xml_reader.rb

@@ -0,0 +1,88 @@
+require 'nokogiri'
+require 'edifact_converter/xml112edi'
+
+module EdifactConverter::XML112EDI
+
+  class XmlReader
+
+    attr_accessor :handler, :state, :edifact
+
+    def initialize()
+      self.edifact = EdiHandler.new
+      self.handler = ChecksumHandler.new edifact
+    end
+
+    def parse(xmlstr, properties)
+      xml11 = if xmlstr.is_a? String
+        Nokogiri::XML(xmlstr) { |config| config.nonet }
+      else
+        xmlstr
+      end
+      xml11.errors.each do |error|
+        properties[:errors] << EdifactConverter::Message.from_syntax_error(error)
+      end
+      parse_xml xml11
+    end
+
+    private
+
+    def parse_xml(xmlsrc)
+      xml = xmlsrc.dup
+      return unless xml.root
+      remove_grouping xml
+      handler.startDocument
+      xml.root.elements.each do |segment|
+        handler.startSegment(segment.name)
+        segment.elements.each do |element|
+          handler.startElement()
+          element.elements.each do |subelm|
+            handler.value subelm.text
+          end
+          handler.endElement()
+        end
+        handler.endSegment()
+      end
+      handler.endDocument
+      enc_converter = Encoding::Converter.new("utf-8", "iso-8859-1")
+      edi_text = enc_converter.convert(edifact.edifact.string)
+      include_binaries edi_text
+    end
+
+    def remove_grouping(xml)
+      hidden, groups = [], []
+      xml.root.traverse do |element|
+        case element.name
+        when /^[S][0-9]{2}$/
+          if element['hidden']
+            hidden << element
+          else
+            groups << element
+          end
+        when "Brev"
+          hidden << element
+        when "BrevIndhold"
+          hidden << element
+        end
+      end
+      hidden.each { |elm| elm.replace elm.elements }
+      groups.each do |elm|
+        first = elm.first_element_child
+        first.unlink
+        elm.next = elm.elements
+        first.parent = elm
+      end
+    end
+
+    def include_binaries(source)
+      return source if edifact.binary.empty?
+      source.force_encoding 'ASCII-8BIT'
+      edifact.binary.each do |id, base64|
+        start = source.index(id)
+        source[start, id.size] = Base64.decode64(base64)
+      end
+      source      
+    end
+
+  end
+
+end

data/lib/edifact_converter/xml112edi.rb

@@ -0,0 +1,10 @@
+require "edifact_converter"
+
+require "edifact_converter/xml112edi/checksum_handler"
+require "edifact_converter/xml112edi/edi_handler"
+require "edifact_converter/xml112edi/segment_checks"
+require "edifact_converter/xml112edi/xml_reader"
+
+module EdifactConverter::XML112EDI
+
+end

data/lib/edifact_converter.rb

@@ -0,0 +1,62 @@
+require "edifact_converter/version"
+
+require 'edifact_converter/binary'
+require "edifact_converter/abstract_syntax_tree"
+require "edifact_converter/comparator"
+require "edifact_converter/empty_handler"
+require "edifact_converter/edifact_error"
+require 'edifact_converter/edi2xml11'
+require "edifact_converter/xml112edi"
+require "edifact_converter/configuration"
+require "edifact_converter/result"
+require "edifact_converter/message"
+require "edifact_converter/command_line_parser"
+require "edifact_converter/converter_methods"
+require "edifact_converter/xml"
+require 'edifact_converter/converter'
+
+module EdifactConverter
+
+  def self.convert_edifact(text)
+    result = Result.new edifact: text, source_format: :edifact
+    result.convert
+    result
+  end
+
+  def self.convert_xml11(text)
+    result = Result.new xml11: text, source_format: :xml11
+    result.convert
+    result
+  end
+
+  def self.convert_xml(text)
+    result = Result.new xml: text, source_format: :xml
+    result.convert
+    result
+  end  
+
+  def self.convert(text)
+    if xml?(text)
+      convert_xml(text)
+    else
+      convert_edifact(text)
+    end
+  end
+
+  def self.read_file(filename)
+    File.open(filename, 'r:iso-8859-1:iso-8859-1') { |f| f.read } #  encoding: 'ISO-8859-1'
+  end
+
+  def self.xml?(text)
+    Nokogiri::XML(text).errors.empty?
+  end
+
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+
+  def self.data
+    File.join root, 'data'
+  end
+
+end

data/test/abstract_syntax_tree_test.rb

@@ -0,0 +1,68 @@
+
+require 'test/unit'
+require 'nokogiri'
+require 'edifact_converter/abstract_syntax_tree'
+
+module EdifactConverter
+
+  class AbstractSyntaxTreeTest < Test::Unit::TestCase
+
+    def xml
+      Nokogiri::XML <<-EOS
+      <edifact>
+      <UNA><Elm><SubElm/></Elm><Elm/><Elm/></UNA>
+      <Brev>
+      <UNB><Elm><SubElm/></Elm><Elm><SubElm> </SubElm></Elm><Elm/></UNB>
+      <UNC/>
+      <S01>
+      <UND/>
+      </S01>
+      <UNT><Elm><SubElm>5</SubElm></Elm></UNT>
+      </Brev>
+      </edifact>
+      EOS
+    end
+
+    def test_pack
+      ast = AbstractSyntaxTree.new xml
+      ast.pack
+      assert ast.document.at("UNA").elements.empty?
+      assert ast.document.at("UNB").elements.size == 2
+      assert ast.document.at("UNB/Elm[1]").elements.empty?
+      assert ast.document.at("UNB/Elm[2]").elements.size == 1      
+    end
+
+    def test_compare
+      ast = AbstractSyntaxTree.new xml
+      errors = ast.compare(xml)
+      assert errors.empty?
+    end
+
+    def test_verify_segments_checksum
+      ast = AbstractSyntaxTree.new xml
+      errors = ast.verify_segments_checksum
+      assert errors.empty?, "Got errors #{errors.inspect}"
+      unt = ast.document.at("UNT")
+      unt.at("SubElm").content = 4
+      errors = ast.verify_segments_checksum
+      assert errors.size == 1
+      error = Difference.new(
+        source: unt,
+        facit: 5,
+        kind: :unt
+      )
+      assert error.eql? errors.first
+      unt.unlink
+      error = Difference.new(
+        source: ast.document.at("Brev/UNT"),
+        facit: 4,
+        kind: :unt
+      )
+      errors = ast.verify_segments_checksum
+      assert errors.size == 1
+      assert error.eql?(errors.first), "#{errors.first.inspect} != #{error.inspect}"
+    end
+
+  end
+
+end