rley 0.8.14 → 0.9.01

data/lib/rley/syntax/grammar.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 require_relative '../rley_error'
 
 module Rley # This module is used as a namespace
@@ -49,7 +48,7 @@ module Rley # This module is used as a namespace
 
       # @return [Array] The list of non-terminals in the grammar.
       def non_terminals
-        @non_terminals ||= symbols.select { |s| s.kind_of?(NonTerminal) }
+        @non_terminals ||= symbols.select { |s| s.is_a?(NonTerminal) }
       end
 
       # @return [Production] The start production of the grammar (i.e.
@@ -74,6 +73,7 @@ module Rley # This module is used as a namespace
         add_symbol(the_lhs)
 
         aProduction.rhs.each { |symb| add_symbol(symb) }
+        aProduction
       end
 
       # If the production is anonymous, then assign it
@@ -82,12 +82,15 @@ module Rley # This module is used as a namespace
         return unless aProduction.name.nil?
 
         index = rules.find_index(aProduction)
+        # @type var index : Integer
+
         prefix = aProduction.lhs.name.dup
         previous = index.zero? ? nil : rules[index - 1]
         if previous.nil? || previous.lhs != aProduction.lhs
           suffix = '_0'
         else
-          prev_serial = previous.name.match(/_(\d+)$/)
+          # @type var previous : Production
+          prev_serial = previous.name&.match(/_(\d+)$/)
           if prev_serial
             suffix = "_#{prev_serial[1].to_i + 1}"
           else
@@ -145,6 +148,8 @@ module Rley # This module is used as a namespace
             end
 
             last_considered = nil
+            # @type var last_considered : Rley::Syntax::GrmSymbol
+
             a_rule.rhs.members.each do |symbol|
               last_considered = symbol
               break unless symbol.generative?
@@ -200,7 +205,7 @@ module Rley # This module is used as a namespace
         # Drop productions with one terminal in rhs or with a nullable lhs
         filtered_rules = rules.reject do |prod|
           prod.lhs.nullable? || prod.rhs.find do |symb|
-            symb.kind_of?(Terminal)
+            symb.is_a?(Terminal)
           end
         end
 

data/lib/rley/syntax/production.rb

@@ -92,7 +92,7 @@ module Rley # This module is used as a namespace
       # Validation method. Return the validated input argument or
       # raise an exception.
       def valid_lhs(aNonTerminal)
-        unless aNonTerminal.kind_of?(NonTerminal)
+        unless aNonTerminal.is_a?(NonTerminal)
           msg_prefix = 'Left side of production must be a non-terminal symbol'
           msg_suffix = ", found a #{aNonTerminal.class} instead."
           raise StandardError, msg_prefix + msg_suffix

data/spec/rley/base/dotted_item_spec.rb

@@ -27,126 +27,126 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:empty_prod) { build_prod(nt_sentence) }
 
       # Default instantiation rule
-      subject { DottedItem.new(sample_prod, 1) }
+      subject(:an_item) { described_class.new(sample_prod, 1) }
 
       context 'Initialization:' do
-        it 'should be created with a production and an index' do
-          expect { DottedItem.new(sample_prod, 0) }.not_to raise_error
-          expect { DottedItem.new(sample_prod, 3) }.not_to raise_error
+        it 'is created with a production and an index' do
+          expect { described_class.new(sample_prod, 0) }.not_to raise_error
+          expect { described_class.new(sample_prod, 3) }.not_to raise_error
         end
 
-        it 'should complain when the index is out-of-bounds' do
+        it 'complains when the index is out-of-bounds' do
           err = StandardError
           msg = 'Out of bound index'
-          expect { DottedItem.new(sample_prod, 4) }.to raise_error(err, msg)
+          expect { described_class.new(sample_prod, 4) }.to raise_error(err, msg)
         end
 
-        it 'should know its production' do
-          expect(subject.production).to eq(sample_prod)
+        it 'knows its production' do
+          expect(an_item.production).to eq(sample_prod)
         end
 
-        it 'should know the lhs of the production' do
-          expect(subject.lhs).to eq(sample_prod.lhs)
+        it 'knows the lhs of the production' do
+          expect(an_item.lhs).to eq(sample_prod.lhs)
         end
 
-        it 'should know its position' do
+        it 'knows its position' do
           # At start position
-          instance1 = DottedItem.new(sample_prod, 0)
+          instance1 = described_class.new(sample_prod, 0)
           expect(instance1.position).to eq(0)
 
           # At (before) last symbol
-          instance2 = DottedItem.new(sample_prod, 2)
+          instance2 = described_class.new(sample_prod, 2)
           expect(instance2.position).to eq(2)
 
           # After all symbols in rhs
-          instance3 = DottedItem.new(sample_prod, 3)
+          instance3 = described_class.new(sample_prod, 3)
           expect(instance3.position).to eq(-1)
 
           # At start/end at the same time (production is empty)
-          instance4 = DottedItem.new(build_prod(nt_sentence), 0)
+          instance4 = described_class.new(build_prod(nt_sentence), 0)
           expect(instance4.position).to eq(-2)
         end
       end # context
 
       context 'Provided service:' do
-        it 'should whether its dot is at start position' do
-          expect(subject).not_to be_at_start
+        it 'knows whether its dot is at start position' do
+          expect(an_item).not_to be_at_start
 
           # At start position
-          instance1 = DottedItem.new(sample_prod, 0)
+          instance1 = described_class.new(sample_prod, 0)
           expect(instance1).to be_at_start
 
           # At start/end at the same time (production is empty)
-          instance2 = DottedItem.new(build_prod(nt_sentence), 0)
+          instance2 = described_class.new(build_prod(nt_sentence), 0)
           expect(instance2).to be_at_start
         end
 
-        it 'should whether it is a reduce item' do
-          expect(subject).not_to be_reduce_item
+        it 'knows whether it is a reduce item' do
+          expect(an_item).not_to be_reduce_item
 
-          first_instance = DottedItem.new(sample_prod, 3)
+          first_instance = described_class.new(sample_prod, 3)
           expect(first_instance).to be_reduce_item
 
-          second_instance = DottedItem.new(empty_prod, 0)
+          second_instance = described_class.new(empty_prod, 0)
           expect(second_instance).to be_reduce_item
         end
 
-        it 'should know the symbol before the dot' do
-          expect(subject.prev_symbol).to eq(t_a)
+        it 'knows the symbol before the dot' do
+          expect(an_item.prev_symbol).to eq(t_a)
 
           # Case of an empty production
-          instance = DottedItem.new(empty_prod, 0)
+          instance = described_class.new(empty_prod, 0)
           expect(instance.prev_symbol).to be_nil
 
           # Case of a dot at start position
-          instance = DottedItem.new(sample_prod, 0)
+          instance = described_class.new(sample_prod, 0)
           expect(instance.prev_symbol).to be_nil
         end
 
-        it 'should know the symbol after the dot' do
-          expect(subject.next_symbol).to eq(t_b)
+        it 'knows the symbol after the dot' do
+          expect(an_item.next_symbol).to eq(t_b)
         end
 
-        it 'should calculate the previous position of the dot' do
-          expect(subject.prev_position).to eq(0)
+        it 'calculates the previous position of the dot' do
+          expect(an_item.prev_position).to eq(0)
 
           # Case of an empty production
-          instance = DottedItem.new(empty_prod, 0)
+          instance = described_class.new(empty_prod, 0)
           expect(instance.prev_position).to be_nil
 
           # Case of a dot at start position
-          instance = DottedItem.new(sample_prod, 0)
+          instance = described_class.new(sample_prod, 0)
           expect(instance.prev_position).to be_nil
 
           # Case of single symbol production
-          instance = DottedItem.new(other_prod, 1)
+          instance = described_class.new(other_prod, 1)
           expect(instance.prev_position).to eq(0)
         end
 
-        it 'should determine if it is a successor of another dotted item' do
-          expect(subject).not_to be_successor_of(subject)
+        it 'determines if it is a successor of another dotted item' do
+          expect(an_item).not_to be_successor_of(an_item)
 
           # Case: different productions
-          instance = DottedItem.new(empty_prod, 0)
-          expect(subject).not_to be_successor_of(instance)
+          instance = described_class.new(empty_prod, 0)
+          expect(an_item).not_to be_successor_of(instance)
 
           # Case: one position difference
-          instance = DottedItem.new(sample_prod, 0)
-          expect(subject).to be_successor_of(instance)
-          expect(instance).not_to be_successor_of(subject)
+          instance = described_class.new(sample_prod, 0)
+          expect(an_item).to be_successor_of(instance)
+          expect(instance).not_to be_successor_of(an_item)
 
           # Case: more than one position difference
-          instance2 = DottedItem.new(sample_prod, 2)
+          instance2 = described_class.new(sample_prod, 2)
           expect(instance).not_to be_successor_of(instance2)
-          expect(subject).not_to be_successor_of(instance2)
-          expect(instance2).to be_successor_of(subject)
+          expect(an_item).not_to be_successor_of(instance2)
+          expect(instance2).to be_successor_of(an_item)
         end
 
 
 
-        it 'should give its text representation' do
+        it 'gives its text representation' do
           expectation = 'sentence => A . B C'
-          expect(subject.to_s).to eq(expectation)
+          expect(an_item.to_s).to eq(expectation)
         end
       end
     end # describe

data/spec/rley/base/grm_items_builder_spec.rb

@@ -21,7 +21,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       context 'Builder pattern behaviour' do
-        it 'should create dotted items for a grammar' do
+        it 'creates dotted items for a grammar' do
           # Next line calls method from mixin module under test
           items = build_dotted_items(grammar_abc)
           expect(items.size).to eq(8)

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