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

stupidedi 1.3.23 → 1.4.0

Files changed (2005) hide show

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  module Refinements
-    refine Symbol do
-      # Returns a proc that calls self on the proc's parameter
-      #
-      # @example
-      #   [1, 2, 3].map(&:-@)       #=> [-1, -2, -3]
-      #   [-1, -2, -3].map(&:abs)   #=> [1, 2, 3]
-      #
-      def to_proc
-        lambda{|*args| args.head.__send__(self, *args.tail) }
-      end
-      # Calls self on the given receiver
-      #
-      # @example
-      #   :to_s.call(100)           #=> "100"
-      #   :join.call([1,2,3], "-")  #=> "1-2-3"
-      #
-      def call(receiver, *args)
-        receiver.__send__(self, *args)
-      end
-    end
-  end
-end

data/lib/stupidedi/blank_slate.rb DELETED

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  BlankSlate =
-    if RUBY_VERSION < "1.9"
-      require "blankslate"
-      ::BlankSlate
-    else
-      ::BasicObject
-    end
-end

data/lib/stupidedi/builder/builder_dsl.rb DELETED

@@ -1,293 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-  module Builder
-    class BuilderDsl
-      include Inspect
-      include Tokenization
-      # @private
-      SEGMENT_ID = /^[A-Z][A-Z0-9]{1,2}$/
-      # @return [StateMachine]
-      attr_reader :machine
-      # @return [Boolean]
-      attr_writer :strict
-      # @return [DslReader]
-      attr_reader :reader
-      def_delegators :@machine, :pretty_print, :segment, :element, :zipper, :successors, :empty?, :first?, :last?, :deterministic?
-      def initialize(machine, strict = true)
-        @machine = machine
-        @strict  = strict
-        @reader  = DslReader.new(Reader::Separators.empty,
-                                 Reader::SegmentDict.empty)
-      end
-      def respond_to_missing?(name, include_private = false)
-        SEGMENT_ID =~ name.to_s || super
-      end
-      def strict?
-        @strict
-      end
-      # @return [BuilderDsl]
-      def segment!(name, position, *elements)
-        segment_tok     = mksegment_tok(@reader.segment_dict, name, elements, position)
-        machine, reader = @machine.insert(segment_tok, @reader)
-        if @strict
-          unless machine.deterministic?
-            matches = machine.active.map do |m|
-              segment_def = m.node.zipper.node.definition
-              "#{segment_def.id} #{segment_def.name}"
-            end.join(", ")
-            raise Exceptions::ParseError,
-              "non-deterministic machine state: #{matches}"
-          end
-          # Validate the new segment (recursively, including its children)
-          machine.active.each{|m| critique(m.node.zipper) }
-          # We want to detect when we've ended a syntax node (or more), like
-          # starting a new interchange will end all previously "open" syntax
-          # nodes. So we compare the state before adding `segment_tok` to the
-          # corresponding state after we've added `segment_tok`.
-          machine.prev.tap do |prev|
-            prev.active.zip(machine.active) do |p, q|
-              # If the new state `q` is a descendent of `p`, we know that `p`
-              # and all of its ancestors are unterminated. However, if `q` is
-              # not a descendent of `p`, but is a descendent of one of `p`s
-              # descendents, then `p` and perhaps some of its ancestors were
-              # terminated when the state transitioned to `q`.
-              qancestors = Set.new
-              # Operate on the syntax tree (instead of the state tree)
-              q = q.node.zipper
-              p = p.node.zipper
-              while q.respond_to?(:parent)
-                qancestors << q.parent
-                q = q.parent
-              end
-              while p.respond_to?(:parent)
-                break if qancestors.include?(p)
-                # Now that we're sure that this syntax node (loop, table, etc)
-                # is done being constructed, we can perform more validations.
-                critique(p)
-                p = p.parent
-              end
-            end
-          end
-        end
-        @machine = machine
-        @reader  = reader
-        self
-      end
-    private
-      def method_missing(name, *args)
-        if SEGMENT_ID =~ name.to_s
-          segment!(name, Reader::Position.caller(2), *args)
-        else
-          super
-        end
-      end
-      # The `zipper` argument should be a _completed_ syntax node, meaning all
-      # children have already been added. This is invariably true for segments,
-      # because the {StateMachine} does not accept smaller units of syntax.
-      def critique(zipper, descriptor = "")
-        if zipper.node.simple? or zipper.node.component?
-          if zipper.node.invalid?
-            raise Exceptions::ParseError,
-              "invalid element #{descriptor}"
-          elsif zipper.node.blank?
-            if zipper.node.usage.required?
-              raise Exceptions::ParseError,
-                "required element #{descriptor} is blank"
-            end
-          elsif zipper.node.usage.forbidden?
-            raise Exceptions::ParseError,
-              "forbidden element #{descriptor} is present"
-          elsif not zipper.node.allowed?
-            raise Exceptions::ParseError,
-              "value #{zipper.node.to_s} not allowed in element #{descriptor}"
-          elsif zipper.node.too_long?
-            raise Exceptions::ParseError,
-              "value is too long in element #{descriptor}"
-          elsif zipper.node.too_short?
-            raise Exceptions::ParseError,
-              "value is too short in element #{descriptor}"
-          end
-        elsif zipper.node.composite?
-          if zipper.node.blank?
-            if zipper.node.usage.required?
-              raise Exceptions::ParseError,
-                "required element #{descriptor} is blank"
-            end
-          elsif zipper.node.usage.forbidden?
-            raise Exceptions::ParseError,
-              "forbidden element #{descriptor} is present"
-          else
-            if zipper.node.present?
-              zipper.children.each_with_index do |z, i|
-                critique(z, "#{descriptor}-#{'%02d' % (i + 1)}")
-              end
-              d = zipper.node.definition
-              d.syntax_notes.each do |s|
-                unless s.satisfied?(zipper)
-                  raise Exceptions::ParseError,
-                    "for element #{descriptor}, #{s.reason(zipper)}"
-                end
-              end
-            end
-          end
-        elsif zipper.node.repeated?
-          zipper.children.each{|z| critique(z) }
-        elsif zipper.node.segment?
-          descriptor = zipper.node.id
-          if zipper.node.invalid?
-            if zipper.up.node.invalid?
-              raise Exceptions::ParseError,
-                zipper.first.node.reason
-            else
-              raise Exceptions::ParseError,
-                "invalid #{descriptor} segment"
-            end
-          else
-            zipper.children.each_with_index do |z, i|
-              critique(z, "#{descriptor}#{'%02d' % (i + 1)}")
-            end
-            d = zipper.node.definition
-            d.syntax_notes.each do |s|
-              raise Exceptions::ParseError,
-                "for segment #{descriptor}, #{s.reason(zipper)}" \
-                unless s.satisfied?(zipper)
-            end
-          end
-        elsif zipper.node.loop?
-          critique_occurences zipper,
-            "loop #{zipper.node.definition.id}"
-        elsif zipper.node.table?
-          critique_occurences zipper,
-            "table #{zipper.node.definition.id}"
-        elsif zipper.node.transaction_set?
-          # @todo
-        elsif zipper.node.functional_group?
-          critique_occurences zipper,
-            "functional group #{zipper.node.definition.id}"
-        elsif zipper.node.interchange?
-          critique_occurences zipper,
-            "interchange #{zipper.node.definition.id}"
-        elsif zipper.node.transmission?
-          # @todo
-        end
-      end
-      def critique_occurences(zipper, name)
-        occurences = Hash.new{|h,k| h[k] = 0 }
-        zipper.children.each do |child|
-          if child.node.respond_to?(:usage)
-            occurences[child.node.usage] += 1
-          else
-            occurences[child.node.definition] += 1
-          end
-        end
-        zipper.node.definition.children.each do |child|
-          bound = child.repeat_count
-          count = occurences.at(child)
-          type =
-            if child.segment?
-              "segment"
-            elsif child.loop?
-              "loop"
-            elsif child.table?
-              "table"
-            else
-              "node"
-            end
-          if count.zero? and child.required?
-            raise Exceptions::ParseError,
-              "required #{type} #{child.id} is missing from #{name}"
-          elsif bound < count
-            raise Exceptions::ParseError,
-              "#{type} #{child.id} occurs too many times in #{name}"
-          end
-        end
-      end
-      # @endgroup
-      #########################################################################
-    end
-    class << BuilderDsl
-      # @group Constructors
-      #########################################################################
-      # @return [BuilderDsl]
-      def build(config, strict = true)
-        new(StateMachine.build(config), strict)
-      end
-      # @endgroup
-      #########################################################################
-    end
-    # @private
-    class DslReader
-      # @return [Reader::Separators]
-      attr_reader :separators
-      # @return [Reader::SegmentDict]
-      attr_reader :segment_dict
-      def initialize(separators, segment_dict)
-        @separators, @segment_dict = separators, segment_dict
-      end
-      # @return [DslReader]
-      def copy(changes = {})
-        @separators   = changes.fetch(:separators, @separators)
-        @segment_dict = changes.fetch(:segment_dict, @segment_dict)
-        self
-      end
-      def stream?
-        false
-      end
-    end
-  end
-end

data/lib/stupidedi/builder/constraint_table.rb DELETED

@@ -1,476 +0,0 @@
-# frozen_string_literal: true
-module Stupidedi
-  using Refinements
-  module Builder
-    #
-    # The {ConstraintTable} is a data structure that contains one or more
-    # {Instruction} values for the same segment identifier. Each concrete
-    # subclass implements different strategies for narrowing down the
-    # {Instruction} list.
-    #
-    # Reducing the number of valid {Instruction} values is important because
-    # executing more than one {Instruction} creates a non-deterministic state --
-    # more than one valid parse tree exists -- which slows the parser. Most
-    # often there is only one valid {Instruction} but the parser cannot
-    # (efficiently or at all) narrow the tree down without evaluating the
-    # constraints declared by each {Instruction}'s {Schema::SegmentUse}, which
-    # is done here.
-    #
-    class ConstraintTable
-      # @return [Array<Instruction>]
-      abstract :matches, :args => %w(segment_tok)
-      # @return [Array<Instruction>]
-      attr_reader :instructions
-      #
-      # Performs no filtering of the {Instruction} list. This is used when there
-      # already is a single {Instruction} or when a {Reader::SegmentTok} doesn't
-      # provide any more information to filter the list.
-      #
-      class Stub < ConstraintTable
-        def initialize(instructions)
-          @instructions = instructions
-        end
-        # @return [Array<Instruction>]
-        def matches(segment_tok, strict)
-          @instructions
-        end
-      end
-      #
-      # 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 always create a new Table 2 and
-      # a new 2000 loop under it.
-      #
-      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
-        # @return [Array<Instruction>]
-        def matches(segment_tok, strict)
-          @__matches ||= begin
-            deepest = @instructions.head
-            @instructions.tail.each do |i|
-              if i.pop_count < deepest.pop_count
-                deepest = i
-              end
-            end
-            deepest.cons
-          end
-        end
-      end
-      #
-      # Chooses the subset of {Instruction} values based on the distinguishing
-      # values allowed by each {Schema::SegmentUse}. For instance, there are
-      # often several loops that begin with `NM1`, which are distinguished by
-      # the qualifier in element `NM101`.
-      #
-      class ValueBased < ConstraintTable
-        def initialize(instructions)
-          @instructions = instructions
-        end
-        # @return [Array<Instruction>]
-        def matches(segment_tok, strict)
-          invalid = true  # Were all present possibly distinguishing elements invalid?
-          present = false # Were any possibly distinguishing elements present?
-          disjoint, distinct = basis(@instructions)
-          # First check single elements that can narrow the search space to
-          # a single matching Instruction.
-          disjoint.each do |(n, m), map|
-            value = deconstruct(segment_tok.element_toks, n, m)
-            case value
-            when nil, :not_used, :default
-              # value wasn't present in segment_tok, can't use it to decide
-            else
-              singleton = map.at(value)
-              present   = true
-              unless singleton.nil?
-                # Success, search is terminated
-                return singleton
-              else
-                if strict
-                  designator = "#{segment_tok.id}#{'%02d' % (n + 1)}"
-                  designator = designator + "-%02d" % m unless m.nil?
-                  raise ArgumentError,
-                    "#{value.inspect} is not allowed in #{designator}"
-                end
-              end
-            end
-          end
-          # If we reach this line, none of the present elements could, on its
-          # own, narrow the search space to a single Instruction. We now test
-          # the combination of elements to iteratively narrow the search space
-          space = @instructions
-          # @todo: These filters could be ordered by probable effectiveness,
-          # so we narrow the search space by the largest amount in the fewest
-          # number of steps.
-          distinct.each do |(n, m), map|
-            value = deconstruct(segment_tok.element_toks, n, m)
-            unless value.nil?
-              # Lookup which instructions are compatible with this input
-              subset  = map.at(value)
-              present = true
-              unless subset.blank?
-                invalid = false
-                space  &= subset
-                if space.length <= 1
-                  # Success, search is terminated
-                  return space
-                end
-              else
-                # This value isn't compatible with any instruction
-                if strict
-                  designator = "#{segment_tok.id}#{'%02d' % n}"
-                  designator = designator + "-%02d" % m unless m.nil?
-                  raise ArgumentError,
-                    "#{value.inspect} is not allowed in #{designator}"
-                end
-              end
-            end
-          end
-          if invalid and present
-            # Some elements were present, but all contained invalid values, and
-            # even ignoring those we could not narrow the matches to a single
-            # instruction.
-            #
-            # We could return the remaining search space, but it is safest to
-            # mark this as an invalid segment and avoid the non-determinism
-            []
-          else
-            # Some elements were present and none were invalid, but it was not
-            # possible to narrow the set of matches to a single instruction.
-            #
-            # It seems wrong to mark the segment invalid. The worst thing you
-            # could say about the input is that it may have been missing a
-            # required element that could have resolved the ambiguity; but it's
-            # also possible all required elements were present and the grammar
-            # is the problem (not the input). So here we return the remaining
-            # search space, which will cause non-determinism in the parser.
-            space
-          end
-        end
-        # Resolve conflicts between instructions that have identical SegmentUse
-        # values. For each SegmentUse, this chooses the Instruction that pops
-        # the greatest number of states.
-        #
-        # @return [Array<Instruction>]
-        def shallowest(instructions)
-          shallowest = Hash.new
-          instructions.each do |i|
-            key = i.segment_use.object_id
-            if shallowest.defined_at?(key)
-              if shallowest.at(key).pop_count < i.pop_count
-                shallowest[key] = i
-              end
-            else
-              shallowest[key] = i
-            end
-          end
-          shallowest.values
-        end
-        # @return [Array(Array<(Integer, Integer, Map)>, Array<(Integer, Integer, Map)>)]
-        def basis(instructions)
-          @__basis ||= begin
-            instructions      = shallowest(instructions)
-            disjoint_elements = []
-            distinct_elements = []
-            # The first SegmentUse is used to represent the structure that must
-            # be shared by the others: number of elements and type of elements
-            element_uses = instructions.head.segment_use.definition.element_uses
-            # Iterate over each element across all SegmentUses (think columns)
-            #   NM1*[IL]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
-            #   NM1*[40]*[  ]*..*..*..*..*..*[  ]*..*..*{..}*..
-            element_uses.length.times do |n|
-              if element_uses.at(n).composite?
-                ms = 0 .. element_uses.at(n).definition.component_uses.length - 1
-              else
-                ms = [nil]
-              end
-              # If this is a composite element, we iterate over each component.
-              # Otherwise this loop iterates once with the index {m} set to nil.
-              ms.each do |m|
-                last  = nil        # the last subset we examined
-                total = Sets.empty # the union of all examined subsets
-                distinct = false
-                disjoint = true
-                instructions.each do |i|
-                  element_use = i.segment_use.definition.element_uses.at(n)
-                  unless m.nil?
-                    element_use = element_use.definition.component_uses.at(m)
-                  end
-                  allowed_vals = element_use.allowed_values
-                  # We want to know if every instruction's set of allowed values
-                  # is disjoint (with one another). Instead of comparing each set
-                  # with every other set, which takes (N-1)! comparisons, we can
-                  # do it in N steps.
-                  disjoint &&= allowed_vals.disjoint?(total)
-                  # We also want to know if one instruction's set of allowed vals
-                  # contains elements that aren't present in at least one other
-                  # set. The opposite condition is easy to test: all sets contain
-                  # the same elements (are equal). So we can similarly, check this
-                  # condition in N steps rather than (N-1)!
-                  distinct ||= allowed_vals != last unless last.nil?
-                  total = allowed_vals.union(total)
-                  last  = allowed_vals
-                end
-              # puts "#{n}.#{m}: disjoint(#{disjoint}) distinct(#{distinct})"
-                if disjoint
-                  # Since each instruction's set of allowed values is disjoint, we
-                  # can build a function/hash that returns the single instruction,
-                  # given one of the values. When given a value outside the set of
-                  # all (combined) values, it returns nil.
-                  disjoint_elements << [[n, m], build_disjoint(total, n, m, instructions)]
-                elsif distinct
-                  # Not all instructions have the same set of allowed values. So
-                  # we can build a function/hash that accepts one of the values
-                  # and returns the subset of the instructions where that value
-                  # can occur. This might be some, none, or all of the original
-                  # instructions, so clearly this provides less information than
-                  # if each allowed value set was disjoint.
-                  # Currently disabled (and untested) because it doesn't look like
-                  # any of the HIPAA schemas would use this -- so testing it would
-                  # be a pain.
-                  #
-                  distinct_elements << [[n, m], build_distinct(total, n, m, instructions)]
-                end
-              end
-            end
-            [disjoint_elements, distinct_elements]
-          end
-        end
-        # @return [Hash<String, Array<Instruction>>]
-        def build_disjoint(total, n, m, instructions)
-          if total.finite?
-            # The sum of all allowed value sets is finite, so we know that each
-            # individual allowed value set is finite (we can iterate over it).
-            map = Hash.new
-            instructions.each do |i|
-              element_use = i.segment_use.definition.element_uses.at(n)
-              unless m.nil?
-                element_use = element_use.definition.component_uses.at(m)
-              end
-              allowed_vals = element_use.allowed_values
-              allowed_vals.each{|v| map[v] = i.cons }
-            end
-            map
-          else
-            # At least one of allowed value sets is infinite. This happens when
-            # it is RelativeComplement, which declares the values that are *not*
-            # allowed in the set.
-            map = Hash.new{|h,k| h[k] = instructions }
-            instructions.each do |i|
-              element_use = i.segment_use.definition.element_uses.at(n)
-              unless m.nil?
-                element_use = element_use.definition.component_uses.at(m)
-              end
-              allowed_vals = element_use.allowed_values
-              unless allowed_vals.finite?
-                allowed_vals.complement.each{|v| map[v] -= i }
-              end
-            end
-            # Clear the default_proc so accesses don't change the Hash
-            map.default = instructions
-            map
-          end
-        end
-        # @return [Hash<String, Array<Instruction>>]
-        def build_distinct(total, n, m, instructions)
-          if total.finite?
-            # The sum of all allowed value sets is finite, so we know that each
-            # individual allowed value set is finite (we can iterate over it).
-            map = Hash.new{|h,k| h[k] = [] }
-            instructions.each do |i|
-              element_use  = i.segment_use.definition.element_uses.at(n)
-              unless m.nil?
-                element_use = element_use.definition.component_uses.at(m)
-              end
-              allowed_vals = element_use.allowed_values
-              allowed_vals.each{|v| map[v] << i }
-            end
-            # Clear the default_proc so accesses don't change the Hash
-            map.default = []
-            map
-          else
-            # At least one of allowed value sets is infinite. This happens when
-            # it is RelativeComplement, which declares the values that are *not*
-            # allowed in the set.
-            map = Hash.new{|h,k| h[k] = instructions }
-            instructions.each do |i|
-              element_use  = i.segment_use.definition.element_uses.at(n)
-              unless m.nil?
-                element_use = element_use.definition.component_uses.at(m)
-              end
-              allowed_vals = element_use.allowed_values
-              unless allowed_vals.finite?
-                allowed_vals.complement.each{|v| map[v] -= i }
-              end
-            end
-            # Clear the default_proc so accesses don't change the Hash
-            map.default = instructions
-            map
-          end
-        end
-        # Return the value of the `m`-th elemnt, or if `n` is not nil, return
-        # the value of the `n`-th component from the `n`-th element. When the
-        # value is blank, the function returns `nil`.
-        #
-        # @param [Array<Reader::SimpleElementTok, Reader::CompositeElementTok>] element_toks
-        # @param [Integer] m
-        # @param [Integer, nil] n
-        #
-        # @return [String, nil]
-        def deconstruct(element_toks, m, n)
-          element_tok = element_toks.at(m)
-          element_tok = element_tok.element_toks.at(0) if element_tok.try(:repeated?)
-          if element_tok.blank?
-            nil
-          elsif n.nil?
-            element_tok.value
-          else
-            element_tok = element_tok.component_toks.at(n)
-            if element_tok.blank?
-              nil
-            else
-              element_tok.value
-            end
-          end
-        end
-      end
-    end
-    class << ConstraintTable
-      # @group Constructors
-      #########################################################################
-      # Given a list of {Instruction} values for the same segment identifier,
-      # this method constructs the appropriate concrete subclass of
-      # {ConstraintTable}.
-      #
-      # @param [Array<Instruction>] instructions
-      # @return [ConstraintTable]
-      def build(instructions)
-        if instructions.length <= 1
-          ConstraintTable::Stub.new(instructions)
-        elsif instructions.any?{|i| i.segment_use.nil? } and
-          not instructions.all?{|i| i.segment_use.nil? }
-          # When one of the instructions has a nil segment_use, it means
-          # the SegmentUse is determined when pushing the new state. There
-          # isn't a way to know the segment constraints from here.
-          ConstraintTable::Stub.new(instructions)
-        else
-          segment_uses = instructions.map{|i| i.segment_use }
-          if segment_uses.map{|u| u.object_id }.uniq.length <= 1
-            # The same SegmentUse may appear more than once, because the
-            # segment can be placed at different levels in the tree. If
-            # 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.
-            instructions.head.segment_id == :ISA ?
-              ConstraintTable::Deepest.new(instructions) :
-              ConstraintTable::Shallowest.new(instructions)
-          else
-            ConstraintTable::ValueBased.new(instructions)
-          end
-        end
-      end
-      # @endgroup
-      #########################################################################
-    end
-  end
-end