stupidedi 1.1.0 → 1.2.1

data/lib/stupidedi/versions/functional_groups/004010/element_types/float_val.rb

@@ -6,19 +6,35 @@ module Stupidedi
 
           #
           class R < SimpleElementDef
+
+            # @return [Integer]
+            attr_reader :max_precision
+
+            def initialize(id, name, min_length, max_length, max_precision = nil, description = nil, parent = nil)
+              super(id, name, min_length, max_length, description, parent)
+
+              if max_precision.try(:>, max_length)
+                raise ArgumentError,
+                  "max_precision cannot be greater than max_length"
+              end
+
+              @max_precision = max_precision
+            end
+
             def companion
               FloatVal
             end
           end
 
           #
-          # @see X222.pdf A.1.3.1.2 Decimal
+          # @see X222.pdf B.1.1.3.1.2 Decimal
           #
           class FloatVal < Values::SimpleElementVal
           # PATTERN = /\A[+-]?            (?# optional leading sign            )
           #            (?:
           #              (?:\d+\.?\d*)  | (?# whole with optional decimal or ..)
           #              (?:\d*?\.?\d+) ) (?# optional whole with decimal      )
+          #            (?:E[+-]?\d+)?     (?# optional exponent                )
           #           \Z/ix
 
             def numeric?
@@ -33,9 +49,6 @@ module Stupidedi
               false
             end
 
-            #
-            #
-            #
             class Invalid < FloatVal
 
               # @return [Object]
@@ -54,6 +67,11 @@ module Stupidedi
                 false
               end
 
+              # @return [FloatVal]
+              def map
+                FloatVal.value(yield(nil), usage, position)
+              end
+
               # @return [String]
               def inspect
                 id = definition.try do |d|
@@ -76,10 +94,14 @@ module Stupidedi
                 ""
               end
 
+              # @return [String]
+              def to_x12(truncate = true)
+                ""
+              end
+
               # @return [Boolean]
               def ==(other)
-                eql?(other) or
-                  (other.is_a?(Invalid) and @value == other.value)
+                eql?(other)
               end
             end
 
@@ -97,6 +119,11 @@ module Stupidedi
                 true
               end
 
+              # @return [FloatVal]
+              def map
+                FloatVal.value(yield(nil), usage, position)
+              end
+
               # @return [String]
               def inspect
                 id = definition.try do |d|
@@ -119,9 +146,14 @@ module Stupidedi
                 ""
               end
 
+              # @return [String]
+              def to_x12(truncate = true)
+                ""
+              end
+
               # @return [Boolean]
               def ==(other)
-                other.is_a?(Empty)
+                other.is_a?(Empty) or other.nil?
               end
             end
 
@@ -132,11 +164,28 @@ module Stupidedi
             class NonEmpty < FloatVal
               include Comparable
 
-              # @return [BigDecimal]
-              attr_reader :value
+              # @group Mathematical Operators
+              #################################################################
+
+              extend Operators::Binary
+              binary_operators(:+, :-, :*, :/, :%, :coerce => :to_d)
+
+              extend Operators::Relational
+              relational_operators(:==, :<=>, :coerce => :to_d)
 
-              delegate :to_i, :to_d, :to_f, :to => :@value
+              extend Operators::Unary
+              unary_operators(:abs, :-@, :+@)
 
+              # @endgroup
+              #################################################################
+
+              # @return [BigDecimal]
+              attr_reader :value
+              
+              extend Forwardable
+              def_delegators :@value, :to_i, :to_d, :to_f, :to_r, :to_c
+                 
+              
               def initialize(value, usage, position)
                 @value = value
                 super(usage, position)
@@ -150,6 +199,17 @@ module Stupidedi
                   changes.fetch(:position, position)
               end
 
+              def coerce(other)
+                # self', other' = other.coerce(self)
+                # self' * other'
+                if other.respond_to?(:to_d)
+                  return copy(:value => other.to_d), self
+                else
+                  raise TypeError,
+                    "cannot coerce FloatVal to #{other.class}"
+                end
+              end
+
               def valid?
                 # False for NaN and +/- Infinity
                 @value.finite?
@@ -159,17 +219,6 @@ module Stupidedi
                 false
               end
 
-              # @return [Array(NonEmpty, Numeric)]
-              def coerce(other)
-                if other.respond_to?(:to_d)
-                  # Re-evaluate other.call(self) as self.op(other.to_d)
-                  return self, other.to_d
-                else
-                  # Fail, other.call(self) is still other.call(self)
-                  raise TypeError, "#{other.class} can't be coerced into #{NonEmpty}"
-                end
-              end
-
               # @return [String]
               def inspect
                 id = definition.try do |d|
@@ -189,71 +238,79 @@ module Stupidedi
 
               # @return [String]
               def to_s
-                if false #definition.precision.present?
-                  @value.round(definition.precision).to_s("F")
+                if definition.max_precision.present?
+                  @value.round(definition.max_precision).to_s("F")
                 else
                   @value.to_s("F")
-                end.gsub(/\.0$/, "")
-              end
-
-              # @group Mathematical Operators
-              #################################################################
-
-              # @return [NonEmpty]
-              def /(other)
-                copy(:value => (@value / other).to_d)
-              end
-
-              # @return [NonEmpty]
-              def +(other)
-                copy(:value => (@value + other).to_d)
+                end
               end
 
-              # @return [NonEmpty]
-              def -(other)
-                copy(:value => (@value - other).to_d)
-              end
+              # While the ASC X12 standard supports the usage of exponential
+              # notation, the HIPAA guides prohibit it. In the interest of
+              # simplicity, this method will not output exponential notation,
+              # as there is currently no configuration attribute to indicate
+              # if this is allowed or not -- if this is required in the future,
+              # the best place for it to fit would be in SimpleElementUse
+              #
+              # @return [String]
+              def to_x12(truncate = true)
+                remaining =
+                  if @value.to_i.zero?
+                    definition.max_length
+                  else
+                    definition.max_length - @value.to_i.abs.to_s.length
+                  end
 
-              # @return [NonEmpty]
-              def **(other)
-                copy(:value => (@value ** other).to_d)
-              end
+                if remaining <= 0
+                  if truncate
+                    int   = @value.to_i.to_s
+                    sign  = (int < 0) ? "-" : ""
+                    return sign << int.abs.to_s.take(definition.max_length)
+                  else
+                    return @value.to_i.abs
+                  end
+                end
 
-              # @return [NonEmpty]
-              def *(other)
-                copy(:value => (@value * other).to_d)
-              end
+                # Don't exceed the definition's max_precision
+                precision =
+                  if definition.max_precision.present?
+                    (definition.max_precision < remaining) ?
+                      definition.max_precision : remaining
+                  else
+                    remaining
+                  end
 
-              # @return [NonEmpty]
-              def %(other)
-                copy(:value => (@value % other).to_d)
-              end
+                rounded = @value.round(precision)
+                sign    = (rounded < 0) ? "-" : ""
 
-              # @return [NonEmpty]
-              def -@
-                copy(:value => -@value)
+                # Leading zeros preceeding the decimal point and trailing zeros
+                # following the decimal point must be supressed unless necessary
+                # to satisfy a minimum length requirement or to indicate
+                # precision, respectively.
+                if rounded.zero?
+                  "0" * definition.min_length
+                else
+                  sign << rounded.abs.to_s("F").
+                    gsub(/^0+/, ""). # leading zeros
+                    gsub(/0+$/, ""). # trailing zeros
+                    gsub(/\.$/, ""). # trailing decimal point
+                    rjust(definition.min_length, "0")
+                end
               end
 
-              # @return [NonEmpty]
-              def +@
-                self
-              end
+              def too_long?
+                # We can truncate the fractional portion as much as needed, so
+                # the only concern we have about length is regarding the digits
+                # to the left of the decimal place.
 
-              # @return [NonEmpty]
-              def abs
-                copy(:value => @value.abs)
+                # The length of a decimal type does not include an optional sign
+                definition.max_length < @value.to_i.abs.to_s.length
               end
 
-              # @return [-1, 0, +1]
-              def <=>(other)
-                if other.respond_to?(:value)
-                  @value <=> other.value
-                else
-                  @value <=> other
-                end
+              # @return [FloatVal]
+              def map
+                FloatVal.value(yield(@value), usage, position)
               end
-
-              # @endgroup
             end
 
           end

data/lib/stupidedi/versions/functional_groups/004010/element_types/identifier_val.rb

@@ -32,8 +32,8 @@ module Stupidedi
 
             # @return [SimpleElementUse]
             def simple_use(requirement, repeat_count, parent = nil)
-              if @code_list and @code_list.internal?
-                Schema::SimpleElementUse.new(self, requirement, repeat_count, Sets.absolute(code_list.codes), parent)
+              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
@@ -41,16 +41,24 @@ module Stupidedi
 
             # @return [ComponentElementUse]
             def component_use(requirement, parent = nil)
-              if @code_list and @code_list.internal?
-                Schema::ComponentElementUse.new(self, requirement, Sets.absolute(code_list.codes), parent)
+              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
+
+            def code_lists(subset = Sets.universal)
+              if @code_list.present?
+                @code_list.code_lists(subset)
+              else
+                Sets.empty
+              end
+            end
           end
 
           #
-          # @see X222.pdf A.1.3.1.3 Identifier
+          # @see X222.pdf B.1.1.3.1.3 Identifier
           #
           class IdentifierVal < Values::SimpleElementVal
 
@@ -66,9 +74,11 @@ module Stupidedi
               false
             end
 
-            #
-            #
-            #
+            # @return [IdentifierVal]
+            def map
+              IdentifierVal.value(yield(value), usage, position)
+            end
+
             class Invalid < IdentifierVal
 
               # @return [Object]
@@ -87,6 +97,11 @@ module Stupidedi
                 false
               end
 
+              # @return [IdentifierVal]
+              def map
+                IdentifierVal.value(yield(nil), usage, position)
+              end
+
               # @return [String]
               def inspect
                 id = definition.bind do |d|
@@ -109,10 +124,14 @@ module Stupidedi
                 ""
               end
 
+              # @return [String]
+              def to_x12(truncate = true)
+                ""
+              end
+
               # @return [Boolean]
               def ==(other)
-                eql?(other) or
-                  (other.is_a?(Invalid) and @value == other.value)
+                eql?(other) or other.nil?
               end
             end
 
@@ -122,12 +141,58 @@ module Stupidedi
             # constructors
             #
             class Empty < IdentifierVal
+              include Comparable
+
+              # (string any* -> any)
+              extend Forwardable
+              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, :each, :split, :scan,
+                :unpack, :encoding, :count, :casecmp, :sum, :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_s
+
+              # @return [IdentifierVal]
+              def copy(changes = {})
+                IdentifierVal.value \
+                  changes.fetch(:value, value),
+                  changes.fetch(:usage, usage),
+                  changes.fetch(:position, position)
+              end
 
-              def valid?
-                true
+              def coerce(other)
+                # me, he = other.coerce(self)
+                # me <OP> he
+                if other.respond_to?(:to_str)
+                  return copy(:value => other.to_str), self
+                else
+                  raise TypeError,
+                    "cannot coerce IdentifierVal to #{other.class}"
+                end
               end
 
-              def empty?
+              def value
+                ""
+              end
+
+              def valid?
                 true
               end
 
@@ -153,9 +218,9 @@ module Stupidedi
                 ""
               end
 
-              # @return [Boolean]
-              def ==(other)
-                other.is_a?(Empty)
+              # @return [String]
+              def to_x12(truncate = true)
+                ""
               end
             end
 
@@ -164,31 +229,62 @@ module Stupidedi
             # instead, use the {IdentifierVal.value} constructor
             #
             class NonEmpty < IdentifierVal
+              include Comparable
 
               # @return [String]
               attr_reader :value
-
-              delegate :to_s, :to_str, :length, :=~, :match, :include?, :to => :@value
+              # (string any* -> any)
+              extend Forwardable
+              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, :each, :split, :scan,
+                :unpack, :encoding, :count, :casecmp, :sum, :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_s
 
               def initialize(value, usage, position)
                 @value = value
                 super(usage, position)
               end
 
-              # @return [NonEmpty]
+              # @return [IdentifierVal]
               def copy(changes = {})
-                NonEmpty.new \
+                IdentifierVal.value \
                   changes.fetch(:value, @value),
                   changes.fetch(:usage, usage),
                   changes.fetch(:position, position)
               end
 
-              def valid?
-                true
+              def coerce(other)
+                # me, he = other.coerce(self)
+                # me <OP> he
+                if other.respond_to?(:to_str)
+                  return copy(:value => other.to_str), self
+                else
+                  raise TypeError,
+                    "cannot coerce IdentifierVal to #{other.class}"
+                end
               end
 
-              def empty?
-                false
+              def valid?
+                true
               end
 
               def too_long?
@@ -199,6 +295,12 @@ module Stupidedi
                 @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]
               def inspect
                 id = definition.bind do |d|
@@ -227,16 +329,6 @@ module Stupidedi
 
                 ansi.element("ID.value#{id}") << "(#{value})"
               end
-
-              # @return [Boolean]
-              def ==(other)
-                eql?(other) or
-                 (if other.is_a?(NonEmpty)
-                    other.value == @value
-                  else
-                    other == @value
-                  end)
-              end
             end
 
           end
@@ -259,15 +351,8 @@ module Stupidedi
               else
                 self::Invalid.new(object, usage, position)
               end
-            end
-
-            # @return [IdentifierVal]
-            def parse(string, usage, position)
-              if string.blank?
-                self::Empty.new(usage, position)
-              else
-                self::NonEmpty.new(string.rstrip, usage, position)
-              end
+            rescue
+              self::Invalid.new(object, usage, position)
             end
 
             # @endgroup