rley 0.8.14 → 0.8.15

data/spec/rley/syntax/production_spec.rb

@@ -12,82 +12,82 @@ require_relative '../../../lib/rley/syntax/production'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe Production do
+      # Default instantiation rule
+      subject(:a_production) { described_class.new(sentence, sequence) }
+
       let(:sentence) { NonTerminal.new('Sentence') }
       let(:np) { NonTerminal.new('NP') }
       let(:vp) { NonTerminal.new('VP') }
       let(:sequence) { [np, vp] }
 
-      # Default instantiation rule
-      subject { Production.new(sentence, sequence) }
-
       context 'Initialization:' do
-        it 'should be created with a non-terminal and a symbol sequence' do
-          expect { Production.new(sentence, sequence) }.not_to raise_error
+        it 'is created with a non-terminal and a symbol sequence' do
+          expect { described_class.new(sentence, sequence) }.not_to raise_error
         end
 
-        it 'should complain when its rhs is nil' do
+        it 'complains when its rhs is nil' do
           err = StandardError
           msg_prefix = 'Right side of a production of the kind '
           msg_suffix = "'Sentence' => ... is nil."
           msg = msg_prefix + msg_suffix
-          expect { Production.new(sentence, nil) }.to raise_error(err, msg)
+          expect { described_class.new(sentence, nil) }.to raise_error(err, msg)
         end
 
-        it 'should know its lhs' do
-          expect(subject.lhs).to eq(sentence)
-          expect(subject.head).to eq(sentence)
+        it 'knows its lhs' do
+          expect(a_production.lhs).to eq(sentence)
+          expect(a_production.head).to eq(sentence)
         end
 
-        it 'should know its rhs' do
-          expect(subject.rhs).to eq(sequence)
-          expect(subject.body).to eq(sequence)
+        it 'knows its rhs' do
+          expect(a_production.rhs).to eq(sequence)
+          expect(a_production.body).to eq(sequence)
         end
 
-        it 'should be free from constraints at start' do
-          expect(subject.constraints).to be_empty
+        it 'is free from constraints at start' do
+          expect(a_production.constraints).to be_empty
         end
 
-        it 'should know whether its rhs is empty' do
-          expect(subject).not_to be_empty
+        it 'knows whether its rhs is empty' do
+          expect(a_production).not_to be_empty
 
-          instance = Production.new(sentence, [])
+          instance = described_class.new(sentence, [])
           expect(instance).to be_empty
         end
 
-        it 'should be anonymous at creation' do
-          expect(subject.name).to be_nil
+        it 'is anonymous at creation' do
+          expect(a_production.name).to be_nil
         end
 
-        it 'should complain if its lhs is not a non-terminal' do
+        it 'complains if its lhs is not a non-terminal' do
           err = StandardError
           msg_prefix = 'Left side of production must be a non-terminal symbol'
           msg_suffix = ", found a #{String} instead."
           msg = msg_prefix + msg_suffix
-          expect { Production.new('wrong', sequence) }.to raise_error(err, msg)
+          expect { described_class.new('wrong', sequence) }.to raise_error(err, msg)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept a name (i)' do
+        it 'accepts a name (i)' do
           a_name = 'nominem'
-          subject.name = a_name
-          expect(subject.name).to eq(a_name)
+          a_production.name = a_name
+          expect(a_production.name).to eq(a_name)
         end
 
-        it 'should accept a name (ii)' do
+        it 'accepts a name (ii)' do
           a_name = 'nominem'
-          subject.as(a_name)
-          expect(subject.name).to eq(a_name)
+          a_production.as(a_name)
+          expect(a_production.name).to eq(a_name)
         end
 
-        it 'should provide human-readable representation of itself' do
-          subject.name = 'some name'
+        it 'provides a human-readable representation of itself' do
+          a_production.name = 'some name'
           prefix = /^#<Rley::Syntax::Production:\d+ @name="some name"/
-          expect(subject.inspect).to match(prefix)
+          expect(a_production.inspect).to match(prefix)
           pattern = /@lhs=Sentence @rhs=#<Rley::Syntax::SymbolSeq/
-          expect(subject.inspect).to match(pattern)
+          expect(a_production.inspect).to match(pattern)
           suffix = /> @generative=>$/
-          expect(subject.inspect).to match(suffix)
+          expect(a_production.inspect).to match(suffix)
         end
       end # context
     end # describe

data/spec/rley/syntax/symbol_seq_spec.rb

@@ -10,63 +10,63 @@ require_relative '../../../lib/rley/syntax/symbol_seq'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe SymbolSeq do
+      # Default instantiation rule
+      subject(:symbol_sequence) { described_class.new([verb, np, pp]) }
+
       let(:verb) { NonTerminal.new('Verb') }
       let(:np) { NonTerminal.new('NP') }
       let(:pp) { NonTerminal.new('PP') }
 
-      # Default instantiation rule
-      subject { SymbolSeq.new([verb, np, pp]) }
-
       context 'Initialization:' do
-        it 'should be created with a list of symbols' do
+        it 'is created with a list of symbols' do
           # Case of non-empty sequence
-          expect { SymbolSeq.new([verb, np, pp]) }.not_to raise_error
+          expect { described_class.new([verb, np, pp]) }.not_to raise_error
 
           # Case of empty sequence
-          expect { SymbolSeq.new([]) }.not_to raise_error
+          expect { described_class.new([]) }.not_to raise_error
         end
 
-        it 'should know its members' do
-          expect(subject.members).to eq([verb, np, pp])
+        it 'knows its members' do
+          expect(symbol_sequence.members).to eq([verb, np, pp])
         end
 
-        it 'should know whether it is empty' do
-          expect(subject).not_to be_empty
-          instance = SymbolSeq.new([])
+        it 'knows whether it is empty' do
+          expect(symbol_sequence).not_to be_empty
+          instance = described_class.new([])
           expect(instance).to be_empty
         end
 
-        it 'should the count of its members' do
-          expect(subject.size).to eq(3)
+        it 'knows the count of its members' do
+          expect(symbol_sequence.size).to be(3)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should compare compare with itself' do
-          me = subject # Use another name to please Rubocop
-          expect(subject == me).to eq(true)
+        it 'compares with itself' do
+          me = symbol_sequence # Use another name to please Rubocop
+          expect(symbol_sequence == me).to be(true)
         end
 
-        it 'should compare with another instance' do
-          empty_one = SymbolSeq.new([])
-          expect(subject == empty_one).not_to eq(true)
+        it 'compares with another instance' do
+          empty_one = described_class.new([])
+          expect(symbol_sequence == empty_one).not_to be(true)
 
-          equal_one = SymbolSeq.new([verb, np, pp])
-          expect(subject == equal_one).to eq(true)
+          equal_one = described_class.new([verb, np, pp])
+          expect(symbol_sequence == equal_one).to be(true)
 
-          unequal_one = SymbolSeq.new([verb, pp, np])
-          expect(subject == unequal_one).not_to eq(true)
+          unequal_one = described_class.new([verb, pp, np])
+          expect(symbol_sequence == unequal_one).not_to be(true)
         end
 
-        it 'should complain when unable to compare' do
+        it 'complains when unable to compare' do
           err = StandardError
           msg = 'Cannot compare a SymbolSeq with a String'
-          expect { subject == 'dummy-text' }.to raise_error(err, msg)
+          expect { symbol_sequence == 'dummy-text' }.to raise_error(err, msg)
         end
 
-        it 'should provide human-readable representation of itself' do
+        it 'provides human-readable representation of itself' do
           suffix = /::SymbolSeq:\d+ @members=\["Verb", "NP", "PP"\]>$/
-          expect(subject.inspect).to match(suffix)
+          expect(symbol_sequence.inspect).to match(suffix)
         end
       end # context
     end # describe

data/spec/rley/syntax/terminal_spec.rb

@@ -8,28 +8,29 @@ require_relative '../../../lib/rley/syntax/terminal'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
     describe Terminal do
+      subject(:the_terminal) { described_class.new(sample_name) }
+
       let(:sample_name) { 'noun' }
-      subject { Terminal.new(sample_name) }
 
       context 'Initialization:' do
-        it 'should be created with a name' do
-          expect { Terminal.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(the_terminal.name).to eq(sample_name)
         end
 
-        it 'should know that is a terminal symbol' do
-          expect(subject).to be_terminal
+        it 'knows that is a terminal symbol' do
+          expect(the_terminal).to be_terminal
         end
 
-        it "should know that isn't nullable" do
-          expect(subject).not_to be_nullable
+        it "knows that isn't nullable" do
+          expect(the_terminal).not_to be_nullable
         end
 
-        it 'should know that it is generative' do
-          expect(subject).to be_generative
+        it 'knows that it is generative' do
+          expect(the_terminal).to be_generative
         end
       end # context
     end # describe

data/spec/support/base_tokenizer_spec.rb

@@ -7,19 +7,20 @@ require_relative '../../lib/support/base_tokenizer'
 
 describe BaseTokenizer do
   let(:sample_input) { '7 + (8 + 9)' }
+
   context 'Standard creation & initialization:' do
-    subject { BaseTokenizer.new(sample_input) }
+    subject(:tokenizer) { described_class.new(sample_input) }
 
-    it 'should be initialized with a text argument' do
-      expect { BaseTokenizer.new(sample_input) }.not_to raise_error
+    it 'is initialized with a text argument' do
+      expect { described_class.new(sample_input) }.not_to raise_error
     end
 
-    it 'should have a scanner initialized' do
-      expect(subject.scanner).to be_kind_of(StringScanner)
+    it 'has a scanner initialized' do
+      expect(tokenizer.scanner).to be_a(StringScanner)
     end
 
-    it 'should have line number initialized' do
-      expect(subject.lineno).to eq(1)
+    it 'has line number initialized' do
+      expect(tokenizer.lineno).to eq(1)
     end
   end # context
 
@@ -58,7 +59,7 @@ describe BaseTokenizer do
       tokenizer.tokens
     end
 
-    it 'should return a sequence of tokens' do
+    it 'returns a sequence of tokens' do
       sequence = tokenize(sample_input)
       checks = [
         ['int', 7, [1, 1]],

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.8.14
+  version: 0.8.15
 platform: ruby
 authors:
 - Dimitri Geshef
 bindir: bin
 cert_chain: []
-date: 2025-02-26 00:00:00.000000000 Z
+date: 2025-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prime