syntax_tree 1.1.1 → 2.0.1

data/lib/syntax_tree/cli.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class SyntaxTree
+module SyntaxTree
   module CLI
     # A utility wrapper around colored strings in the output.
     class Color
@@ -15,6 +15,10 @@ class SyntaxTree
         "\033[#{code}m#{value}\033[0m"
       end
 
+      def self.bold(value)
+        new(value, "1")
+      end
+
       def self.gray(value)
         new(value, "38;5;102")
       end
@@ -30,7 +34,7 @@ class SyntaxTree
 
     # The parent action class for the CLI that implements the basics.
     class Action
-      def run(filepath, source)
+      def run(handler, filepath, source)
       end
 
       def success
@@ -42,8 +46,8 @@ class SyntaxTree
 
     # An action of the CLI that prints out the AST for the given source.
     class AST < Action
-      def run(filepath, source)
-        pp SyntaxTree.parse(source)
+      def run(handler, filepath, source)
+        pp handler.parse(source)
       end
     end
 
@@ -53,8 +57,8 @@ class SyntaxTree
       class UnformattedError < StandardError
       end
 
-      def run(filepath, source)
-        raise UnformattedError if source != SyntaxTree.format(source)
+      def run(handler, filepath, source)
+        raise UnformattedError if source != handler.format(source)
       rescue StandardError
         warn("[#{Color.yellow("warn")}] #{filepath}")
         raise
@@ -75,11 +79,11 @@ class SyntaxTree
       class NonIdempotentFormatError < StandardError
       end
 
-      def run(filepath, source)
+      def run(handler, filepath, source)
         warning = "[#{Color.yellow("warn")}] #{filepath}"
-        formatted = SyntaxTree.format(source)
+        formatted = handler.format(source)
 
-        if formatted != SyntaxTree.format(formatted)
+        if formatted != handler.format(formatted)
           raise NonIdempotentFormatError
         end
       rescue StandardError
@@ -98,28 +102,28 @@ class SyntaxTree
 
     # An action of the CLI that prints out the doc tree IR for the given source.
     class Doc < Action
-      def run(filepath, source)
+      def run(handler, filepath, source)
         formatter = Formatter.new([])
-        SyntaxTree.parse(source).format(formatter)
+        handler.parse(source).format(formatter)
         pp formatter.groups.first
       end
     end
 
     # An action of the CLI that formats the input source and prints it out.
     class Format < Action
-      def run(filepath, source)
-        puts SyntaxTree.format(source)
+      def run(handler, filepath, source)
+        puts handler.format(source)
       end
     end
 
     # An action of the CLI that formats the input source and writes the
     # formatted output back to the file.
     class Write < Action
-      def run(filepath, source)
+      def run(handler, filepath, source)
         print filepath
         start = Time.now
 
-        formatted = SyntaxTree.format(source)
+        formatted = handler.format(source)
         File.write(filepath, formatted)
 
         color = source == formatted ? Color.gray(filepath) : filepath
@@ -135,24 +139,65 @@ class SyntaxTree
     # The help message displayed if the input arguments are not correctly
     # ordered or formatted.
     HELP = <<~HELP
-      stree MODE FILE
+      #{Color.bold("stree ast [OPTIONS] [FILE]")}
+        Print out the AST corresponding to the given files
+
+      #{Color.bold("stree check [OPTIONS] [FILE]")}
+        Check that the given files are formatted as syntax tree would format them
+
+      #{Color.bold("stree debug [OPTIONS] [FILE]")}
+        Check that the given files can be formatted idempotently
+
+      #{Color.bold("stree doc [OPTIONS] [FILE]")}
+        Print out the doc tree that would be used to format the given files
+
+      #{Color.bold("stree format [OPTIONS] [FILE]")}
+        Print out the formatted version of the given files
+
+      #{Color.bold("stree help")}
+        Display this help message
+
+      #{Color.bold("stree lsp")}
+        Run syntax tree in language server mode
 
-      MODE: ast | check | debug | doc | format | write
-      FILE: one or more paths to files to parse
+      #{Color.bold("stree version")}
+        Output the current version of syntax tree
+
+      #{Color.bold("stree write [OPTIONS] [FILE]")}
+        Read, format, and write back the source of the given files
+
+      [OPTIONS]
+
+      --plugins=...
+        A comma-separated list of plugins to load.
     HELP
 
     class << self
       # Run the CLI over the given array of strings that make up the arguments
       # passed to the invocation.
       def run(argv)
-        if argv.length < 2
+        name, *arguments = argv
+
+        case name
+        when "help"
+          puts HELP
+          return 0
+        when "lsp"
+          require "syntax_tree/language_server"
+          LanguageServer.new.run
+          return 0
+        when "version"
+          puts SyntaxTree::VERSION
+          return 0
+        end
+
+        if arguments.empty?
           warn(HELP)
           return 1
         end
 
-        arg, *patterns = argv
         action =
-          case arg
+          case name
           when "a", "ast"
             AST.new
           when "c", "check"
@@ -170,15 +215,31 @@ class SyntaxTree
             return 1
           end
 
+        # If there are any plugins specified on the command line, then load them
+        # by requiring them here. We do this by transforming something like
+        #
+        #     stree format --plugins=haml template.haml
+        #
+        # into
+        #
+        #     require "syntax_tree/haml"
+        #
+        if arguments.first.start_with?("--plugins=")
+          plugins = arguments.shift[/^--plugins=(.*)$/, 1]
+          plugins.split(",").each { |plugin| require "syntax_tree/#{plugin}" }
+        end
+
         errored = false
-        patterns.each do |pattern|
+        arguments.each do |pattern|
           Dir.glob(pattern).each do |filepath|
             next unless File.file?(filepath)
-            source = SyntaxTree.read(filepath)
+
+            handler = HANDLERS[File.extname(filepath)]
+            source = handler.read(filepath)
 
             begin
-              action.run(filepath, source)
-            rescue ParseError => error
+              action.run(handler, filepath, source)
+            rescue Parser::ParseError => error
               warn("Error: #{error.message}")
 
               if error.lineno

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,93 @@
+# 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 the implicitly referenced value (local variable or method call)
+      # that is added into a hash when the value of a key-value pair is omitted.
+      # For example,
+      #
+      #     { value: }
+      #
+      # becomes
+      #
+      #     { value: value }
+      #
+      def missing_hash_value(key, location)
+        after[location.end_char] << " #{key}"
+      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 _, Assoc[key: Label[value: key], value: nil, location:]
+            inlay_hints.missing_hash_value(key[0...-1], 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