rley 0.2.15 → 0.3.00

data/spec/rley/sppf/forest_representation.rb

@@ -0,0 +1,136 @@
+require 'set'
+
+# Mix-in module that generates a Graphviz's DOT file
+# that represents a parse forest.
+class ForestRepresentation
+
+  def generate_graph(aPForest, aFile)
+    heading = build_heading()
+    aFile.puts(heading)
+    
+    fill_graph(aPForest, aFile)
+    
+    trailing = build_trailing()
+    aFile.puts(trailing)
+  end
+  
+private
+
+  def build_heading()
+    text = <<-END_STRING
+  digraph gfg {
+  size="7,9.5";
+  page="8.5,11";
+  ratio = fill;
+
+END_STRING
+
+    return text
+  end
+  
+  def build_trailing()
+    return '}'
+  end
+  
+  def fill_graph(aPForest, aFile)
+    visitees = Set.new
+    visit_node(aPForest.root, aFile, visitees)
+  end
+
+  def visit_node(aNode, aFile, visitees)
+    return if visitees.include?(aNode)
+    visitees << aNode
+    aFile.puts %Q(    node_#{aNode.object_id}[shape=box, fontsize=18.0, label="#{aNode.to_string(0)}"];)
+    
+    if aNode.kind_of?(Rley::SPPF::CompositeNode)
+      aNode.subnodes.each do |snode|
+        # puts snode.to_string(0)
+        next unless snode
+        visit_node(snode, aFile, visitees)
+        aFile.puts %Q(    node_#{aNode.object_id} -> node_#{snode.object_id};)
+      end
+    end
+  end
+
+=begin
+  def fill_graph(aGFGraph, aFile)
+    all_vertices = aGFGraph.vertices.dup
+    (itemized, endpoints) = all_vertices.partition do |vertex| 
+      vertex.is_a?(Rley::GFG::ItemVertex) 
+    end
+    
+    # Group start/end nodes by non-terminal symbol
+    group_endings = endpoints.group_by { |endpoint| endpoint.non_terminal }
+    
+    # Group item vertices by lhs non-terminal symbol
+    group_items = itemized.group_by { |vertex| vertex.lhs }    
+    
+    aFile.puts ''
+    group_endings.each_pair do |nonterm, nodes|
+      text = <<-END_STRING    
+  subgraph cluster_#{nonterm} {
+    color = transparent;
+END_STRING
+      aFile.puts text
+      aFile.puts '    // Define the start and end nodes'      
+      nodes.each do |vertex|
+        # Emit the start/end nodes
+        aFile.puts %Q(    node_#{vertex.object_id}[shape=box, fontsize=18.0, label="#{vertex.label}"];)
+      end
+      
+      # Create sub-clusters by production
+      subnodes = group_items[nonterm]
+      subclusters = subnodes.group_by { |vertex| vertex.dotted_item.production }
+      subclusters.each_pair do |prod, vertices|
+        aFile.puts ''
+        aFile.puts cluster_heading(prod)
+        vertices.each do |vertex|
+          aFile.puts %Q(      node_#{vertex.object_id}[label="#{vertex.label}"];)
+        end
+        aFile.puts cluster_trailing(prod)
+      end      
+      aFile.puts '  }'
+    end
+
+    aFile.puts ''
+    aFile.puts '  // Draw the edges'
+    aGFGraph.vertices.each do |from_vertex|
+      from_vertex.edges.each do |anEdge|
+        if from_vertex.is_a?(Rley::GFG::EndVertex)
+          to_dotted_item = anEdge.successor.dotted_item
+          label = "RET_#{to_dotted_item.production.object_id}_#{to_dotted_item.prev_position}"
+          aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[color=red, style=dashed, arrowhead=onormal,label=#{label}];"
+        else
+          if anEdge.is_a?(Rley::GFG::ScanEdge)
+            aFile.puts %Q(  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[fontsize=18.0, label="#{anEdge.terminal}"];)
+          else
+            if anEdge.successor.is_a?(Rley::GFG::StartVertex)
+              from_dotted_item = from_vertex.dotted_item
+              label = "CALL_#{from_dotted_item.production.object_id}_#{from_dotted_item.position}" 
+              aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[color=green, label=#{label}];"              
+            else
+              aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id};"
+            end
+          end
+        end
+      end  
+    end    
+  end
+
+
+  def cluster_heading(anObject)
+    text = <<-END_STRING
+    subgraph cluster_#{anObject.object_id} {
+      style = rounded;
+      color = blue;
+END_STRING
+
+  return text
+  end
+  
+  def cluster_trailing(anObject) 
+   return '    }'
+  end
+=end
+  
+end # class  

data/spec/rley/sppf/gfg_representation.rb

@@ -0,0 +1,111 @@
+# Mix-in module that generates a Graphviz's DOT file
+# that represents the precedence graph of parse entries.
+class GFGRepresentation
+
+  def generate_graph(aParsing, aFile)
+    heading = build_heading()
+    aFile.puts(heading)
+    
+    fill_graph(aParsing.gf_graph, aFile)
+    
+    trailing = build_trailing()
+    aFile.puts(trailing)
+  end
+  
+private
+
+  def build_heading()
+    text = <<-END_STRING
+  digraph gfg {
+  size="7,9.5";
+  page="8.5,11";
+  ratio = fill;
+END_STRING
+
+    return text
+  end
+  
+  def build_trailing()
+    return '}'
+  end
+  
+  def fill_graph(aGFGraph, aFile)
+    all_vertices = aGFGraph.vertices.dup
+    (itemized, endpoints) = all_vertices.partition do |vertex| 
+      vertex.is_a?(Rley::GFG::ItemVertex) 
+    end
+    
+    # Group start/end nodes by non-terminal symbol
+    group_endings = endpoints.group_by { |endpoint| endpoint.non_terminal }
+    
+    # Group item vertices by lhs non-terminal symbol
+    group_items = itemized.group_by { |vertex| vertex.lhs }    
+    
+    aFile.puts ''
+    group_endings.each_pair do |nonterm, nodes|
+      text = <<-END_STRING    
+  subgraph cluster_#{nonterm} {
+    color = transparent;
+END_STRING
+      aFile.puts text
+      aFile.puts '    // Define the start and end nodes'      
+      nodes.each do |vertex|
+        # Emit the start/end nodes
+        aFile.puts %Q(    node_#{vertex.object_id}[shape=box, fontsize=18.0, label="#{vertex.label}"];)
+      end
+      
+      # Create sub-clusters by production
+      subnodes = group_items[nonterm]
+      subclusters = subnodes.group_by { |vertex| vertex.dotted_item.production }
+      subclusters.each_pair do |prod, vertices|
+        aFile.puts ''
+        aFile.puts cluster_heading(prod)
+        vertices.each do |vertex|
+          aFile.puts %Q(      node_#{vertex.object_id}[label="#{vertex.label}"];)
+        end
+        aFile.puts cluster_trailing(prod)
+      end      
+      aFile.puts '  }'
+    end
+
+    aFile.puts ''
+    aFile.puts '  // Draw the edges'
+    aGFGraph.vertices.each do |from_vertex|
+      from_vertex.edges.each do |anEdge|
+        if from_vertex.is_a?(Rley::GFG::EndVertex)
+          to_dotted_item = anEdge.successor.dotted_item
+          label = "RET_#{to_dotted_item.production.object_id}_#{to_dotted_item.prev_position}"
+          aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[color=red, style=dashed, arrowhead=onormal,label=#{label}];"
+        else
+          if anEdge.is_a?(Rley::GFG::ScanEdge)
+            aFile.puts %Q(  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[fontsize=18.0, label="#{anEdge.terminal}"];)
+          else
+            if anEdge.successor.is_a?(Rley::GFG::StartVertex)
+              from_dotted_item = from_vertex.dotted_item
+              label = "CALL_#{from_dotted_item.production.object_id}_#{from_dotted_item.position}" 
+              aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id}[color=green, label=#{label}];"              
+            else
+              aFile.puts "  node_#{from_vertex.object_id}->node_#{anEdge.successor.object_id};"
+            end
+          end
+        end
+      end  
+    end    
+  end
+
+
+  def cluster_heading(anObject)
+    text = <<-END_STRING
+    subgraph cluster_#{anObject.object_id} {
+      style = rounded;
+      color = blue;
+END_STRING
+
+  return text
+  end
+  
+  def cluster_trailing(anObject) 
+   return '    }'
+  end
+
+end # module

data/spec/rley/sppf/non_terminal_node_spec.rb

@@ -0,0 +1,64 @@
+require 'ostruct'
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/ptree/token_range'
+
+# Load the class under test
+require_relative '../../../lib/rley/sppf/non_terminal_node'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module SPPF # Open this namespace to avoid module qualifier prefixes
+    describe NonTerminalNode do
+      # Factory method. Generate a range from its boundary values.
+      def range(low, high)
+        return PTree::TokenRange.new(low: low, high: high)
+      end
+
+      let(:sample_symbol) do
+        Syntax::NonTerminal.new('VP')
+      end
+      let(:sample_range) { range(0, 3) }
+
+      subject { NonTerminalNode.new(sample_symbol, sample_range) }
+
+      context 'Initialization:' do
+        it 'should know its non-terminal symbol' do
+          expect(subject.symbol).to eq(sample_symbol)
+        end
+
+        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
+        
+        it 'should have :and refinement' do
+          expect(subject.refinement).to eq(:and)
+        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('VP[0, 3]')
+        end
+      end # context
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/support/ambiguous_grammar_helper.rb

@@ -1,36 +1,36 @@
-# Load the builder class
-require_relative '../../../lib/rley/syntax/grammar_builder'
-require_relative '../../../lib/rley/parser/token'
-
-
-module AmbiguousGrammarHelper
-  # Factory method. Creates a grammar builder for a basic ambiguous
-  # expression grammar.
-  # (based on an example from Fisher and LeBlanc: "Crafting a Compiler")
-  def grammar_builder()
-    builder = Rley::Syntax::GrammarBuilder.new
-    builder.add_terminals('+', 'id')
-    builder.add_production('S' => 'E')
-    builder.add_production('E' => %w(E + E))
-    builder.add_production('E' => 'id')
-    builder
-  end
-  
-  # Basic tokenizing method
-  def tokenize(aText, aGrammar)
-    tokens = aText.scan(/\S+/).map do |lexeme|
-      case lexeme
-        when '+'
-          terminal = aGrammar.name2symbol[lexeme]
-        when /^[_a-zA-Z][_a-zA-Z0-9]*$/
-          terminal = aGrammar.name2symbol['id']
-        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 AmbiguousGrammarHelper
+  # Factory method. Creates a grammar builder for a basic ambiguous
+  # expression grammar.
+  # (based on an example from Fisher and LeBlanc: "Crafting a Compiler")
+  def grammar_builder()
+    builder = Rley::Syntax::GrammarBuilder.new
+    builder.add_terminals('+', 'id')
+    builder.add_production('S' => 'E')
+    builder.add_production('E' => %w(E + E))
+    builder.add_production('E' => 'id')
+    builder
+  end
+
+  # Basic tokenizing method
+  def tokenize(aText, aGrammar)
+    tokens = aText.scan(/\S+/).map do |lexeme|
+      case lexeme
+        when '+'
+          terminal = aGrammar.name2symbol[lexeme]
+        when /^[_a-zA-Z][_a-zA-Z0-9]*$/
+          terminal = aGrammar.name2symbol['id']
+        else
+          msg = "Unknown input text '#{lexeme}'"
+          fail StandardError, msg
+      end
+      Rley::Parser::Token.new(lexeme, terminal)
+    end
+
+    return tokens
+  end
+end # module

data/spec/rley/support/expectation_helper.rb

@@ -0,0 +1,36 @@
+# 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

data/spec/rley/support/grammar_helper.rb

@@ -0,0 +1,28 @@
+# Load the builder class
+require_relative '../../../lib/rley/parser/token'
+
+
+# Mixin module implementing helper methods.
+module GrammarHelper
+  # Create a sequence of tokens, one for each grammar symbol name.
+  # Synopsis:
+  #   build_token_sequence(%w(a a b c c), grm1)
+  def build_token_sequence(literals, aGrammar)
+    tokens = literals.map do |lexeme|
+      case lexeme
+        when String
+          terminal = aGrammar.name2symbol[lexeme]
+          Rley::Parser::Token.new(lexeme, terminal)
+
+        when Hash # lexeme is reality a Hash: literal => terminal name
+          sub_array = lexeme.to_a
+          sub_array.map do |(literal, name)|
+            terminal = aGrammar.name2symbol[name]
+            Rley::Parser::Token.new(literal, terminal)
+          end
+      end
+    end
+
+    return tokens.flatten
+  end
+end # module