Increase test coverage

Author: kddnewton

.rubocop.yml

@@ -16,6 +16,9 @@ Layout/LineLength:
 Lint/DuplicateBranch:
   Enabled: false
 
+Lint/EmptyBlock:
+  Enabled: false
+
 Lint/InterpolationCheck:
   Enabled: false
 
@@ -55,6 +58,9 @@ Style/IfInsideElse:
 Style/KeywordParametersOrder:
   Enabled: false
 
+Style/MissingRespondToMissing:
+  Enabled: false
+
 Style/MutableConstant:
   Enabled: false
 

README.md

@@ -29,6 +29,7 @@ It is built with only standard library dependencies. It additionally ships with
   - [pretty_print(q)](#pretty_printq)
   - [to_json(*opts)](#to_jsonopts)
   - [format(q)](#formatq)
+  - [construct_keys](#construct_keys)
 - [Visitor](#visitor)
   - [visit_method](#visit_method)
 - [Language server](#language-server)
@@ -295,6 +296,27 @@ formatter.output.join
 # => "1 + 1"
 ```
 
+### construct_keys
+
+Every node responds to `construct_keys`, which will return a string that contains a Ruby pattern-matching expression that could be used to match against the current node. It's meant to be used in tooling and through the CLI mostly.
+
+```ruby
+program = SyntaxTree.parse("1 + 1")
+puts program.construct_keys
+
+# SyntaxTree::Program[
+#   statements: SyntaxTree::Statements[            
+#     body: [                                      
+#       SyntaxTree::Binary[                        
+#         left: SyntaxTree::Int[value: "1"],       
+#         operator: :+,                            
+#         right: SyntaxTree::Int[value: "1"]       
+#       ]                                          
+#     ]                                            
+#   ]                                              
+# ] 
+```
+
 ## Visitor
 
 If you want to operate over a set of nodes in the tree but don't want to walk the tree manually, the `Visitor` class makes it easy. `SyntaxTree::Visitor` is an implementation of the double dispatch visitor pattern. It works by the user defining visit methods that process nodes in the tree, which then call back to other visit methods to continue the descent. This is easier shown in code.

lib/syntax_tree.rb

@@ -30,6 +30,16 @@
   end
 end
 
+# When PP is running, it expects that everything that interacts with it is going
+# to flow through PP.pp, since that's the main entry into the module from the
+# perspective of its uses in core Ruby. In doing so, it calls guard_inspect_key
+# at the top of the PP.pp method, which establishes some thread-local hashes to
+# check for cycles in the pretty printed tree. This means that if you want to
+# manually call pp on some object _before_ you have established these hashes,
+# you're going to break everything. So this call ensures that those hashes have
+# been set up before anything uses pp manually.
+PP.new(+"", 0).guard_inspect_key {}
+
 # Syntax Tree is a suite of tools built on top of the internal CRuby parser. It
 # provides the ability to generate a syntax tree from source, as well as the
 # tools necessary to inspect and manipulate that syntax tree. It can be used to
@@ -67,8 +77,10 @@ def self.format(source)
   def self.read(filepath)
     encoding =
       File.open(filepath, "r") do |file|
+        break Encoding.default_external if file.eof?
+
         header = file.readline
-        header += file.readline if header.start_with?("#!")
+        header += file.readline if !file.eof? && header.start_with?("#!")
         Ripper.new(header).tap(&:parse).encoding
       end
 

lib/syntax_tree/cli.rb

@@ -129,10 +129,7 @@ def run(handler, _filepath, source)
     # would match the input given.
     class Match < Action
       def run(handler, _filepath, source)
-        formatter = Formatter.new(source, [])
-        Visitor::MatchVisitor.new(formatter).visit(handler.parse(source))
-        formatter.flush
-        puts formatter.output.join
+        puts handler.parse(source).construct_keys
       end
     end
 
@@ -269,14 +266,7 @@ def run(argv)
           action.run(handler, filepath, source)
         rescue Parser::ParseError => error
           warn("Error: #{error.message}")
-
-          if error.lineno
-            highlight_error(error, source)
-          else
-            warn(error.message)
-            warn(error.backtrace)
-          end
-
+          highlight_error(error, source)
           errored = true
         rescue Check::UnformattedError, Debug::NonIdempotentFormatError
           errored = true

lib/syntax_tree/node.rb

@@ -121,6 +121,10 @@ def to_json(*opts)
       visitor = Visitor::JSONVisitor.new
       visitor.visit(self).to_json(*opts)
     end
+
+    def construct_keys
+      PP.format(+"") { |q| Visitor::MatchVisitor.new(q).visit(self) }
+    end
   end
 
   # BEGINBlock represents the use of the +BEGIN+ keyword, which hooks into the
@@ -7090,15 +7094,6 @@ def child_nodes
     def deconstruct_keys(_keys)
       { value: value, location: location }
     end
-
-    def pretty_print(q)
-      q.group(2, "(", ")") do
-        q.text("qsymbols_beg")
-
-        q.breakable
-        q.pp(value)
-      end
-    end
   end
 
   # QWords represents a string literal array without interpolation.

lib/syntax_tree/visitor/field_visitor.rb

@@ -9,7 +9,46 @@ class Visitor
     #
     # In order to properly use this class, you will need to subclass it and
     # implement #comments, #field, #list, #node, #pairs, and #text. Those are
-    # documented at the bottom of this file.
+    # documented here.
+    #
+    # == comments(node)
+    #
+    # This accepts the node that is being visited and does something depending
+    # on the comments attached to the node.
+    #
+    # == field(name, value)
+    #
+    # This accepts the name of the field being visited as a string (like
+    # "value") and the actual value of that field. The value can be a subclass
+    # of Node or any other type that can be held within the tree.
+    #
+    # == list(name, values)
+    #
+    # This accepts the name of the field being visited as well as a list of
+    # values. This is used, for example, when visiting something like the body
+    # of a Statements node.
+    #
+    # == node(name, node)
+    #
+    # This is the parent serialization method for each node. It is called with
+    # the node itself, as well as the type of the node as a string. The type
+    # is an internally used value that usually resembles the name of the
+    # ripper event that generated the node. The method should yield to the
+    # given block which then calls through to visit each of the fields on the
+    # node.
+    #
+    # == text(name, value)
+    #
+    # This accepts the name of the field being visited as well as a string
+    # value representing the value of the field.
+    #
+    # == pairs(name, values)
+    #
+    # This accepts the name of the field being visited as well as a list of
+    # pairs that represent the value of the field. It is used only in a couple
+    # of circumstances, like when visiting the list of optional parameters
+    # defined on a method.
+    #
     class FieldVisitor < Visitor
       attr_reader :q
 
@@ -220,7 +259,7 @@ def visit_class(node)
       end
 
       def visit_comma(node)
-        node(node, "comma") { field("value", node) }
+        node(node, "comma") { field("value", node.value) }
       end
 
       def visit_command(node)
@@ -491,7 +530,7 @@ def visit_if_mod(node)
       end
 
       def visit_if_op(node)
-        node(node, "ifop") do
+        node(node, "if_op") do
           field("predicate", node.predicate)
           field("truthy", node.truthy)
           field("falsy", node.falsy)
@@ -1065,50 +1104,6 @@ def visit___end__(node)
 
       private
 
-      # This accepts the node that is being visited and does something depending
-      # on the comments attached to the node.
-      def comments(node)
-        raise NotImplementedError
-      end
-
-      # This accepts the name of the field being visited as a string (like
-      # "value") and the actual value of that field. The value can be a subclass
-      # of Node or any other type that can be held within the tree.
-      def field(name, value)
-        raise NotImplementedError
-      end
-
-      # This accepts the name of the field being visited as well as a list of
-      # values. This is used, for example, when visiting something like the body
-      # of a Statements node.
-      def list(name, values)
-        raise NotImplementedError
-      end
-
-      # This is the parent serialization method for each node. It is called with
-      # the node itself, as well as the type of the node as a string. The type
-      # is an internally used value that usually resembles the name of the
-      # ripper event that generated the node. The method should yield to the
-      # given block which then calls through to visit each of the fields on the
-      # node.
-      def node(node, type)
-        raise NotImplementedError
-      end
-
-      # This accepts the name of the field being visited as well as a string
-      # value representing the value of the field.
-      def text(name, value)
-        raise NotImplementedError
-      end
-
-      # This accepts the name of the field being visited as well as a list of
-      # pairs that represent the value of the field. It is used only in a couple
-      # of circumstances, like when visiting the list of optional parameters
-      # defined on a method.
-      def pairs(name, values)
-        raise NotImplementedError
-      end
-
       def visit_token(node, type)
         node(node, type) do
           field("value", node.value)

lib/syntax_tree/visitor/match_visitor.rb

@@ -12,10 +12,17 @@ def initialize(q)
       end
 
       def visit(node)
-        if node.is_a?(Node)
+        case node
+        when Node
           super
+        when String
+          # pp will split up a string on newlines and concat them together using
+          # a "+" operator. This breaks the pattern matching expression. So
+          # instead we're going to check here for strings and manually put the
+          # entire value into the output buffer.
+          q.text(node.inspect)
         else
-          node.pretty_print(q)
+          q.pp(node)
         end
       end
 
@@ -28,7 +35,7 @@ def comments(node)
           q.text("comments: [")
           q.indent do
             q.breakable("")
-            q.seplist(node.comments) { |comment| comment.pretty_print(q) }
+            q.seplist(node.comments) { |comment| visit(comment) }
           end
           q.breakable("")
           q.text("]")
@@ -107,7 +114,7 @@ def text(name, value)
         q.nest(0) do
           q.text(name)
           q.text(": ")
-          value.pretty_print(q)
+          q.pp(value)
         end
       end
     end

lib/syntax_tree/visitor/pretty_print_visitor.rb

@@ -10,6 +10,19 @@ def initialize(q)
         @q = q
       end
 
+      # This is here because we need to make sure the operator is cast to a
+      # string before we print it out.
+      def visit_binary(node)
+        node(node, "binary") do
+          field("left", node.left)
+          text("operator", node.operator.to_s)
+          field("right", node.right)
+          comments(node)
+        end
+      end
+
+      # This is here to make it a little nicer to look at labels since they
+      # typically have their : at the end of the value.
       def visit_label(node)
         node(node, "label") do
           q.breakable
@@ -26,25 +39,18 @@ def comments(node)
 
         q.breakable
         q.group(2, "(", ")") do
-          q.seplist(node.comments) { |comment| comment.pretty_print(q) }
+          q.seplist(node.comments) { |comment| q.pp(comment) }
         end
       end
 
       def field(_name, value)
         q.breakable
-
-        # I don't entirely know why this is necessary, but in Ruby 2.7 there is
-        # an issue with calling q.pp on strings that somehow involves inspect
-        # keys. I'm purposefully avoiding the inspect key stuff here because I
-        # know the tree does not contain any cycles.
-        value.is_a?(String) ? q.text(value.inspect) : value.pretty_print(q)
+        q.pp(value)
       end
 
       def list(_name, values)
         q.breakable
-        q.group(2, "(", ")") do
-          q.seplist(values) { |value| value.pretty_print(q) }
-        end
+        q.group(2, "(", ")") { q.seplist(values) { |value| q.pp(value) } }
       end
 
       def node(_node, type)
@@ -57,13 +63,13 @@ def node(_node, type)
       def pairs(_name, values)
         q.group(2, "(", ")") do
           q.seplist(values) do |(key, value)|
-            key.pretty_print(q)
+            q.pp(key)
 
             if value
               q.text("=")
               q.group(2) do
                 q.breakable("")
-                value.pretty_print(q)
+                q.pp(value)
               end
             end
           end