rley 0.8.14 → 0.8.15

data/spec/rley/parse_rep/parse_forest_builder_spec.rb

@@ -18,6 +18,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include GrammarHelper     # Mix-in with token factory method
       include ExpectationHelper # Mix-in with expectation on parse entry sets
 
+      subject(:a_builder) { described_class.new(sample_tokens) }
+
       let(:sample_grammar) do
           # Grammar based on paper from Elisabeth Scott
           # "SPPF=Style Parsing From Earley Recognizers" in
@@ -45,11 +47,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         parser.parse(sample_tokens)
       end
 
-      subject { ParseForestBuilder.new(sample_tokens) }
-
       # Emit a text representation of the current path.
       def path_to_s
-        text_parts = subject.curr_path.map do |path_element|
+        text_parts = a_builder.curr_path.map do |path_element|
           path_element.to_string(0)
         end
         text_parts.join('/')
@@ -57,13 +57,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       def next_event(eventType, anEntryText)
         event = @walker.next
-        subject.receive_event(*event)
+        a_builder.receive_event(*event)
         expect(event[0]).to eq(eventType)
         expect(event[1].to_s).to eq(anEntryText)
       end
 
       def expected_curr_parent(anExpectation)
-        expect(subject.curr_parent.to_string(0)).to eq(anExpectation)
+        expect(a_builder.curr_parent.to_string(0)).to eq(anExpectation)
       end
 
       def expected_curr_path(anExpectation)
@@ -71,41 +71,41 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       def expected_first_child(anExpectation)
-          child = subject.curr_parent.subnodes.first
+          child = a_builder.curr_parent.subnodes.first
           expect(child.to_string(0)).to eq(anExpectation)
       end
 
       context 'Initialization:' do
-        it 'should be created with a sequence of tokens' do
-          expect { ParseForestBuilder.new(sample_tokens) }.not_to raise_error
+        it 'is created with a sequence of tokens' do
+          expect { described_class.new(sample_tokens) }.not_to raise_error
         end
 
-        it 'should know the input tokens' do
-          expect(subject.tokens).to eq(sample_tokens)
+        it 'knows the input tokens' do
+          expect(a_builder.tokens).to eq(sample_tokens)
         end
 
-        it 'should have an empty path' do
-          expect(subject.curr_path).to be_empty
+        it 'has an empty path' do
+          expect(a_builder.curr_path).to be_empty
         end
       end # context
 
       context 'Parse forest construction' do
-        before(:each) do
+        before do
           factory = Parser::ParseWalkerFactory.new
           accept_entry = sample_result.accepting_entry
           accept_index = sample_result.chart.last_index
           @walker = factory.build_walker(accept_entry, accept_index, true)
         end
 
-        it 'should initialize the root node' do
+        it 'initializes the root node' do
           next_event(:visit, 'Phi. | 0')
-          forest = subject.result
+          forest = a_builder.result
 
           expect(forest.root.to_string(0)).to eq('Phi[0, 4]')
           expected_curr_path('Phi[0, 4]')
         end
 
-        it 'should initialize the first child of the root node' do
+        it 'initializes the first child of the root node' do
           next_event(:visit, 'Phi. | 0') # Event 1
           next_event(:visit, 'Phi => S . | 0') # Event 2
           next_event(:visit, 'S. | 0') # Event 3
@@ -113,41 +113,41 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_curr_path('Phi[0, 4]/S[0, 4]')
         end
 
-        it 'should build alternative node when detecting backtrack point' do
+        it 'builds alternative node when detecting backtrack point' do
           3.times do
             event = @walker.next
-            subject.receive_event(*event)
+            a_builder.receive_event(*event)
           end
 
           next_event(:visit, 'S => a T . | 0') # Event 4
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]')
-          expect(subject.curr_path[-2].refinement).to eq(:or)
+          expect(a_builder.curr_path[-2].refinement).to eq(:or)
         end
 
-        it 'should build token node when scan edge was detected' do
+        it 'builds token node when scan edge was detected' do
           4.times do
             event = @walker.next
-            subject.receive_event(*event)
+            a_builder.receive_event(*event)
           end
 
           next_event(:visit, 'T. | 1') # Event5
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]')
-          expect(subject.curr_parent.subnodes).to be_empty
+          expect(a_builder.curr_parent.subnodes).to be_empty
 
           next_event(:visit, 'T => b b b . | 1') # Event 6
-          expect(subject.curr_parent.to_string(0)).to eq('T[1, 4]')
+          expect(a_builder.curr_parent.to_string(0)).to eq('T[1, 4]')
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]')
-          expect(subject.curr_parent.subnodes.size).to eq(1)
+          expect(a_builder.curr_parent.subnodes.size).to eq(1)
           expected_first_child('b[3, 4]')
 
           next_event(:visit, 'T => b b . b | 1') # Event 7
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]')
-          expect(subject.curr_parent.subnodes.size).to eq(2)
+          expect(a_builder.curr_parent.subnodes.size).to eq(2)
           expected_first_child('b[2, 3]')
 
           next_event(:visit, 'T => b . b b | 1') # Event 8
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]/T[1, 4]')
-          expect(subject.curr_parent.subnodes.size).to eq(3)
+          expect(a_builder.curr_parent.subnodes.size).to eq(3)
           expected_first_child('b[1, 2]')
 
           next_event(:visit, 'T => . b b b | 1') # Event 9
@@ -158,7 +158,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event(:visit, 'S => a . T | 0') # Event 11
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => a T .)[0, 4]')
-          expect(subject.curr_parent.subnodes.size).to eq(2)
+          expect(a_builder.curr_parent.subnodes.size).to eq(2)
           expected_first_child('a[0, 1]')
 
           next_event(:visit, 'S => . a T | 0') # Event 12
@@ -175,26 +175,26 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(path_to_s).to be_empty
         end
 
-        it 'should handle backtracking' do
+        it 'handles backtracking' do
           15.times do
             event = @walker.next
-            subject.receive_event(*event)
+            a_builder.receive_event(*event)
           end
 
           # Backtracking is occurring
           next_event(:backtrack, 'S. | 0') # Event 16
           expected_curr_path('Phi[0, 4]/S[0, 4]')
 
-          # Alternate node should be created
+          # Alternate node is created
           next_event(:visit, 'S => A T . | 0') # Event 17
           expected_curr_path('Phi[0, 4]/S[0, 4]/Alt(S => A T .)[0, 4]')
-          expect(subject.curr_path[-2].refinement).to eq(:or)
+          expect(a_builder.curr_path[-2].refinement).to eq(:or)
         end
 
-        it 'should detect second time visit of an entry' do
+        it 'detects second time visit of an entry' do
           17.times do
             event = @walker.next
-            subject.receive_event(*event)
+            a_builder.receive_event(*event)
           end
 
           next_event(:revisit, 'T. | 1') # REVISIT Event 18
@@ -210,7 +210,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event(:visit, 'A => a . | 0') # Event 21
           expected_curr_path("#{path_prefix}Alt(A => a .)[0, 1]")
-          expect(subject.curr_path[-2].refinement).to eq(:or)
+          expect(a_builder.curr_path[-2].refinement).to eq(:or)
 
           next_event(:visit, 'A => . a | 0') # Event 22
           expected_curr_path(expected_path20)
@@ -231,10 +231,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected_curr_path('')
         end
 
-        it 'should handle remaining # Events' do
+        it 'handles remaining # Events' do
           27.times do
             event = @walker.next
-            subject.receive_event(*event)
+            a_builder.receive_event(*event)
           end
 
           # Backtracking is occurring
@@ -280,6 +280,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       context 'Natural language processing' do
         include GrammarL0Helper
 
+        subject(:a_builder) { described_class.new(sentence_tokens) }
+
         let(:grammar_l0) do
           builder = grammar_l0_builder
           builder.grammar
@@ -295,16 +297,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           parser.parse(sentence_tokens)
         end
 
-        before(:each) do
+        before do
           factory = Parser::ParseWalkerFactory.new
           accept_entry = sentence_result.accepting_entry
           accept_index = sentence_result.chart.last_index
           @walker = factory.build_walker(accept_entry, accept_index)
         end
 
-        subject { ParseForestBuilder.new(sentence_tokens) }
-
-        it 'should handle walker events' do
+        it 'handles walker events' do
           next_event(:visit, 'S. | 0') # Event 1
           expected_curr_path('S[0, 5]')
 
@@ -329,7 +329,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event(:visit, 'Nominal => Nominal Noun . | 3') # Event 8
           expected_curr_path('S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]')
-          expect(subject.curr_parent.subnodes.size).to eq(1)
+          expect(a_builder.curr_parent.subnodes.size).to eq(1)
           expected_first_child('Noun[4, 5]')
 
 
@@ -344,7 +344,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           next_event(:visit, 'Nominal => Noun . | 3') # Event11
           path11 = 'S[0, 5]/VP[1, 5]/NP[2, 5]/Nominal[3, 5]/Nominal[3, 4]'
           expected_curr_path(path11)
-          expect(subject.curr_parent.subnodes.size).to eq(1)
+          expect(a_builder.curr_parent.subnodes.size).to eq(1)
           expected_first_child('Noun[3, 4]')
 
           next_event(:visit, 'Nominal => . Noun | 3') # Event 12

data/spec/rley/parse_rep/parse_forest_factory_spec.rb

@@ -17,6 +17,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include GrammarHelper     # Mix-in with token factory method
       include ExpectationHelper # Mix-in with expectation on parse entry sets
 
+      subject(:a_factory) { described_class.new(sample_result) }
+
       let(:sample_grammar) do
           # Grammar based on paper from Elisabeth Scott
           # "SPPF-Style Parsing From Earley Recognizers" in
@@ -44,32 +46,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         parser.parse(sample_tokens)
       end
 
-      subject do
-        ParseForestFactory.new(sample_result)
-      end
-
       # Emit a text representation of the current path.
       def path_to_s
-        text_parts = subject.curr_path.map do |path_element|
+        text_parts = a_factory.curr_path.map do |path_element|
           path_element.to_string(0)
         end
         text_parts.join('/')
       end
 
       context 'Initialization:' do
-        it 'should be created with a GFGParsing' do
-          expect { ParseForestFactory.new(sample_result) }.not_to raise_error
+        it 'is created with a GFGParsing' do
+          expect { described_class.new(sample_result) }.not_to raise_error
         end
 
-        it 'should know the parse result' do
-          expect(subject.parsing).to eq(sample_result)
+        it 'knows the parse result' do
+          expect(a_factory.parsing).to eq(sample_result)
         end
       end
 
       context 'Parse forest construction' do
-        it 'should build a parse forest' do
-          forest = subject.create
-          expect(forest).to be_kind_of(SPPF::ParseForest)
+        it 'builds a parse forest' do
+          forest = a_factory.create
+          expect(forest).to be_a(SPPF::ParseForest)
         end
       end # context
     end # describe

data/spec/rley/parse_rep/parse_tree_factory_spec.rb

@@ -18,28 +18,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include ExpectationHelper # Mix-in with expectation on parse entry sets
       include GrammarABCHelper  # Mix-in for a sample grammar
 
+      subject(:a_factory) { described_class.new(sample_result) }
+
       let(:sample_grammar) do
         builder = grammar_abc_builder
         builder.grammar
       end
-
       let(:sample_tokens) do
         build_token_sequence(%w[a b c], sample_grammar)
       end
-
       let(:sample_result) do
         parser = Parser::GFGEarleyParser.new(sample_grammar)
         parser.parse(sample_tokens)
       end
 
-
-      subject do
-        ParseTreeFactory.new(sample_result)
-      end
-
       # Emit a text representation of the current path.
       def path_to_s
-        text_parts = subject.curr_path.map do |path_element|
+        text_parts = a_factory.curr_path.map do |path_element|
           path_element.to_string(0)
         end
         text_parts.join('/')
@@ -47,19 +42,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
 
       context 'Initialization:' do
-        it 'should be created with a GFGParsing' do
-          expect { ParseTreeFactory.new(sample_result) }.not_to raise_error
+        it 'is created with a GFGParsing' do
+          expect { described_class.new(sample_result) }.not_to raise_error
         end
 
-        it 'should know the parse result' do
-          expect(subject.parsing).to eq(sample_result)
+        it 'knows the parse result' do
+          expect(a_factory.parsing).to eq(sample_result)
         end
       end
 
       context 'Parse tree construction' do
-        it 'should build a parse tree' do
-          forest = subject.create
-          expect(forest).to be_kind_of(PTree::ParseTree)
+        it 'builds a parse tree' do
+          forest = a_factory.create
+          expect(forest).to be_a(PTree::ParseTree)
         end
       end # context
     end # describe

data/spec/rley/parse_tree_visitor_spec.rb

@@ -19,11 +19,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       builder.grammar
     end
 
+    # Default instantiation rule
+    subject(:ptree_visitor) { described_class.new(grm_abc_ptree1) }
+
     let(:a_) { grammar_abc.name2symbol['a'] }
     let(:b_) { grammar_abc.name2symbol['b'] }
     let(:c_) { grammar_abc.name2symbol['c'] }
 
-
     # Helper method that mimicks the output of a tokenizer
     # for the language specified by grammar_abc
     let(:grm_abc_tokens1) do
@@ -51,22 +53,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       ptree
     end
 
-
-    # Default instantiation rule
-    subject { ParseTreeVisitor.new(grm_abc_ptree1) }
-
-
     context 'Standard creation & initialization:' do
-      it 'should be initialized with a parse tree argument' do
-        expect { ParseTreeVisitor.new(grm_abc_ptree1) }.not_to raise_error
+      it 'is initialized with a parse tree argument' do
+        expect { described_class.new(grm_abc_ptree1) }.not_to raise_error
       end
 
-      it 'should know the parse tree to visit' do
-        expect(subject.ptree).to eq(grm_abc_ptree1)
+      it 'knows the parse tree to visit' do
+        expect(ptree_visitor.ptree).to eq(grm_abc_ptree1)
       end
 
-      it "shouldn't have subscribers at start" do
-        expect(subject.subscribers).to be_empty
+      it "doesn't have subscribers at start" do
+        expect(ptree_visitor.subscribers).to be_empty
       end
     end # context
 
@@ -75,32 +72,32 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:listener1) { double('fake-subscriber1') }
       let(:listener2) { double('fake-subscriber2') }
 
-      it 'should allow subscriptions' do
-        subject.subscribe(listener1)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
+      it 'allows subscriptions' do
+        ptree_visitor.subscribe(listener1)
+        expect(ptree_visitor.subscribers.size).to eq(1)
+        expect(ptree_visitor.subscribers).to eq([listener1])
 
-        subject.subscribe(listener2)
-        expect(subject.subscribers.size).to eq(2)
-        expect(subject.subscribers).to eq([listener1, listener2])
+        ptree_visitor.subscribe(listener2)
+        expect(ptree_visitor.subscribers.size).to eq(2)
+        expect(ptree_visitor.subscribers).to eq([listener1, listener2])
       end
 
-      it 'should allow un-subcriptions' do
-        subject.subscribe(listener1)
-        subject.subscribe(listener2)
-        subject.unsubscribe(listener2)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
-        subject.unsubscribe(listener1)
-        expect(subject.subscribers).to be_empty
+      it 'allows un-subcriptions' do
+        ptree_visitor.subscribe(listener1)
+        ptree_visitor.subscribe(listener2)
+        ptree_visitor.unsubscribe(listener2)
+        expect(ptree_visitor.subscribers.size).to eq(1)
+        expect(ptree_visitor.subscribers).to eq([listener1])
+        ptree_visitor.unsubscribe(listener1)
+        expect(ptree_visitor.subscribers).to be_empty
       end
     end # context
 
 
     context 'Notifying visit events:' do
       # Default instantiation rule
-      subject do
-        instance = ParseTreeVisitor.new(grm_abc_ptree1)
+      subject(:ptree_visitor) do
+        instance = described_class.new(grm_abc_ptree1)
         instance.subscribe(listener1)
         instance
       end
@@ -119,19 +116,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       # Sample terminal node
       let(:term_node) { nterm_node.subnodes[0] }
 
-      it 'should react to the start_visit_ptree message' do
+      it 'reacts to the start_visit_ptree message' do
         # Notify subscribers when start the visit of the ptree
         expect(listener1).to receive(:before_ptree).with(grm_abc_ptree1)
-        subject.start_visit_ptree(grm_abc_ptree1)
+        ptree_visitor.start_visit_ptree(grm_abc_ptree1)
       end
 
-      it 'should react to the start_visit_nonterminal message' do
+      it 'reacts to the start_visit_nonterminal message' do
         # Notify subscribers when start the visit of a non-terminal node
         expect(listener1).to receive(:before_non_terminal).with(nterm_node)
-        subject.visit_nonterminal(nterm_node)
+        ptree_visitor.visit_nonterminal(nterm_node)
       end
 
-      it 'should react to the visit_children message' do
+      it 'reacts to the visit_children message' do
         # Notify subscribers when start the visit of children nodes
         children = nterm_node.subnodes
         args = [nterm_node, children]
@@ -139,30 +136,30 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expect(listener1).to receive(:before_terminal).with(children[0])
         expect(listener1).to receive(:after_terminal).with(children[0])
         expect(listener1).to receive(:after_subnodes).with(nterm_node, children)
-        subject.send(:traverse_subnodes, nterm_node)
+        ptree_visitor.send(:traverse_subnodes, nterm_node)
       end
 
-      it 'should react to the end_visit_nonterminal message' do
+      it 'reacts to the end_visit_nonterminal message' do
         # Notify subscribers when ending the visit of a non-terminal node
         expect(listener1).to receive(:after_non_terminal).with(nterm_node)
-        subject.end_visit_nonterminal(nterm_node)
+        ptree_visitor.end_visit_nonterminal(nterm_node)
       end
 
-      it 'should react to the visit_terminal message' do
+      it 'reacts to the visit_terminal message' do
         # Notify subscribers when start & ending the visit of a terminal node
         expect(listener1).to receive(:before_terminal).with(term_node)
         expect(listener1).to receive(:after_terminal).with(term_node)
-        subject.visit_terminal(term_node)
+        ptree_visitor.visit_terminal(term_node)
       end
 
-      it 'should react to the end_visit_ptree message' do
+      it 'reacts to the end_visit_ptree message' do
         # Notify subscribers when ending the visit of the ptree
         expect(listener1).to receive(:after_ptree).with(grm_abc_ptree1)
-        subject.end_visit_ptree(grm_abc_ptree1)
+        ptree_visitor.end_visit_ptree(grm_abc_ptree1)
       end
 
       # rubocop: disable Naming/VariableNumber
-      it 'should begin the visit when requested' do
+      it 'begins the visit when requested' do
         # Reminder: parse tree structure is
         # S[0,5]
         # +- A[0,5]
@@ -212,10 +209,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         # Here we go...
-        subject.start
+        ptree_visitor.start
       end
 
-      it 'should also visit in pre-order' do
+      it 'also visits in pre-order' do
         # Reminder: parse tree structure is
         # S[0,5]
         # +- A[0,5]
@@ -228,7 +225,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         #    +- c[4,5]
         root = grm_abc_ptree1.root
         # Here we defeat encapsulation for the good cause
-        subject.instance_variable_set(:@traversal, :pre_order)
+        ptree_visitor.instance_variable_set(:@traversal, :pre_order)
 
         children = root.subnodes
         big_a_1 = children[0]
@@ -270,7 +267,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
 
         # Here we go...
-        subject.start
+        ptree_visitor.start
       end
       # rubocop: enable Naming/VariableNumber
     end # context

data/spec/rley/parser/dangling_else_spec.rb

@@ -61,7 +61,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       let(:input) { 'if false then if true then 1 else 2' }
 
-      context 'Ambiguous parse: ' do
+      context 'Ambiguous parse:' do
         # Factory method. Creates a grammar builder for a simple grammar.
         def grammar_if_else_amb
           builder = Rley::RGN::GrammarBuilder.new do
@@ -81,13 +81,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.grammar
         end
 
-        subject { GFGEarleyParser.new(grammar_if_else_amb) }
+        subject(:a_parser) { described_class.new(grammar_if_else_amb) }
 
-        it 'should parse a valid simple input' do
+        it 'parses a valid simple input' do
           tokens = tokenizer(input)
-          parse_result = subject.parse(tokens)
-          expect(parse_result.success?).to eq(true)
-          expect(parse_result.ambiguous?).to eq(true)
+          parse_result = a_parser.parse(tokens)
+          expect(parse_result.success?).to be(true)
+          expect(parse_result.ambiguous?).to be(true)
           ######################
           # Expectation chart[0]:
           expected = [
@@ -280,7 +280,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end # context
 
-      context 'Disambiguated parse: ' do
+      context 'Disambiguated parse:' do
         def match_else_with_if(grammar)
           # Brittle code
           prod = grammar.rules[2]
@@ -310,13 +310,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.grammar
         end
 
-        subject { GFGEarleyParser.new(grammar_if_else) }
+        subject(:a_parser) { described_class.new(grammar_if_else) }
 
-        it 'should cope with dangling else problem' do
+        it 'copes with dangling else problem' do
           tokens = tokenizer(input)
-          parse_result = subject.parse(tokens)
-          expect(parse_result.success?).to eq(true)
-          expect(parse_result.ambiguous?).to eq(true)
+          parse_result = a_parser.parse(tokens)
+          expect(parse_result.success?).to be(true)
+          expect(parse_result.ambiguous?).to be(true)
           ######################
           # Expectation chart[0]:
           expected = [