eddy 0.1.0 → 0.3.0

data/lib/eddy/data/persistence/memory.rb

@@ -0,0 +1,65 @@
+module Eddy
+  module Data
+    module Persistence
+      # Persist data as an object in memory.
+      class Memory < Base
+
+        # @return [void]
+        def initialize()
+          @data = {
+            interchange_control_numbers: [],
+            functional_group_control_numbers: {},
+            transaction_set_control_numbers: {},
+          }
+        end
+
+        # @return [Array<Integer>]
+        def interchange_control_numbers()
+          return @data[:interchange_control_numbers]
+        end
+
+        # @param functional_group [String]
+        # @return [Array<Integer>]
+        def functional_group_control_numbers(functional_group)
+          unless @data[:functional_group_control_numbers].key?(functional_group)
+            @data[:functional_group_control_numbers][functional_group] = []
+          end
+          return @data[:functional_group_control_numbers][functional_group]
+        end
+
+        # @param transaction_set_id [String]
+        # @return [Array<Integer>]
+        def transaction_set_control_numbers(transaction_set_id)
+          unless @data[:transaction_set_control_numbers].key?(transaction_set_id)
+            @data[:transaction_set_control_numbers][transaction_set_id] = []
+          end
+          return @data[:transaction_set_control_numbers][transaction_set_id]
+        end
+
+        # @param new_ctrl_num [Integer]
+        # @return [void]
+        def add_interchange_control_number(new_ctrl_num)
+          self.interchange_control_numbers.append(new_ctrl_num)
+          return nil
+        end
+
+        # @param functional_group [String]
+        # @param new_ctrl_num [Integer]
+        # @return [void]
+        def add_functional_group_control_number(functional_group, new_ctrl_num)
+          self.functional_group_control_numbers(functional_group).append(new_ctrl_num)
+          return nil
+        end
+
+        # @param transaction_set_id [String]
+        # @param new_ctrl_num [Integer]
+        # @return [void]
+        def add_transaction_set_control_number(transaction_set_id, new_ctrl_num)
+          self.transaction_set_control_numbers(transaction_set_id).append(new_ctrl_num)
+          return nil
+        end
+
+      end
+    end
+  end
+end

data/lib/eddy/data/store.rb

@@ -0,0 +1,108 @@
+require "time"
+
+module Eddy
+  module Data
+    # Container used to distribute state throughout an Interchange.
+    class Store
+
+      # Time value for use by DT/TM Elements.
+      # @return [Time]
+      attr_accessor :time
+
+      # Component Element Separator
+      #
+      # Used by:
+      #
+      # - Eddy::Elements::I15
+      #
+      # @return [String] (">")
+      attr_accessor :component_separator
+      # @return [String] ("~")
+      attr_accessor :segment_separator
+      # Data Element Separator
+      # @return [String] ("*")
+      attr_accessor :element_separator
+      # QUESTION: is this the same as `component_separator`?
+      #
+      # See:
+      #
+      # - [Repeating Data Elements - X12 RFI](http://www.x12.org/rfis/Repeating%20Data%20Elements.pdf)
+      # @return [String]
+      attr_accessor :repitition_separator
+
+      # Used by:
+      #
+      # - Eddy::Elements::I11
+      #
+      # @return [String] ("00401")
+      attr_accessor :edi_version
+
+      # Version / Release / Industry Identifier Code
+      #
+      # Used by:
+      #
+      # - Eddy::Elements::E480
+      #
+      # @return [String]
+      attr_accessor :version_release_industry_id_code
+
+      # Total number of transaction sets included in the functional group or interchange (transmission) group.
+      # @return [Integer]
+      attr_accessor :number_of_transaction_sets_included
+      # A count of the number of functional groups included in an interchange.
+      # @return [Integer]
+      attr_accessor :number_of_included_functional_groups
+
+      # Application Sender's Code
+      # Code identifying party sending transmission; codes agreed to by trading partners
+      # @return [String]
+      attr_accessor :application_senders_code
+      # Application Receiver's Code
+      # Code identifying party receiving transmission. Codes agreed to by trading partners
+      # @return [String]
+      attr_accessor :application_receivers_code
+
+      # @param time [Time]
+      # @return [void]
+      def initialize(time: Time.now().utc())
+        self.time = time
+        self.component_separator = ">"
+        self.segment_separator   = "~"
+        self.element_separator   = "*"
+        self.edi_version = "00401"
+        self.number_of_included_functional_groups = 0
+        self.number_of_transaction_sets_included  = 0
+        self.application_senders_code = "sender_id"
+        self.application_receivers_code = "receiver_id"
+        self.version_release_industry_id_code = "004010"
+        @group_control_number = 1
+      end
+
+      # FIXME: not implemented
+      #
+      # @return [Integer]
+      def interchange_control_number()
+        # raise NotImplementedError
+        return 1
+      end
+
+      # FIXME: not implemented
+      #
+      # @return [Integer]
+      def transaction_set_control_number()
+        # raise NotImplementedError
+        return 1
+      end
+
+      # Returns an incremended value every time it's called.
+      #
+      # @return [Integer]
+      def group_control_number()
+        old_count = @group_control_number.dup
+        @group_control_number += 1
+        return old_count
+      end
+    end
+
+  end
+end

data/lib/eddy/errors.rb

@@ -0,0 +1,112 @@
+module 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}.
+    class ElementValidationError < Error
+      # @return [Eddy::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.
+      # @return [void]
+      def initialize(msg = "", element: nil)
+        self.element = element unless element.nil?
+        msg = "Invalid value assigned to element #{element_description()}. " << msg
+        super(msg)
+      end
+
+      # @return [String]
+      def element_description()
+        el = self.element
+        return "" if el.nil?
+        description = ""
+        if !el.ref.nil? && el.ref.length > 0
+          description << el.ref
+        else
+          description << el.class.name.split("::").last
+        end
+        description << " (#{el.name})"
+        return description
+      end
+    end
+
+    # 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 msg [String] (nil)
+      # @return [void]
+      def initialize(msg = "", element:)
+        self.element = element
+        if msg.length == 0
+          msg << "This element requires a value but none was set."
+        end
+        super(msg)
+      end
+    end
+
+    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Element::Base} class.
+    class TypeValidationError < ElementValidationError
+      # @param element [Eddy::Element::Base] Element instance that raised the exception.
+      # @param arg [Object] Passed argument that caused the exception.
+      # @param msg [String] ("")
+      # @return [void]
+      def initialize(msg = "", element:, arg:)
+        self.element = element
+        self.arg = arg
+        if msg.length == 0
+          msg << "Value must to be a #{wanted_type(element)}; recieved #{self.arg} (#{self.arg.class.name})"
+        end
+        super(msg)
+      end
+
+      # @param el [Eddy::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"
+               end
+      end
+    end
+
+    # Exception raised when an invalid argument is passed to the `value=` method of an {Eddy::Element::Base} class.
+    class LengthValidationError < ElementValidationError
+
+      # @param element [Eddy::Element::Base] Element instance that raised the exception.
+      # @param arg [Object] Passed argument that caused the exception.
+      # @param msg [String] ("")
+      # @return [void]
+      def initialize(msg = "", element:, arg:)
+        self.element = element
+        self.arg = arg
+        if msg.length == 0
+          msg << "Value can't be longer than #{self.element.max}. "
+          msg << "Length of recieved value: #{self.arg.to_s.length}"
+        end
+        super(msg)
+      end
+    end
+
+    # @!endgroup Element Validation Errors
+
+    # Exception raised when an issue occurs while generating code.
+    class BuildError < Error; end
+
+    # Exception raised from a `render` method.
+    class RenderError < Error; end
+
+    # Exception raised when a definition file can't be found.
+    class MissingDefinitionError < Error; end
+  end
+end

data/lib/eddy/models/element.rb

@@ -0,0 +1,14 @@
+module Eddy
+  # Base types for EDI Data Elements.
+  module Element; end
+end
+
+require "eddy/models/element/base"
+
+require "eddy/models/element/an"
+require "eddy/models/element/b"
+require "eddy/models/element/dt"
+require "eddy/models/element/id"
+require "eddy/models/element/n"
+require "eddy/models/element/r"
+require "eddy/models/element/tm"

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

@@ -0,0 +1,55 @@
+module Eddy
+  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
+
+      # @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
+
+      # @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
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+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
+
+      # @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}"
+          end
+        end
+      end
+
+      # @param _arg [Object] Whatever is to be assigned to `value`
+      # @return [void]
+      def value=(_arg)
+        super()
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Eddy
+  module Element
+    # Base class for EDI Data Element types.
+    class Base
+
+      # Positive number under 1688, or I01-I64
+      # @return [String]
+      attr_reader :id
+      # @return [String]
+      attr_reader :name
+      # @return [String]
+      attr_reader :description
+      # One of: AN, B, DT, ID, N, R, or TM
+      # @return [String]
+      attr_reader :type
+      # Minimum length for a valid value
+      # @return [Integer]
+      attr_reader :min
+      # Maximum length for a valid value
+      # @return [Integer]
+      attr_reader :max
+      # String used to identify a data element within a Segment.
+      # @return [String]
+      attr_accessor :ref
+
+      # # @return [void]
+      # def initialize(**kwargs)
+
+      # end
+
+      # @note Classes inheriting from `Eddy::Element::Base` must define the method `value`.
+      # @return [void]
+      def value(*)
+        raise NotImplementedError, "Classes inheriting from `Eddy::Element::Base` must define a `value` method."
+      end
+
+      # @note Classes inheriting from `Eddy::Element::Base` must define the method `value=`.
+      # @return [void]
+      def value=(*)
+        raise NotImplementedError, "Classes inheriting from `Eddy::Element::Base` must define a `value=` method."
+      end
+
+      # Indicates whether the value must be present in its segment.
+      #
+      # | code  | description |  official  |
+      # | ----- | ----------- | ---------- |
+      # | **M** | Mandatory   | yes        |
+      # | **O** | Optional    | yes        |
+      # | **C** | Conditional | yes        |
+      # | F     | Floating    | deprecated |
+      # | R     | Required    | no         |
+      # | S     | Situational | no         |
+      # | A     | Advised     | no         |
+      # | N     | Not Advised | no         |
+      # | N     | Not Used    | no         |
+      # | X     | Not Used    | no         |
+      # | X     | Conditional | no         |
+      #
+      # See:
+      #
+      # - [The Data Segment - EDIdEv](https://secure.edidev.net/edidev-ca/help/Using/Using_EDI/Using_AscX12/DataStructures/DataSegment/DataSegment.htm)
+      # - [Required vs Mandatory in Code Descriptions - X12 RFI](http://www.x12.org/rfis/Required%20vs%20Mandatory%20in%20Code%20Descriptions.pdf)
+      #
+      # @return [String]
+      def req
+        return @req
+      end
+
+      # (see #req)
+      #
+      # @param req [String, nil]
+      # @return [void]
+      def req=(req)
+        if req.nil?
+          @req = "O"
+          return
+        end
+        raise ArgumentError, req.to_s unless req.is_a?(String)
+        case req.upcase
+        when "M", "R" then @req = "M"
+        when "O"      then @req = "O"
+        when "C", "X" then @req = "C"
+        when "F" then raise Eddy::Errors::Error, "Req value 'F' not supported"
+        else raise Eddy::Errors::Error, "Invalid argument for `req=`: #{req}"
+        end
+      end
+
+      # Generate a description to use as a doc comment for an element.
+      #
+      # @param header [Boolean] (true)
+      # @return [Hash]
+      def doc_comment(header: true)
+        if header
+          return <<~END.strip
+            ### Element Summary:
+
+            - Id: #{self.id}
+            - Name: #{self.name}
+            - Type: #{self.type}
+            - Min/Max: #{self.min}/#{self.max}
+            - Description: #{self.description}
+          END
+        else
+          return <<~END.strip
+            - Id: #{self.id}
+            - Name: #{self.name}
+            - Type: #{self.type}
+            - Min/Max: #{self.min}/#{self.max}
+            - Description: #{self.description}
+          END
+        end
+      end
+
+    end
+  end
+end