eddy 0.5.1 → 0.6.0

data/lib/eddy/build/segment_builder.rb

@@ -6,7 +6,7 @@ module Eddy
     # Generate Ruby code from JSON/YAML EDI definitions.
     class SegmentBuilder
 
-      # @return [Eddy::Schema::SegmentSummary]
+      # @return [Eddy::Summary::Segment]
       attr_accessor :summary
       # @return [String] (nil)
       attr_accessor :folder
@@ -24,18 +24,18 @@ module Eddy
       # @param (see #initialize)
       # @return [Eddy::Build::SegmentBuilder]
       def self.from_file(path, **kwargs)
-        raise Eddy::Errors::Error, "Invalid segment definition" unless Eddy::Schema.valid_segment_data?(path)
+        raise Eddy::Errors::Error, "Invalid segment definition" unless Eddy::Summary.valid_segment_data?(path)
         data = Eddy::Util.read_json_or_yaml(path)
         sb = Eddy::Build::SegmentBuilder.new(**kwargs)
-        sb.summary = Eddy::Schema::SegmentSummary.create(data)
+        sb.summary = Eddy::Summary::Segment.create(data)
         return sb
       end
 
-      # @param summary [Eddy::Schema::SegmentSummary]
+      # @param summary [Eddy::Summary::Segment]
       # @param (see #initialize)
       # @return [Eddy::Build::SegmentBuilder]
       def self.from_summary(summary, **kwargs)
-        sb = Eddy::Build::SegmentBuilder.new(**kwargs)
+        sb = new(**kwargs)
         sb.summary = summary
         return sb
       end
@@ -54,12 +54,17 @@ module Eddy
         return result
       end
 
+      # @return [String]
+      def render()
+        return self.ginny_class.render()
+      end
+
       # @return [Ginny::Class]
       def ginny_class()
         return Ginny::Class.create({
           classify_name: false,
           modules: ["Eddy", "Segments"],
-          parent: "Eddy::Segment",
+          parent: "Eddy::Models::Segment",
           name: summary.id,
           description: summary.doc_comment(header: true),
           body: <<~STR,
@@ -116,8 +121,8 @@ module Eddy
         return defs.join("\n\n")
       end
 
-      # @param el [Eddy::Schema::ElementSummary]
-      # @param header [Symbol] (see Eddy::Schema::ElementSummary#doc_comment)
+      # @param el [Eddy::Summary::Element]
+      # @param header [Symbol] (see Eddy::Summary::Element#doc_comment)
       # @return [String]
       def self.element_accessor_v1(el, header: :summary)
         return <<~RB.strip
@@ -131,7 +136,7 @@ module Eddy
         RB
       end
 
-      # @param el [Eddy::Schema::ElementSummary]
+      # @param el [Eddy::Summary::Element]
       # @param dupes [Hash]
       # @param header [Boolean] (false)
       # @return [String]

data/lib/eddy/build/transaction_set_builder.rb

@@ -1,82 +1,82 @@
 require "ginny"
+require "forwardable"
 
 module Eddy
   module Build
     # Generate Ruby code from JSON/YAML EDI definitions.
-    #
-    # - Validate definition file
-    # - Create Summary
-    # - For Segments, check that we have a default definition for each.
-    #     - Generate segments?
-    # - For Elements, check that we have a default definition for each.
-    #     - Apply any input over default element attributes.
     class TransactionSetBuilder
+      extend Forwardable
 
-      # @return [Eddy::Schema::TransactionSetSummary]
+      # @return [Eddy::Summary::TransactionSet]
       attr_accessor :summary
-      # @return [String] (nil)
-      attr_accessor :folder
-      # @return [Boolean] (false)
-      attr_accessor :headers
 
+      # @param summary [Eddy::Summary::TransactionSet]
       # @param folder [String] (nil)
-      # @param headers [Boolean] (false)
       # @return [void]
-      def initialize(folder: nil, headers: false)
-        self.folder  = folder
-        self.headers = headers
+      def initialize(summary, folder: nil)
+        self.summary = summary
+        @folder = folder
       end
 
+      def_delegators(
+        :@summary,
+        :id,
+        :name,
+        :normalized_name,
+        :functional_group,
+      )
+
       # @param path [String] Path to a JSON or YAML file containing a valid Transaction Set definition.
       # @param (see #initialize)
       # @return [Eddy::Build::TransactionSetBuilder]
       def self.from_file(path, **kwargs)
-        raise Eddy::Errors::Error, "Invalid transaction set definition" unless Eddy::Schema.valid_transaction_set_data?(path)
+        raise Eddy::Errors::Error, "Invalid transaction set definition" unless Eddy::Summary.valid_transaction_set_data?(path)
         data = Eddy::Util.read_json_or_yaml(path)
-        builder = Eddy::Build::TransactionSetBuilder.new(**kwargs)
-        builder.summary = Eddy::Schema::TransactionSetSummary.create(data)
-        return builder
+        return new(Eddy::Summary::TransactionSet.create(data), **kwargs)
       end
 
-      # @param summary [Eddy::Schema::TransactionSetSummary]
-      # @param (see #initialize)
-      # @return [Eddy::Build::TransactionSetBuilder]
-      def self.from_summary(summary, **kwargs)
-        builder = Eddy::Build::TransactionSetBuilder.new(**kwargs)
-        builder.summary = summary
-        return builder
+      # @return [String]
+      def folder()
+        root_path = @folder || File.join(Eddy::Util.root_dir, "build", "transaction_sets")
+        path = File.join(root_path, self.id.to_s)
+        FileUtils.mkdir_p(path)
+        return path
       end
 
       # @return [String]
       def build()
-        root_path = self.folder || File.join(Eddy::Util.root_dir, "build", "transaction_sets")
-        path = File.join(root_path, self.summary.id.to_s)
-        FileUtils.mkdir_p(path)
-        File.open(File.join(path, "loops.rb"), "a") { |f| f.write(self.render_loops) }
-        return self.ginny_class.generate(path)
+        self.build_loops()
+        return self.ginny_class.generate(self.folder, file: "#{self.id}.rb")
       end
 
       # @return [String]
-      def render_loops()
-        loops = self.summary.unique_loops.map do |l|
-          Eddy::Build::LoopBuilder.from_summary(l, t_set_id: self.summary.normalized_name).ginny_class.render()
-        end.join("\n\n")
-        return Ginny.mod(("\n" + loops + "\n"), "Eddy", "TransactionSets", self.summary.normalized_name, "Loops")
+      def render()
+        return self.ginny_class.render()
+      end
+
+      # @return [String]
+      def build_loops()
+        FileUtils.mkdir_p(File.join(self.folder, "loops"))
+        self.summary.unique_loops.each do |looop|
+          File.open(File.join(self.folder, "loops", "#{looop.normalized_name}.rb"), "a") do |f|
+            f.write(Eddy::Build::Loop.render(looop, self.normalized_name) + "\n")
+          end
+        end
       end
 
       # @return [Ginny::Class]
       def ginny_class()
         return Ginny::Class.create({
           classify_name: false,
-          modules: ["Eddy", "TransactionSets", self.summary.normalized_name],
-          parent: "Eddy::TransactionSet",
-          name: self.summary.normalized_name,
+          modules: ["Eddy", "TransactionSets", self.normalized_name],
+          parent: "Eddy::Models::TransactionSet",
+          name: self.normalized_name,
           description: self.summary.doc_comment(header: true),
           body: <<~STR,
 
-            ID = "#{self.summary.id}".freeze
-            NAME = "#{self.summary.name}".freeze
-            FUNCTIONAL_GROUP = "#{self.summary.functional_group}".freeze
+            ID = "#{self.id}".freeze
+            NAME = "#{self.name}".freeze
+            FUNCTIONAL_GROUP = "#{self.functional_group}".freeze
 
             #{self.constructor()}
 
@@ -105,15 +105,10 @@ module Eddy
       def declarations()
         decs = ""
         self.summary.components.each do |comp|
-          case comp
-          when Eddy::Schema::SegmentSummary
+          if comp.is_a?(Eddy::Summary::Loop) && comp.repeat_limit > 1
+            decs << "@#{comp.var_name} = Eddy::TransactionSets::#{self.normalized_name}::Loops::#{comp.id.upcase}::Base.new(store)\n"
+          else
             decs << "@#{comp.id.downcase} = Eddy::Segments::#{comp.id.upcase}.new(store)\n"
-          when Eddy::Schema::LoopSummary
-            if comp.repeat == 1
-              decs << "@#{comp.id.downcase} = Eddy::Segments::#{comp.id.upcase}.new(store)\n"
-            else
-              decs << "@l_#{comp.id.downcase} = Eddy::TransactionSets::#{self.summary.normalized_name}::Loops::#{comp.id.upcase}.new(store)\n"
-            end
           end
         end
         return decs
@@ -124,15 +119,10 @@ module Eddy
         super_call = "super(\n"
         super_call << "  store,\n"
         self.summary.components.each do |comp|
-          case comp
-          when Eddy::Schema::SegmentSummary
+          if comp.is_a?(Eddy::Summary::Loop) && comp.repeat_limit > 1
+            super_call << "  @#{comp.var_name},\n"
+          else
             super_call << "  @#{comp.id.downcase},\n"
-          when Eddy::Schema::LoopSummary
-            if comp.repeat == 1
-              super_call << "  @#{comp.id.downcase},\n"
-            else
-              super_call << "  @l_#{comp.id.downcase},\n"
-            end
           end
         end
         super_call << ")"
@@ -144,15 +134,10 @@ module Eddy
       # @return [String]
       def accessors()
         defs = self.summary.components.map do |comp|
-          case comp
-          when Eddy::Schema::SegmentSummary
+          if comp.is_a?(Eddy::Summary::Loop) && comp.repeat_limit > 1
+            Eddy::Build::TransactionSetBuilder.loop_accessor(comp, self.normalized_name)
+          else
             Eddy::Build::TransactionSetBuilder.segment_accessor(comp.id)
-          when Eddy::Schema::LoopSummary
-            if comp.repeat == 1
-              Eddy::Build::TransactionSetBuilder.segment_accessor(comp.id)
-            else
-              Eddy::Build::TransactionSetBuilder.loop_accessor(comp, self.summary.normalized_name)
-            end
           end
         end
         return defs.join("\n\n")
@@ -166,7 +151,7 @@ module Eddy
         return <<~RB.strip
           # (see Eddy::Segments::#{upper})
           #
-          # @yieldparam [Eddy::Segments::#{upper}] #{lower}
+          # @yieldparam [Eddy::Segments::#{upper}]
           # @return [Eddy::Segments::#{upper}]
           def #{upper}()
             yield(@#{lower}) if block_given?
@@ -175,20 +160,18 @@ module Eddy
         RB
       end
 
-      # @param summary [Eddy::Schema::LoopSummary]
-      # @param t_set_name [String]
+      # @param summary [Eddy::Summary::Loop]
+      # @param t_set_id [String]
       # @return [String]
-      def self.loop_accessor(summary, t_set_name)
-        upper = summary.id.upcase
-        lower = summary.id.downcase
+      def self.loop_accessor(summary, t_set_id)
         return <<~RB.strip
-          # (see Eddy::TransactionSets::#{t_set_name}::Loops::#{upper})
+          # (see Eddy::TransactionSets::#{t_set_id}::Loops::#{summary.id.upcase}::Base)
           #
-          #{self.loop_components(summary, t_set_name)}
+          # @yieldparam [Eddy::TransactionSets::#{t_set_id}::Loops::#{summary.id.upcase}::Repeat]
           # @return [void]
-          def L_#{upper}(&block)
+          def #{summary.var_name.upcase}(&block)
             if block_given?
-              @l_#{lower}.add_iteration(&block)
+              @#{summary.var_name}.repeat(&block)
             else
               raise Eddy::Errors::Error, \"No block given in loop iteration\"
             end
@@ -197,22 +180,6 @@ module Eddy
         RB
       end
 
-      # @param summary [Eddy::Schema::LoopSummary]
-      # @param t_set_name [String]
-      # @return [String]
-      def self.loop_components(summary, t_set_name)
-        comps = []
-        summary.components.each do |comp|
-          case comp
-          when Eddy::Schema::SegmentSummary
-            comps << "# @yieldparam [Eddy::Segments::#{comp.id.upcase}] #{comp.id.downcase}"
-          when Eddy::Schema::LoopSummary
-            comps << "# @yieldparam [Eddy::TransactionSets::#{t_set_name}::Loops::#{comp.id.upcase}] l_#{comp.id.downcase}"
-          end
-        end
-        return comps.join("\n")
-      end
-
     end
   end
 end

data/lib/eddy/build.rb

@@ -2,7 +2,9 @@ require "fileutils"
 
 require "eddy/build/elements/elements"
 require "eddy/build/segment_builder"
-require "eddy/build/loop_builder"
+require "eddy/build/loop/base"
+require "eddy/build/loop/repeat"
+require "eddy/build/loop/render"
 require "eddy/build/transaction_set_builder"
 
 module Eddy

data/lib/eddy/errors.rb

@@ -1,20 +1,21 @@
 module Eddy
+  # Exceptions raised by Eddy.
   module Errors
     # Exceptions raised by Eddy inherit from Error.
     class Error < StandardError; end
 
     # @!group Element Validation Errors
 
-    # Exception raised by descendents of {Eddy::Element::Base}.
+    # Exception raised by descendents of {Eddy::Models::Element::Base}.
     class ElementValidationError < Error
-      # @return [Eddy::Element::Base] Element instance that raised the exception.
+      # @return [Eddy::Models::Element::Base] Element instance that raised the exception.
       attr_accessor :element
       # Argument that caused the exception when passed to `value=`. (if applicable)
       # @return [Object]
       attr_accessor :arg
 
       # @param msg [String] ("")
-      # @param element [Eddy::Element::Base] (nil) Element instance that raised the exception.
+      # @param element [Eddy::Models::Element::Base] (nil) Element instance that raised the exception.
       # @return [void]
       def initialize(msg = "", element: nil)
         self.element = element unless element.nil?
@@ -39,7 +40,7 @@ module Eddy
 
     # Exception raised when `value` has been called before `value=` and no default value is set.
     class ElementNilValueError < ElementValidationError
-      # @param element [Eddy::Element::Base] Element instance that raised the exception.
+      # @param element [Eddy::Models::Element::Base] Element instance that raised the exception.
       # @param msg [String] (nil)
       # @return [void]
       def initialize(msg = "", element:)
@@ -51,9 +52,9 @@ module Eddy
       end
     end
 
-    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Element::Base} class.
+    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Models::Element::Base} class.
     class TypeValidationError < ElementValidationError
-      # @param element [Eddy::Element::Base] Element instance that raised the exception.
+      # @param element [Eddy::Models::Element::Base] Element instance that raised the exception.
       # @param arg [Object] Passed argument that caused the exception.
       # @param msg [String] ("")
       # @return [void]
@@ -66,24 +67,24 @@ module Eddy
         super(msg)
       end
 
-      # @param el [Eddy::Element::Base] Element instance that raised the exception.
+      # @param el [Eddy::Models::Element::Base] Element instance that raised the exception.
       # @return [String]
       def wanted_type(el)
         return case el
-               when Eddy::Element::AN then "String"
-               when Eddy::Element::B  then "String"
-               when Eddy::Element::DT then "Time"
-               when Eddy::Element::TM then "Time"
-               when Eddy::Element::N  then "Float or Integer"
-               when Eddy::Element::R  then "Float or Integer"
+               when Eddy::Models::Element::AN then "String"
+               when Eddy::Models::Element::B  then "String"
+               when Eddy::Models::Element::DT then "Time"
+               when Eddy::Models::Element::TM then "Time"
+               when Eddy::Models::Element::N  then "Float or Integer"
+               when Eddy::Models::Element::R  then "Float or Integer"
                end
       end
     end
 
-    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Element::Base} class.
+    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Models::Element::Base} class.
     class LengthValidationError < ElementValidationError
 
-      # @param element [Eddy::Element::Base] Element instance that raised the exception.
+      # @param element [Eddy::Models::Element::Base] Element instance that raised the exception.
       # @param arg [Object] Passed argument that caused the exception.
       # @param msg [String] ("")
       # @return [void]

data/lib/eddy/models/element/an.rb

@@ -1,55 +1,57 @@
 module Eddy
-  module Element
-    # Alphanumeric string including special characters
-    class AN < Base
+  module Models
+    module Element
+      # Alphanumeric string including special characters
+      class AN < Base
 
-      # @param min [Integer]
-      # @param max [Integer]
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [String] (nil)
-      # @return [void]
-      def initialize(
-        min:,
-        max:,
-        req: nil,
-        ref: nil,
-        val: nil
-      )
-        @type = "AN"
-        @min = min
-        @max = max
-        self.req = req
-        self.ref = ref
-        self.value = val
-      end
+        # @param min [Integer]
+        # @param max [Integer]
+        # @param req [String] (nil)
+        # @param ref [String] (nil)
+        # @param val [String] (nil)
+        # @return [void]
+        def initialize(
+          min:,
+          max:,
+          req: nil,
+          ref: nil,
+          val: nil
+        )
+          @type = "AN"
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          self.value = val
+        end
 
-      # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
-      # @return [String]
-      def value()
-        if @val.nil?
-          case self.req
-          when "M"      then raise Eddy::Errors::ElementNilValueError.new(element: self)
-          when "O", "C" then return ""
-          else raise Eddy::Errors::Error, "Invalid req value: #{self.req}"
+        # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
+        # @return [String]
+        def value()
+          if @val.nil?
+            case self.req
+            when "M"      then raise Eddy::Errors::ElementNilValueError.new(element: self)
+            when "O", "C" then return ""
+            else raise Eddy::Errors::Error, "Invalid req value: #{self.req}"
+            end
           end
+          return @val.ljust(self.min)
         end
-        return @val.ljust(self.min)
-      end
 
-      # @raise [Eddy::Errors::ElementValidationError]
-      # @param arg [String]
-      # @return [void]
-      def value=(arg)
-        if arg.nil?
+        # @raise [Eddy::Errors::ElementValidationError]
+        # @param arg [String]
+        # @return [void]
+        def value=(arg)
+          if arg.nil?
+            @val = arg
+            return
+          end
+          raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(String)
+          raise Eddy::Errors::LengthValidationError.new(element: self, arg: arg) if arg.length > self.max
           @val = arg
-          return
         end
-        raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(String)
-        raise Eddy::Errors::LengthValidationError.new(element: self, arg: arg) if arg.length > self.max
-        @val = arg
-      end
 
+      end
     end
   end
 end

data/lib/eddy/models/element/b.rb

@@ -1,53 +1,55 @@
 module Eddy
-  module Element
-    # Binary Data.
-    # This type only occurs in the BIN segment.
-    #
-    # See:
-    #
-    # - [Maximum Length of Binary Data Element - X12 RFI](http://www.x12.org/rfis/Maximum%20Length%20of%20Binary%20Data%20Element.pdf)
-    class B < Base
+  module Models
+    module Element
+      # Binary Data.
+      # This type only occurs in the BIN segment.
+      #
+      # See:
+      #
+      # - [Maximum Length of Binary Data Element - X12 RFI](http://www.x12.org/rfis/Maximum%20Length%20of%20Binary%20Data%20Element.pdf)
+      class B < Base
 
-      # @param min [Integer]
-      # @param max [Integer]
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [String] (nil)
-      # @return [void]
-      def initialize(
-        min:,
-        max:,
-        req: nil,
-        ref: nil,
-        val: nil
-      )
-        @type = "B"
-        @min = min
-        @max = max
-        self.req = req
-        self.ref = ref
-        self.value = val
-      end
+        # @param min [Integer]
+        # @param max [Integer]
+        # @param req [String] (nil)
+        # @param ref [String] (nil)
+        # @param val [String] (nil)
+        # @return [void]
+        def initialize(
+          min:,
+          max:,
+          req: nil,
+          ref: nil,
+          val: nil
+        )
+          @type = "B"
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          self.value = val
+        end
 
-      # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
-      # @return [String<Binary>]
-      def value()
-        super()
-        if @val.nil?
-          case self.req
-          when "M"      then raise Eddy::Errors::ElementNilValueError.new(element: self)
-          when "O", "C" then return ""
-          else raise Eddy::Errors::Error, "Invalid req value: #{self.req}"
+        # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
+        # @return [String<Binary>]
+        def value()
+          super()
+          if @val.nil?
+            case self.req
+            when "M"      then raise Eddy::Errors::ElementNilValueError.new(element: self)
+            when "O", "C" then return ""
+            else raise Eddy::Errors::Error, "Invalid req value: #{self.req}"
+            end
           end
         end
-      end
 
-      # @param _arg [Object] Whatever is to be assigned to `value`
-      # @return [void]
-      def value=(_arg)
-        super()
-      end
+        # @param _arg [Object] Whatever is to be assigned to `value`
+        # @return [void]
+        def value=(_arg)
+          super()
+        end
 
+      end
     end
   end
 end