edifunct 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bae32c4270171e87b5995a301dbb00c2bbbd494d74796c5b08399771f50c5f04
+  data.tar.gz: 0aabf021fc6a986ad70fe2cf37c5804fd3b53681452e311d9885385d77c7c792
+SHA512:
+  metadata.gz: 309d7c2bffda2a3950ea61262ab17acae1d1fc355cfae735adecd62389dd94ea50171f8920d3171251e2e5ece8c08e250cf2fc51b52eee77ed574ce641bd370c
+  data.tar.gz: 2ca8e55858831214be0972e9b04b56c7f269eb80ae27a6e43c3eb6ad56a34d75584ad483c0925117328d3f44177443610ce78df2d67a1c289c5eefe6b6f68121

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.3
+before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in edifunct.gemspec
+gemspec

data/README.md

@@ -0,0 +1,188 @@
+# Edifunct
+
+Fun with EDIFACT :tada:
+
+EDIFACT files consist of segments and extracting the segments themselves is not too complex.
+But when segments are being grouped in segment groups and nested segment groups, it would require having an additional, manual parsing step after extracting the segments.
+This gem makes this easy by parsing the EDIFACT file according to a simple schema which you provide alongside the EDIFACT file.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'edifunct'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install edifunct
+
+## Usage
+
+An example EDIFACT file:
+
+```
+UNB+UNOC:4+5790000110018:14+SEAFT.AFT006+20151012:1354+31'
+UNH+45689+IFTSTA:D:10B:UN'
+BGM+77+YSTSE-39237+9'
+DTM+137:20150820:203'
+DTM+2:20150820:102'
+DTM+234:20150820:102'
+CNI+1+DSVS41599'
+CNT+7:9:KGM'
+STS++Z1+5+8+38+108'
+RFF+BN:123456'
+RFF+ZTF:9F'
+RFF+CU:8008331140'
+RFF+AAS:7481947187'
+RFF+SRN:57065930000021747'
+RFF+AAM:40157065930100420983'
+RFF+ASI:FM807287'
+DTM+334:201508201020:203'
+FTX+AHN+++Collect remarks1:2:3:4:5'
+NAD+AP'
+CTA+GR+:DONALD DRIVER'
+NAD+CZ+++UAE LOGISTICS AB+BOX 1001:SE-164 21 KISTA+KISTA++164 21+SE'
+NAD+CN+++SIERSEMA+KEURWEG 2:.:NL 5145 NX 5145 NX WAALWIJK+5145 NX WAALWIJK++5145 NX+NL'
+NAD+DP+++BYGMA KOLDING+GEJLHAVEG�RD 2 A:DK-6000 KOLDING+KOLDING++6000+DK'
+NAD+PW+++NAUTISK TEKNIK APS+FARUMVEJ 107, GANL�SE:V/MARTIN KRISTENSEN:DK-3660 STENL�SE+STENL�SE++3660+DK'
+NAD+ST+123456++ALFA LAVAL KOLDING A/S+31 ALBUEN:DK-6000 KOLDING+KOLDING++6000+DK'
+NAD+SF+789456++SANISTAL SIA+Tiraines iela 9+Riga++1058+LV'
+LOC+Z01+SELAA::6:SELAA LANDSKRONA'
+GID+1+1:PK'
+LOC+14+LANDSKRONA'
+MEA+WT+AAB+KGM:100'
+MEA+WT+ADZ+KGM:90'
+MEA+VOL++MTQ:2'
+MEA+LMT++MTR:4'
+MEA+CT+SQ+PLL:5'
+DIM+1+MTR:0.2:0.1:0.1'
+PCI+17'
+GIN+BN+00073000093496312546:00073000090414361624+00073000090414361631:00073000090414361648+00073000090414361655:00073000093496312539+00073000123496312546:00073000053496312546+00073000093496312789:00073000093496312684'
+PCI+18'
+GIN+AW+373999991234567899:373323995756893927+373323995780867383:373323995756893927+373323995859384889:373323995859360043+373323995859387804:373323995859387811+373323995859387842:373323995859392068'
+UNT+18+45689'
+UNZ+1+31'
+```
+
+A schema can be described entirely in JSON. An example schema for the EDIFACT file above could look like this:
+
+```json
+[
+  { "type": "segment", "segment_tag": "UNB" },
+  { "type": "segment", "segment_tag": "UNH" },
+  { "type": "segment", "segment_tag": "BGM" },
+  { "type": "segment", "segment_tag": "DTM", "repeat": true },
+  {
+    "type": "segment_group",
+    "group_name": "SG13",
+    "content": [
+      { "type": "segment", "segment_tag": "CNI" },
+      { "type": "segment", "segment_tag": "CNT", "repeat": true },
+      {
+        "type": "segment_group",
+        "group_name": "SG14",
+        "content": [
+          { "type": "segment", "segment_tag": "STS" },
+          { "type": "segment", "segment_tag": "RFF", "repeat": true },
+          { "type": "segment", "segment_tag": "DTM", "repeat": true },
+          { "type": "segment", "segment_tag": "FTX", "repeat": true },
+          {
+            "type": "segment_group",
+            "group_name": "SG15",
+            "content": [
+              { "type": "segment", "segment_tag": "NAD" },
+              {
+                "type": "segment_group",
+                "group_name": "SG16",
+                "content": [
+                  { "type": "segment", "segment_tag": "CTA" }
+                ]
+              }
+            ]
+          },
+          { "type": "segment", "segment_tag": "LOC" },
+          {
+            "type": "segment_group",
+            "group_name": "SG23",
+            "content": [
+              { "type": "segment", "segment_tag": "GID" },
+              { "type": "segment", "segment_tag": "LOC", "repeat": true },
+              {
+                "type": "segment_group",
+                "group_name": "SG24",
+                "content": [
+                  { "type": "segment", "segment_tag": "MEA" }
+                ]
+              },
+              {
+                "type": "segment_group",
+                "group_name": "SG25",
+                "content": [
+                  { "type": "segment", "segment_tag": "DIM" }
+                ]
+              },
+              {
+                "type": "segment_group",
+                "group_name": "SG26",
+                "content": [
+                  { "type": "segment", "segment_tag": "PCI" },
+                  { "type": "segment", "segment_tag": "GIN", "repeat": true }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+  { "type": "segment", "segment_tag": "UNT" },
+  { "type": "segment", "segment_tag": "UNZ" }
+]
+```
+
+Now we are ready to parse the EDIFACT file:
+
+```ruby
+# iftsta_example_as_string: EDIFACT file (String)
+# iftsta_schema: Schema (Array<Hash>)
+
+iftsta_example = Edifunct.parse(iftsta_example_as_string, schema: iftsta_schema)
+iftsta_example.lookup_groups('SG13').each_with_object({}) do |group, consignments|
+  sg14 = group.lookup_group('SG14')
+  next unless sg14
+
+  rff_cu_record = sg14.lookup_segment('RFF') { |s| s.data_elements[0] && s.data_elements[0][0] == 'CU' }
+  next unless rff_cu_record
+
+  dtm_record = sg14.lookup_segment('DTM')
+  next unless dtm_record
+
+  sts_record = sg14.lookup_segment('STS')
+  next unless sts_record
+
+  consignment_ref = rff_cu_record.data_elements[0][1]
+  consignments[consignment_ref] = [
+    {
+      status: sts_record.data_elements[1][0],
+      event_time: dtm_record.data_elements[0][1],
+    }
+  ]
+end
+# => {"8008331140"=>[{:status=>"Z1", :event_time=>"201508201020"}]}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/orhantoy/edifunct.

data/README_generate.rb

@@ -0,0 +1,102 @@
+require "bundler/setup"
+require "json"
+require "edifunct"
+
+puts "# Edifunct"
+puts
+puts <<-MARKDOWN
+Fun with EDIFACT :tada:
+
+EDIFACT files consist of segments and extracting the segments themselves is not too complex.
+But when segments are being grouped in segment groups and nested segment groups, it would require having an additional, manual parsing step after extracting the segments.
+This gem makes this easy by parsing the EDIFACT file according to a simple schema which you provide alongside the EDIFACT file.
+MARKDOWN
+
+puts "\n## Installation"
+puts
+puts <<-MARKDOWN
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'edifunct'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install edifunct
+MARKDOWN
+
+fixtures_dir = File.join(__dir__, "spec", "fixtures")
+iftsta_example_as_string = File.read(File.join(fixtures_dir, "IFTSTA_example.edi"), encoding: "ISO-8859-1")
+iftsta_schema_json = File.read(File.join(fixtures_dir, "IFTSTA_schema.json"))
+iftsta_schema = JSON.parse(iftsta_schema_json)
+
+puts "\n## Usage"
+puts
+puts "An example EDIFACT file:"
+puts
+puts "```"
+print iftsta_example_as_string
+puts "```"
+puts
+puts "A schema can be described entirely in JSON. An example schema for the EDIFACT file above could look like this:"
+puts
+puts "```json"
+print iftsta_schema_json
+puts "```"
+puts
+puts "Now we are ready to parse the EDIFACT file:"
+puts
+puts "```ruby"
+puts "# iftsta_example_as_string: EDIFACT file (String)"
+puts "# iftsta_schema: Schema (Array<Hash>)"
+puts
+
+prog = <<-PROG
+iftsta_example = Edifunct.parse(iftsta_example_as_string, schema: iftsta_schema)
+iftsta_example.lookup_groups('SG13').each_with_object({}) do |group, consignments|
+  sg14 = group.lookup_group('SG14')
+  next unless sg14
+
+  rff_cu_record = sg14.lookup_segment('RFF') { |s| s.data_elements[0] && s.data_elements[0][0] == 'CU' }
+  next unless rff_cu_record
+
+  dtm_record = sg14.lookup_segment('DTM')
+  next unless dtm_record
+
+  sts_record = sg14.lookup_segment('STS')
+  next unless sts_record
+
+  consignment_ref = rff_cu_record.data_elements[0][1]
+  consignments[consignment_ref] = [
+    {
+      status: sts_record.data_elements[1][0],
+      event_time: dtm_record.data_elements[0][1],
+    }
+  ]
+end
+PROG
+
+print prog
+consignments = eval prog
+puts "# => #{consignments.inspect}"
+
+puts "```"
+
+puts "\n## Development"
+puts
+puts <<-MARKDOWN
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+MARKDOWN
+
+puts "\n## Contributing"
+puts
+puts <<-MARKDOWN
+Bug reports and pull requests are welcome on GitHub at https://github.com/orhantoy/edifunct.
+MARKDOWN

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "edifunct"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/edifunct.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "edifunct/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "edifunct"
+  spec.version       = Edifunct::VERSION
+  spec.authors       = ["Orhan Toy"]
+  spec.email         = ["toyorhan@gmail.com"]
+
+  spec.summary       = 'A schema-based EDIFACT parser'
+  spec.description   = 'Edifunct provides an easy way to structurally parse an EDIFACT file based on a simple schema'
+  spec.homepage      = 'https://github.com/orhantoy/edifunct'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/edifunct/parser.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "edifunct/tokenizer"
+require "edifunct/segment_group"
+
+module Edifunct
+  # The main entry point to converting a raw EDIFACT message into a structured object.
+  # The structure is dictated by the provided schema.
+  class Parser
+    def initialize(message, schema:, tokenizer: nil)
+      @message = message
+      @schema = schema
+      @tokenizer = tokenizer || Tokenizer.for_message(message)
+    end
+
+    def as_root_group(root_group_tag = "<root>")
+      @segments = @tokenizer.as_segments(@message)
+
+      SegmentGroup.new(root_group_tag).tap do |root_group|
+        parse_group(root_group, schema)
+      end
+    end
+
+    private
+
+    attr_reader :schema, :segments
+
+    def parse_group(parent_group, group_schema)
+      group_schema.each do |schema_entry|
+        case schema_entry.fetch("type")
+        when "segment"
+          if current_segment_is?(schema_entry.fetch("segment_tag"))
+            parent_group.add_segment(segments.shift)
+            parent_group.add_segment(segments.shift) while schema_entry["repeat"] && current_segment_is?(schema_entry.fetch("segment_tag"))
+          end
+        when "segment_group"
+          while current_segment_is?(schema_entry.fetch("content").fetch(0).fetch("segment_tag"))
+            group = parent_group.create_group(schema_entry.fetch("group_name"))
+            parse_group(group, schema_entry.fetch("content"))
+          end
+        end
+      end
+    end
+
+    def current_segment_is?(tag)
+      current_segment && current_segment.tag == tag
+    end
+
+    def current_segment
+      segments[0]
+    end
+  end
+end

data/lib/edifunct/segment.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Edifunct
+  # Represents a segment in an EDIFACT document/message.
+  class Segment
+    attr_reader :tag, :raw_segment, :data_elements
+
+    def initialize(tag:, raw_segment:, data_elements:)
+      @tag = tag
+      @raw_segment = raw_segment
+      @data_elements = data_elements
+    end
+  end
+end

data/lib/edifunct/segment_group.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "edifunct/segment"
+
+module Edifunct
+  # Represents the logical grouping of segments.
+  class SegmentGroup
+    attr_reader :tag
+    attr_reader :children
+
+    def initialize(tag)
+      @tag = tag
+      @children = []
+
+      @child_segment_map = Hash.new { |hash, key| hash[key] = [] }
+      @child_segment_group_map = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def add_segment(segment)
+      @children << segment
+      @child_segment_map[segment.tag] << segment
+
+      segment
+    end
+
+    def create_group(segment_group_tag)
+      segment_group = SegmentGroup.new(segment_group_tag)
+
+      @children << segment_group
+      @child_segment_group_map[segment_group.tag] << segment_group
+
+      segment_group
+    end
+
+    def lookup_groups(segment_group_tag)
+      @child_segment_group_map[segment_group_tag]
+    end
+
+    def lookup_group(segment_group_tag)
+      lookup_groups(segment_group_tag).first
+    end
+
+    def lookup_segments(segment_tag)
+      @child_segment_map[segment_tag]
+    end
+
+    def lookup_segment(segment_tag, &block)
+      if block_given?
+        lookup_segments(segment_tag).find(&block)
+      else
+        lookup_segments(segment_tag).first
+      end
+    end
+
+    def print_with_structure
+      _print_with_structure(self)
+    end
+
+    private
+
+    def _print_with_structure(group, padding: "")
+      group.children.each do |child|
+        case child
+        when Segment
+          print "#{padding}#{child.raw_segment}\n"
+        when SegmentGroup
+          print "#{padding}#{child.tag}\n"
+          _print_with_structure(child, padding: padding + "  ")
+        end
+      end
+    end
+  end
+end

data/lib/edifunct/tokenizer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "edifunct/segment"
+
+module Edifunct
+  # Tokenizer is responsible for splitting message into segments, data elements and components.
+  class Tokenizer
+    class << self
+      def for_message(_edifact_message)
+        # TODO: Should check if the message starts with `UNA`, and then extract the different separator/terminator settings to be used for initializing the tokenizer.
+        new
+      end
+    end
+
+    attr_reader :release_character, :segment_terminator, :data_element_separator, :component_data_element_separator
+
+    def initialize(release_character: "?", segment_terminator: "'", data_element_separator: "+", component_data_element_separator: ":")
+      @release_character = release_character
+      @segment_terminator = segment_terminator
+      @data_element_separator = data_element_separator
+      @component_data_element_separator = component_data_element_separator
+    end
+
+    def as_segments(message_as_string)
+      message_as_string.split(segment_regexp).map do |raw_segment|
+        segment_tag, data_elements = split_segment(raw_segment)
+
+        Segment.new(tag: segment_tag, raw_segment: raw_segment, data_elements: data_elements)
+      end
+    end
+
+    def split_segment(raw_segment)
+      segment_without_terminator = raw_segment.chomp(@segment_terminator)
+      segment_tag, *data_elements_as_strings = segment_without_terminator.split(data_element_regexp)
+
+      data_elements = data_elements_as_strings.map do |data_element_as_string|
+        data_element_as_string.split(component_data_element_regexp).map do |component|
+          decode_value(component)
+        end
+      end
+
+      [segment_tag, data_elements]
+    end
+
+    def decode_value(encoded_value)
+      encoded_value.gsub(escape_value_regexp, '\1')
+    end
+
+    def formatted_segments_per_line(message_as_string)
+      message_as_string.gsub(segment_regexp, "\n")
+    end
+
+    private
+
+    def escape_value_regexp
+      @escape_value_regexp ||= Regexp.new("#{Regexp.escape(@release_character)}(#{Regexp.escape(@release_character)}|#{Regexp.escape(@segment_terminator)}|#{Regexp.escape(@data_element_separator)}|#{Regexp.escape(@component_data_element_separator)})")
+    end
+
+    def segment_regexp
+      @segment_regexp ||= Regexp.new("(?!#{Regexp.escape(@release_character)})(?<=#{Regexp.escape(@segment_terminator)})\\s*")
+    end
+
+    def data_element_regexp
+      @data_element_regexp ||= Regexp.new("(?!#{Regexp.escape(@release_character)})#{Regexp.escape(@data_element_separator)}")
+    end
+
+    def component_data_element_regexp
+      @component_data_element_regexp ||= Regexp.new("(?!#{Regexp.escape(@release_character)})#{Regexp.escape(@component_data_element_separator)}")
+    end
+  end
+end

data/lib/edifunct/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Edifunct
+  VERSION = "1.0.0"
+end

data/lib/edifunct.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "edifunct/version"
+require "edifunct/parser"
+require "edifunct/tokenizer"
+
+# Top-level Edifunct namespace with short-hands methods to parse EDIFACT documents.
+module Edifunct
+  class << self
+    def parse(edifact_message, schema:)
+      parser = Parser.new(edifact_message, schema: schema)
+      parser.as_root_group
+    end
+
+    def parse_file(file_args, schema:)
+      edifact_message = File.read(*Array(file_args))
+      parse(edifact_message, schema: schema)
+    end
+
+    def as_segments(edifact_message)
+      tokenizer = Tokenizer.for_message(edifact_message)
+      tokenizer.as_segments(edifact_message)
+    end
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: edifunct
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Orhan Toy
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Edifunct provides an easy way to structurally parse an EDIFACT file based
+  on a simple schema
+email:
+- toyorhan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- README_generate.rb
+- Rakefile
+- bin/console
+- bin/setup
+- edifunct.gemspec
+- lib/edifunct.rb
+- lib/edifunct/parser.rb
+- lib/edifunct/segment.rb
+- lib/edifunct/segment_group.rb
+- lib/edifunct/tokenizer.rb
+- lib/edifunct/version.rb
+homepage: https://github.com/orhantoy/edifunct
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A schema-based EDIFACT parser
+test_files: []