stupidedi 1.1.0

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

@@ -0,0 +1,327 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        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)
+                  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

data/lib/stupidedi/versions/functional_groups/005010/element_types.rb

@@ -0,0 +1,132 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module ElementTypes
+
+          autoload :Operators,
+            "stupidedi/versions/functional_groups/005010/element_types/operators"
+
+          autoload :DateVal,
+            "stupidedi/versions/functional_groups/005010/element_types/date_val"
+
+          autoload :DT,
+            "stupidedi/versions/functional_groups/005010/element_types/date_val"
+
+          autoload :FloatVal,
+            "stupidedi/versions/functional_groups/005010/element_types/float_val"
+
+          autoload :R,
+            "stupidedi/versions/functional_groups/005010/element_types/float_val"
+
+          autoload :IdentifierVal,
+            "stupidedi/versions/functional_groups/005010/element_types/identifier_val"
+
+          autoload :ID,
+            "stupidedi/versions/functional_groups/005010/element_types/identifier_val"
+
+          autoload :FixnumVal,
+            "stupidedi/versions/functional_groups/005010/element_types/fixnum_val"
+
+          autoload :Nn,
+            "stupidedi/versions/functional_groups/005010/element_types/fixnum_val"
+
+          autoload :StringVal,
+            "stupidedi/versions/functional_groups/005010/element_types/string_val"
+
+          autoload :AN,
+            "stupidedi/versions/functional_groups/005010/element_types/string_val"
+
+          autoload :TimeVal,
+            "stupidedi/versions/functional_groups/005010/element_types/time_val"
+
+          autoload :TM,
+            "stupidedi/versions/functional_groups/005010/element_types/time_val"
+
+          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 `String`
+            #
+            # @return [Values::SimpleElementVal]
+            def parse(string, usage)
+              companion.parse(string, usage)
+            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
+
+            # @return [void]
+            def pretty_print(q)
+              type = self.class.name.try{|n| n.split('::').last }
+
+              if type.blank?
+                q.text @id.to_s
+              else
+                q.text "#{type}[#{@id}]"
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/functional_group_def.rb

@@ -0,0 +1,30 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+
+        s = Schema
+        r = ElementReqs
+
+        # Singleton
+        FunctionalGroupDef = Class.new(Schema::FunctionalGroupDef) do
+          # @return [FunctionalGroupVal]
+          def empty
+            Values::FunctionalGroupVal.new(self, [])
+          end
+
+          # @return [Module]
+          def segment_dict
+            SegmentDefs
+          end
+        end.new "005010",
+          # Functional group header
+          [ SegmentDefs::GS.use(1, r::Mandatory, s::RepeatCount.bounded(1)) ],
+
+          # Functional group trailer
+          [ SegmentDefs::GE.use(2, r::Mandatory, s::RepeatCount.bounded(1)) ]
+
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/AK1.rb

@@ -0,0 +1,21 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          AK1 = s::SegmentDef.build(:AK1, "Functional Group Response Header",
+            "To start acknowledgement of a functional group",
+            e::E479 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E28  .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E480 .simple_use(r::Optional,   s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/AK2.rb

@@ -0,0 +1,21 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          AK2 = s::SegmentDef.build(:AK2, "Transaction Set Response Header",
+            "To start acknowledgement of a single transaction set",
+            e::E143 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E329 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E1705.simple_use(r::Optional,   s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/AK9.rb

@@ -0,0 +1,28 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          AK9 = s::SegmentDef.build(:AK9, "Functional Group Response Trailer",
+            "To acknowledge acceptance or rejection of a functional group and report the number of included transaction sets from the original trailer, the accepted sets, and the received sets in this functional group",
+            e::E715 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E97  .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E123 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E2   .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E716 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E716 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+
+            e::E716 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E716 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E716 .simple_use(r::Optional,   s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/AMT.rb

@@ -0,0 +1,21 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          AMT = s::SegmentDef.build(:AMT, "Monetary Amount Information",
+            "To indicate the total monetary amount",
+            e::E522 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E782 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E478 .simple_use(r::Optional,   s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/BHT.rb

@@ -0,0 +1,24 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          BHT = s::SegmentDef.build(:BHT, "Beginning of Hierarchical Transaction",
+            "To define the business hierarchical structure of the transaction set and identify the business application purpose and reference data, i.e., number, date, and time",
+            e::E1005.simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E353 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E127 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E373 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E337 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E640 .simple_use(r::Optional,   s::RepeatCount.bounded(1)))
+
+        end
+      end
+    end
+  end
+end

data/lib/stupidedi/versions/functional_groups/005010/segment_defs/BPR.rb

@@ -0,0 +1,49 @@
+module Stupidedi
+  module Versions
+    module FunctionalGroups
+      module FiftyTen
+        module SegmentDefs
+
+          s = Schema
+          e = ElementDefs
+          r = ElementReqs
+
+          BPR = s::SegmentDef.build(:BPR, "Financial Information",
+            "To indicate the beginning of a Payment Order/Remittance Advice Transaction Set and total payment amount, or to enable related transfer of funds and/or information from payer to payee to occur",
+            e::E305 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E782 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E478 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E591 .simple_use(r::Mandatory,  s::RepeatCount.bounded(1)),
+            e::E812 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E506 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+
+            e::E507 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E569 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E508 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E509 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E510 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E506 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+
+            e::E507 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E569 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E508 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E373 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E1048.simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E506 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+
+            e::E507 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+            e::E569 .simple_use(r::Optional,   s::RepeatCount.bounded(1)),
+            e::E508 .simple_use(r::Relational, s::RepeatCount.bounded(1)),
+
+            SyntaxNotes::P.build( 6,  7),
+            SyntaxNotes::C.build( 8,  9),
+            SyntaxNotes::P.build(12, 13),
+            SyntaxNotes::C.build(14, 15),
+            SyntaxNotes::P.build(18, 19),
+            SyntaxNotes::C.build(20, 21))
+
+        end
+      end
+    end
+  end
+end