rley 0.8.14 → 0.8.15

data/spec/rley/syntax/base_grammar_builder_spec.rb

@@ -8,116 +8,106 @@ require_relative '../../../lib/rley/syntax/base_grammar_builder'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe BaseGrammarBuilder do
+      subject(:a_builder) { described_class.new }
+
       context 'Initialization without argument:' do
-        it 'could be created without argument' do
-          expect { BaseGrammarBuilder.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
-            BaseGrammarBuilder.new { nil }
+            described_class.new { nil }
           end.not_to raise_error
         end
 
-        it 'could have grammar symbols from block argument' do
-          instance = BaseGrammarBuilder.new do
+        it 'has grammar symbols from block argument' 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(Terminal)
-          expect(subject.symbols['a'].name).to eq('a')
-          expect(subject.symbols['b']).to be_kind_of(Terminal)
-          expect(subject.symbols['b'].name).to eq('b')
-          expect(subject.symbols['c']).to be_kind_of(Terminal)
-          expect(subject.symbols['c'].name).to eq('c')
-        end
-
-        it 'should accept already built terminals' do
-          a = Terminal.new('a')
-          b = Terminal.new('b')
-          c = 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)
-        end
-
-        it 'should accept already built terminals' do
+        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(Terminal)
+          expect(a_builder.symbols['a'].name).to eq('a')
+          expect(a_builder.symbols['b']).to be_a(Terminal)
+          expect(a_builder.symbols['b'].name).to eq('b')
+          expect(a_builder.symbols['c']).to be_a(Terminal)
+          expect(a_builder.symbols['c'].name).to eq('c')
+        end
+
+        it 'accepts already built terminals' do
           a = Terminal.new('a')
           b = Terminal.new('b')
           c = 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 = BaseGrammarBuilder.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
-          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(new_prod.rhs[0]).to eq(subject['A'])
-
-          subject.add_production('A' => %w[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']]
+          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]).to eq(a_builder['A'])
+
+          a_builder.add_production('A' => %w[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)
 
           # Try another syntax
-          subject.add_production('A' => 'a A c')
-          expect(subject.productions.size).to eq(3)
-          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(3)
+          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)
 
           # BaseGrammarBuilder#rule is an alias of add_production
-          subject.rule('A' => ['b'])
-          expect(subject.productions.size).to eq(4)
-          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(4)
+          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 support Kleene's plus" do
-          instance = BaseGrammarBuilder.new
+        it "supports Kleene's plus" do
+          instance = described_class.new
           instance.add_terminals('plus', 'minus', 'digit')
 
           instance.add_production('integer' => 'value')
@@ -136,8 +126,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Building grammar:' do
-        subject do
-          instance = BaseGrammarBuilder.new do
+        subject(:a_builder) do
+          instance = described_class.new do
             add_terminals('a', 'b', 'c')
             add_production('S' => ['A'])
             add_production('A' => %w[a A c])
@@ -147,47 +137,47 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance
         end
 
-        it 'should build a grammar' do
-          expect(subject.grammar).to be_kind_of(Grammar)
-          grm = subject.grammar
-          expect(grm.rules).to eq(subject.productions)
+        it 'builds a grammar' do
+          expect(a_builder.grammar).to be_a(Grammar)
+          grm = a_builder.grammar
+          expect(grm.rules).to eq(a_builder.productions)
 
-          # Invoking the factory method again should return
+          # Invoking the factory method again returns
           # the same grammar object
-          second_time = subject.grammar
+          second_time = a_builder.grammar
           expect(second_time).to eq(grm)
         end
 
-        it 'should complain in absence of symbols' do
-          instance = BaseGrammarBuilder.new
+        it 'complains in absence of symbols' do
+          instance = described_class.new
           err = StandardError
           msg = 'No symbol found for grammar'
           expect { instance.grammar }.to raise_error(err, msg)
         end
 
-        it 'should complain in absence of productions' do
-          instance = BaseGrammarBuilder.new
+        it 'complains in absence of productions' do
+          instance = described_class.new
           instance.add_terminals('a', 'b', 'c')
           err = StandardError
           msg = 'No production found for grammar'
           expect { instance.grammar }.to raise_error(err, msg)
         end
 
-        it 'should complain if one or more terminals are useless' do
+        it 'complains if one or more terminals are useless' do
           # Add one useless terminal symbol
-          subject.add_terminals('d')
+          a_builder.add_terminals('d')
 
           err = StandardError
           msg = 'Useless terminal symbol(s): d.'
-          expect { subject.grammar }.to raise_error(err, msg)
+          expect { a_builder.grammar }.to raise_error(err, msg)
 
           # Add another useless terminal
-          subject.add_terminals('e')
+          a_builder.add_terminals('e')
           msg = 'Useless terminal symbol(s): d, e.'
-          expect { subject.grammar }.to raise_error(err, msg)
+          expect { a_builder.grammar }.to raise_error(err, msg)
         end
 
-        it 'should build a grammar with nullable nonterminals' do
+        it 'builds a grammar with nullable nonterminals' do
           # Grammar 4: A grammar with nullable nonterminal
           # based on example in "Parsing Techniques" book (D. Grune, C. Jabobs)
           # S ::= E.
@@ -201,7 +191,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           t_star = Terminal.new('*')
           t_slash = Terminal.new('/')
 
-          builder = BaseGrammarBuilder.new
+          builder = described_class.new
           builder.add_terminals(t_a, t_star, t_slash)
           builder.add_production('S' => 'E')
           builder.add_production('E' => %w[E Q F])

data/spec/rley/syntax/grammar_spec.rb

@@ -29,6 +29,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         result
       end
 
+      subject(:a_grammar) do
+        productions = [prod_S, prod_A1, prod_A2]
+        described_class.new(productions)
+      end
+
       # Grammar 1: arithmetical expressions with integers
       let(:grm1_ops) do
         operators = %w[+ - * / ( )]
@@ -83,91 +88,50 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:prod_A2) { Production.new(nt_A, [b_]) }
       let(:prod_A3) { Production.new(nt_A, [c_, nt_C]) }
 
-=begin
-      # Non-terminals that specify the lexicon of the language
-      let(:noun) { NonTerminal.new('Noun') }
-      let(:noun_list) { %w(flights breeze trip morning) }
-      let(:verb) { NonTerminal.new('Verb') }
-      let(:verb_list) { %w(is prefer like need want fly) }
-      let(:adjective) { NonTerminal.new('Adjective') }
-      let(:adjective_list) { %w(cheapest non-stop first latest other direct) }
-      let(:pronoun) { NonTerminal.new('Pronoun') }
-      let(:pronoun_list) { %w(me I you it) }
-      let(:proper_noun) { NonTerminal.new('Proper_noun') }
-      let(:proper_noun_list) do [ 'Alaska', 'Baltimore', 'Los Angeles',
-        'Chicago', 'United', 'American' ]
-      end
-      let(:determiner) { NonTerminal.new('Determiner') }
-      let(:determiner_list) { %w(the a an this these that) }
-      let(:preposition) { NonTerminal.new('Preposition') }
-      let(:preposition_list) { %w(from to on near) }
-      let(:conjunction) { NonTerminal.new('Conjunction') }
-      let(:conjunction_list) { %w(and or but) }
-
-      let(:noun_prods) { prods_for_list(noun, noun_list) }
-      let(:verb_prods) { prods_for_list(verb, verb_list) }
-      let(:adjective_prods) { prods_for_list(adjective, adjective_list) }
-      let(:pronoun_prods) { prods_for_list(pronoun, pronoun_list) }
-      let(:proper_pronoun_prods) do
-        prods_for_list(proper_pronoun, proper_pronoun_list)
-      end
-      let(:determiner_prods) { prods_for_list(determiner, determiner_list) }
-      let(:preposition_prods) { prods_for_list(preposition, preposition_list) }
-      let(:conjunction_prods) { prods_for_list(conjunction, conjunction_list) }
-
-      # Productions for the L0 language (from Jurafki & Martin)
-      let(:nominal_prods) { Production}
-=end
-
-      subject do
-        productions = [prod_S, prod_A1, prod_A2]
-        Grammar.new(productions)
-      end
-
       context 'Initialization:' do
-        it 'should be created with a list of productions' do
-          expect { Grammar.new([prod_S, prod_A1, prod_A2]) }.not_to raise_error
+        it 'is created with a list of productions' do
+          expect { described_class.new([prod_S, prod_A1, prod_A2]) }.not_to raise_error
         end
 
-        it 'should know its productions' do
-          expect(subject.rules).to eq([prod_S, prod_A1, prod_A2])
+        it 'knows its productions' do
+          expect(a_grammar.rules).to eq([prod_S, prod_A1, prod_A2])
         end
 
-        it 'should know its start symbol' do
-          expect(subject.start_symbol).to eq(nt_S)
+        it 'knows its start symbol' do
+          expect(a_grammar.start_symbol).to eq(nt_S)
         end
 
-        it 'should know all its symbols' do
-          expect(subject.symbols).to eq([nt_S, nt_A, a_, c_, b_])
+        it 'knows all its symbols' do
+          expect(a_grammar.symbols).to eq([nt_S, nt_A, a_, c_, b_])
         end
 
-        it 'should know all its non-terminal symbols' do
-          expect(subject.non_terminals).to eq([nt_S, nt_A])
+        it 'knows all its non-terminal symbols' do
+          expect(a_grammar.non_terminals).to eq([nt_S, nt_A])
         end
 
-        it 'should know its start production' do
-          expect(subject.start_production).to eq(prod_S)
+        it 'knows its start production' do
+          expect(a_grammar.start_production).to eq(prod_S)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should retrieve its symbols from their name' do
-          expect(subject.name2symbol['S']).to eq(nt_S)
-          expect(subject.name2symbol['A']).to eq(nt_A)
-          expect(subject.name2symbol['a']).to eq(a_)
-          expect(subject.name2symbol['b']).to eq(b_)
-          expect(subject.name2symbol['c']).to eq(c_)
+        it 'retrieves its symbols from their name' do
+          expect(a_grammar.name2symbol['S']).to eq(nt_S)
+          expect(a_grammar.name2symbol['A']).to eq(nt_A)
+          expect(a_grammar.name2symbol['a']).to eq(a_)
+          expect(a_grammar.name2symbol['b']).to eq(b_)
+          expect(a_grammar.name2symbol['c']).to eq(c_)
         end
 
-        it 'should ensure that each production has a name' do
-          subject.rules.each do |prod|
+        it 'ensures that each production has a name' do
+          a_grammar.rules.each do |prod|
             expect(prod.name).to match(Regexp.new("#{prod.lhs.name}_\\d$"))
           end
         end
       end # context
 
       context 'Grammar diagnosis:' do
-        it 'should mark any non-terminal that has no production' do
+        it 'marks any non-terminal that has no production' do
           # S ::= A.
           # S ::= B.
           # A ::= "a" .
@@ -176,13 +140,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           prod_S2 = Rley::Syntax::Production.new(nt_S, [nt_B])
           prod_A = Rley::Syntax::Production.new(nt_A, [a_])
           prod_B = Rley::Syntax::Production.new(nt_B, [nt_C, b_]) # C undefined
-          instance = Grammar.new([prod_S1, prod_S2, prod_A, prod_B])
+          instance = described_class.new([prod_S1, prod_S2, prod_A, prod_B])
           undefineds = instance.non_terminals.select(&:undefined?)
           expect(undefineds.size).to eq(1)
           expect(undefineds.first).to eq(nt_C)
         end
 
-        it 'should mark any non-terminal as generative or not' do
+        it 'marks any non-terminal as generative or not' do
           # S ::= A.
           # S ::= B.
           # A ::= "a" .
@@ -191,14 +155,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           prod_S2 = Rley::Syntax::Production.new(nt_S, [nt_B])
           prod_A = Rley::Syntax::Production.new(nt_A, [a_])
           prod_B = Rley::Syntax::Production.new(nt_B, [nt_C, b_]) # C undefined
-          instance = Grammar.new([prod_S1, prod_S2, prod_A, prod_B])
+          instance = described_class.new([prod_S1, prod_S2, prod_A, prod_B])
           partitioning = instance.non_terminals.partition(&:generative?)
           expect(partitioning[0].size).to eq(2)
           expect(partitioning[0]).to eq([nt_S, nt_A])
           expect(partitioning[1]).to eq([nt_B, nt_C])
         end
 
-        it "should do a diagnosis even for 'loopy' grammars" do
+        it "does a diagnosis even for 'loopy' grammars" do
           # 'S' => 'A'
           # 'S' => 'B'
           # 'A' => 'a'
@@ -211,7 +175,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           prd_B = Rley::Syntax::Production.new(nt_B, [nt_C])
           prd_C = Rley::Syntax::Production.new(nt_C, [nt_D])
           prd_D = Rley::Syntax::Production.new(nt_D, [nt_B])
-          instance = Grammar.new([prd_S1, prd_S2, prd_A, prd_B, prd_C, prd_D])
+          instance = described_class.new([prd_S1, prd_S2, prd_A, prd_B, prd_C, prd_D])
           partitioning = instance.non_terminals.partition(&:generative?)
           expect(partitioning[0].size).to eq(2)
           expect(partitioning[0]).to eq([nt_S, nt_A])
@@ -223,8 +187,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Non-nullable grammar:' do
-        it 'should mark all its nonterminals as non-nullable' do
-          nonterms = subject.non_terminals
+        it 'marks all its nonterminals as non-nullable' do
+          nonterms = a_grammar.non_terminals
           nonterms.each do |nterm|
             expect(nterm).not_to be_nullable
           end
@@ -232,24 +196,22 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Nullable grammars:' do
-        subject do
+        subject(:nullable_grammar) do
           prod_A4 = Production.new(nt_A, [])
           productions = [prod_S, prod_A1, prod_A2, prod_A4]
-          Grammar.new(productions)
+          described_class.new(productions)
         end
 
-        it 'should mark its nullable nonterminals' do
+        it 'marks its nullable nonterminals' do
           # In the default grammar, all nonterminals are nullable
-          nonterms = subject.non_terminals
-          nonterms.each do |nterm|
-            expect(nterm).to be_nullable
-          end
+          nonterms = nullable_grammar.non_terminals
+          expect(nonterms).to all(be_nullable)
         end
 
-        it 'should mark its nullable productions' do
+        it 'marks its nullable productions' do
           # Given the above productions, here are our expectations:
           expectations = [true, false, false, true]
-          actuals = subject.rules.map(&:nullable?)
+          actuals = nullable_grammar.rules.map(&:nullable?)
           expect(actuals).to eq(expectations)
         end
       end # context

data/spec/rley/syntax/grm_symbol_spec.rb

@@ -8,22 +8,22 @@ require_relative '../../../lib/rley/syntax/grm_symbol'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe GrmSymbol do
+      subject(:grammar_symb) { described_class.new(sample_name) }
       let(:sample_name) { 'NP' }
-      subject { GrmSymbol.new(sample_name) }
 
       context 'Initialization:' do
-        it 'should be created with a name' do
-          expect { GrmSymbol.new('NP') }.not_to raise_error
+        it 'is created with a name' do
+          expect { described_class.new('NP') }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.name).to eq(sample_name)
+        it 'knows its name' do
+          expect(grammar_symb.name).to eq(sample_name)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should give its text representation' do
-          expect(subject.to_s).to eq(sample_name)
+        it 'gives its text representation' do
+          expect(grammar_symb.to_s).to eq(sample_name)
         end
       end # context
     end # describe

data/spec/rley/syntax/match_closest_spec.rb

@@ -15,6 +15,8 @@ require_relative '../../../lib/rley/syntax/match_closest'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe MatchClosest do
+      subject(:constraint) { described_class.new(prod.rhs.members, 4, 'IF') }
+
       # 'stmt' => 'IF boolean THEN stmt ELSE stmt'
       let(:boolean) { NonTerminal.new('boolean') }
       let(:stmt) { NonTerminal.new('stmt') }
@@ -24,19 +26,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sequence) { [if_t, boolean, then_t, stmt, else_t, stmt] }
       let(:prod) { Production.new(stmt, sequence) }
 
-      subject { MatchClosest.new(prod.rhs.members, 4, 'IF') }
-
       context 'Initialization:' do
-        it 'should be created with an symbol seq., an indice and a name' do
-          expect { MatchClosest.new(prod.rhs.members, 4, 'IF') }.not_to raise_error
+        it 'is created with an symbol seq., an indice and a name' do
+          expect { described_class.new(prod.rhs.members, 4, 'IF') }.not_to raise_error
         end
 
-        it 'should know the index argument' do
-          expect(subject.idx_symbol).to eq(4) # ELSE at position 4
+        it 'knows the index argument' do
+          expect(constraint.idx_symbol).to eq(4) # ELSE at position 4
         end
 
-        it 'should know the name of preceding symbol to pair with' do
-          expect(subject.closest_symb).to eq('IF')
+        it 'knows the name of preceding symbol to pair with' do
+          expect(constraint.closest_symb).to eq('IF')
         end
       end # context
     end # describe

data/spec/rley/syntax/non_terminal_spec.rb

@@ -8,47 +8,47 @@ require_relative '../../../lib/rley/syntax/non_terminal'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe NonTerminal do
+      subject(:a_nonterm) { described_class.new(sample_name) }
       let(:sample_name) { 'noun' }
-      subject { NonTerminal.new(sample_name) }
 
       context 'Initialization:' do
-        it 'should be created with a name' do
-          expect { NonTerminal.new('noun') }.not_to raise_error
+        it 'is created with a name' do
+          expect { described_class.new('noun') }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.name).to eq(sample_name)
+        it 'knows its name' do
+          expect(a_nonterm.name).to eq(sample_name)
         end
 
-        it 'should know that is a not a terminal' do
-          expect(subject).not_to be_terminal
+        it 'knows that is a not a terminal' do
+          expect(a_nonterm).not_to be_terminal
         end
       end # context
 
 
       context 'Provided services:' do
-        it 'should know whether it is nullable' do
-          expect(subject.nullable?).to be_nil
-          subject.nullable = true
-          expect(subject).to be_nullable
-          subject.nullable = false
-          expect(subject).not_to be_nullable
+        it 'knows whether it is nullable' do
+          expect(a_nonterm.nullable?).to be_nil
+          a_nonterm.nullable = true
+          expect(a_nonterm).to be_nullable
+          a_nonterm.nullable = false
+          expect(a_nonterm).not_to be_nullable
         end
 
-        it 'should know whether it is defined' do
-          expect(subject.undefined?).to be_nil
-          subject.undefined = true
-          expect(subject).to be_undefined
-          subject.undefined = false
-          expect(subject).not_to be_undefined
+        it 'knows whether it is defined' do
+          expect(a_nonterm.undefined?).to be_nil
+          a_nonterm.undefined = true
+          expect(a_nonterm).to be_undefined
+          a_nonterm.undefined = false
+          expect(a_nonterm).not_to be_undefined
         end
 
-        it 'should know whether it is generative' do
-          expect(subject.generative?).to be_nil
-          subject.generative = true
-          expect(subject).to be_generative
-          subject.generative = false
-          expect(subject).not_to be_generative
+        it 'knows whether it is generative' do
+          expect(a_nonterm.generative?).to be_nil
+          a_nonterm.generative = true
+          expect(a_nonterm).to be_generative
+          a_nonterm.generative = false
+          expect(a_nonterm).not_to be_generative
         end
       end # context
     end # describe