Check .formatter.exs :inputs relative to its directory

When dealing with `.formatter.exs` files that are in subdirectories of
the main project, the behaviour was incorrect:
#361

And also caused performance problems:
#381

A good example is a project I currently work on. We have a top-level
`.formatter.exs`, as well as a `test/.formatter.exs`.

The one in `test/` has the `:inputs` option set to `["**/*.{ex,exs}"]`.
Before this commit, should_format?/3 would take this pattern and
concatenate it with the project directory. This would result in
Path.wildcard/2 globbing for all source files in the entire project,
rather than just under test/. This causes formatting to take about 5
seconds on our project.

This commit fixes the problem by taking the file to be formatted, and
finding the `.formatter.exs` file that exists in the closest parent
directory (so long as that directory is still within the project root).
We then perform the Path.wildcard/2 relative to that directory.

I’ve removed the hack that was in place to support umbrella projects,
because this is a more general solution to the problem.

On our project, I am now able to format a file in 100ms or so, which
isn’t a bad speed-up!

Author: jonleighton

apps/language_server/lib/language_server/providers/formatting.ex

@@ -56,19 +56,47 @@ defmodule ElixirLS.LanguageServer.Providers.Formatting do
   defp should_format?(file_uri, project_dir, inputs) when is_list(inputs) do
     file_path = file_uri |> SourceFile.abs_path_from_uri()
 
-    inputs
-    |> Stream.flat_map(fn glob ->
-      [
-        Path.join([project_dir, glob]),
-        Path.join([project_dir, "apps", "*", glob])
-      ]
-    end)
-    |> Stream.flat_map(&Path.wildcard(&1, match_dot: true))
-    |> Enum.any?(&(file_path == &1))
+    if File.exists?(file_path) do
+      formatter_dir = find_formatter_dir(project_dir, file_path)
+
+      inputs
+      |> Stream.flat_map(&Path.wildcard(Path.join([formatter_dir, &1]), match_dot: true))
+      |> Enum.any?(&(file_path == &1))
+    else
+      # If the file doesn't actually exist on disk, we can't currently check
+      # whether we should format it via Path.wildcard/2, as that operation is
+      # dependent on the filesystem. So just assume that we should.
+      true
+    end
   end
 
   defp should_format?(_file_uri, _project_dir, _inputs), do: true
 
+  # Finds the deepest directory that contains file_path, that also contains a
+  # .formatter.exs. It's possible, though unlikely, that the .formatter.exs we
+  # find is not actually linked to the project_dir via the :subdirectories
+  # option in the top-level .formatter.exs. Currently, that edge case is
+  # glossed over.
+  defp find_formatter_dir(project_dir, file_path) do
+    parts = Path.split(file_path)
+    project_parts = Path.split(project_dir)
+
+    unless List.starts_with?(parts, project_parts) do
+      raise ArgumentError, "path '#{file_path}' is not within '#{project_dir}'"
+    end
+
+    parts = Enum.drop(parts, length(project_parts))
+
+    {subdirs, _} =
+      for part <- parts, reduce: {[], project_dir} do
+        {dirs, prev_dir} ->
+          dir = Path.join([prev_dir, part])
+          {[dir | dirs], dir}
+      end
+
+    Enum.find(subdirs, &File.exists?(Path.join(&1, ".formatter.exs"))) || project_dir
+  end
+
   defp myers_diff_to_text_edits(myers_diff) do
     myers_diff_to_text_edits(myers_diff, {0, 0}, [])
   end

apps/language_server/test/fixtures/formatter/.formatter.exs

@@ -2,6 +2,8 @@
   line_length: 20,
   subdirectories: [
     "lib",
-    "test"
-  ]
+    "test",
+    "apps/*"
+  ],
+  inputs: ["*.ex"]
 ]

apps/language_server/test/fixtures/formatter/apps/foo/.formatter.exs

@@ -0,0 +1,3 @@
+[
+  inputs: ["foo.ex"]
+]

apps/language_server/test/fixtures/formatter/test/.formatter.exs

@@ -1,3 +1,3 @@
 [
-  inputs: ["**/*.exs"]
+  inputs: ["*.exs"]
 ]

apps/language_server/test/providers/formatting_test.exs

@@ -481,18 +481,26 @@ defmodule ElixirLS.LanguageServer.Providers.FormattingTest do
 
       assert_formatted("file.ex", project_dir)
 
-      # test/.formatter.exs has [inputs: ["**/*.exs"]]
+      # test/.formatter.exs has [inputs: ["*.exs"]]
       assert_formatted("test/file.exs", project_dir)
       refute_formatted("test/file.ex", project_dir)
+
+      File.mkdir!("#{project_dir}/test/foo")
+      refute_formatted("test/foo/file.ex", project_dir)
+
+      # apps/foo/bar/.formatter.exs has [inputs: ["foo.ex"]]
+      assert_formatted("apps/foo/foo.ex", project_dir)
+      refute_formatted("apps/foo/bar.ex", project_dir)
+      refute_formatted("apps/foo.ex", project_dir)
     end)
   end
 
   def assert_formatted(path, project_dir) do
-    assert {:ok, [%{}]} = format(path, project_dir)
+    assert match?({:ok, [%{}]}, format(path, project_dir)), "expected '#{path}' to be formatted"
   end
 
   def refute_formatted(path, project_dir) do
-    assert {:ok, []} = format(path, project_dir)
+    assert match?({:ok, []}, format(path, project_dir)), "expected '#{path}' not to be formatted"
   end
 
   defp format(path, project_dir) do