stupidedi 1.1.0 → 1.2.1

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

@@ -0,0 +1,117 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FortyTen
+        module ElementTypes
+
+          module Operators
+
+            module Unary
+              def unary_operators(*ops)
+                file, line, = Stupidedi.caller
+
+                ops.each do |op|
+                  class_eval(<<-RUBY, file, line.to_i - 1)
+                    def #{op}(&block)
+                      copy(:value => value.__send__(:#{op}, &block))
+                    end
+                  RUBY
+                end
+              end
+            end
+
+            module Binary
+              def binary_operators(*ops)
+                file, line, = Stupidedi.caller
+
+                if ops.last.is_a?(Hash)
+                  options = ops.pop
+
+                  case options[:coerce]
+                  when String, Symbol
+                    coerce = options[:coerce]
+                  else
+                    raise ArgumentError,
+                      "must pass :coerce => :method"
+                  end
+                else
+                  raise ArgumentError,
+                    "must pass :coerce => :method"
+                end
+
+                ops.each do |op|
+                  class_eval(<<-RUBY, file, line.to_i - 1)
+                    def #{op}(other, &block)
+                      if other.respond_to?(:#{coerce})
+                        copy(:value => value.__send__(:#{op}, other.#{coerce}, &block))
+                      elsif other.respond_to?(:coerce)
+                        me, he = other.coerce(self)
+                        copy(:value => me.__send__(:#{op}, he, &block).#{coerce})
+                      else
+                        raise TypeError,
+                          "cannot coerce \#{other.class} to \#{self.class}"
+                      end
+                    end
+                  RUBY
+                end
+              end
+            end
+
+            module Relational
+              def relational_operators(*ops)
+                file, line, = Stupidedi.caller
+
+                if ops.last.is_a?(Hash)
+                  options = ops.pop
+
+                  case options[:coerce]
+                  when String, Symbol
+                    coerce = options[:coerce]
+                  else
+                    raise ArgumentError,
+                      "must pass :coerce => :method"
+                  end
+                else
+                  raise ArgumentError,
+                    "must pass :coerce => :method"
+                end
+
+                ops.each do |op|
+                  class_eval(<<-RUBY, file, line.to_i - 1)
+                    def #{op}(other, &block)
+                      if other.respond_to?(:#{coerce})
+                        value.__send__(:#{op}, other.#{coerce}, &block)
+                      elsif other.respond_to?(:coerce)
+                        me, he = other.coerce(self)
+                        me.__send__(:#{op}, he, &block)
+                      else
+                        raise TypeError,
+                          "cannot coerce \#{other.class} to \#{self.class}"
+                      end
+                    end
+                  RUBY
+                end
+              end
+            end
+
+            module Wrappers
+              def wrappers(*ops)
+                file, line, = Stupidedi.caller
+
+                ops.each do |op|
+                  class_eval(<<-RUBY, file, line.to_i - 1)
+                    def #{op}(*args, &block)
+                      copy(:value => value.__send__(:#{op}, *args, &block))
+                    end
+                  RUBY
+                end
+              end
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -11,7 +11,7 @@ module Stupidedi
           end
 
           #
-          # @see X222.pdf A.1.3.1.4 String
+          # @see X222.pdf B.1.1.3.1.4 String
           #
           class StringVal < Values::SimpleElementVal
 
@@ -27,6 +27,11 @@ module Stupidedi
               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
@@ -52,6 +57,11 @@ module Stupidedi
                 false
               end
 
+              # @return [StringVal]
+              def map
+                StringVal.value(yield(nil), usage, position)
+              end
+
               # @return [String]
               def inspect
                 id = definition.bind do |d|
@@ -74,10 +84,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
 
@@ -86,12 +100,58 @@ module Stupidedi
             # use the {StringVal.empty} constructor.
             #
             class Empty < StringVal
+              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 = {})
+                StringVal.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 StringVal to #{other.class}"
+                end
               end
 
-              def empty?
+              def value
+                ""
+              end
+
+              def valid?
                 true
               end
 
@@ -117,9 +177,9 @@ module Stupidedi
                 ""
               end
 
-              # @return [Boolean]
-              def ==(other)
-                other.is_a?(Empty)
+              # @return [String]
+              def to_x12(truncate = true)
+                ""
               end
             end
 
@@ -128,25 +188,61 @@ module Stupidedi
             # instead, use the {StringVal.value} constructor.
             #
             class NonEmpty < StringVal
+              include Comparable
 
               # @return [String]
               attr_reader :value
 
-              delegate :to_d, :to_s, :to_f, :length, :=~, :match, :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(string, usage, position)
                 @value = string
                 super(usage, position)
               end
 
-              # @return [NonEmpty]
+              # @return [StringVal]
               def copy(changes = {})
-                NonEmpty.new \
+                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
+                if other.respond_to?(:to_str)
+                  return copy(:value => other.to_str), self
+                else
+                  raise TypeError,
+                    "cannot coerce StringVal to #{other.class}"
+                end
+              end
+
               def too_long?
                 @value.lstrip.length > definition.max_length
               end
@@ -155,6 +251,12 @@ module Stupidedi
                 @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|
@@ -176,25 +278,6 @@ module Stupidedi
                 true
               end
 
-              def empty?
-                false
-              end
-
-              # @return [StringVal::NonEmpty]
-              def gsub(*args, &block)
-                copy(:value => @value.gsub(*args, &block))
-              end
-
-              # @return [StringVal::NonEmpty]
-              def upcase
-                copy(:value => @value.upcase)
-              end
-
-              # @return [StringVal::NonEmpty]
-              def downcase
-                copy(:value => @value.downcase)
-              end
-
               def to_date(format)
                 case format
                 when "D8"  # CCYYMMDD
@@ -254,8 +337,8 @@ module Stupidedi
                              @value.slice(4, 2).to_i,
                              @value.slice(6, 2).to_i) ..
                   Date.civil(@value.slice(9, 4).to_i,
-                             @value.slice(11, 2).to_i,
-                             @value.slice(13, 2).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,
@@ -278,16 +361,6 @@ module Stupidedi
                     "Format code #{format} is not recognized"
                 end
               end
-
-              # @return [Boolean]
-              def ==(other)
-                eql?(other) or
-                 (if other.is_a?(NonEmpty)
-                    other.value == @value
-                  else
-                    other == @value
-                  end)
-              end
             end
 
           end
@@ -312,15 +385,6 @@ module Stupidedi
               end
             end
 
-            # @return [StringVal]
-            def parse(string, usage, position)
-              if string.blank?
-                self::Empty.new(usage, position)
-              else
-                self::NonEmpty.new(string.rstrip, usage, position)
-              end
-            end
-
             # @endgroup
             ###################################################################
           end

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

@@ -9,12 +9,12 @@ module Stupidedi
               super(id, name, min_length, max_length, description)
 
               unless min_length == 2 or min_length == 4 or min_length >= 6
-                raise ArgumentError,
+                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 ArgumentError,
+                raise Exceptions::InvalidSchemaError,
                   "max_length must be either 2, 4, 6, or greater"
               end
             end
@@ -25,7 +25,7 @@ module Stupidedi
           end
 
           #
-          # @see X222.pdf A.1.3.1.6 Time
+          # @see X222.pdf B.1.1.3.1.6 Time
           #
           class TimeVal < Values::SimpleElementVal
 
@@ -81,10 +81,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
 
@@ -124,9 +128,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
 
@@ -218,8 +227,31 @@ module Stupidedi
               end
 
               # @return [String]
-              def to_s
-                "#{@hour}#{@minute}#{@second}"
+              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]
@@ -248,9 +280,12 @@ module Stupidedi
                 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_i unless ss.blank? }
+                second = object.to_s.slice(4, 2).try{|ss| ss.to_d unless ss.blank? }
 
                 if decimal = object.to_s.slice(6..-1)
                   second += "0.#{decimal}".to_d
@@ -260,12 +295,14 @@ module Stupidedi
 
               elsif object.is_a?(Time)
                 self::NonEmpty.new(object.hour, object.min,
-                                      object.sec + (object.usec / 1000000.0),
+                                      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 + object.sec_fraction.to_f,
+                                      object.sec.to_d \
+                                      + object.sec_fraction.to_d,
                                       usage, position)
               else
                 self::Invalid.new(object, usage, position)
@@ -274,25 +311,6 @@ module Stupidedi
               self::Invalid.new(object, usage, position)
             end
 
-            # @return [TimeVal]
-            def parse(string, usage, position)
-              if string.blank?
-                self::Empty.new(usage, position)
-              else
-                hour   = string.slice(0, 2).to_i
-                minute = string.slice(2, 2).try{|mm| mm.to_i unless mm.blank? }
-                second = string.slice(4, 2).try{|ss| ss.to_i unless ss.blank? }
-
-                if decimal = string.slice(6..-1)
-                  second += "0.#{decimal}".to_d
-                end
-
-                self::NonEmpty.new(hour, minute, second, usage, position)
-              end
-            rescue Exceptions::InvalidElementError
-              self::Invalid.new(string, usage, position)
-            end
-
             # @endgroup
             ###################################################################
           end