eddy 0.5.0 → 0.8.1

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

@@ -1,84 +1,89 @@
 require "bigdecimal"
 
 module Eddy
-  module Element
-    # Decimal Numeric (decimal points must be transmitted if used).
-    class R < Base
+  module Models
+    module Element
+      # Decimal Numeric (decimal points must be transmitted if used).
+      class R < Base
 
-      # @param min [Integer]
-      # @param max [Integer]
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [Numeric] (nil)
-      # @return [void]
-      def initialize(
-        min:,
-        max:,
-        req: nil,
-        ref: nil,
-        val: nil
-      )
-        @type = "R"
-        @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 [Numeric] (nil)
+        # @return [void]
+        def initialize(
+          min:,
+          max:,
+          req: nil,
+          ref: nil,
+          val: nil
+        )
+          @type = "R"
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          self.value = val
+        end
 
-      # @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}"
+        # @param arg [Numeric]
+        # @raise [ArgumentError] Unless passed a Numeric value.
+        # @return [void]
+        def value=(arg)
+          if arg == :skip
+            @val = :skip
+            return
+          end
+          if arg.nil?()
+            @val = arg
+            return
           end
+          raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Numeric)
+          @val = arg
         end
-        return process(@val)
-      end
 
-      # @param arg [Numeric]
-      # @raise [ArgumentError] Unless passed a Numeric value.
-      # @return [void]
-      def value=(arg)
-        if arg.nil?
-          @val = arg
-          return
+        # @return [String]
+        def value()
+          return super()
         end
-        raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Numeric)
-        @val = arg
-      end
 
-      # Stringify a float value and trim to the element's `max` attribute.
-      #
-      # TODO: Use `sprintf` here?
-      #
-      # See:
-      #
-      # - [Ruby class types and case statements (Stack Overflow)](https://stackoverflow.com/questions/3908380/ruby-class-types-and-case-statements)
-      # - [Numbers and Class Hierarchy in Ruby (Medium)](https://medium.com/rubyinside/numbers-and-class-hierarchy-in-ruby-8c93c4749316)
-      #
-      # @param val [Numeric]
-      # @return [String]
-      def process(val)
-        case val
-        when Integer
-          return val.to_s.slice(0..self.max)
-        when Float
-          return val.to_s.slice(0..(self.max + 1))
-        when Complex
-          # TODO: Handle case
-          raise NotImplementedError
-        when Rational
-          # TODO: Handle case
-          raise NotImplementedError
-        when BigDecimal
-          # TODO: Handle case
-          raise NotImplementedError
+        # @return [String]
+        def process_value()
+          return self.class.process_value(@val, self.max)
+        end
+
+        # Stringify a numeric value and trim it to `max`.
+        #
+        # TODO: Use `sprintf` here?
+        #
+        # See:
+        #
+        # - [Ruby class types and case statements (Stack Overflow)](https://stackoverflow.com/questions/3908380/ruby-class-types-and-case-statements)
+        # - [Numbers and Class Hierarchy in Ruby (Medium)](https://medium.com/rubyinside/numbers-and-class-hierarchy-in-ruby-8c93c4749316)
+        #
+        # @param val [Numeric]
+        # @param max [Integer]
+        # @return [String]
+        def self.process_value(val, max)
+          case val
+          when Integer
+            return val.to_s.slice(0..max)
+          when Float
+            return val.to_s.slice(0..(max + 1))
+          when Complex
+            # TODO: Handle case
+            raise NotImplementedError
+          when Rational
+            # TODO: Handle case
+            raise NotImplementedError
+          when BigDecimal
+            # TODO: Handle case
+            raise NotImplementedError
+          end
         end
-      end
 
+      end
     end
   end
 end

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

@@ -1,113 +1,124 @@
 require "time"
 
 module Eddy
-  module Element
-    # Time in `HHMMSSDD` format.
-    # Time expressed in 24-hour clock time as follows:
-    # `HHMM`, or `HHMMSS`, or `HHMMSSD`, or `HHMMSSDD`
-    # where H = hours (00-23), M = minutes (00-59), S = integer seconds (00-59) and DD = decimal seconds;
-    # decimal seconds are expressed as follows:
-    # D = tenths (0-9) and DD = hundredths (00-99)
-    #
-    # Values for this type are generated from a *UTC* formatted [Time][time] object.
-    #
-    # [time]: https://ruby-doc.org/stdlib-2.6.5/libdoc/time/rdoc/Time.html
-    class TM < Base
+  module Models
+    module Element
+      # Time in `HHMMSSDD` format.
+      # Time expressed in 24-hour clock time as follows:
+      # `HHMM`, or `HHMMSS`, or `HHMMSSD`, or `HHMMSSDD`
+      # where H = hours (00-23), M = minutes (00-59), S = integer seconds (00-59) and DD = decimal seconds;
+      # decimal seconds are expressed as follows:
+      # D = tenths (0-9) and DD = hundredths (00-99)
+      #
+      # Values for this type are generated from a *UTC* formatted [Time][time] object.
+      #
+      # [time]: https://ruby-doc.org/stdlib-2.6.5/libdoc/time/rdoc/Time.html
+      class TM < Base
 
-      # Format for the date. Valid values: `:hhmm`, `:hhmmss`, `:hhmmssd`, and `:hhmmssdd`
-      # TODO: Decide if this should be an attr_accessor
-      # @return [Symbol<:hhmm, :hhmmss, :hhmmssd, :hhmmssdd>]
-      attr_reader :fmt
+        # Format for the date. Valid values: `:hhmm`, `:hhmmss`, `:hhmmssd`, and `:hhmmssdd`
+        # TODO: Decide if this should be an attr_accessor
+        # @return [Symbol<:hhmm, :hhmmss, :hhmmssd, :hhmmssdd>]
+        attr_reader :fmt
 
-      # TM elements require either a `fmt` value, or `min` and `max` values.
-      #
-      # @raise [ArgumentError] If an invalid format argument is passed.
-      # @param min [Integer] (nil)
-      # @param max [Integer] (nil)
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [Time] (nil)
-      # @param fmt [Symbol] (nil) Format for the date. Valid values: `:hhmm`, `:hhmmss`, `:hhmmssd`, and `:hhmmssdd`
-      # @return [void]
-      def initialize(
-        min: nil,
-        max: nil,
-        req: nil,
-        ref: nil,
-        val: nil,
-        fmt: nil
-      )
-        @type = "TM"
-        @min = min
-        @max = max
-        self.req = req
-        self.ref = ref
-        if fmt.nil?
-          raise ArgumentError, "TM elements require either a `fmt` value, or `min` and `max` values." if min.nil? || max.nil?
-          @fmt = determine_format()
-        else
-          self.fmt = fmt
+        # TM elements require either a `fmt` value, or `min` and `max` values.
+        #
+        # @raise [ArgumentError] If an invalid format argument is passed.
+        # @param min [Integer] (nil)
+        # @param max [Integer] (nil)
+        # @param req [String] (nil)
+        # @param ref [String] (nil)
+        # @param val [Time] (nil)
+        # @param fmt [Symbol] (nil) Format for the date. Valid values: `:hhmm`, `:hhmmss`, `:hhmmssd`, and `:hhmmssdd`
+        # @return [void]
+        def initialize(
+          min: nil,
+          max: nil,
+          req: nil,
+          ref: nil,
+          val: nil,
+          fmt: nil
+        )
+          @type = "TM"
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          if fmt.nil?
+            raise ArgumentError, "TM elements require either a `fmt` value, or `min` and `max` values." if min.nil? || max.nil?
+            @fmt = determine_format()
+          else
+            self.fmt = fmt
+          end
+          self.value = val
         end
-        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 [ElementValidationError] Unless passed a *UTC* formatted Time object.
+        # @param arg [Time] A *UTC* formatted `Time` object.
+        # @return [void]
+        def value=(arg)
+          if arg == :skip
+            @val = :skip
+            return
+          end
+          if arg.nil?()
+            @val = arg
+            return
           end
+          raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Time)
+          raise Eddy::Errors::ElementValidationError.new("Argument is not in UTC format", element: self) unless arg.utc?()
+          @val = arg
         end
-        case self.fmt
-        when :hhmm then return Eddy::Util::Time.hhmm(@val)
-        when :hhmmss then return Eddy::Util::Time.hhmmss(@val)
-        when :hhmmssd then return Eddy::Util::Time.hhmmssd(@val)
-        when :hhmmssdd then return Eddy::Util::Time.hhmmssdd(@val)
-        else raise Eddy::Errors::Error, "invalid fmt value for TM object"
+
+        # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
+        # @return [String]
+        def value()
+          return super()
         end
-      end
 
-      # @raise [ElementValidationError] Unless passed a *UTC* formatted Time object.
-      # @param arg [Time] A *UTC* formatted `Time` object.
-      # @return [void]
-      def value=(arg)
-        if arg.nil?
-          @val = arg
-          return
+        # @return [String]
+        def process_value()
+          return self.class.process_value(@val, self.fmt)
         end
-        raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Time)
-        raise Eddy::Errors::ElementValidationError.new("Argument is not in UTC format", element: self) unless arg.utc?()
-        @val = arg
-      end
 
-      # @param fmt [Symbol]
-      # @return [void]
-      def fmt=(fmt)
-        return if fmt.nil?
-        fmt = fmt.to_sym.downcase
-        raise ArgumentError unless accepted_formats.include?(fmt)
-        @fmt = fmt
-      end
+        # @param val [Time] A *UTC* formatted [Time](https://ruby-doc.org/stdlib-2.6.5/libdoc/time/rdoc/Time.html) object.
+        # @param fmt [Symbol]
+        # @return [String]
+        def self.process_value(val, fmt)
+          case fmt
+          when :hhmm then return Eddy::Util::Time.hhmm(val)
+          when :hhmmss then return Eddy::Util::Time.hhmmss(val)
+          when :hhmmssd then return Eddy::Util::Time.hhmmssd(val)
+          when :hhmmssdd then return Eddy::Util::Time.hhmmssdd(val)
+          else raise Eddy::Errors::Error, "invalid fmt value for TM object"
+          end
+        end
 
-      # @return [Array<Symbol>]
-      def accepted_formats()
-        return [:hhmm, :hhmmss, :hhmmssd, :hhmmssdd]
-      end
+        # @param fmt [Symbol]
+        # @return [void]
+        def fmt=(fmt)
+          return if fmt.nil?
+          fmt = fmt.to_sym.downcase
+          raise ArgumentError unless accepted_formats.include?(fmt)
+          @fmt = fmt
+        end
 
-      # @return [Symbol]
-      def determine_format()
-        case self.max
-        when 4 then return :hhmm
-        when 6 then return :hhmmss
-        when 7 then return :hhmmssd
-        when 8 then return :hhmmssdd
-        else raise Eddy::Errors::Error, "unable to determine format for TM element"
+        # @return [Array<Symbol>]
+        def accepted_formats()
+          return [:hhmm, :hhmmss, :hhmmssd, :hhmmssdd]
         end
-      end
 
+        # @return [Symbol]
+        def determine_format()
+          case self.max
+          when 4 then return :hhmm
+          when 6 then return :hhmmss
+          when 7 then return :hhmmssd
+          when 8 then return :hhmmssdd
+          else raise Eddy::Errors::Error, "unable to determine format for TM element"
+          end
+        end
+
+      end
     end
   end
 end

data/lib/eddy/models/functional_group.rb

@@ -1,35 +1,41 @@
 module Eddy
-  # A group of `Eddy::TransactionSet::Base` classes.
-  class FunctionalGroup
+  module Models
+    # A group of `Eddy::Models::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
-    # An array of Transaction Set instances.
-    # @return [Array<Eddy::TransactionSet>]
-    attr_accessor :transaction_sets
+      # @return [String]
+      attr_reader :id
+      # Data store for the Interchange and all encompassed components.
+      # @return [Eddy::Data::Store]
+      attr_accessor :store
+      # A unique control number for the Functional Group.
+      # @return [Integer]
+      attr_accessor :control_number
+      # An array of Transaction Set instances.
+      # @return [Array<Eddy::Models::TransactionSet>]
+      attr_accessor :transaction_sets
 
-    # @param store [Eddy::Data::Store]
-    # @param transaction_sets [Eddy::TransactionSet]
-    # @return [void]
-    def initialize(store, *transaction_sets)
-      self.store = store
-      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"
+      # @param store [Eddy::Data::Store]
+      # @param transaction_sets [Eddy::Models::TransactionSet]
+      # @return [void]
+      def initialize(store, *transaction_sets)
+        self.store = store
+        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
+        self.control_number = Eddy::Data.new_functional_group_control_number(@id)
       end
-      @id = self.transaction_sets.first.functional_group
-    end
 
-    # @return [Array<#render>]
-    def render()
-      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
+      # @return [Array<#render>]
+      def render()
+        gs = Eddy::Segments::GS.new(self.store, self.control_number, @id)
+        ge = Eddy::Segments::GE.new(self.store, self.control_number, self.transaction_sets.length)
+        return [gs, self.transaction_sets, ge].flatten.map(&:render)
+      end
 
+    end
   end
 end

data/lib/eddy/models/interchange.rb

@@ -1,58 +1,65 @@
 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
+      # A unique control number for the Interchange.
+      # @return [Integer]
+      attr_accessor :control_number
+      # @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.control_number = Eddy::Data.new_interchange_control_number()
+        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
+      # @yieldparam [Eddy::Segments::ISA] isa
+      # @yieldparam [Eddy::Segments::IEA] iea
+      # @return [String]
+      def render()
+        f_groups = self.functional_groups()
+        sep = self.store.segment_separator
+        isa = Eddy::Segments::ISA.new(self.store, self.control_number)
+        iea = Eddy::Segments::IEA.new(self.store, self.control_number, 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