RubyGems - stupidedi - Versions diffs - 1.3.23 → 1.4.0 - Mend

stupidedi 1.3.23 → 1.4.0

Files changed (2005) hide show

data/lib/stupidedi/versions/functional_groups/004010/element_types/string_val.rb DELETED

@@ -1,393 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-  module Versions
-    module FunctionalGroups
-      module FortyTen
-        module ElementTypes
-          class AN < SimpleElementDef
-            def companion
-              StringVal
-            end
-          end
-          #
-          # @see X222.pdf B.1.1.3.1.4 String
-          #
-          class StringVal < Values::SimpleElementVal
-            def string?
-              true
-            end
-            def too_long?
-              false
-            end
-            def too_short?
-              false
-            end
-            # @return [StringVal]
-            def map
-              StringVal.value(yield(value), usage, position)
-            end
-            #
-            # Objects passed to StringVal.value that don't respond to #to_s are
-            # modeled by this class. Note most everything in Ruby responds to
-            # that method, including things that really shouldn't be considered
-            # StringVals (like Array or Class), so other validation should be
-            # performed on StringVal::NonEmpty values.
-            #
-            class Invalid < StringVal
-              # @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 [StringVal]
-              def map
-                StringVal.value(yield(nil), usage, position)
-              end
-              # @return [String]
-              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("AN.invalid#{id}") + "(#{ansi.invalid(@value.inspect)})"
-              end
-              # @return [String]
-              def to_s
-                ""
-              end
-              # @return [String]
-              def to_x12(truncate = true)
-                ""
-              end
-              # @return [Boolean]
-              def ==(other)
-                eql?(other) or other.nil?
-              end
-            end
-            #
-            # Empty string value. Shouldn't be directly instantiated -- instead,
-            # use the {StringVal.empty} constructor.
-            #
-            class Empty < StringVal
-              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, :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 = {})
-                StringVal.value \
-                  changes.fetch(:value, value),
-                  changes.fetch(:usage, usage),
-                  changes.fetch(:position, position)
-              end
-              def coerce(other)
-                # me, he = other.coerce(self)
-                # me <OP> he
-                return copy(:value => other.to_str), self
-              end
-              def value
-                ""
-              end
-              def valid?
-                true
-              end
-              # @return [String]
-              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("AN.empty#{id}")
-              end
-              # @return [String]
-              def to_s
-                ""
-              end
-              # @return [String]
-              def to_x12(truncate = true)
-                ""
-              end
-            end
-            #
-            # Non-empty string value. Shouldn't be directly instantiated --
-            # instead, use the {StringVal.value} constructor.
-            #
-            class NonEmpty < StringVal
-              include Comparable
-              # @return [String]
-              attr_reader :value
-              # (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, :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(string, usage, position)
-                @value = string
-                super(usage, position)
-              end
-              # @return [StringVal]
-              def copy(changes = {})
-                StringVal.value \
-                  changes.fetch(:value, @value),
-                  changes.fetch(:usage, usage),
-                  changes.fetch(:position, position)
-              end
-              def coerce(other)
-                # me, he = other.coerce(self)
-                # me <OP> he
-                return copy(:value => other.to_str), self
-              end
-              def too_long?
-                @value.lstrip.length > definition.max_length
-              end
-              def too_short?
-                @value.lstrip.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|
-                  "[#{'% 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("AN.value#{id}") + "(#{@value})"
-              end
-              def valid?
-                true
-              end
-              def to_date(format)
-                case format
-                when "D8"  # CCYYMMDD
-                  Date.civil(@value.slice(0, 4).to_i, # year
-                             @value.slice(4, 2).to_i, # month
-                             @value.slice(6, 2).to_i) # day
-                when "DB"  # MMDDCCYY
-                  Date.civil(@value.slice(4, 4).to_i,
-                             @value.slice(0, 2).to_i,
-                             @value.slice(2, 2).to_i)
-                when "DDT" # CCYYMMDD-CCYYMMDDHHMM
-                  Time.utc(@value.slice(0, 4).to_i,     # year
-                           @value.slice(4, 2).to_i,     # month
-                           @value.slice(6, 2).to_i) ..  # day
-                  Time.utc(@value.slice(9, 4).to_i,
-                           @value.slice(13, 2).to_i,
-                           @value.slice(15, 2).to_i,
-                           @value.slice(17, 2).to_i,    # hour
-                           @value.slice(19, 2).to_i)    # minute
-                when "DT"  # CCYYMMDDHHMM
-                  Time.utc(@value.slice(0, 4).to_i,
-                           @value.slice(4, 2).to_i,
-                           @value.slice(6, 2).to_i,
-                           @value.slice(8, 2).to_i,
-                           @value.slice(10, 2).to_i)
-                when "DTD" # CCYYMMDDHHMM-CCYYMMDD
-                  Time.utc(@value.slice(0, 4).to_i,
-                           @value.slice(4, 2).to_i,
-                           @value.slice(6, 2).to_i,
-                           @value.slice(8, 2).to_i,
-                           @value.slice(10, 2).to_i) ..
-                  Time.utc(@value.slice(13, 4).to_i,
-                           @value.slice(15, 2).to_i,
-                           @value.slice(17, 2).to_i)
-                when "DTS" # CCYYMMDDHHMMSS-CCYYMMDDHHMMSS
-                  Time.utc(@value.slice(0, 4).to_i,
-                           @value.slice(4, 2).to_i,
-                           @value.slice(6, 2).to_i,
-                           @value.slice(8, 2).to_i,
-                           @value.slice(10, 2).to_i,
-                           @value.slice(12, 2).to_i) ..
-                  Time.utc(@value.slice(15, 4).to_i,
-                           @value.slice(19, 2).to_i,
-                           @value.slice(21, 2).to_i,
-                           @value.slice(23, 2).to_i,
-                           @value.slice(25, 2).to_i,
-                           @value.slice(27, 2).to_i)
-                when "RD"  # MMDDCCYY-MMDDCCYY
-                  Date.civil(@value.slice(4, 4).to_i,
-                             @value.slice(0, 2).to_i,
-                             @value.slice(2, 2).to_i) ..
-                  Date.civil(@value.slice(13, 4).to_i,
-                             @value.slice(9, 2).to_i,
-                             @value.slice(11, 2).to_i)
-                when "RD8" # CCYYMMDD-CCYYMMDD
-                  Date.civil(@value.slice(0, 4).to_i,
-                             @value.slice(4, 2).to_i,
-                             @value.slice(6, 2).to_i) ..
-                  Date.civil(@value.slice(9, 4).to_i,
-                             @value.slice(13, 2).to_i,
-                             @value.slice(15, 2).to_i)
-                when "RDT" # CCYYMMDDHHMM-CCYYMMDDHHMM
-                  Time.utc(@value.slice(0, 4).to_i,
-                           @value.slice(4, 2).to_i,
-                           @value.slice(6, 2).to_i,
-                           @value.slice(8, 2).to_i,
-                           @value.slice(10, 2).to_i) ..
-                  Time.utc(@value.slice(13, 4).to_i,
-                           @value.slice(15, 2).to_i,
-                           @value.slice(17, 2).to_i,
-                           @value.slice(19, 2).to_i,
-                           @value.slice(21, 2).to_i)
-                when "RTS" # CCYYMMDDHHMMSS
-                  Time.utc(@value.slice(0, 4).to_i,
-                           @value.slice(4, 2).to_i,
-                           @value.slice(6, 2).to_i,
-                           @value.slice(8, 2).to_i,
-                           @value.slice(10, 2).to_i)
-                else
-                  raise ArgumentError,
-                    "Format code #{format} is not recognized"
-                end
-              end
-            end
-          end
-          class << StringVal
-            # @group Constructors
-            ###################################################################
-            # @return [StringVal]
-            def empty(usage, position)
-              self::Empty.new(usage, position)
-            end
-            # @return [StringVal]
-            def value(object, usage, position)
-              if 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 StringVal
-          StringVal.eigenclass.send(:protected, :new)
-          StringVal::Empty.eigenclass.send(:public, :new)
-          StringVal::Invalid.eigenclass.send(:public, :new)
-          StringVal::NonEmpty.eigenclass.send(:public, :new)
-        end
-      end
-    end
-  end
-end

data/lib/stupidedi/versions/functional_groups/004010/element_types/time_val.rb DELETED

@@ -1,331 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-  module Versions
-    module FunctionalGroups
-      module FortyTen
-        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 [String]
-              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
-              # @return [String]
-              def to_s
-                ""
-              end
-              # @return [String]
-              def to_x12(truncate = true)
-                ""
-              end
-              # @return [Boolean]
-              def ==(other)
-                eql?(other)
-              end
-            end
-            #
-            # Empty time value. Shouldn't be directly instantiated -- instead,
-            # use the {TimeVal.empty} constructor.
-            #
-            class Empty < TimeVal
-              def valid?
-                true
-              end
-              def empty?
-                true
-              end
-              # @return [String]
-              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
-              # @return [String]
-              def to_s
-                ""
-              end
-              # @return [String]
-              def to_x12(truncate = true)
-                ""
-              end
-              # @return [Boolean]
-              def ==(other)
-                other.is_a?(Empty) or other.nil?
-              end
-            end
-            #
-            # Non-empty time value. Unlike common models of time, this
-            # encapsulates only an hour, minute, and second (with fractional
-            # seconds) but not a date. Shouldn't be directly instantiated --
-            # instead, use the {TimeVal.value} constructor.
-            #
-            class NonEmpty < TimeVal
-              # @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
-              # @return [NonEmpty]
-              def copy(changes = {})
-                NonEmpty.new \
-                  changes.fetch(:hour, @hour),
-                  changes.fetch(:minute, @minute),
-                  changes.fetch(:second, @second),
-                  changes.fetch(:usage, usage),
-                  changes.fetch(:position, position)
-              end
-              def valid?
-                true
-              end
-              def empty?
-                false
-              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]
-              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"
-                ansi.element("TM.value#{id}") + "(#{hh}:#{mm}:#{ss})"
-              end
-              # @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}"
-              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 do |s|
-                  s.frac.to_s("F").
-                    gsub(/^0*\./, "").
-                    gsub(/0+$/, "")
-                end
-                x12 = "#{hh}#{mm}#{ss}#{ff}"
-                truncate ? x12.take(definition.max_length) : x12
-              end
-              def too_short?
-                to_s(nil, nil, nil).length < definition.min_length
-              end
-              # @return [Boolean]
-              def ==(other)
-                eql?(other) or
-                 (other.hour   == @hour   and
-                  other.minute == @minute and
-                  other.second == @second)
-              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.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+$/
-                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.is_a?(Time)
-                self::NonEmpty.new(object.hour, object.min,
-                                      object.sec.to_d \
-                                      + (object.usec.to_d / 1000000),
-                                      usage, position)
-              elsif object.is_a?(DateTime)
-                self::NonEmpty.new(object.hour, object.min,
-                                      object.sec.to_d \
-                                      + object.sec_fraction.to_d,
-                                      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
-end