rley 0.8.13 → 0.8.15

data/spec/rley/rgn/grammar_builder_spec.rb

@@ -8,113 +8,115 @@ require_relative '../../../lib/rley/rgn/grammar_builder'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module RGN # Open this namespace to avoid module qualifier prefixes
     describe GrammarBuilder do
+      subject(:a_builder) { described_class.new }
+
       context 'Initialization without argument:' do
-        it 'could be created without argument' do
-          expect { GrammarBuilder.new }.not_to raise_error
+        it 'is created without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have no grammar symbols at start' do
-            expect(subject.symbols).to be_empty
+        it 'has no grammar symbols at start' do
+            expect(a_builder.symbols).to be_empty
         end
 
-        it 'should have no productions at start' do
-            expect(subject.productions).to be_empty
+        it 'has no productions at start' do
+            expect(a_builder.productions).to be_empty
         end
       end # context
 
       context 'Initialization with argument:' do
-        it 'could be created with a block argument' do
+        it 'is created with a block argument' do
           expect do
-            GrammarBuilder.new { nil }
+            described_class.new { nil }
           end.not_to raise_error
         end
 
         it 'could have grammar symbols from block argument' do
-          instance = GrammarBuilder.new do
+          instance = described_class.new do
             add_terminals('a', 'b', 'c')
           end
           expect(instance.symbols.size).to eq(3)
         end
 
-        it 'should have no productions at start' do
-            expect(subject.productions).to be_empty
+        it 'has no productions at start' do
+            expect(a_builder.productions).to be_empty
         end
       end # context
 
       context 'Adding symbols:' do
-        it 'should build terminals from their names' do
-          subject.add_terminals('a', 'b', 'c')
-          expect(subject.symbols.size).to eq(3)
-          expect(subject.symbols['a']).to be_kind_of(Syntax::Terminal)
-          expect(subject.symbols['a'].name).to eq('a')
-          expect(subject.symbols['b']).to be_kind_of(Syntax::Terminal)
-          expect(subject.symbols['b'].name).to eq('b')
-          expect(subject.symbols['c']).to be_kind_of(Syntax::Terminal)
-          expect(subject.symbols['c'].name).to eq('c')
+        it 'builds terminals from their names' do
+          a_builder.add_terminals('a', 'b', 'c')
+          expect(a_builder.symbols.size).to eq(3)
+          expect(a_builder.symbols['a']).to be_a(Syntax::Terminal)
+          expect(a_builder.symbols['a'].name).to eq('a')
+          expect(a_builder.symbols['b']).to be_a(Syntax::Terminal)
+          expect(a_builder.symbols['b'].name).to eq('b')
+          expect(a_builder.symbols['c']).to be_a(Syntax::Terminal)
+          expect(a_builder.symbols['c'].name).to eq('c')
         end
 
-        it 'should accept already built terminals' do
+        it 'accepts already built terminals' do
           a = Syntax::Terminal.new('a')
           b = Syntax::Terminal.new('b')
           c = Syntax::Terminal.new('c')
 
-          subject.add_terminals(a, b, c)
-          expect(subject.symbols.size).to eq(3)
-          expect(subject.symbols['a']).to eq(a)
-          expect(subject.symbols['b']).to eq(b)
-          expect(subject.symbols['c']).to eq(c)
+          a_builder.add_terminals(a, b, c)
+          expect(a_builder.symbols.size).to eq(3)
+          expect(a_builder.symbols['a']).to eq(a)
+          expect(a_builder.symbols['b']).to eq(b)
+          expect(a_builder.symbols['c']).to eq(c)
         end
       end # context
 
       context 'Adding productions:' do
-        subject do
-          instance = GrammarBuilder.new
+        subject(:a_builder) do
+          instance = described_class.new
           instance.add_terminals('a', 'b', 'c')
           instance
         end
 
-        it 'should add a valid production' do
+        it 'adds a valid production' do
           # Case of a rhs representation that consists of one name only
-          expect { subject.add_production('S' => 'A') }.not_to raise_error
-          expect(subject.productions.size).to eq(1)
-          new_prod = subject.productions[0]
-          expect(new_prod.lhs).to eq(subject['S'])
+          expect { a_builder.add_production('S' => 'A') }.not_to raise_error
+          expect(a_builder.productions.size).to eq(1)
+          new_prod = a_builder.productions[0]
+          expect(new_prod.lhs).to eq(a_builder['S'])
           expect(new_prod.rhs[0]).not_to be_nil
-          expect(new_prod.rhs[0]).to eq(subject['A'])
+          expect(new_prod.rhs[0]).to eq(a_builder['A'])
 
           # Case of rhs with multiple symbols
-          subject.add_production('A' => 'a A c')
-          expect(subject.productions.size).to eq(2)
-          new_prod = subject.productions.last
-          expect(new_prod.lhs).to eq(subject['A'])
-          expect_rhs = [subject['a'], subject['A'], subject['c']]
+          a_builder.add_production('A' => 'a A c')
+          expect(a_builder.productions.size).to eq(2)
+          new_prod = a_builder.productions.last
+          expect(new_prod.lhs).to eq(a_builder['A'])
+          expect_rhs = [a_builder['a'], a_builder['A'], a_builder['c']]
           expect(new_prod.rhs.members).to eq(expect_rhs)
 
           # GrammarBuilder#rule is an alias of add_production
-          subject.rule('A' => 'b')
-          expect(subject.productions.size).to eq(3)
-          new_prod = subject.productions.last
-          expect(new_prod.lhs).to eq(subject['A'])
-          expect(new_prod.rhs[0]).to eq(subject['b'])
+          a_builder.rule('A' => 'b')
+          expect(a_builder.productions.size).to eq(3)
+          new_prod = a_builder.productions.last
+          expect(new_prod.lhs).to eq(a_builder['A'])
+          expect(new_prod.rhs[0]).to eq(a_builder['b'])
         end
 
-        it 'should accept annotated terminals' do
-          subject.rule('A' => "a b {match_closest: 'IF' } c")
-          expect(subject.productions.size).to eq(1)
-          new_prod = subject.productions.last
-          expect(new_prod.lhs).to eq(subject['A'])
+        it 'accepts annotated terminals' do
+          a_builder.rule('A' => "a b {match_closest: 'IF' } c")
+          expect(a_builder.productions.size).to eq(1)
+          new_prod = a_builder.productions.last
+          expect(new_prod.lhs).to eq(a_builder['A'])
           expect(new_prod.rhs[0].name).to eq('a')
-          expect(new_prod.rhs[0]).to eq(subject['a'])
+          expect(new_prod.rhs[0]).to eq(a_builder['a'])
           expect(new_prod.rhs[1].name).to eq('b')
           expect(new_prod.rhs[2].name).to eq('c')
           expect(new_prod.constraints.size).to eq(1)
-          expect(new_prod.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(new_prod.constraints[0]).to be_a(Syntax::MatchClosest)
           expect(new_prod.constraints[0].idx_symbol).to eq(1) # b is on position 1
           expect(new_prod.constraints[0].closest_symb).to eq('IF')
         end
 
-        it 'should support optional symbol' do
-          instance = GrammarBuilder.new
+        it 'supports optional symbol' do
+          instance = described_class.new
           instance.add_terminals('LPAREN', 'RPAREN')
 
           instance.rule 'argument_list' => 'LPAREN arguments? RPAREN'
@@ -131,8 +133,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.productions.last.rhs.members).to be_empty
         end
 
-        it "should support Kleene's star" do
-          instance = GrammarBuilder.new
+        it "supports Kleene's star" do
+          instance = described_class.new
           instance.add_terminals('EOF')
 
           instance.rule 'program' => 'declaration* EOF'
@@ -148,8 +150,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(first_prod.rhs.members[0].name).to eq('rep_declaration_star')
         end
 
-        it "should support symbols decorated with Kleene's plus" do
-          instance = GrammarBuilder.new
+        it "supports symbols decorated with Kleene's plus" do
+          instance = described_class.new
           instance.add_terminals('plus', 'minus', 'digit')
 
           instance.rule 'integer' => 'value'
@@ -171,8 +173,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(val_prod.rhs.members[0].name).to eq('rep_digit_plus')
         end
 
-        it 'should support optional grouping' do
-          instance = GrammarBuilder.new
+        it 'supports optional grouping' do
+          instance = described_class.new
           instance.add_terminals('EQUAL', 'IDENTIFIER', 'VAR')
 
           instance.rule 'var_decl' => 'VAR IDENTIFIER (EQUAL expression)?'
@@ -202,8 +204,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.name).to eq('_qmark_none')
         end
 
-        it 'should support grouping with star modifier' do
-          instance = GrammarBuilder.new
+        it 'supports grouping with star modifier' do
+          instance = described_class.new
           instance.add_terminals('OR')
 
           instance.rule 'logic_or' => 'logic_and (OR logic_and)*'
@@ -233,8 +235,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.name).to eq('_star_none')
         end
 
-        it 'should support grouping with plus modifier' do
-          instance = GrammarBuilder.new
+        it 'supports grouping with plus modifier' do
+          instance = described_class.new
           instance.add_terminals('POINT TO SEMI_COLON')
 
           instance.rule 'path' => 'POINT (TO POINT)+ SEMI_COLON'
@@ -264,8 +266,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.name).to eq('_plus_one')
         end
 
-        it 'should support grouping with nested annotation' do
-          instance = GrammarBuilder.new
+        it 'supports grouping with nested annotation' do
+          instance = described_class.new
           instance.add_terminals('IF ELSE LPAREN RPAREN')
           st = "IF LPAREN expr RPAREN stmt (ELSE { match_closest: 'IF' } stmt)?"
           instance.rule('if_stmt' => st)
@@ -282,7 +284,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # expect(p0.rhs[1].name).to eq('stmt')
           # expect(p0.name).to eq('return_children')
           # expect(p0.constraints.size).to eq(1)
-          # expect(p0.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          # expect(p0.constraints[0]).to be_a(Syntax::MatchClosest)
           # expect(p0.constraints[0].idx_symbol).to eq(0) # ELSE is on position 0
           # expect(p0.constraints[0].closest_symb).to eq('IF')
 
@@ -291,7 +293,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p1.rhs[1].name).to eq('stmt')
           expect(p1.name).to eq('return_children')
           expect(p1.constraints.size).to eq(1)
-          expect(p1.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(p1.constraints[0]).to be_a(Syntax::MatchClosest)
           expect(p1.constraints[0].closest_symb).to eq('IF')
 
           expect(p2.lhs.name).to eq('rep_seq_ELSE_stmt_qmark')

data/spec/rley/rgn/parser_spec.rb

@@ -9,7 +9,7 @@ require_relative '../../../lib/rley/rgn/parser'
 module Rley
   module RGN
     describe Parser do
-      subject { Parser.new }
+      subject(:a_parser) { described_class.new }
 
       # Utility method to walk towards deeply nested node
       # @param aNTNode [Rley::PTree::NonTerminalNode]
@@ -24,44 +24,44 @@ module Rley
       end
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Parser.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have its parse engine initialized' do
-          expect(subject.engine).to be_kind_of(Rley::Engine)
+        it 'has its parse engine initialized' do
+          expect(a_parser.engine).to be_a(Rley::Engine)
         end
       end # context
 
       context 'Parsing into CST:' do
-        subject do
-          instance = Parser.new
+        subject(:a_parser) do
+          instance = described_class.new
           instance.engine.configuration.repr_builder = Rley::ParseRep::CSTBuilder
 
           instance
         end
 
-        it 'should parse single symbol names' do
+        it 'parses single symbol names' do
           samples = %w[IF ifCondition statement]
 
           # One drawback of CSTs: they have a deeply nested structure
           samples.each do |source|
-            ptree = subject.parse(source)
-            expect(ptree.root).to be_kind_of(Rley::PTree::NonTerminalNode)
+            ptree = a_parser.parse(source)
+            expect(ptree.root).to be_a(Rley::PTree::NonTerminalNode)
             expect(ptree.root.symbol.name).to eq('notation')
-            expect(ptree.root.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(ptree.root.subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
             expect(ptree.root.subnodes[0].symbol.name).to eq('rhs')
-            expect(ptree.root.subnodes[0].subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(ptree.root.subnodes[0].subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
             member_seq = ptree.root.subnodes[0].subnodes[0]
             expect(member_seq.symbol.name).to eq('member_seq')
-            expect(member_seq.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(member_seq.subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
             expect(member_seq.subnodes[0].symbol.name).to eq('member')
-            expect(member_seq.subnodes[0].subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(member_seq.subnodes[0].subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
             expect(member_seq.subnodes[0].subnodes[0].symbol.name).to eq('strait_member')
             strait_member = member_seq.subnodes[0].subnodes[0]
-            expect(strait_member.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(strait_member.subnodes[0]).to be_a(Rley::PTree::NonTerminalNode)
             expect(strait_member.subnodes[0].symbol.name).to eq('base_member')
-            expect(strait_member.subnodes[0].subnodes[0]).to be_kind_of(Rley::PTree::TerminalNode)
+            expect(strait_member.subnodes[0].subnodes[0]).to be_a(Rley::PTree::TerminalNode)
             expect(strait_member.subnodes[0].subnodes[0].token.lexeme).to eq(source)
           end
         end
@@ -69,122 +69,122 @@ module Rley
 
       context 'Parsing into AST:' do
         subject do
-          instance = Parser.new
+          instance = described_class.new
           instance.engine.configuration.repr_builder = ASTBuilder
 
           instance
         end
 
-        it 'should parse single symbol names' do
+        it 'parses single symbol names' do
           samples = %w[IF ifCondition statement]
 
           samples.each do |source|
-            ptree = subject.parse(source)
-            expect(ptree.root).to be_kind_of(SymbolNode)
+            ptree = a_parser.parse(source)
+            expect(ptree.root).to be_a(SymbolNode)
             expect(ptree.root.name).to eq(source)
             expect(ptree.root.annotation).to be_empty
           end
         end
 
-        it 'should parse a sequence of symbols' do
+        it 'parses a sequence of symbols' do
           sequence = 'INT_LIT ELLIPSIS INT_LIT'
 
-          ptree = subject.parse(sequence)
-          expect(ptree.root).to be_kind_of(SequenceNode)
-          expect(ptree.root.subnodes[0]).to be_kind_of(SymbolNode)
+          ptree = a_parser.parse(sequence)
+          expect(ptree.root).to be_a(SequenceNode)
+          expect(ptree.root.subnodes[0]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[0].name).to eq('INT_LIT')
-          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[1]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[1].name).to eq('ELLIPSIS')
-          expect(ptree.root.subnodes[2]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[2]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[2].name).to eq('INT_LIT')
         end
 
-        it 'should parse an optional symbol' do
+        it 'parses an optional symbol' do
           optional = 'member_seq?'
 
-          ptree = subject.parse(optional)
-          expect(ptree.root).to be_kind_of(RepetitionNode)
+          ptree = a_parser.parse(optional)
+          expect(ptree.root).to be_a(RepetitionNode)
           expect(ptree.root.name).to eq('rep_member_seq_qmark')
-          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child).to be_a(SymbolNode)
           expect(ptree.root.child.name).to eq('member_seq')
           expect(ptree.root.repetition).to eq(:zero_or_one)
         end
 
-        it 'should parse a symbol with a + modifier' do
+        it 'parses a symbol with a + modifier' do
           one_or_more = 'member+'
 
-          ptree = subject.parse(one_or_more)
-          expect(ptree.root).to be_kind_of(RepetitionNode)
+          ptree = a_parser.parse(one_or_more)
+          expect(ptree.root).to be_a(RepetitionNode)
           expect(ptree.root.name).to eq('rep_member_plus')
-          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child).to be_a(SymbolNode)
           expect(ptree.root.child.name).to eq('member')
           expect(ptree.root.repetition).to eq(:one_or_more)
         end
 
-        it 'should parse a symbol with a * modifier' do
+        it 'parses a symbol with a * modifier' do
           zero_or_more = 'declaration* EOF'
 
-          ptree = subject.parse(zero_or_more)
-          expect(ptree.root).to be_kind_of(SequenceNode)
+          ptree = a_parser.parse(zero_or_more)
+          expect(ptree.root).to be_a(SequenceNode)
           expect(ptree.root.name).to eq('seq_rep_declaration_star_EOF')
-          expect(ptree.root.subnodes[0]).to be_kind_of(RepetitionNode)
+          expect(ptree.root.subnodes[0]).to be_a(RepetitionNode)
           expect(ptree.root.subnodes[0].name).to eq('rep_declaration_star')
           expect(ptree.root.subnodes[0].repetition).to eq(:zero_or_more)
-          expect(ptree.root.subnodes[0].child).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[0].child).to be_a(SymbolNode)
           expect(ptree.root.subnodes[0].child.name).to eq('declaration')
-          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[1]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[1].name).to eq('EOF')
         end
 
-        it 'should parse a grouping with a modifier' do
+        it 'parses a grouping with a modifier' do
           input = 'IF ifCondition statement (ELSE statement)?'
 
-          ptree = subject.parse(input)
-          expect(ptree.root).to be_kind_of(SequenceNode)
-          expect(ptree.root.subnodes[0]).to be_kind_of(SymbolNode)
+          ptree = a_parser.parse(input)
+          expect(ptree.root).to be_a(SequenceNode)
+          expect(ptree.root.subnodes[0]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[0].name).to eq('IF')
-          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[1]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[1].name).to eq('ifCondition')
-          expect(ptree.root.subnodes[2]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[2]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[2].name).to eq('statement')
-          expect(ptree.root.subnodes[3]).to be_kind_of(RepetitionNode)
+          expect(ptree.root.subnodes[3]).to be_a(RepetitionNode)
           expect(ptree.root.subnodes[3].name).to eq('rep_seq_ELSE_statement_qmark')
           expect(ptree.root.subnodes[3].repetition).to eq(:zero_or_one)
-          expect(ptree.root.subnodes[3].child).to be_kind_of(SequenceNode)
-          expect(ptree.root.subnodes[3].child.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].child).to be_a(SequenceNode)
+          expect(ptree.root.subnodes[3].child.subnodes[0]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[3].child.subnodes[0].name).to eq('ELSE')
-          expect(ptree.root.subnodes[3].child.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].child.subnodes[1]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[3].child.subnodes[1].name).to eq('statement')
         end
 
-        it 'should parse an annotated symbol' do
+        it 'parses an annotated symbol' do
           optional = 'member_seq{repeat: 0..1}'
 
-          ptree = subject.parse(optional)
-          expect(ptree.root).to be_kind_of(RepetitionNode)
+          ptree = a_parser.parse(optional)
+          expect(ptree.root).to be_a(RepetitionNode)
           expect(ptree.root.name).to eq('rep_member_seq_qmark')
           expect(ptree.root.repetition).to eq(:zero_or_one)
-          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child).to be_a(SymbolNode)
           expect(ptree.root.child.name).to eq('member_seq')
         end
 
-        it 'should parse a grouping with embedded annotation' do
+        it 'parses a grouping with embedded annotation' do
           if_stmt = "IF ifCondition statement ( ELSE { match_closest: 'IF' } statement )?"
 
-          ptree = subject.parse(if_stmt)
-          expect(ptree.root).to be_kind_of(SequenceNode)
-          expect(ptree.root.subnodes[0]).to be_kind_of(SymbolNode)
+          ptree = a_parser.parse(if_stmt)
+          expect(ptree.root).to be_a(SequenceNode)
+          expect(ptree.root.subnodes[0]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[0].name).to eq('IF')
-          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[1]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[1].name).to eq('ifCondition')
-          expect(ptree.root.subnodes[2]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[2]).to be_a(SymbolNode)
           expect(ptree.root.subnodes[2].name).to eq('statement')
           optional = ptree.root.subnodes[3]
-          expect(optional).to be_kind_of(RepetitionNode)
+          expect(optional).to be_a(RepetitionNode)
           expect(optional.name).to eq('rep_seq_ELSE_statement_qmark')
           expect(optional.repetition).to eq(:zero_or_one)
-          expect(optional.child).to be_kind_of(SequenceNode)
-          expect(optional.child.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(optional.child).to be_a(SequenceNode)
+          expect(optional.child.subnodes[0]).to be_a(SymbolNode)
           expect(optional.child.subnodes[0].name).to eq('ELSE')
           expect(optional.child.subnodes[0].annotation).to eq({ 'match_closest' => 'IF' })
           expect(optional.child.subnodes[1].name).to eq('statement')

data/spec/rley/rgn/repetition_node_spec.rb

@@ -11,41 +11,41 @@ require_relative '../../../lib/rley/rgn/repetition_node'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module RGN # Open this namespace to avoid module qualifier prefixes
     describe RepetitionNode do
+      # Default instantiation rule
+      subject(:rep_node) { described_class.new(a_child, star) }
+
       let(:a_name) { 'arguments' }
       let(:a_pos) { Lexical::Position.new(3, 4) }
       let(:a_child) { SymbolNode.new(a_pos, a_name) }
       let(:star) { :zero_or_more }
 
-      # Default instantiation rule
-      subject { RepetitionNode.new(a_child, star) }
-
       context 'Initialization:' do
-        it 'should be created with a child node and a symbol' do
-          expect { RepetitionNode.new(a_child, star) }.not_to raise_error
+        it 'is created with a child node and a symbol' do
+          expect { described_class.new(a_child, star) }.not_to raise_error
         end
 
-        it 'should know its child' do
-          expect(subject.subnodes.size).to eq(1)
-          expect(subject.subnodes.first).to eq(a_child)
-          expect(subject.child).to eq(a_child)
+        it 'knows its child' do
+          expect(rep_node.subnodes.size).to eq(1)
+          expect(rep_node.subnodes.first).to eq(a_child)
+          expect(rep_node.child).to eq(a_child)
         end
 
-        it 'should know its repetition' do
-          expect(subject.repetition).to eq(star)
+        it 'knows its repetition' do
+          expect(rep_node.repetition).to eq(star)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its name' do
+        it 'knows its name' do
           # Case repetition == :zero_or_one
-          instance = RepetitionNode.new(a_child, :zero_or_one)
+          instance = described_class.new(a_child, :zero_or_one)
           expect(instance.name).to eq('rep_arguments_qmark')
 
           # Case repetition == :zero_or_more
-          expect(subject.name).to eq('rep_arguments_star')
+          expect(rep_node.name).to eq('rep_arguments_star')
 
           # Case repetition == :one_or_more
-          instance = RepetitionNode.new(a_child, :one_or_more)
+          instance = described_class.new(a_child, :one_or_more)
           expect(instance.name).to eq('rep_arguments_plus')
         end
       end # context

data/spec/rley/rgn/sequence_node_spec.rb

@@ -11,6 +11,9 @@ require_relative '../../../lib/rley/rgn/sequence_node'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module RGN # Open this namespace to avoid module qualifier prefixes
     describe SequenceNode do
+      # Default instantiation rule
+      subject(:seq_node) { described_class.new([child1, child2, child3]) }
+
       let(:name1) { 'LPAR' }
       let(:name2) { 'arguments' }
       let(:name3) { 'RPAR' }
@@ -21,24 +24,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:child2) { SymbolNode.new(pos2, name2) }
       let(:child3) { SymbolNode.new(pos3, name3) }
 
-      # Default instantiation rule
-      subject { SequenceNode.new([child1, child2, child3]) }
-
       context 'Initialization:' do
-        it 'should be created with an array of child nodes' do
+        it 'is created with an array of child nodes' do
           children = [child1, child2, child3]
-          expect { SequenceNode.new(children) }.not_to raise_error
+          expect { described_class.new(children) }.not_to raise_error
         end
 
-        it 'should know its subnodes' do
-          expect(subject.subnodes.size).to eq(3)
-          expect(subject.subnodes).to eq([child1, child2, child3])
+        it 'knows its subnodes' do
+          expect(seq_node.subnodes.size).to eq(3)
+          expect(seq_node.subnodes).to eq([child1, child2, child3])
         end
       end # context
 
       context 'Provided services:' do
-        it 'should know its name' do
-          expect(subject.name).to eq('seq_LPAR_arguments_RPAR')
+        it 'knows its name' do
+          expect(seq_node.name).to eq('seq_LPAR_arguments_RPAR')
         end
       end # context
     end # describe

data/spec/rley/rgn/symbol_node_spec.rb

@@ -7,7 +7,6 @@ require_relative '../../../lib/rley/lexical/token'
 # Load the class under test
 require_relative '../../../lib/rley/rgn/symbol_node'
 
-
 module Rley # Open this namespace to avoid module qualifier prefixes
   module RGN # Open this namespace to avoid module qualifier prefixes
     describe SymbolNode do
@@ -16,14 +15,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         # Default instantiation rule
-        subject { SymbolNode.new(a_pos, a_name) }
+        subject(:a_node) { described_class.new(a_pos, a_name) }
 
-        it 'should be created with a name and position' do
-          expect { SymbolNode.new(a_pos, a_name) }.not_to raise_error
+        it 'is created with a name and position' do
+          expect { described_class.new(a_pos, a_name) }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.name).to eq(a_name)
+        it 'knows its name' do
+          expect(a_node.name).to eq(a_name)
         end
       end # context
     end # describe