rley 0.8.14 → 0.8.15

data/spec/rley/engine_spec.rb

@@ -11,37 +11,37 @@ require_relative '../../lib/rley/engine'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   describe Engine do
-    subject { Engine.new }
+    subject(:an_engine) { described_class.new }
 
     context 'Creation and initialization:' do
-      it 'could be created without argument' do
-        expect { Engine.new }.not_to raise_error
+      it 'is created without argument' do
+        expect { described_class.new }.not_to raise_error
       end
 
-      it 'could be created with block argument' do
+      it 'is created with block argument' do
         expect do
-          Engine.new do |config|
+          described_class.new do |config|
             config.parse_repr = :raw
           end
         end.not_to raise_error
       end
 
-      it "shouldn't have a link to a grammar yet" do
-        expect(subject.grammar).to be_nil
+      it "doesn't have a link to a grammar yet" do
+        expect(an_engine.grammar).to be_nil
       end
     end # context
 
     context 'Grammar building:' do
-      it 'should build grammar' do
-        subject.build_grammar do
+      it 'builds grammar' do
+        an_engine.build_grammar do
           add_terminals('a', 'b', 'c')
           add_production('S' => 'A')
           add_production('A' => 'a A c')
           add_production('A' => 'b')
         end
 
-        expect(subject.grammar).to be_kind_of(Rley::Syntax::Grammar)
-        expect(subject.grammar.rules.size).to eq(3)
+        expect(an_engine.grammar).to be_a(Rley::Syntax::Grammar)
+        expect(an_engine.grammar.rules.size).to eq(3)
       end
     end # context
 
@@ -78,34 +78,34 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     end
 
     context 'Parsing:' do
-      subject do
-        instance = Engine.new
+      subject(:an_engine) do
+        instance = described_class.new
         add_sample_grammar(instance)
         instance
       end
 
-      it 'should parse a stream of tokens' do
+      it 'parses a stream of tokens' do
         sample_text = 'a a b c c'
         tokenizer = ABCTokenizer.new(sample_text)
-        result = subject.parse(tokenizer)
+        result = an_engine.parse(tokenizer)
         expect(result).to be_success
       end
     end # context
 
     context 'Parse tree manipulation:' do
-      subject do
-        instance = Engine.new
-        add_sample_grammar(instance)
-        instance
-      end
-
       let(:sample_tokenizer) do
         sample_text = 'a a b c c'
         ABCTokenizer.new(sample_text)
       end
 
-      it 'should build a parse tree even for a nullable production' do
-        instance = Engine.new
+      subject(:an_engine) do
+        instance = described_class.new
+        add_sample_grammar(instance)
+        instance
+      end
+
+      it 'builds a parse tree even for a nullable production' do
+        instance = described_class.new
         instance.build_grammar do
           add_terminals('a', 'b', 'c')
           add_production 'S' => 'A BC'
@@ -121,31 +121,31 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expect { instance.to_ptree(raw_result) }.not_to raise_error
       end
 
-      it 'should build default parse trees' do
-        raw_result = subject.parse(sample_tokenizer)
-        ptree = subject.convert(raw_result)
-        expect(ptree).to be_kind_of(PTree::ParseTree)
+      it 'builds default parse trees' do
+        raw_result = an_engine.parse(sample_tokenizer)
+        ptree = an_engine.convert(raw_result)
+        expect(ptree).to be_a(PTree::ParseTree)
       end
 
-      it 'should build custom parse trees' do
+      it 'builds custom parse trees' do
         # Cheating: we point to default tree builder (CST)
-        subject.configuration.repr_builder = ParseRep::CSTBuilder
-        raw_result = subject.parse(sample_tokenizer)
-        ptree = subject.convert(raw_result)
-        expect(ptree).to be_kind_of(PTree::ParseTree)
+        an_engine.configuration.repr_builder = ParseRep::CSTBuilder
+        raw_result = an_engine.parse(sample_tokenizer)
+        ptree = an_engine.convert(raw_result)
+        expect(ptree).to be_a(PTree::ParseTree)
       end
 
-      it 'should provide a parse visitor' do
-        raw_result = subject.parse(sample_tokenizer)
-        ptree = subject.to_ptree(raw_result)
-        visitor = subject.ptree_visitor(ptree)
-        expect(visitor).to be_kind_of(ParseTreeVisitor)
+      it 'provides a parse visitor' do
+        raw_result = an_engine.parse(sample_tokenizer)
+        ptree = an_engine.to_ptree(raw_result)
+        visitor = an_engine.ptree_visitor(ptree)
+        expect(visitor).to be_a(ParseTreeVisitor)
       end
     end # context
 
     context 'Parse forest manipulation:' do
-      subject do
-        instance = Engine.new
+      subject(:an_engine) do
+        instance = described_class.new
         add_sample_grammar(instance)
         instance
       end
@@ -155,8 +155,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         ABCTokenizer.new(sample_text)
       end
 
-      it 'should build a parse forest even for a nullable production' do
-        instance = Engine.new
+      it 'builds a parse forest even for a nullable production' do
+        instance = described_class.new
         instance.build_grammar do
           add_terminals('a', 'b', 'c')
           add_production 'S' => 'A BC'
@@ -172,17 +172,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expect { instance.to_pforest(raw_result) }.not_to raise_error
       end
 
-      it 'should build parse forest' do
-        raw_result = subject.parse(sample_tokenizer)
-        pforest = subject.to_pforest(raw_result)
-        expect(pforest).to be_kind_of(SPPF::ParseForest)
+      it 'builds parse forest' do
+        raw_result = an_engine.parse(sample_tokenizer)
+        pforest = an_engine.to_pforest(raw_result)
+        expect(pforest).to be_a(SPPF::ParseForest)
       end
 
-      it 'should provide a parse visitor' do
-        raw_result = subject.parse(sample_tokenizer)
-        ptree = subject.to_pforest(raw_result)
-        visitor = subject.pforest_visitor(ptree)
-        expect(visitor).to be_kind_of(ParseForestVisitor)
+      it 'provides a parse visitor' do
+        raw_result = an_engine.parse(sample_tokenizer)
+        ptree = an_engine.to_pforest(raw_result)
+        visitor = an_engine.pforest_visitor(ptree)
+        expect(visitor).to be_a(ParseForestVisitor)
       end
     end # context
   end # describe

data/spec/rley/formatter/asciitree_spec.rb

@@ -15,6 +15,8 @@ require_relative '../../../lib/rley/formatter/asciitree'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Asciitree do
+      subject(:a_formatter) { described_class.new(destination) }
+
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do
@@ -55,25 +57,23 @@ module Rley # Re-open the module to get rid of qualified names
         ptree = engine.convert(parse_result)
         ptree
       end
-
       let(:destination) { StringIO.new(+'', 'w') }
-      subject { Asciitree.new(destination) }
 
       context 'Standard creation & initialization:' do
-        it 'should be initialized with an IO argument' do
-          expect { Asciitree.new(StringIO.new(+'', 'w')) }.not_to raise_error
+        it 'is initialized with an IO argument' do
+          expect { described_class.new(StringIO.new(+'', 'w')) }.not_to raise_error
         end
 
-        it 'should know its output destination' do
-          expect(subject.output).to eq(destination)
+        it 'knows its output destination' do
+          expect(a_formatter.output).to eq(destination)
         end
       end # context
 
 
       context 'Rendering:' do
-        it 'should render a parse tree' do
+        it 'renders a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
-          subject.render(visitor)
+          a_formatter.render(visitor)
           expectations = <<-SNIPPET
 S
 +-- A

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -15,6 +15,8 @@ require_relative '../../../lib/rley/formatter/bracket_notation'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe BracketNotation do
+      subject(:a_formatter) { described_class.new(destination) }
+
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do
@@ -57,36 +59,34 @@ module Rley # Re-open the module to get rid of qualified names
       end
 
       let(:destination) { StringIO.new(+'', 'w') }
-      subject { BracketNotation.new(destination) }
 
       context 'Standard creation & initialization:' do
-        it 'should be initialized with an IO argument' do
+        it 'is initialized with an IO argument' do
           expect do
-            BracketNotation.new(StringIO.new(+'', 'w'))
+            described_class.new(StringIO.new(+'', 'w'))
           end.not_to raise_error
         end
 
-        it 'should know its output destination' do
-          expect(subject.output).to eq(destination)
+        it 'knows its output destination' do
+          expect(a_formatter.output).to eq(destination)
         end
       end # context
 
-
       context 'Formatting events:' do
-        it 'should support visit events of a parse tree' do
+        it 'supports visit events of a parse tree' do
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
-          subject.render(visitor)
+          a_formatter.render(visitor)
           expectations = '[S [A [a a][A [a a][A [b b]][c c]][c c]]]'
           expect(destination.string).to eq(expectations)
         end
 
-        it 'should escape square brackets' do
+        it 'escapes square brackets' do
           f_node = double('fake-node')
           f_token = double('fake-token')
           expect(f_node).to receive(:token).and_return(f_token)
           expect(f_token).to receive(:lexeme).and_return('[][]')
 
-          subject.after_terminal(f_node)
+          a_formatter.after_terminal(f_node)
           expectations = '\[\]\[\]]'
           expect(destination.string).to eq(expectations)
         end

data/spec/rley/formatter/debug_spec.rb

@@ -79,24 +79,24 @@ module Rley # Re-open the module to get rid of qualified names
       let(:destination) { StringIO.new(+'', 'w') }
 
       context 'Standard creation & initialization:' do
-        it 'should be initialized with an IO argument' do
-          expect { Debug.new(StringIO.new(+'', 'w')) }.not_to raise_error
+        it 'is initialized with an IO argument' do
+          expect { described_class.new(StringIO.new(+'', 'w')) }.not_to raise_error
         end
 
-        it 'should know its output destination' do
-          instance = Debug.new(destination)
+        it 'knows its output destination' do
+          instance = described_class.new(destination)
           expect(instance.output).to eq(destination)
         end
 
-        it 'should have a zero indentation' do
-          instance = Debug.new(destination)
+        it 'has a zero indentation' do
+          instance = described_class.new(destination)
           expect(instance.indentation).to be_zero
         end
       end # context
 
       context 'Formatting events:' do
-        it 'should support visit events of a parse tree' do
-          instance = Debug.new(destination)
+        it 'supports visit events of a parse tree' do
+          instance = described_class.new(destination)
           expect(instance.output).to eq(destination)
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           instance.render(visitor)
@@ -133,8 +133,8 @@ SNIPPET
           expect(destination.string).to eq(expectations)
         end
 
-        it 'should support visit events of a parse forest' do
-          instance = Debug.new(destination)
+        it 'supports visit events of a parse forest' do
+          instance = described_class.new(destination)
           expect(instance.output).to eq(destination)
           visitor = Rley::ParseForestVisitor.new(grm_sppf_pforest1)
           instance.render(visitor)

data/spec/rley/formatter/json_spec.rb

@@ -54,24 +54,23 @@ module Rley # Re-open the module to get rid of qualified names
         ptree = engine.convert(parse_result)
         ptree
       end
-
       let(:destination) { StringIO.new(+'', 'w') }
 
       context 'Standard creation & initialization:' do
-        it 'should be initialized with an IO argument' do
-          expect { Json.new(StringIO.new(+'', 'w')) }.not_to raise_error
+        it 'is initialized with an IO argument' do
+          expect { described_class.new(StringIO.new(+'', 'w')) }.not_to raise_error
         end
 
-        it 'should know its output destination' do
-          instance = Json.new(destination)
+        it 'knows its output destination' do
+          instance = described_class.new(destination)
           expect(instance.output).to eq(destination)
         end
       end # context
 
 
       context 'Formatting events:' do
-        it 'should render a parse tree in JSON' do
-          instance = Json.new(destination)
+        it 'renders a parse tree in JSON' do
+          instance = described_class.new(destination)
           visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
           instance.render(visitor)
           expectations = <<-SNIPPET

data/spec/rley/gfg/call_edge_spec.rb

@@ -21,6 +21,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         return Syntax::Production.new(theLHS, theRHSSymbols)
       end
 
+      subject(:an_edge) { described_class.new(vertex1, vertex2) }
+
       let(:t_a) { Rley::Syntax::Terminal.new('a') }
       let(:t_b) { Rley::Syntax::Terminal.new('b') }
       let(:t_c) { Rley::Syntax::Terminal.new('c') }
@@ -28,21 +30,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
       let(:sample_prod) { build_prod(nt_sentence, t_a, nt_b_sequence, t_c) }
       let(:sample_item) { Base::DottedItem.new(sample_prod, 1) }
-
       let(:vertex1) { ItemVertex.new(sample_item) }
       let(:vertex2) { StartVertex.new('to') }
-      subject { CallEdge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { CallEdge.new(vertex1, vertex2) }.not_to raise_error
+        it 'is created with two vertice arguments' do
+          expect { described_class.new(vertex1, vertex2) }.not_to raise_error
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its key' do
+        it 'knows its key' do
           expectation = "CALL_#{sample_prod.object_id}_#{sample_item.position}"
-          expect(subject.key).to eq(expectation)
+          expect(an_edge.key).to eq(expectation)
         end
       end # context
     end # describe

data/spec/rley/gfg/edge_spec.rb

@@ -11,21 +11,22 @@ require_relative '../../../lib/rley/gfg/edge'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe Edge do
+      subject(:an_edge) { described_class.new(vertex1, vertex2) }
+
       let(:vertex1) { StartVertex.new('from') }
       let(:vertex2) { StartVertex.new('to') }
-      subject { Edge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { Edge.new(vertex1, vertex2) }.not_to raise_error
+        it 'is created with two vertice arguments' do
+          expect { described_class.new(vertex1, vertex2) }.not_to raise_error
         end
 
-        it 'should be registered by the predecessor vertex' do
-          expect(subject).to eq(vertex1.edges.last)
+        it 'is registered by the predecessor vertex' do
+          expect(an_edge).to eq(vertex1.edges.last)
         end
 
-        it 'should know the successor vertex' do
-          expect(subject.successor).to eq(vertex2)
+        it 'knows the successor vertex' do
+          expect(an_edge.successor).to eq(vertex2)
         end
       end # context
     end # describe

data/spec/rley/gfg/end_vertex_spec.rb

@@ -9,24 +9,25 @@ require_relative '../../../lib/rley/gfg/end_vertex'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
     describe EndVertex do
+      subject(:a_vertex) { described_class.new(sample_nt) }
+
       let(:sample_nt) { Syntax::NonTerminal.new('NT') }
-      subject { EndVertex.new(sample_nt) }
 
       context 'Initialization:' do
-        it 'should be created with a non-terminal symbol' do
-          expect { EndVertex.new(sample_nt) }.not_to raise_error
+        it 'is created with a non-terminal symbol' do
+          expect { described_class.new(sample_nt) }.not_to raise_error
         end
 
-        it 'should know its label' do
+        it 'knows its label' do
           expect(sample_nt).to receive(:to_s).and_return('NT')
-          expect(subject.label).to eq('NT.')
+          expect(a_vertex.label).to eq('NT.')
         end
       end # context
 
       context 'Provided services:' do
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           pattern = /^#<Rley::GFG::EndVertex:\d+ label="NT\."/
-          expect(subject.inspect).to match(pattern)
+          expect(a_vertex.inspect).to match(pattern)
         end
       end # context
     end # describe

data/spec/rley/gfg/epsilon_edge_spec.rb

@@ -10,14 +10,15 @@ require_relative '../../../lib/rley/gfg/epsilon_edge'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Edge do
+    describe EpsilonEdge do
+      subject { described_class.new(vertex1, vertex2) }
+
       let(:vertex1) { StartVertex.new('from') }
       let(:vertex2) { StartVertex.new('to') }
-      subject { EpsilonEdge.new(vertex1, vertex2) }
 
       context 'Initialization:' do
-        it 'should be created with two vertice arguments' do
-          expect { EpsilonEdge.new(vertex1, vertex2) }.not_to raise_error
+        it 'is created with two vertice arguments' do
+          expect { described_class.new(vertex1, vertex2) }.not_to raise_error
         end
       end # context
     end # describe

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -34,6 +34,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end
 
+      # Default instantiation rule
+      subject(:a_graph) { described_class.new(items_from_grammar) }
+
       # Factory method. Build a production with the given sequence
       # of symbols as its rhs.
       let(:grammar_abc) do
@@ -45,52 +48,48 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       # from the abc grammar
       let(:items_from_grammar) { build_items_for_grammar(grammar_abc) }
 
-      # Default instantiation rule
-      subject { GrmFlowGraph.new(items_from_grammar) }
-
-
       context 'Initialization:' do
-        it 'should be created with an array of dotted items' do
-          expect { GrmFlowGraph.new(items_from_grammar) }.not_to raise_error
+        it 'is created with an array of dotted items' do
+          expect { described_class.new(items_from_grammar) }.not_to raise_error
         end
 
-        it 'should know its main start vertex' do
-          expect(subject.start_vertex).to eq(subject.vertices.first)
+        it 'knows its main start vertex' do
+          expect(a_graph.start_vertex).to eq(a_graph.vertices.first)
         end
 
-        it 'should have the correct number of vertices' do
+        it 'has the correct number of vertices' do
           # Number of vertices = count of dotted items +...
           #   ... 2 * count of non-terminals
           count_vertices = 2 * grammar_abc.non_terminals.size
           count_vertices += items_from_grammar.size
-          expect(subject.vertices.size).to eq(count_vertices)
+          expect(a_graph.vertices.size).to eq(count_vertices)
         end
 
-        it 'should have for each non-terminal one start and end vertex' do
+        it 'has for each non-terminal one start and end vertex' do
           # Iterate over all non-terminals of grammar...
           grammar_abc.non_terminals.each do |nterm|
             # ...to each non-terminal there should be a start vertex
-            start_vertex = subject.start_vertex_for[nterm]
-            expect(start_vertex).to be_kind_of(StartVertex)
+            start_vertex = a_graph.start_vertex_for[nterm]
+            expect(start_vertex).to be_a(StartVertex)
             expect(start_vertex.label).to eq(".#{nterm}")
 
             # ...to each non-terminal there should be an end vertex
-            end_vertex = subject.end_vertex_for[nterm]
-            expect(end_vertex).to be_kind_of(EndVertex)
+            end_vertex = a_graph.end_vertex_for[nterm]
+            expect(end_vertex).to be_a(EndVertex)
             expect(end_vertex.label).to eq("#{nterm}.")
           end
         end
 
-        it 'should have one or more entry edges per start vertex' do
-          subject.start_vertex_for.each_value do |a_start|
+        it 'has one or more entry edges per start vertex' do
+          a_graph.start_vertex_for.each_value do |a_start|
             expect(a_start.edges.size >= 1).to be_truthy
             a_start.edges.each do |edge|
-              expect(edge.successor.dotted_item.at_start?).to be_truthy
+              expect(edge.successor.dotted_item).to be_at_start
             end
           end
         end
 
-        it 'should have the correct graph structure' do
+        it 'has the correct graph structure' do
           # We use the abc grammar
           expected = [
             '.S --> S => . A',
@@ -108,10 +107,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'A => b . --> A.'
           ]
 
-          compare_graph_expectations(subject, expected)
+          compare_graph_expectations(a_graph, expected)
         end
 
-        it 'should handle empty productions' do
+        it 'handles empty productions' do
             builder = Rley::Syntax::BaseGrammarBuilder.new
             builder.add_terminals('a')
             builder.add_production('S' => 'A')
@@ -121,7 +120,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             grammar = builder.grammar
             items = build_items_for_grammar(grammar)
 
-            graph = GrmFlowGraph.new(items)
+            graph = described_class.new(items)
             expected = [
               '.S --> S => . A',
               '.A --> A => . a',
@@ -137,8 +136,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             compare_graph_expectations(graph, expected)
         end
 
-        it 'should have shortcut edges' do
-          subject.vertices.each do |a_vertex|
+        it 'has shortcut edges' do
+          a_graph.vertices.each do |a_vertex|
             next unless a_vertex.kind_of?(ItemVertex)
 
             if a_vertex.next_symbol.kind_of?(Syntax::NonTerminal)
@@ -177,9 +176,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder.grammar
         end
 
-        it 'should provide depth-first traversal' do
+        it 'provides depth-first traversal' do
           result = []
-          subject.traverse_df(subject.start_vertex) do |vertex|
+          a_graph.traverse_df(a_graph.start_vertex) do |vertex|
             result << vertex.label
           end
 
@@ -200,28 +199,28 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(result).to eq(expected)
         end
 
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           prefix = /^#<Rley::GFG::GrmFlowGraph:\d+ @vertices=\[/
-          expect(subject.inspect).to match(prefix)
+          expect(a_graph.inspect).to match(prefix)
           pattern = /@vertices=\[#<Rley::GFG::StartVertex:\d+ label="\.S"/
-          expect(subject.inspect).to match(pattern)
+          expect(a_graph.inspect).to match(pattern)
           suffix = /]>$/
-          expect(subject.inspect).to match(suffix)
+          expect(a_graph.inspect).to match(suffix)
         end
 
-        it 'should perform a diagnosis of a correct grammar' do
-          expect { subject.diagnose }.not_to raise_error
+        it 'performs a diagnosis of a correct grammar' do
+          expect { a_graph.diagnose }.not_to raise_error
           grammar_abc.non_terminals.each do |nterm|
             expect(nterm).not_to be_undefined
             expect(nterm).not_to be_unreachable
           end
         end
 
-        it 'should detect when a non-terminal is unreachable' do
+        it 'detects when a non-terminal is unreachable' do
           grammar = problematic_grammar
           items = build_items_for_grammar(grammar)
 
-          graph = GrmFlowGraph.new(items)
+          graph = described_class.new(items)
           expect { graph.diagnose }.not_to raise_error
           grammar.non_terminals.each do |nterm|
             expect(nterm).not_to be_undefined