dendroid 0.0.12 → 0.1.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56842965215f0cef73b768223b5acb907fc1642b57528a9e616852ae6adab2cc
-  data.tar.gz: d53478ebcb86c89a407d648c67bfd34dd1f3333f41f7b6e0eac1dcb3e2a25cb6
+  metadata.gz: 722b27a6f20e87c43de339b3f0c45e2bcc77c464d5dd9ecd56bbb686c4857b61
+  data.tar.gz: ce6ffd0c100ea7b7c336044e2877617eebb85c7bb306d5de9d1d4395200320aa
 SHA512:
-  metadata.gz: 7ef9e4766ad0c786471d08ba6cffcdffaec2d9acf734e25dafa796e714e1103ee838421b3b817c0c732b91c1a238c5fd32c9c3a6f2954926880336b70caab8b9
-  data.tar.gz: 7e389e83762cedfbdbdf23acbcf821f478a237d8e2b6da6c4299db17d0ade7e760f77328e8f9f59cb10c251f6b1711257793c2b94c12e7ddd8bde2bcad5add66
+  metadata.gz: 69870ade1f77e7fe0b9faf20b7943a500abdf2b41d383a4e048438e431e6f65bf4b418806ec4ba325a6839ee4eb1337085772fe7fa5c594b59663cd653cdeac6
+  data.tar.gz: 137bbf46a71dcb603f3866f51b5be25a8557fb574937e2e1b3f8b40980cd6e7fd6a851c84b229b7b7ecb692d2899d721e3bcc041fe09e213318f46efdb041ea7

data/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+## [0.1.00] - 2023-11-03
+Version bump: the Earley recognizer is functional.
+
 ## [0.0.12] - 2023-11-02
 Added more tests.
 

data/lib/dendroid/grm_analysis/grm_analyzer.rb

@@ -13,7 +13,6 @@ module Dendroid
       attr_reader :grammar
       attr_reader :items
       attr_reader :production2items
-      attr_reader :symbol2productions
 
       # @return [Dendroid::Syntax::Terminal] The pseudo-terminal `__epsilon` (for empty string)
       attr_reader :epsilon
@@ -37,7 +36,6 @@ module Dendroid
         @grammar = aGrammar
         @items = []
         @production2items = {}
-        @symbol2productions = {}
         @epsilon = Syntax::Terminal.new(:__epsilon)
         @endmarker = Syntax::Terminal.new(:"$$")
         @first_sets = {}
@@ -56,14 +54,14 @@ module Dendroid
         prod.next_item(aDottedItem)
       end
 
+      def symbol2production(sym)
+        grammar.nonterm2production[sym]
+      end
+
       private
 
       def build_dotted_items
         grammar.rules.each do |prod|
-          lhs = prod.head
-          symbol2productions[lhs] = [] unless symbol2productions.include? lhs
-          symbol2productions[lhs] << prod
-          # production2items[prod] = []
           mixin = prod.choice? ? ChoiceItems : ProductionItems
           prod.extend(mixin)
           prod.build_items
@@ -76,33 +74,31 @@ module Dendroid
       def build_first_sets
         initialize_first_sets
 
-        begin
+        loop do
           changed = false
           grammar.rules.each do |prod|
             head = prod.head
             first_head = first_sets[head]
             pre_first_size = first_head.size
-            if prod.choice?
-              prod.alternatives.each do |alt|
-                first_head.merge(sequence_first(alt.members))
-              end
-            else
-              first_head.merge(sequence_first(prod.body.members))
+            prod.rhs.each do |seq|
+              first_head.merge(sequence_first(seq.members))
             end
             changed = true if first_head.size > pre_first_size
           end
-        end until !changed
+          break unless changed
+        end
       end
 
       def initialize_first_sets
         grammar.symbols.each do |symb|
-          if symb.terminal?
-            first_sets[symb] = Set.new([symb])
-          elsif symb.nullable?
-            first_sets[symb] = Set.new([epsilon])
-          else
-            first_sets[symb] = Set.new
-          end
+          set_arg = if symb.terminal?
+                      [symb]
+                    elsif symb.nullable?
+                      [epsilon]
+                    else
+                      nil
+                    end
+          first_sets[symb] = Set.new(set_arg)
         end
       end
 
@@ -122,43 +118,11 @@ module Dendroid
       def build_follow_sets
         initialize_follow_sets
 
-        begin
+        loop do
           changed = false
           grammar.rules.each do |prod|
-            if prod.choice?
-              prod.alternatives.each do |alt|
-                body = alt.members
-                next if body.empty?
-
-                head = prod.head
-                head_follow = follow_sets[head]
-                # trailer = Set.new
-                last = true
-                last_index = body.size - 1
-                last_index.downto(0) do |i|
-                  symbol = body[i]
-                  next if symbol.terminal?
-
-                  follow_symbol = follow_sets[symbol]
-                  size_before = follow_symbol.size
-                  if last
-                    # Rule: if last non-terminal member (symbol) is nullable
-                    # then add FOLLOW(head) to FOLLOW(symbol)
-                    follow_sets[symbol].merge(head_follow) if symbol.nullable?
-                    last = false
-                  else
-                    symbol_seq = body.slice(i + 1, last_index - i)
-                    trailer_first = sequence_first(symbol_seq)
-                    contains_epsilon = trailer_first.include? epsilon
-                    trailer_first.delete(epsilon) if contains_epsilon
-                    follow_sets[symbol].merge(trailer_first)
-                    follow_sets[symbol].merge(head_follow) if contains_epsilon
-                  end
-                  changed = true if follow_sets[symbol].size > size_before
-                end
-              end
-            else
-              body = prod.body.members
+            prod.rhs.each do |alt|
+              body = alt.members
               next if body.empty?
 
               head = prod.head
@@ -189,7 +153,8 @@ module Dendroid
               end
             end
           end
-        end until !changed
+          break unless changed
+        end
       end
 
       def initialize_follow_sets

data/lib/dendroid/recognizer/chart.rb

@@ -19,10 +19,10 @@ module Dendroid
       attr_writer :success
 
       # @return [StandardError] The exception class in case of an error found by the recognizer
-      attr_accessor :failure_class
+      attr_reader :failure_class
 
       # @return [String] The error message
-      attr_accessor :failure_reason
+      attr_reader :failure_reason
 
       def_delegators :@item_sets, :[], :last, :size
 
@@ -50,6 +50,14 @@ module Dendroid
       def successful?
         @success
       end
+
+      # Set the error cause.
+      # @param exception_class [StandardError] Exception class
+      # @param message [String] Error message
+      def failure(exception_class, message)
+        @failure_class = exception_class
+        @failure_reason = message
+      end
     end # class
   end # module
 end # module

data/lib/dendroid/recognizer/recognizer.rb

@@ -31,8 +31,7 @@ module Dendroid
         tok = tokenizer.next_token
         if tok.nil? && !grm_analysis.grammar.start_symbol.nullable?
           chart = new_chart
-          chart.failure_class = StandardError
-          chart.failure_reason = 'Error: Input may not be empty nor blank.'
+          chart.failure(StandardError, 'Error: Input may not be empty nor blank.')
           chart
         else
           earley_parse(tok)
@@ -62,7 +61,7 @@ module Dendroid
 
           rank += 1 if advance
           break if eos_reached && !advance
-          break if !advance
+          break unless advance
         end
 
         determine_outcome(chart, tokens)
@@ -74,13 +73,10 @@ module Dendroid
       def new_chart
         top_symbol = grm_analysis.grammar.start_symbol
 
-        # Reminder: there might be multiple rules for the start symbol
-        prods = grm_analysis.grammar.nonterm2productions[top_symbol]
+        prd = grm_analysis.grammar.nonterm2production[top_symbol]
         chart = Chart.new
-        prods.each do |prd|
-          seed_items = prd.predicted_items
-          seed_items.each { |item| chart.seed_last_set(EItem.new(item, 0)) }
-        end
+        seed_items = prd.predicted_items
+        seed_items.each { |item| chart.seed_last_set(EItem.new(item, 0)) }
 
         chart
       end
@@ -103,12 +99,10 @@ module Dendroid
 
         if entry.completed?
           completer(chart, entry, rank, tokens, mode)
+        elsif entry.next_symbol.terminal?
+          advance = scanner(chart, entry, rank, tokens)
         else
-          if entry.next_symbol.terminal?
-            advance = scanner(chart, entry, rank, tokens)
-          else
-            predictor(chart, entry, rank, tokens, mode, predicted_symbols)
-          end
+          predictor(chart, entry, rank, tokens, mode, predicted_symbols)
         end
 
         advance
@@ -131,31 +125,28 @@ module Dendroid
           predicted.add(next_symbol)
         end
 
-        prods = grm_analysis.symbol2productions[next_symbol]
         curr_set = chart[rank]
         next_token = tokens[rank]
-        prods.each do |prd|
-          entry_items = prd.predicted_items
-          entry_items.each do |entry|
-            member = entry.next_symbol
-            if member&.terminal?
-              next unless next_token
-              next if (member.name != next_token.terminal) && mode == :genuine
-            end
-
-            new_item = EItem.new(entry, rank)
-            curr_set.add_item(new_item)
+        prd = grm_analysis.symbol2production(next_symbol)
+        entry_items = prd.predicted_items
+        entry_items.each do |entry|
+          member = entry.next_symbol
+          if member&.terminal?
+            next unless next_token
+            next if (member.name != next_token.terminal) && mode == :genuine
           end
-        end
 
-        # Use trick from paper John Aycock and R. Nigel Horspool: "Practical Earley Parsing"
-        if next_symbol.nullable?
-          next_item = grm_analysis.next_item(item.dotted_item)
-          if next_item
-            new_item = EItem.new(next_item, item.origin)
-            curr_set.add_item(new_item)
-          end
+          new_item = EItem.new(entry, rank)
+          curr_set.add_item(new_item)
         end
+        # Use trick from paper John Aycock and R. Nigel Horspool: "Practical Earley Parsing"
+        return unless next_symbol.nullable?
+
+        next_item = grm_analysis.next_item(item.dotted_item)
+        return unless next_item
+
+        new_item = EItem.new(next_item, item.origin)
+        curr_set.add_item(new_item)
       end
 
       # procedure SCANNER((A → α•aβ, j), k, words)
@@ -219,13 +210,11 @@ module Dendroid
         success = false
         if chart.size == tokens.size + 1
           top_symbol = grm_analysis.grammar.start_symbol
-          top_rules = grm_analysis.grammar.nonterm2productions[top_symbol]
-          final_items = top_rules.reduce([]) do |items, rule|
-            items.concat(rule.reduce_items)
-          end
+          top_rule = grm_analysis.grammar.nonterm2production[top_symbol]
+          final_items = top_rule.reduce_items
           last_set = chart.item_sets.last
           last_set.each do |entry|
-            next if ((!entry.origin.zero?) || !final_items.include?(entry.dotted_item))
+            next if !entry.origin.zero? || !final_items.include?(entry.dotted_item)
 
             success = true
           end
@@ -239,39 +228,37 @@ module Dendroid
             offending_token = tokens[chart.size - 1]
             pos = offending_token.position
             (line, col) = [pos.lineno, pos.column]
-            last_set = chart.last
-            terminals = last_set.items.reduce([]) do |result, ent|
-              result << ent.next_symbol if ent.pre_scan?
-              result
-            end
-            terminals.uniq!
+            terminals = expected_terminals(chart)
             prefix = "Syntax error at or near token line #{line}, column #{col} >>>#{offending_token.source}<<<"
             expectation = terminals.size == 1 ? terminals[0].name.to_s : "one of: [#{terminals.map(&:name).join(', ')}]"
             err_msg = "#{prefix} Expected #{expectation}, found a #{offending_token.terminal} instead."
-            chart.failure_class = StandardError
-            chart.failure_reason = err_msg
+            chart.failure(StandardError, err_msg)
           elsif chart.size == tokens.size + 1
             # EOS unexpected...
             last_token = tokens.last
             pos = last_token.position
             (line, col) = [pos.lineno, pos.column]
-            last_set = chart.last
-            terminals = last_set.items.reduce([]) do |result, ent|
-              result << ent.next_symbol if ent.pre_scan?
-              result
-            end
-            terminals.uniq!
-
+            terminals = expected_terminals(chart)
             prefix = "Line #{line}, column #{col}: Premature end of input after '#{last_token.source}'"
             expectation = terminals.size == 1 ? terminals[0].name.to_s : "one of: [#{terminals.map(&:name).join(', ')}]"
             err_msg = "#{prefix}, expected: #{expectation}."
-            chart.failure_class = StandardError
-            chart.failure_reason = err_msg
+            chart.failure(StandardError, err_msg)
           end
         end
         chart.success = success
       end
 
+      def expected_terminals(chart)
+        last_set = chart.last
+        terminals = last_set.items.reduce([]) do |result, ent|
+          result << ent.next_symbol if ent.pre_scan?
+          result
+        end
+        terminals.uniq!
+
+        terminals
+      end
+
       def replay_last_set(chart, tokens)
         rank = chart.size - 1
         seed_set(chart, rank) # Re-initialize last set with scan entries

data/lib/dendroid/syntax/grammar.rb

@@ -17,47 +17,48 @@ module Dendroid
       # @return [Array<Dendroid::Syntax::GrmSymbol>] The terminal and non-terminal symbols.
       attr_reader :symbols
 
+      # A Hash that maps symbol names to their grammar symbols
+      # @return [Hash{String|Symbol => Dendroid::Syntax::GrmSymbol}]
+      attr_reader :name2symbol
+
       # The list of production rules for the language.
       # @return [Array<Dendroid::Syntax::Rule>] Array of rules for the grammar.
       attr_reader :rules
 
-      # A Hash that maps symbol names to their grammar symbols
-      # @return [Hash{String => Dendroid::Syntax::GrmSymbol}]
-      attr_reader :name2symbol
-
-      # TODO: make nonterminal - rules one-to-one
       # A Hash that maps symbol names to their grammar symbols
       # @return [Hash{Dendroid::Syntax::GrmSymbol => Dendroid::Syntax::Rule}]
-      attr_reader :nonterm2productions
+      attr_reader :nonterm2production
 
       # Constructor.
       # @param terminals [Array<Dendroid::Syntax::Terminal>]
       def initialize(terminals)
         @symbols = []
         @name2symbol = {}
+        @rules = []
+        @nonterm2production = {}
         add_terminals(terminals)
       end
 
-      # Add a rule to the grammar
+      # Add a rule to the grammar.
       # @param rule [Dendroid::Syntax::Rule]
       def add_rule(rule)
-        if @rules.nil?
-          @rules = []
-          @nonterm2productions = {}
+        if lhs_already_defined?(rule)
+          msg = "Non-terminal '#{rule.head}' is on left-hand side of more than one rule."
+          raise StandardError, msg
         end
-        # TODO: add test for duplicate productions
-        if nonterm2productions[rule.head]&.include? rule
-          raise StandardError, "Production rule '#{rule}' appears more than once in the grammar."
+        if duplicate_rule?(rule)
+          raise StandardError, "Duplicate production rule '#{rule}'."
         end
 
         add_symbol(rule.head)
         rule.nonterminals.each { |nonterm| add_symbol(nonterm) }
         rules << rule
-        nonterm2productions[rule.head] = [] unless nonterm2productions.include? rule.head
-        nonterm2productions[rule.head] << rule
+        nonterm2production[rule.head] = rule
       end
 
-      # Return the start symbol for the language
+      # Return the start symbol for the language, that is,
+      # the non-terminal symbol used to denote the top-level
+      # construct of the language being defined.
       # @return [Dendroid::Syntax::NonTerminal]
       def start_symbol
         rules.first.lhs
@@ -73,10 +74,14 @@ module Dendroid
 
       private
 
-      # rubocop: disable Metrics/AbcSize
-      # rubocop: disable Metrics/BlockNesting
-      # rubocop: disable Metrics/MethodLength
-      # rubocop: disable Metrics/PerceivedComplexity
+      def lhs_already_defined?(rule)
+        nonterm2production.include? rule.head
+      end
+
+      def duplicate_rule?(rule)
+        nonterm2production[rule.head]&.include? rule
+      end
+
       def add_terminals(terminals)
         terminals.each { |term| add_symbol(term) }
       end
@@ -89,6 +94,15 @@ module Dendroid
         name2symbol[symb.name.to_s] = symb
       end
 
+      def all_terminals
+        Set.new(symbols.select(&:terminal?))
+      end
+
+      def all_nonterminals
+        Set.new(symbols.reject(&:terminal?))
+      end
+
+      # Perform correctness checks of the grammar.
       def validate
         at_least_one_terminal
         are_terminals_referenced?
@@ -104,7 +118,6 @@ module Dendroid
       # Does the grammar contain at least one terminal symbol?
       def at_least_one_terminal
         found = symbols.any?(&:terminal?)
-
         return true if found
 
         err_msg = "Grammar doesn't contain any terminal symbol."
@@ -114,37 +127,28 @@ module Dendroid
       # Does every terminal symbol appear at least once
       # in a rhs of a production rule?
       def are_terminals_referenced?
-        all_terminals = Set.new(symbols.select(&:terminal?))
         terms_in_rhs = rules.reduce(Set.new) do |collected, prd|
           found = prd.terminals
           collected.merge(found)
         end
-        check_ok = all_terminals == terms_in_rhs
-        unless check_ok
-          unused_terms = all_terminals.difference(terms_in_rhs)
-          text = unused_terms.map(&:name).join("', '")
-          err_msg = "Terminal symbols '#{text}' never appear in production rules."
-          raise StandardError, err_msg
-        end
+        return true if all_terminals == terms_in_rhs
 
-        check_ok
+        unused_terms = all_terminals.difference(terms_in_rhs)
+        text = unused_terms.map(&:name).join("', '")
+        err_msg = "Terminal symbols '#{text}' never appear in production rules."
+        raise StandardError, err_msg
       end
 
       def are_nonterminals_rewritten?
-        all_nonterminals = Set.new(symbols.reject(&:terminal?))
-
         symbs_in_lhs = rules.reduce(Set.new) do |collected, prd|
           collected.add(prd.head)
         end
-        check_ok = all_nonterminals == symbs_in_lhs
-        unless check_ok
-          undefined_nterms = all_nonterminals.difference(symbs_in_lhs)
-          text = undefined_nterms.map(&:name).join("', '")
-          err_msg = "Non-terminal symbols '#{text}' never appear in head of any production rule."
-          raise StandardError, err_msg
-        end
+        return true if all_nonterminals == symbs_in_lhs
 
-        check_ok
+        undefined_nterms = all_nonterminals.difference(symbs_in_lhs)
+        text = undefined_nterms.map(&:name).join("', '")
+        err_msg = "Non-terminal symbols '#{text}' never appear in head of any production rule."
+        raise StandardError, err_msg
       end
 
       def are_symbols_reachable?
@@ -165,28 +169,31 @@ module Dendroid
         raise StandardError, err_msg
       end
 
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # Are all symbols reachable from start symbol?
+      # @return [Set<NonTerminal>] Set of unreachable symbols
       def unreachable_symbols
         backlog = [start_symbol]
         set_reachable = Set.new(backlog.dup)
 
-        begin
+        loop do
           reachable_sym = backlog.pop
-          prods = nonterm2productions[reachable_sym]
-          prods.each do |prd|
-            prd.rhs_symbols.each do |member|
-              unless member.terminal? || set_reachable.include?(member)
-                backlog.push(member)
-              end
-              set_reachable.add(member)
-            end
+          prd = nonterm2production[reachable_sym]
+          prd.rhs_symbols.each do |member|
+            backlog.push(member) unless member.terminal? || set_reachable.include?(member)
+            set_reachable.add(member)
           end
-        end until backlog.empty?
+          break if backlog.empty?
+        end
 
         all_symbols = Set.new(symbols)
         all_symbols - set_reachable
       end
 
+      # @return [Array<Dendroid::Syntax::NonTerminal>]
       def mark_non_productive_symbols
         prod_count = rules.size
         backlog = Set.new(0...prod_count)
@@ -214,11 +221,11 @@ module Dendroid
         nullable_found = false
         sym2seqs = {}
 
-        nonterm2productions.each_pair do |sym, prods|
-          if prods.any?(&:empty?)
+        nonterm2production.each_pair do |sym, prod|
+          if prod.empty?
             sym.nullable = nullable_found = true
           else
-            sym2seqs[sym] = prods.map(&:rhs).flatten
+            sym2seqs[sym] = prod.rhs
           end
         end
 
@@ -228,7 +235,7 @@ module Dendroid
             seqs.each { |sq| backlog[sq] = [0, sym] }
           end
 
-          begin
+          loop do
             seqs_done = []
             backlog.each_pair do |sq, (elem_index, lhs)|
               member = sq[elem_index]
@@ -256,18 +263,23 @@ module Dendroid
                 backlog.delete(sq)
               end
             end
-          end until backlog.empty? || seqs_done.empty?
+            break if backlog.empty? || seqs_done.empty?
+          end
         end
 
+        # symbols.each do |sym|
+        #   next if sym.terminal?
+        #
+        #   sym.nullable = false if sym.nullable.nil?
+        # end
         symbols.each do |sym|
-          next if sym.terminal?
+          next if sym.terminal? || sym.nullable?
 
-          sym.nullable = false if sym.nullable.nil?
+          sym.nullable = false
         end
       end
       # rubocop: enable Metrics/AbcSize
-      # rubocop: enable Metrics/BlockNesting
-      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/CyclomaticComplexity
       # rubocop: enable Metrics/PerceivedComplexity
     end # class
   end # module

data/spec/dendroid/syntax/grammar_spec.rb

@@ -58,8 +58,8 @@ describe Dendroid::Syntax::Grammar do
       expect(subject.symbols).to eq(all_terminals)
     end
 
-    it 'ignores about productions after initialization' do
-      expect(subject.rules).to be_nil
+    it 'does not have rules after initialization' do
+      expect(subject.rules).to be_empty
     end
 
     it 'maps a terminal name to one GrmSymbol object' do
@@ -109,14 +109,15 @@ describe Dendroid::Syntax::Grammar do
       end
     end
 
-    it 'maps every non-terminal to its defining productions' do
+    it 'maps every non-terminal to its defining production' do
       rules = build_all_rules
       rules.each { |rl| subject.add_rule(rl) }
       %i[p s m t].each do |symb_name|
         symb = subject.name2symbol[symb_name]
         expected_prods = subject.rules.select { |prd| prd.head == symb }
-        related_prods = subject.nonterm2productions[symb]
-        expect(related_prods).to eq(expected_prods)
+        expect(expected_prods.size).to eq(1)
+        related_prod = subject.nonterm2production[symb]
+        expect(related_prod).to eq(expected_prods[0])
       end
     end
   end # context
@@ -230,8 +231,7 @@ describe Dendroid::Syntax::Grammar do
         # No terminal symbol explicitly declared => all symbols are non-terminals
 
         rule 'S' => 'A'
-        rule 'A' => 'a A c'
-        rule 'A' => 'b'
+        rule 'A' => ['a A c', 'b']
       end
 
       builder.grammar
@@ -243,8 +243,7 @@ describe Dendroid::Syntax::Grammar do
 
         # # Wrong: terminals 'd' and 'e' never appear in rules
         rule 'S' => 'A'
-        rule 'A' => 'a A c'
-        rule 'A' => 'b'
+        rule 'A' => ['a A c', 'b']
       end
 
       builder.grammar
@@ -282,13 +281,24 @@ describe Dendroid::Syntax::Grammar do
       builder.grammar
     end
 
+    def grm_multiple_defs
+      builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
+        declare_terminals('a b c')
+
+        rule 'A' => %w[a B]
+        rule 'B' => ['b', '']
+        rule 'A' => 'c'
+      end
+
+      builder.grammar
+    end
+
     def duplicate_production
       builder = Dendroid::GrmDSL::BaseGrmBuilder.new do
-        declare_terminals('a', 'b', 'c')
+        declare_terminals('a')
 
         rule 'S' => 'A'
-        rule 'A' => ['a A c', 'b']
-        rule 'S' => 'A' # Duplicate rule
+        rule 'A' => %w[a a] # Duplicate alternatives
       end
 
       builder.grammar
@@ -329,8 +339,13 @@ describe Dendroid::Syntax::Grammar do
       expect { grm_undefined_nterm }.to raise_error(StandardError, err_msg)
     end
 
+    it 'raises an error when a non-terminal is defined multiple times' do
+      err_msg = "Non-terminal 'A' is on left-hand side of more than one rule."
+      expect { grm_multiple_defs }.to raise_error(StandardError, err_msg)
+    end
+
     it 'raises an error when a production is duplicated' do
-      err_msg = "Production rule 'S => A' appears more than once in the grammar."
+      err_msg = 'Duplicate alternatives: A => a'
       expect { duplicate_production }.to raise_error(StandardError, err_msg)
     end
 

data/version.txt

@@ -1 +1 @@
-0.0.12
+0.1.00

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-02 00:00:00.000000000 Z
+date: 2023-11-03 00:00:00.000000000 Z
 dependencies: []
 description: WIP. A Ruby implementation of an Earley parser
 email: famished.tiger@yahoo.com