edifact_converter 2.0.13

data/lib/edifact_converter/edi2xml11/xml_handler.rb

@@ -0,0 +1,108 @@
+require 'edifact_converter/edi2xml11'
+require 'nokogiri'
+
+module EdifactConverter::EDI2XML11
+
+  class XmlHandler < EdifactConverter::EmptyHandler
+
+    attr_accessor :current, :document
+
+    class XmlElement
+
+      ATTRIBUTES = [:name, :children, :text, :position, :parent, :position, :hidden]
+
+      ATTRIBUTES.each do |attribute|
+        attr_accessor attribute
+      end
+
+      def initialize(options)
+        self.children = []
+        options.each do |attribute, value|
+          if ATTRIBUTES.include? attribute.to_sym
+            send "#{attribute}=", value
+          end
+        end
+        parent.children << self if parent
+      end
+
+      def render(xml)
+        args = []
+        args << text if text
+        attributes = {}
+        unless EdifactConverter::Configuration.hide_position?
+          attributes[:linie] = position.line
+          attributes[:position] = position.column
+        end
+        attributes[:hidden] = true if hidden
+        args << attributes
+        xml.send(name, *args) do |newxml|
+          children.each do |child|
+            child.render xml
+          end
+        end
+      end
+    end
+
+    def startDocument
+      self.document = self.current = XmlElement.new name: 'Edifact', position: Position.new(0, 0)
+      super
+    end
+
+    def endDocument
+      unless current == document
+        raise EdifactConverter::EdifactError.new "Internal Error, please report to jacob@medware.dk", Position.new(0,0)
+      end
+      super
+    end
+
+    def startSegmentGroup(name, hidden = false)
+      self.current = XmlElement.new name: name.encode(Encoding::UTF_8), position: locator.position, parent: current, hidden: hidden
+      super
+    end
+
+    def endSegmentGroup(name)
+      self.current = current.parent
+      super
+    end
+
+    def startSegment(name)
+      self.current = XmlElement.new name: name.encode(Encoding::UTF_8), position: locator.position, parent: current
+      super
+    end
+
+    def endSegment(name)
+      self.current = self.current.parent
+      super
+    end
+
+    def startElement
+      self.current = XmlElement.new name: 'Elm', position: locator.position, parent: current
+      super
+    end
+
+    def endElement
+      self.current = current.parent
+      super
+    end
+
+    def value(value)
+      XmlElement.new name: 'SubElm', position: locator.position, parent: current, text: value.encode(Encoding::UTF_8)
+      #val.text = value.encode(Encoding::UTF_8)
+      super
+    end
+
+    def xml
+      builder = Nokogiri::XML::Builder.new(:encoding => 'ISO-8859-1') do |xml|
+        xml.comment "Created from Edifact at #{Time.now.utc}"
+        document.render xml
+      end
+      xml = builder.doc
+      xml.xpath("//Elm").each do |elm|
+        elm.children.last.remove if elm.children.last.content == ""
+      end
+      xml
+    end
+
+  end
+
+end

data/lib/edifact_converter/edi2xml11.rb

@@ -0,0 +1,19 @@
+require "edifact_converter/edi2xml11/xml_handler"
+require "edifact_converter/edi2xml11/edi_reader"
+require "edifact_converter/edi2xml11/brev_handler"
+require "edifact_converter/edi2xml11/segment_group_handler"
+require "edifact_converter/edi2xml11/position"
+require "edifact_converter/edi2xml11/position_io"
+require "edifact_converter/edi2xml11/settings_handler"
+require "edifact_converter/edi2xml11/hidden_group_handler"
+require "edifact_converter/edi2xml11/parent_group_handler"
+require "edifact_converter/edi2xml11/pipeline"
+require "edifact_converter/edi2xml11/locator"
+require "edifact_converter/edi2xml11/properties_handler.rb"
+
+require "edifact_converter"
+
+
+module EdifactConverter::EDI2XML11
+
+end

data/lib/edifact_converter/edifact.rb

@@ -0,0 +1,110 @@
+
+require 'edifact_converter/edi2xml11/xml_handler'
+require 'edifact_converter/edi2xml11/edi_reader'
+
+# Refactoring work in progress
+
+module EdifactConverter
+
+  class Edifact
+
+    ATTRIBUTES = [:ast, :text]
+
+    ATTRIBUTES.each do |attribute|
+      attr_accessor attribute
+    end
+
+    def initialize(options = {})
+      options.each do |name, value|
+        if ATTRIBUTES.include? name
+          send "#{name}=", value
+        else
+          raise ArgumentError, 'Argument(#{name}) is not supported '
+        end
+      end
+    end
+
+    def parse(options = {}, &block)
+      return ast unless text
+      handler = EdifactConverter::EDI2XML11::XmlHandler.new
+      reader = EdifactConverter::EDI2XML11::EdiReader.new handler
+      reader.parse_string text, properties
+      xml = handler.xml
+      insert_letters xml
+      self.ast = AbstractSyntaxTree.new xml
+    end
+
+    def serialize(options = {}, &block)
+
+    end
+
+    private
+
+    def properties
+      @properties ||= Hash.new do |hash,key|
+        case key
+        when :errors
+          hash[key] = []
+        when :warnings
+          hash[key] = []
+        else
+          nil
+        end
+      end
+    end
+
+    def insert_letters(xml)
+      parent = dummy_element
+      xml.root.elements.each do |elm|
+        parent.add_child elm
+        case elm.name
+        when "UNB"
+          parent = xml.create_element "Brev"
+          elm.add_next_sibling parent
+        when "UNT"
+          parent = dummy_element
+        end
+      end
+      xml.xpath("//Brev").each { |brev| insert_letter_content brev }
+    end
+
+    def insert_letter_content(letter)
+      parent = dummy_element
+      letter.elements.each do |elm|
+        case elm.name
+        when "UNH"
+          parent = elm.document.create_element "BrevIndhold"
+          elm.add_next_sibling parent
+          next
+        when "UNT"
+          parent = dummy_element
+        end
+        parent.add_child elm
+      end
+      letter.xpath("//BrevIndhold").each { |content| group_segments content }
+    end
+
+    def group_segments(content)
+      parent = dummy_element
+      content.elements.each do |elm|
+        case elm.name
+        when /S[0-9]{2}/
+          parent = elm
+          next
+        end
+        parent.add_child elm
+      end
+    end
+
+    DummyElement = Struct.new :dummy do 
+      def add_child(elm)
+      end
+    end
+
+    def dummy_element
+      @dummy_element ||= DummyElement.new
+    end
+
+  end
+
+end

data/lib/edifact_converter/edifact_error.rb

@@ -0,0 +1,19 @@
+require "edifact_converter"
+
+module EdifactConverter
+
+	class EdifactError < StandardError
+		attr_accessor :message, :position, :edifact_base64
+
+		def initialize(message, position)
+			self.message = message
+			self.position = position
+		end
+
+    def to_message
+      Message.new(position: position, text: message)
+    end
+
+	end
+
+end

data/lib/edifact_converter/empty_handler.rb

@@ -0,0 +1,28 @@
+
+module EdifactConverter
+
+	class EmptyHandler
+		attr_accessor :next_handler, :locator
+
+		def initialize(nexthandler = nil)
+			self.next_handler = nexthandler
+		end
+
+		def method_missing(sym, *args, &block)
+			if self.next_handler
+				self.next_handler.send(sym, *args, &block)
+			end
+		end
+
+		def locator=(locator)
+			@locator = locator
+			next_handler.locator = locator if next_handler
+		end
+
+		def locator
+			@locator ||= (next_handler.locator if next_handler )
+		end
+
+	end
+
+end

data/lib/edifact_converter/ftx_text.rb

@@ -0,0 +1,153 @@
+module EdifactConverter
+
+  class FTXText
+
+    Line = Struct.new(:align) do
+
+      def texts
+        @texts ||= []
+      end
+
+      def texts=(texts)
+        @texts = texts
+      end
+
+      def ==(line)
+        align == line.align and texts == line.texts
+      end
+
+      def to_s
+        txt = "#{align}:\t"
+        texts.each do |text|
+          txt << text.to_s
+        end
+        txt
+      end
+
+    end
+
+    Text = Struct.new(:format, :font, :text) do
+
+      def merge(text)
+        self.text << text.text
+        self
+      end
+
+      def ==(text)
+        format == text.format and font == text.font and self.text == text.text
+      end
+
+      def to_s
+        "(#{font} #{format})#{text}"
+      end
+
+    end
+
+    attr_accessor :current_line
+
+    def lines
+      @lines ||= []
+    end
+
+    def self.parse(ftxs)
+      self.new ftxs
+    end
+
+    def initialize(ftxs)
+      ftxs.each do |ftx|
+        font, format, align = extract_style ftx
+        ftx.xpath('Elm[position() > 2]/SubElm/text()').each do |text|
+          text = text.to_s
+          continue_line = if text[-1] == '\\'
+            text.chop!
+            true
+          end
+          current_or_new_line(align).texts << Text.new(format, font, text)
+          self.current_line = nil unless continue_line
+        end
+      end
+      optimize_formatting
+      pack_lines
+      #lines.each { |line| puts line }
+    end
+
+    def ==(ftx_text)
+      lines == ftx_text.lines
+    end
+
+    private
+
+    def new_line(align)
+      self.current_line = Line.new(align)
+    end
+
+    def current_or_new_line(align)
+      if current_line and current_line.align == align
+        current_line
+      else
+        new_line align
+      end
+    end
+
+    def current_line=(line)
+      lines << line if line
+      @current_line = line
+    end
+
+    def extract_style(ftx)
+      compressed = ftx.xpath('Elm[2]/SubElm/text()').to_s
+      compressed.chars.map.with_index do |char, index|
+        case char
+        when 'P'
+          :proportional
+        when 'F'
+          if index == 0
+            :fixed
+          else
+            :bold
+          end
+        when 'H'
+          :right
+        when 'M'
+          :center
+        when 'U'
+          :underline
+        when '0'
+          if index == 2
+            :left
+          else
+            :normal
+          end
+        end
+      end
+    end
+
+    def optimize_formatting
+      start_spaces_regex = Regexp.new '^( +)'
+      end_spaces_regex = Regexp.new '( +)$'
+      lines.each do |line|
+        line.texts.each_with_index do |text, index|
+          next if text.format == :normal
+          end_spaces_regex.match(text.text) do |m|
+            line.texts.insert index+1, Text.new(:normal, text.font, m[0])
+          end
+          start_spaces_regex.match(text.text) do |m|
+            line.texts.insert index, Text.new(:normal, text.font, m[0])
+          end
+          text.text.strip!
+        end
+      end
+    end
+
+    def pack_lines
+      lines.each do |line|
+        chunked = line.texts.chunk { |text| "#{text.format}:#{text.font}" }.map do |set|
+          set[1] = set.last.reduce :merge
+        end
+        line.texts = chunked
+      end
+    end
+
+  end
+
+end

data/lib/edifact_converter/message.rb

@@ -0,0 +1,30 @@
+require 'edifact_converter'
+
+module EdifactConverter
+
+  class Message
+
+    ATTRIBUTES = [:position, :text, :source]
+
+    ATTRIBUTES.each do |attribute|
+      attr_accessor attribute
+    end
+
+    def initialize(options)
+      self.position = options[:position] 
+      self.text = options.fetch(:text, "Ukendt fejl")
+      self.source = options.fetch(:source, :edifact)
+    end
+
+    def self.from_syntax_error(error)
+      position = EdifactConverter::EDI2XML11::Position.new(error.line, error.column)
+      self.new(position: position, text: error.to_s, source: :xml)
+    end
+
+    def to_s
+      "#{source.to_s.capitalize}: #{text} #{position}"
+    end
+
+  end
+
+end

data/lib/edifact_converter/result.rb

@@ -0,0 +1,39 @@
+require 'edifact_converter'
+require 'edifact_converter/converter_methods'
+
+module EdifactConverter
+
+  class Result
+
+    include EdifactConverter::ConverterMethods
+
+    ATTRIBUTES = [:xml, :ast, :edifact, :properties, :source_format]
+
+    ATTRIBUTES.each do |attribute|
+      attr_accessor attribute
+    end
+
+    def initialize(options)
+      options.each do |key, value|
+        if ATTRIBUTES.member? key.to_sym
+          self.send "#{key}=", value
+        end
+      end
+    end
+
+    def properties
+      @properties ||= Hash.new do |hash,key|
+        case key
+        when :errors
+          hash[key] = []
+        when :warnings
+          hash[key] = []
+        else
+          nil
+        end
+      end
+    end
+
+  end
+
+end

data/lib/edifact_converter/version.rb

@@ -0,0 +1,3 @@
+module EdifactConverter
+  VERSION = "2.0.13"
+end

data/lib/edifact_converter/xml/paragraph.rb

@@ -0,0 +1,183 @@
+require 'edifact_converter/xml'
+
+module EdifactConverter::XML
+
+  class Paragraph
+    MONOSPACE = 'F'
+    PROPOTIONAL = 'P'
+    CENTER = 'M'
+    RIGHT = 'H'
+    BOLD = 'F'
+    UNDERLINE = 'U'
+    ITALIC = 'K'
+    NORMAL = 'Normal'
+
+    attr_accessor :font, :format, :content
+
+    Break = Struct.new(:break) do
+      def break?
+        true
+      end
+    end
+
+    Text = Struct.new(:value) do
+      def break?
+        false
+      end
+    end
+
+    def initialize()
+      self.font = PROPOTIONAL
+      self.format = NORMAL
+    end
+
+    def remove_start_break
+      content.shift if start_breaks?
+    end
+
+    def start_breaks?
+      content.first.break? if content.any?
+    end
+
+    def add_start_break(text_break)
+      content.unshift text_break
+    end
+
+    def add_end_break(text_break)
+      content.push text_break
+    end
+
+    def remove_end_break
+      content.shift if end_breaks?
+    end
+
+    def end_breaks?
+      content.last.break? if content.any?
+    end
+
+    def add_text(text)
+      content.push Text.new(text)
+    end
+
+    def add_break
+      content.push Break.new
+    end
+
+    def empty?
+      content.empty?
+    end
+
+    def content
+      @content ||= []
+    end
+
+    def texts?
+      content.index { |obj| not obj.break? }
+    end
+
+    def empty_copy
+      copy = Paragraph.new
+      copy.format = format
+      copy.font = font
+      copy
+    end
+
+    def ftx_format
+      text = "#{font}"
+      text << case format
+      when NORMAL
+        '00'
+      when CENTER
+        '0M'
+      when RIGHT
+        '0H'
+      when BOLD
+        'F0'
+      when ITALIC
+        'K0'
+      when UNDERLINE
+        'U0'
+      else
+        '00'
+      end
+    end
+
+    def to_subelms(next_paragraph)
+      texts = []
+      text = StringIO.new
+      content_clone = content.clone
+      content_clone.delete_if do |obj|
+        if obj.break?
+          text.write '.' if text.size == 0
+          texts << text.string
+          text.string = ""
+        else
+          text.string = divide_text(obj.value) { |t| texts << t }
+        end
+        true
+      end
+      text.seek text.size
+      if text.size > 0
+        if next_paragraph
+          if next_paragraph.start_breaks?
+            next_paragraph.remove_start_break
+          else
+            if text.size == 70
+              last = text.chars.last
+              text.seek 69
+              text.write('\\')
+              texts << text.string
+              text.string = "#{last}"
+              text.seek text.size
+            end
+            text.write('\\')
+          end
+        end
+        texts << text.string
+        text.string = ''
+      end
+      texts
+    end
+
+    def divide_text(value, &block)
+      chars = value.encode("iso-8859-1").chars
+      text = StringIO.new
+      text.set_encoding("iso-8859-1")
+      chars = chars.reject do |c|
+        if text.size == 69 and chars.count > 1
+          text.string = insert_split(text, &block)
+        end
+        text.seek text.size
+        text.write c
+        true
+      end
+      text.string.encode "UTF-8"
+    end
+
+    def insert_split(text)
+      index = text.string.rindex(/[\s]/)
+      if index and index > 2
+        yield "#{text.string[0..(index)]}\\".encode "UTF-8"
+        text.string[(index+1)..-1]
+      else
+        text.write '\\'
+        yield text.string.encode "UTF-8"
+        ''
+      end
+    end
+
+    def to_s
+      txt = "<#{ftx_format}:"
+      content.each do |obj|
+        if obj.break?
+          txt << "\n"
+        else
+          txt << obj.value
+        end
+      end
+      txt << ">"
+    end
+
+  end
+
+end