rley 0.7.03 → 0.7.08

data/spec/rley/parse_rep/parse_forest_factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
@@ -23,12 +25,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           builder = Syntax::GrammarBuilder.new do
             add_terminals('a', 'b')
             rule 'Phi' => 'S'
-            rule 'S' => %w[A T]
-            rule 'S' => %w[a T]
+            rule 'S' => 'A T'
+            rule 'S' => 'a T'
             rule 'A' => 'a'
-            rule 'A' => %w[B A]
+            rule 'A' => 'B A'
             rule 'B' => []
-            rule 'T' => %w[b b b]
+            rule 'T' => 'b b b'
           end
           builder.grammar
       end
@@ -47,11 +49,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       # Emit a text representation of the current path.
-      def path_to_s()
+      def path_to_s
         text_parts = subject.curr_path.map do |path_element|
           path_element.to_string(0)
         end
-        return text_parts.join('/')
+        text_parts.join('/')
       end
 
       context 'Initialization:' do

data/spec/rley/parse_rep/parse_tree_factory_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
@@ -36,11 +38,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       # Emit a text representation of the current path.
-      def path_to_s()
+      def path_to_s
         text_parts = subject.curr_path.map do |path_element|
           path_element.to_string(0)
         end
-        return text_parts.join('/')
+        text_parts.join('/')
       end
 
 

data/spec/rley/parse_tree_visitor_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper'
 
 require_relative '../../lib/rley/lexical/token'
@@ -9,7 +11,7 @@ require_relative './support/grammar_sppf_helper'
 require_relative '../../lib/rley/parse_tree_visitor'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  describe ParseTreeVisitor do    
+  describe ParseTreeVisitor do
     let(:grammar_abc) do
       sandbox = Object.new
       sandbox.extend(GrammarABCHelper)
@@ -43,7 +45,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
     # Capital letters represent non-terminal nodes
     let(:grm_abc_ptree1) do
       engine = Rley::Engine.new
-      engine.use_grammar(grammar_abc)     
+      engine.use_grammar(grammar_abc)
       parse_result = engine.parse(grm_abc_tokens1)
       ptree = engine.convert(parse_result)
       ptree
@@ -159,6 +161,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         subject.end_visit_ptree(grm_abc_ptree1)
       end
 
+      # rubocop: disable Naming/VariableNumber
       it 'should begin the visit when requested' do
         # Reminder: parse tree structure is
         # S[0,5]
@@ -207,11 +210,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations.each do |(msg, args)|
           expect(listener1).to receive(msg).with(*args).ordered
         end
-        
+
         # Here we go...
         subject.start
       end
-      
+
       it 'should also visit in pre-order' do
         # Reminder: parse tree structure is
         # S[0,5]
@@ -226,7 +229,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         root = grm_abc_ptree1.root
         # Here we defeat encapsulation for the good cause
         subject.instance_variable_set(:@traversal, :pre_order)
-        
+
         children = root.subnodes
         big_a_1 = children[0]
         big_a_1_children = big_a_1.subnodes
@@ -237,7 +240,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations = [
           [:before_ptree, [grm_abc_ptree1]]
           # TODO: fix this test
-          # [:before_subnodes, [root, children]],          
+          # [:before_subnodes, [root, children]],
           # [:before_non_terminal, [root]],
 
           # [:before_non_terminal, [big_a_1]],
@@ -265,10 +268,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         expectations.each do |(msg, args)|
           expect(listener1).to receive(msg).with(*args).ordered
         end
-        
+
         # Here we go...
         subject.start
-      end      
+      end
+      # rubocop: enable Naming/VariableNumber
     end # context
   end # describe
 end # module

data/spec/rley/parser/error_reason_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require_relative '../../../lib/rley/lexical/token'
 
@@ -44,8 +46,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            ExpectationNotMet.new(3, err_token, terminals) 
+          expect do
+            ExpectationNotMet.new(3, err_token, terminals)
           end.not_to raise_error
         end
 
@@ -73,8 +75,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            UnexpectedToken.new(3, err_token, terminals) 
+          expect do
+            UnexpectedToken.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context
@@ -105,8 +107,8 @@ MESSAGE_END
 
       context 'Initialization:' do
         it 'should be created with arguments' do
-          expect do 
-            PrematureInputEnd.new(3, err_token, terminals) 
+          expect do
+            PrematureInputEnd.new(3, err_token, terminals)
           end.not_to raise_error
         end
       end # context

data/spec/rley/parser/gfg_chart_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require 'stringio'
 
@@ -75,13 +77,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Provided services:' do
         it 'should accept the pushing of a parse entry in existing set' do
-          expect(subject.sets[0].entries.size).to eq(1)        
+          expect(subject.sets[0].entries.size).to eq(1)
           subject.push_entry(second_vertex, 0, 0, :scan_rule)
           expect(subject.sets[0].entries.size).to eq(2)
         end
-        
+
         it 'should accept the pushing of a parse entry in new set' do
-          expect(subject.sets[0].entries.size).to eq(1)       
+          expect(subject.sets[0].entries.size).to eq(1)
           subject.push_entry(second_vertex, 0, 1, :scan_rule)
           expect(subject.sets[0].entries.size).to eq(1)
           expect(subject.sets.size).to eq(2)
@@ -90,7 +92,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should retrieve an existing set at given position' do
           expect(subject[0]).to eq(subject.sets[0])
-        end        
+        end
+
+        it 'should a user-friendly text representation of itself' do
+          subject.push_entry(second_vertex, 0, 1, :scan_rule)
+          representation = <<REPR
+State[0]
+  .S | 0
+State[1]
+  S => . A | 0
+REPR
+          expect(subject.to_s).to eq(representation)
+        end
       end # context
     end # describe
   end # module

data/spec/rley/parser/gfg_earley_parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require 'stringio'
 require_relative '../../../lib/rley/syntax/verbatim_symbol'
@@ -53,7 +55,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:plus) { Syntax::VerbatimSymbol.new('+') }
       let(:star) { Syntax::VerbatimSymbol.new('*') }
       let(:integer) do
-        integer_pattern = /[-+]?[0-9]+/	# Decimal notation
+        integer_pattern = /[-+]?[0-9]+/ # Decimal notation
         Syntax::Literal.new('integer', integer_pattern)
       end
       let(:prod_P) { Syntax::Production.new(nt_P, [nt_S]) }
@@ -69,7 +71,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by grammar_expr
-      def grm2_tokens()
+      def grm2_tokens
         input_sequence = [
           { '2' => 'integer' },
           '+',
@@ -77,7 +79,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           '*',
           { '4' => 'integer' }
         ]
-        return build_token_sequence(input_sequence, grammar_expr)
+        build_token_sequence(input_sequence, grammar_expr)
       end
 
       # Default instantiation rule
@@ -102,6 +104,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end # context
 
       context 'Parsing: ' do
+        # rubocop: disable Naming/VariableNumber
         it 'should parse a valid simple input' do
           parse_result = subject.parse(grm1_tokens)
           expect(parse_result.success?).to eq(true)
@@ -149,7 +152,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expected = [
             'A => b . | 2',      # scan 'b'
             'A. | 2',            # exit rule
-            'A => a A . c | 1',  # end rule
+            'A => a A . c | 1'   # end rule
           ]
           entry_set_3 = parse_result.chart[3]
           expect(entry_set_3.entries.size).to eq(3)
@@ -181,6 +184,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(entry_set_5.entries.size).to eq(4)
           compare_entry_texts(entry_set_5, expected)
         end
+        # rubocop: enable Naming/VariableNumber
 
         it 'should parse a valid simple expression' do
           instance = GFGEarleyParser.new(grammar_expr)
@@ -284,10 +288,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # A => ;
           t_x = Syntax::VerbatimSymbol.new('x')
 
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals(t_x)
-          builder.add_production('Ss' => %w[A A x])
-          builder.add_production('A' => [])
+          builder = Syntax::GrammarBuilder.new do
+            add_terminals(t_x)
+            rule 'Ss' => 'A A x'
+            rule 'A' => []
+          end
           pos = Lexical::Position.new(1, 1)
           tokens = [Lexical::Token.new('x', t_x, pos)]
 
@@ -406,7 +411,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'P => S . | 0',       # end rule
             "S => S . '+' S | 0", # end rule
             "S => S . '*' S | 0", # end rule
-            'P. | 0',             # exit rule
+            'P. | 0'              # exit rule
           ]
           compare_entry_texts(parse_result.chart[3], expected)
 
@@ -549,7 +554,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'E => E . + E | 2',   # end rule
             'S => E . | 0',       # end rule
             'E => E . + E | 0',   # end rule
-            'S. | 0',             # exit rule
+            'S. | 0'              # exit rule
           ]
           compare_entry_texts(parse_result.chart[5], expected)
         end
@@ -618,7 +623,7 @@ MSG
           ]
           compare_entry_texts(parse_result.chart[2], expected)
 
-          err_msg = "Premature end of input after '+' at position line 1, "
+          err_msg = +"Premature end of input after '+' at position line 1, "
           err_msg << 'column 3'
           err_msg << "\nExpected one of: ['int', '(']."
           expect(parse_result.failure_reason.message).to eq(err_msg)

data/spec/rley/parser/gfg_parsing_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper'
 require 'stringio'
 
@@ -25,7 +27,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       include GrammarABCHelper # Mix-in module with builder for grammar abc
       include GrammarBExprHelper # Mix-in with builder for simple expressions
       include GrammarHelper # Mix-in with method for creating token sequence
-      
+
       # Helper method. Create an array of dotted items
       # from the given grammar
       def build_items_for_grammar(aGrammar)
@@ -93,14 +95,14 @@ SNIPPET
 
       context 'Parsing:' do
         # Utility method to fill the first entry set...
-        def fill_first_set()
+        def fill_first_set
           subject.start_rule(subject.initial_entry, 0)
           subject.call_rule(subject.chart[0].last, 0)
           subject.start_rule(subject.chart[0].last, 0)
         end
 
         # Utility method to initialize the second entry set...
-        def seed_second_set()
+        def seed_second_set
           # Cheating: we change the tokens to scan...
           # Seeding second entry set...
           subject.scan_rule(0, grm1_token_b[0])
@@ -164,7 +166,7 @@ SNIPPET
           expect(subject.chart[0].size).to eq(3)
           # Last entry is: (.A, 0)
           dot_A_entry = subject.chart[0].last
-          
+
           subject.start_rule(dot_A_entry, 0)
 
           # Expectations: two entries:
@@ -194,7 +196,7 @@ SNIPPET
           expect(last_entry.vertex.label).to eq('A => a . A c')
           expect(last_entry.origin).to eq(0)
           antecedence = subject.antecedence
-          expect(antecedence.fetch(last_entry)).to eq([fourth_entry])          
+          expect(antecedence.fetch(last_entry)).to eq([fourth_entry])
         end
 
         it 'should apply the exit rule correctly' do
@@ -219,7 +221,7 @@ SNIPPET
           exit_entry = subject.chart[1].last
           expect(exit_entry.vertex.label).to eq('A.')
           expect(exit_entry.origin).to eq(0)
-          expect(subject.antecedence.fetch(exit_entry)).to eq([last_entry]) 
+          expect(subject.antecedence.fetch(exit_entry)).to eq([last_entry])
         end
 
         it 'should apply the end rule correctly' do
@@ -248,10 +250,8 @@ SNIPPET
           expect(end_entry.origin).to eq(0)
           expect(subject.antecedence.fetch(end_entry)).to eq([exit_entry])
         end
-=begin
-
-
 
+=begin
         it 'should retrieve the parse states that expect a given terminal' do
           item1 = DottedItem.new(prod_A1, 2)
           item2 = DottedItem.new(prod_A1, 1)
@@ -282,18 +282,7 @@ SNIPPET
 =end
       end # context
 
-      context 'Parse forest building:' do
-        let(:sample_grammar1) do
-          builder = grammar_abc_builder
-          builder.grammar
-        end
-
-        let(:token_seq1) do
-          %w[a a b c c].map do |letter|
-            Lexical::Token.new(letter, sample_grammar1.name2symbol[letter])
-          end
-        end
-
+      context 'Provided services:' do
         let(:b_expr_grammar) do
           builder = grammar_expr_builder
           builder.grammar
@@ -308,247 +297,47 @@ SNIPPET
           tokens = expr_tokenizer('2 + 3 * 4')
           parser.parse(tokens)
         end
-        
-        it 'should indicate whether a parse succeeded' do
-          expect(subject.success?).to be_truthy
-        end
-
-        it 'should build a parse forest' do
-          expect { subject.parse_forest }.not_to raise_error if subject.success?
-        end
-=begin
-        it 'should create the root of a parse forest' do
-          (entry_tracker, builder) = prepare_parse_forest(subject)
-          # The root node should correspond to the start symbol and
-          # its direct children should correspond to rhs of start production
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-
-          expect(entry_tracker.entry_set_index).to eq(subject.tokens.size)
-          expected_entry = 'P => S . | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(builder.current_node.to_string(0)).to eq('S[0, 5]')
-        end
-=end
-=begin
-        it 'should use a reduce item for a matched non-terminal' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          # Same entry as in previous example
-
-          # Given matched symbol is S[0, 5]
-          # And its reduce item is S => S + M . | 0
-          # Then add child nodes corresponding to the rhs symbols
-          # And make M[?, 5] the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[?, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'S => S + M . | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          expect(builder.current_node.to_string(0)).to eq('M[?, 5]')
-
-          # Second similar test
-
-          # Given matched symbol is M[?, 5]
-          # And its reduce item is M => M * T . | 2
-          # Then add child nodes corresponding to the rhs symbols
-          # And make T[?, 5] the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[?, 5]
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'M => M * T . | 2'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          expect(builder.current_node.to_string(0)).to eq('T[?, 5]')
-        end
-
-
 
-        it 'should use a previous item for a terminal symbol' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          3.times do
-            subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          # Given matched symbol is T[?, 5]
-          # And its reduce item is T => integer . | 4
-          # Then add child node corresponding to the rhs symbol
-          # And make integer[4, 5]: '(nil)' the current symbol
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '(nil)'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'T => integer . | 4'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(5)
-          integer_repr = "integer[4, 5]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(integer_repr)
-
-          # Given current tree symbol is integer[4, 5]: '(nil)'
-          # And its previous item is T => . integer | 4
-          # Then attach the token to the terminal node
-          # And decrement the entry index by one
-          # Make *[?, ?]: '(nil)' the current symbol
-          subject.insert_matched_symbol(entry_tracker, builder)
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'T => . integer | 4'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(4)
-          next_symbol = "*[?, ?]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
+        it 'should give a text representation of itself' do
+          repr = subject.to_s
+          expect(repr).to match(/^success\? true/)
+
+          # Let's test the last chart state only
+          expectation = <<REPR
+State[5]
+  T => integer . | 4
+  T. | 4
+  M => M * T . | 2
+  M. | 2
+  S => S + M . | 0
+  M => M . * T | 2
+  S. | 0
+  P => S . | 0
+  S => S . + M | 0
+  P. | 0
+REPR
         end
+      end # context
 
-        it 'should handle [no symbol before dot, terminal tree node] case' do
-          # Setup
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          4.times do
-            subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          # Given current tree symbol is *[?, ?]: '(nil)'
-          # And current dotted item is T => . integer | 4
-          # When one retrieves the parse entry expecting the T
-          # Then new parse entry is changed to: M => M * . T | 2
-          subject.insert_matched_symbol(entry_tracker, builder)
-
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, ?]
-   +- +[?, ?]: '(nil)'
-   +- M[2, 5]
-      +- M[2, ?]
-      +- *[?, ?]: '(nil)'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-          expected_entry = 'M => M * . T | 2'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(4)
-          next_symbol = "*[?, ?]: '(nil)'"
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
-
-          subject.insert_matched_symbol(entry_tracker, builder)
-          next_symbol = 'M[2, ?]'
-          expect(builder.current_node.to_string(0)).to eq(next_symbol)
+      context 'Parse forest building:' do
+        let(:b_expr_grammar) do
+          builder = grammar_expr_builder
+          builder.grammar
         end
 
-        it 'should handle the end of parse tree generation' do
-          # Begin setup
-          is_done = false
-          (entry_tracker, builder) = prepare_parse_tree(subject)
-          16.times do
-            is_done = subject.insert_matched_symbol(entry_tracker, builder)
-          end
-
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, 1]
-      +- M[0, 1]
-         +- T[0, 1]
-            +- integer[0, 1]: '2'
-   +- +[1, 2]: '+'
-   +- M[2, 5]
-      +- M[2, 3]
-         +- T[2, 3]
-            +- integer[2, 3]: '3'
-      +- *[3, 4]: '*'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          root_text = builder.root.to_string(0)
-          expect(root_text).to eq(expected_text.chomp)
-
-          expected_entry = 'T => . integer | 0'
-          expect(entry_tracker.parse_entry.to_s).to eq(expected_entry)
-          expect(entry_tracker.entry_set_index).to eq(0)
-          expect(is_done).to eq(true)
+        def grm_symbol(aSymbolName)
+          b_expr_grammar.name2symbol[aSymbolName]
         end
 
-
-
-        it 'should build the parse tree for a simple non-ambiguous grammar' do
-          parser = EarleyParser.new(sample_grammar1)
-          instance = parser.parse(token_seq1)
-          ptree = instance.parse_tree
-          expect(ptree).to be_kind_of(PTree::ParseTree)
+        subject do
+          parser = GFGEarleyParser.new(b_expr_grammar)
+          tokens = expr_tokenizer('3 * 4')
+          parser.parse(tokens)
         end
 
-        it 'should build the parse tree for a simple expression grammar' do
-          parser = EarleyParser.new(b_expr_grammar)
-          tokens = expr_tokenizer('2 + 3 * 4', b_expr_grammar)
-          instance = parser.parse(tokens)
-          ptree = instance.parse_tree
-          expect(ptree).to be_kind_of(PTree::ParseTree)
-
-          # Expect parse tree:
-          expected_text = <<-SNIPPET
-P[0, 5]
-+- S[0, 5]
-   +- S[0, 1]
-      +- M[0, 1]
-         +- T[0, 1]
-            +- integer[0, 1]: '2'
-   +- +[1, 2]: '+'
-   +- M[2, 5]
-      +- M[2, 3]
-         +- T[2, 3]
-            +- integer[2, 3]: '3'
-      +- *[3, 4]: '*'
-      +- T[4, 5]
-         +- integer[4, 5]: '4'
-SNIPPET
-          actual = ptree.root.to_string(0)
-          expect(actual).to eq(expected_text.chomp)
+        it 'should indicate whether a parse succeeded' do
+          expect(subject.success?).to be_truthy
         end
-=end
       end # context
     end # describe
   end # module