rley 0.2.15 → 0.3.00

data/spec/rley/gfg/shortcut_edge_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/rley/syntax/non_terminal'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/shortcut_edge'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Edge do
+      let(:nt_b_sequence) { Rley::Syntax::NonTerminal.new('b_sequence') }
+
+      let(:vertex1) { double('fake_vertex1') }
+      let(:vertex2) { double('fake_vertex2') }
+      subject { ShortcutEdge.new(vertex1, vertex2) }
+
+      context 'Initialization:' do
+        it 'should be created with two vertice arguments & a non-terminal' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+
+          expect { ShortcutEdge.new(vertex1, vertex2) }
+            .not_to raise_error
+        end
+
+        it 'should know the successor vertex' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+          
+          expect(subject.successor).to eq(vertex2)
+        end
+
+        it 'should know the related terminal' do
+          allow(vertex1).to receive(:shortcut=)
+          allow(vertex1).to receive(:next_symbol).and_return(nt_b_sequence)
+
+          expect(subject.nonterminal).to eq(nt_b_sequence)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/vertex_spec.rb

@@ -1,38 +1,53 @@
-require_relative '../../spec_helper'
-
-# Load the class under test
-require_relative '../../../lib/rley/gfg/vertex'
-
-module Rley # Open this namespace to avoid module qualifier prefixes
-  module GFG # Open this namespace to avoid module qualifier prefixes
-    describe Vertex do
-      subject { Vertex.new() }
-
-      context 'Initialization:' do
-        it 'should be created without argument' do
-          expect { Vertex.new() }.not_to raise_error
-        end
-        
-        it "shouldn't have edges at start" do
-          expect(subject.edges.empty?).to eq(true)
-        end
-      end # context
-      
-      context 'Provided services:' do
-        it 'should accept new edges' do
-          edge1 = double('fake-edge1')
-          edge2 = double('fake-edge2')
-          
-          expect { subject.add_edge(edge1) }.not_to raise_error
-          expect(subject.edges.size).to eq(1)
-          expect(subject.edges.last).to eq(edge1)
-          expect { subject.add_edge(edge2) }.not_to raise_error          
-          expect(subject.edges.size).to eq(2)
-          expect(subject.edges.last).to eq(edge2)
-        end
-      end # context
-    end # describe
-  end # module
-end # module
-
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/gfg/vertex'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module GFG # Open this namespace to avoid module qualifier prefixes
+    describe Vertex do
+      subject { Vertex.new() }
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { Vertex.new() }.not_to raise_error
+        end
+
+        it "shouldn't have edges at start" do
+          expect(subject.edges.empty?).to eq(true)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should know whether it has a dot at the end of the rhs' do
+          expect(subject).not_to be_complete
+        end
+        
+        it 'should know the previous symbol (if any) in the rhs' do
+          expect(subject.prev_symbol).to be_nil
+        end        
+
+        it 'should know the next symbol (if any) in the rhs' do
+          expect(subject.next_symbol).to be_nil
+        end
+
+        it 'should accept at most one new edge' do
+          edge1 = double('fake-edge1')
+          edge2 = double('fake-edge2')
+
+          expect { subject.add_edge(edge1) }.not_to raise_error
+          expect(subject.edges.size).to eq(1)
+          expect(subject.edges.last).to eq(edge1)
+          
+          err = StandardError
+          msg = 'At most one edge accepted'
+          expect { subject.add_edge(edge2) }.to raise_error err, msg
+          expect(subject.edges.size).to eq(1)
+          expect(subject.edges.last).to eq(edge1)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
 # End of file

data/spec/rley/parse_forest_visitor_spec.rb

@@ -0,0 +1,238 @@
+require_relative '../spec_helper'
+
+require_relative './support/grammar_helper'
+require_relative './support/grammar_sppf_helper'
+require_relative '../../lib/rley/parser/token'
+require_relative '../../lib/rley/parser/gfg_earley_parser'
+require_relative '../../lib/rley/sppf/non_terminal_node'
+require_relative '../../lib/rley/sppf/parse_forest'
+
+# Load the class under test
+require_relative '../../lib/rley/parse_forest_visitor'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  describe ParseForestVisitor do
+    include GrammarSPPFHelper # Mix-in module with builder for grammar sppf
+    include GrammarHelper     # Mix-in with token factory method
+    
+    # Assumption the aParseEntry corresponds to an end GFG node
+    def create_non_terminal_node(aParseEntry, aRange)
+      a_vertex = aParseEntry.vertex
+      return Rley::SPPF::NonTerminalNode.new(a_vertex.non_terminal, aRange)
+    end    
+    
+    let(:grammar_sppf) do
+      builder = grammar_sppf_builder
+      builder.grammar
+    end
+
+    let(:sample_tokens) do
+      build_token_sequence(%w(a b b b), grammar_sppf)
+    end
+    
+    # A forest with just a root node
+    let(:rooted_forest) do
+      parser = Parser::GFGEarleyParser.new(grammar_sppf)
+      parse_result = parser.parse(sample_tokens)
+      full_range = { low: 0, high: parse_result.chart.last_index }
+      root_node = create_non_terminal_node(parse_result.accepting_entry, full_range)
+      Rley::SPPF::ParseForest.new(root_node)      
+    end
+
+=begin
+    # Factory method that builds a sample parse forest.
+    # Generated forest has the following structure:
+    # S[0,5]
+    # +- A[0,5]
+    #    +- a[0,0]
+    #    +- A[1,4]
+    #    |  +- a[1,1]
+    #    |  +- A[2,3]
+    #    |  |  +- b[2,3]
+    #    |  +- c[3,4]
+    #    +- c[4,5]
+    # Capital letters represent non-terminal nodes
+    let(:grm_abc_pforest1) do
+      parser = Parser::EarleyParser.new(grammar_abc)
+      parse_result = parser.parse(grm_abc_tokens1)
+      parse_result.parse_forest
+    end
+=end
+
+    # Default instantiation rule
+    subject { ParseForestVisitor.new(rooted_forest) }
+
+
+    context 'Standard creation & initialization:' do
+      it 'should be initialized with a parse forest argument' do
+        expect { ParseForestVisitor.new(rooted_forest) }.not_to raise_error
+      end
+
+      it 'should know the parse forest to visit' do
+        expect(subject.pforest).to eq(rooted_forest)
+      end
+
+      it "shouldn't have subscribers at start" do
+        expect(subject.subscribers).to be_empty
+      end
+    end # context
+
+
+    context 'Subscribing:' do
+      let(:listener1) { double('fake-subscriber1') }
+      let(:listener2) { double('fake-subscriber2') }
+
+      it 'should allow subscriptions' do
+        subject.subscribe(listener1)
+        expect(subject.subscribers.size).to eq(1)
+        expect(subject.subscribers).to eq([listener1])
+
+        subject.subscribe(listener2)
+        expect(subject.subscribers.size).to eq(2)
+        expect(subject.subscribers).to eq([listener1, listener2])
+      end
+
+      it 'should allow un-subcriptions' do
+        subject.subscribe(listener1)
+        subject.subscribe(listener2)
+        subject.unsubscribe(listener2)
+        expect(subject.subscribers.size).to eq(1)
+        expect(subject.subscribers).to eq([listener1])
+        subject.unsubscribe(listener1)
+        expect(subject.subscribers).to be_empty
+      end
+    end # context
+
+
+    context 'Notifying visit events:' do
+      # Use doubles/mocks to simulate subscribers
+      let(:listener1) { double('fake-subscriber1') }
+      let(:listener2) { double('fake-subscriber2') }
+      
+      it 'should react to the start_visit_pforest message' do
+        subject.subscribe(listener1)
+        
+        # Notify subscribers when start the visit of the pforest
+        expect(listener1).to receive(:before_pforest).with(rooted_forest)
+        subject.start_visit_pforest(rooted_forest)
+      end  
+=begin    
+      # Default instantiation rule
+      subject do
+        instance = ParseForestVisitor.new(grm_abc_pforest1)
+        instance.subscribe(listener1)
+        instance
+      end
+
+
+
+      # Sample non-terminal node
+      let(:nterm_node) do
+        first_big_a = grm_abc_pforest1.root.children[0]
+        second_big_a = first_big_a.children[1]
+        second_big_a.children[1]
+      end
+
+      # Sample terminal node
+      let(:term_node) { nterm_node.children[0] }
+
+      it 'should react to the start_visit_pforest message' do
+        # Notify subscribers when start the visit of the pforest
+        expect(listener1).to receive(:before_pforest).with(grm_abc_pforest1)
+        subject.start_visit_pforest(grm_abc_pforest1)
+      end
+
+      it 'should react to the start_visit_nonterminal message' do
+        # Notify subscribers when start the visit of a non-terminal node
+        expect(listener1).to receive(:before_non_terminal).with(nterm_node)
+        subject.visit_nonterminal(nterm_node)
+      end
+
+      it 'should react to the visit_children message' do
+        # Notify subscribers when start the visit of children nodes
+        children = nterm_node.children
+        args = [nterm_node, children]
+        expect(listener1).to receive(:before_children).with(*args)
+        expect(listener1).to receive(:before_terminal).with(children[0])
+        expect(listener1).to receive(:after_terminal).with(children[0])
+        expect(listener1).to receive(:after_children).with(nterm_node, children)
+        subject.send(:traverse_children, nterm_node)
+      end
+
+      it 'should react to the end_visit_nonterminal message' do
+        # Notify subscribers when ending the visit of a non-terminal node
+        expect(listener1).to receive(:after_non_terminal).with(nterm_node)
+        subject.end_visit_nonterminal(nterm_node)
+      end
+
+      it 'should react to the visit_terminal message' do
+        # Notify subscribers when start & ending the visit of a terminal node
+        expect(listener1).to receive(:before_terminal).with(term_node)
+        expect(listener1).to receive(:after_terminal).with(term_node)
+        subject.visit_terminal(term_node)
+      end
+
+      it 'should react to the end_visit_pforest message' do
+        # Notify subscribers when ending the visit of the pforest
+        expect(listener1).to receive(:after_pforest).with(grm_abc_pforest1)
+        subject.end_visit_pforest(grm_abc_pforest1)
+      end
+
+      it 'should begin the visit when requested' do
+        # Reminder: parse forest structure is
+        # S[0,5]
+        # +- A[0,5]
+        #    +- a[0,0]
+        #    +- A[1,4]
+        #    |  +- a[1,1]
+        #    |  +- A[2,3]
+        #    |  |  +- b[2,3]
+        #    |  +- c[3,4]
+        #    +- c[4,5]
+        root = grm_abc_pforest1.root
+        children = root.children
+        big_a_1 = children[0]
+        big_a_1_children = big_a_1.children
+        big_a_2 = big_a_1_children[1]
+        big_a_2_children = big_a_2.children
+        big_a_3 = big_a_2_children[1]
+        big_a_3_children = big_a_3.children
+        expectations = [
+          [:before_pforest, [grm_abc_pforest1]],
+          [:before_non_terminal, [root]],
+          [:before_children, [root, children]],
+          [:before_non_terminal, [big_a_1]],
+          [:before_children, [big_a_1, big_a_1_children]],
+          [:before_terminal, [big_a_1_children[0]]],
+          [:after_terminal, [big_a_1_children[0]]],
+          [:before_non_terminal, [big_a_2]],
+          [:before_children, [big_a_2, big_a_2_children]],
+          [:before_terminal, [big_a_2_children[0]]],
+          [:after_terminal, [big_a_2_children[0]]],
+          [:before_non_terminal, [big_a_3]],
+          [:before_children, [big_a_3, big_a_3_children]],
+          [:before_terminal, [big_a_3_children[0]]],
+          [:after_terminal, [big_a_3_children[0]]],
+          [:after_children, [big_a_3, big_a_3_children]],
+          [:before_terminal, [big_a_2_children[2]]],
+          [:after_terminal, [big_a_2_children[2]]],
+          [:after_children, [big_a_2, big_a_2_children]],
+          [:before_terminal, [big_a_1_children[2]]],
+          [:after_terminal, [big_a_1_children[2]]],
+          [:after_children, [big_a_1, big_a_1_children]],
+          [:after_children, [root, children]],
+          [:after_pforest, [grm_abc_pforest1]]
+        ]
+        expectations.each do |(msg, args)|
+          allow(listener1).to receive(msg).with(*args).ordered
+        end
+        
+        # Here we go...
+        subject.start
+      end
+=end      
+    end # context
+  end # describe
+end # module
+
+# End of file

data/spec/rley/parser/dotted_item_spec.rb

@@ -91,36 +91,57 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should know the symbol before the dot' do
           expect(subject.prev_symbol).to eq(t_a)
-          
+
           # Case of an empty production
           instance = DottedItem.new(empty_prod, 0)
           expect(instance.prev_symbol).to be_nil
-          
+
           # Case of a dot at start position
           instance = DottedItem.new(sample_prod, 0)
-          expect(instance.prev_symbol).to be_nil          
+          expect(instance.prev_symbol).to be_nil
         end
 
         it 'should know the symbol after the dot' do
           expect(subject.next_symbol).to eq(t_b)
         end
-        
+
         it 'should calculate the previous position of the dot' do
           expect(subject.prev_position).to eq(0)
-          
+
           # Case of an empty production
           instance = DottedItem.new(empty_prod, 0)
           expect(instance.prev_position).to be_nil
-          
+
           # Case of a dot at start position
           instance = DottedItem.new(sample_prod, 0)
-          expect(instance.prev_position).to be_nil 
+          expect(instance.prev_position).to be_nil
 
           # Case of single symbol production
           instance = DottedItem.new(other_prod, 1)
-          expect(instance.prev_position).to eq(0)           
+          expect(instance.prev_position).to eq(0)
         end
 
+        it 'should determine if it is a successor of another dotted item' do
+          expect(subject).not_to be_successor_of(subject)
+          
+          # Case: different productions
+          instance = DottedItem.new(empty_prod, 0)
+          expect(subject).not_to be_successor_of(subject)
+
+          # Case: one position difference
+          instance = DottedItem.new(sample_prod, 0)
+          expect(subject).to be_successor_of(instance)
+          expect(instance).not_to be_successor_of(subject)
+
+          # Case: more than one position difference
+          instance2 = DottedItem.new(sample_prod, 2)
+          expect(instance).not_to be_successor_of(instance2)
+          expect(subject).not_to be_successor_of(instance2)
+          expect(instance2).to be_successor_of(subject)           
+        end
+
+
+
         it 'should give its text representation' do
           expectation = 'sentence => A . B C'
           expect(subject.to_s).to eq(expectation)

data/spec/rley/parser/gfg_chart_spec.rb

@@ -0,0 +1,138 @@
+require_relative '../../spec_helper'
+require 'stringio'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/parser/token'
+require_relative '../../../lib/rley/gfg/start_vertex'
+require_relative '../../../lib/rley/parser/parse_entry'
+require_relative '../../../lib/rley/parser/parse_tracer'
+require_relative '../../../lib/rley/parser/grm_items_builder'
+require_relative '../../../lib/rley/gfg/grm_flow_graph'
+require_relative '../support/grammar_abc_helper'
+
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/gfg_chart'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser # Open this namespace to avoid module qualifier prefixes
+    describe GFGChart do
+      include GrammarABCHelper # Mix-in module with builder for grammar abc
+
+      # Helper method. Create an array of dotted items
+      # from the given grammar
+      def build_items_for_grammar(aGrammar)
+        helper = Object.new
+        helper.extend(Parser::GrmItemsBuilder)
+        return helper.build_dotted_items(aGrammar)
+      end
+
+      let(:count_token) { 20 }
+      let(:output) { StringIO.new('', 'w') }
+
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+
+      let(:token_seq) do
+        literals = %w(a a b c c)
+        literals.map { |lexeme| Token.new(lexeme, nil) }
+      end
+
+      # Helper method. Create an array of dotted items
+      # from the abc grammar
+      let(:items_from_grammar) { build_items_for_grammar(grammar_abc) }
+      let(:sample_gfg) { GFG::GrmFlowGraph.new(items_from_grammar) }
+      let(:sample_tracer) { ParseTracer.new(0, output, token_seq) }
+      let(:sample_start_symbol) { sample_gfg.start_vertex.non_terminal }
+
+
+      # Default instantiation rule
+      subject { GFGChart.new(count_token, sample_gfg, sample_tracer) }
+
+
+      context 'Initialization:' do
+        it 'should be created with start vertex, token count, tracer' do
+          expect { GFGChart.new(count_token, sample_gfg, sample_tracer) }
+            .not_to raise_error
+        end
+
+        it 'should have correct entry set count' do
+          expect(subject.sets.size).to eq(count_token + 1)
+        end
+
+        it 'should reference a tracer' do
+          expect(subject.tracer).to eq(sample_tracer)
+        end
+
+        it 'should know the start symbol' do
+          expect(subject.start_symbol).to eq(sample_start_symbol)
+        end
+        
+        it 'should know the initial parse entry' do
+          expect(subject.initial_entry.vertex).to eq(sample_gfg.start_vertex)
+          expect(subject.initial_entry.origin).to eq(0)
+        end
+=begin
+
+        it 'should know the start dotted rule' do
+          expect(subject.start_dotted_rule).to eq(dotted_rule)
+        end
+
+
+=end
+      end # context
+
+      context 'Provided services:' do
+=begin
+        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(:origin_val) { 3 }
+        let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
+        let(:complete_rule) { DottedItem.new(sample_prod, 3) }
+        let(:sample_parse_state) { ParseState.new(dotted_rule, origin_val) }
+        let(:sample_tracer) { ParseTracer.new(1, output, token_seq) }
+
+        # Factory method.
+        def parse_state(origin, aDottedRule)
+          ParseState.new(aDottedRule, origin)
+        end
+
+
+        it 'should trace its initialization' do
+          subject[0]  # Force constructor call here
+          expectation = <<-SNIPPET
+['I', 'saw', 'John', 'with', 'a', 'dog']
+|.  I   . saw  . John . with .  a   . dog  .|
+|>      .      .      .      .      .      .| [0:0] sentence => A B . C
+SNIPPET
+          expect(output.string).to eq(expectation)
+        end
+
+        it 'should trace parse state pushing' do
+          subject[0]  # Force constructor call here
+          output.string = ''
+
+          subject.push_state(dotted_rule, 3, 5, :prediction)
+          expectation = <<-SNIPPET
+|.      .      .      >      .| [3:5] sentence => A B . C
+SNIPPET
+          expect(output.string).to eq(expectation)
+        end
+=end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file