stupidedi 1.1.0

data/lib/stupidedi/thread_local.rb

@@ -0,0 +1,174 @@
+module Stupidedi
+
+  #
+  # @example
+  #   t = ThreadLocalVal("default")
+  #   t.get           #=> "default"
+  #   t.set("value")  #=> "value"
+  #
+  #   Thread.new { t.get }.value                  #=> "default"
+  #   Thread.new { t.set(:vanish); t.get }.value  #=> :vanish
+  #
+  #   t.get           #=> "value"
+  #
+  class ThreadLocalVar
+    include Inspect
+
+    def initialize(value)
+      @value   = value
+      @threads = Hash.new
+      @cleaner = lambda {|key| @threads.delete(key) }
+    end
+
+    def get
+      @threads.fetch(key) do
+        case @value
+        when Numeric, Symbol, nil
+          # These are immutable values and can't be cloned
+          @value
+        else
+          finalizer(Thread.current)
+          @threads[key] = @value.clone
+        end
+      end
+    end
+
+    # @return value
+    def set(value)
+      unless @threads.include?(key)
+        finalizer(Thread.current)
+      end
+
+      @threads[key] = value
+    end
+
+    def unset
+      @threads.delete(key)
+    end
+
+    def set?
+      @threads.include?(key)
+    end
+
+  private
+
+    # @return [Numeric]
+    def key
+      Thread.current.object_id
+    end
+
+    # @return [void]
+    def finalizer(thread)
+      ObjectSpace.define_finalizer(thread, @cleaner)
+    end
+
+  end
+
+  #
+  # @example
+  #   class Counter
+  #     delegate :current, :current=, :to => @threadlocal
+  #
+  #     def counter(start)
+  #       @threadlocal = ThreadLocalHash.new(:current => start)
+  #     end
+  #   end
+  #
+  #   counter = Counter.new(50)
+  #
+  #   x = Thread.new { 200.times { counter.current += 1 }; counter.current }
+  #   y = Thread.new { 300.times { counter.current += 1 }; counter.current }
+  #
+  #   x.value         #=> 250
+  #   x.value         #=> 350
+  #   counter.current #=> 50
+  #
+  class ThreadLocalHash
+    include Inspect
+
+    def initialize(defaults = {})
+      @defaults = defaults.clone
+      @threads  = Hash.new
+      @cleaner  = lambda {|key| @threads.delete_if{|(t,_),_| t == key }}
+
+      defaults.keys.each do |name|
+        case defaults[name]
+        when Numeric, Symbol, nil
+          # These are immutable values and can't be cloned
+          instance_eval <<-RUBY
+            def #{name}
+              @threads.fetch([key, :#{name}]) do
+                @defaults[:#{name}]
+              end
+            end
+          RUBY
+        else
+          instance_eval <<-RUBY
+            def #{name}
+              @threads.fetch([key, :#{name}]) do
+                finalizer(Thread.current)
+                @threads[[key, :#{name}]] =
+                  @defaults[:#{name}].clone
+              end
+            end
+          RUBY
+        end
+
+        instance_eval <<-RUBY
+          def #{name}=(value)
+            unless @threads.include?(key)
+              finalizer(Thread.current)
+            end
+
+            @threads[[key, :#{name}]] = value
+          end
+        RUBY
+      end
+    end
+
+    def [](name)
+      @threads.fetch([Thread.current, name]) do
+        case value = @defaults[name]
+        when Numeric, Symbol, nil
+          # These are immutable values and can't be cloned
+          value
+        else
+          finalizer(Thread.current)
+          @threads[[key, name]] = value.clone
+        end
+      end
+    end
+
+    def []=(name, value)
+      unless @threads.include?(key)
+        finalizer(Thread.current)
+      end
+
+      @threads[[key, name]] = value
+    end
+
+  private
+
+    def key
+      Thread.current.object_id
+    end
+
+    # @return [void]
+    def finalizer(thread)
+      ObjectSpace.define_finalizer(thread, @cleaner)
+    end
+
+    def method_missing(name, value = (getter = true))
+      if getter
+        self[name]
+      else
+        if name.to_s =~ /^(.+)=$/
+          self[$1.to_sym] = value
+        else
+          super
+        end
+      end
+    end
+
+  end
+end

data/lib/stupidedi/values/abstract_element_val.rb

@@ -0,0 +1,19 @@
+module Stupidedi
+  module Values
+
+    class AbstractElementVal < AbstractVal
+
+      # (see AbstractVal#element?)
+      # @return true
+      def element?
+        true
+      end
+
+      # (see AbstractVal#size)
+      def size
+        0
+      end
+    end
+
+  end
+end

data/lib/stupidedi/values/abstract_val.rb

@@ -0,0 +1,130 @@
+module Stupidedi
+  module Values
+
+    class AbstractVal
+      include Inspect
+      include Color
+
+      # @return [SimpleElementDef, CompositeElementDef, LoopDef, SegmentDef, TableDef]
+      abstract :definition
+
+      # @see X222.pdf B.1.3.10 Absence of Data
+      def empty?
+        @children.all?(&:empty?)
+      end
+
+      abstract :leaf?
+
+      # Number of segments in this subtree
+      #
+      # @return [Integer]
+      def size
+        @children.sum(&:size)
+      end
+
+      # True except for {InvalidSegmentVal} and {AbstractElementVal} values
+      # that could not be parsed -- "abc" in a numeric field, for example.
+      def valid?
+        true
+      end
+
+      def invalid?
+        not valid?
+      end
+
+      # Is the element not blank?
+      def present?
+        not empty?
+      end
+
+      # Is the element not present?
+      def blank?
+        empty?
+      end
+
+      # Is this a {TransmissionVal}?
+      def transmission?
+        false
+      end
+
+      # Is this an {InterchangeVal}?
+      def interchange?
+        false
+      end
+
+      # Is this an {FunctionalGroupVal}?
+      def functional_group?
+        false
+      end
+
+      # Is this an {TransactionSetVal}?
+      def transaction_set?
+        false
+      end
+
+      # Is this a {TableVal}?
+      def table?
+        false
+      end
+
+      # Is this a {LoopVal}?
+      def loop?
+        false
+      end
+
+      # Is this a {SegmentVal} or {InvalidSegmentVal}?
+      def segment?
+        false
+      end
+
+      # Is this a {AbstractElementVal}?
+      def element?
+        false
+      end
+
+      # Is this a {CompositeElementVal}?
+      def composite?
+        false
+      end
+
+      # Is this a component {SimpleElementVal}?
+      def component?
+        false
+      end
+
+      # Is this a repeated {AbstractElementVal}?
+      def repeated?
+        false
+      end
+
+      # Is this a non-component {SimpleElementVal}?
+      def simple?
+        false
+      end
+
+      # Is this a simple element that represents a separator (delimiter)? For
+      # instance, ISA16 represents the repetition separator in version 00501.
+      def separator?
+        false
+      end
+
+      # Returns the set of characters that are used as data in this subtree, not
+      # including the separator (delimiter) elements found in the ISA segment.
+      #
+      # @return [AbstractSet<String>]
+      def characters(result = Sets.absolute([], Reader::C_BYTES.split(//)))
+        if leaf?
+          if present? and not separator?
+            result | to_x12.split(//)
+          else
+            result
+          end
+        else
+          children.inject(result){|r,c| c.characters(r) }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/stupidedi/values/composite_element_val.rb

@@ -0,0 +1,95 @@
+module Stupidedi
+  module Values
+
+    #
+    # @see X222.pdf B.1.1.3.3 Composite Data Structure
+    #
+    class CompositeElementVal < AbstractElementVal
+
+      # @return [CompositeElementDef]
+      delegate :definition, :to => :@usage
+
+      # @return [Array<SimpleElementVal>]
+      attr_reader :children
+      alias component_vals children
+
+      # @return [CompositeElementUse]
+      attr_reader :usage
+
+      delegate :position, :to => "@children.head"
+
+      def initialize(children, usage)
+        @children, @usage =
+          children, usage
+      end
+
+      # @return [CompositeElementVal]
+      def copy(changes = {})
+        CompositeElementVal.new \
+          changes.fetch(:children, @children),
+          changes.fetch(:usage, @usage)
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      # (see AbstractVal#composite?)
+      # @return true
+      def composite?
+        true
+      end
+
+      # @return [SimpleElementVal]
+      def element(n)
+        unless n > 0
+          raise ArgumentError,
+            "n must be positive"
+        end
+
+        @children.at(n - 1)
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = definition.bind do |d|
+          "[#{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
+
+        q.text(ansi.composite("CompositeElementVal#{id}"))
+
+        if empty?
+          q.text(ansi.composite(".empty"))
+        else
+          q.group(2, "(", ")") do
+            q.breakable ""
+            @children.each do |e|
+              unless q.current_group.first?
+                q.text ", "
+                q.breakable
+              end
+              q.pp e
+            end
+          end
+        end
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == definition and
+          other.children   == @children)
+      end
+    end
+
+  end
+end

data/lib/stupidedi/values/functional_group_val.rb

@@ -0,0 +1,102 @@
+module Stupidedi
+  module Values
+
+    #
+    # @see X222.pdf B.1.1.3.13 Functional Group
+    # @see X222.pdf B.1.1.4.2 Functional Groups
+    #
+    class FunctionalGroupVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [FunctionalGroupDef]
+      attr_reader :definition
+
+      # @return [Array<SegmentVal, TransactionSetVal>]
+      attr_reader :children
+
+      delegate :position, :to => "@children.head"
+
+      def initialize(definition, children)
+        @definition, @children =
+          definition, children
+      end
+
+      # @return [FunctionalGroupVal]
+      def copy(changes = {})
+        FunctionalGroupVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children)
+      end
+
+      # (see AbstractVal#functional_group?)
+      # @return true
+      def functional_group?
+        true
+      end
+
+      # @return [String, nil]
+      def version
+        if at(6) == "X"
+          at(7).to_s.slice(0, 3)
+        end
+      end
+
+      # @return [String, nil]
+      def release
+        if at(6) == "X"
+          at(7).to_s.slice(0, 4)
+        end
+      end
+
+      # @return [String, nil]
+      def subrelease
+        if at(6) == "X"
+          at(7).to_s.slice(0, 5)
+        end
+      end
+
+      # @return [String, nil]
+      def implementation
+        if at(6) == "X"
+          at(7).to_s.slice(6, 4)
+        end
+      end
+
+      # @return [Module]
+      def segment_dict
+        @definition.segment_dict
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.envelope("FunctionalGroupVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ", "
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.envelope("Group") << "(#{@children.map(&:inspect).join(', ')})"
+      end
+
+      def ==(other)
+        eql?(other) or
+          (other.definition == @definition or
+           other.children   == @children)
+      end
+    end
+
+  end
+end

data/lib/stupidedi/values/interchange_val.rb

@@ -0,0 +1,86 @@
+module Stupidedi
+  module Values
+
+    #
+    # @see X12-5.pdf 3.2.1 Basic Interchange Service Request
+    # @see X222.pdf B.1.1.4.1 Interchange Control Structures
+    #
+    class InterchangeVal < AbstractVal
+      include SegmentValGroup
+
+      # @return [InterchangeDef]
+      attr_reader :definition
+
+      # @return [Array<SegmentVal, FunctionalGroupVal>]
+      attr_reader :children
+
+      delegate :position, :to => "@children.head"
+
+      def initialize(definition, children, separators)
+        @definition, @children, @separators =
+          definition, children, separators
+      end
+
+      # @return [InterchangeVal]
+      def copy(changes = {})
+        InterchangeVal.new \
+          changes.fetch(:definition, @definition),
+          changes.fetch(:children, @children),
+          changes.fetch(:separators, @separators)
+      end
+
+      # (see AbstractVal#interchange?)
+      # @return true
+      def interchange?
+        true
+      end
+
+      # @return [Module]
+      def segment_dict
+        @definition.segment_dict
+      end
+
+      # Note these will not contain the element and segment terminator, because
+      # those are not values stored as part of the interchange. Those values are
+      # stored in the state machine and can be retrieved by calling #separators
+      # on StateMachine
+      #
+      # @return [Reader::Separators]
+      def separators
+        @separators.merge(definition.separators(@children.find(&:segment?)))
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        id = @definition.try do |d|
+          ansi.bold("[#{d.id.to_s}]")
+        end
+
+        q.text(ansi.envelope("InterchangeVal#{id}"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ", "
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.envelope("Interchange") << "(#{@children.map(&:inspect).join(', ')})"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        eql?(other) or
+         (other.definition == @definition and
+          other.children   == @children)
+      end
+    end
+
+  end
+end

data/lib/stupidedi/values/invalid_envelope_val.rb

@@ -0,0 +1,61 @@
+module Stupidedi
+  module Values
+
+    class InvalidEnvelopeVal < AbstractVal
+
+      # @return [Array<SegmentVal>]
+      attr_reader :children
+
+      delegate :position, :to => "@children.head"
+
+      def initialize(children)
+        @children = children
+      end
+
+      # @return [SegmentVal]
+      def copy(changes = {})
+        InvalidEnvelopeVal.new(changes.fetch(:children, @children))
+      end
+
+      # (see AbstractVal#size)
+      def size
+        0
+      end
+
+      # @return false
+      def leaf?
+        false
+      end
+
+      def valid?
+        false
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text(ansi.segment("InvalidEnvelopeVal"))
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.text @children.first.reason
+          q.text ","
+          q.breakable
+
+          @children.each do |e|
+            unless q.current_group.first?
+              q.text ","
+              q.breakable
+            end
+            q.pp e
+          end
+        end
+      end
+
+      # @return [String]
+      def inspect
+        ansi.invalid("InvalidEnvelopeVal") <<
+          "(#{@children.map(&:inspect).join(', ')})"
+      end
+    end
+
+  end
+end