rley 0.3.04 → 0.3.05

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -1,82 +1,84 @@
-require_relative '../../spec_helper'
-
-require_relative '../../../lib/rley/parser/gfg_earley_parser'
-
-require_relative '../../../lib/rley/syntax/grammar_builder'
-require_relative '../support/grammar_helper'
-require_relative '../support/expectation_helper'
-
-# Load the class under test
-require_relative '../../../lib/rley/parser/parse_forest_factory'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser
-    describe ParseForestFactory do
-      include GrammarHelper     # Mix-in with token factory method
-      include ExpectationHelper # Mix-in with expectation on parse entry sets
-
-      let(:sample_grammar) do
-          # Grammar based on paper from Elisabeth Scott
-          # "SPPF=Style Parsing From Earley Recognizers" in
-          # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
-          # contains a hidden left recursion and a cycle
-          builder = Syntax::GrammarBuilder.new
-          builder.add_terminals('a', 'b')
-          builder.add_production('Phi' => %'S')
-          builder.add_production('S' => %w[A T])
-          builder.add_production('S' => %w[a T])
-          builder.add_production('A' => 'a')
-          builder.add_production('A' => %w[B A])
-          builder.add_production('B' => [])
-          builder.add_production('T' => %w( b b b))
-          builder.grammar
-      end
-
-      let(:sample_tokens) do
-        build_token_sequence(%w(a b b b), sample_grammar)
-      end
-
-      let(:sample_result) do
-        parser = Parser::GFGEarleyParser.new(sample_grammar)
-        parser.parse(sample_tokens)
-      end
-
-
-      subject do
-        ParseForestFactory.new(sample_result)
-      end
-
-      # Emit a text representation of the current path.
-      def path_to_s()
-        text_parts = subject.curr_path.map { |path_element|  path_element.to_string(0) }
-        return text_parts.join('/')
-      end
-
-
-      context 'Initialization:' do
-        it 'should be created with a GFGParsing' do
-          expect { ParseForestFactory.new(sample_result) }.not_to raise_error
-        end
-
-        it 'should know the parse result' do
-          expect(subject.parsing).to eq(sample_result)
-        end
-      end
-      
-      context 'Parse forest construction' do
-        it 'should build a parse forest' do
-          forest = subject.build_parse_forest
-          expect(forest).to be_kind_of(SPPF::ParseForest)
-=begin          
-          require 'yaml' 
-          require_relative '../../../exp/lab/forest_representation'           
-          File.open("forest.yml", "w") { |f| YAML.dump(forest, f) }
-          pen = ForestRepresentation.new
-          pen.generate_graph(forest, File.open("forest.dot", "w")) 
-=end          
-        end        
-      end # context      
-    end # describe
-  end # module
-end # module
-# End of file      
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
+
+require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../support/grammar_helper'
+require_relative '../support/expectation_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/parse_forest_factory'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser
+    describe ParseForestFactory do
+      include GrammarHelper     # Mix-in with token factory method
+      include ExpectationHelper # Mix-in with expectation on parse entry sets
+
+      let(:sample_grammar) do
+          # Grammar based on paper from Elisabeth Scott
+          # "SPPF=Style Parsing From Earley Recognizers" in
+          # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
+          # contains a hidden left recursion and a cycle
+          builder = Syntax::GrammarBuilder.new
+          builder.add_terminals('a', 'b')
+          builder.add_production('Phi' => 'S')
+          builder.add_production('S' => %w(A T))
+          builder.add_production('S' => %w(a T))
+          builder.add_production('A' => 'a')
+          builder.add_production('A' => %w(B A))
+          builder.add_production('B' => [])
+          builder.add_production('T' => %w(b b b))
+          builder.grammar
+      end
+
+      let(:sample_tokens) do
+        build_token_sequence(%w(a b b b), sample_grammar)
+      end
+
+      let(:sample_result) do
+        parser = Parser::GFGEarleyParser.new(sample_grammar)
+        parser.parse(sample_tokens)
+      end
+
+
+      subject do
+        ParseForestFactory.new(sample_result)
+      end
+
+      # Emit a text representation of the current path.
+      def path_to_s()
+        text_parts = subject.curr_path.map do |path_element|
+          path_element.to_string(0)
+        end
+        return text_parts.join('/')
+      end
+
+
+      context 'Initialization:' do
+        it 'should be created with a GFGParsing' do
+          expect { ParseForestFactory.new(sample_result) }.not_to raise_error
+        end
+
+        it 'should know the parse result' do
+          expect(subject.parsing).to eq(sample_result)
+        end
+      end
+
+      context 'Parse forest construction' do
+        it 'should build a parse forest' do
+          forest = subject.build_parse_forest
+          expect(forest).to be_kind_of(SPPF::ParseForest)
+=begin
+          require 'yaml'
+          require_relative '../../../exp/lab/forest_representation'
+          File.open("forest.yml", "w") { |f| YAML.dump(forest, f) }
+          pen = ForestRepresentation.new
+          pen.generate_graph(forest, File.open("forest.dot", "w"))
+=end
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+# End of file

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -45,13 +45,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           # contains a hidden left recursion and a cycle
           builder = Syntax::GrammarBuilder.new
           builder.add_terminals('a', 'b')
-          builder.add_production('Phi' => %'S')
-          builder.add_production('S' => %w[A T])
-          builder.add_production('S' => %w[a T])
+          builder.add_production('Phi' => 'S')
+          builder.add_production('S' => %w(A T))
+          builder.add_production('S' => %w(a T))
           builder.add_production('A' => 'a')
-          builder.add_production('A' => %w[B A])
+          builder.add_production('A' => %w(B A))
           builder.add_production('B' => [])
-          builder.add_production('T' => %w( b b b))
+          builder.add_production('T' => %w(b b b))
           builder.grammar
       end
 
@@ -77,7 +77,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Parse graph traversal:' do
         it 'should create an Enumerator as a walker' do
-          expect(subject.build_walker(accept_entry, accept_index)).to be_kind_of(Enumerator)
+          entry = accept_entry
+          index = accept_index
+          expect(subject.build_walker(entry, index)).to be_kind_of(Enumerator)
         end
 
         it 'should return the accepting parse entry in the first place' do
@@ -247,11 +249,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           walker = subject.build_walker(accept_entry, accept_index)
           37.times { walker.next }
 
-          expect{ walker.next }.to raise_error(StopIteration)
+          expect { walker.next }.to raise_error(StopIteration)
         end
-
       end # context
     end # describe
   end # module
 end # module
-# End of file
+# End of file

data/spec/rley/parser/parsing_spec.rb

@@ -170,7 +170,6 @@ SNIPPET
           return [state_tracker, builder]
         end
 
-# Spiff
         it 'should create the root of a parse tree' do
           (state_tracker, builder) = prepare_parse_tree(subject)
           # The root node should correspond to the start symbol and

data/spec/rley/sppf/alternative_node_spec.rb

@@ -33,7 +33,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Construction:' do
         it 'should be created with a item vertex and a token range' do
-          expect { AlternativeNode.new(sample_vertex, sample_range) }.not_to raise_error
+          expect { AlternativeNode.new(sample_vertex, sample_range) }
+            .not_to raise_error
         end      
       end
       
@@ -64,7 +65,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.to_string(0)).to eq('Alt(sentence => A B C .)[0, 3]')
         end
       end # context
-
     end # describe
   end # module
 end # module

data/spec/rley/sppf/non_terminal_node_spec.rb

@@ -56,7 +56,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.to_string(0)).to eq('VP[0, 3]')
         end
       end # context
-
     end # describe
   end # module
 end # module

data/spec/rley/support/ambiguous_grammar_helper.rb

@@ -26,7 +26,7 @@ module AmbiguousGrammarHelper
           terminal = aGrammar.name2symbol['id']
         else
           msg = "Unknown input text '#{lexeme}'"
-          fail StandardError, msg
+          raise StandardError, msg
       end
       Rley::Parser::Token.new(lexeme, terminal)
     end

data/spec/rley/support/expectation_helper.rb

@@ -1,36 +1,37 @@
-# Load the builder class
-require_relative '../../../lib/rley/parser/token'
-
-
-# Mixin module implementing expectation helper methods.
-module ExpectationHelper
-  # Helper method. Compare the data from all the parse entries
-  # of a given ParseEntrySet with an array of expectation strings.
-  def compare_entry_texts(anEntrySet, expectations)
-    (0...expectations.size).each do |i|
-      expect(anEntrySet.entries[i].to_s).to eq(expectations[i])
-    end
-  end
-
-  # Helper method. Compare the antecedents from all the parse entries
-  # of a given ParseEntrySet at given position with a Hash of the form:
-  # consequent label => [ antecedent label(s) ]
-  def check_antecedence(aParsing, aPosition, expectations)
-    entry_set = aParsing.chart[aPosition]
-    
-    expectations.each do |consequent_label, antecedent_labels|
-      consequent = entry_set.entries.find do |entry| 
-        entry.to_s == consequent_label
-      end
-      actual_antecedents = aParsing.antecedence.fetch(consequent)
-      expect(actual_antecedents.map(&:to_s)).to eq(antecedent_labels)
-    end
-  end
-
-
-  def expected_terminals(anEntrySet, termNames)
-    terminals = anEntrySet.expected_terminals
-    actual_names = terminals.map(&:name)
-    expect(actual_names.sort).to eq(termNames.sort)
-  end
-end # module
+# Load the builder class
+require_relative '../../../lib/rley/parser/token'
+
+
+# Mixin module implementing expectation helper methods.
+module ExpectationHelper
+  # Helper method. Compare the data from all the parse entries
+  # of a given ParseEntrySet with an array of expectation strings.
+  def compare_entry_texts(anEntrySet, expectations)
+    (0...expectations.size).each do |i|
+      expect(anEntrySet.entries[i].to_s).to eq(expectations[i])
+    end
+  end
+
+  # Helper method. Compare the antecedents from all the parse entries
+  # of a given ParseEntrySet at given position with a Hash of the form:
+  # consequent label => [ antecedent label(s) ]
+  def check_antecedence(aParsing, aPosition, expectations)
+    entry_set = aParsing.chart[aPosition]
+
+    expectations.each do |consequent_label, antecedent_labels|
+      consequent = entry_set.entries.find do |entry|
+        entry.to_s == consequent_label
+      end
+      actual_antecedents = aParsing.antecedence.fetch(consequent)
+      expect(actual_antecedents.map(&:to_s)).to eq(antecedent_labels)
+    end
+  end
+
+
+  def expected_terminals(anEntrySet, termNames)
+    terminals = anEntrySet.expected_terminals
+    actual_names = terminals.map(&:name)
+    expect(actual_names.sort).to eq(termNames.sort)
+  end
+end # module
+# End of file

data/spec/rley/support/grammar_abc_helper.rb

@@ -1,17 +1,17 @@
-# Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
-
-
-module GrammarABCHelper
-  # Factory method. Creates a grammar builder for a simple grammar.
-  # (based on example in N. Wirth "Compiler Construction" book, p. 6)
-  def grammar_abc_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('a', 'b', 'c')
-    builder.add_production('S' => 'A')
-    builder.add_production('A' => %w(a A c))
-    builder.add_production('A' => 'b')
-
-    return builder
-  end
-end # module
+# Load the builder class
+require_relative '../../../lib/rley/syntax/grammar_builder'
+
+module GrammarABCHelper
+  # Factory method. Creates a grammar builder for a simple grammar.
+  # (based on example in N. Wirth "Compiler Construction" book, p. 6)
+  def grammar_abc_builder()
+    builder = Rley::Syntax::GrammarBuilder.new
+    builder.add_terminals('a', 'b', 'c')
+    builder.add_production('S' => 'A')
+    builder.add_production('A' => %w(a A c))
+    builder.add_production('A' => 'b')
+
+    return builder
+  end
+end # module
+# End of file

data/spec/rley/support/grammar_b_expr_helper.rb

@@ -1,39 +1,40 @@
-# Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
-require_relative '../../../lib/rley/parser/token'
-
-
-module GrammarBExprHelper
-  # Factory method. Creates a grammar builder for a basic arithmetic
-  # expression grammar.
-  # (based on the article about Earley's algorithm in Wikipedia)
-  def grammar_expr_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('+', '*', 'integer')
-    builder.add_production('P' => 'S')
-    builder.add_production('S' => %w(S + M))
-    builder.add_production('S' => 'M')
-    builder.add_production('M' => %w(M * T))
-    builder.add_production('M' => 'T')
-    builder.add_production('T' => 'integer')
-    builder
-  end
-  
-  # Basic expression tokenizer
-  def expr_tokenizer(aText, aGrammar)
-    tokens = aText.scan(/\S+/).map do |lexeme|
-      case lexeme
-        when '+', '*'
-          terminal = aGrammar.name2symbol[lexeme]
-        when /^[-+]?\d+$/
-          terminal = aGrammar.name2symbol['integer']
-        else
-          msg = "Unknown input text '#{lexeme}'"
-          fail StandardError, msg
-      end
-      Rley::Parser::Token.new(lexeme, terminal)
-    end
-    
-    return tokens
-  end
-end # module
+# Load the builder class
+require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../../../lib/rley/parser/token'
+
+
+module GrammarBExprHelper
+  # Factory method. Creates a grammar builder for a basic arithmetic
+  # expression grammar.
+  # (based on the article about Earley's algorithm in Wikipedia)
+  def grammar_expr_builder()
+    builder = Rley::Syntax::GrammarBuilder.new
+    builder.add_terminals('+', '*', 'integer')
+    builder.add_production('P' => 'S')
+    builder.add_production('S' => %w(S + M))
+    builder.add_production('S' => 'M')
+    builder.add_production('M' => %w(M * T))
+    builder.add_production('M' => 'T')
+    builder.add_production('T' => 'integer')
+    builder
+  end
+
+  # Basic expression tokenizer
+  def expr_tokenizer(aText, aGrammar)
+    tokens = aText.scan(/\S+/).map do |lexeme|
+      case lexeme
+        when '+', '*'
+          terminal = aGrammar.name2symbol[lexeme]
+        when /^[-+]?\d+$/
+          terminal = aGrammar.name2symbol['integer']
+        else
+          msg = "Unknown input text '#{lexeme}'"
+          raise StandardError, msg
+      end
+      Rley::Parser::Token.new(lexeme, terminal)
+    end
+
+    return tokens
+  end
+end # module
+# End of file

data/spec/rley/support/grammar_helper.rb

@@ -25,4 +25,5 @@ module GrammarHelper
 
     return tokens.flatten
   end
-end # module
+end # module
+# End of file