tediparse 2.0.0

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

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Versions
+    module Common
+      module ElementTypes
+        class ID < SimpleElementDef
+          # @return [Schema::CodeList]
+          attr_reader :code_list
+
+          def initialize(id, name, min_length, max_length, code_list = nil, description = nil, parent = nil)
+            super(id, name, min_length, max_length, description, parent)
+            @code_list = code_list
+          end
+
+          def companion
+            IdentifierVal
+          end
+
+          # @return [ID]
+          def copy(changes = {})
+            ID.new \
+              changes.fetch(:id, @id),
+              changes.fetch(:name, @name),
+              changes.fetch(:min_length, @min_length),
+              changes.fetch(:max_length, @max_length),
+              changes.fetch(:code_list, @code_list),
+              changes.fetch(:description, @description),
+              changes.fetch(:parent, @parent)
+          end
+
+          # @return [SimpleElementUse]
+          def simple_use(requirement, repeat_count, parent = nil)
+            if @code_list.try(:internal?)
+              Schema::SimpleElementUse.new(self, requirement, repeat_count, Sets.absolute(@code_list.codes), parent)
+            else
+              Schema::SimpleElementUse.new(self, requirement, repeat_count, Sets.universal, parent)
+            end
+          end
+
+          # @return [ComponentElementUse]
+          def component_use(requirement, parent = nil)
+            if @code_list.try(:internal?)
+              Schema::ComponentElementUse.new(self, requirement, Sets.absolute(@code_list.codes), parent)
+            else
+              Schema::ComponentElementUse.new(self, requirement, Sets.universal, parent)
+            end
+          end
+        end
+
+        #
+        # @see X222.pdf B.1.1.3.1.3 Identifier
+        #
+        class IdentifierVal < Values::SimpleElementVal
+          def id?
+            true
+          end
+
+          def too_long?
+            false
+          end
+
+          def too_short?
+            false
+          end
+
+          class Invalid < IdentifierVal
+            # @return [Object]
+            attr_reader :value
+
+            def initialize(value, usage, position)
+              @value = value
+              super(usage, position)
+            end
+
+            # @return [Invalid]
+            def copy(changes = {})
+              self
+            end
+
+            def valid?
+              false
+            end
+
+            def empty?
+              false
+            end
+
+            # @return [IdentifierVal]
+            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("ID.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
+          end
+
+          class Valid < IdentifierVal
+            include Comparable
+
+            # (string any* -> any)
+            def_delegators :value, :to_d, :to_s, :to_f, :to_c, :to_r, :to_sym,
+              :to_str, :hex, :oct, :ord, :sum, :length, :count, :index, :rindex,
+              :lines, :bytes, :chars, :each, :upto, :split, :scan, :unpack, :=~,
+              :match, :partition, :rpatition, :encoding, :valid_enocding?,
+              :at, :empty?, :blank?
+
+            # (string any* -> StringVal)
+            extend Operators::Wrappers
+            wrappers :%, :+, :*, :slice, :take, :drop, :[], :capitalize,
+              :center, :ljust, :rjust, :chomp, :delete, :tr, :tr_s,
+              :sub, :gsub, :encode, :force_encoding, :squeeze
+
+            # (string -> StringVal)
+            extend Operators::Unary
+            unary_operators :chr, :chop, :upcase, :downcase, :strip,
+              :lstrip, :rstrip, :dump, :succ, :next, :reverse, :swapcase
+
+            # (string string -> any)
+            extend Operators::Relational
+            relational_operators :<=>, :start_with?, :end_with?,
+              :include?, :casecmp, :coerce => :to_str
+
+            def ==(other)
+              other = IdentifierVal.value(other, usage, position)
+              other.valid? and other.value == value
+            end
+
+            # @return [StringVal]
+            def copy(changes = {})
+              IdentifierVal.value \
+                changes.fetch(:value, value),
+                changes.fetch(:usage, usage),
+                changes.fetch(:position, position)
+            end
+
+            def coerce(other)
+              return IdentifierVal.value(other, usage, position), self
+            end
+
+            # @return [IdentifierVal]
+            def map
+              IdentifierVal.value(yield(value), usage, position)
+            end
+
+            def valid?
+              true
+            end
+          end
+
+          class Empty < Valid
+            # @return [String]
+            def value
+              ""
+            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("ID.empty#{id}")
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_x12(truncate = true)
+              ""
+            end
+          end
+
+          class NonEmpty < Valid
+            # @return [String]
+            attr_reader :value
+
+            def initialize(value, usage, position)
+              @value = value
+              super(usage, position)
+            end
+
+            def too_long?
+              @value.length > definition.max_length
+            end
+
+            def too_short?
+              @value.length < definition.min_length
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              x12 = @value.ljust(definition.min_length, " ")
+              truncate ? x12.take(definition.max_length) : x12
+            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
+
+              if definition.code_list.try(&:internal?)
+                if usage.allowed_values.include?(@value)
+                  value = "#{@value}: " + ansi.dark(definition.code_list.at(@value))
+                elsif definition.code_list.defined_at?(@value)
+                  value = ansi.red("#{@value}: " + definition.code_list.at(@value))
+                else
+                  value = ansi.red(@value)
+                end
+              else
+                value = @value
+              end
+
+              ansi.element("ID.value#{id}") + "(#{value})"
+            end
+            # :nocov:
+          end
+        end
+
+        class << IdentifierVal
+          # @group Constructors
+          ###################################################################
+
+          # @return [IdentifierVal]
+          def empty(usage, position)
+            self::Empty.new(usage, position)
+          end
+
+          # @return [IdentifierVal]
+          def value(object, usage, position)
+            if object.is_a?(IdentifierVal)
+              object#.copy(:usage => usage, :position => position)
+            elsif object.blank?
+              self::Empty.new(usage, position)
+            else
+              self::NonEmpty.new(object.to_s.rstrip, usage, position)
+            end
+          rescue
+            self::Invalid.new(object, usage, position)
+          end
+
+          # @endgroup
+          ###################################################################
+        end
+
+        # Prevent direct instantiation of abstract class IdentifierVal
+        IdentifierVal.eigenclass.send(:protected, :new)
+        IdentifierVal::Empty.eigenclass.send(:public, :new)
+        IdentifierVal::Invalid.eigenclass.send(:public, :new)
+        IdentifierVal::NonEmpty.eigenclass.send(:public, :new)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+module Stupidedi
+  using Refinements
+
+  module Versions
+    module Common
+      module ElementTypes
+        class Nn < SimpleElementDef
+          # @return [Integer]
+          attr_reader :precision
+
+          def initialize(id, name, min_length, max_length, precision, description = nil, parent = nil)
+            super(id, name, min_length, max_length, description, parent)
+
+            if precision > max_length
+              raise Exceptions::InvalidSchemaError,
+                "precision cannot be greater than max_length"
+            end
+
+            @precision = precision
+          end
+
+          # @return [Nn]
+          def copy(changes = {})
+            Nn.new \
+              changes.fetch(:id, @id),
+              changes.fetch(:name, @name),
+              changes.fetch(:min_length, @min_length),
+              changes.fetch(:max_length, @max_length),
+              changes.fetch(:precision, @precision),
+              changes.fetch(:description, @description),
+              changes.fetch(:parent, @parent)
+          end
+
+          def companion
+            FixnumVal
+          end
+        end
+
+        #
+        # @see X222.pdf B.1.1.3.1.1 Numeric
+        #
+        class FixnumVal < Values::SimpleElementVal
+          def numeric?
+            true
+          end
+
+          def too_long?
+            false
+          end
+
+          def too_short?
+            false
+          end
+
+          class Invalid < FixnumVal
+            # @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 [FixnumVal]
+            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("Nn.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
+
+            # @return [Invalid]
+            def copy(changes = {})
+              self
+            end
+          end
+
+          class Valid < FixnumVal
+            def valid?
+              true
+            end
+
+            # @return [FixnumVal]
+            def map
+              FixnumVal.value(yield(value), usage, position)
+            end
+
+            # @return [Empty]
+            def copy(changes = {})
+              FixnumVal.value \
+                changes.fetch(:value, value),
+                changes.fetch(:usage, usage),
+                changes.fetch(:position, position)
+            end
+
+            def coerce(other)
+              return FixnumVal.value(other, usage, position), self
+            end
+
+            def ==(other)
+              other = FixnumVal.value(other, usage, position)
+              other.valid? and other.value == value
+            end
+          end
+
+          #
+          # Empty numeric value. Shouldn't be directly instantiated -- instead
+          # use the {FixnumVal.value} and {FixnumVal.empty} constructors.
+          #
+          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("Nn.empty#{id}")
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_s
+              ""
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              ""
+            end
+          end
+
+          #
+          # Non-empty numeric value. Shouldn't be directly instantiated --
+          # instead, use the {FixnumVal.value} constructors.
+          #
+          class NonEmpty < Valid
+            # @group Mathematical Operators
+            #################################################################
+
+            extend Operators::Binary
+            binary_operators :+, :-, :*, :/, :%, :coerce => :to_d
+
+            extend Operators::Unary
+            unary_operators :abs, :-@, :+@
+
+            extend Operators::Relational
+            relational_operators :<, :>, :<=, :>=, :<=>, :coerce => :to_d
+
+            # @endgroup
+            #################################################################
+
+            # @return [BigDecimal]
+            attr_reader :value
+
+            def_delegators :value, :to_i, :to_d, :to_f, :to_r, :to_c
+
+            def initialize(value, usage, position)
+              @value = value
+              super(usage, position)
+            end
+
+            def empty?
+              false
+            end
+
+            def too_long?
+              nn = (@value * (10 ** definition.precision)).to_i
+
+              # The length of a numeric type does not include an optional sign
+              definition.max_length < nn.abs.to_s.length
+            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("Nn.value#{id}") + "(#{@value.to_s("F").gsub(/\.0+$/, "")})"
+            end
+            # :nocov:
+
+            # @return [String]
+            def to_s
+              # The number of fractional digits is implied by usage.precision
+              @value.to_s("F").gsub(/\.0+$/, "")
+            end
+
+            # @return [String]
+            def to_x12(truncate = true)
+              nn   = (@value * (10 ** definition.precision)).to_i
+              sign = (nn < 0) ? "-" : ""
+
+              # Leading zeros must be suppressed unless necessary to satisfy a
+              # minimum length requirement
+              if truncate
+                sign = sign + nn.abs.to_s.
+                  take(definition.max_length).
+                  rjust(definition.min_length, "0")
+              else
+                sign = sign + nn.abs.to_s.
+                  rjust(definition.min_length, "0")
+              end
+            end
+          end
+        end
+
+        class << FixnumVal
+          # @group Constructors
+          ###################################################################
+
+          # @return [FixnumVal]
+          def empty(usage, position)
+            self::Empty.new(usage, position)
+          end
+
+          # @return [FixnumVal]
+          def value(object, usage, position)
+            if object.is_a?(FixnumVal)
+              object#.copy(:usage => usage, :position => position)
+            elsif object.blank?
+              self::Empty.new(usage, position)
+            elsif object.is_a?(String)
+              # The number of fractional digits is implied by usage.precision
+              factor = 10 ** usage.definition.precision
+              self::NonEmpty.new(object.to_d / factor, usage, position)
+            else
+              self::NonEmpty.new(object.to_d, usage, position)
+            end
+          rescue ArgumentError
+            self::Invalid.new(object, usage, position)
+          end
+
+          # @endgroup
+          ###################################################################
+        end
+
+        # Prevent direct instantiation of abstract class FixnumVal
+        FixnumVal.eigenclass.send(:protected, :new)
+        FixnumVal::Empty.eigenclass.send(:public, :new)
+        FixnumVal::Invalid.eigenclass.send(:public, :new)
+        FixnumVal::NonEmpty.eigenclass.send(:public, :new)
+      end
+    end
+  end
+end