eddy 0.5.1 → 0.6.0

data/lib/definitions/transaction_sets/manual/856/loops/hl_order.rb

@@ -0,0 +1,59 @@
+module Eddy
+  module TransactionSets
+    module TS856
+      module Loops
+        module HL_Order
+
+          # ### Loop Summary:
+          #
+          # - Repeat: 1
+          # - Components:
+          #   - HL
+          #   - PRF
+          class Base < Eddy::Models::Loop::Base
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @repeat_limit = 1
+              super(store, Repeat)
+            end
+          end
+
+          # (see Eddy::TransactionSets::TS856::Loops::HL_Order::Base)
+          class Repeat < Eddy::Models::Loop::Repeat
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @hl = Eddy::Segments::HL.new(store)
+              @prf = Eddy::Segments::PRF.new(store)
+              super(
+                store,
+                @hl,
+                @prf,
+              )
+            end
+
+            # (see Eddy::Segments::HL)
+            #
+            # @yieldparam [Eddy::Segments::HL]
+            # @return [Eddy::Segments::HL]
+            def HL()
+              yield(@hl) if block_given?
+              return @hl
+            end
+
+            # (see Eddy::Segments::PRF)
+            #
+            # @yieldparam [Eddy::Segments::PRF]
+            # @return [Eddy::Segments::PRF]
+            def PRF()
+              yield(@prf) if block_given?
+              return @prf
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/definitions/transaction_sets/manual/856/loops/hl_shipment.rb

@@ -0,0 +1,159 @@
+module Eddy
+  module TransactionSets
+    module TS856
+      module Loops
+        module HL_Shipment
+
+          # ### Loop Summary:
+          #
+          # - Repeat: 200000
+          # - Components:
+          #   - HL
+          #   - TD1
+          #   - TD5
+          #   - REF
+          #   - DTM
+          #   - N1 (loop)
+          #   - HL_ORDER (loop)
+          #   - HL_TARE (loop)
+          #   - HL_ITEM (loop)
+          class Base < Eddy::Models::Loop::Base
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @repeat_limit = 200000
+              super(store, Repeat)
+            end
+          end
+
+          # (see Eddy::TransactionSets::TS856::Loops::HL_Shipment::Base)
+          class Repeat < Eddy::Models::Loop::Repeat
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @hl = Eddy::Segments::HL.new(store)
+              @td1 = Eddy::Segments::TD1.new(store)
+              @td5 = Eddy::Segments::TD5.new(store)
+              @ref = Eddy::Segments::REF.new(store)
+              @dtm = Eddy::Segments::DTM.new(store)
+              @l_n1 = Eddy::TransactionSets::TS856::Loops::N1::Base.new(store)
+              @hl_order = Eddy::TransactionSets::TS856::Loops::HL_Order::Base.new(store)
+              @hl_tare = Eddy::TransactionSets::TS856::Loops::HL_Tare::Base.new(store)
+              @hl_item = Eddy::TransactionSets::TS856::Loops::HL_Item::Base.new(store)
+              super(
+                store,
+                @hl,
+                @td1,
+                @td5,
+                @ref,
+                @dtm,
+                @l_n1,
+                @hl_order,
+                @hl_tare,
+                @hl_item,
+              )
+            end
+
+            # (see Eddy::Segments::HL)
+            #
+            # @yieldparam [Eddy::Segments::HL]
+            # @return [Eddy::Segments::HL]
+            def HL()
+              yield(@hl) if block_given?
+              return @hl
+            end
+
+            # (see Eddy::Segments::TD1)
+            #
+            # @yieldparam [Eddy::Segments::TD1]
+            # @return [Eddy::Segments::TD1]
+            def TD1()
+              yield(@td1) if block_given?
+              return @td1
+            end
+
+            # (see Eddy::Segments::TD5)
+            #
+            # @yieldparam [Eddy::Segments::TD5]
+            # @return [Eddy::Segments::TD5]
+            def TD5()
+              yield(@td5) if block_given?
+              return @td5
+            end
+
+            # (see Eddy::Segments::REF)
+            #
+            # @yieldparam [Eddy::Segments::REF]
+            # @return [Eddy::Segments::REF]
+            def REF()
+              yield(@ref) if block_given?
+              return @ref
+            end
+
+            # (see Eddy::Segments::DTM)
+            #
+            # @yieldparam [Eddy::Segments::DTM]
+            # @return [Eddy::Segments::DTM]
+            def DTM()
+              yield(@dtm) if block_given?
+              return @dtm
+            end
+
+            # (see Eddy::TransactionSets::TS856::Loops::N1::Base)
+            #
+            # @yieldparam [Eddy::TransactionSets::TS856::Loops::N1::Repeat]
+            # @return [void]
+            def L_N1(&block)
+              if block_given?
+                @l_n1.repeat(&block)
+              else
+                raise Eddy::Errors::Error, "No block given in loop iteration"
+              end
+              return nil
+            end
+
+            # (see Eddy::TransactionSets::TS856::Loops::HL_Order::Base)
+            #
+            # @yieldparam [Eddy::TransactionSets::TS856::Loops::HL_Order::Repeat]
+            # @return [void]
+            def HL_ORDER(&block)
+              if block_given?
+                @hl_order.repeat(&block)
+              else
+                raise Eddy::Errors::Error, "No block given in loop iteration"
+              end
+              return nil
+            end
+
+            # (see Eddy::TransactionSets::TS856::Loops::HL_Tare::Base)
+            #
+            # @yieldparam [Eddy::TransactionSets::TS856::Loops::HL_Tare::Repeat]
+            # @return [void]
+            def HL_TARE(&block)
+              if block_given?
+                @hl_tare.repeat(&block)
+              else
+                raise Eddy::Errors::Error, "No block given in loop iteration"
+              end
+              return nil
+            end
+
+            # (see Eddy::TransactionSets::TS856::Loops::HL_Item::Base)
+            #
+            # @yieldparam [Eddy::TransactionSets::TS856::Loops::HL_Item::Repeat]
+            # @return [Eddy::TransactionSets::TS856::Loops::HL_Item::Repeat]
+            def HL_ITEM(&block)
+              if block_given?
+                @hl_item.repeat(&block)
+              else
+                raise Eddy::Errors::Error, "No block given in loop iteration"
+              end
+              return nil
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/definitions/transaction_sets/manual/856/loops/hl_tare.rb

@@ -0,0 +1,59 @@
+module Eddy
+  module TransactionSets
+    module TS856
+      module Loops
+        module HL_Tare
+
+          # ### Loop Summary:
+          #
+          # - Repeat: 1
+          # - Components:
+          #   - HL
+          #   - MAN
+          class Base < Eddy::Models::Loop::Base
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @repeat_limit = 1
+              super(store, Repeat)
+            end
+          end
+
+          # (see Eddy::TransactionSets::TS856::Loops::HL_Tare::Base)
+          class Repeat < Eddy::Models::Loop::Repeat
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @hl = Eddy::Segments::HL.new(store)
+              @man = Eddy::Segments::MAN.new(store)
+              super(
+                store,
+                @hl,
+                @man,
+              )
+            end
+
+            # (see Eddy::Segments::HL)
+            #
+            # @yieldparam [Eddy::Segments::HL]
+            # @return [Eddy::Segments::HL]
+            def HL()
+              yield(@hl) if block_given?
+              return @hl
+            end
+
+            # (see Eddy::Segments::MAN)
+            #
+            # @yieldparam [Eddy::Segments::MAN]
+            # @return [Eddy::Segments::MAN]
+            def MAN()
+              yield(@man) if block_given?
+              return @man
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/definitions/transaction_sets/manual/856/loops/n1.rb

@@ -0,0 +1,71 @@
+module Eddy
+  module TransactionSets
+    module TS856
+      module Loops
+        module N1
+
+          # ### Loop Summary:
+          #
+          # - Repeat: 200
+          # - Components:
+          #   - N1
+          #   - N3
+          #   - N4
+          class Base < Eddy::Models::Loop::Base
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @repeat_limit = 200
+              super(store, Repeat)
+            end
+          end
+
+          # (see Eddy::TransactionSets::TS856::Loops::N1::Base)
+          class Repeat < Eddy::Models::Loop::Repeat
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @n1 = Eddy::Segments::N1.new(store)
+              @n3 = Eddy::Segments::N3.new(store)
+              @n4 = Eddy::Segments::N4.new(store)
+              super(
+                store,
+                @n1,
+                @n3,
+                @n4,
+              )
+            end
+
+            # (see Eddy::Segments::N1)
+            #
+            # @yieldparam [Eddy::Segments::N1]
+            # @return [Eddy::Segments::N1]
+            def N1()
+              yield(@n1) if block_given?
+              return @n1
+            end
+
+            # (see Eddy::Segments::N3)
+            #
+            # @yieldparam [Eddy::Segments::N3]
+            # @return [Eddy::Segments::N3]
+            def N3()
+              yield(@n3) if block_given?
+              return @n3
+            end
+
+            # (see Eddy::Segments::N4)
+            #
+            # @yieldparam [Eddy::Segments::N4]
+            # @return [Eddy::Segments::N4]
+            def N4()
+              yield(@n4) if block_given?
+              return @n4
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/definitions/transaction_sets/manual/856/loops/sln.rb

@@ -0,0 +1,44 @@
+module Eddy
+  module TransactionSets
+    module TS856
+      module Loops
+        module SLN
+
+          # ### Loop Summary:
+          #
+          # - Repeat: 1000
+          # - Components:
+          #   - SLN
+          class Base < Eddy::Models::Loop::Base
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @repeat_limit = 1000
+              super(store, Repeat)
+            end
+          end
+
+          # (see Eddy::TransactionSets::TS856::Loops::SLN::Base)
+          class Repeat < Eddy::Models::Loop::Repeat
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              @sln = Eddy::Segments::SLN.new(store)
+              super(store, @sln)
+            end
+
+            # (see Eddy::Segments::SLN)
+            #
+            # @yieldparam [Eddy::Segments::SLN]
+            # @return [Eddy::Segments::SLN]
+            def SLN()
+              yield(@sln) if block_given?
+              return @sln
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/eddy/build/elements/element.rb

@@ -4,7 +4,7 @@ module Eddy
   module Build
     module Elements
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @return [Array<Hash>]
       def self.element_params(el)
         return [
@@ -14,7 +14,7 @@ module Eddy
         ]
       end
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @return [String]
       def self.default_constructor(el)
         return Ginny::Func.create({
@@ -35,7 +35,7 @@ module Eddy
         }).render()
       end
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @param body [String]
       # @return [Ginny::Class]
       def self.ginny_class(el, body)
@@ -43,13 +43,13 @@ module Eddy
           classify_name: false,
           name:          Eddy::Util.normalize_id(el.id),
           description:   el.doc_comment,
-          parent:        "Eddy::Element::#{el.edi_type}",
+          parent:        "Eddy::Models::Element::#{el.edi_type}",
           modules:       ["Eddy", "Elements"],
           body:          body,
         })
       end
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
       # @return [void]
       def self.element(el, test: false)

data/lib/eddy/build/elements/elements.rb

@@ -9,7 +9,7 @@ module Eddy
 
       # Generate `Eddy::Element` classes for all data elements defined in `data/004010/elements.tsv`
       #
-      # @param elements [Array<Eddy::Schema::ElementSummary>]
+      # @param elements [Array<Eddy::Summary::Element>]
       # @return [void]
       def self.generate_elements(elements = self.generate_element_data())
         existing = (Eddy::Util.list_element_classes() + Eddy::Util.list_built_elements()).uniq()
@@ -31,12 +31,12 @@ module Eddy
 
       # Generate usable data from `data/004010/elements.tsv`.
       #
-      # @return [Array<Eddy::Schema::ElementSummary>]
+      # @return [Array<Eddy::Summary::Element>]
       def self.generate_element_data()
         data = Eddy::Util.raw_element_data()
         elements = data.map do |el|
           next if el[:type].nil? || el[:description].nil?
-          Eddy::Schema::ElementSummary.create(el)
+          Eddy::Summary::Element.create(el)
         end
         return elements.compact
       end

data/lib/eddy/build/elements/id.rb

@@ -4,7 +4,7 @@ module Eddy
   module Build
     module Elements
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
       # @return [void]
       def self.id(el, test: false)

data/lib/eddy/build/elements/n.rb

@@ -4,7 +4,7 @@ module Eddy
   module Build
     module Elements
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
       # @return [void]
       def self.n(el, test: false)

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

@@ -0,0 +1,49 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Loop
+      # Generate Ruby code from JSON/YAML EDI definitions.
+      class Base
+
+        # @return [Eddy::Summary::Loop]
+        attr_accessor :summary
+        # Namespace the Loop is within.
+        # @return [String]
+        attr_accessor :t_set_id
+
+        # @param summary [Eddy::Summary::Loop]
+        # @param t_set_id [String]
+        # @return [void]
+        def initialize(summary, t_set_id)
+          self.summary  = summary
+          self.t_set_id = t_set_id
+        end
+
+        # @return [String]
+        def render()
+          return self.ginny_class.render()
+        end
+
+        # @return [Ginny::Class]
+        def ginny_class()
+          return Ginny::Class.create({
+            classify_name: false,
+            parent: "Eddy::Models::Loop::Base",
+            name: "Base",
+            description: summary.doc_comment(header: true),
+            body: <<~STR.strip,
+              # @param store [Eddy::Data::Store]
+              # @return [void]
+              def initialize(store)
+                @repeat_limit = #{self.summary.repeat_limit}
+                super(store, Repeat)
+              end
+            STR
+          })
+        end
+
+      end
+    end
+  end
+end

data/lib/eddy/build/loop/render.rb

@@ -0,0 +1,18 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Loop
+      # Generate Ruby code for an EDI loop.
+      #
+      # @param summary [Eddy::Summary::Loop]
+      # @param t_set_id [String]
+      # @return [String]
+      def self.render(summary, t_set_id)
+        base = Eddy::Build::Loop::Base.new(summary, t_set_id).render()
+        repeat = Eddy::Build::Loop::Repeat.new(summary, t_set_id).render()
+        return Ginny.mod(("\n" + base + "\n\n" + repeat + "\n"), "Eddy", "TransactionSets", t_set_id, "Loops", summary.id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Loop
+      # Generate Ruby code from JSON/YAML EDI definitions.
+      class Repeat
+
+        # @return [Eddy::Summary::Loop]
+        attr_accessor :summary
+        # Namespace the Loop is within.
+        # @return [String]
+        attr_accessor :t_set_id
+
+        # @param summary [Eddy::Summary::Loop]
+        # @param t_set_id [String]
+        # @return [void]
+        def initialize(summary, t_set_id)
+          self.summary  = summary
+          self.t_set_id = t_set_id
+        end
+
+        # @return [String]
+        def render()
+          return self.ginny_class.render()
+        end
+
+        # @return [Ginny::Class]
+        def ginny_class()
+          return Ginny::Class.create({
+            classify_name: false,
+            parent: "Eddy::Models::Loop::Repeat",
+            name: "Repeat",
+            description: "(see Eddy::TransactionSets::#{t_set_id}::Loops::#{self.summary.id}::Base)",
+            body: <<~STR.strip,
+              # @param store [Eddy::Data::Store]
+              # @return [void]
+              def initialize(store)
+              #{self.declarations()}
+                super(
+                  store,
+                #{self.super_call()}
+                )
+              end
+
+              #{self.accessors()}
+            STR
+          })
+        end
+
+        # @return [String]
+        def super_call()
+          return self.summary.components.map do |comp|
+            case comp
+            when Eddy::Summary::Segment then "  @#{comp.id.downcase},"
+            when Eddy::Summary::Loop    then "  @#{comp.var_name},"
+            end
+          end.compact.join("\n  ")
+        end
+
+        # @return [String]
+        def declarations()
+          self.summary.components.map do |comp|
+            case comp
+            when Eddy::Summary::Segment then "  @#{comp.id.downcase} = Eddy::Segments::#{comp.id.upcase}.new(store)"
+            when Eddy::Summary::Loop    then "  @#{comp.var_name} = Eddy::TransactionSets::#{t_set_id}::Loops::#{comp.id.upcase}::Base.new(store)"
+            end
+          end.compact.join("\n")
+        end
+
+        # @return [String]
+        def accessors()
+          defs = self.summary.components.map do |comp|
+            if comp.is_a?(Eddy::Summary::Loop) && comp.repeat_limit > 1
+              Eddy::Build::TransactionSetBuilder.loop_accessor(comp, self.t_set_id)
+            else
+              Eddy::Build::TransactionSetBuilder.segment_accessor(comp.id)
+            end
+          end
+          return defs.join("\n\n")
+        end
+
+      end
+    end
+  end
+end