rley 0.8.06 → 0.8.08

data/lib/rley/{notation → rgn}/grammar_builder.rb

@@ -7,8 +7,9 @@ require_relative 'ast_visitor'
 require_relative '../syntax/match_closest'
 
 module Rley # This module is used as a namespace
-  module Notation # This module is used as a namespace
-    # Structure used for production rules that are implicitly generated by Rley
+  # Namespace for classes that define RGN (Rley Grammar Notation)
+  module RGN # This module is used as a namespace
+    # Structure used by Rley to generate implicdit production rules.
     RawRule = Struct.new(:lhs, :rhs, :tag, :simple, :constraints)
 
     # Builder GoF pattern. Builder builds a complex object
@@ -19,7 +20,7 @@ module Rley # This module is used as a namespace
       #   to the matching grammar symbol object.
       attr_reader(:symbols)
 
-      # @return [Notation::Parser] Parser for the right-side of productions
+      # @return [RGN::Parser] Parser for the right-side of productions
       attr_reader(:parser)
 
       # @return [Hash{ASTVisitor, Array}]
@@ -32,21 +33,12 @@ module Rley # This module is used as a namespace
       # @return [Hash{String, String}] The synthesized raw productions
       attr_reader(:synthetized)
 
-      # Creates a new grammar builder.
+      # Creates a new RGN grammar builder.
       # @param aBlock [Proc] code block used to build the grammar.
-      # @example Building a tiny English grammar
-      #   builder = Rley::Notation::GrammarBuilder.new do
-      #     add_terminals('n', 'v', 'adj', 'det')
-      #     rule 'S' => 'NP VP'
-      #     rule 'VP' => 'v NP'
-      #     rule 'NP' => 'det n'
-      #     rule 'NP' => 'adj NP'
-      #   end
-      #   tiny_eng = builder.grammar
       def initialize(&aBlock)
         @symbols = {}
         @productions = []
-        @parser = Notation::Parser.new
+        @parser = RGN::Parser.new
         @visitor2rhs = {}
         @synthetized = {}
 
@@ -73,7 +65,7 @@ module Rley # This module is used as a namespace
       end
 
       # Add the given marker symbol to the grammar of the language
-      # @param aMarkerSymbol [String] A mazker symbol
+      # @param aMarkerSymbol [String] A marker symbol
       # @return [void]
       def add_marker(aMarkerSymbol)
         new_symb = build_symbol(Syntax::Marker, aMarkerSymbol)
@@ -227,105 +219,64 @@ module Rley # This module is used as a namespace
       # ################################
       def after_symbol_node(aSymbolNode, aVisitor)
         symb_name = aSymbolNode.name
-
-        case aSymbolNode.repetition
-        when :zero_or_one
-          # implicitly called: rule('symb_name_qmark' => 'symb_name_qmark').tag suffix_qmark_one
-          # implicitly called: rule('symb_name_qmark' => '').tag suffix_qmark_none
-          name_modified = "#{symb_name}#{suffix_qmark}"
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, symb_name, suffix_qmark_one)
-            add_raw_rule(name_modified, '', suffix_qmark_none)
-          end
-          symb_name = name_modified
-
-        when :zero_or_more
-          # implicitly called: rule('symb_name_star' => 'symb_name_star symb_name').tag suffix_star_more
-          # implicitly called: rule('symb_name_star' => '').tag suffix_star_none
-          name_modified = "#{symb_name}#{suffix_star}"
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_star_more)
-            add_raw_rule(name_modified, [], suffix_star_none)
-          end
-          symb_name = name_modified
-
-        when :exactly_one
-          # Do nothing
-
-        when :one_or_more
-          name_modified = "#{symb_name}#{suffix_plus}"
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_plus_more)
-            add_raw_rule(name_modified, symb_name, suffix_plus_one)
-          end
-          symb_name = name_modified
-        else
-          raise StandardError, 'Unhandled multiplicity'
-        end
-
         symb = get_grm_symbol(symb_name)
         visitor2rhs[aVisitor] << symb
       end
 
       def after_sequence_node(aSequenceNode, _visitor)
-        aSequenceNode.subnodes.each_with_index do |sn, i|
-          next if sn.annotation.empty?
-
-          matching = sn.annotation['match_closest']
-          aSequenceNode.constraints << Syntax::MatchClosest.new(aSequenceNode, i, matching)
-        end
+        add_constraints(aSequenceNode)
       end
 
-      def after_grouping_node(aGroupingNode, aVisitor)
-        after_sequence_node(aGroupingNode, aVisitor)
-        symb_name = sequence_name(aGroupingNode)
+      def after_repetition_node(aRepNode, aVisitor)
+        add_constraints(aRepNode)
+        return if aRepNode.repetition == :exactly_one
 
-        unless symbols.include?(symb_name) || aGroupingNode.repetition == :exactly_one
-          add_nonterminal(symb_name)
-          rhs = serialize_sequence(aGroupingNode)
-          add_raw_rule(symb_name, rhs, 'return_children', true, aGroupingNode.constraints)
+        node_name = aRepNode.name
+        child_name = aRepNode.subnodes[0].name
+
+        if aRepNode.child.is_a?(SequenceNode) &&
+           !symbols.include?(child_name) && aRepNode.repetition != :zero_or_one
+          add_nonterminal(child_name)
+          rhs = aRepNode.child.to_text
+          add_raw_rule(child_name, rhs, 'return_children', true)
         end
-        name_modified = "#{symb_name}#{repetition2suffix(aGroupingNode.repetition)}"
 
-        case aGroupingNode.repetition
+        case aRepNode.repetition
         when :zero_or_one
-          # implicitly called: rule('symb_name_qmark' => 'symb_name_qmark').tag suffix_qmark_one
-          # implicitly called: rule('symb_name_qmark' => '').tag suffix_qmark_none
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, symb_name, suffix_qmark_one, true)
-            add_raw_rule(name_modified, [], suffix_qmark_none, true)
+          # implicitly called: rule('node_name_qmark' => 'node_name_qmark').tag suffix_qmark_one
+          # implicitly called: rule('node_name_qmark' => '').tag suffix_qmark_none
+          unless symbols.include? node_name
+            add_nonterminal(node_name)
+            if aRepNode.child.is_a?(SequenceNode) && !aRepNode.child.constraints.empty?
+              aRepNode.constraints.merge(aRepNode.child.constraints)
+            end
+            rhs = aRepNode.child.to_text
+            add_raw_rule(node_name, rhs, 'return_children', false, aRepNode.constraints)
+            add_raw_rule(node_name, [], suffix_qmark_none, true)
           end
 
         when :zero_or_more
-          # implicitly called: rule('symb_name_star' => 'symb_name_star symb_name').tag suffix_star_more
-          # implicitly called: rule('symb_name_star' => '').tag suffix_star_none
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_star_more)
-            add_raw_rule(name_modified, '', suffix_star_none)
+          # implicitly called: rule('node_name_star' => 'node_name_star node_name').tag suffix_star_more
+          # implicitly called: rule('node_name_star' => '').tag suffix_star_none
+          unless symbols.include? node_name
+            add_nonterminal(node_name)
+            rhs = "#{node_name} #{child_name}"
+            add_raw_rule(node_name, rhs, suffix_star_more)
+            add_raw_rule(node_name, '', suffix_star_none)
           end
 
-        when :exactly_one
-          # Do nothing
-
         when :one_or_more
-          unless symbols.include? name_modified
-            add_nonterminal(name_modified)
-            add_raw_rule(name_modified, "#{name_modified} #{symb_name}", suffix_plus_more)
-            add_raw_rule(name_modified, symb_name, suffix_plus_one)
+          unless symbols.include? node_name
+            add_nonterminal(node_name)
+            add_raw_rule(node_name, "#{node_name} #{child_name}", suffix_plus_more)
+            add_raw_rule(node_name, child_name, suffix_plus_one)
           end
         else
           raise StandardError, 'Unhandled multiplicity'
         end
 
-        unless aGroupingNode.repetition == :exactly_one
-          symb = get_grm_symbol(name_modified)
-          visitor2rhs[aVisitor] << symb
-        end
+        symb = get_grm_symbol(node_name)
+        visitor2rhs[aVisitor] << symb
       end
 
       # A notification to the builderobject that the programmer
@@ -425,22 +376,33 @@ module Rley # This module is used as a namespace
         symbols[name]
       end
 
-      def sequence_name(aSequenceNode)
-        subnode_names = +''
-        aSequenceNode.subnodes.each do |subn|
-          case subn
-          when SymbolNode
-            subnode_names << "_#{subn.name}"
-          when SequenceNode
-            subnode_names << "_#{sequence_name(subn)}"
-          end
-          suffix = repetition2suffix(subn.repetition)
-          subnode_names << suffix
-        end
+      def add_constraints(aCompositeNode)
+        aCompositeNode.subnodes.each_with_index do |sn, i|
+          next if sn.annotation.empty?
 
-        "seq#{subnode_names}"
+          matching = sn.annotation['match_closest']
+          constraint = Syntax::MatchClosest.new(aCompositeNode, i, matching)
+          aCompositeNode.constraints << constraint
+        end
       end
 
+      # def sequence_name(aSequenceNode)
+      #   subnode_names = +''
+      #   aSequenceNode.subnodes.each do |subn|
+      #     case subn
+      #     when SymbolNode
+      #       subnode_names << "_#{subn.name}"
+      #     when SequenceNode
+      #       subnode_names << "_#{sequence_name(subn)}"
+      #     when RepetitionNode
+      #       suffix = repetition2suffix(subn.repetition)
+      #       subnode_names << suffix
+      #     end
+      #   end
+      #
+      #   "seq#{subnode_names}"
+      # end
+
       def node_base_name(aNode)
         if aNode.kind_of?(SymbolNode)
           aNode.name
@@ -456,23 +418,23 @@ module Rley # This module is used as a namespace
         "#{base_name}#{suffix}"
       end
 
-      def serialize_sequence(aSequenceNode)
-        text = +''
-        aSequenceNode.subnodes.each do |sn|
-          text << ' '
-          case sn
-          when SymbolNode
-            text << sn.name
-          when SequenceNode
-            text << sequence_name(sn)
-          end
-
-          suffix = repetition2suffix(sn.repetition)
-          text << suffix
-        end
-
-        text.strip
-      end
+      # def serialize_sequence(aSequenceNode)
+      #   text = +''
+      #   aSequenceNode.subnodes.each do |sn|
+      #     text << ' '
+      #     case sn
+      #     when SymbolNode
+      #       text << sn.name
+      #     when SequenceNode
+      #       text << sequence_name(sn)
+      #     when RepetitionNode
+      #       suffix = repetition2suffix(sn.repetition)
+      #       text << suffix
+      #     end
+      #   end
+      #
+      #   text.strip
+      # end
 
       def add_raw_rule(aSymbol, aRHS, aTag, simplified = false, constraints = [])
         raw_rule = RawRule.new(aSymbol, aRHS, aTag, simplified, constraints)
@@ -484,7 +446,7 @@ module Rley # This module is used as a namespace
       end
 
       def process_raw_rules
-        until synthetized.empty? do
+        until synthetized.empty?
           raw_rules = synthetized.delete(synthetized.keys.first)
           raw_rules.each do |raw|
             new_prod = nil
@@ -494,7 +456,7 @@ module Rley # This module is used as a namespace
               new_prod = rule(raw.lhs => raw.rhs)
             end
             new_prod.tag(raw.tag)
-            new_prod.constraints = raw.constraints
+            new_prod.constraints.concat(raw.constraints)
           end
         end
       end

data/lib/rley/{notation → rgn}/parser.rb

@@ -5,8 +5,8 @@ require_relative 'grammar'
 require_relative 'ast_builder'
 
 module Rley
-  module Notation
-    # A Lox parser that produce concrete parse trees.
+  module RGN
+    # A RRN (Rley Rule Notation) parser that produce concrete parse trees.
     # Concrete parse trees are the default kind of parse tree
     # generated by the Rley library.
     # They consist of two node types only:
@@ -28,11 +28,11 @@ module Rley
         # Create a Rley facade object
         @engine = Rley::Engine.new do |cfg|
           cfg.diagnose = true
-          cfg.repr_builder = Notation::ASTBuilder
+          cfg.repr_builder = RGN::ASTBuilder
         end
 
         # Step 1. Load RGN grammar
-        @engine.use_grammar(Rley::Notation::RGNGrammar)
+        @engine.use_grammar(Rley::RGN::RGNGrammar)
       end
 
       # Parse the given Lox program into a parse tree.

data/lib/rley/rgn/repetition_node.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'composite_node'
+
+module Rley
+  module RGN
+    # A RGN syntax node representing an expression quantified by a ?, * or +.
+    class RepetitionNode < CompositeNode
+      # @return [Symbol] one of: :zero_or_one, :zero_or_more, :one_or_more
+      attr_accessor :repetition
+
+      Repetition2suffix = {
+        zero_or_one: '_qmark',
+        zero_or_more: '_star',
+        exactly_one: '',
+        one_or_more: '_plus'
+      }.freeze
+
+      # @param child [Array<ASTNode>] sequence of AST nodes
+      # @param theRepetition [Symbol] how many times the child node can be repeated
+      def initialize(child, theRepetition)
+        super([child])
+        @repetition = theRepetition
+      end
+
+      # @return [RGN::ASTNode]
+      def child
+        subnodes[0]
+      end
+
+      # @return [String]
+      def name
+        child_name = subnodes[0].name
+        "rep_#{child_name}#{Repetition2suffix[repetition]}"
+      end
+
+      # @return [String]
+      def to_text
+        child_text = subnodes[0].to_text
+        "rep_#{child_text}#{Repetition2suffix[repetition]}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [RGN::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_repetition_node(self)
+      end
+
+      def suffix_qmark
+        Repetition2suffix[:zero_or_one]
+      end
+
+      def suffix_star
+        Repetition2suffix[:zero_or_more]
+      end
+
+      def suffix_plus
+        Repetition2suffix[:one_or_more]
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/rgn/sequence_node.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'composite_node'
+
+module Rley
+  module RGN
+    # A syntax node for a sequence of AST nodes
+    class SequenceNode < CompositeNode
+      def name
+        result = +''
+        subnodes.each do |sn|
+          result << "_#{sn.name}"
+        end
+
+        "seq#{result}"
+      end
+
+      def to_text
+        arr = subnodes.map(&:to_text)
+        arr.join(' ')
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [RGN::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_sequence_node(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/rley/{notation → rgn}/symbol_node.rb

@@ -3,24 +3,32 @@
 require_relative 'ast_node'
 
 module Rley
-  module Notation
-    # A syntax node for a grammar symbol occurring in rhs of a rule
+  module RGN
+    # A syntax node for a grammar symbol occurring in rhs of a rule.
+    # symbol nodes are leaf nodes of RRN parse trees.
     class SymbolNode < ASTNode
+      # @return [Rley::Lexical::Position] Position of the entry in the input stream.
+      attr_reader :position
+
       # @return [String] name of grammar symbol
       attr_reader :name
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param aName [String] name of grammar symbol
-      # @param theRepetition [Symbol] indicates how many times the symbol can be repeated
-      def initialize(aPosition, aName, theRepetition = nil)
-        super(aPosition)
+      def initialize(aPosition, aName)
+        super()
+        @position = aPosition
         @name = aName
-        self.repetition = theRepetition if theRepetition
+      end
+
+      # @return [String] name of grammar symbol
+      def to_text
+        annotation.empty? ? name : "#{name} #{annotation_to_text}"
       end
 
       # Abstract method (must be overriden in subclasses).
       # Part of the 'visitee' role in Visitor design pattern.
-      # @param _visitor [LoxxyTreeVisitor] the visitor
+      # @param visitor [LoxxyTreeVisitor] the visitor
       def accept(visitor)
         visitor.visit_symbol_node(self)
       end

data/lib/rley/{notation → rgn}/tokenizer.rb

@@ -4,7 +4,7 @@ require 'strscan'
 require_relative '../lexical/token'
 
 module Rley
-  module Notation
+  module RGN
     # A tokenizer for the Rley notation language.
     # Responsibility: break input into a sequence of token objects.
     # The tokenizer should recognize:

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

@@ -292,75 +292,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 +372,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 +932,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 +1021,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')