stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/versions/common/element_types/simple_element.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Versions
+    module Common
+      module ElementTypes
+        class SimpleElementDef < Schema::SimpleElementDef
+          # @return [Symbol]
+          attr_reader :id
+
+          # @return [String]
+          attr_reader :name
+
+          # @return [String]
+          attr_reader :description
+
+          # @return [Integer]
+          attr_reader :min_length
+
+          # @return [Integer]
+          attr_reader :max_length
+
+          # @return [Schema::SegmentDef, Schema::CompositeElementDef]
+          attr_reader :parent
+
+          # @return [Class<Values::SimpleElementVal>]
+          abstract :companion
+
+          def initialize(id, name, min_length, max_length, description = nil, parent = nil)
+            @id, @name, @min_length, @max_length, @description, @parent =
+              id, name, min_length, max_length, description, parent
+
+            if min_length < 1
+              raise Exceptions::InvalidSchemaError,
+                "min_length must be positive"
+            end
+
+            if min_length > max_length
+              raise Exceptions::InvalidSchemaError,
+                "min_length cannot be greater than max_length"
+            end
+          end
+
+          # @return [SimpleElementDef]
+          def copy(changes = {})
+            self.class.new \
+              changes.fetch(:id, @id),
+              changes.fetch(:name, @name),
+              changes.fetch(:min_length, @min_length),
+              changes.fetch(:max_length, @max_length),
+              changes.fetch(:description, @description),
+              changes.fetch(:parent, @parent)
+          end
+
+          # Constructs a SimpleElementVal from the given `value`
+          #
+          # @return [Values::SimpleElementVal]
+          def value(object, usage, position)
+            companion.value(object, usage, position)
+          end
+
+          # Constructs an empty SimpleElementVal
+          #
+          # @return [Values::SimpleElementVal]
+          def empty(usage, position)
+            companion.empty(usage, position)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/common/element_types/tm.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Versions
+    module Common
+      module ElementTypes
+        class TM < SimpleElementDef
+          def initialize(id, name, min_length, max_length, description = nil, parent = nil)
+            super(id, name, min_length, max_length, description)
+
+            unless min_length == 2 or min_length == 4 or min_length >= 6
+              raise Exceptions::InvalidSchemaError,
+                "min_length must be either 2, 4, 6, or greater"
+            end
+
+            unless max_length == 2 or max_length == 4 or max_length >= 6
+              raise Exceptions::InvalidSchemaError,
+                "max_length must be either 2, 4, 6, or greater"
+            end
+          end
+
+          def companion
+            TimeVal
+          end
+        end
+
+        #
+        # @see X222.pdf B.1.1.3.1.6 Time
+        #
+        class TimeVal < Values::SimpleElementVal
+          def time?
+            true
+          end
+
+          def too_short?
+            false
+          end
+
+          def too_long?
+            false
+          end
+
+          class Invalid < TimeVal
+            # @return [Object]
+            attr_reader :value
+
+            def initialize(value, usage, position)
+              @value = value
+              super(usage, position)
+            end
+
+            def valid?
+              false
+            end
+
+            def empty?
+              false
+            end
+
+            # @return [TimeVal]
+            def map
+              self
+            end
+
+            # @return [String]
+            # :nocov:
+            def inspect
+              id = definition.bind do |d|
+                "[#{"% 5s" % d.id}: #{d.name}]".bind do |s|
+                  if usage.forbidden?
+                    ansi.forbidden(s)
+                  elsif usage.required?
+                    ansi.required(s)
+                  else
+                    ansi.optional(s)
+                  end
+                end
+              end
+
+              ansi.element("TM.invalid#{id}") + "(#{ansi.invalid(@value.inspect)})"
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_s
+              ""
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              ""
+            end
+
+            # @return [Boolean]
+            def ==(other)
+              eql?(other)
+            end
+
+            def copy(changes = {})
+              self
+            end
+          end
+
+          class Valid < TimeVal
+            def valid?
+              true
+            end
+
+            # @return [TimeVal]
+            def map
+              TimeVal.value(yield(value), usage, position)
+            end
+
+            def copy(changes = {})
+              TimeVal.value \
+                changes.fetch(:value, value),
+                changes.fetch(:usage, usage),
+                changes.fetch(:position, position)
+            end
+
+            def coerce(other)
+              return TimeVal.value(other, usage, position), self
+            end
+
+            # @return [Boolean]
+            def ==(other)
+              other = TimeVal.value(other, usage, position)
+              other.valid? and other.value == value
+            end
+          end
+
+          class Empty < Valid
+            def value
+              nil
+            end
+
+            def empty?
+              true
+            end
+
+            # @return [String]
+            # :nocov:
+            def inspect
+              id = definition.bind do |d|
+                "[#{"% 5s" % d.id}: #{d.name}]".bind do |s|
+                  if usage.forbidden?
+                    ansi.forbidden(s)
+                  elsif usage.required?
+                    ansi.required(s)
+                  else
+                    ansi.optional(s)
+                  end
+                end
+              end
+
+              ansi.element("TM.empty#{id}")
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_s
+              ""
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              ""
+            end
+          end
+
+          class NonEmpty < Valid
+            # @return [Integer]
+            attr_reader :hour
+
+            # @return [Integer]
+            attr_reader :minute
+
+            # @return [Integer, BigDecimal]
+            attr_reader :second
+
+            def initialize(hour, minute, second, usage, position)
+              @hour, @minute, @second = hour, minute, second
+
+              valid   = (  hour.nil? or hour.between?(0, 24))
+              valid &&= (minute.nil? or not hour.nil?)
+              valid &&= (minute.nil? or minute.between?(0, 60))
+              valid &&= (second.nil? or not minute.nil?)
+              valid &&= (second.nil? or second.between?(0, 60))
+
+              super(usage, position)
+
+              unless valid
+                raise Exceptions::InvalidElementError,
+                  "invalid time #{inspect}"
+              end
+            end
+
+            def copy(changes = {})
+              if [:hour, :minute, :second].any?{|x| changes.include?(x) }
+                changes[:value] = [changes.fetch(:hour, @hour),
+                                   changes.fetch(:minute, @minute),
+                                   changes.fetch(:second, @second)]
+              end
+
+              super(changes)
+            end
+
+            def value
+              [@hour, @minute, @second]
+            end
+
+            def empty?
+              false
+            end
+
+            def too_short?
+              to_x12(false).length < definition.min_length
+            end
+
+            # @return [Time]
+            def to_time(date, minute = nil, second = nil)
+              minute = @minute || minute
+              second = @second || second
+
+              if not second.nil?
+                Time.utc(date.year, date.month, date.day, @hour, minute, second.to_f)
+              elsif not minute.nil?
+                Time.utc(date.year, date.month, date.day, @hour, minute)
+              else
+                Time.utc(date.year, date.month, date.day, @hour)
+              end
+            end
+
+            # @return [String]
+            # :nocov:
+            def inspect
+              id = definition.bind do |d|
+                "[#{"% 5s" % d.id}: #{d.name}]".bind do |s|
+                  if usage.forbidden?
+                    ansi.forbidden(s)
+                  elsif usage.required?
+                    ansi.required(s)
+                  else
+                    ansi.optional(s)
+                  end
+                end
+              end
+
+              hh =   @hour.try{|h| "%02d" % h }  || "hh"
+              mm = @minute.try{|m| "%02d" % m }  || "mm"
+              ss = @second.try{|s| s.to_s("F") } || "ss"
+              ss = ss.gsub(/^0*\.|\.0*$/, "")
+
+              ansi.element("TM.value#{id}") + "(#{hh}:#{mm}:#{ss})"
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_s(hh = "hh", mm = "mm", ss = "ss")
+              hh =   @hour.try{|h| "%02d" % h } || hh
+              mm = @minute.try{|m| "%02d" % m } || mm
+              ss = @second.try{|s| "%02f" % s } || ss
+              "#{hh}:#{mm}:#{ss}".gsub(/\.?0*$|:$/, "")
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              hh =   @hour.try{|h| "%02d" % h }
+              mm = @minute.try{|m| "%02d" % m }
+              ss = @second.try{|s| "%02d" % s }
+              ff = @second.try{|s| s.frac.to_s("F").gsub(/^0*\.|0+$/, "") }
+
+              x12 = "#{hh}#{mm}#{ss}#{ff}"
+
+              truncate ? x12.take(definition.max_length) : x12
+            end
+          end
+        end
+
+        class << TimeVal
+          # @group Constructors
+          ###################################################################
+
+          # @return [TimeVal]
+          def empty(usage, position)
+            self::Empty.new(usage, position)
+          end
+
+          # @return [TimeVal]
+          def value(object, usage, position)
+            if object.is_a?(TimeVal)
+              object#.copy(:usage => usage, :position => position)
+            elsif object.blank?
+              self::Empty.new(usage, position)
+            elsif object.is_a?(String) or object.is_a?(StringVal)
+              return self::Invalid.new(object, usage, position) \
+                unless object =~ /^\d{4,}$/
+
+              hour   = object.to_s.slice(0, 2).to_i
+              minute = object.to_s.slice(2, 2).try{|mm| mm.to_i unless mm.blank? }
+              second = object.to_s.slice(4, 2).try{|ss| ss.to_d unless ss.blank? }
+
+              if decimal = object.to_s.slice(6..-1)
+                decimal = 0 if decimal.empty?
+                second += "0.#{decimal}".to_d
+              end
+
+              self::NonEmpty.new(hour, minute, second, usage, position)
+            elsif object.respond_to?(:hour) and
+                  object.respond_to?(:min)  and
+                  object.respond_to?(:sec)
+              sec = object.sec.to_d
+
+              if object.respond_to?(:usec)
+                sec += object.usec.to_d / 1000000
+              elsif object.respond_to?(:sec_fraction)
+                sec += object.sec_fraction.to_d
+              end
+
+              self::NonEmpty.new(object.hour, object.min, sec, usage, position)
+            elsif object.respond_to?(:hour)    and
+                  object.respond_to?(:minute)  and
+                  object.respond_to?(:second)
+              self::NonEmpty.new(object.hour, object.minute, object.second.to_d, usage, position)
+            elsif object.is_a?(Array) and object.length == 3
+              self::NonEmpty.new(*object, usage, position)
+            else
+              self::Invalid.new(object, usage, position)
+            end
+          rescue Exceptions::InvalidElementError
+            self::Invalid.new(object, usage, position)
+          end
+
+          # @endgroup
+          ###################################################################
+        end
+
+        # Prevent direct instantiation of abstract class TimeVal
+        TimeVal.eigenclass.send(:protected, :new)
+        TimeVal::Empty.eigenclass.send(:public, :new)
+        TimeVal::Invalid.eigenclass.send(:public, :new)
+        TimeVal::NonEmpty.eigenclass.send(:public, :new)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Versions
+    module Common
+      #
+      # @see X222.pdf A.1.3.9 Condition Designator
+      # @see X222.pdf A.1.3.12.6 Data Segment Requirement Designator
+      #
+      module SegmentReqs
+        Mandatory = Schema::SegmentReq.new(true,  false, "M")
+        Optional  = Schema::SegmentReq.new(false, false, "O")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Versions
+    module Common
+      #
+      # @see X222.pdf A.1.3.4 Syntax Notes
+      # @see X222.pdf A.1.3.8 Condition Designator
+      #
+      module SyntaxNotes
+        #
+        # Paired or Multiple: if any element specified in the relational
+        # condition is present, then all of the elements specified must
+        # be present.
+        #
+        class P < Schema::SyntaxNote
+          def required(zipper)
+            # if zipper.node.present?
+              xs = children(zipper)
+              xs.any?{|x| x.node.present? } ? xs : []
+            # else
+            #   []
+            # end
+          end
+
+          def forbidden(zipper)
+            []
+          end
+
+          def reason(zipper)
+            present = indexes.select{|n| zipper.child(n - 1).node.present? }
+            missing = indexes - present
+            "elements #{missing.join(", ")} must be present when elements #{present.join(", ")} are present"
+          end
+        end
+
+        #
+        # Required: at least one of the elements specified in the condition
+        # must be present
+        #
+        class R < Schema::SyntaxNote
+          def required(zipper)
+            # if zipper.node.present?
+              xs = children(zipper)
+              xs.any?{|x| x.node.present? } ? [] : xs
+            # else
+            #   []
+            # end
+          end
+
+          def forbidden(zipper)
+            []
+          end
+
+          def reason(zipper)
+            present = indexes.select{|n| zipper.child(n - 1).node.present? }
+            missing = indexes - present
+            "at least one of elements #{missing.join(", ")} must be present"
+          end
+        end
+
+        #
+        # Exclusion: not more than one of the elements in the condition may
+        # be present
+        #
+        class E < Schema::SyntaxNote
+          def required(zipper)
+            []
+          end
+
+          def forbidden(zipper)
+            # if zipper.node.present?
+              xs = children(zipper)
+              xs.count{|x| x.node.present? } <= 1 ? [] : xs
+            # else
+            #   []
+            # end
+          end
+
+          def reason(zipper)
+            present = indexes.select{|n| zipper.child(n - 1).node.present? }
+            "only one of elements #{present.join(", ")} may be present"
+          end
+        end
+
+        #
+        # Conditional: if the first element specified in the condition is
+        # present, then all other elements must be specified.
+        #
+        class C < Schema::SyntaxNote
+          def required(zipper)
+            # if zipper.node.present?
+              if zipper.child(indexes.head - 1).node.present?
+                children(zipper).tail
+              else
+                []
+              end
+            # else
+            #   []
+            # end
+          end
+
+          def forbidden(zipper)
+            []
+          end
+
+          def reason(zipper)
+            "elements #{indexes.tail.join(", ")} must be present when element #{indexes.head} is present"
+          end
+        end
+
+        #
+        # List Conditional: if the first element specified in the condition is
+        # present, then at least one of the remaining elements must be present
+        #
+        class L < Schema::SyntaxNote
+          def required(zipper)
+            # if zipper.node.present?
+              if zipper.child(indexes.head - 1).node.present?
+                xs = children(zipper).tail
+                xs.any?{|x| x.node.present? } ? [] : xs
+              else
+                []
+              end
+            # else
+            #   []
+            # end
+          end
+
+          def forbidden(zipper)
+            []
+          end
+
+          def reason(zipper)
+            "at least one of elements #{indexes.tail.join(", ")} must be present when element #{indexes.head} is present"
+          end
+        end
+
+        class << P
+          def build(*args)
+            new(args)
+          end
+        end
+
+        class << R
+          def build(*args)
+            new(args)
+          end
+        end
+
+        class << E
+          def build(*args)
+            new(args)
+          end
+        end
+
+        class << C
+          def build(*args)
+            new(args)
+          end
+        end
+
+        class << L
+          def build(*args)
+            new(args)
+          end
+        end
+      end
+    end
+  end
+end