dendroid 0.2.00 → 0.2.02

data/lib/dendroid/parsing/walk_progress.rb

@@ -1,117 +1,121 @@
-# frozen_string_literal: true
-
-require_relative 'and_node'
-require_relative 'or_node'
-require_relative 'terminal_node'
-require_relative 'empty_rule_node'
-
-module Dendroid
-  module Parsing
-    class WalkProgress
-      attr_accessor :state
-      attr_accessor :curr_rank
-      attr_reader :curr_item
-      attr_accessor :predecessor
-      attr_reader :parents
-
-      def initialize(start_rank, start_item, parents)
-        @state = :New
-        @curr_rank = start_rank
-        @curr_item = start_item
-        @predecessor = nil
-        @parents = parents
-      end
-
-      # Factory method.
-      def initialize_copy(orig)
-        @state = orig.state
-        @curr_rank = orig.curr_rank
-        @curr_item = orig.curr_item
-        @predecessor = nil
-        @parents = orig.parents.dup
-      end
-
-      def fork(thePredecessor)
-        @state = :Forking
-        @predecessor = thePredecessor
-      end
-
-      def curr_item=(anEntry)
-        if anEntry.nil?
-          raise StandardError
-        else
-          @curr_item = anEntry
-        end
-      end
-
-      def add_node_empty(anEntry)
-        node_empty = EmptyRuleNode.new(anEntry, curr_rank)
-        add_child_node(node_empty)
-      end
-
-      # Add a terminal node for terminal at current rank as a child of last parent
-      def add_terminal_node(token)
-        @curr_rank -= 1
-        term_node = TerminalNode.new(curr_item.prev_symbol, token, curr_rank)
-        add_child_node(term_node)
-      end
-
-      # Add an AND node for given entry as a child of last parent
-      def push_and_node(anEntry)
-        node = ANDNode.new(anEntry, curr_rank)
-        raise StandardError unless anEntry.rule == node.rule # Fails
-        add_child_node(node)
-        parents.push(node)
-
-        node
-      end
-
-      def push_or_node(origin, arity)
-        node = OrNode.new(curr_item.prev_symbol, origin, curr_rank, arity)
-        add_child_node(node)
-        parents.push(node)
-
-        node
-      end
-
-      def add_child_node(aNode)
-        parents.last.add_child(aNode, curr_item.position - 1)
-        aNode
-      end
-
-      # Do the given EItems match one of the parent?
-      # Matching = corresponds to the same rule and range
-      # @return [Array<EItem>]
-      def match_parent?(entries, stop_at_first)
-        matching = []
-        min_origin = entries[0].origin
-        first_iteration = true
-        offset = 0
-
-        parents.reverse_each do |node|
-          if node.is_a?(OrNode)
-            offset += 1
-            next
-          end
-          entries.each do |ent|
-            if first_iteration
-              min_origin = ent.origin if ent.origin < min_origin
-            end
-            next unless node.match(ent)
-
-            matching << [ent, offset]
-            break if stop_at_first
-          end
-          first_iteration = false
-          break if stop_at_first && !matching.empty?
-
-          # Stop loop when parent.origin < min(entries.origin)
-          break if node.range[0] < min_origin
-          offset += 1
-        end
-
-        matching
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'and_node'
+require_relative 'or_node'
+require_relative 'terminal_node'
+require_relative 'empty_rule_node'
+
+module Dendroid
+  module Parsing
+    class WalkProgress
+      attr_accessor :state
+      attr_accessor :curr_rank
+      attr_reader :curr_item
+      attr_accessor :predecessor
+      attr_reader :parents
+
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
+      def initialize(start_rank, start_item, parents)
+        @state = :New
+        @curr_rank = start_rank
+        @curr_item = start_item
+        @predecessor = nil
+        @parents = parents
+      end
+
+      # Factory method.
+      def initialize_copy(orig)
+        @state = orig.state
+        @curr_rank = orig.curr_rank
+        @curr_item = orig.curr_item
+        @predecessor = nil
+        @parents = orig.parents.dup
+      end
+
+      def fork(thePredecessor)
+        @state = :Forking
+        @predecessor = thePredecessor
+      end
+
+      def curr_item=(anEntry)
+        raise StandardError if anEntry.nil?
+
+        @curr_item = anEntry
+      end
+
+      def add_node_empty(anEntry)
+        node_empty = EmptyRuleNode.new(anEntry, curr_rank)
+        add_child_node(node_empty)
+      end
+
+      # Add a terminal node for terminal at current rank as a child of last parent
+      def add_terminal_node(token)
+        @curr_rank -= 1
+        term_node = TerminalNode.new(curr_item.prev_symbol, token, curr_rank)
+        add_child_node(term_node)
+      end
+
+      # Add an AND node for given entry as a child of last parent
+      def push_and_node(anEntry)
+        node = ANDNode.new(anEntry, curr_rank)
+        raise StandardError unless anEntry.rule == node.rule # Fails
+
+        add_child_node(node)
+        parents.push(node)
+
+        node
+      end
+
+      def push_or_node(origin, arity)
+        node = OrNode.new(curr_item.prev_symbol, origin, curr_rank, arity)
+        add_child_node(node)
+        parents.push(node)
+
+        node
+      end
+
+      def add_child_node(aNode)
+        parents.last.add_child(aNode, curr_item.position - 1)
+        aNode
+      end
+
+      # Do the given EItems match one of the parent?
+      # Matching = corresponds to the same rule and range
+      # @return [Array<EItem>]
+      def match_parent?(entries, stop_at_first)
+        matching = []
+        min_origin = entries[0].origin
+        first_iteration = true
+        offset = 0
+
+        parents.reverse_each do |node|
+          if node.is_a?(OrNode)
+            offset += 1
+            next
+          end
+          entries.each do |ent|
+            min_origin = ent.origin if first_iteration && ent.origin < min_origin
+            next unless node.match(ent)
+
+            matching << [ent, offset]
+            break if stop_at_first
+          end
+          first_iteration = false
+          break if stop_at_first && !matching.empty?
+
+          # Stop loop when parent.origin < min(entries.origin)
+          break if node.range[0] < min_origin
+
+          offset += 1
+        end
+
+        matching
+      end
+    end # class
+
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/PerceivedComplexity
+  end # module
+end # module

data/lib/dendroid/recognizer/chart.rb

@@ -16,7 +16,7 @@ module Dendroid
       attr_reader :item_sets
 
       # @return [Array<Dendroid::Lexical::Token>] The input tokens
-      attr_reader :tokens
+      attr_accessor :tokens
 
       # @return [Boolean] Indicates whether the recognizer successfully processed the whole input
       attr_writer :success
@@ -48,11 +48,6 @@ module Dendroid
         item_sets.last.add_item(e_item)
       end
 
-      # @param input_tokens [Array<Dendroid::Lexical::Token>] The input tokens
-      def tokens=(input_tokens)
-        @tokens = input_tokens
-      end
-
       # Return true if the input text is valid according to the grammar.
       # @return [Boolean]
       def successful?

data/lib/dendroid/recognizer/recognizer.rb

@@ -5,7 +5,7 @@ require_relative 'e_item'
 require_relative 'chart'
 
 module Dendroid
-  # This module host classes needed to implement an Earley recognizer
+  # This module host classes needed to implement an Earley recognizer.
   module Recognizer
     # A recognizer determines whether the input text complies to the grammar (syntax) rules.
     # This class implements the Earley recognition algorithm.
@@ -16,6 +16,10 @@ module Dendroid
       # @return [Object]
       attr_reader :tokenizer
 
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # @param grammar [Dendroid::Syntax::Grammar]
       # @param tokenizer [Object]
       def initialize(grammar, tokenizer)
@@ -120,7 +124,7 @@ module Dendroid
       #   Assuming next symbol is a non-terminal
       #
       #   Error case: next actual token matches none of the expected tokens.
-      def predictor(chart, item, rank, tokens, mode, predicted_symbols)
+      def predictor(chart, item, rank, tokens, mode, _predicted_symbols)
         next_symbol = item.next_symbol
         # if mode == :genuine
         #   predicted_symbols << Set.new if rank == predicted_symbols.size
@@ -149,9 +153,7 @@ module Dendroid
         next_item = grm_analysis.next_item(item.dotted_item)
         return unless next_item
 
-        special = add_item(curr_set, next_item, item.origin, nil, :predictor)
-        # special = add_item(curr_set, next_item, item.origin, added.shift, :predictor)
-        # added.each { |e|  special.add_predecessor(e) }
+        add_item(curr_set, next_item, item.origin, nil, :predictor)
       end
 
       # procedure SCANNER((A → α•aβ, j), k, words)
@@ -263,7 +265,7 @@ module Dendroid
 
       def expected_terminals(chart)
         last_set = chart.last
-        terminals = last_set.items.reduce([]) do |result, ent|
+        terminals = last_set.items.each_with_object([]) do |ent, result|
           result << ent.next_symbol if ent.pre_scan?
           result
         end
@@ -282,5 +284,9 @@ module Dendroid
         end
       end
     end # class
+
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/PerceivedComplexity
   end # module
 end # module

data/lib/dendroid/syntax/grammar.rb

@@ -39,6 +39,8 @@ module Dendroid
         add_terminals(terminals)
       end
 
+      # rubocop: disable Style/IfUnlessModifier
+
       # Add a rule to the grammar.
       # @param rule [Dendroid::Syntax::Rule]
       def add_rule(rule)
@@ -55,6 +57,7 @@ module Dendroid
         rules << rule
         nonterm2production[rule.head] = rule
       end
+      # rubocop: enable Style/IfUnlessModifier
 
       # Return the start symbol for the language, that is,
       # the non-terminal symbol used to denote the top-level
@@ -267,11 +270,6 @@ module Dendroid
           end
         end
 
-        # symbols.each do |sym|
-        #   next if sym.terminal?
-        #
-        #   sym.nullable = false if sym.nullable.nil?
-        # end
         symbols.each do |sym|
           next if sym.terminal? || sym.nullable?
 

data/lib/dendroid/syntax/rule.rb

@@ -106,7 +106,7 @@ module Dendroid
       def valid_alternatives(alt)
         raise StandardError, "Expecting an Array, found a #{rhs.class} instead." unless alt.is_a?(Array)
 
-        if alt.size.zero?
+        if alt.empty?
           # A choice must have at least two alternatives
           raise StandardError, "The choice for `#{head}` must have at least one alternative."
         end

data/lib/dendroid.rb

@@ -1,5 +1,18 @@
 # frozen_string_literal: true
 
+# File: dendroid.rb
+
 # Namespace for all modules, classes and constants from Dendroid library.
 module Dendroid
 end # module
+
+
+# This file acts as a jumping-off point for loading dependencies expected
+# for a Dendroid client.
+
+require_relative './dendroid/grm_dsl/base_grm_builder'
+require_relative './dendroid/utils/base_tokenizer'
+require_relative './dendroid/recognizer/recognizer'
+require_relative './dendroid/parsing/chart_walker'
+require_relative './dendroid/parsing/parse_tree_visitor'
+require_relative './dendroid//formatters/ascii_tree'

data/spec/dendroid/grm_analysis/dotted_item_spec.rb

@@ -61,7 +61,7 @@ describe Dendroid::GrmAnalysis::DottedItem do
       expect(described_class.new(choice, 0, 1)).not_to be_final_pos
       expect(described_class.new(choice, 2, 1)).not_to be_final_pos
       expect(described_class.new(choice, 3, 1)).to be_final_pos
-      expect(described_class.new(choice, 3,1)).to be_completed
+      expect(described_class.new(choice, 3, 1)).to be_completed
 
       # Case of an empty alternative
       expect(described_class.new(choice, 0, 2)).to be_final_pos