eddy 0.5.0 → 0.8.1

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

@@ -1,6 +1,8 @@
 module Eddy
-  module Element
-    # - [References to Component Data Elements - X12 RFI](http://www.x12.org/rfis/References%20to%20Component%20Data%20Elements.pdf)
-    class Composite; end
+  module Models
+    module Element
+      # - [References to Component Data Elements - X12 RFI](http://www.x12.org/rfis/References%20to%20Component%20Data%20Elements.pdf)
+      class Composite; end
+    end
   end
 end

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

@@ -1,100 +1,111 @@
 require "time"
 
 module Eddy
-  module Element
-    # Date in `YYMMDD` or `CCYYMMDD` format based on EDI version being used (DLMS Baseline is 004010)
-    #
-    # 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 DT < Base
+  module Models
+    module Element
+      # Date in `YYMMDD` or `CCYYMMDD` format based on EDI version being used (DLMS Baseline is 004010)
+      #
+      # 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 DT < Base
 
-      # Format for the date. Valid values: `:yymmdd` or `:ccyymmdd`
-      # @return [Symbol<:yymmdd, :ccyymmdd>]
-      attr_reader :fmt
+        # Format for the date. Valid values: `:yymmdd` or `:ccyymmdd`
+        # @return [Symbol<:yymmdd, :ccyymmdd>]
+        attr_reader :fmt
 
-      # @param min [Integer] (nil)
-      # @param max [Integer] (nil)
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [Time] (nil) A *UTC* formatted Time object.
-      # @param fmt [Symbol] (nil) Format for the date. Valid values: `:yymmdd` or `:ccyymmdd`.
-      # @return [void]
-      def initialize(
-        min: nil,
-        max: nil,
-        req: nil,
-        ref: nil,
-        val: nil,
-        fmt: nil
-      )
-        @type = "DT"
-        @min = min
-        @max = max
-        self.req = req
-        self.ref = ref
-        if fmt.nil?
-          raise ArgumentError, "DT elements require either a `fmt` value, or `min` and `max` values." if min.nil? || max.nil?
-          @fmt = determine_format()
-        else
-          self.fmt = fmt
+        # @param min [Integer] (nil)
+        # @param max [Integer] (nil)
+        # @param req [String] (nil)
+        # @param ref [String] (nil)
+        # @param val [Time] (nil) A *UTC* formatted Time object.
+        # @param fmt [Symbol] (nil) Format for the date. Valid values: `:yymmdd` or `:ccyymmdd`.
+        # @return [void]
+        def initialize(
+          min: nil,
+          max: nil,
+          req: nil,
+          ref: nil,
+          val: nil,
+          fmt: nil
+        )
+          @type = "DT"
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          if fmt.nil?
+            raise ArgumentError, "DT 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](https://ruby-doc.org/stdlib-2.6.5/libdoc/time/rdoc/Time.html) 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 passed is not in UTC format", element: self) unless arg.utc?()
+          @val = arg
         end
-        case self.fmt
-        when :yymmdd then return Eddy::Util::Time.yymmdd(@val)
-        when :ccyymmdd then return Eddy::Util::Time.ccyymmdd(@val)
-        else raise Eddy::Errors::Error "invalid fmt value for DT 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](https://ruby-doc.org/stdlib-2.6.5/libdoc/time/rdoc/Time.html) 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 passed 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, "Invalid fmt for DT value: #{fmt}" 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 :yymmdd then return Eddy::Util::Time.yymmdd(val)
+          when :ccyymmdd then return Eddy::Util::Time.ccyymmdd(val)
+          else raise Eddy::Errors::Error "invalid fmt value for DT object"
+          end
+        end
 
-      # @return [Array<Symbol>]
-      def accepted_formats()
-        return [:yymmdd, :ccyymmdd]
-      end
+        # @param fmt [Symbol]
+        # @return [void]
+        def fmt=(fmt)
+          return if fmt.nil?
+          fmt = fmt.to_sym.downcase
+          raise ArgumentError, "Invalid fmt for DT value: #{fmt}" unless accepted_formats.include?(fmt)
+          @fmt = fmt
+        end
 
-      # @return [Symbol]
-      def determine_format()
-        case self.max
-        when 6 then return :yymmdd
-        when 8 then return :ccyymmdd
-        else raise Eddy::Errors::Error, "unable to determine format for dt element"
+        # @return [Array<Symbol>]
+        def accepted_formats()
+          return [:yymmdd, :ccyymmdd]
         end
-      end
 
+        # @return [Symbol]
+        def determine_format()
+          case self.max
+          when 6 then return :yymmdd
+          when 8 then return :ccyymmdd
+          else raise Eddy::Errors::Error, "unable to determine format for dt element"
+          end
+        end
+
+      end
     end
   end
 end

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

@@ -1,58 +1,68 @@
 module Eddy
-  module Element
-    # Identifier (works with a code list specified by the dictionary).
-    class ID < Base
+  module Models
+    module Element
+      # Identifier (works with a code list specified by the dictionary).
+      class ID < 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 = "ID"
-        @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 = "ID"
+          @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}"
+        # @param arg [String]
+        # return [void]
+        def value=(arg)
+          if arg == :skip
+            @val = :skip
+            return
           end
+          if arg.nil?()
+            @val = arg
+            return
+          end
+          raise Eddy::Errors::ElementValidationError.new("Value not present in code list: #{arg}", element: self) unless self.code_list().include?(arg)
+          @val = arg
         end
-        return @val
-      end
 
-      # @param arg [String]
-      # return [void]
-      def value=(arg)
-        if arg.nil?
-          @val = arg
-          return
+        # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
+        # @return [String]
+        def value()
+          return super()
         end
-        raise Eddy::Errors::ElementValidationError.new("Value not present in code list: #{arg}", element: self) unless self.code_list().include?(arg)
-        @val = arg
-      end
 
-      # @return [Array<String>]
-      def code_list()
-        raise NotImplementedError, "Each ID element must define its own code_list"
-      end
+        # @return [String]
+        def process_value()
+          return self.class.process_value(@val)
+        end
+
+        # @param val [String] Original value.
+        # @return [String]
+        def self.process_value(val)
+          return val
+        end
 
+        # @return [Array<String>]
+        def code_list()
+          raise NotImplementedError, "Each ID element must define its own code_list"
+        end
+
+      end
     end
   end
 end

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

@@ -1,94 +1,92 @@
 module Eddy
-  module Element
-    # Numeric (implies the number of decimal points, e.g., N2 would be two decimal positions)
-    class N < Base
+  module Models
+    module Element
+      # Numeric (implies the number of decimal points, e.g., N2 would be two decimal positions)
+      class N < Base
 
-      # *Implied* number of decimal points.
-      # @return [Integer]
-      attr_accessor :decimals
+        # *Implied* number of decimal points.
+        # @return [Integer]
+        attr_accessor :decimals
 
-      # @param min [Integer]
-      # @param max [Integer]
-      # @param req [String] (nil)
-      # @param ref [String] (nil)
-      # @param val [Numeric] (nil)
-      # @param decimals [Integer] (0)
-      # @return [void]
-      def initialize(
-        min:,
-        max:,
-        req: nil,
-        ref: nil,
-        val: nil,
-        decimals: 0
-      )
-        @min = min
-        @max = max
-        self.req = req
-        self.ref = ref
-        self.decimals = decimals
-        self.value = val
-      end
+        # @param min [Integer]
+        # @param max [Integer]
+        # @param req [String] (nil)
+        # @param ref [String] (nil)
+        # @param val [Numeric] (nil)
+        # @param decimals [Integer] (0)
+        # @return [void]
+        def initialize(
+          min:,
+          max:,
+          req: nil,
+          ref: nil,
+          val: nil,
+          decimals: 0
+        )
+          @min = min
+          @max = max
+          self.req = req
+          self.ref = ref
+          self.decimals = decimals
+          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::ElementValidationError]
+        # @param arg [Numeric]
+        # @return [void]
+        def value=(arg)
+          if arg == :skip
+            @val = :skip
+            return
           end
+          if arg.nil?()
+            @val = nil
+            return
+          end
+          raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Numeric)
+          @val = arg
         end
-        return self.process_value()
-      end
 
-      # @raise [Eddy::Errors::ElementValidationError]
-      # @param arg [Numeric]
-      # @return [void]
-      def value=(arg)
-        if arg.nil?
-          @val = nil
-          return
+        # @raise [Eddy::Errors::ElementNilValueError] If the element is required and no value has been set.
+        # @return [String]
+        def value()
+          return super()
         end
-        raise Eddy::Errors::TypeValidationError.new(element: self, arg: arg) unless arg.is_a?(Numeric)
-        @val = arg
-      end
 
-      # @return [String]
-      def process_value()
-        return self.class.process_value(
-          @val,
-          self.decimals,
-          min: self.min,
-          max: self.max,
-        )
-      end
+        # @return [String]
+        def process_value()
+          return self.class.process_value(
+            @val,
+            self.decimals,
+            min: self.min,
+            max: self.max,
+          )
+        end
 
-      # Convert a Float or Integer value to a valid EDI string representation.
-      # [Stas Spiridonov is a wizard](https://github.com/spiridonov/baldr/blob/master/lib/baldr/types.rb#L43).
-      #
-      # @param val [Numeric] Original value.
-      # @param decimals [Integer] *Implied* number of decimal points.
-      # @param min [Integer] (1) Minimum length for a valid value.
-      # @param max [Integer] (nil) Maximum length for a valid value.
-      # @return [String]
-      def self.process_value(val, decimals, min: 1, max: nil)
-        case val
-        when Integer
-          if (val - val.floor) == 0
-            return sprintf("%0#{min}d", val.truncate)
+        # Convert a Float or Integer value to a valid EDI string representation.
+        # [Stas Spiridonov is a wizard](https://github.com/spiridonov/baldr/blob/master/lib/baldr/types.rb#L43).
+        #
+        # @param val [Numeric] Original value.
+        # @param decimals [Integer] *Implied* number of decimal points.
+        # @param min [Integer] (1) Minimum length for a valid value.
+        # @param max [Integer] (nil) Maximum length for a valid value.
+        # @return [String]
+        def self.process_value(val, decimals, min: 1, max: nil)
+          case val
+          when Integer
+            if (val - val.floor) == 0
+              return sprintf("%0#{min}d", val.truncate)
+            else
+              return sprintf("%0#{min}d", val.round(2))
+            end
+          when Float
+            return (val * (10.0**decimals)).round.to_s
           else
-            return sprintf("%0#{min}d", val.round(2))
+            raise ArgumentError, "'val' must be a Float or an Integer."
           end
-          # return sprintf("%0#{min}d", val)
-        when Float
-          return (val * (10.0**decimals)).round.to_s
-        else
-          raise ArgumentError, "'val' must be a Float or an Integer."
         end
-      end
 
+      end
     end
   end
 end