eddy 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f42340c2240a26ad129493767545915bfa8d6405d79691841fada80cac9ac7ee
-  data.tar.gz: d60b37dc82e5a008e616ee98c902201df6d97808d4e215769e208a0de404bffb
+  metadata.gz: 54eb94b693f0ba6522fb7acdaddd77d3f84c82519f53f8cef07b1f7d67ebf556
+  data.tar.gz: 8baff248f6b4dfc3a52a62592540539998619d7244a6c5675ade29f60ff20eae
 SHA512:
-  metadata.gz: 5c6ac232571b5cd098770a25c20416cfa7ce4a65be98bf5b001666185010b0d84dbf9af160406bcd1e313c35eda2a463da92b413cceee1a9458f728ab0894e3d
-  data.tar.gz: f41c5e4c6bc496f0354e6046c1d9bec085037f529647d9ea04c4c81706c4bcd3412528413afb5166866894c19484279d098f9b35ebc6de13129a31217c7977f5
+  metadata.gz: 870298adcb6cab4c53100d6094edb4a1a028048fcf0cfbe49cc2977aca8412df192bca48edf15bf6a30efb0141d3cd45ea939151466e66dfed1a83647bee1b86
+  data.tar.gz: 60822c6c92d13a0fc96c3d33894417ed70e85cbc908302518dbe567ca6c22ee20b4b07ea3c28cea70323f4fc7565d9c089f64b7bf2baf9133ac24f747b5f7454

data/CHANGELOG.md

@@ -13,6 +13,22 @@ All code should be considered Work In Progress.
 
 While the API is still changing, enough code exists that EDI documents can currently be written with Eddy (though I wouldn't recommend use in production environments yet).
 
+## 0.5.0 (2020-01-05)
+
+### Changed
+
+- Updated the implementation of `Eddy::Interchange` and `Eddy::FunctionalGroup`
+- Added arguments to the `initialize` methods of the following classes:
+    - `Eddy::Segments::GS`
+    - `Eddy::Segments::GE`
+    - `Eddy::Segments::ISA`
+    - `Eddy::Segments::IEA`
+- Slightly modified file/folder layout.
+
+### Removed
+
+- `Eddy::SimpleInterchange` and its associated test.
+
 ## 0.4.0 (2020-01-05)
 
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    eddy (0.4.0)
+    eddy (0.5.0)
       ginny (~> 0.6.3)
       json_schemer (~> 0.2.8)
       thor (~> 1.0.1)

data/README.md

@@ -10,7 +10,7 @@
 [travis-ci]: https://travis-ci.org/tcd/eddy
 [coveralls]: https://coveralls.io/github/tcd/eddy?branch=master
 [license]: https://github.com/tcd/eddy/blob/master/LICENSE.txt
-[docs]: https://www.rubydoc.info/gems/eddy/0.4.0
+[docs]: https://www.rubydoc.info/gems/eddy/0.5.0
 
 ## Installation
 

data/eddy.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
     "yard.run" => "yri", # use "yard" to build full HTML docs.
   }
 
-  spec.files         = Dir.chdir(File.expand_path("..", __FILE__)) do
+  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"

data/lib/definitions/segments/manual/envelopes/ge.rb

@@ -8,12 +8,13 @@ module Eddy
     class GE < Eddy::Segment
 
       # @param store [Eddy::Data::Store]
-      # @param group_control_number [Integer]
+      # @param group_control_number [Integer] A unique *functional group control number*.
+      # @param number_of_transaction_sets [Integer] Number of transaction sets included in a functional group.
       # @return [void]
-      def initialize(store, group_control_number)
+      def initialize(store, group_control_number, number_of_transaction_sets)
         @id = "GE"
         @name = "Functional Group Trailer"
-        @ge01 = Eddy::Elements::E97.new(ref: "GE01", req: "M", val: store.number_of_transaction_sets_included)
+        @ge01 = Eddy::Elements::E97.new(ref: "GE01", req: "M", val: number_of_transaction_sets)
         @ge02 = Eddy::Elements::E28.new(ref: "GE02", req: "M", val: group_control_number)
         super(store, @ge01, @ge02)
       end

data/lib/definitions/segments/manual/envelopes/gs.rb

@@ -8,13 +8,13 @@ module Eddy
     class GS < Eddy::Segment
 
       # @param store [Eddy::Data::Store]
-      # @param group_control_number [Integer]
-      # @param transaction_set [Eddy::TransactionSet]
+      # @param group_control_number [Integer] A unique *functional group control number*.
+      # @param functional_group [String] A two-letter functional group id.
       # @return [void]
-      def initialize(store, group_control_number, transaction_set)
+      def initialize(store, group_control_number, functional_group)
         @id = "GS"
         @name = "Functional Group Header"
-        @gs01 = Eddy::Elements::E479.new(ref: "GS01", req: "M", val: transaction_set.functional_group)
+        @gs01 = Eddy::Elements::E479.new(ref: "GS01", req: "M", val: functional_group)
         @gs02 = Eddy::Elements::E142.new(ref: "GS02", req: "M", val: store.application_senders_code)
         @gs03 = Eddy::Elements::E124.new(ref: "GS03", req: "M", val: store.application_receivers_code)
         @gs04 = Eddy::Elements::E373.new(ref: "GS04", req: "M", val: store.time)

data/lib/definitions/segments/manual/envelopes/iea.rb

@@ -8,12 +8,13 @@ module Eddy
     class IEA < Eddy::Segment
 
       # @param store [Eddy::Data::Store]
-      # @param interchange_control_number [Integer]
+      # @param interchange_control_number [Integer] A unique *interchange control number*.
+      # @param number_of_functional_groups [Integer] Number of functional groups included in an Interchange.
       # @return [void]
-      def initialize(store, interchange_control_number)
+      def initialize(store, interchange_control_number, number_of_functional_groups)
         @id = "IEA"
         @name = "Interchange Control Trailer"
-        @iea01 = Eddy::Elements::I16.new(ref: "IEA01", req: "M", val: store.number_of_included_functional_groups)
+        @iea01 = Eddy::Elements::I16.new(ref: "IEA01", req: "M", val: number_of_functional_groups)
         @iea02 = Eddy::Elements::I12.new(ref: "IEA02", req: "M", val: interchange_control_number)
         super(store, @iea01, @iea02)
       end

data/lib/definitions/segments/manual/envelopes/isa.rb

@@ -8,7 +8,7 @@ module Eddy
     class ISA < Eddy::Segment
 
       # @param store [Eddy::Data::Store]
-      # @param interchange_control_number [Integer]
+      # @param interchange_control_number [Integer] A unique *interchange control number*.
       # @return [void]
       def initialize(store, interchange_control_number)
         @id = "ISA"

data/lib/eddy/data/store.rb

@@ -46,13 +46,6 @@ module Eddy
       # @return [String]
       attr_accessor :version_release_industry_id_code
 
-      # Total number of transaction sets included in the functional group or interchange (transmission) group.
-      # @return [Integer]
-      attr_accessor :number_of_transaction_sets_included
-      # A count of the number of functional groups included in an interchange.
-      # @return [Integer]
-      attr_accessor :number_of_included_functional_groups
-
       # Application Sender's Code
       # Code identifying party sending transmission; codes agreed to by trading partners
       # @return [String]
@@ -70,39 +63,34 @@ module Eddy
         self.segment_separator   = "~"
         self.element_separator   = "*"
         self.edi_version = "00401"
-        self.number_of_included_functional_groups = 0
-        self.number_of_transaction_sets_included  = 0
         self.application_senders_code = "sender_id"
         self.application_receivers_code = "receiver_id"
         self.version_release_industry_id_code = "004010"
-        @group_control_number = 1
       end
 
-      # FIXME: not implemented
+      # (see Eddy::Data.new_interchange_control_number)
       #
       # @return [Integer]
       def interchange_control_number()
-        # raise NotImplementedError
-        return 1
+        return Eddy::Data.new_interchange_control_number()
       end
 
-      # FIXME: not implemented
+      # (see Eddy::Data.new_transaction_set_control_number)
       #
+      # @param transaction_set_id [String]
       # @return [Integer]
-      def transaction_set_control_number()
-        # raise NotImplementedError
-        return 1
+      def transaction_set_control_number(transaction_set_id)
+        return Eddy::Data.new_transaction_set_control_number(transaction_set_id)
       end
 
-      # Returns an incremended value every time it's called.
+      # (see Eddy::Data.new_interchange_control_number)
       #
+      # @param functional_group [String]
       # @return [Integer]
-      def group_control_number()
-        old_count = @group_control_number.dup
-        @group_control_number += 1
-        return old_count
+      def functional_group_control_number(functional_group)
+        return Eddy::Data.new_functional_group_control_number(functional_group)
       end
-    end
 
+    end
   end
 end

data/lib/eddy/data.rb

@@ -5,6 +5,7 @@ require "eddy/data/persistence/memory"
 module Eddy
 
   # Persistent data used by Eddy.
+  #
   # @return [Eddy::Data::Persistence::Base]
   def self.data
     return @data if defined?(@data) && !@data.nil?
@@ -32,6 +33,8 @@ module Eddy
   # Code for storing & generating data used by Eddy when generating EDI documents.
   module Data
 
+    # Return a new, unique number.
+    #
     # @return [Integer]
     def self.new_interchange_control_number
       existing = Eddy.data.interchange_control_numbers()
@@ -40,24 +43,27 @@ module Eddy
       return new_ctrl_num
     end
 
-    # @param functional_group [String]
+    # Return a new, unique number.
+    #
+    # @param transaction_set_id [String]
     # @return [Integer]
-    def self.new_functional_group_control_number(functional_group)
-      existing = Eddy.data.functional_group_control_numbers(functional_group)
+    def self.new_transaction_set_control_number(transaction_set_id)
+      existing = Eddy.data.transaction_set_control_numbers(transaction_set_id)
       new_ctrl_num = Eddy::Util.new_number(existing)
-      Eddy.data.add_functional_group_control_number(functional_group, new_ctrl_num)
+      Eddy.data.add_transaction_set_control_number(transaction_set_id, new_ctrl_num)
       return new_ctrl_num
     end
 
-    # @param transaction_set_id [String]
+    # Return a new, unique number.
+    #
+    # @param functional_group [String]
     # @return [Integer]
-    def self.new_transaction_set_control_number(transaction_set_id)
-      existing = Eddy.data.transaction_set_control_numbers(transaction_set_id)
+    def self.new_functional_group_control_number(functional_group)
+      existing = Eddy.data.functional_group_control_numbers(functional_group)
       new_ctrl_num = Eddy::Util.new_number(existing)
-      Eddy.data.transaction_set_control_numbers(transaction_set_id, new_ctrl_num)
+      Eddy.data.add_functional_group_control_number(functional_group, new_ctrl_num)
       return new_ctrl_num
     end
 
   end
-
 end

data/lib/eddy/models/functional_group.rb

@@ -2,31 +2,33 @@ module Eddy
   # A group of `Eddy::TransactionSet::Base` classes.
   class FunctionalGroup
 
+    # @return [String]
+    attr_reader :id
     # @return [Eddy::Data::Store] Data store for the Interchange and all encompassed components.
     attr_accessor :store
-    # Class for making new Transaction Sets.
-    # @return [Eddy::TransactionSet]
-    attr_accessor :transaction_set
-    # An array of Transaction Set instances
+    # An array of Transaction Set instances.
     # @return [Array<Eddy::TransactionSet>]
     attr_accessor :transaction_sets
 
     # @param store [Eddy::Data::Store]
-    # @param transaction_set [Eddy::TransactionSet]
+    # @param transaction_sets [Eddy::TransactionSet]
     # @return [void]
-    def initialize(store, transaction_set)
+    def initialize(store, *transaction_sets)
       self.store = store
-      self.transaction_set = transaction_set
-      self.transaction_sets = []
+      transaction_sets.flatten!
+      self.transaction_sets = transaction_sets || []
+      if self.transaction_sets.length == 0
+        raise ArgumentError, "At least one transaction set is required to create a functional group"
+      end
+      @id = self.transaction_sets.first.functional_group
     end
 
-    # @return [String]
+    # @return [Array<#render>]
     def render()
-      number_of_included_functional_groups = self.store.number_of_included_functional_groups
-      gs = Eddy::Segments::GS.new(store, number_of_included_functional_groups, self.transaction_set)
-      ge = Eddy::Segments::GE.new(store, number_of_included_functional_groups, self.transaction_set)
-      segments = [gs, self.transaction_sets, ge].flatten
-      return segments.join(self.store.segment_separator) + segment_separator
+      f_group_ctrl_num = Eddy::Data.new_functional_group_control_number(@id)
+      gs = Eddy::Segments::GS.new(store, f_group_ctrl_num, @id)
+      ge = Eddy::Segments::GE.new(store, f_group_ctrl_num, self.transaction_sets.length)
+      return [gs, self.transaction_sets, ge].flatten.map(&:render)
     end
 
   end

data/lib/eddy/models/interchange.rb

@@ -3,13 +3,14 @@ module Eddy
   class Interchange
     # @return [Eddy::Data::Store] Data store for the Interchange.
     attr_accessor :store
-    # @return [Array<Eddy::Write::FunctionalGroup>]
-    attr_accessor :functional_groups
+    # @return [Array<Eddy::TransactionSet>]
+    attr_accessor :transaction_sets
 
+    # @param store [Eddy::Data::Store] (Eddy::Data::Store.new)
     # @return [void]
-    def initialize()
-      self.store = Eddy::Data::Store.new()
-      self.functional_groups = []
+    def initialize(store = Eddy::Data::Store.new())
+      self.store = store
+      self.transaction_sets = []
     end
 
     # @param _transaction_sets [Array<Eddy::TransactionSet>]
@@ -21,7 +22,36 @@ module Eddy
 
     # @return [String]
     def render()
-      raise NotImplementedError
+      ctrl_num = Eddy::Data.new_interchange_control_number()
+      f_groups = self.functional_groups()
+      sep = self.store.segment_separator
+      isa = Eddy::Segments::ISA.new(self.store, ctrl_num)
+      iea = Eddy::Segments::IEA.new(self.store, ctrl_num, f_groups.length)
+      yield(isa, iea) if block_given?
+      return [isa, f_groups, iea].flatten.map(&:render).join(sep) + sep
+    end
+
+    # @return [Array<Eddy::FunctionalGroup>]
+    def functional_groups()
+      sorted_sets = {}
+      self.transaction_sets.each do |ts|
+        sorted_sets[ts.functional_group] ||= []
+        sorted_sets[ts.functional_group] << ts
+      end
+      return sorted_sets.map { |_, value| Eddy::FunctionalGroup.new(self.store, *value) }
+    end
+
+    private
+
+    # @raise [ArgumentError] Unless `transaction_set` is a subclass of {Eddy::TransactionSet}
+    # @param transaction_set [Eddy::TransactionSet]
+    # @return [void]
+    def verify_transaction_set(transaction_set)
+      raise ArgumentError unless transaction_set < Eddy::TransactionSet
+      raise ArgumentError unless transaction_set <= Eddy::TransactionSet
+      raise ArgumentError unless transaction_set.ancestors.include?(Eddy::TransactionSet)
+      raise ArgumentError unless transaction_set.superclass == Eddy::TransactionSet
+      return nil
     end
 
   end

data/lib/eddy/models/transaction_set.rb

@@ -55,16 +55,16 @@ module Eddy
 
     # Add `ST` and `SE` segments to the `components` array.
     #
-    # @param t_set_control_number [Integer] (Eddy::Data::Store#transaction_set_control_number)
+    # @param control_number [Integer] (Eddy::Data.new_transaction_set_control_number())
     # @return [void]
-    def add_envelope(t_set_control_number = self.store.transaction_set_control_number)
+    def add_envelope(control_number = Eddy::Data.new_transaction_set_control_number(self.id))
       st = Eddy::Segments::ST.new(self.store)
       st.TransactionSetIdentifierCode = self.id
-      st.TransactionSetControlNumber  = t_set_control_number
+      st.TransactionSetControlNumber  = control_number
 
       se = Eddy::Segments::SE.new(self.store)
       se.NumberOfIncludedSegments    = self.all_components.length + 2
-      se.TransactionSetControlNumber = t_set_control_number
+      se.TransactionSetControlNumber = control_number
 
       self.components.unshift(st)
       self.components.push(se)
@@ -77,8 +77,7 @@ module Eddy
     # @return [String]
     def render(s_sep = self.store.segment_separator)
       add_envelope()
-      e_sep = self.store.element_separator
-      return self.all_components.map { |s| s.render(e_sep) }.join(s_sep) + s_sep
+      return self.all_components.map { |s| s.render(self.store.element_separator) }.join(s_sep)
     end
 
     # Return all contained Segments in a single, flattened array.

data/lib/eddy/models.rb

@@ -5,7 +5,6 @@ require "eddy/models/loop/base"
 require "eddy/models/transaction_set"
 require "eddy/models/functional_group"
 require "eddy/models/interchange"
-require "eddy/models/simple_interchange"
 
 module Eddy
   # Classes modeling EDI components.

data/lib/eddy/version.rb

@@ -1,3 +1,3 @@
 module Eddy
-  VERSION = "0.4.0".freeze
+  VERSION = "0.5.0".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eddy
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Clay Dunston
@@ -1523,7 +1523,6 @@ files:
 - lib/eddy/models/loop/base.rb
 - lib/eddy/models/loop/repeat.rb
 - lib/eddy/models/segment.rb
-- lib/eddy/models/simple_interchange.rb
 - lib/eddy/models/transaction_set.rb
 - lib/eddy/parse.rb
 - lib/eddy/schema/element_summary.rb
@@ -1554,7 +1553,7 @@ metadata:
   homepage_uri: https://github.com/tcd/eddy
   source_code_uri: https://github.com/tcd/eddy
   changelog_uri: https://github.com/tcd/eddy/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/eddy/0.4.0
+  documentation_uri: https://www.rubydoc.info/gems/eddy/0.5.0
   yard.run: yri
 post_install_message: 
 rdoc_options: []

data/lib/eddy/models/simple_interchange.rb

@@ -1,57 +0,0 @@
-module Eddy
-  # An EDI interchange with one Transaction Set.
-  class SimpleInterchange
-    # @return [Eddy::Data::Store] Data store for the Interchange and all encompassed components.
-    attr_accessor :store
-    # @return [Eddy::TransactionSet]
-    attr_accessor :transaction_set
-    # @return [Array]
-    attr_accessor :components
-
-    # Initialize an interchange with one Functional Group containing one Transaction Set.
-    #
-    # @param transaction_set [Eddy::TransactionSet]
-    # @param store [Eddy::Data::Store] (Eddy::Data::Store.new)
-    # @return [void]
-    def initialize(transaction_set, store: Eddy::Data::Store.new())
-      self.components = []
-      self.transaction_set = transaction_set
-      self.store = store
-      self.store.number_of_transaction_sets_included  = 1
-      self.store.number_of_included_functional_groups = 1
-    end
-
-    # @yieldparam [Eddy::Segments::ISA] isa
-    # @yieldparam [Eddy::Segments::IEA] iea
-    # @yieldparam [Eddy::Segments::GS] gs
-    # @yieldparam [Eddy::Segments::GE] ge
-    # @return [String]
-    def render()
-      itch_ctrl_num = Eddy::Data.new_interchange_control_number()
-      isa = Eddy::Segments::ISA.new(store, itch_ctrl_num)
-      iea = Eddy::Segments::IEA.new(store, itch_ctrl_num)
-      number_of_included_functional_groups = self.store.number_of_included_functional_groups
-      gs = Eddy::Segments::GS.new(store, number_of_included_functional_groups, self.transaction_set)
-      ge = Eddy::Segments::GE.new(store, number_of_included_functional_groups)
-      yield(isa, iea, gs, ge) if block_given?
-      self.components.prepend(gs)
-      self.components.prepend(isa)
-      self.components.append(ge)
-      self.components.append(iea)
-      segments = self.components.map(&:render).flatten().join(store.segment_separator) + store.segment_separator
-      return segments
-    end
-
-    # @raise [ArgumentError] Unless `transaction_set` is a subclass of {Eddy::TransactionSet}
-    # @param transaction_set [Eddy::TransactionSet]
-    # @return [void]
-    def verify_transaction_set(transaction_set)
-      raise ArgumentError unless transaction_set < Eddy::TransactionSet
-      raise ArgumentError unless transaction_set <= Eddy::TransactionSet
-      raise ArgumentError unless transaction_set.ancestors.include?(Eddy::TransactionSet)
-      raise ArgumentError unless transaction_set.superclass == Eddy::TransactionSet
-      return nil
-    end
-
-  end
-end