rley 0.8.06 → 0.8.10

data/lib/rley/syntax/terminal.rb

@@ -7,25 +7,29 @@ module Rley # This module is used as a namespace
     # A terminal symbol represents a class of words in the language
     # defined the grammar.
     class Terminal < GrmSymbol
-      # Constructor.
-      # @param aName [String] The name of the grammar symbol.
-      def initialize(aName)
-        super(aName)
-        self.generative = true
+      # An indicator that tells whether the grammar symbol can generate a
+      # non-empty string of terminals.
+      # @return [TrueClass]
+      def generative?
+        true
       end
 
       # Return true iff the symbol is a terminal
+      # @return [TrueClass]
       def terminal?
-        return true
+        true
       end
 
       # @return [false] Return true if the symbol derives
       # the empty string. As terminal symbol corresponds to a input token
       # it is by definition non-nullable.
+      # @return [FalseClass]
       def nullable?
         false
       end
 
+      # Return a readable text representation of the instance
+      # @return [String] The symbol name
       def to_s
         name
       end

data/spec/rley/parser/dangling_else_spec.rb

@@ -9,7 +9,7 @@ require_relative '../../../lib/rley/syntax/base_grammar_builder'
 require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/base/dotted_item'
 require_relative '../../../lib/rley/parser/gfg_parsing'
-require_relative '../../../lib/rley/notation/grammar_builder'
+require_relative '../../../lib/rley/rgn/grammar_builder'
 
 require_relative '../support/expectation_helper'
 
@@ -64,7 +64,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       context 'Ambiguous parse: ' do
         # Factory method. Creates a grammar builder for a simple grammar.
         def grammar_if_else_amb
-          builder = Rley::Notation::GrammarBuilder.new do
+          builder = Rley::RGN::GrammarBuilder.new do
             add_terminals('IF', 'THEN', 'ELSE')
             add_terminals('FALSE', 'TRUE', 'INTEGER')
 
@@ -290,7 +290,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         # Factory method. Creates a grammar builder for a simple grammar.
         def grammar_if_else
-          builder = Rley::Notation::GrammarBuilder.new do
+          builder = Rley::RGN::GrammarBuilder.new do
             add_terminals('IF', 'THEN', 'ELSE')
             add_terminals('FALSE', 'TRUE', 'INTEGER')
 

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -22,7 +22,6 @@ require_relative '../support/expectation_helper'
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  # rubocop: disable Metrics/BlockLength
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe GFGEarleyParser do
       include GrammarABCHelper # Mix-in module with builder for grammar abc
@@ -292,75 +291,75 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ###################### S(0): . 6, 36, 216
           # Expectation chart[0]:
           expected = [
-            '.S | 0',                                   # Initialization
-            'S => . sequence | 0',                      # start rule
-            'S => . | 0',                               # start rule
-            '.sequence | 0',                            # call rule
-            'S. | 0',                                   # exit rule
-            'sequence => . sequence comma integer | 0', # start rule
-            'sequence => . integer | 0',                # start rule
-            '.integer | 0',                             # call rule
-            'integer => . digit_plus | 0',              # start rule
-            '.digit_plus | 0',                          # call rule
-            'digit_plus => . digit_plus digit | 0',     # start rule (generated)
-            'digit_plus => . digit | 0'                 # start rule (generated)
+            '.S | 0',                                       # Initialization
+            'S => . sequence | 0',                          # start rule
+            'S => . | 0',                                   # start rule
+            '.sequence | 0',                                # call rule
+            'S. | 0',                                       # exit rule
+            'sequence => . sequence comma integer | 0',     # start rule
+            'sequence => . integer | 0',                    # start rule
+            '.integer | 0',                                 # call rule
+            'integer => . rep_digit_plus | 0',              # start rule
+            '.rep_digit_plus | 0',                          # call rule
+            'rep_digit_plus => . rep_digit_plus digit | 0', # start rule (generated)
+            'rep_digit_plus => . digit | 0'                 # start rule (generated)
           ]
           compare_entry_texts(parse_result.chart[0], expected)
 
           ###################### S(1): 6 ., 36, 216
           # Expectation chart[1]:
           expected = [
-            'digit_plus => digit . | 0',                # Scan
-            'digit_plus. | 0',                          # exit rule
-            'integer => digit_plus . | 0',              # end rule
-            'digit_plus => digit_plus . digit | 0',     # rule (generated)
-            'integer. | 0',                             # exit rule
-            'sequence => integer . | 0',                # end rule
-            'sequence. | 0',                            # exit rule
-            'S => sequence . | 0',                      # end rule
-            'sequence => sequence . comma integer | 0', #  rule
-            'S. | 0'                                    # exit rule
+            'rep_digit_plus => digit . | 0',                # Scan
+            'rep_digit_plus. | 0',                          # exit rule
+            'integer => rep_digit_plus . | 0',              # end rule
+            'rep_digit_plus => rep_digit_plus . digit | 0', # rule (generated)
+            'integer. | 0',                                 # exit rule
+            'sequence => integer . | 0',                    # end rule
+            'sequence. | 0',                                # exit rule
+            'S => sequence . | 0',                          # end rule
+            'sequence => sequence . comma integer | 0',     #  rule
+            'S. | 0'                                        # exit rule
           ]
           compare_entry_texts(parse_result.chart[1], expected)
 
           ###################### S(2): 6 , . 36, 216
           # Expectation chart[2]:
           expected = [
-            'sequence => sequence comma . integer | 0', #  Scan
-            '.integer | 2',                             # call rule
-            'integer => . digit_plus | 2',              # start rule
-            '.digit_plus | 2',                          # call rule
-            'digit_plus => . digit_plus digit | 2',     # start rule (generated)
-            'digit_plus => . digit | 2'                 # start rule (generated)
+            'sequence => sequence comma . integer | 0',     #  Scan
+            '.integer | 2',                                 # call rule
+            'integer => . rep_digit_plus | 2',              # start rule
+            '.rep_digit_plus | 2',                          # call rule
+            'rep_digit_plus => . rep_digit_plus digit | 2', # start rule (generated)
+            'rep_digit_plus => . digit | 2'                 # start rule (generated)
           ]
           compare_entry_texts(parse_result.chart[2], expected)
 
           ###################### S(3): 6 , 3 . 6. , 216
           # Expectation chart[3]:
           expected = [
-            'digit_plus => digit . | 2',                # Scan
-            'digit_plus. | 2',                          # exit rule
-            'integer => digit_plus . | 2',              # end rule
-            'digit_plus => digit_plus . digit | 2',     # rule (generated)
-            'integer. | 2',                             # exit rule
-            'sequence => sequence comma integer . | 0', # rule
-            'sequence. | 0',                            # exit rule
-            'S => sequence . | 0',                      # end rule
-            'sequence => sequence . comma integer | 0'  #  rule
+            'rep_digit_plus => digit . | 2',                # Scan
+            'rep_digit_plus. | 2',                          # exit rule
+            'integer => rep_digit_plus . | 2',              # end rule
+            'rep_digit_plus => rep_digit_plus . digit | 2', # rule (generated)
+            'integer. | 2',                                 # exit rule
+            'sequence => sequence comma integer . | 0',     # rule
+            'sequence. | 0',                                # exit rule
+            'S => sequence . | 0',                          # end rule
+            'sequence => sequence . comma integer | 0'      #  rule
           ]
           compare_entry_texts(parse_result.chart[3], expected)
 
           ###################### S(4): 6 , 36 . . , 216
           # Expectation chart[4]:
           expected = [
-            'digit_plus => digit_plus digit . | 2',     # Scan
-            'digit_plus. | 2',                          # exit rule
-            'integer => digit_plus . | 2',              # end rule
-            'digit_plus => digit_plus . digit | 2',     #
-            'integer. | 2',                             # exit rule
-            'sequence => sequence comma integer . | 0', # rule
-            'sequence. | 0',                            # exit rule
-            'S => sequence . | 0'                       # end rule
+            'rep_digit_plus => rep_digit_plus digit . | 2', # Scan
+            'rep_digit_plus. | 2',                          # exit rule
+            'integer => rep_digit_plus . | 2',              # end rule
+            'rep_digit_plus => rep_digit_plus . digit | 2', #
+            'integer. | 2',                                 # exit rule
+            'sequence => sequence comma integer . | 0',     # rule
+            'sequence. | 0',                                # exit rule
+            'S => sequence . | 0'                           # end rule
           ]
           compare_entry_texts(parse_result.chart[4], expected)
         end
@@ -372,7 +371,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # A => ;
           t_x = Syntax::Terminal.new('x')
 
-          builder = Notation::GrammarBuilder.new do
+          builder = RGN::GrammarBuilder.new do
             add_terminals(t_x)
             rule 'Ss' => 'A A x'
             rule 'A' => []
@@ -932,7 +931,7 @@ MSG
           # S => ;
           # This grammar requires a time that is quadratic in the number of
           # input tokens
-          builder = Notation::GrammarBuilder.new do
+          builder = RGN::GrammarBuilder.new do
             add_terminals('a')
             rule('S' => 'a S')
             rule('S' => '')
@@ -1021,7 +1020,7 @@ MSG
           # An implicit EOF marker is a special terminal
           # that denotes the end of input string but doesn't
           # appear explicitly as some character or text in the input.
-          builder = Notation::GrammarBuilder.new do
+          builder = RGN::GrammarBuilder.new do
             add_terminals('a', 'b', 'EOF')
 
             rule('S' => 'a_or_b* EOF')
@@ -1038,6 +1037,5 @@ MSG
       end # context
     end # describe
   end # module
-  # rubocop: enable Metrics/BlockLength
 end # module
 # End of file

data/spec/rley/{notation → rgn}/grammar_builder_spec.rb

@@ -3,10 +3,10 @@
 require_relative '../../spec_helper'
 
 # Load the class under test
-require_relative '../../../lib/rley/notation/grammar_builder'
+require_relative '../../../lib/rley/rgn/grammar_builder'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  module Notation # Open this namespace to avoid module qualifier prefixes
+  module RGN # Open this namespace to avoid module qualifier prefixes
     describe GrammarBuilder do
       context 'Initialization without argument:' do
         it 'could be created without argument' do
@@ -123,11 +123,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # implicitly called: rule('arguments_qmark' => 'arguments').tag suffix_qmark_one
           # implicitly called: rule('arguments_qmark' => '').tag suffix_qmark_none
           expect(instance.productions.size).to eq(3)
-          prod_star = instance.productions.select { |prod| prod.lhs.name == 'arguments_qmark' }
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'rep_arguments_qmark' }
           expect(prod_star.size).to eq(2)
           first_prod = instance.productions.first
           expect(first_prod.lhs.name).to eq('argument_list')
-          expect(first_prod.rhs.members[1].name).to eq('arguments_qmark')
+          expect(first_prod.rhs.members[1].name).to eq('rep_arguments_qmark')
+          expect(instance.productions.last.rhs.members).to be_empty
         end
 
         it "should support Kleene's star" do
@@ -137,14 +138,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance.rule 'program' => 'declaration* EOF'
           instance.grammar_complete!
 
-          # implicitly called: rule('declaration_star' => 'declaration_star declaration').tag suffix_star_more
-          # implicitly called: rule('declaration_star' => '').tag suffix_star_last
+          # implicitly called: rule('rep_declaration_star' => 'rep_declaration_star declaration').tag suffix_star_more
+          # implicitly called: rule('rep_declaration_star' => '').tag suffix_star_last
           expect(instance.productions.size).to eq(3)
-          prod_star = instance.productions.select { |prod| prod.lhs.name == 'declaration_star' }
+          prod_star = instance.productions.select { |prod| prod.lhs.name == 'rep_declaration_star' }
           expect(prod_star.size).to eq(2)
           first_prod = instance.productions.first
           expect(first_prod.lhs.name).to eq('program')
-          expect(first_prod.rhs.members[0].name).to eq('declaration_star')
+          expect(first_prod.rhs.members[0].name).to eq('rep_declaration_star')
         end
 
         it "should support symbols decorated with Kleene's plus" do
@@ -163,11 +164,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # implicitly called: rule('digit_plus' => 'digit_plus digit').tag suffix_plus_more
           # implicitly called: rule('digit_plus' => 'digit').tag suffix_plus_last
           expect(instance.productions.size).to eq(7) # Two additional rules generated
-          prod_plus = instance.productions.select { |prod| prod.lhs.name == 'digit_plus' }
+          prod_plus = instance.productions.select { |prod| prod.lhs.name == 'rep_digit_plus' }
           expect(prod_plus.size).to eq(2)
           val_prod = instance.productions[4]
           expect(val_prod.lhs.name).to eq('value')
-          expect(val_prod.rhs.members[0].name).to eq('digit_plus')
+          expect(val_prod.rhs.members[0].name).to eq('rep_digit_plus')
         end
 
         it 'should support optional grouping' do
@@ -180,21 +181,23 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # implicitly called: rule('seq_EQUAL_expression' => 'EQUAL expression').tag 'return_children'
           # implicitly called: rule('seq_EQUAL_expression_qmark' => 'seq_EQUAL_expression').tag suffix_qmark_one
           # implicitly called: rule('seq_EQUAL_expression_qmark' => '').tag suffix_qmark_none
-          expect(instance.productions.size).to eq(4)
+          expect(instance.productions.size).to eq(3)
           first_prod = instance.productions.first
           expect(first_prod.lhs.name).to eq('var_decl')
-          expect(first_prod.rhs.members[2].name).to eq('seq_EQUAL_expression_qmark')
-          (p0, p1, p2) = instance.productions[1..3]
-          expect(p0.lhs.name).to eq('seq_EQUAL_expression')
-          expect(p0.rhs[0].name).to eq('EQUAL')
-          expect(p0.rhs[1].name).to eq('expression')
-          expect(p0.name).to eq('return_children')
-
-          expect(p1.lhs.name).to eq('seq_EQUAL_expression_qmark')
-          expect(p1.rhs[0].name).to eq('seq_EQUAL_expression')
-          expect(p1.name).to eq('_qmark_one')
-
-          expect(p2.lhs.name).to eq('seq_EQUAL_expression_qmark')
+          expect(first_prod.rhs.members[2].name).to eq('rep_seq_EQUAL_expression_qmark')
+          (p1, p2) = instance.productions[1..2]
+          # expect(p0.lhs.name).to eq('rep_seq_EQUAL_expression_qmark')
+          # expect(p0.rhs[0].name).to eq('EQUAL')
+          # expect(p0.rhs[1].name).to eq('expression')
+          # expect(p0.name).to eq('return_children')
+
+          expect(p1.lhs.name).to eq('rep_seq_EQUAL_expression_qmark')
+          expect(p1.rhs[0].name).to eq('EQUAL')
+          expect(p1.rhs[1].name).to eq('expression')
+          # expect(p1.rhs[0].name).to eq('seq_EQUAL_expression')
+          expect(p1.name).to eq('return_children') # TODO _qmark_one
+
+          expect(p2.lhs.name).to eq('rep_seq_EQUAL_expression_qmark')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_qmark_none')
         end
@@ -212,7 +215,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.productions.size).to eq(4)
           first_prod = instance.productions.first
           expect(first_prod.lhs.name).to eq('logic_or')
-          expect(first_prod.rhs.members[1].name).to eq('seq_OR_logic_and_star')
+          expect(first_prod.rhs.members[1].name).to eq('rep_seq_OR_logic_and_star')
 
           (p0, p1, p2) = instance.productions[1..3]
           expect(p0.lhs.name).to eq('seq_OR_logic_and')
@@ -220,12 +223,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p0.rhs[1].name).to eq('logic_and')
           expect(p0.name).to eq('return_children')
 
-          expect(p1.lhs.name).to eq('seq_OR_logic_and_star')
-          expect(p1.rhs[0].name).to eq('seq_OR_logic_and_star')
+          expect(p1.lhs.name).to eq('rep_seq_OR_logic_and_star')
+          expect(p1.rhs[0].name).to eq('rep_seq_OR_logic_and_star')
           expect(p1.rhs[1].name).to eq('seq_OR_logic_and')
           expect(p1.name).to eq('_star_more')
 
-          expect(p2.lhs.name).to eq('seq_OR_logic_and_star')
+          expect(p2.lhs.name).to eq('rep_seq_OR_logic_and_star')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_star_none')
         end
@@ -243,7 +246,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.productions.size).to eq(4)
           first_prod = instance.productions.first
           expect(first_prod.lhs.name).to eq('path')
-          expect(first_prod.rhs.members[1].name).to eq('seq_TO_POINT_plus')
+          expect(first_prod.rhs.members[1].name).to eq('rep_seq_TO_POINT_plus')
 
           (p0, p1, p2) = instance.productions[1..3]
           expect(p0.lhs.name).to eq('seq_TO_POINT')
@@ -251,12 +254,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p0.rhs[1].name).to eq('POINT')
           expect(p0.name).to eq('return_children')
 
-          expect(p1.lhs.name).to eq('seq_TO_POINT_plus')
-          expect(p1.rhs[0].name).to eq('seq_TO_POINT_plus')
+          expect(p1.lhs.name).to eq('rep_seq_TO_POINT_plus')
+          expect(p1.rhs[0].name).to eq('rep_seq_TO_POINT_plus')
           expect(p1.rhs[1].name).to eq('seq_TO_POINT')
           expect(p1.name).to eq('_plus_more')
 
-          expect(p2.lhs.name).to eq('seq_TO_POINT_plus')
+          expect(p2.lhs.name).to eq('rep_seq_TO_POINT_plus')
           expect(p2.rhs[0].name).to eq('seq_TO_POINT')
           expect(p2.name).to eq('_plus_one')
         end
@@ -268,29 +271,30 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance.rule('if_stmt' => st)
           instance.grammar_complete!
 
-          # implicitly called: rule('seq_ELSE_stmt' => 'ELSE stmt').tag 'return_children'
-          # implicitly called: rule('seq_ELSE_stmt_qmark' => 'seq_ELSE_stmt ').tag suffix_plus_more
-          # implicitly called: rule('seq_ELSE_stmt_qmark' => '').tag suffix_plus_one
-          expect(instance.productions.size).to eq(4)
-          first_prod = instance.productions.first
-          expect(first_prod.lhs.name).to eq('if_stmt')
-          expect(first_prod.rhs.members[5].name).to eq('seq_ELSE_stmt_qmark')
-
-          (p0, p1, p2) = instance.productions[1..3]
-          expect(p0.lhs.name).to eq('seq_ELSE_stmt')
-          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[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')
-
-          expect(p1.lhs.name).to eq('seq_ELSE_stmt_qmark')
-          expect(p1.rhs[0].name).to eq('seq_ELSE_stmt')
-          expect(p1.name).to eq('_qmark_one')
-
-          expect(p2.lhs.name).to eq('seq_ELSE_stmt_qmark')
+          # implicitly called: rule('rep_seq_ELSE_stmt_qmark' => 'ELSE stmt').tag return_children'
+          # implicitly called: rule('rep_seq_ELSE_stmt_qmark' => '').tag suffix_qmark_none
+          expect(instance.productions.size).to eq(3)
+          (p0, p1, p2) = instance.productions[0..2]
+          expect(p0.lhs.name).to eq('if_stmt')
+          expect(p0.rhs.members[5].name).to eq('rep_seq_ELSE_stmt_qmark')
+          # expect(p0.lhs.name).to eq('seq_ELSE_stmt')
+          # 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[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')
+
+          expect(p1.lhs.name).to eq('rep_seq_ELSE_stmt_qmark')
+          expect(p1.rhs[0].name).to eq('ELSE')
+          expect(p1.rhs[1].name).to eq('stmt')
+          expect(p1.name).to eq('return_children')
+          expect(p1.constraints.size).to eq(1)
+          expect(p1.constraints[0]).to be_kind_of(Syntax::MatchClosest)
+          expect(p1.constraints[0].closest_symb).to eq('IF')
+
+          expect(p2.lhs.name).to eq('rep_seq_ELSE_stmt_qmark')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_qmark_none')
         end

data/spec/rley/{notation → rgn}/parser_spec.rb

@@ -2,12 +2,12 @@
 
 require_relative '../../spec_helper' # Use the RSpec framework
 
-require_relative '../../../lib/rley/notation/ast_builder'
+require_relative '../../../lib/rley/rgn/ast_builder'
 # Load the class under test
-require_relative '../../../lib/rley/notation/parser'
+require_relative '../../../lib/rley/rgn/parser'
 
 module Rley
-  module Notation
+  module RGN
     describe Parser do
       subject { Parser.new }
 
@@ -44,7 +44,7 @@ module Rley
         it 'should parse single symbol names' do
           samples = %w[IF ifCondition statement]
 
-          # One drawback od CSTs: they have a deeply nested structure
+          # One drawback of 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)
@@ -82,7 +82,7 @@ module Rley
             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)
+            expect(ptree.root.annotation).to be_empty
           end
         end
 
@@ -103,8 +103,10 @@ module Rley
           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).to be_kind_of(RepetitionNode)
+          expect(ptree.root.name).to eq('rep_member_seq_qmark')
+          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child.name).to eq('member_seq')
           expect(ptree.root.repetition).to eq(:zero_or_one)
         end
 
@@ -112,8 +114,10 @@ module Rley
           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).to be_kind_of(RepetitionNode)
+          expect(ptree.root.name).to eq('rep_member_plus')
+          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child.name).to eq('member')
           expect(ptree.root.repetition).to eq(:one_or_more)
         end
 
@@ -122,12 +126,14 @@ module Rley
 
           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.name).to eq('seq_rep_declaration_star_EOF')
+          expect(ptree.root.subnodes[0]).to be_kind_of(RepetitionNode)
+          expect(ptree.root.subnodes[0].name).to eq('rep_declaration_star')
           expect(ptree.root.subnodes[0].repetition).to eq(:zero_or_more)
+          expect(ptree.root.subnodes[0].child).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[0].child.name).to eq('declaration')
           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
@@ -141,21 +147,25 @@ module Rley
           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]).to be_kind_of(RepetitionNode)
+          expect(ptree.root.subnodes[3].name).to eq('rep_seq_ELSE_statement_qmark')
           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')
+          expect(ptree.root.subnodes[3].child).to be_kind_of(SequenceNode)
+          expect(ptree.root.subnodes[3].child.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].child.subnodes[0].name).to eq('ELSE')
+          expect(ptree.root.subnodes[3].child.subnodes[1]).to be_kind_of(SymbolNode)
+          expect(ptree.root.subnodes[3].child.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).to be_kind_of(RepetitionNode)
+          expect(ptree.root.name).to eq('rep_member_seq_qmark')
           expect(ptree.root.repetition).to eq(:zero_or_one)
+          expect(ptree.root.child).to be_kind_of(SymbolNode)
+          expect(ptree.root.child.name).to eq('member_seq')
         end
 
         it 'should parse a grouping with embedded annotation' do
@@ -170,12 +180,14 @@ module Rley
           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).to be_kind_of(RepetitionNode)
+          expect(optional.name).to eq('rep_seq_ELSE_statement_qmark')
           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')
+          expect(optional.child).to be_kind_of(SequenceNode)
+          expect(optional.child.subnodes[0]).to be_kind_of(SymbolNode)
+          expect(optional.child.subnodes[0].name).to eq('ELSE')
+          expect(optional.child.subnodes[0].annotation).to eq({ 'match_closest' => 'IF' })
+          expect(optional.child.subnodes[1].name).to eq('statement')
         end
       end # context
     end # describe

data/spec/rley/rgn/repetition_node_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/lexical/token'
+require_relative '../../../lib/rley/rgn/symbol_node'
+
+# Load the class under test
+require_relative '../../../lib/rley/rgn/repetition_node'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module RGN # Open this namespace to avoid module qualifier prefixes
+    describe RepetitionNode do
+      let(:a_name) { 'arguments' }
+      let(:a_pos) { Lexical::Position.new(3, 4) }
+      let(:a_child) { SymbolNode.new(a_pos, a_name) }
+      let(:star) { :zero_or_more }
+
+      # Default instantiation rule
+      subject { RepetitionNode.new(a_child, star) }
+
+      context 'Initialization:' do
+        it 'should be created with a child node and a symbol' do
+          expect { RepetitionNode.new(a_child, star) }.not_to raise_error
+        end
+
+        it 'should know its child' do
+          expect(subject.subnodes.size).to eq(1)
+          expect(subject.subnodes.first).to eq(a_child)
+          expect(subject.child).to eq(a_child)
+        end
+
+        it 'should know its repetition' do
+          expect(subject.repetition).to eq(star)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know its name' do
+          # Case repetition == :zero_or_one
+          instance = RepetitionNode.new(a_child, :zero_or_one)
+          expect(instance.name).to eq('rep_arguments_qmark')
+
+          # Case repetition == :zero_or_more
+          expect(subject.name).to eq('rep_arguments_star')
+
+          # Case repetition == :one_or_more
+          instance = RepetitionNode.new(a_child, :one_or_more)
+          expect(instance.name).to eq('rep_arguments_plus')
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file