rley 0.7.06 → 0.8.01

data/lib/rley/parser/parse_state_tracker.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    # Helper class that keeps track of the parse states used
-    # while a Parsing instance is constructing a parse tree.
-    class ParseStateTracker
-      # The index of the current state set
-      attr_reader(:state_set_index)
-
-      # The current parse state
-      attr_reader(:parse_state)
-
-      # The already processed states from current state set
-      attr_reader(:processed_states)
-
-      # Constructor. Refined variant of the inherited constructor.
-      def initialize(aStateSetIndex)
-        self.state_set_index = aStateSetIndex
-      end
-
-      # Write accessor. Sets the value of the state set index
-      def state_set_index=(anIndex)
-        @state_set_index = anIndex
-        @processed_states = {}
-      end
-
-      # Write accessor. Set the given parse state as the current one.
-      def parse_state=(aParseState)
-        raise StandardError, 'Nil parse state' if aParseState.nil?
-        
-        @parse_state = aParseState
-        processed_states[parse_state] = true
-      end
-
-      # Take the first provided state that wasn't processed yet.
-      def select_state(theStates)
-        a_state = theStates.find { |st| !processed_states.include?(st) }
-        self.parse_state = a_state
-      end
-
-      # The dotted item for the current parse state.
-      def curr_dotted_item()
-        parse_state.dotted_rule
-      end
-
-      def symbol_on_left()
-        return curr_dotted_item.prev_symbol
-      end
-
-      # Notification that one begins with the previous state set
-      def to_prev_state_set()
-        self.state_set_index = state_set_index - 1
-      end
-    end # class
-  end # module
-end # module
-
-# End of file

data/lib/rley/parser/state_set.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable' # Delegation
-
-module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
-    class StateSet
-      extend Forwardable
-      def_delegators :states, :empty?, :size, :first, :each
-
-      # The set of parse states
-      attr_reader(:states)
-
-      def initialize()
-        @states = []
-      end
-
-      # Append the given state (if it isn't yet in the set)
-      # to the list of states
-      # @param aState [ParseState] the state to push.
-      # @return [TrueClass/FalseClass] true when the state is really added
-      def push_state(aState)
-        if include?(aState)
-          result = false
-        else
-          @states << aState
-          result = true
-        end
-
-        return result
-      end
-
-      # The list of ParseState that expect the given symbol.
-      # @param aSymbol [GrmSymbol] the expected symbol
-      #   (=on the right of the dot)
-      def states_expecting(aSymbol)
-        return states.select { |s| s.dotted_rule.next_symbol == aSymbol }
-      end
-
-      # The list of complete ParseState that have the given non-terminal
-      # symbol as the lhs of their production.
-      def states_rewriting(aNonTerm)
-        return states.select do |s|
-          (s.dotted_rule.production.lhs == aNonTerm) && s.complete?
-        end
-      end
-
-      # The list of ParseState that involve the given production
-      def states_for(aProduction)
-        return states.select { |s| s.dotted_rule.production == aProduction }
-      end
-
-      # Retrieve the parse state that is the predecessor of the given one.
-      def predecessor_state(aPState)
-        dotted_rule = aPState.dotted_rule
-        raise StandardError, aPState.to_s unless dotted_rule.prev_position
-
-        candidate = states.find { |s| s.precedes?(aPState) }
-        return candidate
-      end
-
-      # The list of distinct expected terminal symbols. An expected symbol
-      # is on the left of a dot in a parse state of the parse set.
-      def expected_terminals()
-        expecting_terminals = states.select do |s|
-          s.dotted_rule.next_symbol.kind_of?(Rley::Syntax::Terminal)
-        end
-
-        terminals = expecting_terminals.map { |s| s.dotted_rule.next_symbol }
-        return terminals.uniq
-      end
-
-      # Return an Array of Arrays of ambiguous parse states.
-      def ambiguities()
-        complete_states = states.select(&:complete?)
-        return [] if complete_states.size <= 1
-
-        # Group parse state by lhs symbol and origin
-        groupings = complete_states.group_by do |st|
-          st.dotted_rule.lhs.object_id.to_s
-        end
-
-        # Retain the groups having more than one element.
-        ambiguous_groups = []
-        groupings.each_value do |a_group|
-          ambiguous_groups << a_group if a_group.size > 1
-        end
-
-        return ambiguous_groups
-      end
-
-      private
-
-      def include?(aState)
-        # TODO: make it better than linear search
-        return states.include?(aState)
-      end
-    end # class
-  end # module
-end # module
-# End of file

data/spec/rley/parser/parse_state_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/syntax/terminal'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/base/dotted_item'
-
-# Load the class under test
-require_relative '../../../lib/rley/parser/parse_state'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser # Open this namespace to avoid module qualifier prefixes
-    describe ParseState do
-      let(:t_a) { Syntax::Terminal.new('A') }
-      let(:t_b) { Syntax::Terminal.new('B') }
-      let(:t_c) { Syntax::Terminal.new('C') }
-      let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
-
-      let(:sample_prod) do
-        Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
-      end
-
-      let(:other_prod) do
-        Syntax::Production.new(nt_sentence, [t_a])
-      end
-
-      let(:empty_prod) do
-        Syntax::Production.new(nt_sentence, [])
-      end
-
-      let(:origin_val) { 3 }
-      let(:dotted_rule) { Base::DottedItem.new(sample_prod, 2) }
-      let(:other_dotted_rule) { double('mock-dotted-item') }
-
-      # Default instantiation rule
-      subject { ParseState.new(dotted_rule, origin_val) }
-
-      context 'Initialization:' do
-        it 'should be created with a dotted item and a origin position' do
-          args = [dotted_rule, origin_val]
-          expect { ParseState.new(*args) }.not_to raise_error
-        end
-
-        it 'should complain when the dotted rule is nil' do
-          err = StandardError
-          msg = 'Dotted item cannot be nil'
-          expect { ParseState.new(nil, 2) }.to raise_error(err, msg)
-        end
-
-        it 'should know the related dotted rule' do
-          expect(subject.dotted_rule).to eq(dotted_rule)
-        end
-
-        it 'should know the origin value' do
-          expect(subject.origin).to eq(origin_val)
-        end
-      end # context
-
-      context 'Provided services:' do
-        def new_parse_state(aProd, aRank, aVal)
-          item = Base::DottedItem.new(aProd, aRank)
-          ParseState.new(item, aVal)
-        end
-        
-        it 'should compare with itself' do
-          synonym = subject # Fool Rubocop
-          expect(subject == synonym).to eq(true)
-        end
-
-        it 'should compare with another' do
-          equal = ParseState.new(dotted_rule, origin_val)
-          expect(subject == equal).to eq(true)
-
-          # Same dotted_rule, different origin
-          diff_origin = ParseState.new(dotted_rule, 2)
-          expect(subject == diff_origin).to eq(false)
-
-          # Different dotted item, same origin
-          diff_rule = ParseState.new(other_dotted_rule, 3)
-          expect(subject == diff_rule).to eq(false)
-        end
-        
-        it 'should know if the parsing is at the start of the production' do
-          expect(subject).not_to be_predicted
-          at_start = Base::DottedItem.new(sample_prod, 0)
-
-          instance = ParseState.new(at_start, 0)
-          expect(instance).to be_predicted
-        end        
-
-        it 'should know if the parsing reached the end of the production' do
-          expect(subject).not_to be_complete
-          at_end = Base::DottedItem.new(sample_prod, 3)
-
-          instance = ParseState.new(at_end, 2)
-          expect(instance).to be_complete
-        end
-
-        it 'should know the next expected symbol' do
-          expect(subject.next_symbol).to eq(t_c)
-        end
-        
-        it 'should know whether another instance follows this one' do
-          expect(subject.precedes?(subject)).to eq(false)
-          state1 = new_parse_state(sample_prod, 1, origin_val)
-          expect(state1.precedes?(subject)).to eq(true)
-          state0 = new_parse_state(sample_prod, 0, origin_val)
-          expect(state0.precedes?(state1)).to eq(true)
-          expect(state0.precedes?(subject)).to eq(false)
-          state3 = new_parse_state(sample_prod, 3, origin_val)
-          expect(state3.precedes?(state0)).to eq(false)
-        end
-        
-        it 'should know its text representation' do
-          expected = 'sentence => A B . C | 3'
-          expect(subject.to_s).to eq(expected)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file

data/spec/rley/parser/parse_tracer_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-require 'stringio'
-
-require_relative '../../../lib/rley/syntax/terminal'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/base/dotted_item'
-require_relative '../../../lib/rley/parser/parse_state'
-require_relative '../../../lib/rley/lexical/token'
-
-# Load the class under test
-require_relative '../../../lib/rley/parser/parse_tracer'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser # Open this namespace to avoid module qualifier prefixes
-    describe ParseTracer do
-      let(:output) { StringIO.new(+'', 'w') }
-      let(:tpos) { Lexical::Position.new(3, 4) }
-
-      let(:token_seq) do
-        literals = %w[I saw John with a dog]
-        literals.map do |lexeme|
-          Lexical::Token.new(lexeme, double('fake-terminal'), tpos)
-        end
-      end
-
-      subject { ParseTracer.new(1, output, token_seq) }
-
-      context 'Creation & initialization:' do
-        it 'should accept trace level 0' do
-          expect { ParseTracer.new(0, output, token_seq) }.not_to raise_error
-          expect(output.string).to eq('')
-        end
-
-
-        it 'should accept trace level 1' do
-          expect { ParseTracer.new(1, output, token_seq) }.not_to raise_error
-          expectations = <<-SNIPPET
-['I', 'saw', 'John', 'with', 'a', 'dog']
-|.  I   . saw  . John . with .  a   . dog  .|
-SNIPPET
-          expect(output.string).to eq(expectations)
-        end
-
-        it 'should accept trace level 2' do
-          expect { ParseTracer.new(2, output, token_seq) }.not_to raise_error
-          expectations = <<-SNIPPET
-['I', 'saw', 'John', 'with', 'a', 'dog']
-|.  I   . saw  . John . with .  a   . dog  .|
-SNIPPET
-          expect(output.string).to eq(expectations)
-        end
-
-        it 'should know the trace level' do
-          expect(subject.level).to eq(1)
-        end
-
-        it 'should know the output stream' do
-          expect(subject.ostream).to eq(output)
-        end
-      end # context
-
-      context 'Provided services:' do
-        let(:t_a) { Syntax::Terminal.new('A') }
-        let(:t_b) { Syntax::Terminal.new('B') }
-        let(:t_c) { Syntax::Terminal.new('C') }
-        let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
-
-        let(:sample_prod) do
-          Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
-        end
-
-        let(:origin_val) { 3 }
-        let(:dotted_rule) { Base::DottedItem.new(sample_prod, 2) }
-        let(:complete_rule) { Base::DottedItem.new(sample_prod, 3) }
-        let(:sample_parse_state) { ParseState.new(dotted_rule, origin_val) }
-
-        # Factory method.
-        def parse_state(origin, aDottedRule)
-          ParseState.new(aDottedRule, origin)
-        end
-
-        it 'should render a scanning step' do
-          # Case: token at the beginning
-          subject.ostream.string = +''
-          subject.trace_scanning(1, parse_state(0, dotted_rule))
-          expectations = <<-SNIPPET
-|[------]      .      .      .      .      .| [0:1] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: token in the middle
-          subject.ostream.string = +''
-          subject.trace_scanning(4, sample_parse_state)
-          expectations = <<-SNIPPET
-|.      .      .      [------]      .      .| [3:4] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: token at the end
-          subject.ostream.string = +''
-          subject.trace_scanning(6, parse_state(5, dotted_rule))
-          expectations = <<-SNIPPET
-|.      .      .      .      .      [------]| [5:6] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-        end
-
-
-        it 'should render a prediction step' do
-          # Case: initial stateset
-          subject.ostream.string = +''
-          subject.trace_prediction(0, parse_state(0, dotted_rule))
-          expectations = <<-SNIPPET
-|>      .      .      .      .      .      .| [0:0] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: stateset in the middle
-          subject.ostream.string = +''
-          subject.trace_prediction(3, sample_parse_state)
-          expectations = <<-SNIPPET
-|.      .      .      >      .      .      .| [3:3] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: final stateset
-          subject.ostream.string = +''
-          subject.trace_prediction(6, parse_state(6, dotted_rule))
-          expectations = <<-SNIPPET
-|.      .      .      .      .      .      >| [6:6] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-        end
-
-        it 'should render a completion step' do
-          # Case: full parse completed
-          subject.ostream.string = +''
-          subject.trace_completion(6, parse_state(0, complete_rule))
-          expectations = <<-SNIPPET
-|[=========================================]| [0:6] sentence => A B C .
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the start (complete)
-          subject.ostream.string = +''
-          subject.trace_completion(1, parse_state(0, complete_rule))
-          expectations = <<-SNIPPET
-|[------]      .      .      .      .      .| [0:1] sentence => A B C .
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the start (not complete)
-          subject.ostream.string = +''
-          subject.trace_completion(1, parse_state(0, dotted_rule))
-          expectations = <<-SNIPPET
-|[------>      .      .      .      .      .| [0:1] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the middle (complete)
-          subject.ostream.string = +''
-          subject.trace_completion(4, parse_state(2, complete_rule))
-          expectations = <<-SNIPPET
-|.      .      [-------------]      .      .| [2:4] sentence => A B C .
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the middle (not complete)
-          subject.ostream.string = +''
-          subject.trace_completion(4, parse_state(2, dotted_rule))
-          expectations = <<-SNIPPET
-|.      .      [------------->      .      .| [2:4] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the end (complete)
-          subject.ostream.string = +''
-          subject.trace_completion(6, parse_state(3, complete_rule))
-          expectations = <<-SNIPPET
-|.      .      .      [--------------------]| [3:6] sentence => A B C .
-SNIPPET
-          expect(output.string).to eq(expectations)
-
-          # Case: step at the end (not complete)
-          subject.ostream.string = +''
-          subject.trace_completion(6, parse_state(3, dotted_rule))
-          expectations = <<-SNIPPET
-|.      .      .      [-------------------->| [3:6] sentence => A B . C
-SNIPPET
-          expect(output.string).to eq(expectations)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file