stupidedi 1.2.20 → 1.4.1

data/lib/stupidedi/builder/generation.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  module Builder
-
-    module Generation
-
-      # @return [(StateMachine, Either<Reader::TokenReader>)]
-      def read(reader)
-        machine = self
-        reader  = reader.read_segment
-
-        while reader.defined?
-          reader = reader.flatmap do |segment_tok, reader1|
-            machine, reader =
-              machine.insert(segment_tok, reader1)
-
-            reader.read_segment
-          end
-        end
-
-        return machine, reader
-      end
-
-      # @return [(StateMachine, Reader::TokenReader)]
-      def insert(segment_tok, reader)
-        active = []
-
-        @active.each do |zipper|
-          state        = zipper.node
-          instructions = state.instructions.matches(segment_tok)
-
-          if instructions.empty?
-            active << zipper.append(FailureState.mksegment(segment_tok, state))
-            next
-          end
-
-          instructions.each do |op|
-            if op.push.nil?
-              table = zipper.node.instructions
-              value = zipper.node.zipper
-              state = zipper
-
-              op.pop_count.times do
-                value = value.up
-                state = state.up
-              end
-
-              # Create a new AbstractState node that has a new InstructionTable
-              # and also points to a new AbstractVal tree (with the new segment)
-              segment   = AbstractState.mksegment(segment_tok, op.segment_use)
-              successor = state.append(state.node.copy(
-                :zipper       => value.append(segment),
-                :instructions => table.pop(op.pop_count).drop(op.drop_count)))
-
-              unless op.pop_count.zero? or reader.stream?
-                # More general than checking if segment_tok is an ISE/GE segment
-                unless reader.separators.eql?(successor.node.separators) \
-                  and reader.segment_dict.eql?(successor.node.segment_dict)
-                  reader = reader.copy \
-                    :separators   => successor.node.separators,
-                    :segment_dict => successor.node.segment_dict
-                end
-              end
-            else
-              table = zipper.node.instructions
-              value = zipper.node.zipper
-              state = zipper
-
-              op.pop_count.times do
-                value = value.up
-                state = state.up
-              end
-
-              parent = state.node.copy \
-                :zipper       => value,
-                :children     => [],
-                :separators   => reader.separators,
-                :segment_dict => reader.segment_dict,
-                :instructions => table.pop(op.pop_count).drop(op.drop_count)
-
-              state = state.append(parent) unless state.root?
-
-              successor = op.push.push(state, parent, segment_tok, op.segment_use, @config)
-
-              # More general than checking if segment_tok is an ISA/GS segment
-              unless reader.separators.eql?(successor.node.separators) \
-                and reader.segment_dict.eql?(successor.node.segment_dict)
-                reader = reader.copy \
-                  :separators   => successor.node.separators,
-                  :segment_dict => successor.node.segment_dict
-              end
-            end
-
-            active << successor
-          end
-        end
-
-        return StateMachine.new(@config, active), reader
-      end
-
-      # @return [StateMachine]
-      def replace(segment_tok, reader)
-        # @todo
-      end
-
-      # @return [StateMachine]
-      def remove
-        # @todo
-      end
-
-    end
-  end
-end

data/lib/stupidedi/builder/identifier_stack.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  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

data/lib/stupidedi/builder/instruction.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  module Builder
-
-    class Instruction
-      include Inspect
-
-      # The segment identifier to which this {Instruction} applies
-      #
-      # @return [Symbol]
-      attr_reader :segment_id
-
-      # The segment use contains helpful information about the context of the
-      # segment within a definition tree (eg the parent structure's definition).
-      # It also enumerates the allowed values for segment qualifiers, which is
-      # used to minimize non-determinism.
-      #
-      # @return [Schema::SegmentUse]
-      attr_reader :segment_use
-
-      # This indicates the number of levels to ascend and terminate within the
-      # tree before storing the segment.
-      #
-      # @return [Integer]
-      attr_reader :pop_count
-
-      # This controls the allowed order in which structures may occur, by
-      # indicating the number of instructions to remove from the beginning of
-      # the instruction table.
-      #
-      # Repeatable structures have a value that ensures that their instruction
-      # remains in the successor table.
-      #
-      # Sibling structures that have the same position (as defined by their
-      # {Schema::SegmentUse}) will have equal drop_count values such that all of
-      # the sibling instructions remain in the successor table when any one of
-      # them is executed.
-      #
-      # @return [Integer]
-      attr_reader :drop_count
-
-      # This indicates that a child node should be added to the tree, which
-      # will then contain the segment.
-      #
-      # When a segment indicates the start of a child structure, the class
-      # indicated by this attribute is expected to respond to `push` by
-      # creating a new {AbstractState}.
-      #
-      # @return [Zipper::AbstractCursor]
-      attr_reader :push
-
-      def initialize(segment_id, segment_use, pop, drop, push)
-        @segment_id, @segment_use, @pop_count, @drop_count, @push =
-          segment_id || segment_use.definition.id, segment_use, pop, drop, push
-      end
-
-      # @return [Instruction]
-      def copy(changes = {})
-        Instruction.new \
-          changes.fetch(:segment_id, @segment_id),
-          changes.fetch(:segment_use, @segment_use),
-          changes.fetch(:pop_count, @pop_count),
-          changes.fetch(:drop_count, @drop_count),
-          changes.fetch(:push, @push)
-      end
-
-      # @return [void]
-      def pretty_print(q)
-        id = '% 3s' % @segment_id.to_s
-
-        unless @segment_use.nil?
-          width = 18
-          name  = @segment_use.definition.name
-
-          # Truncate the segment name to `width` characters
-          if name.length > width - 2
-            id = id + ": #{name.slice(0, width - 2)}.."
-          else
-            id = id + ": #{name.ljust(width)}"
-          end
-        end
-
-        q.text "Instruction[#{'% 3s' % id}]"
-
-        q.group(6, "(", ")") do
-          q.breakable ""
-
-          q.text "pop: #{@pop_count},"
-          q.breakable
-
-          q.text "drop: #{@drop_count}"
-
-          unless @push.nil?
-            q.text ","
-            q.breakable
-            q.text "push: #{@push.try{|c| c.name.split('::').last}}"
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/stupidedi/builder/instruction_table.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module Stupidedi
-  using Refinements
-
-  module Builder
-
-    class InstructionTable
-      include Inspect
-
-      class NonEmpty < InstructionTable
-
-        # @return [Array<Instruction>]
-        attr_reader :instructions
-
-        def initialize(instructions, pop)
-          @instructions, @pop = instructions.freeze, pop
-
-          @__push = Hash.new
-          @__drop = Hash.new
-        end
-
-        # @return [InstructionTable]
-        def copy(changes = {})
-          NonEmpty.new \
-            changes.fetch(:instructions, @instructions),
-            changes.fetch(:pop, @pop)
-        end
-
-        # @return [Integer]
-        def length
-          @instructions.length
-        end
-
-        # @return [Instruction]
-        def at(segment_use)
-          @instructions.find{|op| op.segment_use.eql?(segment_use) }
-        end
-
-        # @return [InstructionTable]
-        def push(instructions)
-          @__push[instructions] ||= begin
-            bottom = @instructions.map do |op|
-              op.copy(:pop_count => op.pop_count + 1)
-            end
-
-            NonEmpty.new(instructions + bottom, self)
-          end
-        end
-
-        # @return [Array<Instruction>]
-        def matches(segment_tok, strict = false)
-          @__matches ||= begin
-            constraints = Hash.new
-
-            # Group instructions by segment identifier
-            grouped = Hash.new{|h,k| h[k] = [] }
-            @instructions.each{|op| grouped[op.segment_id] << op }
-
-            # For each group of instructions that have the same segment
-            # id, build a constraint table that can distinguish them
-            grouped.each do |segment_id, instructions|
-              constraints[segment_id] = ConstraintTable.build(instructions)
-            end
-
-            constraints
-          end
-
-          if @__matches.defined_at?(segment_tok.id)
-            @__matches.at(segment_tok.id).matches(segment_tok, strict)
-          else
-            []
-          end
-        end
-
-        # @return [InstructionTable]
-        def pop(count)
-          if count.zero?
-            self
-          else
-            @pop.pop(count - 1)
-          end
-        end
-
-        # @return [InstructionTable]
-        def drop(count)
-          if count.zero?
-            self
-          else
-            @__drop[count] ||= begin
-              # Calculate the fewest number of instructions we can drop. We
-              # drop this many to construct the next InstructionTable, from
-              # which we drop the remaining number of instructions.
-              smallest = @instructions.length
-              top = @instructions.take(@instructions.length - @pop.length)
-              top.each do |i|
-                unless i.drop_count.zero? or smallest < i.drop_count
-                  smallest = i.drop_count
-                end
-              end
-
-              if smallest == count
-                # There are no intermediate steps to take, because we can't drop
-                # any fewer than the given number of instructions.
-                remaining = @instructions.drop(count)
-
-                # Adjust the drop_count for each remaining instruction except
-                # those that belong to the parent InstructionTable @pop
-                top, pop = remaining.split_at(remaining.length - @pop.length)
-
-                top.map!{|op| op.copy(:drop_count => op.drop_count - count) }
-                top.concat(pop)
-
-                NonEmpty.new(top, @pop)
-              else
-                drop(smallest).drop(count - smallest)
-              end
-            end
-          end
-        end
-
-        # @return [void]
-        def pretty_print(q)
-          q.text("InstructionTable")
-          q.group(2, "(", ")") do
-            q.breakable ""
-
-            index = 0
-            @instructions.each do |e|
-              index += 1
-              unless q.current_group.first?
-                q.text ","
-                q.breakable
-              end
-
-              q.text "#{'% 2s' % index}: "
-              q.pp e
-            end
-          end
-        end
-      end
-
-      Empty = Class.new(InstructionTable) do
-        # @return [Empty]
-        def copy(changes = {})
-          self
-        end
-
-        # @return [Integer]
-        def length
-          0
-        end
-
-        # @return nil
-        def at(segment_use)
-          nil
-        end
-
-        # @return [NonEmpty]
-        def push(instructions)
-          InstructionTable::NonEmpty.new(instructions, self)
-        end
-
-        def matches(segment_tok)
-          raise Exceptions::ParseError,
-            "empty stack"
-        end
-
-        # @return [Empty]
-        def pop(count)
-          if count.zero?
-            self
-          else
-            "empty stack"
-          end
-        end
-
-        # @return [Empty]
-        def drop(count)
-          self
-        end
-
-        # @return [void]
-        def pretty_print(q)
-          q.text "InstructionTable.empty"
-        end
-      end.new
-    end
-
-    class << InstructionTable
-      # @group Constructors
-      #########################################################################
-
-      # @return [InstructionTable::Empty]
-      def empty
-        InstructionTable::Empty
-      end
-
-      # @return [InstructionTable::NonEmpty]
-      def build(instructions)
-        empty.push(instructions)
-      end
-
-      # @endgroup
-      #########################################################################
-    end
-  end
-end