tediparse 2.0.0

data/lib/stupidedi/values/loop_val.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222.pdf B.1.1.3.12.2 Data Segment Groups
+    # @see X222.pdf B.1.1.3.12.4 Loops of Data Segments
+    #
+    class LoopVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [LoopDef]
+      attr_reader :definition
+
+      def_delegators :definition, :descriptor
+
+      # @return [Array<SegmentVal, LoopVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :position
+
+      def initialize(definition, children)
+        @definition, @children =
+          definition, children
+      end
+
+      # @return [LoopVal]
+      def copy(changes = {})
+        LoopVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children)
+      end
+
+      # (see AbstractVal#loop?)
+      # @return true
+      def loop?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.loop("LoopVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.loop("Loop") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == @definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/repeated_element_val.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222.pdf B.1.1.3.2 Repeating Data Elements
+    #
+    class RepeatedElementVal < AbstractElementVal
+      # @return [CompositeElementDef, SimpleElementDef]
+      def_delegators :usage, :definition, :descriptor
+
+      # @return [Array<AbstractElementVal>]
+      attr_reader :children
+      alias element_vals children
+
+      # @return [Schema::SimpleElementUse, Schema::CompositeElementUse
+      attr_reader :usage
+
+      def_delegators :children, :defined_at?, :length
+      def_delegators "children.first", :position
+
+      def initialize(children, usage)
+        @children, @usage =
+          children, usage
+      end
+
+      # @return [RepeatedElementVal]
+      def copy(changes = {})
+        RepeatedElementVal.new \
+          changes.fetch(:children, @children),
+          changes.fetch(:usage, @usage)
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      # @return true
+      def repeated?
+        true
+      end
+
+      # @return [Boolean]
+      def empty?
+        @children.empty? or @children.all?(&:empty?)
+      end
+
+      def element(n, o = nil)
+        unless n > 0
+          raise ArgumentError,
+            "n must be positive"
+        end
+
+        unless o.nil?
+          @children.at(n - 1).element(o)
+        else
+          @children.at(n - 1)
+        end
+      end
+
+      # @return [void]
+      # :nocov:
+      def pretty_print(q)
+        if @children.empty?
+          id = definition.try do |d|
+            ansi.bold("[#{d.id.to_s}: #{d.name.to_s}]")
+          end
+          q.text(ansi.repeated("RepeatedElementVal#{id}"))
+        else
+          q.text(ansi.repeated("RepeatedElementVal"))
+          q.group(2, "(", ")") do
+            q.breakable ""
+            @children.each do |e|
+              unless q.current_group.first?
+                q.text ", "
+                q.breakable
+              end
+              q.pp e
+            end
+          end
+        end
+      end
+      # :nocov:
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or \
+         (other.definition == definition and
+          other.children   == @children)
+      end
+    end
+
+    class << RepeatedElementVal
+      #########################################################################
+      # @group Constructors
+
+      # @return [RepeatedElementVal]
+      def empty(element_use)
+        RepeatedElementVal.new([], element_use)
+      end
+
+      # @return [RepeatedElementVal]
+      def build(children, element_use)
+        RepeatedElementVal.new(children, element_use)
+      end
+
+      # @endgroup
+      #########################################################################
+    end
+  end
+end

data/lib/stupidedi/values/segment_val.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222 B.1.1.3.4 Data Segment
+    #
+    class SegmentVal < AbstractVal
+      # @return [SegmentDef]
+      def_delegators :usage, :definition, :descriptor, :id
+
+      # @return [Array<AbstractElementVal>]
+      attr_reader :children
+
+      # @return [SegmentUse]
+      attr_reader :usage
+
+      # @return [Position]
+      attr_reader :position
+
+      def initialize(children, usage, position)
+        @children, @usage, @position =
+          children, usage, position
+      end
+
+      # @return [SegmentVal]
+      def copy(changes = {})
+        SegmentVal.new \
+          changes.fetch(:children, @children),
+          changes.fetch(:usage, @usage),
+          changes.fetch(:position, @position)
+      end
+
+      # (see AbstractVal#size)
+      def size
+        1
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      def valid?
+        true
+      end
+
+      # (see AbstractVal#segment?)
+      # @return true
+      def segment?
+        true
+      end
+
+      # @return [AbstractElementVal]
+      def element(m, n = nil, o = nil)
+        unless m > 0
+          raise ArgumentError,
+            "m must be positive"
+        end
+
+        unless n.nil?
+          @children.at(m - 1).element(n, o)
+        else
+          @children.at(m - 1)
+        end
+      end
+
+      # @return [void]
+      # :nocov:
+      def pretty_print(q)
+        id = definition.try do |d|
+          ansi.bold("[#{d.id}: #{d.name}]")
+        end
+
+        q.text(ansi.segment("SegmentVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+      # :nocov:
+
+      # @return [String]
+      # :nocov:
+      def inspect
+        ansi.segment(ansi.bold(definition.id.to_s))
+      end
+      # :nocov:
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/segment_val_group.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @see X222.pdf B.1.1.3.12.2 Data Segment Groups
+    #
+    module SegmentValGroup
+      # @return [LoopDef, TableDef]
+      abstract :definition
+
+      # (see AbstractVal#leaf?)
+      # @return false
+      def leaf?
+        false
+      end
+    end
+  end
+end

data/lib/stupidedi/values/simple_element_val.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    #
+    # @abstract This must be subclassed to add type- and version-specific
+    #   functionality. For instance, DateVal adds `#day`, `#month`, etc.
+    #
+    # @see X222 B.1.1.3.1 Data Element
+    #
+    class SimpleElementVal < AbstractElementVal
+      # @return [SimpleElementDef]
+      def_delegators :usage, :definition, :descriptor
+
+      abstract :valid?
+
+      # @return [String]
+      abstract :to_x12
+
+      abstract :too_long?
+
+      abstract :too_short?
+
+      abstract :to_s
+
+      # @return [SimpleElementUse, ComponentElementUse]
+      attr_reader :usage
+
+      # @return [Reader::Position]
+      attr_reader :position
+
+      def initialize(usage, position)
+        @usage, @position =
+          usage, position
+      end
+
+      # @return [SimpleElementVal]
+      abstract :copy, "changes={}"
+
+      # True unless this value isn't included in {Schema::SimpleElementUse#allowed_values}
+      def allowed?
+        empty? or invalid? or usage.allowed_values.include?(to_s)
+      end
+
+      def id?
+        false
+      end
+
+      def date?
+        false
+      end
+
+      def time?
+        false
+      end
+
+      def string?
+        false
+      end
+
+      def numeric?
+        false
+      end
+
+      # @return true
+      def leaf?
+        true
+      end
+
+      def component?
+        @usage.component?
+      end
+
+      def simple?
+        not @usage.component?
+      end
+    end
+  end
+end

data/lib/stupidedi/values/table_val.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class TableVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [TableDef]
+      attr_reader :definition
+
+      def_delegators :definition, :descriptor
+
+      # @return [Array<SegmentVal, LoopVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :position
+
+      def initialize(definition, children)
+        @definition, @children =
+          definition, children
+      end
+
+      # @return [TableVal]
+      def copy(changes = {})
+        TableVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children)
+      end
+
+      # (see AbstractVal#table?)
+      # @return true
+      def table?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.table("TableVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.table("Table") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == @definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/transaction_set_val.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class TransactionSetVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [TransactionSetDef]
+      attr_reader :definition
+
+      def_delegators :definition, :descriptor
+
+      # @return [Array<TableVal>]
+      attr_reader :children
+
+      def_delegators "@children.head", :position
+
+      def initialize(definition, children)
+        @definition, @children =
+          definition, children
+      end
+
+      # @return [TransactionSetVal]
+      def copy(changes = {})
+        TransactionSetVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children)
+      end
+
+      # (see AbstractSet#transaction_set?)
+      # @return true
+      def transaction_set?
+        true
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.functional_group}#{d.id}]")
+        end
+
+        q.text(ansi.envelope("TransactionSetVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.envelope("Transaction") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == @definition and
+          other.children   == @children)
+      end
+    end
+  end
+end

data/lib/stupidedi/values/transmission_val.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Values
+    class TransmissionVal < AbstractVal
+      # @return [Array<InterchangeVal>]
+      attr_reader :children
+
+      def initialize(children = [])
+        @children = children
+      end
+
+      def copy(changes = {})
+        TransmissionVal.new(changes.fetch(:children, @children))
+      end
+
+      def descriptor
+        "root"
+      end
+
+      def leaf?
+        false
+      end
+
+      def transmission?
+        true
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or other.children == @children
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text(ansi.envelope("TransmissionVal"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.envelope("TransmissionVal") + "(#{@children.map(&:inspect).join(", ")})"
+      end
+    end
+  end
+end

data/lib/stupidedi/values.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Values
+    autoload :AbstractVal,          "stupidedi/values/abstract_val"
+    autoload :TransmissionVal,      "stupidedi/values/transmission_val"
+    autoload :InterchangeVal,       "stupidedi/values/interchange_val"
+    autoload :FunctionalGroupVal,   "stupidedi/values/functional_group_val"
+    autoload :TransactionSetVal,    "stupidedi/values/transaction_set_val"
+
+    autoload :TableVal,             "stupidedi/values/table_val"
+    autoload :LoopVal,              "stupidedi/values/loop_val"
+    autoload :SegmentVal,           "stupidedi/values/segment_val"
+    autoload :InvalidSegmentVal,    "stupidedi/values/invalid_segment_val"
+    autoload :InvalidEnvelopeVal,   "stupidedi/values/invalid_envelope_val"
+    autoload :SegmentValGroup,      "stupidedi/values/segment_val_group"
+
+    autoload :AbstractElementVal,   "stupidedi/values/abstract_element_val"
+    autoload :CompositeElementVal,  "stupidedi/values/composite_element_val"
+    autoload :RepeatedElementVal,   "stupidedi/values/repeated_element_val"
+    autoload :SimpleElementVal,     "stupidedi/values/simple_element_val"
+  end
+end

data/lib/stupidedi/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Stupidedi
+  VERSION = "2.0.0"
+end

data/lib/stupidedi/versions/common/element_reqs.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Versions
+    module Common
+      module ElementReqs
+        Mandatory  = Schema::ElementReq.new(true,  false, "M")
+        Optional   = Schema::ElementReq.new(false, false, "O")
+        Relational = Schema::ElementReq.new(false, false, "X")
+        # Flexible = Schema::ElementReq.new(false, false, "F")
+      end
+    end
+  end
+end