eddy 0.5.1 → 0.6.0

data/lib/eddy/models/interchange.rb

@@ -1,58 +1,60 @@
 module Eddy
-  # Top level EDI interchange.
-  class Interchange
-    # @return [Eddy::Data::Store] Data store for the Interchange.
-    attr_accessor :store
-    # @return [Array<Eddy::TransactionSet>]
-    attr_accessor :transaction_sets
+  module Models
+    # Top level EDI interchange.
+    class Interchange
+      # @return [Eddy::Data::Store] Data store for the Interchange.
+      attr_accessor :store
+      # @return [Array<Eddy::Models::TransactionSet>]
+      attr_accessor :transaction_sets
 
-    # @param store [Eddy::Data::Store] (Eddy::Data::Store.new)
-    # @return [void]
-    def initialize(store = Eddy::Data::Store.new())
-      self.store = store
-      self.transaction_sets = []
-    end
+      # @param store [Eddy::Data::Store] (Eddy::Data::Store.new)
+      # @return [void]
+      def initialize(store = Eddy::Data::Store.new())
+        self.store = store
+        self.transaction_sets = []
+      end
 
-    # @param _transaction_sets [Array<Eddy::TransactionSet>]
-    # @return [Eddy::Interchange]
-    def self.create(_transaction_sets)
-      itch = Eddy::Interchange.new()
-      return itch
-    end
+      # @param _transaction_sets [Array<Eddy::Models::TransactionSet>]
+      # @return [Eddy::Models::Interchange]
+      def self.create(_transaction_sets)
+        itch = Eddy::Models::Interchange.new()
+        return itch
+      end
 
-    # @return [String]
-    def render()
-      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 [String]
+      def render()
+        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
+      # @return [Array<Eddy::Models::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::Models::FunctionalGroup.new(self.store, *value) }
       end
-      return sorted_sets.map { |_, value| Eddy::FunctionalGroup.new(self.store, *value) }
-    end
 
-    private
+      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
+      # @raise [ArgumentError] Unless `transaction_set` is a subclass of {Eddy::Models::TransactionSet}
+      # @param transaction_set [Eddy::Models::TransactionSet]
+      # @return [void]
+      def verify_transaction_set(transaction_set)
+        raise ArgumentError unless transaction_set < Eddy::Models::TransactionSet
+        raise ArgumentError unless transaction_set <= Eddy::Models::TransactionSet
+        raise ArgumentError unless transaction_set.ancestors.include?(Eddy::Models::TransactionSet)
+        raise ArgumentError unless transaction_set.superclass == Eddy::Models::TransactionSet
+        return nil
+      end
 
+    end
   end
 end

data/lib/eddy/models/loop/base.rb

@@ -1,75 +1,74 @@
 module Eddy
-  module Loop
-    # A repeated collection of Segments and/or other Loops.
-    #
-    # See:
-    #
-    # - [HL Loop Structure in TS 837 - X12 RFI](http://www.x12.org/rfis/HL%20Loop%20Structure%20in%20TS%20837.pdf)
-    # - [HL Segment Content - X12 RFI](http://www.x12.org/rfis/HL%20Segment%20Content.pdf)
-    class Base
+  module Models
+    module Loop
+      # A repeated collection of Segments and/or other Loops.
+      #
+      # See:
+      #
+      # - [HL Loop Structure in TS 837 - X12 RFI](http://www.x12.org/rfis/HL%20Loop%20Structure%20in%20TS%20837.pdf)
+      # - [HL Segment Content - X12 RFI](http://www.x12.org/rfis/HL%20Segment%20Content.pdf)
+      class Base
 
-      # (Name) A unique string used to identify the Loop within its Transaction Set.
-      # This is not EDI standardized, any name will do.
-      # @return [String]
-      attr_reader :id
-      # Number of times a particular Loop may be repeated.
-      # @return [Integer]
-      attr_reader :repeat
-      # Defines if/how the Loop is required.
-      # @return [String]
-      attr_reader :req
-      # An array of Segments and/or other Loops.
-      # This is used as a template to populate `content`.
-      # @return [Array<Eddy::Segment, Eddy::Loop::Base>]
-      attr_reader :components
-      # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
-      attr_reader :store
-      # An array of loop iterations.
-      # @return [Array<Array>]
-      attr_accessor :content
+        # (Name) A unique string used to identify the Loop within its Transaction Set.
+        # This is not EDI standardized, any name will do.
+        # @return [String]
+        attr_reader :id
+        # Number of times a particular Loop may be repeated.
+        # @return [Integer]
+        attr_reader :repeat_limit
+        # Defines if/how the Loop is required.
+        # @return [String]
+        attr_reader :req
+        # Used to contain the components of a single loop iteration (or a single loop *repeat*).
+        # This value is a class, not an instance.
+        # @return [Eddy::Models::Loop::Repeat]
+        attr_reader :repeat_object
+        # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
+        attr_reader :store
+        # An array of loop iterations.
+        # @return [Array<Array>]
+        attr_accessor :content
 
-      # All of a Loop's elements need to be declared in its constructor.
-      #
-      # @param store [Eddy::Data::Store]
-      # @param components [Array<Eddy::Loop, Eddy::Segment>]
-      # @return [void]
-      def initialize(store, *components)
-        @store = store
-        components.flatten!
-        @components = components || []
-        @content = []
-      end
+        # All of a Loop's elements need to be declared in its constructor.
+        #
+        # @param store [Eddy::Data::Store]
+        # @param repeat_object [Eddy::Models::Loop::Repeat]
+        # @return [void]
+        def initialize(store, repeat_object)
+          @store = store
+          @repeat_object = repeat_object
+          @content = []
+        end
 
-      # Return all contained Segments in a single, flattened array.
-      #
-      # @return [Array<Eddy::Segment>]
-      def all_contents()
-        contents = self.content.flatten.map do |c|
-          if c.is_a?(Eddy::Loop::Base)
-            c.all_contents()
-          elsif c.is_a?(Eddy::Segment)
-          # elsif c < Eddy::Segment
-            c
-          else
-            raise Eddy::Errors::RenderError
+        # Return all contained Segments in a single, flattened array.
+        #
+        # @return [Array<Eddy::Models::Segment>]
+        def all_contents()
+          contents = self.content.flatten.map do |c|
+            case c
+            when Eddy::Models::Loop::Repeat then c.all_contents()
+            when Eddy::Models::Loop::Base   then c.all_contents()
+            when Eddy::Models::Segment      then c
+            else raise Eddy::Errors::RenderError
+            end
           end
+          return contents.flatten
         end
-        return contents.flatten
-      end
 
-      # @param block [Block]
-      # @return [void]
-      def add_iteration(&block)
-        iteration = self.components.map { |c| c.new(self.store) }
-        if block_given?
-          yield(*iteration)
-        else
-          raise Eddy::Errors::Error, "No block given in loop iteration"
+        # @param block [Block]
+        # @return [void]
+        def repeat(&block)
+          rep = self.repeat_object.new(self.store)
+          if block_given?
+            rep.repeat(&block)
+          else
+            raise Eddy::Errors::Error, "No block given in loop iteration"
+          end
+          self.content << rep
+          return nil
         end
-        self.content << iteration
-        return nil
-      end
 
+      end
     end
   end
 end

data/lib/eddy/models/loop/repeat.rb

@@ -1,42 +1,54 @@
 module Eddy
-  module Loop
-    # Data form a single loop iteration.
-    class Repeat
+  module Models
+    module Loop
+      # Data form a single loop iteration.
+      class Repeat
 
-      # An array of Segments and/or other Loops.
-      # This is used as a template to populate `content`.
-      # @return [Array<Eddy::Segment, Eddy::Loop::Base>]
-      attr_reader :components
-      # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
-      attr_reader :store
+        # An array of Segments and/or other Loops.
+        # This is used as a template to populate `content`.
+        # @return [Array<Eddy::Models::Segment, Eddy::Models::Loop::Base>]
+        attr_reader :components
+        # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
+        attr_reader :store
 
-      # All of a Loop's elements need to be declared in its constructor.
-      #
-      # @param store [Eddy::Data::Store]
-      # @param components [Array<Eddy::Loop, Eddy::Segment>]
-      # @return [void]
-      def initialize(store, *components)
-        @store = store
-        components.flatten!
-        @components = components || []
-      end
+        # All of a Loop's elements need to be declared in its constructor.
+        #
+        # @param store [Eddy::Data::Store]
+        # @param components [Array<Eddy::Models::Loop, Eddy::Models::Segment>]
+        # @return [void]
+        def initialize(store, *components)
+          @store = store
+          components.flatten!
+          @components = components || []
+        end
 
-      # Return all contained Segments in a single, flattened array.
-      #
-      # @return [Array<Eddy::Segment>]
-      def all_contents()
-        contents = self.content.flatten.map do |c|
-          if c.is_a?(Eddy::Loop::Base)
-            c.all_contents()
-          elsif c.is_a?(Eddy::Segment)
-            c
+        # Return all contained Segments in a single, flattened array.
+        #
+        # @return [Array<Eddy::Models::Segment>]
+        def all_contents()
+          contents = self.components.flatten.map do |c|
+            case c
+            when Eddy::Models::Loop::Repeat then c.all_contents()
+            when Eddy::Models::Loop::Base   then c.all_contents()
+            when Eddy::Models::Segment      then c
+            else raise Eddy::Errors::RenderError
+            end
+          end
+          return contents.flatten
+        end
+
+        # @yieldparam [self] rep
+        # @return [self]
+        def repeat()
+          if block_given?
+            yield(self)
           else
-            raise Eddy::Errors::RenderError
+            raise Eddy::Errors::Error, "No block given in loop iteration"
           end
+          return self
         end
-        return contents.flatten
-      end
 
+      end
     end
   end
 end

data/lib/eddy/models/segment.rb

@@ -1,35 +1,37 @@
 module Eddy
-  # Base class for EDI Segments.
-  class Segment
+  module Models
+    # Base class for EDI Segments.
+    class Segment
 
-    # An alphanumeric code unique to each Segment type.
-    # @return [String]
-    attr_reader :id
-    # Short name of the Segment.
-    # @return [String]
-    attr_reader :name
-    # @return [Array<Element>]
-    attr_accessor :elements
-    # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
-    attr_accessor :store
+      # An alphanumeric code unique to each Segment type.
+      # @return [String]
+      attr_reader :id
+      # Short name of the Segment.
+      # @return [String]
+      attr_reader :name
+      # @return [Array<Element>]
+      attr_accessor :elements
+      # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
+      attr_accessor :store
 
-    # All of a Segment's elements need to be declared in its constructor.
-    #
-    # @param store [Eddy::Data::Store]
-    # @param elements [Eddy::Element::Base]
-    # @return [void]
-    def initialize(store, *elements)
-      self.store = store
-      elements.flatten!
-      self.elements = elements || []
-    end
+      # All of a Segment's elements need to be declared in its constructor.
+      #
+      # @param store [Eddy::Data::Store]
+      # @param elements [Eddy::Models::Element::Base]
+      # @return [void]
+      def initialize(store, *elements)
+        self.store = store
+        elements.flatten!
+        self.elements = elements || []
+      end
 
-    # @param separator [String] (self.store.element_separator) String used to delimit elements within a segment.
-    # @return [String]
-    def render(separator = self.store.element_separator)
-      segment = [self.id, self.elements.map(&:value)].join(separator)
-      return Eddy::Util.trim_delims_from_segment(segment, separator: separator)
-    end
+      # @param separator [String] (self.store.element_separator) String used to delimit elements within a segment.
+      # @return [String]
+      def render(separator = self.store.element_separator)
+        segment = [self.id, self.elements.map(&:value)].join(separator)
+        return Eddy::Util.trim_delims_from_segment(segment, separator: separator)
+      end
 
+    end
   end
 end

data/lib/eddy/models/transaction_set.rb

@@ -1,100 +1,102 @@
 module Eddy
-  # Base class for EDI Transaction Sets.
-  class TransactionSet
+  module Models
+    # Base class for EDI Transaction Sets.
+    class TransactionSet
 
-    # @return [Integer]
-    ID = nil
-    # @return [String]
-    NAME = nil
-    # @return [String]
-    FUNCTIONAL_GROUP = nil
+      # @return [Integer]
+      ID = nil
+      # @return [String]
+      NAME = nil
+      # @return [String]
+      FUNCTIONAL_GROUP = nil
 
-    # @return [Array<Segment, Loop>]
-    attr_accessor :components
-    # @return [Eddy::Data::Store] Container used to distribute state throughout an Interchange.
-    attr_accessor :store
+      # @return [Array<Segment, Loop>]
+      attr_accessor :components
+      # @return [Eddy::Data::Store] Container used to distribute state throughout an Interchange.
+      attr_accessor :store
 
-    # @param store [Eddy::Data::Store]
-    # @param components [Array<Segment, Loop>]
-    # @return [void]
-    def initialize(store, *components)
-      self.store = store
-      components.flatten!
-      self.components = components || []
-    end
+      # @param store [Eddy::Data::Store]
+      # @param components [Array<Segment, Loop>]
+      # @return [void]
+      def initialize(store, *components)
+        self.store = store
+        components.flatten!
+        self.components = components || []
+      end
 
-    # @return [String]
-    def id
-      return self.class::ID
-    end
+      # @return [String]
+      def id
+        return self.class::ID
+      end
 
-    # @return [String]
-    def self.id
-      return self::ID
-    end
+      # @return [String]
+      def self.id
+        return self::ID
+      end
 
-    # @return [String]
-    def functional_group
-      return self.class::FUNCTIONAL_GROUP
-    end
+      # @return [String]
+      def functional_group
+        return self.class::FUNCTIONAL_GROUP
+      end
 
-    # @return [String]
-    def self.functional_group
-      return self::FUNCTIONAL_GROUP
-    end
+      # @return [String]
+      def self.functional_group
+        return self::FUNCTIONAL_GROUP
+      end
 
-    # @return [String]
-    def name
-      return self.class::NAME
-    end
+      # @return [String]
+      def name
+        return self.class::NAME
+      end
 
-    # @return [String]
-    def self.name
-      return self::NAME
-    end
+      # @return [String]
+      def self.name
+        return self::NAME
+      end
 
-    # Add `ST` and `SE` segments to the `components` array.
-    #
-    # @param control_number [Integer] (Eddy::Data.new_transaction_set_control_number())
-    # @return [void]
-    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  = control_number
+      # Add `ST` and `SE` segments to the `components` array.
+      #
+      # @param control_number [Integer] (Eddy::Data.new_transaction_set_control_number())
+      # @return [void]
+      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  = control_number
 
-      se = Eddy::Segments::SE.new(self.store)
-      se.NumberOfIncludedSegments    = self.all_components.length + 2
-      se.TransactionSetControlNumber = control_number
+        se = Eddy::Segments::SE.new(self.store)
+        se.NumberOfIncludedSegments    = self.all_components.length + 2
+        se.TransactionSetControlNumber = control_number
 
-      self.components.unshift(st)
-      self.components.push(se)
-    end
+        self.components.unshift(st)
+        self.components.push(se)
+      end
 
-    # This shouldn't be used.
-    # An Interchange or FunctionalGroup should call `all_components` and render those itself.
-    #
-    # @param s_sep [String] (self.store.segment_separator)
-    # @return [String]
-    def render(s_sep = self.store.segment_separator)
-      add_envelope()
-      return self.all_components.map { |s| s.render(self.store.element_separator) }.join(s_sep)
-    end
+      # This shouldn't be used.
+      # An Interchange or FunctionalGroup should call `all_components` and render those itself.
+      #
+      # @param s_sep [String] (self.store.segment_separator)
+      # @return [String]
+      def render(s_sep = self.store.segment_separator)
+        add_envelope()
+        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.
-    #
-    # @return [Array<Eddy::Segment>]
-    def all_components()
-      comps = self.components.map do |c|
-        if c.is_a?(Eddy::Loop::Base)
-          c.all_contents()
-        elsif c.is_a?(Eddy::Segment)
-          c
-        else
-          raise Eddy::Errors::RenderError
+      # Return all contained Segments in a single, flattened array.
+      #
+      # @return [Array<Eddy::Models::Segment>]
+      def all_components()
+        comps = self.components.map do |c|
+          if c.is_a?(Eddy::Models::Loop::Base)
+            c.all_contents()
+          elsif c.is_a?(Eddy::Models::Segment)
+            c
+          else
+            raise Eddy::Errors::RenderError
+          end
         end
+        return comps.flatten
       end
-      return comps.flatten
-    end
 
+    end
   end
 end

data/lib/eddy/models.rb

@@ -1,7 +1,7 @@
 require "eddy/models/element"
 require "eddy/models/segment"
 require "eddy/models/loop/base"
-# require "eddy/models/loop/repeat"
+require "eddy/models/loop/repeat"
 require "eddy/models/transaction_set"
 require "eddy/models/functional_group"
 require "eddy/models/interchange"

data/lib/eddy/{schema/element_summary.rb → summary/element.rb}

@@ -1,7 +1,7 @@
 module Eddy
-  module Schema
+  module Summary
     # An individual EDI Data Element. Used in Companion Guides to define requirements for a Segment.
-    class ElementSummary
+    class Element
 
       # Indicates the order in which Elements should appear in their Segment.
       # @return [String]
@@ -37,7 +37,7 @@ module Eddy
       # @param params [Hash] ({})
       # @return [self]
       def self.create(params = {})
-        summary = new()
+        summary = self.new()
         summary.ref          = params[:ref]&.strip
         summary.id           = params[:id]&.strip
         summary.name         = params[:name]&.strip