dendroid 0.1.00 → 0.2.00

data/spec/dendroid/syntax/grammar_spec.rb

@@ -4,8 +4,7 @@ require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
 require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
-require_relative '..\..\..\lib\dendroid\syntax\choice'
+require_relative '..\..\..\lib\dendroid\syntax\rule'
 require_relative '..\..\..\lib\dendroid\syntax\grammar'
 require_relative '..\..\..\lib\dendroid\grm_dsl\base_grm_builder'
 
@@ -33,19 +32,15 @@ describe Dendroid::Syntax::Grammar do
     Dendroid::Syntax::SymbolSeq.new(symbols)
   end
 
-  def build_production(lhs, symbols)
-    Dendroid::Syntax::Production.new(lhs, build_symbol_seq(symbols))
-  end
-
   def build_choice(lhs, sequences)
-    Dendroid::Syntax::Choice.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
+    Dendroid::Syntax::Rule.new(lhs, sequences.map { |arr| build_symbol_seq(arr) })
   end
 
   def build_all_rules
-    rule1 = build_production(p_symb, [s_symb]) # p => s
+    rule1 = build_choice(p_symb, [[s_symb]]) # p => s
     rule2 = build_choice(s_symb, [[s_symb, plus_symb, m_symb], [m_symb]]) # s => s + m | m
     rule3 = build_choice(m_symb, [[m_symb, star_symb, t_symb], [t_symb]]) # m => m * t
-    rule4 = build_production(t_symb, [int_symb]) # t => INTEGER
+    rule4 = build_choice(t_symb, [[int_symb]]) # t => INTEGER
     [rule1, rule2, rule3, rule4]
   end
 
@@ -72,7 +67,7 @@ describe Dendroid::Syntax::Grammar do
 
   context 'Adding productions:' do
     it 'allows the addition of one production rule' do
-      rule = build_production(p_symb, [s_symb])
+      rule = build_choice(p_symb, [[s_symb]])
       expect { subject.add_rule(rule) }.not_to raise_error
       expect(subject.rules.size).to eq(1)
       expect(subject.rules.first).to eq(rule)
@@ -141,10 +136,10 @@ describe Dendroid::Syntax::Grammar do
       nterm_e = build_nonterminal('E')
 
       instance = described_class.new([terminal_a])
-      instance.add_rule(build_production(nterm_s_prime, [nterm_s]))
-      instance.add_rule(build_production(nterm_s, [nterm_a, nterm_a, nterm_a, nterm_a]))
+      instance.add_rule(build_choice(nterm_s_prime, [[nterm_s]]))
+      instance.add_rule(build_choice(nterm_s, [[nterm_a, nterm_a, nterm_a, nterm_a]]))
       instance.add_rule(build_choice(nterm_a, [[terminal_a], [nterm_e]]))
-      instance.add_rule(build_production(nterm_e, []))
+      instance.add_rule(build_choice(nterm_e, [[]]))
 
       instance.complete!
       all_nonterminals = subject.symbols.reject(&:terminal?)
@@ -160,7 +155,7 @@ describe Dendroid::Syntax::Grammar do
       # Let add's unreachable symbols
       zed_symb = build_nonterminal('Z')
       question_symb = build_nonterminal('?')
-      bad_rule = build_production(zed_symb, [zed_symb, question_symb, int_symb]) # Z => Z ? INTEGER
+      bad_rule = build_choice(zed_symb, [[zed_symb, question_symb, int_symb]]) # Z => Z ? INTEGER
       subject.add_rule(bad_rule)
       unreachable = subject.send(:unreachable_symbols)
       expect(unreachable).not_to be_empty
@@ -175,7 +170,7 @@ describe Dendroid::Syntax::Grammar do
       expect(t_symb).to be_productive
       expect(p_symb).to be_productive
 
-      # Grammar with non-productive symbols
+      # # Grammar with non-productive symbols
       term_a = build_terminal('a')
       term_b = build_terminal('b')
       term_c = build_terminal('c')
@@ -191,12 +186,12 @@ describe Dendroid::Syntax::Grammar do
       nterm_S = build_nonterminal('S')
       instance = described_class.new([term_a, term_b, term_c, term_d, term_e, term_f])
       instance.add_rule(build_choice(nterm_S, [[nterm_A, nterm_B], [nterm_D, nterm_E]]))
-      instance.add_rule(build_production(nterm_A, [term_a]))
-      instance.add_rule(build_production(nterm_B, [term_b, nterm_C]))
-      instance.add_rule(build_production(nterm_C, [term_c]))
-      instance.add_rule(build_production(nterm_D, [term_d, nterm_F]))
-      instance.add_rule(build_production(nterm_E, [term_e]))
-      instance.add_rule(build_production(nterm_F, [term_f, nterm_D]))
+      instance.add_rule(build_choice(nterm_A, [[term_a]]))
+      instance.add_rule(build_choice(nterm_B, [[term_b, nterm_C]]))
+      instance.add_rule(build_choice(nterm_C, [[term_c]]))
+      instance.add_rule(build_choice(nterm_D, [[term_d, nterm_F]]))
+      instance.add_rule(build_choice(nterm_E, [[term_e]]))
+      instance.add_rule(build_choice(nterm_F, [[term_f, nterm_D]]))
       nonproductive = instance.send(:mark_non_productive_symbols)
       expect(nonproductive).not_to be_empty
       expect(nonproductive).to eq([nterm_D, nterm_F])

data/spec/dendroid/syntax/rule_spec.rb

@@ -3,28 +3,77 @@
 require_relative '..\..\spec_helper'
 require_relative '..\..\..\lib\dendroid\syntax\terminal'
 require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
+require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
 require_relative '..\..\..\lib\dendroid\syntax\rule'
 
 describe Dendroid::Syntax::Rule do
   let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
+  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
+  let(:minus_symb) { Dendroid::Syntax::Terminal.new('MINUS') }
   let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
+  let(:foo_symb) { Dendroid::Syntax::NonTerminal.new('foo') }
+  let(:alt1) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
+  let(:alt2) { Dendroid::Syntax::SymbolSeq.new([num_symb, minus_symb, num_symb]) }
+  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
 
-  subject { described_class.new(expr_symb) }
+  # Implements a choice rule:
+  #   expression => NUMBER PLUS NUMBER
+  #              |  NUMBER MINUS NUMBER
+  #              |  epsilon
+  subject { described_class.new(expr_symb, [alt1, alt2, empty_body]) }
 
   context 'Initialization:' do
-    it 'is initialized with a non-terminal' do
-      expect { described_class.new(expr_symb) }.not_to raise_error
+    it 'is initialized with a head and alternatives' do
+      expect { described_class.new(expr_symb, [alt1, alt2, empty_body]) }.not_to raise_error
     end
 
     it 'knows its head (aka lhs)' do
       expect(subject.head).to eq(expr_symb)
     end
+
+    it 'knows its alternatives' do
+      expect(subject.alternatives).to eq([alt1, alt2, empty_body])
+    end
+
+    it 'renders a String representation of itself' do
+      expectation = 'expression => NUMBER PLUS NUMBER | NUMBER MINUS NUMBER | '
+      expect(subject.to_s).to eq(expectation)
+    end
+  end # context
+
+  context 'Provided services:' do
+    it 'knows its terminal members' do
+      expect(subject.terminals).to eq([num_symb, plus_symb, minus_symb])
+    end
+
+    it 'knows its non-terminal members' do
+      expect(subject.nonterminals).to be_empty
+
+      my_alt1 = Dendroid::Syntax::SymbolSeq.new([expr_symb, plus_symb, expr_symb])
+      my_alt2 = Dendroid::Syntax::SymbolSeq.new([foo_symb, minus_symb, expr_symb])
+      instance = described_class.new(foo_symb, [my_alt1, my_alt2])
+      expect(instance.nonterminals).to eq([expr_symb, foo_symb])
+    end
   end # context
 
   context 'Errors:' do
-    it 'fails when initialized with a terminal' do
-      msg = "Terminal symbol 'NUMBER' may not be on left-side of a rule."
-      expect { described_class.new(num_symb) }.to raise_error(StandardError, msg)
+    context 'Errors:' do
+      it 'fails when initialized with a terminal' do
+        msg = "Terminal symbol 'NUMBER' may not be on left-side of a rule."
+        expect { described_class.new(num_symb, []) }.to raise_error(StandardError, msg)
+      end
+    end
+
+    it 'fails when initialized with one alternative only' do
+      err = StandardError
+      err_msg = 'The choice for `expression` must have at least one alternative.'
+      expect { described_class.new(expr_symb, []) }.to raise_error(err, err_msg)
     end
-  end
+
+    it 'fails in presence of duplicate rhs' do
+      err = StandardError
+      err_msg = 'Duplicate alternatives: expression => NUMBER PLUS NUMBER'
+      expect { described_class.new(expr_symb, [alt1, alt2, alt1]) }.to raise_error(err, err_msg)
+    end
+  end # context
 end # describe

data/version.txt

@@ -1 +1 @@
-0.1.00
+0.2.00

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dendroid
 version: !ruby/object:Gem::Version
-  version: 0.1.00
+  version: 0.2.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-03 00:00:00.000000000 Z
+date: 2023-12-16 00:00:00.000000000 Z
 dependencies: []
 description: WIP. A Ruby implementation of an Earley parser
 email: famished.tiger@yahoo.com
@@ -24,47 +24,54 @@ files:
 - bin/dendroid
 - dendroid.gemspec
 - lib/dendroid.rb
-- lib/dendroid/grm_analysis/alternative_item.rb
-- lib/dendroid/grm_analysis/choice_items.rb
+- lib/dendroid/formatters/ascii_tree.rb
+- lib/dendroid/formatters/base_formatter.rb
+- lib/dendroid/formatters/bracket_notation.rb
 - lib/dendroid/grm_analysis/dotted_item.rb
 - lib/dendroid/grm_analysis/grm_analyzer.rb
-- lib/dendroid/grm_analysis/production_items.rb
+- lib/dendroid/grm_analysis/rule_items.rb
 - lib/dendroid/grm_dsl/base_grm_builder.rb
 - lib/dendroid/lexical/literal.rb
 - lib/dendroid/lexical/token.rb
 - lib/dendroid/lexical/token_position.rb
+- lib/dendroid/parsing/and_node.rb
+- lib/dendroid/parsing/chart_walker.rb
+- lib/dendroid/parsing/composite_parse_node.rb
+- lib/dendroid/parsing/empty_rule_node.rb
+- lib/dendroid/parsing/or_node.rb
+- lib/dendroid/parsing/parse_node.rb
+- lib/dendroid/parsing/parse_tree_visitor.rb
+- lib/dendroid/parsing/parser.rb
+- lib/dendroid/parsing/terminal_node.rb
+- lib/dendroid/parsing/walk_progress.rb
 - lib/dendroid/recognizer/chart.rb
 - lib/dendroid/recognizer/e_item.rb
 - lib/dendroid/recognizer/item_set.rb
 - lib/dendroid/recognizer/recognizer.rb
-- lib/dendroid/syntax/choice.rb
 - lib/dendroid/syntax/grammar.rb
 - lib/dendroid/syntax/grm_symbol.rb
 - lib/dendroid/syntax/non_terminal.rb
-- lib/dendroid/syntax/production.rb
 - lib/dendroid/syntax/rule.rb
 - lib/dendroid/syntax/symbol_seq.rb
 - lib/dendroid/syntax/terminal.rb
 - lib/dendroid/utils/base_tokenizer.rb
-- spec/dendroid/grm_analysis/alternative_item_spec.rb
-- spec/dendroid/grm_analysis/choice_items_spec.rb
 - spec/dendroid/grm_analysis/dotted_item_spec.rb
 - spec/dendroid/grm_analysis/grm_analyzer_spec.rb
-- spec/dendroid/grm_analysis/production_items_spec.rb
+- spec/dendroid/grm_analysis/rule_items_spec.rb
 - spec/dendroid/grm_dsl/base_grm_builder_spec.rb
 - spec/dendroid/lexical/literal_spec.rb
 - spec/dendroid/lexical/token_position_spec.rb
 - spec/dendroid/lexical/token_spec.rb
+- spec/dendroid/parsing/chart_walker_spec.rb
+- spec/dendroid/parsing/terminal_node_spec.rb
 - spec/dendroid/recognizer/chart_spec.rb
 - spec/dendroid/recognizer/e_item_spec.rb
 - spec/dendroid/recognizer/item_set_spec.rb
 - spec/dendroid/recognizer/recognizer_spec.rb
 - spec/dendroid/support/sample_grammars.rb
-- spec/dendroid/syntax/choice_spec.rb
 - spec/dendroid/syntax/grammar_spec.rb
 - spec/dendroid/syntax/grm_symbol_spec.rb
 - spec/dendroid/syntax/non_terminal_spec.rb
-- spec/dendroid/syntax/production_spec.rb
 - spec/dendroid/syntax/rule_spec.rb
 - spec/dendroid/syntax/symbol_seq_spec.rb
 - spec/dendroid/syntax/terminal_spec.rb
@@ -90,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: WIP. A Ruby implementation of an Earley parser

data/lib/dendroid/grm_analysis/alternative_item.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dotted_item'
-
-module Dendroid
-  module GrmAnalysis
-    # A specialization of DottedItem specific for Choice (rule)
-    class AlternativeItem < DottedItem
-      # @return [Integer] the alternative number
-      attr_reader :alt_index
-
-      # Constructor.
-      # @param aChoice [Dendroid::Syntax::Choice]
-      # @param aPosition [Integer] Position of the dot in rhs of production.
-      # @param index [Integer] the rank of the alternative at hand
-      def initialize(aChoice, aPosition, index)
-        @alt_index = index
-        super(aChoice, aPosition)
-      end
-
-      # Return a String representation of the alternative item.
-      # @return [String]
-      def to_s
-        rhs_names = rule.alternatives[alt_index].members.map(&:to_s)
-        dotted_rhs = rhs_names.insert(position, '.')
-        "#{rule.head} => #{dotted_rhs.join(' ')}"
-      end
-
-      # Indicate whether the rhs of the alternative is empty
-      # @return [Boolean]
-      def empty?
-        rule.alternatives[alt_index].empty?
-      end
-
-      # Indicate whether the dot is at the start of rhs
-      # @return [Boolean]
-      def final_pos?
-        empty? || position == rule.alternatives[alt_index].size
-      end
-
-      alias completed? final_pos?
-
-      # Return the symbol right after the dot (if any)
-      # @return [Dendroid::Syntax::GrmSymbol, NilClass]
-      def next_symbol
-        return nil if empty? || completed?
-
-        rule.alternatives[alt_index].members[position]
-      end
-
-      # Test for equality with another dotted item.
-      # Two dotted items are equal if they refer to the same rule and
-      # have both the same rhs and dot positions.
-      # @return [Boolean]
-      def ==(other)
-        return true if eql?(other)
-
-        (position == other.position) && rule.eql?(other.rule) && (alt_index == other.alt_index)
-      end
-
-      private
-
-      def valid_position(aPosition)
-        raise StandardError if aPosition.negative? || aPosition > rule.alternatives[alt_index].size
-
-        aPosition
-      end
-    end # class
-  end # module
-end # module

data/lib/dendroid/grm_analysis/production_items.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'dotted_item'
-
-module Dendroid
-  module GrmAnalysis
-    # Mix-in module for extending the Dendroid::Syntax::Production class
-    # with dotted items manipulation methods and an attribute named `items`.
-    module ProductionItems
-      # Build the dotted items for this production and assign them
-      # to the `items` attributes
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def build_items
-        @items = if empty?
-                   [DottedItem.new(self, 0)]
-                 else
-                   (0..body.size).reduce([]) do |result, pos|
-                     result << GrmAnalysis::DottedItem.new(self, pos)
-                   end
-                 end
-      end
-
-      # Read accessor for the `items` attribute.
-      # Return the dotted items for this production
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def items
-        @items
-      end
-
-      # Return the predicted item (i.e. the dotted item with the dot at start)
-      # for this production.
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def predicted_items
-        [@items.first]
-      end
-
-      # Return the reduce item (i.e. the dotted item with the dot at end)
-      # for this production.
-      # @return [Array<GrmAnalysis::DottedItem>]
-      def reduce_items
-        [@items.last]
-      end
-
-      # Return the next item given the provided item.
-      # In other words, advance the dot by one position.
-      # @param anItem [GrmAnalysis::DottedItem]
-      # @return [GrmAnalysis::DottedItem|NilClass]
-      def next_item(anItem)
-        return nil if anItem == @items.last
-
-        @items[anItem.position + 1]
-      end
-    end # module
-  end # module
-end # module

data/lib/dendroid/syntax/choice.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rule'
-
-module Dendroid
-  module Syntax
-    # A specialization of the Rule class.
-    # A choice is a rule with multiple rhs
-    class Choice < Rule
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      attr_reader :alternatives
-
-      # Create a Choice instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      # @param alt [Array<Dendroid::Syntax::SymbolSeq>] the alternatives (each as a sequence of symbols).
-      def initialize(lhs, alt)
-        super(lhs)
-        @alternatives = valid_alternatives(alt)
-      end
-
-      # Predicate method to check whether the rule has alternatives
-      # @return [TrueClass]
-      def choice?
-        true
-      end
-
-      # Return the text representation of the choice
-      # @return [String]
-      def to_s
-        "#{head} => #{alternatives.join(' | ')}"
-      end
-
-      # Predicate method to check whether the choice rule body is productive.
-      # It is productive when at least of its alternative is productive.
-      # @return [Boolean]
-      def productive?
-        productive_alts = alternatives.select(&:productive?)
-        return false if productive_alts.empty?
-
-        @productive = Set.new(productive_alts)
-        head.productive = true
-      end
-
-      # Predicate method to check whether the rule has at least one empty alternative.
-      # @return [Boolean]
-      def empty?
-        alternatives.any?(&:empty?)
-      end
-
-      # Returns an array with the symbol sequence of its alternatives
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      def rhs
-        alternatives
-      end
-
-      # Equality operator
-      # Two production rules are equal when their head and alternatives are equal.
-      # @return [Boolean]
-      def ==(other)
-        return true if equal?(other)
-        return false if other.is_a?(Production)
-
-        (head == other.head) && (alternatives == other.alternatives)
-      end
-
-      private
-
-      def valid_alternatives(alt)
-        raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
-
-        if alt.size < 2
-          # A choice must have at least two alternatives
-          raise StandardError, "The choice for `#{head}` must have at least two alternatives."
-        end
-
-        # Verify that each array element is a valid symbol sequence
-        alt.each { |elem| valid_sequence(elem) }
-
-        # Fail when duplicate rhs found
-        alt_texts = alt.map(&:to_s)
-        no_duplicate = alt_texts.uniq
-        if alt_texts.size > no_duplicate.size
-          alt_texts.each_with_index do |str, i|
-            next if str == no_duplicate[i]
-
-            err_msg = "Duplicate alternatives: #{head} => #{alt_texts[i]}"
-            raise StandardError, err_msg
-          end
-        end
-
-        alt
-      end
-    end # class
-  end # module
-end # module

data/lib/dendroid/syntax/production.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'rule'
-
-module Dendroid
-  module Syntax
-    # A specialization of the Rule class.
-    # A production is a rule with a single rhs
-    class Production < Rule
-      # @return [Dendroid::Syntax::SymbolSeq]
-      attr_reader :body
-
-      # Create a Production instance.
-      # @param lhs [Dendroid::Syntax::NonTerminal] The left-hand side of the rule.
-      # @param rhs [Dendroid::Syntax::SymbolSeq] the sequence of symbols on rhs.
-      def initialize(lhs, rhs)
-        super(lhs)
-        @body = valid_sequence(rhs)
-      end
-
-      # Predicate method to check whether the rule body (its rhs) is empty.
-      # @return [Boolean]
-      def empty?
-        body.empty?
-      end
-
-      # Predicate method to check whether the rule has alternatives
-      # @return [FalseClass]
-      def choice?
-        false
-      end
-
-      # Predicate method to check whether the production rule body is productive.
-      # It is productive when it is empty or all of its rhs members are productive too.
-      # @return [Boolean, NilClass]
-      def productive?
-        if @productive.nil?
-          if body.productive?
-            self.productive = true
-          else
-            nil
-          end
-        else
-          @productive
-        end
-      end
-
-      # Mark the production rule as non-productive.
-      def non_productive
-        self.productive = false
-      end
-
-      # Return the text representation of the production rule
-      # @return [String]
-      def to_s
-        "#{head} => #{body}"
-      end
-
-      # Equality operator
-      # Two production rules are equal when their head and rhs are equal.
-      # @return [Boolean]
-      def ==(other)
-        return true if equal?(other)
-
-        (head == other.head) && (body == other.body)
-      end
-
-      # Returns an array with the symbol sequence of its rhs
-      # @return [Array<Dendroid::Syntax::SymbolSeq>]
-      def rhs
-        [body]
-      end
-
-      private
-
-      def productive=(val)
-        @productive = val
-        lhs.productive = val
-      end
-    end # class
-  end # module
-end # module

data/spec/dendroid/grm_analysis/alternative_item_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '..\..\spec_helper'
-require_relative '..\..\..\lib\dendroid\syntax\terminal'
-require_relative '..\..\..\lib\dendroid\syntax\non_terminal'
-require_relative '..\..\..\lib\dendroid\syntax\symbol_seq'
-require_relative '..\..\..\lib\dendroid\syntax\production'
-require_relative '..\..\..\lib\dendroid\grm_analysis\alternative_item'
-
-describe Dendroid::GrmAnalysis::DottedItem do
-  # TODO
-end # describe

data/spec/dendroid/grm_analysis/production_items_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../spec_helper'
-require_relative '../../../lib/dendroid/syntax/terminal'
-require_relative '../../../lib/dendroid/syntax/non_terminal'
-require_relative '../../../lib/dendroid/syntax/symbol_seq'
-require_relative '../../../lib/dendroid/syntax/production'
-require_relative '../../../lib/dendroid/grm_analysis/production_items'
-
-describe Dendroid::GrmAnalysis::ProductionItems do
-  let(:num_symb) { Dendroid::Syntax::Terminal.new('NUMBER') }
-  let(:plus_symb) { Dendroid::Syntax::Terminal.new('PLUS') }
-  let(:expr_symb) { Dendroid::Syntax::NonTerminal.new('expression') }
-  let(:rhs) { Dendroid::Syntax::SymbolSeq.new([num_symb, plus_symb, num_symb]) }
-  let(:empty_body) { Dendroid::Syntax::SymbolSeq.new([]) }
-  let(:prod) { Dendroid::Syntax::Production.new(expr_symb, rhs) }
-  let(:empty_prod) do
-    e = Dendroid::Syntax::Production.new(expr_symb, empty_body)
-    e.extend(Dendroid::GrmAnalysis::ProductionItems)
-    e.build_items
-    e
-  end
-
-  subject do
-    prod.extend(Dendroid::GrmAnalysis::ProductionItems)
-    prod.build_items
-    prod
-  end
-
-  context 'Methods from mix-in' do
-    it 'builds items for given non-empty production' do
-      expect(subject.items.size).to eq(subject.body.size + 1)
-      subject.items.each_with_index do |item, index|
-        expect(item.rule).to eq(subject)
-        expect(item.position).to eq(index)
-      end
-    end
-
-    it 'builds the item for given empty production' do
-      expect(empty_prod.items.size).to eq(1)
-      expect(empty_prod.items[0].rule).to eq(empty_prod)
-      expect(empty_prod.items[0].position).to eq(0)
-    end
-
-    it 'returns the first (predicted) item of the production' do
-      expect(subject.predicted_items).to eq([subject.items.first])
-      expect(empty_prod.predicted_items).to eq([empty_prod.items.first])
-    end
-
-    it 'returns the last (reduce) item of the production' do
-      expect(subject.reduce_items).to eq([subject.items.last])
-      expect(empty_prod.reduce_items).to eq([empty_prod.items.first])
-    end
-
-    # rubocop: disable Style/EachForSimpleLoop
-    it 'returns the consecutive item to a given one' do
-      (0..2).each do |pos|
-        curr_item = subject.items[pos]
-        next_one = subject.next_item(curr_item)
-        expect(next_one).to eq(subject.items[pos + 1])
-      end
-      expect(subject.next_item(subject.items[-1])).to be_nil
-
-      expect(empty_prod.next_item(empty_prod.items[-1])).to be_nil
-    end
-    # rubocop: enable Style/EachForSimpleLoop
-  end # context
-end # describe