syntax_tree 2.3.0 → 2.4.1

data/lib/syntax_tree/formatter/single_quotes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class Formatter
+    # This module overrides the quote method on the formatter to use single
+    # quotes for everything instead of double quotes.
+    module SingleQuotes
+      def quote
+        "'"
+      end
+    end
+  end
+end

data/lib/syntax_tree/formatter.rb

@@ -41,11 +41,12 @@ module SyntaxTree
 
         # If the node has a stree-ignore comment right before it, then we're
         # going to just print out the node as it was seen in the source.
-        if leading.last&.ignore?
-          doc = text(source[node.location.start_char...node.location.end_char])
-        else
-          doc = node.format(self)
-        end
+        doc =
+          if leading.last&.ignore?
+            text(source[node.location.start_char...node.location.end_char])
+          else
+            node.format(self)
+          end
 
         # Print all comments that were found after the node.
         trailing.each do |comment|

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -2,14 +2,79 @@
 
 module SyntaxTree
   class LanguageServer
-    class InlayHints
-      attr_reader :before, :after
+    # This class provides inlay hints for the language server. It is loosely
+    # designed around the LSP spec, but existed before the spec was finalized so
+    # is a little different for now.
+    #
+    # For more information, see the spec here:
+    # https://github.com/microsoft/language-server-protocol/issues/956.
+    #
+    class InlayHints < Visitor
+      attr_reader :stack, :before, :after
 
       def initialize
+        @stack = []
         @before = Hash.new { |hash, key| hash[key] = +"" }
         @after = Hash.new { |hash, key| hash[key] = +"" }
       end
 
+      def visit(node)
+        stack << node
+        result = super
+        stack.pop
+        result
+      end
+
+      # Adds parentheses around assignments contained within the default values
+      # of parameters. For example,
+      #
+      #     def foo(a = b = c)
+      #     end
+      #
+      # becomes
+      #
+      #     def foo(a = ₍b = c₎)
+      #     end
+      #
+      def visit_assign(node)
+        parentheses(node.location) if stack[-2].is_a?(Params)
+      end
+
+      # Adds parentheses around binary expressions to make it clear which
+      # subexpression will be evaluated first. For example,
+      #
+      #     a + b * c
+      #
+      # becomes
+      #
+      #     a + ₍b * c₎
+      #
+      def visit_binary(node)
+        case stack[-2]
+        in Assign | OpAssign
+          parentheses(node.location)
+        in Binary[operator: operator] if operator != node.operator
+          parentheses(node.location)
+        else
+        end
+      end
+
+      # Adds parentheses around ternary operators contained within certain
+      # expressions where it could be confusing which subexpression will get
+      # evaluated first. For example,
+      #
+      #     a ? b : c ? d : e
+      #
+      # becomes
+      #
+      #     a ? b : ₍c ? d : e₎
+      #
+      def visit_if_op(node)
+        if stack[-2] in Assign | Binary | IfOp | OpAssign
+          parentheses(node.location)
+        end
+      end
+
       # Adds the implicitly rescued StandardError into a bare rescue clause. For
       # example,
       #
@@ -23,54 +88,38 @@ module SyntaxTree
       #     rescue StandardError
       #     end
       #
-      def bare_rescue(location)
-        after[location.start_char + "rescue".length] << " StandardError"
+      def visit_rescue(node)
+        if node.exception.nil?
+          after[node.location.start_char + "rescue".length] << " StandardError"
+        end
       end
 
-      # Adds implicit parentheses around certain expressions to make it clear
-      # which subexpression will be evaluated first. For example,
+      # Adds parentheses around unary statements using the - operator that are
+      # contained within Binary nodes. For example,
       #
-      #     a + b * c
+      #     -a + b
       #
       # becomes
       #
-      #     a + ₍b * c₎
+      #     ₍-a₎ + b
       #
-      def precedence_parentheses(location)
-        before[location.start_char] << "₍"
-        after[location.end_char] << "₎"
+      def visit_unary(node)
+        if stack[-2].is_a?(Binary) && (node.operator == "-")
+          parentheses(node.location)
+        end
       end
 
       def self.find(program)
-        inlay_hints = new
-        queue = [[nil, program]]
-
-        until queue.empty?
-          parent_node, child_node = queue.shift
-
-          child_node.child_nodes.each do |grand_child_node|
-            queue << [child_node, grand_child_node] if grand_child_node
-          end
+        visitor = new
+        visitor.visit(program)
+        visitor
+      end
 
-          case [parent_node, child_node]
-          in _, Rescue[exception: nil, location:]
-            inlay_hints.bare_rescue(location)
-          in Assign | Binary | IfOp | OpAssign, IfOp[location:]
-            inlay_hints.precedence_parentheses(location)
-          in Assign | OpAssign, Binary[location:]
-            inlay_hints.precedence_parentheses(location)
-          in Binary[operator: parent_oper], Binary[operator: child_oper, location:] if parent_oper != child_oper
-            inlay_hints.precedence_parentheses(location)
-          in Binary, Unary[operator: "-", location:]
-            inlay_hints.precedence_parentheses(location)
-          in Params, Assign[location:]
-            inlay_hints.precedence_parentheses(location)
-          else
-            # do nothing
-          end
-        end
+      private
 
-        inlay_hints
+      def parentheses(location)
+        before[location.start_char] << "₍"
+        after[location.end_char] << "₎"
       end
     end
   end

data/lib/syntax_tree/language_server.rb

@@ -7,10 +7,15 @@ require "uri"
 require_relative "language_server/inlay_hints"
 
 module SyntaxTree
+  # Syntax Tree additionally ships with a language server conforming to the
+  # language server protocol. It can be invoked through the CLI by running:
+  #
+  #     stree lsp
+  #
   class LanguageServer
     attr_reader :input, :output
 
-    def initialize(input: STDIN, output: STDOUT)
+    def initialize(input: $stdin, output: $stdout)
       @input = input.binmode
       @output = output.binmode
     end
@@ -21,7 +26,7 @@ module SyntaxTree
           hash[uri] = File.binread(CGI.unescape(URI.parse(uri).path))
         end
 
-      while headers = input.gets("\r\n\r\n")
+      while (headers = input.gets("\r\n\r\n"))
         source = input.read(headers[/Content-Length: (\d+)/i, 1].to_i)
         request = JSON.parse(source, symbolize_names: true)
 
@@ -29,26 +34,46 @@ module SyntaxTree
         in { method: "initialize", id: }
           store.clear
           write(id: id, result: { capabilities: capabilities })
-        in { method: "initialized" }
+        in method: "initialized"
           # ignored
-        in { method: "shutdown" }
+        in method: "shutdown"
           store.clear
           return
-        in { method: "textDocument/didChange", params: { textDocument: { uri: }, contentChanges: [{ text: }, *] } }
+        in {
+             method: "textDocument/didChange",
+             params: { textDocument: { uri: }, contentChanges: [{ text: }, *] }
+           }
           store[uri] = text
-        in { method: "textDocument/didOpen", params: { textDocument: { uri:, text: } } }
+        in {
+             method: "textDocument/didOpen",
+             params: { textDocument: { uri:, text: } }
+           }
           store[uri] = text
-        in { method: "textDocument/didClose", params: { textDocument: { uri: } } }
+        in {
+             method: "textDocument/didClose", params: { textDocument: { uri: } }
+           }
           store.delete(uri)
-        in { method: "textDocument/formatting", id:, params: { textDocument: { uri: } } }
+        in {
+             method: "textDocument/formatting",
+             id:,
+             params: { textDocument: { uri: } }
+           }
           write(id: id, result: [format(store[uri])])
-        in { method: "textDocument/inlayHints", id:, params: { textDocument: { uri: } } }
+        in {
+             method: "textDocument/inlayHints",
+             id:,
+             params: { textDocument: { uri: } }
+           }
           write(id: id, result: inlay_hints(store[uri]))
-        in { method: "syntaxTree/visualizing", id:, params: { textDocument: { uri: } } }
+        in {
+             method: "syntaxTree/visualizing",
+             id:,
+             params: { textDocument: { uri: } }
+           }
           output = []
           PP.pp(SyntaxTree.parse(store[uri]), output)
           write(id: id, result: output.join)
-        in { method: %r{\$/.+} }
+        in method: %r{\$/.+}
           # ignored
         else
           raise "Unhandled: #{request}"
@@ -61,15 +86,24 @@ module SyntaxTree
     def capabilities
       {
         documentFormattingProvider: true,
-        textDocumentSync: { change: 1, openClose: true }
+        textDocumentSync: {
+          change: 1,
+          openClose: true
+        }
       }
     end
 
     def format(source)
       {
         range: {
-          start: { line: 0, character: 0 },
-          end: { line: source.lines.size + 1, character: 0 }
+          start: {
+            line: 0,
+            character: 0
+          },
+          end: {
+            line: source.lines.size + 1,
+            character: 0
+          }
         },
         newText: SyntaxTree.format(source)
       }
@@ -88,6 +122,8 @@ module SyntaxTree
         after: inlay_hints.after.map(&serialize)
       }
     rescue Parser::ParseError
+      # If there is a parse error, then we're not going to return any inlay
+      # hints for this source.
     end
 
     def write(value)