stupidedi 1.1.0 → 1.2.1

data/bin/edi-pp

@@ -2,72 +2,47 @@
 require File.expand_path("../../lib/stupidedi", __FILE__)
 require "pp"
 
+# Short-lived processes should win some peformance gains here
+GC.disable
+
 # This will be auto-enabled when $stdout.tty?, but -C forces color output
 require "term/ansicolor" if ARGV.delete("-C")
 
-config = Stupidedi::Config.new
-config.interchange.tap do |c|
-  c.register("00401") { Stupidedi::Versions::Interchanges::FourOhOne::InterchangeDef }
-  c.register("00501") { Stupidedi::Versions::Interchanges::FiveOhOne::InterchangeDef }
-end
-
-config.functional_group.tap do |c|
-  # The 4010 functional group definition doesn't actually have any segment defs,
-  # so the tokenizer makes assumptions (eg, that every element is simple), which
-  # results in tokens that don't match the transaction set definition. This is
-  # only because we linked some 4010 transaction sets to the 5010 definitions.
-  # It would never happen when the transaction set definition is built from the
-  # same set of segment definitions. There might be a good place to detect this
-  # mismatch, but it's not yet implemented.
-  #
-  # c.register("004010") { Stupidedi::Versions::FunctionalGroups::FortyTen::FunctionalGroupDef }
-
-  c.register("004010") { Stupidedi::Versions::FunctionalGroups::FiftyTen::FunctionalGroupDef }
-  c.register("005010") { Stupidedi::Versions::FunctionalGroups::FiftyTen::FunctionalGroupDef }
-end
-
-config.transaction_set.tap do |c|
-  c.register("005010", "HN", "277") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HN277 }
-  c.register("005010", "HP", "835") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HP835 }
-  c.register("005010", "HC", "837") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::HC837 }
-  c.register("005010", "FA", "999") { Stupidedi::Versions::FunctionalGroups::FiftyTen::TransactionSetDefs::FA999 }
-
-  c.register("005010X214", "HN", "277", Stupidedi::Guides::FiftyTen::X214::HN277)
-  c.register("005010X221", "HP", "835", Stupidedi::Guides::FiftyTen::X221::HP835)
-  c.register("005010X222", "HC", "837", Stupidedi::Guides::FiftyTen::X222::HC837P)
-  c.register("005010X231", "FA", "999", Stupidedi::Guides::FiftyTen::X231::FA999)
-
-  c.register("005010X221A1", "HP", "835", Stupidedi::Guides::FiftyTen::X221A1::HP835)
-  c.register("004010X098A1", "HC", "837", Stupidedi::Guides::FiftyTen::X222A1::HC837P)
-  c.register("005010X222A1", "HC", "837", Stupidedi::Guides::FiftyTen::X222A1::HC837P)
-  c.register("005010X231A1", "FA", "999", Stupidedi::Guides::FiftyTen::X231A1::FA999)
-end
+# config = Stupidedi::Config.default
+# config = Stupidedi::Config.contrib
+config = Stupidedi::Config.hipaa
 
 parser = Stupidedi::Builder::StateMachine.build(config)
 start  = Time.now
+nondet = ARGV.delete('-N')
 
 ARGV.each do |path|
+  # Reading the entire input at once is slightly faster than streaming
+  # from a file handle.
+  # content   = File.read(path, :encoding => "ISO-8859-1")
+  # parser, r = parser.read(Stupidedi::Reader.build(content))
+
   File.open(path) do |io|
     parser, result = parser.read(Stupidedi::Reader.build(io))
-    pp result
   end
 end
 
 stop = Time.now
 
-parser.zipper.map{|z| pp z.root.node }.
-  explain { puts "Non-deterministic state" }
-
-begin
-  count  = 0
-  cursor = parser.first
-
-  while cursor.defined?
-    count += 1
-    cursor = cursor.flatmap{|c| c.next }
+parser.zipper.map{|z| pp z.root.node }.explain do
+  # Multiple parse trees (non-deterministic state)
+  unless nondet 
+    puts "Non-deterministic state"
+  else
+    puts "Non-deterministic states (#{parser.active.length}):"
+    puts "#{"-" * 70}\n\n"
+
+    parser.active.each do |state|
+      zipper = state.node.zipper
+      pp zipper.root.node
+      puts "\n#{"-" * 70}\n\n"
+    end
   end
-
-  puts "#{count} segments"
 end
 
 begin

data/doc/Navigating.md

@@ -208,6 +208,7 @@ is not reachable will cause [`#find`][14] to raise an exception. To be clear,
 #### Sibling Segments
 
 <iframe src="images/837P-siblings.png" frameborder="no" scrolling="yes" height="430" width="100%"></iframe>
+<a href="images/837P-siblings.png">View diagram</a>
 
 Segments connected directly by a horizontal dashed black line are siblings and
 are reachable using [`#find`][14]. For instance, from the third `NM1`, the `N3`,
@@ -249,6 +250,7 @@ there are no segments in Loop 2000A that follow the child loops.
 #### Nephew Segments
 
 <iframe src="images/837P-nephews.png" frameborder="no" scrolling="yes" height="450" width="100%"></iframe>
+<a href="images/837P-nephews.png">View diagram</a>
 
 Segments that occur as the _first_ direct child of a sibling node are nephews.
 The siblings that _follow_ the first child are not directly reachable, but they
@@ -281,6 +283,7 @@ problems.
 #### Cousin Segments
 
 <iframe src="images/837P-cousins.png" frameborder="no" scrolling="yes" height="470" width="100%"></iframe>
+<a href="images/837P-cousins.png">View diagram</a>
 
 Segments that occurr as the _first_ child of a sibling of the parent node are
 cousins of the current segment. Similar to the restriction on nephew segments,
@@ -305,6 +308,7 @@ See [Element Constraints](#Element_Constraints) for information on how to find a
 #### Parent Segments
 
 <iframe src="images/837P-parents.png" frameborder="no" scrolling="yes" height="450" width="100%"></iframe>
+<a href="images/837P-parents.png">View diagram</a>
 
 Internal knowledge of the underlying tree structure makes it possible to
 *rewind* to the first segment of a parent structure, using the [`#parent`][15]

data/lib/ruby/array.rb

@@ -159,6 +159,23 @@ class Array
     return prefix, suffix
   end
 
+  # Returns a list of sublists, where each sublist contains only equal
+  # elements. Equality is determined by a two-argument block parameter.
+  # The concatenation of the result is equal to the original argument.
+  #
+  # @example
+  #   "abba".split(//).group_seq(&:==) #=> [["y"], ["a"], ["b", "b"], ["a"]]
+  #
+  # @return [[Array]]
+  def runs(&block)
+    unless empty?
+      as, bs = tail.split_until{|x| block.call(head, x) }
+      head.cons(as).cons(bs.runs(&block))
+    else
+      []
+    end
+  end
+
   # @endgroup
   #############################################################################
 end

data/lib/ruby/blank.rb

@@ -24,8 +24,10 @@ module Enumerable
   #   [1,2].blank?    #=> false
   #   [].blank?       #=> false
   #
-  def blank?
-    empty?
+  unless respond_to?(:blank?)
+    def blank?
+      empty?
+    end
   end
 
   def present?

data/lib/ruby/enumerable.rb

@@ -16,7 +16,7 @@ module Enumerable
     else
       inject(0){|n, e| e == args.first ? n + 1 : n }
     end
-  end
+  end unless method_defined?(:count)
 
   # Accumulate elements using the `+` method, optionally
   # transforming them first using a block
@@ -31,5 +31,5 @@ module Enumerable
     else
       tail.inject(head){|sum,e| sum + e }
     end
-  end
+  end unless method_defined?(:sum)
 end

data/lib/ruby/module.rb

@@ -47,33 +47,5 @@ class Module
   #   end
   #
   # @return [void]
-  def delegate(*params)
-    unless params.last.is_a?(Hash)
-      raise ArgumentError,
-        "last argument must be :to => ..."
-    end
-
-    methods = params.init
-    target  = params.last.fetch(:to) or
-      raise ArgumentError,
-        ":to => ... cannot be nil"
-
-    file, line, = Stupidedi.caller
 
-    for m in methods
-      if m.to_s =~ /=$/
-        class_eval(<<-RUBY, file, line.to_i - 1)
-          def #{m}(value)
-            #{target}.#{m}(value)
-          end
-        RUBY
-      else
-        class_eval(<<-RUBY, file, line.to_i - 1)
-          def #{m}(*args, &block)
-            #{target}.#{m}(*args, &block)
-          end
-        RUBY
-      end
-    end
-  end
 end

data/lib/ruby/to_d.rb

@@ -6,7 +6,7 @@ class BigDecimal
   # @return [BigDecimal] self
   def to_d
     self
-  end
+  end unless method_defined?(:to_d)
 end
 
 class String
@@ -31,7 +31,7 @@ class String
     else
       raise ArgumentError, "#{inspect} is not a valid number"
     end
-  end
+  end unless method_defined?(:to_d)
 end
 
 class Integer
@@ -44,7 +44,7 @@ class Integer
   # @return [BigDecimal]
   def to_d
     BigDecimal(to_s)
-  end
+  end unless method_defined?(:to_d)
 end
 
 class Rational
@@ -57,7 +57,7 @@ class Rational
   # @return [BigDecimal]
   def to_d
     numerator.to_d / denominator.to_d
-  end
+  end unless method_defined?(:to_d)
 end
 
 class Float
@@ -77,5 +77,5 @@ class Float
     # The programmer should convert the Float to a String using whatever
     # precision he chooses, and call #to_d on the String.
     raise TypeError, "cannot convert Float to BigDecimal"
-  end
+  end unless method_defined?(:to_d)
 end

data/lib/ruby/try.rb

@@ -13,17 +13,18 @@ class Object
   #   "non-nil".try(:slice, 0, 3)   #=> "non"
   #   nil.try(:slice, 0, 3)         #=> nil
   #
+
   def try(*args, &block)
     if args.empty?
       yield self
     else
       __send__(*args, &block)
     end
-  end
+  end unless method_defined?(:try)
+
 end
 
 class NilClass
-
   # @group Combinators
   #############################################################################
 
@@ -37,6 +38,7 @@ class NilClass
   #   nil.try(:slice, 0, 3)         #=> nil
   #
   # @return nil
+
   def try(*args)
     self
   end

data/lib/stupidedi.rb

@@ -1,6 +1,8 @@
 require "bigdecimal"
 require "time"
 require "date"
+require "set"
+require "forwardable"
 
 begin
   require "term/ansicolor" if $stdout.tty?
@@ -30,6 +32,7 @@ require "ruby/instance_exec"
 module Stupidedi
   autoload :Builder,      "stupidedi/builder"
   autoload :Config,       "stupidedi/config"
+  autoload :Contrib,      "stupidedi/contrib"
   autoload :Color,        "stupidedi/color"
   autoload :Versions,     "stupidedi/versions"
   autoload :Editor,       "stupidedi/editor"

data/lib/stupidedi/builder.rb

@@ -9,6 +9,7 @@ module Stupidedi
     autoload :Navigation,           "stupidedi/builder/navigation"
     autoload :Tokenization,         "stupidedi/builder/tokenization"
     autoload :StateMachine,         "stupidedi/builder/state_machine"
+    autoload :IdentifierStack,      "stupidedi/builder/identifier_stack"
 
     autoload :AbstractState,        "stupidedi/builder/states/abstract_state"
     autoload :FailureState,         "stupidedi/builder/states/failure_state"

data/lib/stupidedi/builder/builder_dsl.rb

@@ -14,8 +14,8 @@ module Stupidedi
       # @return [Boolean]
       attr_writer :strict
 
-      delegate :pretty_print, :segment, :element, :zipper, :successors,
-        :empty?, :first?, :last?, :deterministic?, :to => :@machine
+      extend Forwardable
+      def_delegators :@machine, :pretty_print, :segment, :element, :zipper, :successors, :empty?, :first?, :last?, :deterministic?
 
       def initialize(machine, strict = true)
         @machine = machine

data/lib/stupidedi/builder/constraint_table.rb

@@ -37,13 +37,39 @@ module Stupidedi
       end
 
       #
-      # Chooses the {Instruction} that pops the fewest number of states. For
+      # Chooses the {Instruction} that pops the greatest number of states. For
       # example, in the X222 837P an HL segment signals the start of a new
       # 2000 loop, but may or may not begin a new Table 2 -- the specifications
-      # aren't actually clear. This rule will avoid creating a new Table 2 if
-      # possible, and instead create a new 2000 loop under the current Table 2.
+      # aren't actually clear. This rule will always create a new Table 2 and
+      # a new 2000 loop under it.
       #
-      class DepthBased < ConstraintTable
+      class Shallowest < ConstraintTable
+        def initialize(instructions)
+          @instructions = instructions
+        end
+
+        # @return [Array<Instruction>]
+        def matches(segment_tok, strict)
+          @__matches ||= begin
+            shallowest = @instructions.head
+
+            @instructions.tail.each do |i|
+              if i.pop_count > shallowest.pop_count
+                shallowest = i
+              end
+            end
+
+            shallowest.cons
+          end
+        end
+      end
+
+      #
+      # The only exception to the rule of preferring the {Instruction} which pops
+      # the greatest number of states is when the {Instruction} is for ISA. We want
+      # to reuse one root {Values::TransmissionVal} container for all children.
+      #
+      class Deepest < ConstraintTable
         def initialize(instructions)
           @instructions = instructions
         end
@@ -80,7 +106,7 @@ module Stupidedi
           invalid = true  # Were all possibly distinguishing elements invalid?
           present = false # Were any possibly distinguishing elements present?
 
-          @__basis ||= basis(deepest(@instructions))
+          @__basis ||= basis(shallowest(@instructions))
           @__basis.head.each do |(n, m), map|
             value = deconstruct(segment_tok.element_toks, n, m)
 
@@ -150,25 +176,25 @@ module Stupidedi
 
         # Resolve conflicts between instructions that have identical SegmentUse
         # values. For each SegmentUse, this chooses the Instruction that pops
-        # the fewest number of states.
+        # the greatest number of states.
         #
         # @return [Array<Instruction>]
-        def deepest(instructions)
-          deepest = Hash.new
+        def shallowest(instructions)
+          shallowest = Hash.new
 
           instructions.each do |i|
             key = i.segment_use.object_id
 
-            if deepest.defined_at?(key)
-              if deepest.at(key).pop_count > i.pop_count
-                deepest[key] = i
+            if shallowest.defined_at?(key)
+              if shallowest.at(key).pop_count < i.pop_count
+                shallowest[key] = i
               end
             else
-              deepest[key] = i
+              shallowest[key] = i
             end
           end
 
-          deepest.values
+          shallowest.values
         end
 
         # @return [Array(Array<(Integer, Integer, Map)>, Array<(Integer, Integer, Map)>)]
@@ -403,7 +429,9 @@ module Stupidedi
             # all the instructions have the same SegmentUse, they also have
             # the same element constraints so we can't use them to narrow
             # down the instruction list.
-            ConstraintTable::DepthBased.new(instructions)
+            instructions.head.segment_id == :ISA ?
+              ConstraintTable::Deepest.new(instructions) :
+              ConstraintTable::Shallowest.new(instructions)
           else
             ConstraintTable::ValueBased.new(instructions)
           end

data/lib/stupidedi/builder/identifier_stack.rb

@@ -0,0 +1,167 @@
+module Stupidedi
+  module Builder
+
+    class IdentifierStack
+      def initialize(id)
+        @state = Empty.new(id)
+      end
+
+      def id
+        @state.id
+      end
+
+      def isa
+        @state = @state.isa
+        @state.id
+      end
+
+      def gs
+        @state = @state.gs
+        @state.id
+      end
+
+      def st
+        @state = @state.st
+        @state.id
+      end
+
+      def hl
+        @state = @state.hl
+        @state.id
+      end
+
+      def pop
+        @state.id.tap { @state = @state.pop }
+      end
+
+      def method_missing(name, *args)
+        @state.__send__(name, *args)
+      end
+
+      # State Representations
+      #########################################################################
+
+      class Empty
+        def initialize(id)
+          @count, @next, @id = 0, id, id
+        end
+
+        def isa
+          ISA.new(self, @next).tap { @count += 1; @next += 1 }
+        end
+
+        # Number of Interchanges (ISA..IEA)
+        def count
+          @count
+        end
+      end
+
+      class ISA
+        attr_reader :id
+
+        def initialize(parent, id)
+          @count, @parent, @next, @id = 0, parent, id, id
+        end
+
+        def gs
+          GS.new(self, @next).tap { @count += 1; @next += 1 }
+        end
+
+        # Number of Functional Groups (GS..GE)
+        def count
+          @count
+        end
+
+        def pop
+          @parent
+        end
+      end
+
+      class GS
+        attr_reader :id
+
+        def initialize(parent, id)
+          @count, @parent, @next, @id = 0, parent, id, id
+        end
+
+        def st
+          ST.new(self, @next).tap { @count += 1; @next += 1 }
+        end
+
+        # GE01 Number of Transaction Sets (within current functional group)
+        #
+        # @return [Integer]
+        def count
+          @count
+        end
+
+        def pop
+          @parent
+        end
+      end
+
+      class ST
+        attr_writer :sequence
+
+        def initialize(parent, id)
+          @sequence, @parent, @id = 0, parent, id
+        end
+
+        def hl
+          HL.new(self, @sequence += 1)
+        end
+
+        def id
+          @id.to_s.rjust(4, "0")
+        end
+
+        # Number of segments (ST..SE)
+        def count(builder)
+          m = Either.success(builder.machine)
+
+          while m.defined?
+            if m.flatmap(&:segment).map{|s| s.node.id == :ST }.fetch(false)
+              return m.flatmap{|n| n.distance(builder.machine) }.fetch(0) + 2
+            else
+              m = m.flatmap(&:parent)
+            end
+          end
+        end
+
+        def pop
+          @parent
+        end
+      end
+
+      class HL
+        attr_writer :sequence
+
+        def initialize(parent, id)
+          @parent, @id, @sequence = parent, id, id
+        end
+
+        def hl
+          HL.new(self, @sequence += 1)
+        end
+
+        def id
+          @id.to_s
+        end
+
+        # Parent HL number
+        def parent
+          case @parent
+          when HL
+            @parent.id
+          end
+        end
+
+        def pop
+          @parent.sequence = @sequence
+          @parent
+        end
+      end
+    end
+
+  end
+end