rley 0.1.02 → 0.1.03

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTI1YmQ5MTEwOTcyYmZjZmVjMzE0Y2NmNjBhNzA0MzE3NTgzYWE1Yw==
+    NDY5YjhjZjdmMGRlZTVhYzk4NWI1NjlkNTQ4N2MzMDMwZjEyMmRhYg==
   data.tar.gz: !binary |-
-    MjA1YTQ4NWVjNTNjNjdjY2NlN2M2NTQ5NDQzNWQxZWU4NGEwOWU1OA==
+    ZjM3OTdhY2VhMzhjYzA5ZDMwYzQyNDM5ZjIxZGJmNzMyMjljMGU1ZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    OGQwOTA2NjE0MzM2NjA0MzlkZTAxYzE0ZTUzZDY0MTMyMGRhNzQzYTg2YmIy
-    NWExNGI4NGQ0OGQ0NGEwMDkyNTJkMjRkMDM5ODZhZmY5NmIxYWVkNzA4YmVl
-    YjMxMjNjMGRjOTE5NDJmZmI4YjYzYjFhYTNhYmI3NDMxZGYxNjM=
+    Mzg2MjBhOTllMWUwMjZiN2U0YWE3MGMwNzg5MGJmZmJhNzcyN2UyNDk5NDdh
+    YjgwYmRlMDBhODQwZTAyYmU2ZWVkZTlhZTVlZjUxNzJmMzM4ZDYwOWUwNGM2
+    ZjEzZDMwYjk2Y2Y5MGVhYTk2Mzg4MGY5NDNkOThiOTg2NmViMzM=
   data.tar.gz: !binary |-
-    NWM3NGY1ODJlM2JjYTJjMGVmYmJiODMyOWUzYzEzZGNmYjMxYjZiMTJmMGNh
-    NTY4ZGZmMWY4ZjIzODA3ZjVjYmVhODYwOWYwMWQ2NmRjNWFkNTEzNzUwZTMy
-    YTcwMDAzN2RkMDg1ZWFjNWYyNmI1OWM1MzgyYzNjMmJjNWQ5OTU=
+    NGZhM2RmYmQzYzZlMGMzZjQ3MWRlNGZmOGRlMzUyMGYwOWI2NjVkZWQzOThm
+    NDg3OWU4MmMyNmVhNzBkMmZlZTEwYWU1MTE0YjA4YjQxZjJiOWJiNjc2ZTFk
+    MGE2YWJlZDEzMDNkZDMxNTEyYzU5MDg0YTgzNGJjMGFmMDY2Y2Q=

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.03 / 2014-12-08
+* [NEW] `ParseTreeVisitor` class. A class that walks through a parse tree.
+* [NEW] Method `accept` added to `ParseTree`, `TerminalNode`, `NonTerminalNode` classes.
+
 ### 0.1.02 / 2014-12-06
 * [CHANGE] Upgraded code & spec files to reach 100% code coverage again.
 

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.1.02'
+  Version = '0.1.03'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/parse_tree_visitor.rb

@@ -0,0 +1,102 @@
+module Rley # This module is used as a namespace
+  # A visitor class dedicated in the visit of ParseTree objects.
+  class ParseTreeVisitor
+    # Link to the parse tree to visit
+    attr_reader(:ptree)
+
+    # List of objects that subscribed to the visit event notification.
+    attr_reader(:subscribers)
+
+    # Build a visitor for the given ptree.
+    # @param aParseTree [ParseTree] the parse tree to visit.
+    def initialize(aParseTree)
+      @ptree = aParseTree
+      @subscribers = []
+    end
+
+    public
+
+    # Add a subscriber for the visit event notifications.
+    # @param aSubscriber [Object]
+    def subscribe(aSubscriber)
+      subscribers << aSubscriber
+    end
+
+    # Remove the given object from the subscription list.
+    # The object won't be notified of visit events.
+    # @param aSubscriber [Object]
+    def unsubscribe(aSubscriber)
+      subscribers.delete_if { |entry| entry == aSubscriber }
+    end
+
+    # The signal to begin the visit of the parse tree.
+    def start()
+      ptree.accept(self)
+    end
+
+
+    # Visit event. The visitor is about to visit the ptree.
+    # @param aParseTree [ParseTree] the ptree to visit.
+    def start_visit_ptree(aParseTree)
+      broadcast(:before_ptree, aParseTree)
+    end
+
+
+    # Visit event. The visitor is about to visit the given non terminal node.
+    # @param aNonTerminal [NonTerminalNode] the node to visit.
+    def start_visit_nonterminal(aNonTerminalNode)
+      broadcast(:before_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor is about to visit the children of a non 
+    # terminal node.
+    # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
+    def visit_children(aParentNode)
+      children = aParentNode.children
+      broadcast(:before_children, aParentNode, children)
+      
+      # Let's proceed with the visit of children
+      children.each { |a_node| a_node.accept(self) }
+      
+      broadcast(:after_children, aParentNode, children)
+    end
+
+    # Visit event. The visitor is visiting the
+    # given terminal node.
+    # @param aTerminal [TerminalNode] the terminal to visit.
+    def visit_terminal(aTerminalNode)
+      broadcast(:before_terminal, aTerminalNode)
+      broadcast(:after_terminal, aTerminalNode)
+    end
+
+
+    # Visit event. The visitor has completed its visit of the given 
+    # non-terminal node.
+    # @param aNonTerminal [NonTerminalNode] the node to visit.
+    def end_visit_nonterminal(aNonTerminalNode)
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+
+    # Visit event. The visitor has completed the visit of the ptree.
+    # @param aParseTree [ParseTree] the ptree to visit.
+    def end_visit_ptree(aParseTree)
+      broadcast(:after_ptree, aParseTree)
+    end
+
+    private
+
+    # Send a notification to all subscribers.
+    # @param msg [Symbol] event to notify
+    # @param args [Array] arguments of the notification.
+    def broadcast(msg, *args)
+      subscribers.each do |a_subscriber|
+        next unless a_subscriber.respond_to?(msg)
+        a_subscriber.send(msg, *args)
+      end
+    end
+
+
+  end # class
+end # module
+
+# End of file

data/lib/rley/parser/parsing.rb

@@ -42,6 +42,7 @@ module Rley # This module is used as a namespace
             when Syntax::Terminal
               state_set_index -= 1
               ptree.step_back(state_set_index)
+              #ptree.current_node.token = tokens[state_set_index]
               parse_state = chart[state_set_index].predecessor_state(parse_state)
               curr_dotted_item = parse_state.dotted_rule
               

data/lib/rley/ptree/non_terminal_node.rb

@@ -15,6 +15,14 @@ module Rley # This module is used as a namespace
       def add_child(aChildNode)
         children << aChildNode
       end
+      
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.start_visit_nonterminal(self)
+        aVisitor.visit_children(self)
+        aVisitor.end_visit_nonterminal(self)
+      end
     end # class
   end # module
 end # module

data/lib/rley/ptree/parse_tree.rb

@@ -21,6 +21,18 @@ module Rley # This module is used as a namespace
         return current_path.last
       end
 
+      # Part of the 'visitee' role in the Visitor design pattern.
+      #   A visitee is expected to accept the visit from a visitor object
+      # @param aVisitor [ParseTreeVisitor] the visitor object
+      def accept(aVisitor)
+        aVisitor.start_visit_ptree(self)
+
+        # Let's proceed with the visit of nodes
+        root.accept(aVisitor) if root
+
+        aVisitor.end_visit_ptree(self)
+      end
+
 
       def add_children(aProduction, aRange)
         aProduction.rhs.each do |symb|
@@ -47,7 +59,6 @@ module Rley # This module is used as a namespace
       # @param tokenPos [Fixnum] position of the matching input token
       def step_up(tokenPos)
         (pos, last_node) = current_path.pop(2)
-        #last_node.range = low_bound({low: tokenPos})
       end
       
 
@@ -69,6 +80,7 @@ module Rley # This module is used as a namespace
       end
 
       private
+
         def low_bound(aRange)
           result = case aRange
             when Hash then aRange[:low]

data/lib/rley/ptree/terminal_node.rb

@@ -9,6 +9,12 @@ module Rley # This module is used as a namespace
       def initialize(aTerminalSymbol, aRange)
         super(aTerminalSymbol, aRange)
       end
+      
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_terminal(self)
+      end
 
     end # class
   end # module

data/spec/rley/parse_tree_visitor_spec.rb

@@ -0,0 +1,174 @@
+require_relative '../spec_helper'
+
+require_relative '../../lib/rley/syntax/grammar_builder'
+require_relative '../../lib/rley/parser/token'
+require_relative '../../lib/rley/parser/earley_parser'
+# Load the class under test
+require_relative '../../lib/rley/parse_tree_visitor'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  describe ParseTreeVisitor do
+    let(:grammar_abc) do
+      builder = 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'])
+      builder.grammar
+    end
+
+    let(:a_) { grammar_abc.name2symbol['a'] }
+    let(:b_) { grammar_abc.name2symbol['b'] }
+    let(:c_) { grammar_abc.name2symbol['c'] }
+
+
+    # Helper method that mimicks the output of a tokenizer
+    # for the language specified by gramma_abc
+    let(:grm_abc_tokens1) do
+      [
+        Parser::Token.new('a', a_),
+        Parser::Token.new('a', a_),
+        Parser::Token.new('b', b_),
+        Parser::Token.new('c', c_),
+        Parser::Token.new('c', c_)
+      ]
+    end
+
+    # Factory method that builds a sample parse tree.
+    # Generated tree 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_ptree1) do
+      parser = Parser::EarleyParser.new(grammar_abc)
+      parse_result = parser.parse(grm_abc_tokens1)
+      parse_result.parse_tree
+    end
+
+
+    # Default instantiation rule
+    subject { ParseTreeVisitor.new(grm_abc_ptree1) }
+
+
+    context 'Standard creation & initialization:' do
+
+      it 'should be initialized with a parse tree argument' do
+        expect { ParseTreeVisitor.new(grm_abc_ptree1) }.not_to raise_error
+      end
+
+      it 'should know the parse tree to visit' do
+        expect(subject.ptree).to eq(grm_abc_ptree1)
+      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
+      # Default instantiation rule
+      subject do
+        instance = ParseTreeVisitor.new(grm_abc_ptree1)
+        instance.subscribe(listener1)
+        instance
+      end
+
+      # Use doubles/mocks to simulate formatters
+      let(:listener1) { double('fake-subscriber1') }
+      let(:listener2) { double('fake-subscriber2') }
+      
+      # Sample non-terminal node
+      let(:nterm_node) do 
+        first_big_a = grm_abc_ptree1.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_ptree message' do
+        # Notify subscribers when start the visit of the ptree
+        expect(listener1).to receive(:before_ptree).with(grm_abc_ptree1)
+        subject.start_visit_ptree(grm_abc_ptree1)
+      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.start_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
+        expect(listener1).to receive(:before_children).with(nterm_node, children)
+        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.visit_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_ptree message' do
+        # Notify subscribers when ending the visit of the ptree
+        expect(listener1).to receive(:after_ptree).with(grm_abc_ptree1)
+        subject.end_visit_ptree(grm_abc_ptree1)
+      end
+      
+      it 'should begin the visit when requested' do
+        subject.start
+      end
+
+    end # context
+  end # describe
+end # module
+
+# End of file

data/spec/rley/parser/earley_parser_spec.rb

@@ -35,6 +35,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 =end
 
+
       # Grammar 1: A very simple language
       # (based on example in N. Wirth "Compiler Construction" book, p. 6)
       # S ::= A.

data/spec/rley/parser/parsing_spec.rb

@@ -26,7 +26,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:prod_S) { Syntax::Production.new(nt_S, [nt_A]) }
       let(:prod_A1) { Syntax::Production.new(nt_A, [a_, nt_A, c_]) }
       let(:prod_A2) { Syntax::Production.new(nt_A, [b_]) }
-      let(:start_dotted_rule) { DottedItem.new(prod_S, 0) }
+
 
       # Helper method that mimicks the output of a tokenizer
       # for the language specified by gramma_abc
@@ -40,6 +40,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         ]
       end
 
+
+      let(:start_dotted_rule) { DottedItem.new(prod_S, 0) }
+      
       # Default instantiation rule
       subject { Parsing.new(start_dotted_rule, grm1_tokens) }
 
@@ -128,7 +131,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           end
         end
         
-        
+
         it 'should build the parse tree for a non-ambiguous grammar' do
           parser = EarleyParser.new(sample_grammar1)
           instance = parser.parse(token_seq1)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.1.02
+  version: 0.1.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-06 00:00:00.000000000 Z
+date: 2014-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -96,6 +96,7 @@ files:
 - lib/rley/parser/parsing.rb
 - lib/rley/parser/state_set.rb
 - lib/rley/parser/token.rb
+- lib/rley/parse_tree_visitor.rb
 - lib/rley/ptree/non_terminal_node.rb
 - lib/rley/ptree/parse_tree.rb
 - lib/rley/ptree/parse_tree_node.rb
@@ -117,6 +118,7 @@ files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
+- spec/rley/parse_tree_visitor_spec.rb
 - spec/rley/ptree/non_terminal_node_spec.rb
 - spec/rley/ptree/parse_tree_node_spec.rb
 - spec/rley/ptree/parse_tree_spec.rb
@@ -170,6 +172,7 @@ test_files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
+- spec/rley/parse_tree_visitor_spec.rb
 - spec/rley/ptree/non_terminal_node_spec.rb
 - spec/rley/ptree/parse_tree_node_spec.rb
 - spec/rley/ptree/parse_tree_spec.rb