eancom 0.1.0 → 2.0.0

data/eancom.gemspec

@@ -1,7 +1,7 @@
 require_relative 'lib/eancom/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "eancom"
+  spec.name          = 'eancom'
   spec.version       = Eancom::VERSION
   spec.authors       = ["Fadendaten GmbH"]
   spec.email         = ["support@fadendaten.ch"]
@@ -27,4 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-remote"
   spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "timecop"
 end

data/lib/eancom.rb

@@ -1,43 +1,88 @@
 require 'eancom/version'
-require 'eancom/edifact'
 
 module Eancom
 
   class Error < StandardError; end
+  class StructureNotFoundError < StandardError; end
+
+  FILE_TYPES = %I[
+    desadv
+    pricat
+    ordrsp
+    slsrpt
+    invrpt
+    orders
+    invoic
+    retann
+  ].freeze
 
-  FILE_TYPES = [
-    :desadv,
-    :pricat,
-    :ordrsp,
-    :salsrp,
-    :invrp,
-    :orders
-  ]
+  DELIMITERS = {
+    component: ':',
+    data: '+',
+    release: '?',
+    decimal: '.',
+    reserve: ' ',
+    segment: '\''
+  }.freeze
 
-  attr_accessor :definitions
+  attr_accessor :definitions, :segments
 
   def self.definitions
-    @@configs ||= Hash.new
+    @configs ||= {}
+  end
+
+  def self.segments
+    @segments ||= {}
+  end
+
+  def self.structures
+    @structures ||= {}
   end
 
   def self.register_definition(definition)
     type = definition.type
     name = definition.name
-    definitions[type] ||= Hash.new
+    definitions[type] ||= {}
     definitions[type][name] = definition
   end
 
   def self.find_definition(name:, type:)
     definitions[type][name]
   end
+
+  def self.register_segment(tag:, klass:)
+    segments[tag] ||= klass
+  end
+
+  def self.find_segment(tag:)
+    segments[tag]
+  end
+
+  def self.register_structure(tag:, structure:)
+    structures[tag] ||= structure
+  end
+
+  def self.find_structure(tag:)
+    structure = structures[tag]
+    if structure.nil?
+      raise StructureNotFoundError.new(
+        "Structure for tag: #{tag} not found."
+      )
+    end
+    structure
+  end
 end
 
-require "eancom/factory"
-require "eancom/definition"
+# TODO: Describe why loaded here...
+
+require 'eancom/edifact'
+require 'eancom/factory'
+require 'eancom/parser'
+require 'eancom/definition'
 
-spec = Gem::Specification.find_by_name("eancom")
+spec = Gem::Specification.find_by_name('eancom')
 gem_root = spec.gem_dir
 
-Dir[File.join(gem_root, "definitions", "**/*.rb")].sort.each do |file|
+Dir[File.join(gem_root, 'definitions', '**/*.rb')].sort.each do |file|
   require file
 end

data/lib/eancom/definition.rb

@@ -5,7 +5,7 @@ module Eancom
 
     def self.create(name:, type:, &block)
       definition = new(name: name, type: type, &block)
-      Eancom::register_definition(definition)
+      Eancom.register_definition(definition)
     end
 
     def initialize(name:, type:, &block)

data/lib/eancom/edifact.rb

@@ -1,19 +1,66 @@
-require 'eancom/edifact/element'
-require 'eancom/edifact/document'
-require 'eancom/edifact/envelope'
-require 'eancom/edifact/message'
 require 'eancom/edifact/segment'
 
+require 'eancom/edifact/document_element'
+require 'eancom/edifact/header'
+require 'eancom/edifact/message'
+require 'eancom/edifact/item'
+require 'eancom/edifact/body'
+require 'eancom/edifact/footer'
+
+require 'eancom/edifact/document'
+
+require 'eancom/edifact/structure'
+require 'eancom/edifact/composite'
+require 'eancom/edifact/data'
+
+require 'eancom/edifact/segments/una'
+require 'eancom/edifact/segments/unb'
+require 'eancom/edifact/segments/unh'
+require 'eancom/edifact/segments/uns'
+require 'eancom/edifact/segments/unt'
+require 'eancom/edifact/segments/unz'
+
+require 'eancom/edifact/segments/alc'
+require 'eancom/edifact/segments/ajt'
+require 'eancom/edifact/segments/dgs'
+require 'eancom/edifact/segments/efi'
+require 'eancom/edifact/segments/tru'
+require 'eancom/edifact/segments/cdi'
+require 'eancom/edifact/segments/gin'
+require 'eancom/edifact/segments/rte'
+require 'eancom/edifact/segments/pcd'
+require 'eancom/edifact/segments/eqd'
+require 'eancom/edifact/segments/tod'
+require 'eancom/edifact/segments/pat'
+require 'eancom/edifact/segments/doc'
+require 'eancom/edifact/segments/ali'
+require 'eancom/edifact/segments/bgm'
+require 'eancom/edifact/segments/cav'
+require 'eancom/edifact/segments/cci'
+require 'eancom/edifact/segments/cnt'
+require 'eancom/edifact/segments/cps'
+require 'eancom/edifact/segments/cux'
+require 'eancom/edifact/segments/cta'
+require 'eancom/edifact/segments/dtm'
+require 'eancom/edifact/segments/ftx'
+require 'eancom/edifact/segments/imd'
+require 'eancom/edifact/segments/inv'
+require 'eancom/edifact/segments/lin'
+require 'eancom/edifact/segments/loc'
+require 'eancom/edifact/segments/mea'
+require 'eancom/edifact/segments/moa'
+require 'eancom/edifact/segments/nad'
+require 'eancom/edifact/segments/pac'
+require 'eancom/edifact/segments/pci'
+require 'eancom/edifact/segments/pgi'
+require 'eancom/edifact/segments/pia'
+require 'eancom/edifact/segments/pri'
+require 'eancom/edifact/segments/qty'
+require 'eancom/edifact/segments/rff'
+require 'eancom/edifact/segments/tax'
+require 'eancom/edifact/segments/tdt'
+
 module Eancom
   module Edifact
-    DELIMITERS = {
-      component: ':',
-      data: '+',
-      decimal: '.',
-      release: '?',
-      reserve: ' ',
-      segment: "'"
-    }
   end
 end
-

data/lib/eancom/edifact/body.rb

@@ -0,0 +1,63 @@
+module Eancom
+  module Edifact
+    class Body < DocumentElement
+
+      attr_accessor :hash, :items, :messages
+
+      def initialize
+        super
+        @hash = {}
+        @messages = []
+      end
+
+      def to_json_hash
+        @segments.each do |segment|
+          start_message(segment) if segment.starts_message?
+          start_item(segment) if segment.starts_item?
+          if @item
+            @item << segment
+          else
+            @message << segment
+          end
+        end
+        @message.add_item(@item.to_json_hash)
+        @messages << @message.to_json_hash
+        hash.merge!({ messages: messages })
+        { body: hash }
+      end
+
+      def start_message(segment)
+        if @message
+          @messages << @message.to_json_hash
+          if @item && !@item.empty?
+            @message.add_item(@item.to_json_hash)
+          end
+          @item = nil
+        end
+        @message = Eancom::Edifact::Message.new()
+      end
+
+      def start_item(segment)
+        if @item && !@item.empty?
+          @message.add_item(@item.to_json_hash)
+        end
+        @item = Eancom::Edifact::Item.new()
+      end
+
+      private
+
+      def merge(hash, segment)
+        if name = group_name(segment)
+          hash[name] = [] if hash[name].nil?
+          hash[name] << segment.to_json_hash
+        else
+          hash.merge!(segment.to_json_hash)
+        end
+      end
+
+      def group_name(segment)
+        return segment.group_name
+      end
+    end
+  end
+end

data/lib/eancom/edifact/composite.rb

@@ -0,0 +1,38 @@
+module Eancom
+  module Edifact
+    class Composite
+      class DataTypeError < StandardError; end
+
+      attr_reader :data
+
+      def initialize
+        @data = {}
+      end
+
+      def add(key, value)
+        if value.kind_of?(Data)
+          @data[key] = value
+        else
+          raise DataTypeError.new('Added value is not of type Data.')
+        end
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def delete(key)
+        @data.delete(key)
+      end
+
+      def to_array
+        array = []
+        @data.each do |key, value|
+          array << key
+        end
+        array
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/data.rb

@@ -0,0 +1,108 @@
+module Eancom
+  module Edifact
+    class Data
+      class TypeError < StandardError; end
+      class LengthError < StandardError; end
+      class RequiredError < StandardError; end
+      class NotFoundInDictionary < StandardError; end
+
+      attr_accessor :type, :length, :dictionary, :description, :required
+
+      def initialize(type:,
+                     length:,
+                     dictionary: nil,
+                     description:,
+                     required:
+                    )
+        @type = type
+        @length = length
+        @dictionary = dictionary
+        @description = description
+        @required = required
+      end
+
+      def valid?(key, value)
+        type?(key, value)
+        length?(key, value)
+        required?(key, value)
+        dictionary?(key, value) unless value.empty?
+      end
+
+
+      def identifier(value)
+        if @dictionary
+          hash = @dictionary[value]
+          unless hash
+            raise NotFoundInDictionary.new(
+              "Value not found for #{value}. Error in Data: #{self.to_s}"
+            )
+          else
+            hash[:identifier]
+          end
+        else
+          ""
+        end
+      end
+
+      def to_s
+        "type: #{@type} " \
+        "length: #{@length} " \
+        "dictionary: #{@dictionary} " \
+        "description: #{@description} " \
+        "required: #{required} "
+      end
+
+      private
+
+      def type?(key, value)
+        unless value.kind_of?(@type)
+          raise TypeError.new(
+            "Wrong type of #{key}: #{value}, should be #{@type}. Error in Data: #{self.to_s}"
+          )
+        end
+      end
+
+      def length?(key, value)
+        if @length.kind_of?(Range)
+          unless @length.include?(value.length)
+            raise LengthError.new(
+              "The value #{key}: #{value} is not in the range of #{@length}. Error in Data: #{self.to_s}")
+          end
+        elsif @length.kind_of?(Integer)
+          unless value.length == @length
+            raise LengthError.new(
+              "The length of #{key}: #{value} should be #{@length}. Error in Data: #{self.to_s}"
+            )
+          end
+        else
+          raise LengthError.new(
+            "Error in length definition. Error in Data: #{self.to_s}"
+          )
+        end
+      end
+
+      def required?(key, value)
+        unless (!@required || !value.nil?)
+          raise RequiredError.new(
+            "The field required. Error in #{self.to_s}"
+          )
+        end
+      end
+
+      def dictionary?(key, value)
+        unless @dictionary.nil?
+          unless @dictionary.key?(value)
+            if @dictionary.key?('*') # Bypass Validation
+              return true
+            else
+              raise NotFoundInDictionary.new(
+                "The value '#{key}: #{value}' is not in the dictionary. Error in #{self.to_s}"
+              )
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/eancom/edifact/document.rb

@@ -2,27 +2,59 @@ module Eancom
   module Edifact
     class Document
 
+      attr_accessor :header_element, :body_element, :footer_element
+
       def initialize
-        @envelope = Envelope.new
-        @message = Message.new
+        @header_element = Header.new()
+        @body_element = Body.new()
+        @footer_element = Footer.new()
+      end
+
+      def header(&block)
+        yield(@header_element)
+      end
+
+      def body(&block)
+        yield(@body_element)
+      end
+
+      def footer(&block)
+        yield(@footer_element)
+      end
+
+      def add_to_header(segment)
+        @header_element.segment(segment)
       end
 
-      def envelope(&block)
-        yield(@envelope)
+      def add_to_body(segment)
+        @body_element.segment(segment)
       end
 
-      def message(name, &block)
-        @message.name = name
-        yield(@message)
+      def add_to_footer(segment)
+        @footer_element.segment(segment)
       end
 
-      def to_s
-        stream = ""
-        stream << @envelope.to_s
-        stream << @message.to_s
+      # Should header and footer segments be added to total_segments?
+      def total_segments
+        total = 0
+        total += @body_element.segments.count
+        total
+      end
+
+      def to_s(debug: false)
+        stream = ''
+        stream << @header_element.to_s(debug: debug)
+        stream << @body_element.to_s(debug: debug)
+        stream << @footer_element.to_s(debug: debug)
         stream
       end
 
+      def to_json
+        hash = {}
+        hash.merge! @header_element.to_json_hash
+        hash.merge! @body_element.to_json_hash
+        hash.to_json
+      end
     end
   end
 end