rley 0.7.08 → 0.8.00

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

data/spec/rley/parser/state_set_spec.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/parser/parse_state'
-
-# Load the class under test
-require_relative '../../../lib/rley/parser/state_set'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser # Open this namespace to avoid module qualifier prefixes
-    describe StateSet do
-      let(:dotted_rule1) { double('fake_dotted_rule1') }
-      let(:state1) { ParseState.new(dotted_rule1, 2) }
-      let(:dotted_rule2) { double('fake_dotted_rule2') }
-      let(:state2) { ParseState.new(dotted_rule2, 5) }
-
-      context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { StateSet.new }.not_to raise_error
-        end
-
-        it 'should be empty at creation' do
-          expect(subject.states).to be_empty
-        end
-      end # context
-
-      context 'Provided services:' do
-        it 'should push a state' do
-          expect(subject.states).to be_empty
-          expect { subject.push_state(state1) }.not_to raise_error
-          expect(subject).not_to be_empty
-          subject.push_state(state2)
-          expect(subject.states).to eq([state1, state2])
-        end
-
-        it 'should ignore a second push of a state' do
-          expect(subject.states).to be_empty
-          subject.push_state(state1)
-          subject.push_state(state2)
-          expect(subject.states).to eq([state1, state2])
-
-          # One tries to push an already pushed state
-          expect(subject.push_state(state1)).to be_falsy
-
-          # ...It is not added
-          expect(subject.states).to eq([state1, state2])
-        end
-
-        it 'should list the states expecting a given terminal' do
-          # Case of no state
-          expect(subject.states_expecting(:a)).to be_empty
-
-          # Adding states
-          subject.push_state(state1)
-          subject.push_state(state2)
-          allow(dotted_rule1).to receive(:next_symbol).and_return(:b)
-          allow(dotted_rule2).to receive(:next_symbol).and_return(:a)
-          expect(subject.states_expecting(:a)).to eq([state2])
-          expect(subject.states_expecting(:b)).to eq([state1])
-        end
-
-        it 'should list the states related to a production' do
-          a_prod = double('fake-production')
-
-          # Case of no state
-          expect(subject.states_for(a_prod)).to be_empty
-
-          # Adding states
-          subject.push_state(state1)
-          subject.push_state(state2)
-          expect(dotted_rule1).to receive(:production).and_return(:dummy)
-          expect(dotted_rule2).to receive(:production).and_return(a_prod)
-          expect(subject.states_for(a_prod)).to eq([state2])
-        end
-
-        it 'should list the states that rewrite a given non-terminal' do
-          non_term = double('fake-non-terminal')
-          prod1 = double('fake-production1')
-          prod2 = double('fake-production2')
-
-          # Adding states
-          subject.push_state(state1)
-          subject.push_state(state2)
-          expect(dotted_rule1).to receive(:production).and_return(prod1)
-          expect(prod1).to receive(:lhs).and_return(:dummy)
-          expect(dotted_rule2).to receive(:production).and_return(prod2)
-          expect(dotted_rule2).to receive(:reduce_item?).and_return(true)
-          expect(prod2).to receive(:lhs).and_return(non_term)
-          expect(subject.states_rewriting(non_term)).to eq([state2])
-        end
-
-        it 'should list of ambiguous states' do
-          prod1 = double('fake-production1')
-          prod2 = double('fake-production2')
-          expect(subject.ambiguities.size).to eq(0)
-
-          # Adding states
-          subject.push_state(state1)
-          allow(dotted_rule1).to receive(:production).and_return(prod1)
-          allow(dotted_rule1).to receive(:reduce_item?).and_return(true)
-          allow(dotted_rule1).to receive(:lhs).and_return(:something)
-          expect(subject.ambiguities.size).to eq(0)
-          allow(dotted_rule2).to receive(:production).and_return(prod2)
-          allow(dotted_rule2).to receive(:reduce_item?).and_return(true)
-          allow(dotted_rule2).to receive(:lhs).and_return(:something_else)
-          subject.push_state(state2)
-          expect(subject.ambiguities.size).to eq(0)
-          dotted_rule3 = double('fake_dotted_rule3')
-          allow(dotted_rule3).to receive(:production).and_return(prod2)
-          allow(dotted_rule3).to receive(:reduce_item?).and_return(true)
-          allow(dotted_rule3).to receive(:lhs).and_return(:something_else)
-          state3 = ParseState.new(dotted_rule3, 5)
-          subject.push_state(state3)
-          expect(subject.ambiguities[0]).to eq([state2, state3])
-        end
-
-        it 'should complain when impossible predecessor of parse state' do
-          subject.push_state(state1)
-          subject.push_state(state2)
-          expect(dotted_rule1).to receive(:prev_position).and_return(nil)
-          err = StandardError
-          expect { subject.predecessor_state(state1) }.to raise_error(err)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
-# End of file