rley 0.2.15 → 0.3.00

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -0,0 +1,81 @@
+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
+=begin      
+      context 'Parse forest construction' do
+        it 'should build a parse forest' do
+          forest = subject.build_parse_forest
+          
+          require 'yaml' 
+          require_relative '../sppf/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 # context
+=end      
+    end # describe
+  end # module
+end # module
+# End of file      

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -0,0 +1,235 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/grammar_builder'
+require_relative '../support/grammar_helper'
+require_relative '../support/expectation_helper'
+
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/parse_walker_factory'
+
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser
+    describe ParseWalkerFactory do
+      include GrammarHelper     # Mix-in with token factory method
+      include ExpectationHelper # Mix-in with expectation on parse entry sets
+
+      # Helper method use to check wether a visit event
+      # matches the given expectations
+      # The expectations form an array with the given elements:
+      # [0] => the event symbol (:visit)
+      # [1] => the parse entry being visited
+      # [2] => the index of the parse entry set to which the visitee belongs to
+      def event_expectations(anEvent, expectations)
+        visit_event, entry, index = anEvent
+        expect(visit_event).to eq(expectations[0])
+        if expectations[1].is_a?(String)
+          case entry
+            when Parser::ParseEntry
+              expect(entry.to_s).to eq(expectations[1])
+            when Parser::Token
+              expect(entry.lexeme).to eq(expectations[1])
+          end
+        else
+          expect(entry).to eq(expectations[1])
+        end
+        expect(index).to eq(expectations[2])
+      end
+
+      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
+
+      let(:subject) { ParseWalkerFactory.new }
+
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { ParseWalkerFactory.new }.not_to raise_error
+        end
+      end # context
+
+      context 'Parse graph traversal:' do
+        it 'should create an Enumerator as a walker' do
+          expect(subject.build_walker(sample_result)).to be_kind_of(Enumerator)
+        end
+
+        it 'should return the accepting parse entry in the first place' do
+          walker = subject.build_walker(sample_result)
+          first_event = walker.next
+          expectations = [:visit, sample_result.accepting_entry, 4]
+          event_expectations(first_event, expectations)
+        end
+
+        it 'should traverse the parse graph backwards' do
+          walker = subject.build_walker(sample_result)
+          event1 = walker.next
+          expectations = [:visit, 'Phi. | 0', 4]
+          event_expectations(event1, expectations)
+
+          event2 = walker.next
+          expectations = [:visit, 'Phi => S . | 0', 4]
+          event_expectations(event2, expectations)
+
+          event3 = walker.next
+          expectations = [:visit, 'S. | 0', 4]
+          event_expectations(event3, expectations)
+          
+          # Backtrack created: first alternative selected
+          event4 = walker.next
+          expectations = [:visit, 'S => a T . | 0', 4]
+          event_expectations(event4, expectations)
+
+          event5 = walker.next
+          expectations = [:visit, 'T. | 1', 4]
+          event_expectations(event5, expectations)
+
+          event6 = walker.next
+          expectations = [:visit, 'T => b b b . | 1', 4]
+          event_expectations(event6, expectations)        
+          
+          event7 = walker.next
+          expectations = [:visit, 'T => b b . b | 1', 3]
+          event_expectations(event7, expectations)      
+
+          event8 = walker.next
+          expectations = [:visit, 'T => b . b b | 1', 2]
+          event_expectations(event8, expectations)       
+          
+          event9 = walker.next
+          expectations = [:visit, 'T => . b b b | 1', 1]
+          event_expectations(event9, expectations)
+
+          event10 = walker.next
+          expectations = [:visit, '.T | 1', 1]
+          event_expectations(event10, expectations)
+
+          event11 = walker.next
+          expectations = [:visit, 'S => a . T | 0', 1]
+          event_expectations(event11, expectations)
+
+          event12 = walker.next
+          expectations = [:visit, 'S => . a T | 0', 0]
+          event_expectations(event12, expectations)
+
+          event13 = walker.next
+          expectations = [:visit, '.S | 0', 0]
+          event_expectations(event13, expectations)
+
+          event14 = walker.next
+          expectations = [:visit, 'Phi => . S | 0', 0]
+          event_expectations(event14, expectations) 
+
+          event15 = walker.next
+          expectations = [:visit, '.Phi | 0', 0]
+          event_expectations(event15, expectations)
+
+          # Backtracking is occurring
+          event16 = walker.next
+          expectations = [:backtrack, 'S. | 0', 4]
+          event_expectations(event16, expectations)          
+          
+          event18 = walker.next
+          expectations = [:visit, 'S => A T . | 0', 4]
+          event_expectations(event18, expectations)
+
+          event19 = walker.next
+          expectations = [:revisit, 'T. | 1', 4]
+          event_expectations(event19, expectations)
+
+          # Multiple visit occurred: jump to antecedent of start entry
+          event20 = walker.next
+          expectations = [:visit, 'S => A . T | 0', 1]
+          event_expectations(event20, expectations)
+
+          event21 = walker.next
+          expectations = [:visit, 'A. | 0', 1]
+          event_expectations(event21, expectations)
+          
+          # Backtrack created: first alternative selected
+          event22 = walker.next
+          expectations = [:visit, 'A => a . | 0', 1]
+          event_expectations(event22, expectations)                     
+          
+          event23 = walker.next
+          expectations = [:visit, 'A => . a | 0', 0]
+          event_expectations(event23, expectations)
+
+          event24 = walker.next
+          expectations = [:visit, '.A | 0', 0]
+          event_expectations(event24, expectations)
+
+          event25 = walker.next
+          expectations = [:visit, 'S => . A T | 0', 0]
+          event_expectations(event25, expectations)
+
+          # Backtracking is occurring
+          event26 = walker.next
+          expectations = [:backtrack, 'A. | 0', 1]
+          event_expectations(event26, expectations)          
+          
+          event27 = walker.next
+          expectations = [:visit, 'A => B A . | 0', 1]
+          event_expectations(event27, expectations)
+          
+          event28 = walker.next
+          expectations = [:revisit, 'A. | 0', 1]
+          event_expectations(event28, expectations)
+
+          event29 = walker.next
+          expectations = [:visit, 'A => B . A | 0', 0]
+          event_expectations(event29, expectations)           
+
+          event30 = walker.next
+          expectations = [:visit, 'B. | 0', 0]
+          event_expectations(event30, expectations)
+
+          event31 = walker.next
+          expectations = [:visit, 'B => . | 0', 0]
+          event_expectations(event31, expectations)
+
+          event32 = walker.next
+          expectations = [:visit, '.B | 0', 0]
+          event_expectations(event32, expectations)  
+
+          event33 = walker.next
+          expectations = [:visit, 'A => . B A | 0', 0]
+          event_expectations(event33, expectations)        
+        end
+        
+        it 'should raise an exception at end of visit' do
+          walker = subject.build_walker(sample_result)
+          32.times { walker.next }
+          
+          expect{ walker.next }.to raise_error(StopIteration)
+        end
+
+      end # context
+    end # describe
+  end # module
+end # module
+# End of file

data/spec/rley/parser/state_set_spec.rb

@@ -17,6 +17,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should be created without argument' do
           expect { StateSet.new }.not_to raise_error
         end
+        
+        it 'should be empty at creation' do
+          expect(subject.states).to be_empty
+        end
       end # context
 
       context 'Provided services:' do

data/spec/rley/sppf/alternative_node_spec.rb

@@ -0,0 +1,72 @@
+require 'ostruct'
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/gfg/item_vertex'
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/ptree/token_range'
+require_relative '../../../lib/rley/parser/dotted_item'
+
+# Load the class under test
+require_relative '../../../lib/rley/sppf/alternative_node'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module SPPF # Open this namespace to avoid module qualifier prefixes
+    describe AlternativeNode do
+      # Factory method. Generate a range from its boundary values.
+      def range(low, high)
+        return PTree::TokenRange.new(low: low, high: high)
+      end
+      
+      let(:t_a) { Syntax::Terminal.new('A') }
+      let(:t_b) { Syntax::Terminal.new('B') }
+      let(:t_c) { Syntax::Terminal.new('C') }
+      let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
+      let(:sample_prod) do
+        Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
+      end
+      let(:sample_item) { Parser::DottedItem.new(sample_prod, 3) }
+      let(:sample_vertex) { GFG::ItemVertex.new(sample_item) }
+      let(:sample_range) { range(0, 3) }      
+
+      subject { AlternativeNode.new(sample_vertex, sample_range) }
+
+      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
+        end      
+      end
+      
+      context 'Initialization:' do
+        it 'should know its token range' do
+          expect(subject.range).to eq(sample_range)
+          expect(subject.origin).to eq(sample_range.low)
+        end
+
+        it "shouldn't have children yet" do
+          expect(subject.subnodes).to be_empty
+        end
+      end # context
+      
+      context 'Provided services:' do
+        it 'should accept the addition of subnodes' do
+          subnode1 = double('first_subnode')
+          subnode2 = double('second_subnode')
+          subnode3 = double('third_subnode')
+          expect { subject.add_subnode(subnode1) }.not_to raise_error
+          subject.add_subnode(subnode2)
+          subject.add_subnode(subnode3)
+          expect(subject.subnodes).to eq([subnode3, subnode2, subnode1])
+        end
+
+
+        it 'should have a string representation' do    
+          expect(subject.to_string(0)).to eq('Alt(sentence => A B C .)[0, 3]')
+        end
+      end # context
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/sppf/antecedence_graph.rb

@@ -0,0 +1,87 @@
+# Mix-in module that generates a Graphviz's DOT file
+# that represents the precedence graph of parse entries.
+module AntecedenceGraph
+
+  def generate_graph(aParsing, aFile)
+    heading = build_heading()
+    aFile.puts(heading)
+    
+    fill_graph(aParsing, aFile)
+    
+    trailing = build_trailing()
+    aFile.puts(trailing)
+  end
+  
+private
+
+  def build_heading()
+    text = <<-END_STRING
+  digraph entries {
+  size = "7,9.5";
+  page = "8.5,11";
+  ratio = fill;
+  rankdir = "BT"; // Draw arrows from bottom to top
+END_STRING
+
+    return text
+  end
+  
+  def build_trailing()
+    return '}'
+  end
+  
+  def fill_graph(aParsing, aFile)
+    # Associate to each parse entry a node id
+    oid2node_id = build_nodes_id(aParsing)
+    aParsing.chart.sets.each_with_index do |entry_set, chart_index|
+      # Create the graph nodes
+      aFile.puts ''
+      aFile.puts(cluster_heading(chart_index))
+      
+      entry_set.entries.each do |entry|
+        aFile.puts %Q(    #{oid2node_id[entry]}[label="#{entry}"];)
+      end
+      aFile.puts '  }'  # Close cluster
+      
+      # Create the edges
+      aFile.puts ''
+      entry_set.entries.each do |entry|
+        antecedents = aParsing.antecedence[entry]
+        antecedents.each do |antec|
+          aFile.puts "  #{oid2node_id[antec]} -> #{oid2node_id[entry]};"
+        end
+      end      
+    end    
+  end
+  
+  # For each parse entry, associate a graph node id
+  def build_nodes_id(aParsing)
+    # Create a Hash with pairs of the form: object id => node id
+    oid2node_id = {} 
+    
+    aParsing.chart.sets.each_with_index do |entry_set, chart_index|
+      entry_set.entries.each_with_index do |entry, entry_index|
+        oid2node_id[entry] = "node_#{chart_index}_#{entry_index}"
+      end
+    end
+
+    return oid2node_id
+  end
+
+  
+  def cluster_heading(anIndex)
+    text = <<-END_STRING
+  subgraph cluster_chart_#{anIndex} {
+    style = rounded;
+    color = blue;
+    fontsize = 24.0;
+    labeljust = "r";    
+    label="chart[#{anIndex}]";
+END_STRING
+
+  return text
+  end
+  
+  
+
+end # module