edifact_rails 1.2.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c51652b41747f2b0c07ecd834c5c79b3bebbb1537464a450f37ee58ea68150e
-  data.tar.gz: 2669313b30c7565c60f4dc568c528127577770946f7d4a8ffee7a1fc87f4c07e
+  metadata.gz: 617b14ce31edcecdb4d3c4a599f79612716680513a740a425f2bcd0cdb8f1d65
+  data.tar.gz: aa8d78ea8759f43a1465e2036c55ea704c1dce3f4c67c30f943324d32525787c
 SHA512:
-  metadata.gz: ded47109a99423254023e4f7316e1bdc3d1dc6602e73225a900c815baa2b2c4d9d14fe16f131aa5e1239b6b49ecab6394d7051ec9fc66923c6ffb5eb0e674ba5
-  data.tar.gz: f3c9d7ae8f793651c62eff11b3356321f6bcc531b5ce61020f23d530a08b0112d46e338edc8ff1711bc514fb53875508b5792795c3cbea8056e5ee97a60e52f1
+  metadata.gz: a7531b90d3f9d84223e3176fd6ebd012a26076d3f029e30c344c2ab2a26964c069e8a387f5c73c02445cccbc140e3bdba81bbb832ac08c07af7625bc56a4f686
+  data.tar.gz: ccd019d6bd9beac78be1c07563357a4b6f616bdb538e9a66b5b816a2a6ceadcd7abb05749940a8bf6277cc2d9507da0a003e6f8954fa0d90ef6588ade5327f71

data/CHANGELOG.md

@@ -1,23 +1,45 @@
 # Changelog
 
-## 1.0.0 (26/04/2023)
+## 2.1.0 (18/06/2024)
 
-* Initial release
+* Added EDIFACT serialization. Contributed by [sallesma](https://github.com/sallesma)
 
-## 1.1.0 (27/04/2023)
+## 2.0.0 (18/06/2024)
 
-* Added support for TRADACOMS input
+* Added support for ANSIX12 format.
 
-## 1.1.1 (4/05/2023)
+##### Breaking changes:
+* `#una_special_characters` renamed to `#special_characters` (since it can now accept input of any supported format)
+* New `UnrecognizedFormat` Error will now be thrown if the format of the input can not be detected.
+    * In essence, input must begin now with `UNA` or `UNB` (EDIFACT), `STX` (TRADACOMS), or `ISA` (ANSIX12)
 
-* Fixed crash caused by running the gem in a production environment.
+## 1.2.1 (4/06/2024)
+
+* `#una_special_characters` method now also returns decimal notation character, default `.`.
+* `#una_special_characters` method can now take no arguments, and will return the default special characters if so.
 
 ## 1.2.0 (31/05/2024)
 
 * Added support for UNA segments. Special characters different from the defaults can now be used.
 * Added `#una_special_characters` method that returns just the special characters.
 
-## 1.2.1 (4/06/2024)
+## 1.1.1 (4/05/2023)
+
+* Fixed crash caused by running the gem in a production environment.
+
+## 1.1.0 (27/04/2023)
+
+* Added support for TRADACOMS input
+
+## 1.0.0 (26/04/2023)
+
+* Initial release
+
+
+
+
+
+
+
+
 
-* `#una_special_characters` method now also returns decimal notation character, default `.`.
-* `#una_special_characters` method can now take no arguments, and will return the default special characters if so.

data/README.md

@@ -1,10 +1,10 @@
 # EdifactRails
 
-This gem parses EDIFACT or TRADACOMS input, and converts it into a ruby array structure for whatever further processing or validation you desire.
+This gem parses EDIFACT, TRADACOMS, or ANSIX12 input, and converts it into a ruby array structure for whatever further processing or validation you desire.
 
-It does not handle validation itself.
+This gem can also take a ruby array input, and serialize it into EDIFACT.
 
-This gem is heavily inspired by and attempts to output similar results as [edifact_parser](https://github.com/pvdvreede/edifact_parser)
+This gem is heavily inspired by [edifact_parser](https://github.com/pvdvreede/edifact_parser)
 
 ## Requirements
 
@@ -20,7 +20,7 @@ This gem has been tested on the following ruby versions:
 In your `Gemfile`:
 
 ```ruby
-gem 'edifact_rails', '~> 1.2'
+gem 'edifact_rails', '~> 2.1.0'
 ```
 
 Otherwise:
@@ -36,21 +36,40 @@ If you don't have the gem in your `Gemfile`, you will need to:
 ```ruby
 require 'edifact_rails'
 ```
+### Parsing
 
-You can pass either the path to your EDIFACT (or TRADACOMS) file, or a document (or snippet) as a string:
+You can parse a string input with `#parse`, or a file with `#parse_file`
+
+```ruby
+ruby_array = EdifactRails.parse("UNB+UNOA:3+TESTPLACE:1+DEP1:1+20051107:1159+6002'")
+```
 
 ```ruby
 ruby_array = EdifactRails.parse_file("your/file/path")
 ```
 
+### Serialization
+
+You can convert a ruby input into EDIFACT with `#serialize`. Use the `with_service` option to insert the UNA segment.
+
 ```ruby
-ruby_array = EdifactRails.parse("LIN+1+1+0764569104:IB'QTY+1:25'")
+edifact_output = Edifact.serialize(
+  [
+    ["LIN", [1], [1], ["0764569104", "IB"]],
+    ["QTY", [1, 25]]
+  ],
+  with_service: true
+)
+# edifact_output =>
+"UNA:+.? 'LIN+1+1+0764569104:IB'QTY+1:25'"
 ```
 
-You can pull just the special characters from the UNA segment (or the defaults if no UNA segment is present):
+### Special Characters
+
+You can return the special characters of your input with `#special_characters`.
 ```ruby
-una_special_characters = EdifactRails.una_special_characters(your_string_input)
-# una_special_characters =>
+special_characters = EdifactRails.special_characters(example_edifact_input)
+# special_characters =>
 {
   component_data_element_seperator: ":",
   data_element_seperator: "+",
@@ -60,7 +79,7 @@ una_special_characters = EdifactRails.una_special_characters(your_string_input)
 }
 ```
 
-## Output
+## Parse Output
 
 ### EDIFACT
 
@@ -179,4 +198,66 @@ Will be returned as:
   ['MTR', [3]],
   ['END', [5]]
 ]
-```
+```
+
+### ANSIX12
+
+This ANSIX12 file:
+
+```
+ISA*00*          *00*          *01*SENDER         *01*RECEIVER       *231014*1200*U*00401*000000001*1*P*>~
+GS*SS*APP SENDER*APP RECEIVER*20231014*1200*0001*X*004010~
+ST*862*0001~
+BSS*05*12345*20230414*DL*20231014*20231203****ORDER1*A~
+N1*MI*SEEBURGER AG*ZZ*00000085~
+N3*EDISONSTRASSE 1~
+N4*BRETTEN**75015*DE~
+N1*SU*SUPLIER NAME*ZZ*11222333~
+N3*203 STREET NAME~
+N4*ATLANTA*GA*30309*US~
+LIN**BP*MATERIAL1*EC*ENGINEERING1*DR*001~
+UIT*EA~
+PER*SC*SEEBURGER INFO*TE*+49(7525)0~
+FST*13*C*D*20231029****DO*12345-1~
+FST*77*C*D*20231119****DO*12345-2~
+FST*68*C*D*20231203****DO*12345-3~
+SHP*01*927*011*20231014~
+REF*SI*Q5880~
+SHP*02*8557*011*20231014**20231203~
+CTT*1*5~
+SE*19*0001~
+GE*1*0001~
+IEA*1*000000001~
+```
+
+Will be returned as:
+
+```ruby
+[
+  ["ISA", ["00"], [nil], ["00"], [nil], ["01"], ["SENDER"], ["01"], ["RECEIVER"], [231014], [1200], ["U"], ["00401"], ["000000001"], [1], ["P"], []],
+  ["GS", ["SS"], ["APP SENDER"], ["APP RECEIVER"], [20231014], [1200], ["0001"], ["X"], ["004010"]],
+  ["ST", [862], ["0001"]],
+  ["BSS", ["05"], [12345], [20230414], ["DL"], [20231014], [20231203], [], [], [], ["ORDER1"], ["A"]],
+  ["N1", ["MI"], ["SEEBURGER AG"], ["ZZ"], ["00000085"]],
+  ["N3", ["EDISONSTRASSE 1"]],
+  ["N4", ["BRETTEN"], [], [75015], ["DE"]],
+  ["N1", ["SU"], ["SUPLIER NAME"], ["ZZ"], [11222333]],
+  ["N3", ["203 STREET NAME"]],
+  ["N4", ["ATLANTA"], ["GA"], [30309], ["US"]],
+  ["LIN", [], ["BP"], ["MATERIAL1"], ["EC"], ["ENGINEERING1"], ["DR"], ["001"]],
+  ["UIT", ["EA"]],
+  ["PER", ["SC"], ["SEEBURGER INFO"], ["TE"], ["+49(7525)0"]],
+  ["FST", [13], ["C"], ["D"], [20231029], [], [], [], ["DO"], ["12345-1"]],
+  ["FST", [77], ["C"], ["D"], [20231119], [], [], [], ["DO"], ["12345-2"]],
+  ["FST", [68], ["C"], ["D"], [20231203], [], [], [], ["DO"], ["12345-3"]],
+  ["SHP", ["01"], [927], ["011"], [20231014]],
+  ["REF", ["SI"], ["Q5880"]],
+  ["SHP", ["02"], [8557], ["011"], [20231014], [], [20231203]],
+  ["CTT", [1], [5]],
+  ["SE", [19], ["0001"]],
+  ["GE", [1], ["0001"]],
+  ["IEA", [1], ["000000001"]]
+]
+```
+
+

data/lib/edifact_rails/exceptions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EdifactRails
+  class UnrecognizedFormat < StandardError
+    def initialize
+      super("Unrecognized EDI format. Accepted formats: Edifact, Tradacoms, ANSIX12. File must begin with UNA, UNB, STX, or ISA.")
+    end
+  end
+end

data/lib/edifact_rails/formats.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EdifactRails
+  class Formats
+    EDIFACT = "EDIFACT"
+    TRADACOMS = "TRADACOMS"
+    ANSIX12 = "ANSIX12"
+  end
+end

data/lib/edifact_rails/parser.rb

@@ -10,20 +10,26 @@ module EdifactRails
 
     # Treat the input, split the input string into segments, parse those segments
     def parse(string)
-      # Trim newlines and excess spaces around those newlines
-      string = string.gsub(/\s*\n\s*/, "")
+      # Remove all carraige returns, and leading and trailing whitespace
+      string = string.delete("\r").gsub(/^\s*(.*)\s*$/, '\1')
 
-      # Check for UNA segment, update special characters if so
+      @edi_format = detect_edi_format(string)
+
+      # Detects special characters in the UNA segment (edifact) or ISA segment (ansix12),
+      # updates special characters if so
       detect_special_characters(string)
 
       # Does some funky regex maniulation to handle escaped special characters
-      string = treat_input(string)
+      # Ansix12 does not have escape characters, so we can skip
+      string = handle_duplicate_escape_characters(string) unless @edi_format == EdifactRails::Formats::ANSIX12
 
       # Split the input string into segments
-      segments = string.split(/(?<!#{Regexp.quote(@escape_character)})#{Regexp.quote(@segment_seperator)}/)
-
-      # Detect if the input is a tradacoms file
-      @is_tradacoms = segments.map { |s| s[3] }.uniq == ["="]
+      segments =
+        if @edi_format == EdifactRails::Formats::ANSIX12
+          string.split(@special_characters[:segment_seperator])
+        else
+          string.split(/(?<!#{Regexp.quote(@special_characters[:escape_character])})#{Regexp.quote(@special_characters[:segment_seperator])}/)
+        end
 
       # Drop the UNA segment, if present (we have already dealt with it in #detect_special_characters)
       segments.reject! { |s| s[0..2] == "UNA" }
@@ -33,62 +39,92 @@ module EdifactRails
     end
 
     # Given an input string, return the special characters as defined by the UNA segment
-    # If no UNA segment is present, returns the default special characters
-    def una_special_characters(string)
+    def special_characters(string = "")
+      # If no string is passed, return default edifact characters
+      return EdifactRails::DEFAULT_SPECIAL_CHARACTERS if string.empty?
+
+      string = string.delete("\r").gsub(/^\s*(.*)\s*$/, '\1')
+      @edi_format = detect_edi_format(string)
       detect_special_characters(string)
 
-      {
-        component_data_element_seperator: @component_data_element_seperator,
-        data_element_seperator: @data_element_seperator,
-        decimal_notation: @decimal_notation,
-        escape_character: @escape_character,
-        segment_seperator: @segment_seperator
-      }
+      @special_characters
     end
 
     private
 
-    def set_special_characters(
-      component_data_element_seperator =
-        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:component_data_element_seperator],
-      data_element_seperator = EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:data_element_seperator],
-      decimal_notation = EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:decimal_notation],
-      escape_character = EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:escape_character],
-      segment_seperator = EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:segment_seperator]
-    )
-      # Set the special characters
-      @component_data_element_seperator = component_data_element_seperator
-      @data_element_seperator = data_element_seperator
-      @decimal_notation = decimal_notation
-      @escape_character = escape_character
-      @segment_seperator = segment_seperator
+    def detect_edi_format(string)
+      case string[0..2]
+      when "UNA", "UNB"
+        EdifactRails::Formats::EDIFACT
+      when "STX"
+        EdifactRails::Formats::TRADACOMS
+      when "ISA"
+        EdifactRails::Formats::ANSIX12
+      else
+        raise EdifactRails::UnrecognizedFormat
+      end
     end
 
     def detect_special_characters(string)
-      # UNA tags must be at the start of the input otherwise they are ignored
-      return unless string[0..2] == "UNA"
+      # Format must be EDIFACT or ANSI X12 to set custom characters
+      # Tradacoms uses the defaults
+      return unless [EdifactRails::Formats::EDIFACT, EdifactRails::Formats::ANSIX12].include?(@edi_format)
+
+      # If EDIFACT, UNA tags are optional, so return if it's not present
+      return if @edi_format == EdifactRails::Formats::EDIFACT && string[0..2] != "UNA"
+
+      case @edi_format
+      when EdifactRails::Formats::EDIFACT
+        # UNA segments look like this:
+        #
+        # UNA:+.? '
+        #
+        # UNA followed by 6 special characters which are, in order:
+        # 1. Component data element separator
+        # 2. Data element separator
+        # 3. Decimal notation (must be . or ,)
+        # 4. Release character (aka escape character)
+        # 5. Reserved for future use, so always a space for now
+        # 6. Segment terminator
+        set_special_characters(
+          component_data_element_seperator: string[3],
+          data_element_seperator: string[4],
+          decimal_notation: string[5],
+          escape_character: string[6],
+          segment_seperator: string[8]
+        )
+      when EdifactRails::Formats::ANSIX12
+        # ISA segments look like this:
+        # ISA*00*          *00*          *01*SENDER         *01*RECEIVER       *231014*1200*U*00401*000000001*1*P*>~
+        # These are designed to always be the same number of characters, so we can use the hardcoded positions
+        # The special characters are the 4th (default *, data_element_seperator),
+        # 105th, 106th, 103rd, and 3rd characters
+        set_special_characters(
+          data_element_seperator: string[3],
+          component_data_element_seperator: string[104],
+          segment_seperator: string[105]
+        )
+      end
+    end
 
-      # UNA segments look like this:
-      #
-      # UNA:+.? '
-      #
-      # UNA followed by 6 special characters which are, in order:
-      # 1. Component data element separator
-      # 2. Data element separator
-      # 3. Decimal notation (must be . or ,)
-      # 4. Release character (aka escape character)
-      # 5. Reserved for future use, so always a space for now
-      # 6. Segment terminator
-      set_special_characters(string[3], string[4], string[5], string[6], string[8])
+    def set_special_characters(args = {})
+      # arg keys will overwrite the defaults when present
+      @special_characters = EdifactRails::DEFAULT_SPECIAL_CHARACTERS.merge(args)
+
+      # ANSIX12 files have no escape character or decimal notation character§
+      return unless @edi_format == EdifactRails::Formats::ANSIX12
+
+      @special_characters.delete(:escape_character)
+      @special_characters.delete(:decimal_notation)
     end
 
-    def treat_input(string)
+    def handle_duplicate_escape_characters(string)
       # Prepare regex
-      other_specials_rx = Regexp.quote(
+      other_specials_regex = Regexp.quote(
         [
-          @segment_seperator,
-          @data_element_seperator,
-          @component_data_element_seperator
+          @special_characters[:segment_seperator],
+          @special_characters[:data_element_seperator],
+          @special_characters[:component_data_element_seperator]
         ].join
       )
 
@@ -96,7 +132,7 @@ module EdifactRails
       # the special character is therefore unescaped.
       # Add a space between these even number of escapes, and the special character
       #
-      # This means the regex logic for #splitting on special characters is now consistent, since there will only ever
+      # This means the regex logic for splitting on special characters is now consistent, since there will only ever
       # be either 0 or 1 escape characters before every special character.
       #
       # We have to do this because we can't negative lookbehind for 'an even number of escape characters' since
@@ -110,20 +146,30 @@ module EdifactRails
       # "LIN+even????+123" => '+' is not escaped, gsub'ed => "even???? +123" => parsed => ['LIN', ['even??'], [123]]
       # "LIN+odd???+123" => '+' is escaped, not gsub'ed => "odd???+123" => parsed => ['LIN', ['odd?+123']]
       string.gsub(
-        /(?<!#{Regexp.quote(@escape_character)})((#{Regexp.quote(@escape_character)}{2})+)([#{other_specials_rx}])/,
+        /(?<!#{Regexp.quote(@special_characters[:escape_character])})((#{Regexp.quote(@special_characters[:escape_character])}{2})+)([#{other_specials_regex}])/,
         '\1 \3'
       )
     end
 
     # Split the segment into data elements, take the first as the tag, then parse the rest
     def parse_segment(segment)
+      segment.chomp("")
+      segment.gsub!(/^\s*(.*)\s*/, '\1')
+
       # If the input is a tradacoms file, the segment tag will be proceeded by '=' instead of '+'
       # 'QTY=1+A:B' instead of 'QTY+1+A:B'
       # Fortunately, this is easily handled by simply changing these "="s into "+"s before the split
-      segment[3] = @data_element_seperator if @is_tradacoms && segment.length >= 4
+      if @edi_format == EdifactRails::Formats::TRADACOMS && segment.length >= 4
+        segment[3] = @special_characters[:data_element_seperator]
+      end
 
       # Segments are made up of data elements
-      data_elements = segment.split(/(?<!#{Regexp.quote(@escape_character)})#{Regexp.quote(@data_element_seperator)}/)
+      data_elements =
+        if @edi_format == EdifactRails::Formats::ANSIX12
+          segment.split(@special_characters[:data_element_seperator])
+        else
+          segment.split(/(?<!#{Regexp.quote(@special_characters[:escape_character])})#{Regexp.quote(@special_characters[:data_element_seperator])}/)
+        end
 
       # The first element is the tag, pop it off
       parsed_segment = []
@@ -137,7 +183,11 @@ module EdifactRails
     def parse_data_element(element)
       # Split data element into components
       components =
-        element.split(/(?<!#{Regexp.quote(@escape_character)})#{Regexp.quote(@component_data_element_seperator)}/)
+        if @edi_format == EdifactRails::Formats::ANSIX12
+          element.split(@special_characters[:component_data_element_seperator])
+        else
+          element.split(/(?<!#{Regexp.quote(@special_characters[:escape_character])})#{Regexp.quote(@special_characters[:component_data_element_seperator])}/)
+        end
 
       components.map { |component| treat_component(component) }
     end
@@ -149,15 +199,19 @@ module EdifactRails
 
       # Prepare regex
       all_special_characters_string = [
-        @segment_seperator,
-        @data_element_seperator,
-        @component_data_element_seperator,
-        @escape_character
+        @special_characters[:segment_seperator],
+        @special_characters[:data_element_seperator],
+        @special_characters[:component_data_element_seperator],
+        @special_characters[:escape_character]
       ].join
 
-      # If the component has escaped characters in it, remove the escape character and return the character as is
-      # "?+" -> "+", "??" -> "?"
-      component.gsub!(/#{Regexp.quote(@escape_character)}([#{Regexp.quote(all_special_characters_string)}])/, '\1')
+      unless @edi_format == EdifactRails::Formats::ANSIX12
+        # If the component has escaped characters in it, remove the escape character and return the character as is
+        # "?+" -> "+", "??" -> "?"
+        component.gsub!(
+          /#{Regexp.quote(@special_characters[:escape_character])}([#{Regexp.quote(all_special_characters_string)}])/, '\1'
+        )
+      end
 
       # Convert empty strings to nils
       component = nil if component.empty?

data/lib/edifact_rails/serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module EdifactRails
+  class Serializer
+    # with_service is used to force the service segment (UNA) at the beginning of the message
+    def serialize(segments, with_service:)
+      # Serialize and join the segments
+      output = segments.map { |segment| serialize_segment(segment) }
+                       .join(EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:segment_seperator])
+
+      # Add the UNA segment
+      output.insert(0, "UNA:+.? '") unless segments.first.first == "UNA" || !with_service
+      output + EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:segment_seperator]
+    end
+
+    private
+
+    # Serialize the data elements and join them to serialize the segment
+    def serialize_segment(segment)
+      return if segment.empty?
+
+      # Get the tag
+      tag = segment.first
+      data_elements = segment[1..]
+
+      # Serialize the data elements
+      serialized_elements = data_elements.map { |element| serialize_data_element(element) }
+
+      # Join tag and data elements
+      serialized_elements.prepend(tag).join(EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:data_element_seperator])
+    end
+
+    def serialize_data_element(element)
+      element.map { |component| treat_component(component) }
+             .join(EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:component_data_element_seperator])
+    end
+
+    # Strip, remove escape characters, convert to nil where needed, convert to integer where needed
+    def treat_component(component)
+      return component unless component.is_a? String
+
+      # Prepare regex
+      all_special_characters = [
+        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:segment_seperator],
+        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:data_element_seperator],
+        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:component_data_element_seperator],
+        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:escape_character]
+      ].join
+
+      # If the component has escaped characters in it, prepend the escape character "+" -> "?+", "?" -> "??"
+      component.gsub(/([#{Regexp.quote(all_special_characters)}])/) do |match|
+        EdifactRails::DEFAULT_SPECIAL_CHARACTERS[:escape_character] + match
+      end
+    end
+  end
+end

data/lib/edifact_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EdifactRails
-  VERSION = "1.2.1"
+  VERSION = "2.1.0"
 end

data/lib/edifact_rails.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "edifact_rails/parser"
+require "edifact_rails/serializer"
+require "edifact_rails/formats"
+require "edifact_rails/exceptions"
 
 module EdifactRails
   DEFAULT_SPECIAL_CHARACTERS = {
@@ -17,11 +20,16 @@ module EdifactRails
   end
 
   def self.parse_file(file_path)
-    parse(File.read(file_path).split("\n").join)
+    parse(File.read(file_path))
   end
 
-  def self.una_special_characters(string = '')
+  def self.special_characters(string = "")
     parser = EdifactRails::Parser.new
-    parser.una_special_characters(string)
+    parser.special_characters(string)
+  end
+
+  def self.serialize(array, with_service: true)
+    serializer = EdifactRails::Serializer.new
+    serializer.serialize array, with_service: with_service
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edifact_rails
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.1.0
 platform: ruby
 authors:
 - David Blackwood
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-04 00:00:00.000000000 Z
+date: 2024-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -124,7 +124,10 @@ files:
 - LICENSE
 - README.md
 - lib/edifact_rails.rb
+- lib/edifact_rails/exceptions.rb
+- lib/edifact_rails/formats.rb
 - lib/edifact_rails/parser.rb
+- lib/edifact_rails/serializer.rb
 - lib/edifact_rails/version.rb
 homepage: https://github.com/david-blackwood/edifact_rails
 licenses: