rley 0.8.01 → 0.8.02

data/lib/rley/parser/gfg_earley_parser.rb

@@ -51,7 +51,7 @@ module Rley # This module is used as a namespace
         result.chart[index].each do |entry|
           # Is entry of the form? [A => alpha . B beta, k]...
           next_symbol = entry.next_symbol
-          if next_symbol&.kind_of?(Syntax::NonTerminal)
+          if next_symbol.kind_of?(Syntax::NonTerminal)
             # ...apply the Call rule
             call_rule(result, entry, index)
           end

data/lib/rley/syntax/base_grammar_builder.rb

@@ -55,14 +55,14 @@ module Rley # This module is used as a namespace
         new_symbs = build_symbols(Terminal, terminalSymbols)
         symbols.merge!(new_symbs)
       end
-      
+
       # Add the given marker symbol to the grammar of the language
       # @param aMarkerSymbol [Syntax::Marker] A mazker symbol
-      # @return [void]      
+      # @return [void]
       def add_marker(aMarkerSymbol)
         new_symb = build_symbol(Marker, aMarkerSymbol)
         symbols[aMarkerSymbol.name] = new_symb
-      end      
+      end
 
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => Array.

data/lib/rley/syntax/match_closest.rb

@@ -7,13 +7,13 @@ module Rley # This module is used as a namespace
     class MatchClosest
       # @return [Integer] index of constrained symbol to match
       attr_reader(:idx_symbol)
-      
+
       # @return [String] name of closest preceding symbol to pair
       attr_reader(:closest_symb)
 
       # @return [NilClass, Array<Parser::ParseEntry>] set of entries with closest symbol
       attr_accessor(:entries)
-      
+
       # @param aSymbolSeq [Rley::Syntax::SymbolSeq] a sequence of grammar symbols
       # @param idxSymbol [Integer] index of symbol
       # @param nameClosest [String] Terminal symbol name
@@ -21,18 +21,18 @@ module Rley # This module is used as a namespace
         @idx_symbol = valid_idx_symbol(idxSymbol, aSymbolSeq)
         @closest_symb = valid_name_closest(nameClosest)
       end
-      
+
       private
-      
+
       # Check that the provided index is within plausible bounds
       def valid_idx_symbol(idxSymbol, aSymbolSeq)
-        bounds = 0 .. aSymbolSeq.size - 1
+        bounds = 0..aSymbolSeq.size - 1
         err_msg_outbound = 'Index of symbol out of bound'
         raise StandardError, err_msg_outbound unless bounds.include? idxSymbol
-        
+
         idxSymbol
       end
-      
+
       def valid_name_closest(nameClosest)
         nameClosest
       end

data/spec/rley/notation/grammar_builder_spec.rb

@@ -170,7 +170,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(val_prod.rhs.members[0].name).to eq('digit_plus')
         end
 
-        it "should support optional grouping" do
+        it 'should support optional grouping' do
           instance = GrammarBuilder.new
           instance.add_terminals('EQUAL', 'IDENTIFIER', 'VAR')
 
@@ -199,7 +199,7 @@ 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
+        it 'should support grouping with star modifier' do
           instance = GrammarBuilder.new
           instance.add_terminals('OR')
 
@@ -230,7 +230,7 @@ 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
+        it 'should support grouping with plus modifier' do
           instance = GrammarBuilder.new
           instance.add_terminals('POINT TO SEMI_COLON')
 
@@ -261,7 +261,7 @@ 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
+        it 'should support grouping with nested annotation' do
           instance = GrammarBuilder.new
           instance.add_terminals('IF ELSE LPAREN RPAREN')
           st = "IF LPAREN expr RPAREN stmt (ELSE { match_closest: 'IF' } stmt)?"
@@ -281,7 +281,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p0.rhs[0].name).to eq('ELSE')
           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.size).to eq(1)
           expect(p0.constraints[0]).to be_kind_of(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')
@@ -299,4 +299,4 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/notation/parser_spec.rb

@@ -1,184 +1,183 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper' # Use the RSpec framework
-
-require_relative '../../../lib/rley/notation/ast_builder'
-# Load the class under test
-require_relative '../../../lib/rley/notation/parser'
-
-module Rley
-  module Notation
-    describe Parser do
-      subject { Parser.new }
-
-      # Utility method to walk towards deeply nested node
-      # @param aNTNode [Rley::PTree::NonTerminalNode]
-      # @param subnodePath[Array<Integer>] An Array of subnode indices
-      def walk_subnodes(aNTNode, subnodePath)
-        curr_node = aNTNode
-        subnodePath.each do |index|
-          curr_node = curr_node.subnodes[index]
-        end
-
-        curr_node
-      end
-
-      context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { Parser.new }.not_to raise_error
-        end
-
-        it 'should have its parse engine initialized' do
-          expect(subject.engine).to be_kind_of(Rley::Engine)
-        end
-      end # context
-     
-      context 'Parsing into CST:' do
-        subject do
-          instance = Parser.new
-          instance.engine.configuration.repr_builder = Rley::ParseRep::CSTBuilder
-
-          instance
-        end
-
-        it 'should parse single symbol names' do
-          samples = %w[IF ifCondition statement]
-
-          # One drawback od 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)
-            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].symbol.name).to eq('rhs')
-            expect(ptree.root.subnodes[0].subnodes[0]).to be_kind_of(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].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].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].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].token.lexeme).to eq(source)
-          end
-        end
-
-      end # context
-
-      context 'Parsing into AST:' do
-        subject do
-          instance = Parser.new
-          instance.engine.configuration.repr_builder = ASTBuilder
-
-          instance
-        end
-
-        it 'should parse 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)
-            expect(ptree.root.name).to eq(source)
-            expect(ptree.root.repetition).to eq(:exactly_one)
-          end
-        end
-
-        it 'should parse 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)
-          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].name).to eq('ELLIPSIS')
-          expect(ptree.root.subnodes[2]).to be_kind_of(SymbolNode)
-          expect(ptree.root.subnodes[2].name).to eq('INT_LIT')
-        end
-
-        it 'should parse an optional symbol' do
-          optional = 'member_seq?'
-
-          ptree = subject.parse(optional)
-          expect(ptree.root).to be_kind_of(SymbolNode)
-          expect(ptree.root.name).to eq('member_seq')
-          expect(ptree.root.repetition).to eq(:zero_or_one)
-        end
-
-        it 'should parse a symbol with a + modifier' do
-          one_or_more = 'member+'
-
-          ptree = subject.parse(one_or_more)
-          expect(ptree.root).to be_kind_of(SymbolNode)
-          expect(ptree.root.name).to eq('member')
-          expect(ptree.root.repetition).to eq(:one_or_more)
-        end
-
-        it 'should parse 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)
-          expect(ptree.root.subnodes[0]).to be_kind_of(SymbolNode)
-          expect(ptree.root.subnodes[0].name).to eq('declaration')
-          expect(ptree.root.subnodes[0].repetition).to eq(:zero_or_more)
-          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
-          expect(ptree.root.subnodes[1].name).to eq('EOF')
-          expect(ptree.root.subnodes[1].repetition).to eq(:exactly_one)
-        end
-
-        it 'should parse 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)
-          expect(ptree.root.subnodes[0].name).to eq('IF')
-          expect(ptree.root.subnodes[1]).to be_kind_of(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].name).to eq('statement')
-          expect(ptree.root.subnodes[3]).to be_kind_of(SequenceNode)
-          expect(ptree.root.subnodes[3].repetition).to eq(:zero_or_one)
-          expect(ptree.root.subnodes[3].subnodes[0]).to be_kind_of(SymbolNode)
-          expect(ptree.root.subnodes[3].subnodes[0].name).to eq('ELSE')
-          expect(ptree.root.subnodes[3].subnodes[1]).to be_kind_of(SymbolNode)
-          expect(ptree.root.subnodes[3].subnodes[1].name).to eq('statement')
-        end
-
-        it 'should parse an annotated symbol' do
-          optional = 'member_seq{repeat: 0..1}'
-
-          ptree = subject.parse(optional)
-          expect(ptree.root).to be_kind_of(SymbolNode)
-          expect(ptree.root.name).to eq('member_seq')
-          expect(ptree.root.repetition).to eq(:zero_or_one)
-        end
-
-        it 'should parse 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)
-          expect(ptree.root.subnodes[0].name).to eq('IF')
-          expect(ptree.root.subnodes[1]).to be_kind_of(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].name).to eq('statement')
-          optional = ptree.root.subnodes[3]
-          expect(optional).to be_kind_of(SequenceNode)
-          expect(optional.repetition).to eq(:zero_or_one)
-          expect(optional.subnodes[0]).to be_kind_of(SymbolNode)
-          expect(optional.subnodes[0].name).to eq('ELSE')
-          expect(optional.subnodes[0].annotation).to eq({'match_closest' => 'IF'})
-          expect(optional.subnodes[1].name).to eq('statement')
-        end
-      end # context
-    end # describe
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative '../../spec_helper' # Use the RSpec framework
+
+require_relative '../../../lib/rley/notation/ast_builder'
+# Load the class under test
+require_relative '../../../lib/rley/notation/parser'
+
+module Rley
+  module Notation
+    describe Parser do
+      subject { Parser.new }
+
+      # Utility method to walk towards deeply nested node
+      # @param aNTNode [Rley::PTree::NonTerminalNode]
+      # @param subnodePath[Array<Integer>] An Array of subnode indices
+      def walk_subnodes(aNTNode, subnodePath)
+        curr_node = aNTNode
+        subnodePath.each do |index|
+          curr_node = curr_node.subnodes[index]
+        end
+
+        curr_node
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Parser.new }.not_to raise_error
+        end
+
+        it 'should have its parse engine initialized' do
+          expect(subject.engine).to be_kind_of(Rley::Engine)
+        end
+      end # context
+
+      context 'Parsing into CST:' do
+        subject do
+          instance = Parser.new
+          instance.engine.configuration.repr_builder = Rley::ParseRep::CSTBuilder
+
+          instance
+        end
+
+        it 'should parse single symbol names' do
+          samples = %w[IF ifCondition statement]
+
+          # One drawback od 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)
+            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].symbol.name).to eq('rhs')
+            expect(ptree.root.subnodes[0].subnodes[0]).to be_kind_of(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].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].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].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].token.lexeme).to eq(source)
+          end
+        end
+      end # context
+
+      context 'Parsing into AST:' do
+        subject do
+          instance = Parser.new
+          instance.engine.configuration.repr_builder = ASTBuilder
+
+          instance
+        end
+
+        it 'should parse 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)
+            expect(ptree.root.name).to eq(source)
+            expect(ptree.root.repetition).to eq(:exactly_one)
+          end
+        end
+
+        it 'should parse 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)
+          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].name).to eq('ELLIPSIS')
+          expect(ptree.root.subnodes[2]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[2].name).to eq('INT_LIT')
+        end
+
+        it 'should parse an optional symbol' do
+          optional = 'member_seq?'
+
+          ptree = subject.parse(optional)
+          expect(ptree.root).to be_kind_of(SymbolNode)
+          expect(ptree.root.name).to eq('member_seq')
+          expect(ptree.root.repetition).to eq(:zero_or_one)
+        end
+
+        it 'should parse a symbol with a + modifier' do
+          one_or_more = 'member+'
+
+          ptree = subject.parse(one_or_more)
+          expect(ptree.root).to be_kind_of(SymbolNode)
+          expect(ptree.root.name).to eq('member')
+          expect(ptree.root.repetition).to eq(:one_or_more)
+        end
+
+        it 'should parse 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)
+          expect(ptree.root.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[0].name).to eq('declaration')
+          expect(ptree.root.subnodes[0].repetition).to eq(:zero_or_more)
+          expect(ptree.root.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[1].name).to eq('EOF')
+          expect(ptree.root.subnodes[1].repetition).to eq(:exactly_one)
+        end
+
+        it 'should parse 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)
+          expect(ptree.root.subnodes[0].name).to eq('IF')
+          expect(ptree.root.subnodes[1]).to be_kind_of(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].name).to eq('statement')
+          expect(ptree.root.subnodes[3]).to be_kind_of(SequenceNode)
+          expect(ptree.root.subnodes[3].repetition).to eq(:zero_or_one)
+          expect(ptree.root.subnodes[3].subnodes[0]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].subnodes[0].name).to eq('ELSE')
+          expect(ptree.root.subnodes[3].subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].subnodes[1].name).to eq('statement')
+        end
+
+        it 'should parse an annotated symbol' do
+          optional = 'member_seq{repeat: 0..1}'
+
+          ptree = subject.parse(optional)
+          expect(ptree.root).to be_kind_of(SymbolNode)
+          expect(ptree.root.name).to eq('member_seq')
+          expect(ptree.root.repetition).to eq(:zero_or_one)
+        end
+
+        it 'should parse 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)
+          expect(ptree.root.subnodes[0].name).to eq('IF')
+          expect(ptree.root.subnodes[1]).to be_kind_of(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].name).to eq('statement')
+          optional = ptree.root.subnodes[3]
+          expect(optional).to be_kind_of(SequenceNode)
+          expect(optional.repetition).to eq(:zero_or_one)
+          expect(optional.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(optional.subnodes[0].name).to eq('ELSE')
+          expect(optional.subnodes[0].annotation).to eq({ 'match_closest' => 'IF' })
+          expect(optional.subnodes[1].name).to eq('statement')
+        end
+      end # context
+    end # describe
+  end # module
+end # module