rley 0.6.07 → 0.6.08

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25c9a2612411bdb3767901c9b21d1e38f5279c94
-  data.tar.gz: 9c3ffe74bda63f31d40421b74a6f976ac3db49ad
+  metadata.gz: 552a2a05bcb871b84b8d86b7c0bab8de2d776754
+  data.tar.gz: 0f80fc6e91cbe752393e04d878afeb6646ea0d27
 SHA512:
-  metadata.gz: d289304c2a693fb1eb14747751e205bc23cccb9941c5f416af1966e6b3fcf3d2ff58f52ae6d56a2cae40752bcccbc2cd9a2c9015cc555a5ad3ef1890306f15e9
-  data.tar.gz: c59a9d80ff3b941efabed869de7e5d16b6ebc597c3a63d914de3976aa3c709a6cfde0630c8c931e14ae559e4c3fcbc5dddb935fa2d58c12c71fafad2fc817f4e
+  metadata.gz: 9cc73045f3e36363b201b61262ba9e8bac5154585033d8a1a48b0a45cdb259050bebdb42df747f0254276930e58488d740ab7a98d0659da485deb0ee22898798
+  data.tar.gz: 129611092776086798e54391535b50c9bdb673a8a4342fca81a3a8c66628113cf83aae1a872a1b1969845502347707e6994ed99e0a7ebeb25942acf8b0425eb4

data/examples/NLP/nano_eng/nano_en_demo.rb

@@ -1,12 +1,13 @@
 require 'rley' # Load Rley library
 
 ########################################
-# Step 0. Instantiate facade object of Rley library.
+# Step 1. Instantiate facade object of Rley library.
 # It provides a unified, higher-level interface
 engine = Rley::Engine.new
 
+
 ########################################
-# Step 1. Define a grammar for a nano English-like language
+# Step 2. Define a grammar for a nano English-like language
 # based on example from Jurafski & Martin book (chapter 8 of the book).
 # Bird, Steven, Edward Loper and Ewan Klein: "Speech and Language Processing";
 # 2009, Pearson Education, Inc., ISBN 978-0135041963
@@ -37,7 +38,7 @@ engine.build_grammar do
 end
 
 ########################################
-# Step 2. Creating a lexicon
+# Step 3. Creating a lexicon
 # To simplify things, lexicon is implemented as a Hash with pairs of the form:
 # word => terminal symbol name
 Lexicon = {
@@ -63,7 +64,7 @@ Lexicon = {
 }.freeze
 
 ########################################
-# Step 3. Creating a tokenizer
+# Step 4. Creating a tokenizer
 # A tokenizer reads the input string and converts it into a sequence of tokens
 # Highly simplified tokenizer implementation.
 def tokenizer(aTextToParse)
@@ -79,13 +80,11 @@ end
 ########################################
 # Step 5. Parsing the input
 input_to_parse = 'John saw Mary'
-# input_to_parse = 'John saw Mary with a telescope'
-# input_to_parse = 'the dog saw a man in the park' # This one is ambiguous
 # Convert input text into a sequence of token objects...
 tokens = tokenizer(input_to_parse)
 result = engine.parse(tokens)
 
-puts "Parsing successful? #{result.success?}"
+puts "Parsing '#{input_to_parse}' successful? #{result.success?}"
 unless result.success?
   puts result.failure_reason.message
   exit(1)
@@ -94,20 +93,38 @@ end
 ########################################
 # Step 6. Generating a parse tree from parse result
 ptree = engine.convert(result)
-
-# Let's create a parse tree visitor
 visitor = engine.ptree_visitor(ptree)
-
-# Let's create a formatter (i.e. visit event listener)
-# renderer = Rley::Formatter::Debug.new($stdout)
-
+renderer = Rley::Formatter::Debug.new($stdout)
 # Let's create a formatter that will render the parse tree with characters
-renderer = Rley::Formatter::Asciitree.new($stdout)
+# renderer = Rley::Formatter::Asciitree.new($stdout)
 
 # Let's create a formatter that will render the parse tree in labelled
 # bracket notation
 # renderer = Rley::Formatter::BracketNotation.new($stdout)
 
-# Subscribe the formatter to the visitor's event and launch the visit
 renderer.render(visitor)
+
+
+########################################
+# Redoing Step 5 and 6 with an ambiguous sentence
+input_to_parse = 'John saw Mary with a telescope'
+# input_to_parse = 'the dog saw a man in the park' # This one is also ambiguous
+# Convert input text into a sequence of token objects...
+tokens = tokenizer(input_to_parse)
+result = engine.parse(tokens)
+
+puts ''
+puts "Parsing '#{input_to_parse}' successful? #{result.success?}"
+unless result.success?
+  puts result.failure_reason.message
+  exit(1)
+end
+
+########################################
+# Step 6. Generating a parse forest from parse result
+pforest = engine.to_pforest(result)
+visitor = engine.pforest_visitor(pforest)
+renderer = Rley::Formatter::Debug.new($stdout)
+renderer.render(visitor)
+
 # End of file

data/lib/rley/constants.rb

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

data/lib/rley/engine.rb

@@ -1,13 +1,22 @@
 require_relative './syntax/grammar_builder'
 require_relative './parser/gfg_earley_parser'
+require_relative './parse_tree_visitor'
+require_relative './parse_forest_visitor'
 require_relative './parse_rep/parse_tree_factory'
+require_relative './parse_rep/parse_forest_factory'
 
 module Rley # This module is used as a namespace
+  # Configuration of an Rley::Engine instance.
   EngineConfig = Struct.new(
+    # @!attribute [r] parse_repr
+    #   Indicates how the parse result must represented
+    #   @return [Symbol] allowed values are: :parse_tree, :parse_forest
     :parse_repr,
     :repr_builder,
     :diagnose
   ) do
+
+    # Constructor with default initialization.
     def initialize()
       super()
       self.parse_repr = :parse_tree
@@ -17,18 +26,22 @@ module Rley # This module is used as a namespace
   end
 
   # Implementation of the GoF Facade design pattern.
-  # an Engine object provides a higher-level interface that shields
+  # An Engine object provides a higher-level interface that shields
   # Rley client code from the lower-level classes.
   class Engine
     # @!attribute [r] configuration
-    #   @return [EngineConfig] the engine's configuration 
+    # @return [EngineConfig] the engine's configuration 
     attr_reader :configuration
     
     # @!attribute [r] grammar
-    #   @return [Rley::Syntax::Grammar] the grammar of the language to parse    
+    # @return [Rley::Syntax::Grammar] the grammar of the language to parse    
     attr_reader :grammar
 
     # Constructor.
+    # @example Produce a parse forest
+    #   Engine.new do |config|
+    #     config.parse_repr = :parse_forest
+    #   end
     def initialize()
       @configuration = EngineConfig.new
       yield configuration if block_given?
@@ -36,6 +49,17 @@ module Rley # This module is used as a namespace
 
     # Factory method.
     # @param aBlock [Proc, Lambda] Code block for creating the grammar.
+    # @return [Rley::Syntax::Grammar] the grammar of the language to parse.
+    # @example Grammar for array of integers
+    #   instance = Engine.new
+    #   instance.build_grammar do
+    #     add_terminals('LBRACKET', 'RBRACKET', 'COMMA', 'INTEGER')
+    #     add_production('start' => 'array')    
+    #     add_production('array' => 'LBRACKET elements RBRACKET')
+    #     add_production('array' => 'LBRACKET RBRACKET')
+    #     add_production('elements' => 'elements COMMA INTEGER')
+    #     add_production('elements' => 'INTEGER')    
+    #   end
     def build_grammar(&aBlock)
       builder = Rley::Syntax::GrammarBuilder.new(&aBlock)
       @grammar = builder.grammar
@@ -43,6 +67,7 @@ module Rley # This module is used as a namespace
     
     # Use the given grammar.
     # @param aGrammar [Rley::Syntax::Grammar]
+    # @return [Rley::Syntax::Grammar] the grammar of the language to parse.
     def use_grammar(aGrammar)
       @grammar = aGrammar
     end
@@ -70,6 +95,7 @@ module Rley # This module is used as a namespace
     # Convert raw parse result into a more convenient representation
     # (parse tree or parse forest) as specified by the configuration.
     # @param aRawParse [Parser::GFGParsing]
+    # @return [Rley::PTree::ParseTree, Rley::SPPF::ParseForest]
     def convert(aRawParse)
       result = case configuration.parse_repr
                  when :parse_tree
@@ -83,6 +109,7 @@ module Rley # This module is used as a namespace
 
     # Convert raw parse result into a parse tree representation
     # @param aRawParse [Parser::GFGParsing]
+    # @return [Rley::PTree::ParseTree]
     def to_ptree(aRawParse)
       factory = ParseRep::ParseTreeFactory.new(aRawParse)
       if configuration.repr_builder == :default
@@ -96,29 +123,31 @@ module Rley # This module is used as a namespace
 
     # Convert raw parse result into a parse forest representation
     # @param aRawParse [Parser::GFGParsing]
-    # def to_pforest(aRawParse)
-    #   factory = ParseRep::ParseForestFactory.new(aRawParse)
-    #   if configuration.repr_builder == :default
-    #     result = factory.create(nil)
-    #   else
-    #     result = factory.create(configuration.repr_builder)
-    #   end
+    # @return [Rley::SPPF::ParseForest]
+    def to_pforest(aRawParse)
+      factory = ParseRep::ParseForestFactory.new(aRawParse)
+      if configuration.repr_builder == :default
+        result = factory.create(nil)
+      else
+        result = factory.create(configuration.repr_builder)
+      end
 
-    #   return result
-    # end
+      return result
+    end
 
     # Build a visitor for the given parse tree
-    # @param aPTree[PTree::ParseTree]
+    # @param aPTree [PTree::ParseTree]
     # @return [ParseTreeVisitor]
     def ptree_visitor(aPTree)
-      return Rley::ParseTreeVisitor.new(aPTree)
+      return ParseTreeVisitor.new(aPTree)
     end
 
-    # @param aPTree[SPPF::ParseForest]
+    # Build a visitor for the given parse forest
+    # @param aPForest [SPPF::ParseForest]
     # @return [ParseForestVisitor]
-    # def pforest_visitor(aPForest)
-    #   return Rley::ParseForestVisitor.new(aPForest)
-    # end
+    def pforest_visitor(aPForest)
+      return ParseForestVisitor.new(aPForest)
+    end
 
     protected
 

data/lib/rley/formatter/debug.rb

@@ -17,77 +17,27 @@ module Rley # This module is used as a namespace
         super(anIO)
         @indentation = 0
       end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor is about to visit the given
-      # parse tree
-      # @param _ptree [ParseTree]
-      def before_ptree(_ptree)
-        output_event(__method__, indentation)
-        indent
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor is about to visit
-      # a non-terminal node
-      # @param _nonterm [NonTerminalNode]
-      def before_non_terminal(_nonterm)
-        output_event(__method__, indentation)
-        indent
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor is about to visit
-      # the children of a non-terminal node
-      # @param _parent [NonTerminalNode]
-      # @param _children [Array] array of children nodes
-      def before_subnodes(_parent, _children)
-        output_event(__method__, indentation)
-        indent
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor is about to visit
-      # a terminal node
-      # @param _term [TerminalNode]
-      def before_terminal(_term)
-        output_event(__method__, indentation)
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor completed the visit of
-      # a terminal node.
-      # @param _term [TerminalNode]
-      def after_terminal(_term)
-        output_event(__method__, indentation)
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor completed the visit of
-      # a non-terminal node
-      # @param _nonterm [NonTerminalNode]
-      def after_non_terminal(_nonterm)
-        dedent
-        output_event(__method__, indentation)
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor completed the visit of
-      # the children of a non-terminal node.
-      # @param _parent [NonTerminalNode]
-      # @param _children [Array] array of children nodes
-      def after_subnodes(_parent, _children)
-        dedent
-        output_event(__method__, indentation)
-      end
-
-      # Method called by a ParseTreeVisitor to which the formatter subscribed.
-      # Notification of a visit event: the visitor completed the visit
-      # of the given parse tree
-      # @param _ptree [ParseTree]
-      def after_ptree(_ptree)
-        dedent
-        output_event(__method__, indentation)
+      
+      # Indicates that this formatter accepts all visit events
+      # provided their names start with 'before_' or 'after_'
+      # @return [Boolean]
+      def accept_all
+        return true
+      end
+      
+      # Ghost method pattern.
+      def method_missing(mth, *args)    
+        mth_name = mth.to_s         
+        case mth_name
+          when /^before_/
+            output_event(mth_name, indentation)
+            indent unless mth_name == 'before_terminal'
+          when /^after_/
+            dedent unless mth_name == 'after_terminal'
+            output_event(mth_name, indentation)
+          else
+            super(mth, args)
+        end
       end
 
       private

data/lib/rley/parse_forest_visitor.rb

@@ -1,25 +1,56 @@
+# require 'pry'
+require 'prime'
+
 module Rley # This module is used as a namespace
+  module SPPF # This module is used as a namespace
+    # Monkey-patching
+    class CompositeNode
+      attr_reader(:signatures)
+
+      # Associate for each edge between this node and each subnode
+      # an unique prime number (called a signature).
+      def add_edge_signatures(prime_enumerator)
+        @signatures = subnodes.map { |_| prime_enumerator.next }
+      end
+
+      def signature_exist?()
+        @signatures.nil? ? false : true
+      end
+    end # class
+  end # module
+
   # A visitor class dedicated in the visit of a parse forest.
   # It combines the Visitor and Observer patterns.
   class ParseForestVisitor
-    # Link to the parse forest to visit
+    # @return [SPPF::ParseForest] Link to the parse forest to visit
     attr_reader(:pforest)
 
-    # List of objects that subscribed to the visit event notification.
+    # @return [Array<Object>]
+    #   List of objects that subscribed to the visit event notification.
     attr_reader(:subscribers)
 
-    # A Hash with pairs of the form: Node => node visit data
-    attr_reader(:agenda)
+    # @return [Enumerator]
+    # Enumerator that generates a sequence of prime numbers
+    attr_reader(:prime_enum)
+
+    # @return [Array<SPPF::CompositeNode, Integer>]
+    #   Stack of [node, path signature]
+    # path signature: an integer value that represents the set of edges used
+    # in traversal
+    attr_reader(:legs)
 
-    # Indicates the kind of forest traversal to perform: :post_order, :pre-order
-    attr_reader(:traversal)
+    # @return [Hash{SPPF::CompositeNode, Array<Integer>}]
+    #   Keep trace from which path(s) a given node was accessed
+    attr_reader(:node_accesses)
 
     # Build a visitor for the given pforest.
-    # @param aParseForest [ParseForest] the parse tree to visit.
-    def initialize(aParseForest, aTraversalStrategy = :post_order)
+    # @param aParseForest [SPPF::ParseForest] the parse tree to visit.
+    def initialize(aParseForest)
       @pforest = aParseForest
       @subscribers = []
-      @traversal = aTraversalStrategy
+      @prime_enum = Prime.instance.each
+      @legs = []
+      @node_accesses = Hash.new { |h, key| h[key] = Array.new }
     end
 
     # Add a subscriber for the visit event notifications.
@@ -47,16 +78,28 @@ module Rley # This module is used as a namespace
     end
 
     # Visit event. The visitor is about to visit the given non terminal node.
-    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def visit_nonterminal(aNonTerminalNode)
-      if @traversal == :post_order
-        broadcast(:before_non_terminal, aNonTerminalNode)
-        traverse_children(aNonTerminalNode)
-      else
-        traverse_children(aNonTerminalNode)
-        broadcast(:before_non_terminal, aNonTerminalNode)
+    # @param nonTerminalNd [NonTerminalNode] the node to visit.
+    def visit_nonterminal(nonTerminalNd)
+      broadcast(:before_non_terminal, nonTerminalNd)
+     unless nonTerminalNd.signature_exist?
+       nonTerminalNd.add_edge_signatures(prime_enum)
+     end
+      traverse_children(nonTerminalNd)
+      broadcast(:after_non_terminal, nonTerminalNd)
+    end
+
+    # TODO: control the logic of this method.
+    # Visit event. The visitor is visiting the
+    # given alternative node.
+    # @param alternativeNd [AlternativeNode] the alternative node to visit.
+    def visit_alternative(alternativeNd)
+      broadcast(:before_alternative, alternativeNd)
+      unless alternativeNd.signature_exist?
+        alternativeNd.add_edge_signatures(prime_enum)
       end
-      broadcast(:after_non_terminal, aNonTerminalNode)
+
+      traverse_children(alternativeNd)
+      broadcast(:after_alternative, alternativeNd)
     end
 
     # Visit event. The visitor is visiting the
@@ -67,12 +110,20 @@ module Rley # This module is used as a namespace
       broadcast(:after_terminal, aTerminalNode)
     end
 
+    # Visit event. The visitor is visiting the
+    # given epsilon node.
+    # @param anEpsilonNode [EpsilonNode] the terminal to visit.
+    def visit_epsilon(anEpsilonNode)
+      broadcast(:before_epsilon, anEpsilonNode)
+      broadcast(:after_epsilon, anEpsilonNode)
+    end
+
     # Visit event. The visitor has completed its visit of the given
     # non-terminal node.
     # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def end_visit_nonterminal(aNonTerminalNode)
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
+    # def end_visit_nonterminal(aNonTerminalNode)
+      # broadcast(:after_non_terminal, aNonTerminalNode)
+    # end
 
     # Visit event. The visitor has completed the visit of the pforest.
     # @param aParseForest [ParseForest] the pforest to visit.
@@ -87,24 +138,57 @@ module Rley # This module is used as a namespace
     # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
     def traverse_children(aParentNode)
       children = aParentNode.children
-      broadcast(:before_children, aParentNode, children)
+      broadcast(:before_subnodes, aParentNode, children)
 
       # Let's proceed with the visit of children
-      children.each { |a_node| a_node.accept(self) }
+      children.each_with_index do |a_node, i|
+        edge_sign = aParentNode.signatures[i]
+        if a_node.kind_of?(SPPF::CompositeNode)
+          push_node(a_node, edge_sign)
+          access_paths = node_accesses[a_node]
+          last_path = legs.last[-1]
+          path_reused = access_paths.include?(last_path)
+          unless path_reused
+            node_accesses[a_node].push(last_path)
+            a_node.accept(self)
+          end
+          pop_node
+        else
+          a_node.accept(self)
+        end
+      end
 
-      broadcast(:after_children, aParentNode, children)
+      broadcast(:after_subnodes, aParentNode, children)
     end
 
     # 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)
+      subscribers.each do |subscr|
+        next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+        subscr.send(msg, *args)
+      end
+    end
+
+    def push_node(aCompositeNode, anEdgeSignature)
+      if legs.empty?
+        legs << [aCompositeNode, anEdgeSignature]
+      else
+        path_signature = legs.last[-1]
+        # binding.pry if anEdgeSignature == 37 && path_signature != 230
+        if (path_signature % anEdgeSignature).zero?
+          legs << [aCompositeNode, path_signature]
+        else
+          legs << [aCompositeNode, path_signature * anEdgeSignature]
+        end
       end
     end
+
+    def pop_node
+      return if legs.empty?
+      legs.pop
+    end
   end # class
 end # module
-
 # End of file