rley 0.8.00 → 0.8.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee99e1b9803a447d18a3f82e91353659e211109a5fb99d48a834ddebf572998f
-  data.tar.gz: f4719d9fa301a0de2be143ca0aa5d0c261cf1562194a40b038c79b1faa1c04dc
+  metadata.gz: 5652efd2016050e7a40a94c279fa545a03b69b705bdcc5089a479d72c4743325
+  data.tar.gz: c3f46ba853632a95e3c1fbe16f0f77f8e8a07ed3acd69a82297ca13eec9b6ccc
 SHA512:
-  metadata.gz: 9810a2d3884f86d2d437e1ba0911681f53895ff60ef500e4d19bd5d9429ff433f46c1dd57d6e185eb0bce3fcf869b1e4884acd09aaff72aee0323d00a781e763
-  data.tar.gz: e7d49393824bbbeaff70bc7d57137d1fe82f86a98bfda52fc9144dbafa3e5568e51ce7e9da8c15fc2f51438b29100801e8ea145f613165ba4369093f07bfad23
+  metadata.gz: 532ca6d76a277e6fd234d66ec74e9ade425a91f8ace039e0dc0636547663ac52f64613001e9c36497d5a0e0d9fe67f09eb2fff80b77d8c2f4950095e58ac3b2e
+  data.tar.gz: b288a0345c1696b8987b362ab99dafa4354f94ece73c5c80c87d7a28aa3c3d9ccaf0f516f29cead1707727582e917812435e4254e372aa2d62c110af7aa99a99

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+### 0.8.01 / 2021-08-22
+- Unused/redundant file removal. Fix in rule generation
+
+* [CHANGE] Removal of files in repository that were redundant/useless.
+* [FIX] The rule ordering was broken by the rules implicitly generated by Rlry
+
 ### 0.8.00 / 2021-08-15
 - New grammar builder that accepts ? * + modifiers
 
@@ -15,10 +21,10 @@
 - [FIX] Method `GFGParsing#nullable_rule`: issue with nullable productions having at least one member in their rhs.
 
 ### 0.7.04 / 2019-08-17
-- Rley recognizer is about 25% faster than previous version. Kudos to the people 
-behind the *magic_frozen_string_literal* gem. 
+- Rley recognizer is about 25% faster than previous version. Kudos to the people
+behind the *magic_frozen_string_literal* gem.
 - Code refactoring to use string frozen magic comments (as a consequence, Rley runs only on Rubies 2.3 or newer).  
-- Code restyling to please rubocop 0.7.40. 
+- Code restyling to please rubocop 0.7.40.
 - [CHANGE] Class `ParseEntrySet`: minor code optimization
 - [CHANGE] File `README.md` removed allusion to Ruby 2.0.x up to 2.2.x.
 - [CHANGE] File `README.md` added Ruby 2.6.x up as supported version.
@@ -103,7 +109,7 @@ behind the *magic_frozen_string_literal* gem.
 * [FIX] Code re-styling to remove most style offenses found by Rubocop 0.52.1
 
 ### 0.6.00 / 2018-02-25
-Version bump. Highlights: new programming interface through facade object, improved AST generation. 
+Version bump. Highlights: new programming interface through facade object, improved AST generation.
 * [NEW] Class `Rley::Engine`: Implementation of Facade design pattern to reach more convenient interface.
 * [NEW] Class `Rley::ParseRep::ASTBaseBuilder` Abstract class that simplifies the creation of custom AST (Abstract Syntax Tree)
 * [NEW] Module `Rley::ParseRep` hosts the classes for building parse representations (parse trees and forests)

data/lib/rley/constants.rb

@@ -5,7 +5,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.8.00'
+  Version = '0.8.01'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/notation/grammar_builder.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require 'set'
+
 require_relative 'parser'
 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
+    RawRule = Struct.new(:lhs, :rhs, :tag, :simple, :constraints)
+  
     # Builder GoF pattern. Builder builds a complex object
     #   (say, a grammar) from simpler objects (terminals and productions)
     #   and using a step by step approach.
@@ -24,16 +28,19 @@ module Rley # This module is used as a namespace
       # @return [Array<Production>] The list of production rules for
       #   the grammar to build.
       attr_reader(:productions)
+      
+      # @return [Hash{String, String}] The synthesized raw productions
+      attr_reader(:synthetized)
 
       # Creates a new grammar builder.
       # @param aBlock [Proc] code block used to build the grammar.
       # @example Building a tiny English grammar
-      #   builder = Rley::Syntax::GrammarBuilder.new do
+      #   builder = Rley::Notation::GrammarBuilder.new do
       #     add_terminals('n', 'v', 'adj', 'det')
-      #     rule 'S' => %w[NP VP]
-      #     rule 'VP' => %w[v NP]
-      #     rule 'NP' => %w[det n]
-      #     rule 'NP' => %w[adj NP]
+      #     rule 'S' => 'NP VP'
+      #     rule 'VP' => 'v NP'
+      #     rule 'NP' => 'det n'
+      #     rule 'NP' => 'adj NP'
       #   end
       #   tiny_eng = builder.grammar
       def initialize(&aBlock)
@@ -41,8 +48,12 @@ module Rley # This module is used as a namespace
         @productions = []
         @parser = Notation::Parser.new
         @visitor2rhs = {}
+        @synthetized = {}
 
-        instance_exec(&aBlock) if block_given?
+        if block_given?
+          instance_exec(&aBlock)
+          grammar_complete!
+        end
       end
 
       # Retrieve a grammar symbol from its name.
@@ -60,6 +71,14 @@ module Rley # This module is used as a namespace
         new_symbs = build_symbols(Syntax::Terminal, terminalSymbols)
         symbols.merge!(new_symbs)
       end
+      
+      # Add the given marker symbol to the grammar of the language
+      # @param aMarkerSymbol [String] A mazker symbol
+      # @return [void]      
+      def add_marker(aMarkerSymbol)
+        new_symb = build_symbol(Syntax::Marker, aMarkerSymbol)
+        symbols[new_symb.name] = new_symb
+      end       
 
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => String.
@@ -204,7 +223,7 @@ module Rley # This module is used as a namespace
       end
 
       ##################################
-      # AST visit notification events
+      # RGN's AST visit notification events
       # ################################
       def after_symbol_node(aSymbolNode, aVisitor)
         symb_name = aSymbolNode.name
@@ -215,9 +234,9 @@ module Rley # This module is used as a namespace
           # implicitly called: rule('symb_name_qmark' => '').tag suffix_qmark_none
           name_modified = "#{symb_name}#{suffix_qmark}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{symb_name}" ).tag suffix_qmark_one
-            rule(name_modified => '').tag suffix_qmark_none
+            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
 
@@ -226,9 +245,9 @@ module Rley # This module is used as a namespace
           # implicitly called: rule('symb_name_star' => '').tag suffix_star_none
           name_modified = "#{symb_name}#{suffix_star}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_star_more
-            rule(name_modified => '').tag suffix_star_none
+            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
 
@@ -238,9 +257,9 @@ module Rley # This module is used as a namespace
         when  :one_or_more
           name_modified = "#{symb_name}#{suffix_plus}"
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_plus_more
-            rule(name_modified => symb_name).tag suffix_plus_one
+            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
@@ -264,10 +283,9 @@ module Rley # This module is used as a namespace
         symb_name = sequence_name(aGroupingNode)
 
         unless symbols.include?(symb_name) || aGroupingNode.repetition == :exactly_one
-          symbols[symb_name] = Syntax::NonTerminal.new(symb_name)
-          simple_rule(symb_name => serialize_sequence(aGroupingNode) ).tag 'return_children'
-          prod = productions.last
-          prod.constraints = aGroupingNode.constraints
+          add_nonterminal(symb_name)
+          rhs = serialize_sequence(aGroupingNode)
+          add_raw_rule(symb_name, rhs, 'return_children', true, aGroupingNode.constraints)
         end
         name_modified = "#{symb_name}#{repetition2suffix(aGroupingNode.repetition)}"
 
@@ -276,18 +294,18 @@ module Rley # This module is used as a namespace
           # 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
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            simple_rule(name_modified => symb_name).tag suffix_qmark_one
-            simple_rule(name_modified => []).tag suffix_qmark_none
+            add_nonterminal(name_modified)
+            add_raw_rule(name_modified, symb_name, suffix_qmark_one, true)
+            add_raw_rule(name_modified, [], 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
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_star_more
-            rule(name_modified => '').tag suffix_star_none
+            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
 
         when :exactly_one
@@ -295,9 +313,9 @@ module Rley # This module is used as a namespace
 
         when :one_or_more
           unless symbols.include? name_modified
-            symbols[name_modified] = Syntax::NonTerminal.new(name_modified)
-            rule(name_modified => "#{name_modified} #{symb_name}").tag suffix_plus_more
-            rule(name_modified => symb_name).tag suffix_plus_one
+            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
         else
           raise StandardError, 'Unhandled multiplicity'
@@ -309,7 +327,17 @@ module Rley # This module is used as a namespace
         end
       end
 
+      # A notification to the builderobject that the programmer
+      # has completed the entry of terminals and production rules
+      def grammar_complete!
+        process_raw_rules()
+      end
+
       private
+      
+      def add_nonterminal(aName) 
+        symbols[aName] = Syntax::NonTerminal.new(aName)
+      end  
 
       def simple_rule(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
@@ -444,6 +472,31 @@ module Rley # This module is used as a namespace
 
         text.strip
       end
+      
+      def add_raw_rule(aSymbol, aRHS, aTag, simplified = false, constraints = [])
+        raw_rule = RawRule.new(aSymbol, aRHS, aTag, simplified, constraints)
+        if synthetized.include?(aSymbol)
+          @synthetized[aSymbol] << raw_rule
+        else
+          @synthetized[aSymbol] = [raw_rule]
+        end
+      end
+
+      def process_raw_rules
+        until synthetized.empty? do
+          raw_rules = synthetized.delete(synthetized.keys.first)
+          raw_rules.each do |raw|
+            new_prod = nil
+            if raw.simple
+              new_prod = simple_rule(raw.lhs => raw.rhs)
+            else
+              new_prod = rule(raw.lhs => raw.rhs)
+            end
+            new_prod.tag(raw.tag)
+            new_prod.constraints = raw.constraints
+          end
+        end
+      end
     end # class
   end # module
 end # module

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -126,16 +126,42 @@ module Rley # This module is used as a namespace
 
       # Standard method for handling one or more modifier: symbol+
       # rule('symbol_plus' => 'symbol_plus symbol')
-      def reduce_base_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
+      # def reduce_base_plus_more(_production, _range, _tokens, theChildren)
+        # theChildren[0] << theChildren[1]
+      # end
 
       # Standard rule method handling one or more modifier: symbol+
       # rule('symbol_plus' => 'symbol')
-      def reduce_base_plus_last(_production, _range, _tokens, theChildren)
-        [theChildren[0]]
+      # def reduce_base_plus_last(_production, _range, _tokens, theChildren)
+        # [theChildren[0]]
+      # end
+      
+      # Implicit rule generated for * modifier
+      # rule('X') => 'X item'.as '_star_more'
+      def reduce__star_more(_production, _range, _tokens, theChildren)
+        theChildren[0]  << theChildren[1]
+        theChildren[0]
+      end
+
+      # Implicit rule generated for * modifier
+      # rule('X') => ''.as '_star_none'
+      def reduce__star_none(_production, _range, _tokens, theChildren)
+        []
       end
 
+      # Implicit rule generated for + modifier
+      # rule('X') => 'X item'.as '_plus_more'
+      def reduce__plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0]  << theChildren[1]
+        theChildren[0]
+      end
+
+      # Implicit rule generated for + modifier
+      # rule('X') => 'item'.as '_plus_one'
+      def reduce__plus_one(_production, _range, _tokens, theChildren)
+        [theChildren[0]]
+      end      
+
     end # class
   end # module
 end # module

data/lib/rley/syntax/base_grammar_builder.rb

@@ -55,6 +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]      
+      def add_marker(aMarkerSymbol)
+        new_symb = build_symbol(Marker, aMarkerSymbol)
+        symbols[aMarkerSymbol.name] = new_symb
+      end      
 
       # Add a production rule in the grammar given one
       # key-value pair of the form: String => Array.

data/spec/rley/notation/grammar_builder_spec.rb

@@ -113,70 +113,78 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(new_prod.constraints[0].closest_symb).to eq('IF')
         end
 
-        it "should support optional symbol" do
+        it 'should support optional symbol' do
           instance = GrammarBuilder.new
           instance.add_terminals('LPAREN', 'RPAREN')
 
-          instance.add_production('argument_list' => 'LPAREN arguments? RPAREN')
+          instance.rule 'argument_list' => 'LPAREN arguments? RPAREN'
+          instance.grammar_complete!
 
           # 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' }
           expect(prod_star.size).to eq(2)
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('argument_list')
-          expect(last_prod.rhs.members[1].name).to eq('arguments_qmark')
+          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')
         end
 
         it "should support Kleene's star" do
           instance = GrammarBuilder.new
           instance.add_terminals('EOF')
 
-          instance.add_production('program' => 'declaration* EOF')
+          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
           expect(instance.productions.size).to eq(3)
           prod_star = instance.productions.select { |prod| prod.lhs.name == 'declaration_star' }
           expect(prod_star.size).to eq(2)
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('program')
-          expect(last_prod.rhs.members[0].name).to eq('declaration_star')
+          first_prod = instance.productions.first
+          expect(first_prod.lhs.name).to eq('program')
+          expect(first_prod.rhs.members[0].name).to eq('declaration_star')
         end
 
         it "should support symbols decorated with Kleene's plus" do
           instance = GrammarBuilder.new
           instance.add_terminals('plus', 'minus', 'digit')
 
-          instance.add_production('integer' => 'value')
-          instance.add_production('integer' => 'sign value')
-          instance.add_production('sign' => 'plus')
-          instance.add_production('sign' => 'minus')
-          expect(instance.productions.size).to eq(4)
-          instance.add_production('value' => 'digit+')
+          instance.rule 'integer' => 'value'
+          instance.rule 'integer' => 'sign value'
+          instance.rule 'sign' => 'plus'
+          instance.rule 'sign' => 'minus'
+          instance.rule 'value' => 'digit+'
+          expect(instance.productions.size).to eq(5)
+          instance.grammar_complete!
+          expect(instance.productions.size).to eq(7)
 
           # 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' }
           expect(prod_plus.size).to eq(2)
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('value')
-          expect(last_prod.rhs.members[0].name).to eq('digit_plus')
+          val_prod = instance.productions[4]
+          expect(val_prod.lhs.name).to eq('value')
+          expect(val_prod.rhs.members[0].name).to eq('digit_plus')
         end
 
         it "should support optional grouping" do
           instance = GrammarBuilder.new
           instance.add_terminals('EQUAL', 'IDENTIFIER', 'VAR')
 
-          instance.add_production('var_decl' => 'VAR IDENTIFIER (EQUAL expression)?')
+          instance.rule 'var_decl' => 'VAR IDENTIFIER (EQUAL expression)?'
+          instance.grammar_complete!
 
           # 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)
-          (p0, p1, p2) = instance.productions[0..2]
+          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')
@@ -189,23 +197,24 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.lhs.name).to eq('seq_EQUAL_expression_qmark')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_qmark_none')
-
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('var_decl')
-          expect(last_prod.rhs.members[2].name).to eq('seq_EQUAL_expression_qmark')
         end
 
         it "should support grouping with star modifier" do
           instance = GrammarBuilder.new
           instance.add_terminals('OR')
 
-          instance.add_production('logic_or' => 'logic_and (OR logic_and)*')
+          instance.rule 'logic_or' => 'logic_and (OR logic_and)*'
+          instance.grammar_complete!
 
           # implicitly called: rule('seq_OR_logic_and' => 'OR logic_and').tag 'return_children'
           # implicitly called: rule('seq_EQUAL_expression_star' => 'seq_EQUAL_expression_star seq_EQUAL_expression').tag suffix_star_more
           # implicitly called: rule('seq_EQUAL_expression_star' => '').tag suffix_star_none
           expect(instance.productions.size).to eq(4)
-          (p0, p1, p2) = instance.productions[0..2]
+          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')
+
+          (p0, p1, p2) = instance.productions[1..3]
           expect(p0.lhs.name).to eq('seq_OR_logic_and')
           expect(p0.rhs[0].name).to eq('OR')
           expect(p0.rhs[1].name).to eq('logic_and')
@@ -219,23 +228,24 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.lhs.name).to eq('seq_OR_logic_and_star')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_star_none')
-
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('logic_or')
-          expect(last_prod.rhs.members[1].name).to eq('seq_OR_logic_and_star')
         end
 
         it "should support grouping with plus modifier" do
           instance = GrammarBuilder.new
           instance.add_terminals('POINT TO SEMI_COLON')
 
-          instance.add_production('path' => 'POINT (TO POINT)+ SEMI_COLON')
+          instance.rule 'path' => 'POINT (TO POINT)+ SEMI_COLON'
+          instance.grammar_complete!
 
           # implicitly called: rule('seq_TO_POINT' => 'TO POINT').tag 'return_children'
           # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT_plus seq_TO_POINT').tag suffix_plus_more
           # implicitly called: rule('seq_TO_POINT_plus' => 'seq_TO_POINT').tag suffix_plus_one
           expect(instance.productions.size).to eq(4)
-          (p0, p1, p2) = instance.productions[0..2]
+          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')
+
+          (p0, p1, p2) = instance.productions[1..3]
           expect(p0.lhs.name).to eq('seq_TO_POINT')
           expect(p0.rhs[0].name).to eq('TO')
           expect(p0.rhs[1].name).to eq('POINT')
@@ -249,23 +259,24 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.lhs.name).to eq('seq_TO_POINT_plus')
           expect(p2.rhs[0].name).to eq('seq_TO_POINT')
           expect(p2.name).to eq('_plus_one')
-
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('path')
-          expect(last_prod.rhs.members[1].name).to eq('seq_TO_POINT_plus')
         end
 
         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)?"
-          instance.add_production('if_stmt' => st)
+          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)
-          (p0, p1, p2) = instance.productions[0..2]
+          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')
@@ -282,10 +293,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(p2.lhs.name).to eq('seq_ELSE_stmt_qmark')
           expect(p2.rhs).to be_empty
           expect(p2.name).to eq('_qmark_none')
-
-          last_prod = instance.productions.last
-          expect(last_prod.lhs.name).to eq('if_stmt')
-          expect(last_prod.rhs.members[5].name).to eq('seq_ELSE_stmt_qmark')
         end
       end # context
     end # describe

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -934,10 +934,11 @@ MSG
           # S => ;
           # This grammar requires a time that is quadratic in the number of
           # input tokens
-          builder = Notation::GrammarBuilder.new
-          builder.add_terminals('a')
-          builder.add_production('S' => 'a S')
-          builder.add_production('S' => '')
+          builder = Notation::GrammarBuilder.new do
+            add_terminals('a')
+            rule('S' => 'a S')
+            rule('S' => '')
+          end
           grammar = builder.grammar
           tokens = build_token_sequence(%w[a a a a], grammar)
 
@@ -1017,6 +1018,25 @@ MSG
           ]
           compare_entry_texts(parse_result.chart[4], expected)
         end
+
+        it 'should support modifier(s) in start rule' do
+          # 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
+            add_terminals('a', 'b', 'EOF')
+
+            rule('S' => 'a_or_b* EOF')
+            rule('a_or_b' => 'a')
+            rule('a_or_b' => 'b')
+          end
+          grammar = builder.grammar
+          tokens = build_token_sequence(%w[EOF], grammar)
+          tokens[0].instance_variable_set(:@lexeme, '')
+          instance = GFGEarleyParser.new(grammar)
+          parse_result = instance.parse(tokens)
+          expect(parse_result.success?).to eq(true)
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.8.00
+  version: 0.8.01
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-15 00:00:00.000000000 Z
+date: 2021-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake