Merge pull request #92 from ruby-syntax-tree/tests

Tests

Author: kddnewton

.rubocop.yml

@@ -78,3 +78,6 @@ Style/PerlBackrefs:
 
 Style/SpecialGlobalVars:
   Enabled: false
+
+Style/StructInheritance:
+  Enabled: false

lib/syntax_tree/formatter.rb

@@ -4,6 +4,18 @@ module SyntaxTree
   # A slightly enhanced PP that knows how to format recursively including
   # comments.
   class Formatter < PrettierPrint
+    # We want to minimize as much as possible the number of options that are
+    # available in syntax tree. For the most part, if users want non-default
+    # formatting, they should override the format methods on the specific nodes
+    # themselves. However, because of some history with prettier and the fact
+    # that folks have become entrenched in their ways, we decided to provide a
+    # small amount of configurability.
+    #
+    # Note that we're keeping this in a global-ish hash instead of just
+    # overriding methods on classes so that other plugins can reference this if
+    # necessary. For example, the RBS plugin references the quote style.
+    OPTIONS = { quote: "\"", trailing_comma: false }
+
     COMMENT_PRIORITY = 1
     HEREDOC_PRIORITY = 2
 
@@ -14,13 +26,20 @@ class Formatter < PrettierPrint
     attr_reader :quote, :trailing_comma
     alias trailing_comma? trailing_comma
 
-    def initialize(source, ...)
-      super(...)
+    def initialize(
+      source,
+      *args,
+      quote: OPTIONS[:quote],
+      trailing_comma: OPTIONS[:trailing_comma]
+    )
+      super(*args)
 
       @source = source
       @stack = []
-      @quote = "\""
-      @trailing_comma = false
+
+      # Memoizing these values per formatter to make access faster.
+      @quote = quote
+      @trailing_comma = trailing_comma
     end
 
     def self.format(source, node)

lib/syntax_tree/formatter/single_quotes.rb

@@ -70,13 +70,11 @@ def run
              id:,
              params: { textDocument: { uri: } }
            }
-          output = []
-          PP.pp(SyntaxTree.parse(store[uri]), output)
-          write(id: id, result: output.join)
+          write(id: id, result: PP.pp(SyntaxTree.parse(store[uri]), +""))
         in method: %r{\$/.+}
           # ignored
         else
-          raise "Unhandled: #{request}"
+          raise ArgumentError, "Unhandled: #{request}"
         end
       end
     end
@@ -109,10 +107,6 @@ def 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 } }

lib/syntax_tree/formatter/trailing_comma.rb

@@ -38,6 +38,7 @@ def visit(node)
       #
       def visit_assign(node)
         parentheses(node.location) if stack[-2].is_a?(Params)
+        super
       end
 
       # Adds parentheses around binary expressions to make it clear which
@@ -57,6 +58,8 @@ def visit_binary(node)
           parentheses(node.location)
         else
         end
+
+        super
       end
 
       # Adds parentheses around ternary operators contained within certain
@@ -70,9 +73,13 @@ def visit_binary(node)
       #     a ? b : ₍c ? d : e₎
       #
       def visit_if_op(node)
-        if stack[-2] in Assign | Binary | IfOp | OpAssign
+        case stack[-2]
+        in Assign | Binary | IfOp | OpAssign
           parentheses(node.location)
+        else
         end
+
+        super
       end
 
       # Adds the implicitly rescued StandardError into a bare rescue clause. For
@@ -92,6 +99,8 @@ def visit_rescue(node)
         if node.exception.nil?
           after[node.location.start_char + "rescue".length] << " StandardError"
         end
+
+        super
       end
 
       # Adds parentheses around unary statements using the - operator that are
@@ -107,6 +116,8 @@ def visit_unary(node)
         if stack[-2].is_a?(Binary) && (node.operator == "-")
           parentheses(node.location)
         end
+
+        super
       end
 
       def self.find(program)

lib/syntax_tree/language_server.rb

@@ -2129,11 +2129,13 @@ def format(q)
           #
           #     break
           #
-        in [Paren[
-             contents: {
-               body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
-             }
-           ]]
+        in [
+             Paren[
+               contents: {
+                 body: [ArrayLiteral[contents: { parts: [_, _, *] }] => array]
+               }
+             ]
+           ]
           # Here we have a single argument that is a set of parentheses wrapping
           # an array literal that has at least 2 elements. We're going to print
           # the contents of the array directly. This would be like if we had:
@@ -5472,12 +5474,14 @@ def format_flat(q)
       q.format(predicate)
       q.text(" ?")
 
-      q.breakable
-      q.format(truthy)
-      q.text(" :")
+      q.indent do
+        q.breakable
+        q.format(truthy)
+        q.text(" :")
 
-      q.breakable
-      q.format(falsy)
+        q.breakable
+        q.format(falsy)
+      end
     end
   end
 

lib/syntax_tree/language_server/inlay_hints.rb

@@ -548,13 +548,6 @@ def on_aryptn(constant, requireds, rest, posts)
           parts[0].location.to(parts[-1].location)
         end
 
-      # If there's the optional then keyword, then we'll delete that and use it
-      # as the end bounds of the location.
-      if (token = find_token(Kw, "then", consume: false))
-        tokens.delete(token)
-        location = location.to(token.location)
-      end
-
       # If there is a plain *, then we're going to fix up the location of it
       # here because it currently doesn't have anything to use for its precise
       # location. If we hit a comma, then we've gone too far.
@@ -1698,12 +1691,6 @@ def on_hshptn(constant, keywords, keyword_rest)
         end
       end
 
-      # Delete the optional then keyword
-      if (token = find_token(Kw, "then", consume: false))
-        parts << token
-        tokens.delete(token)
-      end
-
       HshPtn.new(
         constant: constant,
         keywords: keywords || [],
@@ -3013,6 +3000,11 @@ def on_stmts_new
     #     (StringEmbExpr | StringDVar | TStringContent) part
     #   ) -> StringContent
     def on_string_add(string, part)
+      # Due to some eccentricities in how ripper works, you need this here in
+      # case you have a syntax error with an embedded expression that doesn't
+      # finish, as in: "#{"
+      return string if part.is_a?(String)
+
       location =
         string.parts.any? ? string.location.to(part.location) : part.location
 

lib/syntax_tree/node.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require "syntax_tree/formatter/single_quotes"
-SyntaxTree::Formatter.prepend(SyntaxTree::Formatter::SingleQuotes)
+SyntaxTree::Formatter::OPTIONS[:quote] = "'"

lib/syntax_tree/parser.rb

@@ -1,4 +1,3 @@
 # frozen_string_literal: true
 
-require "syntax_tree/formatter/trailing_comma"
-SyntaxTree::Formatter.prepend(SyntaxTree::Formatter::TrailingComma)
+SyntaxTree::Formatter::OPTIONS[:trailing_comma] = true

lib/syntax_tree/plugin/single_quotes.rb

@@ -142,11 +142,41 @@ def test_generic_error
       end
     end
 
+    def test_plugins
+      Dir.mktmpdir do |directory|
+        Dir.mkdir(File.join(directory, "syntax_tree"))
+        $:.unshift(directory)
+
+        File.write(
+          File.join(directory, "syntax_tree", "plugin.rb"),
+          "puts 'Hello, world!'"
+        )
+        result = run_cli("format", "--plugins=plugin")
+
+        assert_equal("Hello, world!\ntest\n", result.stdio)
+      end
+    end
+
+    def test_language_server
+      prev_stdin = $stdin
+      prev_stdout = $stdout
+
+      request = { method: "shutdown" }.merge(jsonrpc: "2.0").to_json
+      $stdin =
+        StringIO.new("Content-Length: #{request.bytesize}\r\n\r\n#{request}")
+      $stdout = StringIO.new
+
+      assert_equal(0, SyntaxTree::CLI.run(["lsp"]))
+    ensure
+      $stdin = prev_stdin
+      $stdout = prev_stdout
+    end
+
     private
 
     Result = Struct.new(:status, :stdio, :stderr, keyword_init: true)
 
-    def run_cli(command, file: nil)
+    def run_cli(command, *args, file: nil)
       if file.nil?
         file = Tempfile.new(%w[test- .rb])
         file.puts("test")
@@ -156,7 +186,7 @@ def run_cli(command, file: nil)
 
       status = nil
       stdio, stderr =
-        capture_io { status = SyntaxTree::CLI.run([command, file.path]) }
+        capture_io { status = SyntaxTree::CLI.run([command, *args, file.path]) }
 
       Result.new(status: status, stdio: stdio, stderr: stderr)
     ensure

lib/syntax_tree/plugin/trailing_comma.rb

@@ -4,6 +4,22 @@
 end
 %
 case foo
+in [] then
+end
+-
+case foo
+in []
+end
+%
+case foo
+in * then
+end
+-
+case foo
+in [*]
+end
+%
+case foo
 in _, _
 end
 -

test/cli_test.rb

@@ -1,6 +1,8 @@
 %
 foo.bar
 %
+foo.bar(baz)
+%
 foo.()
 %
 foo::()
@@ -21,3 +23,40 @@
   .barrrrrrrrrrrrrrrrrrr {}
   .bazzzzzzzzzzzzzzzzzzzzzzzzzz
   .quxxxxxxxxx
+%
+foo. # comment
+  bar
+%
+foo
+  .bar
+  .baz # comment
+  .qux
+  .quux
+%
+foo
+  .bar
+  .baz.
+  # comment
+  qux
+  .quux
+%
+{ a: 1, b: 2 }.fooooooooooooooooo.barrrrrrrrrrrrrrrrrrr.bazzzzzzzzzzzz.quxxxxxxxxxxxx
+-
+{ a: 1, b: 2 }.fooooooooooooooooo
+  .barrrrrrrrrrrrrrrrrrr
+  .bazzzzzzzzzzzz
+  .quxxxxxxxxxxxx
+%
+fooooooooooooooooo.barrrrrrrrrrrrrrrrrrr.bazzzzzzzzzzzz.quxxxxxxxxxxxx.each { block }
+-
+fooooooooooooooooo.barrrrrrrrrrrrrrrrrrr.bazzzzzzzzzzzz.quxxxxxxxxxxxx.each do
+  block
+end
+%
+foo.bar.baz.each do
+  block1
+  block2
+end
+%
+a b do
+end.c d

test/fixtures/aryptn.rb

@@ -32,3 +32,5 @@
 foo.
   # comment
   bar baz
+%
+foo.bar baz ? qux : qaz

test/fixtures/call.rb

@@ -14,3 +14,15 @@
 foo :bar do
   baz
 end
+%
+sig do
+  override.params(contacts: Contact::ActiveRecord_Relation).returns(
+    Customer::ActiveRecord_Relation
+  )
+end
+-
+sig do
+  override
+    .params(contacts: Contact::ActiveRecord_Relation)
+    .returns(Customer::ActiveRecord_Relation)
+end