rley 0.8.00 → 0.8.05

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