dendroid 0.2.00 → 0.2.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb2bba5cca25fb6a95bfa820891edb4882595062be6a3a439a0fee8c2515efb1
-  data.tar.gz: 52643afdeded2e2944e93124267c009d6c496ab6d645d4878087072f24685e67
+  metadata.gz: bb58d7b275f7eb65ccfef37ee213fc53319c5634cf8dbd79020451c79769a3c3
+  data.tar.gz: f075b751545df13bda67d3e2df1c3861dfdaffa8fc416a7a735d0c4fc2da01bb
 SHA512:
-  metadata.gz: 47db9f266723dc8d292bdc8cbb7006bd8e9da8471bd89e933312231bf26ba90e5c40e7bf3e6eead665918a968f476705936507b66b753debde18391a4fa6936a
-  data.tar.gz: 2fdc6b316b2f250644818af70ea40bf68c263776fcbb751ac2b05e03555194a3d86344f28574d3d6efd1a303f0d89c619f7ac199d57468c5e8eddff9f397f123
+  metadata.gz: 1f3598bbc4f19ff183e655a92ca86908615a10b2f142982c09eb11b01b9fd05296db1ce5b9fa14be9d5f71c8358fd60535a0eb8b0feea8fcddafae5100fe8df4
+  data.tar.gz: c3227a5e8cb2675d2de6d011091e3b665e0217e62401619db36e43967a9d407c06a50205031c03dacc43f72b01cd1b0ebf66132240194d61de1ae1e167594113

data/.rubocop.yml

@@ -37,3 +37,6 @@ Style/AccessorGrouping:
 
 Style/CommentedKeyword:
   Enabled: false
+  
+Style/ParallelAssignment:
+  Enabled: false

data/CHANGELOG.md

@@ -2,9 +2,25 @@
 
 ## [Unreleased]
 
+## [0.2.02] - 2023-12-18
+Code re-styling to fix most Rubocop offenses.
+
+### Added
+- Directory 'modeling' for PlantUML text files.
+
+### Changed
+- File `dendroid.rb`: added `relative_require` to load key dependencies. 
+
+## [0.2.01] - 2023-12-17
+Code re-styling to fix most Rubocop offenses.
+
 ## [0.2.00] - 2023-12-16
 Version bump: Very crude parser implementation (generate shared parse forests in case of ambiguity).
 
+### Added
+- Directory `parsing`: module implementing a parser
+- Directory `formatters`: module with classes for rendering parse tree/forest 
+
 ## [0.1.00] - 2023-11-03
 Version bump: the Earley recognizer is functional.
 

data/lib/dendroid/formatters/ascii_tree.rb

@@ -1,142 +1,142 @@
-# frozen_string_literal: true
-
-require_relative 'base_formatter'
-
-# A formatter class that draws parse trees by using characters
-class Asciitree < BaseFormatter
-  # TODO
-  attr_reader(:curr_path)
-
-  # For each node in curr_path, there is a corresponding string value.
-  # Allowed string values are: 'first', 'last', 'first_and_last', 'other'
-  attr_reader(:ranks)
-
-  # @return [String] The character pattern used for rendering
-  # a parent - child nesting
-  attr_reader(:and_nesting_prefix)
-
-  # TODO: comment
-  attr_reader(:or_nesting_prefix)
-
-  # @return [String] The character pattern used for a blank indentation
-  attr_reader(:blank_indent)
-
-  # @return [String] The character pattern for indentation and nesting
-  # continuation.
-  attr_reader(:continuation_indent)
-
-  # Constructor.
-  # @param anIO [IO] The output stream to which the parse tree
-  # is written.
-  def initialize(anIO)
-    super(anIO)
-    @curr_path = []
-    @ranks = []
-
-    @and_nesting_prefix = '+-- '
-    @or_nesting_prefix = '/-- '
-    @blank_indent = '    '
-    @continuation_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<ParseTreeNode>] array of children nodes
-  def before_subnodes(parent, _children)
-    rank_of(parent)
-    curr_path << parent
-  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 aNonTerm [NonTerminalNode]
-  def before_and_node(aNonTerm)
-    emit_and(aNonTerm)
-  end
-
-  def before_or_node(aNonTerm)
-    emit_or(aNonTerm)
-  end
-
-  def before_empty_rule_node(anEmptyRuleNode)
-    emit_and(anEmptyRuleNode, ': .')
-  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 aTerm [TerminalNode]
-  def before_terminal(aTerm)
-    emit_terminal(aTerm, ": '#{aTerm.token.source}'")
-  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)
-    curr_path.pop
-    ranks.pop
-  end
-
-  private
-
-  # Parent node is last node in current path
-  # or current path is empty (then aChild is root node)
-  def rank_of(aChild)
-    if curr_path.empty?
-      rank = 'root'
-    elsif curr_path[-1].children.size == 1
-      rank = 'first_and_last'
-    else
-      parent = curr_path[-1]
-      siblings = parent.children
-      siblings_last_index = siblings.size - 1
-      rank = case siblings.find_index(aChild)
-             when 0 then 'first'
-             when siblings_last_index then 'last'
-             else
-               'other'
-             end
-    end
-    ranks << rank
-  end
-
-  # 'root', 'first', 'first_and_last', 'last', 'other'
-  def path_prefix(connector)
-    return '' if ranks.empty?
-
-    prefix = +''
-    @ranks.each_with_index do |rank, i|
-      next if i.zero?
-
-      case rank
-      when 'first', 'other'
-        prefix << continuation_indent
-
-      when 'last', 'first_and_last', 'root'
-        prefix << blank_indent
-      end
-    end
-
-    nesting = (connector == :and) ? and_nesting_prefix : or_nesting_prefix
-    prefix << nesting
-    prefix
-  end
-
-  def emit_and(aNode, aSuffix = '')
-    output.puts("#{path_prefix(:and)}#{aNode.rule.lhs.name}#{aSuffix}")
-  end
-
-  def emit_or(aNode, aSuffix = '')
-    output.puts("#{path_prefix(:or)}OR #{aNode.symbol.name}#{aSuffix}")
-  end
-
-  def emit_terminal(aNode, aSuffix = '')
-    output.puts("#{path_prefix(:and)}#{aNode.symbol.name}#{aSuffix}")
-  end
-end # class
+# frozen_string_literal: true
+
+require_relative 'base_formatter'
+
+# A formatter class that draws parse trees by using characters
+class Asciitree < BaseFormatter
+  # TODO
+  attr_reader(:curr_path)
+
+  # For each node in curr_path, there is a corresponding string value.
+  # Allowed string values are: 'first', 'last', 'first_and_last', 'other'
+  attr_reader(:ranks)
+
+  # @return [String] The character pattern used for rendering
+  # a parent - child nesting
+  attr_reader(:and_nesting_prefix)
+
+  # TODO: comment
+  attr_reader(:or_nesting_prefix)
+
+  # @return [String] The character pattern used for a blank indentation
+  attr_reader(:blank_indent)
+
+  # @return [String] The character pattern for indentation and nesting
+  # continuation.
+  attr_reader(:continuation_indent)
+
+  # Constructor.
+  # @param anIO [IO] The output stream to which the parse tree
+  # is written.
+  def initialize(anIO)
+    super(anIO)
+    @curr_path = []
+    @ranks = []
+
+    @and_nesting_prefix = '+-- '
+    @or_nesting_prefix = '/-- '
+    @blank_indent = '    '
+    @continuation_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<ParseTreeNode>] array of children nodes
+  def before_subnodes(parent, _children)
+    rank_of(parent)
+    curr_path << parent
+  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 aNonTerm [NonTerminalNode]
+  def before_and_node(aNonTerm)
+    emit_and(aNonTerm)
+  end
+
+  def before_or_node(aNonTerm)
+    emit_or(aNonTerm)
+  end
+
+  def before_empty_rule_node(anEmptyRuleNode)
+    emit_and(anEmptyRuleNode, ': .')
+  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 aTerm [TerminalNode]
+  def before_terminal(aTerm)
+    emit_terminal(aTerm, ": '#{aTerm.token.source}'")
+  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)
+    curr_path.pop
+    ranks.pop
+  end
+
+  private
+
+  # Parent node is last node in current path
+  # or current path is empty (then aChild is root node)
+  def rank_of(aChild)
+    if curr_path.empty?
+      rank = 'root'
+    elsif curr_path[-1].children.size == 1
+      rank = 'first_and_last'
+    else
+      parent = curr_path[-1]
+      siblings = parent.children
+      siblings_last_index = siblings.size - 1
+      rank = case siblings.find_index(aChild)
+             when 0 then 'first'
+             when siblings_last_index then 'last'
+             else
+               'other'
+             end
+    end
+    ranks << rank
+  end
+
+  # 'root', 'first', 'first_and_last', 'last', 'other'
+  def path_prefix(connector)
+    return '' if ranks.empty?
+
+    prefix = +''
+    @ranks.each_with_index do |rank, i|
+      next if i.zero?
+
+      case rank
+      when 'first', 'other'
+        prefix << continuation_indent
+
+      when 'last', 'first_and_last', 'root'
+        prefix << blank_indent
+      end
+    end
+
+    nesting = connector == :and ? and_nesting_prefix : or_nesting_prefix
+    prefix << nesting
+    prefix
+  end
+
+  def emit_and(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:and)}#{aNode.rule.lhs.name}#{aSuffix}")
+  end
+
+  def emit_or(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:or)}OR #{aNode.symbol.name}#{aSuffix}")
+  end
+
+  def emit_terminal(aNode, aSuffix = '')
+    output.puts("#{path_prefix(:and)}#{aNode.symbol.name}#{aSuffix}")
+  end
+end # class

data/lib/dendroid/formatters/base_formatter.rb

@@ -1,25 +1,24 @@
-# frozen_string_literal: true
-
-
-# Superclass for parse tree formatters.
-class BaseFormatter
-  # The IO output stream in which the formatter's result will be sent.
-  # @return [IO] The output stream for the formatter.
-  attr_reader(:output)
-
-  # Constructor.
-  # @param anIO [IO] an output IO where the formatter's result will
-  # be placed.
-  def initialize(anIO)
-    @output = anIO
-  end
-
-  # Given a parse tree visitor, perform the visit
-  # and render the visit events in the output stream.
-  # @param aVisitor [ParseTreeVisitor]
-  def render(aVisitor)
-    aVisitor.subscribe(self)
-    aVisitor.start
-    aVisitor.unsubscribe(self)
-  end
-end # class
+# frozen_string_literal: true
+
+# Superclass for parse tree formatters.
+class BaseFormatter
+  # The IO output stream in which the formatter's result will be sent.
+  # @return [IO] The output stream for the formatter.
+  attr_reader(:output)
+
+  # Constructor.
+  # @param anIO [IO] an output IO where the formatter's result will
+  # be placed.
+  def initialize(anIO)
+    @output = anIO
+  end
+
+  # Given a parse tree visitor, perform the visit
+  # and render the visit events in the output stream.
+  # @param aVisitor [ParseTreeVisitor]
+  def render(aVisitor)
+    aVisitor.subscribe(self)
+    aVisitor.start
+    aVisitor.unsubscribe(self)
+  end
+end # class

data/lib/dendroid/formatters/bracket_notation.rb

@@ -1,50 +1,50 @@
-# frozen_string_literal: true
-
-require_relative 'base_formatter'
-
-class BracketNotation < BaseFormatter
-  # 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 and_node [ANDNode]
-  def before_and_node(and_node)
-    write("[#{and_node.rule.lhs.name} ")
-  end
-
-  def before_empty_rule_node(anEmptyRuleNode)
-    write("[#{anEmptyRuleNode.rule.lhs.name}]")
-  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 aTerm [TerminalNode]
-  def before_terminal(aTerm)
-    write("[#{aTerm.symbol.name} ")
-  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 aTerm [TerminalNode]
-  def after_terminal(aTerm)
-    # Escape all opening and closing square brackets
-    escape_lbrackets = aTerm.token.source.gsub(/\[/, '\[')
-    escaped = escape_lbrackets.gsub(/\]/, '\]')
-    write("#{escaped}]")
-  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_and_node(_nonterm)
-    write(']')
-  end
-
-  private
-
-  def write(aText)
-    output.write(aText)
-  end
-end # class
+# frozen_string_literal: true
+
+require_relative 'base_formatter'
+
+class BracketNotation < BaseFormatter
+  # 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 and_node [ANDNode]
+  def before_and_node(and_node)
+    write("[#{and_node.rule.lhs.name} ")
+  end
+
+  def before_empty_rule_node(anEmptyRuleNode)
+    write("[#{anEmptyRuleNode.rule.lhs.name}]")
+  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 aTerm [TerminalNode]
+  def before_terminal(aTerm)
+    write("[#{aTerm.symbol.name} ")
+  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 aTerm [TerminalNode]
+  def after_terminal(aTerm)
+    # Escape all opening and closing square brackets
+    escape_lbrackets = aTerm.token.source.gsub(/\[/, '\[')
+    escaped = escape_lbrackets.gsub(/\]/, '\]')
+    write("#{escaped}]")
+  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_and_node(_nonterm)
+    write(']')
+  end
+
+  private
+
+  def write(aText)
+    output.write(aText)
+  end
+end # class

data/lib/dendroid/grm_analysis/dotted_item.rb

@@ -87,7 +87,6 @@ module Dendroid
         position == rule.alternatives[alt_index].size ? :completed : :partial
       end
 
-
       # Return the symbol right after the dot (if any)
       # @return [Dendroid::Syntax::GrmSymbol, NilClass]
       def next_symbol

data/lib/dendroid/grm_analysis/grm_analyzer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../grm_analysis/rule_items.rb'
+require_relative '../grm_analysis/rule_items'
 
 module Dendroid
   module GrmAnalysis
@@ -111,6 +111,10 @@ module Dendroid
         result
       end
 
+      # rubocop: disable Metrics/AbcSize
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+
       # FOLLOW(A): is the set of terminals (+ end marker) that may come after the
       # non-terminal A.
       def build_follow_sets
@@ -155,6 +159,10 @@ module Dendroid
         end
       end
 
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
+
       def initialize_follow_sets
         grammar.symbols.each do |symb|
           next if symb.terminal?

data/lib/dendroid/grm_analysis/rule_items.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'dotted_item.rb'
+require_relative 'dotted_item'
 
 module Dendroid
   module GrmAnalysis

data/lib/dendroid/parsing/and_node.rb

@@ -1,56 +1,54 @@
-# frozen_string_literal: true
-
-require_relative 'composite_parse_node'
-
-module Dendroid
-  module Parsing
-    class ANDNode < CompositeParseNode
-      attr_reader :rule
-      attr_reader :alt_index
-
-      def initialize(anEItem, rank)
-        @rule = WeakRef.new(anEItem.dotted_item.rule)
-        @alt_index = anEItem.dotted_item.alt_index
-        upper_bound = rank
-        super(anEItem.origin, upper_bound, rule.rhs[alt_index].size)
-      end
-
-      def add_child(child_node, index)
-        if children[index].nil? # Is slot available?
-          super(child_node, index)
-        else
-          raise StandardError
-        end
-      end
-
-      def match(anEItem)
-        return false if range[0] != anEItem.origin
-
-        dotted = anEItem.dotted_item
-        same_rule = (rule.lhs == dotted.rule.lhs) && (alt_index == dotted.alt_index)
-        return false unless same_rule
-
-        dotted.initial_pos? ? true : partial?
-      end
-
-      def expecting?(symbol, position)
-        symb_seq = rule.rhs[alt_index]
-        symb_seq[position] == symbol
-      end
-
-      def partial?
-        children.any?(&:nil?)
-      end
-
-      def to_s
-        "#{rule.lhs} => #{rule.rhs[alt_index]} #{range}"
-      end
-
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param aVisitor[ParseTreeVisitor] the visitor
-      def accept(aVisitor)
-        aVisitor.visit_and_node(self)
-      end
-    end # class
-  end # module
-end # module
+# frozen_string_literal: true
+
+require_relative 'composite_parse_node'
+
+module Dendroid
+  module Parsing
+    class ANDNode < CompositeParseNode
+      attr_reader :rule
+      attr_reader :alt_index
+
+      def initialize(anEItem, rank)
+        @rule = WeakRef.new(anEItem.dotted_item.rule)
+        @alt_index = anEItem.dotted_item.alt_index
+        upper_bound = rank
+        super(anEItem.origin, upper_bound, rule.rhs[alt_index].size)
+      end
+
+      def add_child(child_node, index)
+        raise StandardError unless children[index].nil? # Is slot available?
+
+        super(child_node, index)
+      end
+
+      def match(anEItem)
+        return false if range[0] != anEItem.origin
+
+        dotted = anEItem.dotted_item
+        same_rule = (rule.lhs == dotted.rule.lhs) && (alt_index == dotted.alt_index)
+        return false unless same_rule
+
+        dotted.initial_pos? ? true : partial?
+      end
+
+      def expecting?(symbol, position)
+        symb_seq = rule.rhs[alt_index]
+        symb_seq[position] == symbol
+      end
+
+      def partial?
+        children.any?(&:nil?)
+      end
+
+      def to_s
+        "#{rule.lhs} => #{rule.rhs[alt_index]} #{range}"
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param aVisitor[ParseTreeVisitor] the visitor
+      def accept(aVisitor)
+        aVisitor.visit_and_node(self)
+      end
+    end # class
+  end # module
+end # module