Soft deprecate --json instead of --format json in workspace.list (#12)

Author: ilyichv

workspace/lib/mix/tasks/workspace.list.ex

@@ -1,21 +1,30 @@
 defmodule Mix.Tasks.Workspace.List do
   opts = [
+    format: [
+      type: :string,
+      default: "pretty",
+      doc: """
+      The output format of the list. It can be one of the following:
+        * `json` - pretty prints the list as a json.
+        * `pretty` - pretty prints the list.
+      """,
+      allowed: ["json", "pretty"]
+    ],
     json: [
       type: :boolean,
-      default: false,
       doc: """
       If set a `json` file will be generated with the list of workspace projects and
       associated metadata. By default it will be saved in `workspace.json` in the
       current directory. You can override the output path by setting the `--output`
       option.
       """,
+      deprecated: "Use `--format json` with `--output` instead.",
       doc_section: :export
     ],
     output: [
       type: :string,
-      default: "workspace.json",
       doc: """
-      The output file. Applicable only if `--json` is set.
+      Save the list to a file. Applicable only if `--format` is set to `json`.
       """,
       doc_section: :export
     ],
@@ -24,7 +33,7 @@ defmodule Mix.Tasks.Workspace.List do
       default: false,
       doc: """
       If set the paths in the exported json file will be relative with respect to the
-      workspace path. Applicable only if `--json` is set.
+      workspace path. Applicable only if `--format` is set to `json`.
       """,
       doc_section: :export
     ],
@@ -162,13 +171,18 @@ defmodule Mix.Tasks.Workspace.List do
   end
 
   defp list_or_save_workspace_projects(workspace, opts) do
-    case opts[:json] do
-      false -> list_workspace_projects(workspace, opts[:show_status])
-      true -> write_json(workspace, opts)
-    end
+    # TODO: remove --json support in 0.4.0
+    opts =
+      if opts[:json] do
+        Keyword.merge(opts, format: "json", output: opts[:output] || "workspace.json")
+      else
+        opts
+      end
+
+    output_result(workspace, opts, opts[:format])
   end
 
-  defp list_workspace_projects(workspace, show_status) do
+  defp output_result(workspace, opts, "pretty") do
     projects = Workspace.projects(workspace)
 
     case Enum.count(projects, &(not &1.skip)) do
@@ -184,13 +198,26 @@ defmodule Mix.Tasks.Workspace.List do
           :reset,
           " matching the given options."
         ])
+
+        max_project_length = max_project_length(projects)
+
+        projects
+        |> Enum.sort_by(& &1.app)
+        |> Enum.each(&print_project_info(&1, max_project_length, opts[:show_status]))
     end
+  end
 
-    max_project_length = max_project_length(projects)
+  defp output_result(workspace, opts, "json") do
+    json_data = Workspace.Export.to_json(workspace, sort: true, relative: opts[:relative_paths])
 
-    projects
-    |> Enum.sort_by(& &1.app)
-    |> Enum.each(&print_project_info(&1, max_project_length, show_status))
+    case opts[:output] do
+      nil ->
+        IO.puts(json_data)
+
+      output ->
+        File.write!(output, json_data)
+        Workspace.Cli.log([:green, "generated ", :reset, output], prefix: :header)
+    end
   end
 
   defp max_project_length([]), do: 0
@@ -223,14 +250,6 @@ defmodule Mix.Tasks.Workspace.List do
   defp description(nil), do: ""
   defp description(doc) when is_binary(doc), do: [" - ", doc]
 
-  defp write_json(workspace, opts) do
-    json_data = Workspace.Export.to_json(workspace, sort: true, relative: opts[:relative_paths])
-
-    File.write!(opts[:output], json_data)
-
-    Workspace.Cli.log([:green, "generated ", :reset, opts[:output]], prefix: :header)
-  end
-
   defp tags([]), do: []
 
   defp tags(tags) do

workspace/test/mix/tasks/workspace.list_test.exs

@@ -418,4 +418,185 @@ defmodule Mix.Tasks.Workspace.ListTest do
       git: true
     )
   end
+
+  @tag :tmp_dir
+  test "with --format pretty option set", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        expected = """
+        Found 11 workspace projects matching the given options.
+          * :package_a package_a/mix.exs :shared, area:core
+          * :package_b package_b/mix.exs - a dummy project
+          * :package_c package_c/mix.exs
+          * :package_d package_d/mix.exs
+          * :package_e package_e/mix.exs
+          * :package_f package_f/mix.exs
+          * :package_g package_g/mix.exs
+          * :package_h package_h/mix.exs
+          * :package_i package_i/mix.exs
+          * :package_j package_j/mix.exs
+          * :package_k nested/package_k/mix.exs
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--format",
+                   "pretty"
+                 ])
+               end) == expected
+      end
+    )
+  end
+
+  @tag :tmp_dir
+  test "with --format json option set", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        output =
+          capture_io(fn ->
+            ListTask.run([
+              "--workspace-path",
+              tmp_dir,
+              "--format",
+              "json"
+            ])
+          end)
+
+        data = Jason.decode!(output)
+
+        assert length(data["projects"]) == 11
+        assert Path.type(data["workspace_path"]) == :absolute
+
+        for project <- data["projects"] do
+          assert Path.type(project["workspace_path"]) == :absolute
+          assert Path.type(project["mix_path"]) == :absolute
+          assert Path.type(project["path"]) == :absolute
+        end
+      end
+    )
+  end
+
+  @tag :tmp_dir
+  test "with --format json and --output option set", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        Workspace.Test.modify_project(tmp_dir, "package_d")
+        Workspace.Test.modify_project(tmp_dir, "package_e")
+
+        output = Path.join(tmp_dir, "workspace.json")
+
+        expected = """
+        ==> generated #{output}
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--format",
+                   "json",
+                   "--output",
+                   output
+                 ])
+               end) == expected
+
+        data = File.read!(output) |> Jason.decode!()
+
+        assert length(data["projects"]) == 11
+        assert Path.type(data["workspace_path"]) == :absolute
+
+        for project <- data["projects"] do
+          assert Path.type(project["workspace_path"]) == :absolute
+          assert Path.type(project["mix_path"]) == :absolute
+          assert Path.type(project["path"]) == :absolute
+        end
+      end,
+      git: true
+    )
+  end
+
+  @tag :tmp_dir
+  test "with --format json and --relative-paths", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        output = Path.join(tmp_dir, "workspace.json")
+
+        expected = """
+        ==> generated #{output}
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--format",
+                   "json",
+                   "--output",
+                   output,
+                   "--relative-paths"
+                 ])
+               end) == expected
+
+        data = File.read!(output) |> Jason.decode!()
+
+        assert data["workspace_path"] == "."
+        assert length(data["projects"]) == 11
+
+        for project <- data["projects"] do
+          assert project["workspace_path"] == "."
+          assert Path.type(project["mix_path"]) == :relative
+          assert Path.type(project["path"]) == :relative
+        end
+      end
+    )
+  end
+
+  @tag :tmp_dir
+  test "with --format json and filtering options", %{tmp_dir: tmp_dir} do
+    Workspace.Test.with_workspace(
+      tmp_dir,
+      [],
+      :default,
+      fn ->
+        output = Path.join(tmp_dir, "workspace.json")
+
+        expected = """
+        ==> generated #{output}
+        """
+
+        assert capture_io(fn ->
+                 ListTask.run([
+                   "--workspace-path",
+                   tmp_dir,
+                   "--format",
+                   "json",
+                   "--output",
+                   output,
+                   "-e",
+                   "package_a",
+                   "-e",
+                   "package_b"
+                 ])
+               end) == expected
+
+        assert %{"projects" => projects} = File.read!(output) |> Jason.decode!()
+
+        assert length(projects) == 9
+      end
+    )
+  end
 end