eddy 0.1.0 → 0.3.0

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

@@ -0,0 +1,6 @@
+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
+  end
+end

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

@@ -0,0 +1,100 @@
+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
+
+      # 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
+        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}"
+          end
+        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"
+        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
+        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
+
+      # @return [Array<Symbol>]
+      def accepted_formats()
+        return [:yymmdd, :ccyymmdd]
+      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

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

@@ -0,0 +1,58 @@
+module Eddy
+  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
+
+      # @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
+      end
+
+      # @param arg [String]
+      # return [void]
+      def value=(arg)
+        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 [Array<String>]
+      def code_list()
+        raise NotImplementedError, "Each ID element must define its own code_list"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Eddy
+  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
+
+      # @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}"
+          end
+        end
+        return self.process_value()
+      end
+
+      # @raise [Eddy::Errors::ElementValidationError]
+      # @param arg [Numeric]
+      # @return [void]
+      def value=(arg)
+        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 [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)
+          else
+            return sprintf("%0#{min}d", val.round(2))
+          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

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

@@ -0,0 +1,84 @@
+require "bigdecimal"
+
+module Eddy
+  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
+
+      # @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 process(@val)
+      end
+
+      # @param arg [Numeric]
+      # @raise [ArgumentError] Unless passed a Numeric value.
+      # @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?(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
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+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
+
+      # 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
+        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}"
+          end
+        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"
+        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
+        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
+
+      # @return [Array<Symbol>]
+      def accepted_formats()
+        return [:hhmm, :hhmmss, :hhmmssd, :hhmmssdd]
+      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