eddy 0.1.0 → 0.3.0

data/lib/eddy/models/loop.rb

@@ -0,0 +1,74 @@
+module Eddy
+  module Loop
+    # A repeated collection of Segments and/or other Loops.
+    #
+    # See:
+    #
+    # - [HL Loop Structure in TS 837 - X12 RFI](http://www.x12.org/rfis/HL%20Loop%20Structure%20in%20TS%20837.pdf)
+    # - [HL Segment Content - X12 RFI](http://www.x12.org/rfis/HL%20Segment%20Content.pdf)
+    class Base
+
+      # (Name) A unique string used to identify the Loop within its Transaction Set.
+      # @return [String]
+      attr_reader :loop_id
+      # Number of times a particular Loop may be repeated.
+      # @return [Integer]
+      attr_reader :repeat
+      # Defines if/how the Loop is required.
+      # @return [String]
+      attr_reader :req
+      # An array of Segments and/or other Loops.
+      # This is used as a template to populate `content`.
+      # @return [Array<Eddy::Segment, Eddy::Loop::Base>]
+      attr_reader :components
+      # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
+      attr_reader :store
+      # An array of loop iterations.
+      # @return [Array<Array>]
+      attr_accessor :content
+
+      # All of a Loop's elements need to be declared in its constructor.
+      #
+      # @param store [Eddy::Data::Store]
+      # @param components [Array<Eddy::Loop, Eddy::Segment>]
+      # @return [void]
+      def initialize(store, *components)
+        @store = store
+        components.flatten!
+        @components = components || []
+        @content = []
+      end
+
+      # Return all contained Segments in a single, flattened array.
+      #
+      # @return [Array<Eddy::Segment>]
+      def all_contents()
+        contents = self.content.flatten.map do |c|
+          if c.is_a?(Eddy::Loop::Base)
+            c.all_contents()
+          elsif c.is_a?(Eddy::Segment)
+          # elsif c < Eddy::Segment
+            c
+          else
+            raise Eddy::Errors::RenderError
+          end
+        end
+        return contents.flatten
+      end
+
+      # @param block [Block]
+      # @return [void]
+      def add_iteration(&block)
+        iteration = self.components.map { |c| c.new(self.store) }
+        if block_given?
+          yield(*iteration)
+        else
+          raise Eddy::Errors::Error, "No block given in loop iteration"
+        end
+        self.content << iteration
+        return nil
+      end
+
+    end
+  end
+end

data/lib/eddy/models/segment.rb

@@ -0,0 +1,35 @@
+module Eddy
+  # Base class for EDI Segments.
+  class Segment
+
+    # An alphanumeric code unique to each Segment type.
+    # @return [String]
+    attr_reader :id
+    # Short name of the Segment.
+    # @return [String]
+    attr_reader :name
+    # @return [Array<Element>]
+    attr_accessor :elements
+    # @return [Eddy::Data::Store] Data passed down from a Transaction Set.
+    attr_accessor :store
+
+    # All of a Segment's elements need to be declared in its constructor.
+    #
+    # @param store [Eddy::Data::Store]
+    # @param elements [Eddy::Element::Base]
+    # @return [void]
+    def initialize(store, *elements)
+      self.store = store
+      elements.flatten!
+      self.elements = elements || []
+    end
+
+    # @param separator [String] (self.store.element_separator) String used to delimit elements within a segment.
+    # @return [String]
+    def render(separator = self.store.element_separator)
+      segment = [self.id, self.elements.map(&:value)].join(separator)
+      return Eddy::Util.trim_delims_from_segment(segment, separator: separator)
+    end
+
+  end
+end

data/lib/eddy/models/transaction_set.rb

@@ -0,0 +1,101 @@
+module Eddy
+  # Base class for EDI Transaction Sets.
+  class TransactionSet
+
+    # @return [Integer]
+    ID = nil
+    # @return [String]
+    NAME = nil
+    # @return [String]
+    FUNCTIONAL_GROUP = nil
+
+    # @return [Array<Segment, Loop>]
+    attr_accessor :components
+    # @return [Eddy::Data::Store] Container used to distribute state throughout an Interchange.
+    attr_accessor :store
+
+    # @param store [Eddy::Data::Store]
+    # @param components [Array<Segment, Loop>]
+    # @return [void]
+    def initialize(store, *components)
+      self.store = store
+      components.flatten!
+      self.components = components || []
+    end
+
+    # @return [String]
+    def id
+      return self.class::ID
+    end
+
+    # @return [String]
+    def self.id
+      return self::ID
+    end
+
+    # @return [String]
+    def functional_group
+      return self.class::FUNCTIONAL_GROUP
+    end
+
+    # @return [String]
+    def self.functional_group
+      return self::FUNCTIONAL_GROUP
+    end
+
+    # @return [String]
+    def name
+      return self.class::NAME
+    end
+
+    # @return [String]
+    def self.name
+      return self::NAME
+    end
+
+    # Add `ST` and `SE` segments to the `components` array.
+    #
+    # @param t_set_control_number [Integer] (Eddy::Data::Store#transaction_set_control_number)
+    # @return [void]
+    def add_envelope(t_set_control_number = self.store.transaction_set_control_number)
+      st = Eddy::Segments::ST.new(self.store)
+      st.TransactionSetIdentifierCode = self.id
+      st.TransactionSetControlNumber  = t_set_control_number
+
+      se = Eddy::Segments::SE.new(self.store)
+      se.NumberOfIncludedSegments    = self.all_components.length + 2
+      se.TransactionSetControlNumber = t_set_control_number
+
+      self.components.unshift(st)
+      self.components.push(se)
+    end
+
+    # This shouldn't be used.
+    # An Interchange or FunctionalGroup should call `all_components` and render those itself.
+    #
+    # @param s_sep [String] (self.store.segment_separator)
+    # @return [String]
+    def render(s_sep = self.store.segment_separator)
+      add_envelope()
+      e_sep = self.store.element_separator
+      return self.all_components.map { |s| s.render(e_sep) }.join(s_sep) + s_sep
+    end
+
+    # Return all contained Segments in a single, flattened array.
+    #
+    # @return [Array<Eddy::Segment>]
+    def all_components()
+      comps = self.components.map do |c|
+        if c.is_a?(Eddy::Loop::Base)
+          c.all_contents()
+        elsif c.is_a?(Eddy::Segment)
+          c
+        else
+          raise Eddy::Errors::RenderError
+        end
+      end
+      return comps.flatten
+    end
+
+  end
+end

data/lib/eddy/parse.rb

@@ -0,0 +1,58 @@
+module Eddy
+  module Parse
+    # Wrapper around an interchange file or string.
+    class Interchange
+
+      # Raw content of the interchange.
+      # @return [String]
+      attr_accessor :document
+      # Component Element Separator
+      # @return [String] (">")
+      attr_accessor :component_separator
+      # @return [String] ("~")
+      attr_accessor :segment_separator
+      # Data Element Separator
+      # @return [String] ("*")
+      attr_accessor :element_separator
+
+      # @param doc [String] EDI document.
+      # @param component_separator [String] (">")
+      # @param segment_separator [String] ("~")
+      # @param element_separator [String] ("*")
+      # @return [void]
+      def initialize(doc, component_separator: ">", segment_separator: "~", element_separator: "*")
+        self.document = doc
+        self.component_separator = component_separator
+        self.segment_separator = segment_separator
+        self.element_separator = element_separator
+      end
+
+      # @param path [String]
+      # @return [self]
+      def self.from_file(path, **kwargs)
+        return self.new(File.read(path), **kwargs)
+      end
+
+      # @return [Array<Hash>]
+      def parse()
+        doc = self.document.gsub(/\n/, "")
+        segments = doc.split(self.segment_separator)
+        segments.map { |seg| self.parse_segment(seg) }
+      end
+
+      # @param seg [String]
+      # @return [Hash]
+      def parse_segment(seg)
+        name, *elements = seg.split(self.element_separator)
+        res = { name: name, elements: {} }
+        elements.each_with_index do |value, index|
+          next if value == ""
+          key = sprintf("%s%02d", name, index + 1)
+          res[:elements][key] = value
+        end
+        return res
+      end
+
+    end
+  end
+end

data/lib/eddy/schema/element_summary.rb

@@ -0,0 +1,123 @@
+module Eddy
+  module Schema
+    # An individual EDI Data Element. Used in Companion Guides to define requirements for a Segment.
+    class ElementSummary
+
+      # Indicates the order in which Elements should appear in their Segment.
+      # @return [String]
+      attr_accessor :ref
+      # Short string used to identify the Element.
+      # @return [String]
+      attr_accessor :id
+      # Full name of the Element.
+      # @return [String]
+      attr_accessor :name
+      # Minimum length for a valid Element value. Used for validation.
+      # @return [Integer]
+      attr_accessor :min
+      # Maximum length for a valid Element value. Used for validation.
+      # @return [Integer]
+      attr_accessor :max
+      # Description of the Element.
+      # @return [String]
+      attr_accessor :description
+      # Defines if/how the Element is required.
+      # @return [String]
+      attr_accessor :req
+      # Default value for the Element
+      # @return [String]
+      attr_accessor :default
+      # A list of valid values for the Element.
+      # @return [Array]
+      attr_accessor :valid_values
+      # The kind of value the Element will contain.
+      # @return [String]
+      attr_accessor :type
+
+      # @param params [Hash] ({})
+      # @return [self]
+      def self.create(params = {})
+        summary = new()
+        summary.ref          = params[:ref]&.strip
+        summary.id           = params[:id]&.strip
+        summary.name         = params[:name]&.strip
+        summary.min          = params[:min]&.to_i
+        summary.max          = params[:max]&.to_i
+        summary.description  = params[:description]&.strip
+        summary.req          = params[:req]&.strip
+        summary.default      = params[:default]&.strip
+        summary.valid_values = params[:valid_values]
+        summary.type         = params[:type]&.strip
+        return summary
+      end
+
+      # @param id [String]
+      # @return [self]
+      def self.default_for_id(id)
+        data = Eddy::Util.raw_element_data()
+        id.upcase!
+        result = data.find { |el| el[:id] == id }
+        raise Eddy::Errors::Error, "No element found with id #{id}" if result.nil?
+        return self.create(result)
+      end
+
+      # @return [String]
+      def normalized_name
+        return Eddy::Util.normalize_name(self.name)
+      end
+
+      # Generate a description to use as a doc comment for an element.
+      #
+      # @param header [Hash<:none, :ref, :see, :summary>] (:summary)
+      # @return [String]
+      def doc_comment(header: :summary)
+        parts = []
+        case header
+        when :none, nil, false
+          # Nothing to do
+        when :see     then return "(see Eddy::Elements::#{Eddy::Util.normalize_id(self.id)})"
+        when :ref     then parts << "### #{self.ref.upcase}\n"
+        when :summary then parts << "### Element Summary:\n"
+        else raise ArgumentError, "header must be a valid symbol"
+        end
+        parts << <<~YARD.strip
+          - Id: #{self.id}
+          - Name: #{self.name}
+          - Type: #{self.type}
+          - Min/Max: #{self.min}/#{self.max}
+          - Description: #{self.description}
+        YARD
+        return parts.compact.join("\n")
+      end
+
+      # @return [String]
+      def yard_type()
+        return case self.type
+               when "AN"   then "String"
+               when "B"    then "String"
+               when "DT"   then "Time"
+               when "ID"   then "String"
+               when /N\d*/ then "Integer"
+               when /R\d*/ then "Float"
+               when "TM"   then "Time"
+               else raise Eddy::Errors::Error, "unable to determine element type"
+               end
+      end
+
+      # @return [String]
+      def edi_type()
+        return case self.type
+               when "AN"   then "AN"
+               when "B"    then "B"
+               when "DT"   then "DT"
+               when "ID"   then "ID"
+               when /N\d*/ then "N"
+               when /R\d*/ then "R"
+               when "TM"   then "TM"
+               else raise Eddy::Errors::Error, "unable to determine element type"
+               end
+      end
+
+    end
+  end
+end

data/lib/eddy/schema/loop_summary.rb

@@ -0,0 +1,101 @@
+module Eddy
+  module Schema
+    # A repeated collection of Segments and/or other Loops. Used in Companion Guides.
+    class LoopSummary
+
+      # A unique string used to identify the Loop within its Transaction Set.
+      # @return [String]
+      attr_accessor :loop_id
+      # Number of times a particular Loop may be repeated.
+      # @return [Integer]
+      attr_accessor :repeat
+      # *Syntax*, *Semantic*, or *Comment* notes on a Loop.
+      # @return [String]
+      attr_accessor :notes
+      # Indicates where the Loop is located in the Transaction Set.
+      # @return [String]
+      attr_accessor :level
+      # Defines if/how the Loop is required.
+      # @return [String]
+      attr_accessor :req
+      # The components that make up the Loop.
+      # @return [Array<Eddy::Schema::SegmentSummary, Eddy::Schema::LoopSummary>]
+      attr_accessor :components
+
+      # @return [void]
+      def initialize()
+        self.components = []
+      end
+
+      # @param params [Hash]
+      # @return [self]
+      def self.create(params = {})
+        l = LoopSummary.new
+        l.loop_id = params[:loop_id]
+        l.repeat = params[:repeat]
+        l.notes = params[:notes]
+        l.level = params[:level]
+        l.req = params[:req]
+        l.process_components(params[:components])
+        return l
+      end
+
+      # @param path [String] Path to a JSON or YAML file containing a valid Loop definition.
+      # @return [self]
+      def self.from_file(path)
+        raise Eddy::Errors::Error, "Invalid segment definition" unless Eddy::Schema.valid_loop_data?(path)
+        data = Eddy::Util.read_json_or_yaml(path)
+        return Eddy::Schema::LoopSummary.create(data)
+      end
+
+      # @param components [Array<Hash>]
+      # @return [void]
+      def process_components(components)
+        return if components.nil?
+        components.each do |comp|
+          if comp.key?(:loop_id)
+            self.components << Eddy::Schema::LoopSummary.create(comp)
+          else
+            self.components << Eddy::Schema::SegmentSummary.create(comp)
+          end
+        end
+      end
+
+      # Generate a description to use as a doc comment for a Loop.
+      #
+      # @param header [Boolean] (true)
+      # @return [String]
+      def doc_comment(header: true)
+        comps = ""
+        self.components.each do |comp|
+          case comp
+          when Eddy::Schema::SegmentSummary then comps << "  - #{comp.id.upcase}\n"
+          when Eddy::Schema::LoopSummary    then comps << "  - #{comp.loop_id.upcase} (loop)\n"
+          end
+        end
+        parts = []
+        parts << "### Loop Summary:\n" if header
+        parts << <<~YARD.strip
+          - Repeat: #{self.repeat}
+          - Components:
+          #{comps}
+        YARD
+        return parts.compact.join("\n")
+      end
+
+      # Return all components in a single, flattened array.
+      #
+      # @return [Array<Eddy::Schema::SegmentSummary, Eddy::Schema::LoopSummary>]
+      def all_components()
+        return self.components.map do |comp|
+          case comp
+          when Eddy::Schema::LoopSummary    then [comp, comp.all_components()]
+          when Eddy::Schema::SegmentSummary then comp
+          else raise Eddy::Errors::Error
+          end
+        end.flatten
+      end
+
+    end
+  end
+end