syntax_tree 1.2.0 → 2.1.0

data/lib/syntax_tree/formatter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  # A slightly enhanced PP that knows how to format recursively including
+  # comments.
+  class Formatter < PP
+    COMMENT_PRIORITY = 1
+    HEREDOC_PRIORITY = 2
+
+    attr_reader :source, :stack, :quote
+
+    def initialize(source, ...)
+      super(...)
+
+      @source = source
+      @stack = []
+      @quote = "\""
+    end
+
+    def format(node, stackable: true)
+      stack << node if stackable
+      doc = nil
+
+      # If there are comments, then we're going to format them around the node
+      # so that they get printed properly.
+      if node.comments.any?
+        leading, trailing = node.comments.partition(&:leading?)
+
+        # Print all comments that were found before the node.
+        leading.each do |comment|
+          comment.format(self)
+          breakable(force: true)
+        end
+
+        # 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
+
+        # Print all comments that were found after the node.
+        trailing.each do |comment|
+          line_suffix(priority: COMMENT_PRIORITY) do
+            text(" ")
+            comment.format(self)
+            break_parent
+          end
+        end
+      else
+        doc = node.format(self)
+      end
+
+      stack.pop if stackable
+      doc
+    end
+
+    def format_each(nodes)
+      nodes.each { |node| format(node) }
+    end
+
+    def parent
+      stack[-2]
+    end
+
+    def parents
+      stack[0...-1].reverse_each
+    end
+  end
+end

data/lib/syntax_tree/language_server/inlay_hints.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  class LanguageServer
+    class InlayHints
+      attr_reader :before, :after
+
+      def initialize
+        @before = Hash.new { |hash, key| hash[key] = +"" }
+        @after = Hash.new { |hash, key| hash[key] = +"" }
+      end
+
+      # Adds the implicitly rescued StandardError into a bare rescue clause. For
+      # example,
+      #
+      #     begin
+      #     rescue
+      #     end
+      #
+      # becomes
+      #
+      #     begin
+      #     rescue StandardError
+      #     end
+      #
+      def bare_rescue(location)
+        after[location.start_char + "rescue".length] << " StandardError"
+      end
+
+      # Adds implicit parentheses around certain expressions to make it clear
+      # which subexpression will be evaluated first. For example,
+      #
+      #     a + b * c
+      #
+      # becomes
+      #
+      #     a + ₍b * c₎
+      #
+      def precedence_parentheses(location)
+        before[location.start_char] << "₍"
+        after[location.end_char] << "₎"
+      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
+
+          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
+
+        inlay_hints
+      end
+    end
+  end
+end

data/lib/syntax_tree/language_server.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "json"
+require "uri"
+
+require_relative "language_server/inlay_hints"
+
+module SyntaxTree
+  class LanguageServer
+    attr_reader :input, :output
+
+    def initialize(input: STDIN, output: STDOUT)
+      @input = input.binmode
+      @output = output.binmode
+    end
+
+    def run
+      store =
+        Hash.new do |hash, uri|
+          hash[uri] = File.binread(CGI.unescape(URI.parse(uri).path))
+        end
+
+      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)
+
+        case request
+        in { method: "initialize", id: }
+          store.clear
+          write(id: id, result: { capabilities: capabilities })
+        in { method: "initialized" }
+          # ignored
+        in { method: "shutdown" }
+          store.clear
+          return
+        in { method: "textDocument/didChange", params: { textDocument: { uri: }, contentChanges: [{ text: }, *] } }
+          store[uri] = text
+        in { method: "textDocument/didOpen", params: { textDocument: { uri:, text: } } }
+          store[uri] = text
+        in { method: "textDocument/didClose", params: { textDocument: { uri: } } }
+          store.delete(uri)
+        in { method: "textDocument/formatting", id:, params: { textDocument: { uri: } } }
+          write(id: id, result: [format(store[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: } } }
+          output = []
+          PP.pp(SyntaxTree.parse(store[uri]), output)
+          write(id: id, result: output.join)
+        in { method: %r{\$/.+} }
+          # ignored
+        else
+          raise "Unhandled: #{request}"
+        end
+      end
+    end
+
+    private
+
+    def capabilities
+      {
+        documentFormattingProvider: true,
+        textDocumentSync: { change: 1, openClose: true }
+      }
+    end
+
+    def format(source)
+      {
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: source.lines.size + 1, character: 0 }
+        },
+        newText: SyntaxTree.format(source)
+      }
+    end
+
+    def log(message)
+      write(method: "window/logMessage", params: { type: 4, message: message })
+    end
+
+    def inlay_hints(source)
+      inlay_hints = InlayHints.find(SyntaxTree.parse(source))
+      serialize = ->(position, text) { { position: position, text: text } }
+
+      {
+        before: inlay_hints.before.map(&serialize),
+        after: inlay_hints.after.map(&serialize)
+      }
+    rescue Parser::ParseError
+    end
+
+    def write(value)
+      response = value.merge(jsonrpc: "2.0").to_json
+      output.print("Content-Length: #{response.bytesize}\r\n\r\n#{response}")
+      output.flush
+    end
+  end
+end