dendroid 0.2.00 → 0.2.01

data/lib/dendroid/parsing/empty_rule_node.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-require_relative 'parse_node'
-
-module Dendroid
-  module Parsing
-    class EmptyRuleNode < ParseNode
-      attr_reader :rule
-      attr_reader :alt_index
-
-      def initialize(anEItem, rank)
-        super(rank, rank)
-        @rule = WeakRef.new(anEItem.dotted_item.rule)
-        @alt_index = anEItem.dotted_item.alt_index
-      end
-
-      def to_s
-        "_ #{super}"
-      end
-
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param aVisitor[ParseTreeVisitor] the visitor
-      def accept(aVisitor)
-        aVisitor.visit_empty_rule_node(self)
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'parse_node'
+
+module Dendroid
+  module Parsing
+    class EmptyRuleNode < ParseNode
+      attr_reader :rule
+      attr_reader :alt_index
+
+      def initialize(anEItem, rank)
+        super(rank, rank)
+        @rule = WeakRef.new(anEItem.dotted_item.rule)
+        @alt_index = anEItem.dotted_item.alt_index
+      end
+
+      def to_s
+        "_ #{super}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_empty_rule_node(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/or_node.rb

@@ -1,51 +1,46 @@
-# frozen_string_literal: true
-
-require_relative 'composite_parse_node'
-
-module Dendroid
-  module Parsing
-    class OrNode  < CompositeParseNode
-      attr_reader :symbol
-
-      def initialize(sym, lower, upper, arity)
-        @symbol = sym
-        super(lower, upper, arity)
-      end
-
-      def add_child(child_node, _index)
-        idx = children.find_index(&:nil?)
-        if idx
-          # Use first found available slot...
-          super(child_node, idx)
-          if children.size > 3
-            raise StandardError
-          end
-        else
-          raise StandardError
-        end
-      end
-
-      def match(anEItem)
-        return false if range[0] != anEItem.origin
-
-        dotted = anEItem.dotted_item
-        (symbol == dotted.rule.lhs) && children.any? { |ch| ch.match(anEItem) }
-      end
-
-      def partial?
-        # children.any?(&:nil?)
-        false
-      end
-
-      def to_s
-        "OR: #{symbol.name} #{range}"
-      end
-
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param aVisitor[ParseTreeVisitor] the visitor
-      def accept(aVisitor)
-        aVisitor.visit_or_node(self)
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'composite_parse_node'
+
+module Dendroid
+  module Parsing
+    class OrNode < CompositeParseNode
+      attr_reader :symbol
+
+      def initialize(sym, lower, upper, arity)
+        @symbol = sym
+        super(lower, upper, arity)
+      end
+
+      def add_child(child_node, _index)
+        idx = children.find_index(&:nil?)
+        raise StandardError unless idx
+
+        # Use first found available slot...
+        super(child_node, idx)
+      end
+
+      def match(anEItem)
+        return false if range[0] != anEItem.origin
+
+        dotted = anEItem.dotted_item
+        (symbol == dotted.rule.lhs) && children.any? { |ch| ch.match(anEItem) }
+      end
+
+      def partial?
+        # children.any?(&:nil?)
+        false
+      end
+
+      def to_s
+        "OR: #{symbol.name} #{range}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_or_node(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/parse_node.rb

@@ -1,26 +1,26 @@
-# frozen_string_literal: true
-
-module Dendroid
-  module Parsing
-    class ParseNode
-      # @return [Array<Integer>] The range of input tokens that match this node.
-      attr_reader :range
-
-      def initialize(lowerBound, upperBound)
-        @range = valid_range(lowerBound, upperBound)
-      end
-
-      def to_s
-        "[#{range[0]}, #{range[1]}]"
-      end
-
-      private
-
-      def valid_range(lowerBound, upperBound)
-        raise StandardError unless lowerBound.is_a?(Integer) && upperBound.is_a?(Integer)
-
-        [lowerBound, upperBound]
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+module Dendroid
+  module Parsing
+    class ParseNode
+      # @return [Array<Integer>] The range of input tokens that match this node.
+      attr_reader :range
+
+      def initialize(lowerBound, upperBound)
+        @range = valid_range(lowerBound, upperBound)
+      end
+
+      def to_s
+        "[#{range[0]}, #{range[1]}]"
+      end
+
+      private
+
+      def valid_range(lowerBound, upperBound)
+        raise StandardError unless lowerBound.is_a?(Integer) && upperBound.is_a?(Integer)
+
+        [lowerBound, upperBound]
+      end
+    end # class
+  end # module
+end # module

data/lib/dendroid/parsing/parse_tree_visitor.rb

@@ -1,127 +1,127 @@
-# frozen_string_literal: true
-
-class ParseTreeVisitor
-  # Link to the result root node of the tree (forest)
-  attr_reader(:root)
-
-  # List of objects that subscribed to the visit event notification.
-  attr_reader(:subscribers)
-
-  # Indicates the kind of tree traversal to perform: :post_order, :pre-order
-  attr_reader(:traversal)
-
-  # Build a visitor for the given root.
-  # @param aParseTree [ParseTree] the parse tree to visit.
-  def initialize(aParseTree, aTraversalStrategy = :post_order)
-    raise StandardError if aParseTree.nil?
-
-    @root = aParseTree
-    @subscribers = []
-    @traversal = aTraversalStrategy
-  end
-
-  # 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
-    root.accept(self)
-  end
-
-  # Visit event. The visitor is about to visit the root.
-  # @param aParseTree [ParseTree] the root to visit.
-  def start_visit_root(aParseTree)
-    broadcast(:before_root, aParseTree)
-  end
-
-  # Visit event. The visitor is about to visit the given non terminal node.
-  # @param aNonTerminalNode [ANDNode] the node to visit.
-  def visit_and_node(aNonTerminalNode)
-    if @traversal == :post_order
-      broadcast(:before_and_node, aNonTerminalNode)
-      traverse_subnodes(aNonTerminalNode)
-    else
-      traverse_subnodes(aNonTerminalNode)
-      broadcast(:before_and_node, aNonTerminalNode)
-    end
-    broadcast(:after_and_node, aNonTerminalNode)
-  end
-
-  # Visit event. The visitor is about to visit the given non terminal node.
-  # @param aNonTerminalNode [OrNode] the node to visit.
-  def visit_or_node(aNonTerminalNode)
-    if @traversal == :post_order
-      broadcast(:before_or_node, aNonTerminalNode)
-      traverse_subnodes(aNonTerminalNode)
-    else
-      traverse_subnodes(aNonTerminalNode)
-      broadcast(:before_or_node, aNonTerminalNode)
-    end
-    broadcast(:after_or_node, aNonTerminalNode)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given terminal node.
-  # @param anEmptyRuleNode [EmptyRuleNode] the node to visit.
-  def visit_empty_rule_node(anEmptyRuleNode)
-    broadcast(:before_empty_rule_node, anEmptyRuleNode)
-    broadcast(:after_empty_rule_node, anEmptyRuleNode)
-  end
-
-  # Visit event. The visitor is visiting the
-  # given terminal node.
-  # @param aTerminalNode [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 aNonTerminalNode [NonTerminalNode] the node to visit.
-  def end_visit_nonterminal(aNonTerminalNode)
-    broadcast(:after_and_node, aNonTerminalNode)
-  end
-
-  # Visit event. The visitor has completed the visit of the root.
-  # @param aParseTree [ParseTree] the root to visit.
-  def end_visit_root(aParseTree)
-    broadcast(:after_root, aParseTree)
-  end
-
-  private
-
-  # Visit event. The visitor is about to visit the subnodes of a non
-  # terminal node.
-  # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
-  def traverse_subnodes(aParentNode)
-    subnodes = aParentNode.children
-    broadcast(:before_subnodes, aParentNode, subnodes)
-
-    # Let's proceed with the visit of subnodes
-    subnodes.each { |a_node| a_node.accept(self) }
-
-    broadcast(:after_subnodes, aParentNode, subnodes)
-  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 |subscr|
-      next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
-
-      subscr.send(msg, *args)
-    end
-  end
-end # class
+# frozen_string_literal: true
+
+class ParseTreeVisitor
+  # Link to the result root node of the tree (forest)
+  attr_reader(:root)
+
+  # List of objects that subscribed to the visit event notification.
+  attr_reader(:subscribers)
+
+  # Indicates the kind of tree traversal to perform: :post_order, :pre-order
+  attr_reader(:traversal)
+
+  # Build a visitor for the given root.
+  # @param aParseTree [ParseTree] the parse tree to visit.
+  def initialize(aParseTree, aTraversalStrategy = :post_order)
+    raise StandardError if aParseTree.nil?
+
+    @root = aParseTree
+    @subscribers = []
+    @traversal = aTraversalStrategy
+  end
+
+  # 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
+    root.accept(self)
+  end
+
+  # Visit event. The visitor is about to visit the root.
+  # @param aParseTree [ParseTree] the root to visit.
+  def start_visit_root(aParseTree)
+    broadcast(:before_root, aParseTree)
+  end
+
+  # Visit event. The visitor is about to visit the given non terminal node.
+  # @param aNonTerminalNode [ANDNode] the node to visit.
+  def visit_and_node(aNonTerminalNode)
+    if @traversal == :post_order
+      broadcast(:before_and_node, aNonTerminalNode)
+      traverse_subnodes(aNonTerminalNode)
+    else
+      traverse_subnodes(aNonTerminalNode)
+      broadcast(:before_and_node, aNonTerminalNode)
+    end
+    broadcast(:after_and_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor is about to visit the given non terminal node.
+  # @param aNonTerminalNode [OrNode] the node to visit.
+  def visit_or_node(aNonTerminalNode)
+    if @traversal == :post_order
+      broadcast(:before_or_node, aNonTerminalNode)
+      traverse_subnodes(aNonTerminalNode)
+    else
+      traverse_subnodes(aNonTerminalNode)
+      broadcast(:before_or_node, aNonTerminalNode)
+    end
+    broadcast(:after_or_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor is visiting the
+  # given terminal node.
+  # @param anEmptyRuleNode [EmptyRuleNode] the node to visit.
+  def visit_empty_rule_node(anEmptyRuleNode)
+    broadcast(:before_empty_rule_node, anEmptyRuleNode)
+    broadcast(:after_empty_rule_node, anEmptyRuleNode)
+  end
+
+  # Visit event. The visitor is visiting the
+  # given terminal node.
+  # @param aTerminalNode [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 aNonTerminalNode [NonTerminalNode] the node to visit.
+  def end_visit_nonterminal(aNonTerminalNode)
+    broadcast(:after_and_node, aNonTerminalNode)
+  end
+
+  # Visit event. The visitor has completed the visit of the root.
+  # @param aParseTree [ParseTree] the root to visit.
+  def end_visit_root(aParseTree)
+    broadcast(:after_root, aParseTree)
+  end
+
+  private
+
+  # Visit event. The visitor is about to visit the subnodes of a non
+  # terminal node.
+  # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
+  def traverse_subnodes(aParentNode)
+    subnodes = aParentNode.children
+    broadcast(:before_subnodes, aParentNode, subnodes)
+
+    # Let's proceed with the visit of subnodes
+    subnodes.each { |a_node| a_node.accept(self) }
+
+    broadcast(:after_subnodes, aParentNode, subnodes)
+  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 |subscr|
+      next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+
+      subscr.send(msg, *args)
+    end
+  end
+end # class

data/lib/dendroid/parsing/parser.rb

@@ -130,7 +130,7 @@ case kode
 when 0
   recognizer = Dendroid::Recognizer::Recognizer.new(grammar_l1, tokenizer_l1)
   chart = recognizer.run('2 + 3 * 4')
-  succ_item =  retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  succ_item = retrieve_success_item(chart, recognizer.grm_analysis.grammar)
   walker = Dendroid::Parsing::ChartWalker.new(chart)
   root = walker.walk(succ_item)
 
@@ -142,7 +142,7 @@ when 0
 when 1
   recognizer = Dendroid::Recognizer::Recognizer.new(grammar_l10, tokenizer_l10)
   chart = recognizer.run('a a a a a')
-  succ_item =  retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  succ_item = retrieve_success_item(chart, recognizer.grm_analysis.grammar)
   walker = Dendroid::Parsing::ChartWalker.new(chart)
   root = walker.walk(succ_item)
 
@@ -153,7 +153,7 @@ when 1
 when 2
   recognizer = Dendroid::Recognizer::Recognizer.new(grammar_l11, tokenizer_l11)
   chart = recognizer.run('a a a a a')
-  succ_item =  retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  succ_item = retrieve_success_item(chart, recognizer.grm_analysis.grammar)
   walker = Dendroid::Parsing::ChartWalker.new(chart)
   root = walker.walk(succ_item)
 
@@ -164,7 +164,7 @@ when 2
 when 3
   recognizer = Dendroid::Recognizer::Recognizer.new(grammar_l31, tokenizer_l1)
   chart = recognizer.run('2 + 3 * 4')
-  succ_item =  retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  succ_item = retrieve_success_item(chart, recognizer.grm_analysis.grammar)
   walker = Dendroid::Parsing::ChartWalker.new(chart)
   root = walker.walk(succ_item)
 
@@ -175,7 +175,7 @@ when 3
 when 4
   recognizer = Dendroid::Recognizer::Recognizer.new(grammar_l8, tokenizer_l8)
   chart = recognizer.run('x x x x')
-  succ_item =  retrieve_success_item(chart, recognizer.grm_analysis.grammar)
+  succ_item = retrieve_success_item(chart, recognizer.grm_analysis.grammar)
   walker = Dendroid::Parsing::ChartWalker.new(chart)
   root = walker.walk(succ_item)
 

data/lib/dendroid/parsing/terminal_node.rb

@@ -1,32 +1,32 @@
-# frozen_string_literal: true
-
-require_relative 'parse_node'
-
-module Dendroid
-  module Parsing
-    class TerminalNode < ParseNode
-      # @return [Dendroid::Syntax::Terminal] Terminal symbol of matching token.
-      attr_reader :symbol
-
-      # @return [Dendroid::Lexical::Token] Matching input token object.
-      attr_reader :token
-
-      def initialize(sym, tok, rank)
-        super(rank, rank + 1)
-        @symbol = sym
-        @token = tok
-      end
-
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param aVisitor[ParseTreeVisitor] the visitor
-      def accept(aVisitor)
-        aVisitor.visit_terminal(self)
-      end
-
-      def to_s()
-        display_val = token.is_a?(Dendroid::Lexical::Literal) ? ": #{token.value}" : ''
-        "#{symbol.name}#{display_val} #{super}"
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'parse_node'
+
+module Dendroid
+  module Parsing
+    class TerminalNode < ParseNode
+      # @return [Dendroid::Syntax::Terminal] Terminal symbol of matching token.
+      attr_reader :symbol
+
+      # @return [Dendroid::Lexical::Token] Matching input token object.
+      attr_reader :token
+
+      def initialize(sym, tok, rank)
+        super(rank, rank + 1)
+        @symbol = sym
+        @token = tok
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_terminal(self)
+      end
+
+      def to_s
+        display_val = token.is_a?(Dendroid::Lexical::Literal) ? ": #{token.value}" : ''
+        "#{symbol.name}#{display_val} #{super}"
+      end
+    end # class
+  end # module
+end # module