Remodel the plugins so that the options are available

Author: kddnewton

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,15 @@ 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

@@ -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/formatter/trailing_comma.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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module SyntaxTree
+  class SingleQuotesTest < Minitest::Test
+    OPTIONS = Plugin.options("syntax_tree/plugin/single_quotes")
+
+    def test_empty_string_literal
+      assert_format("''\n", "\"\"")
+    end
+
+    def test_string_literal
+      assert_format("'string'\n", "\"string\"")
+    end
+
+    def test_string_literal_with_interpolation
+      assert_format("\"\#{foo}\"\n")
+    end
+
+    def test_dyna_symbol
+      assert_format(":'symbol'\n", ":\"symbol\"")
+    end
+
+    def test_single_quote_in_string
+      assert_format("\"str'ing\"\n")
+    end
+
+    def test_label
+      assert_format(
+        "{ foo => foo, :'bar' => bar }\n",
+        "{ foo => foo, \"bar\": bar }"
+      )
+    end
+
+    private
+
+    def assert_format(expected, source = expected)
+      formatter = Formatter.new(source, [], **OPTIONS)
+      SyntaxTree.parse(source).format(formatter)
+    
+      formatter.flush
+      assert_equal(expected, formatter.output.join)
+    end
+  end
+end

lib/syntax_tree/plugin/trailing_comma.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+module SyntaxTree
+  class TrailingCommaTest < Minitest::Test
+    OPTIONS = Plugin.options("syntax_tree/plugin/trailing_comma")
+
+    def test_arg_paren_flat
+      assert_format("foo(a)\n")
+    end
+
+    def test_arg_paren_break
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        foo(
+          #{"a" * 80},
+        )
+      EXPECTED
+        foo(#{"a" * 80})
+      SOURCE
+    end
+
+    def test_arg_paren_block
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        foo(
+          &#{"a" * 80}
+        )
+      EXPECTED
+        foo(&#{"a" * 80})
+      SOURCE
+    end
+
+    def test_arg_paren_command
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        foo(
+          bar #{"a" * 80}
+        )
+      EXPECTED
+        foo(bar #{"a" * 80})
+      SOURCE
+    end
+
+    def test_arg_paren_command_call
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        foo(
+          bar.baz #{"a" * 80}
+        )
+      EXPECTED
+        foo(bar.baz #{"a" * 80})
+      SOURCE
+    end
+
+    def test_array_literal_flat
+      assert_format("[a]\n")
+    end
+
+    def test_array_literal_break
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        [
+          #{"a" * 80},
+        ]
+      EXPECTED
+        [#{"a" * 80}]
+      SOURCE
+    end
+
+    def test_hash_literal_flat
+      assert_format("{ a: a }\n")
+    end
+
+    def test_hash_literal_break
+      assert_format(<<~EXPECTED, <<~SOURCE)
+        {
+          a:
+            #{"a" * 80},
+        }
+      EXPECTED
+        { a: #{"a" * 80} }
+      SOURCE
+    end
+
+    private
+
+    def assert_format(expected, source = expected)
+      formatter = Formatter.new(source, [], **OPTIONS)
+      SyntaxTree.parse(source).format(formatter)
+    
+      formatter.flush
+      assert_equal(expected, formatter.output.join)
+    end
+  end
+end