Added percentage based progress reporters

apps/remote_control/lib/lexical/remote_control/api/messages.ex

@@ -30,10 +30,13 @@ defmodule Lexical.RemoteControl.Api.Messages do
   defrecord :module_updated, file: nil, name: nil, functions: [], macros: [], struct: nil
 
   defrecord :project_diagnostics, project: nil, build_number: 0, diagnostics: []
+
   defrecord :file_diagnostics, project: nil, build_number: 0, uri: nil, diagnostics: []
 
   defrecord :project_progress, label: nil, message: nil, stage: :report
 
+  defrecord :percent_progress, label: nil, message: nil, stage: :report, max: 0, delta: 0
+
   defrecord :struct_discovered, module: nil, fields: []
 
   @type compile_status :: :successful | :error

apps/remote_control/lib/lexical/remote_control/build/project.ex

@@ -6,7 +6,7 @@ defmodule Lexical.RemoteControl.Build.Project do
   alias Lexical.RemoteControl.Plugin
   alias Mix.Task.Compiler.Diagnostic
 
-  use Build.Progress
+  use RemoteControl.Progress
   require Logger
 
   def compile(%Project{} = project, force?) do

apps/remote_control/lib/lexical/remote_control/build/state.ex

@@ -14,7 +14,7 @@ defmodule Lexical.RemoteControl.Build.State do
 
   import Messages
 
-  use Build.Progress
+  use RemoteControl.Progress
 
   defstruct project: nil, build_number: 0, uri_to_source_and_edit_time: %{}
 

apps/remote_control/lib/lexical/remote_control/dispatch.ex

@@ -73,7 +73,7 @@ defmodule Lexical.RemoteControl.Dispatch do
   end
 
   defp register_progress_listener do
-    register_listener(progress_pid(), [project_progress()])
+    register_listener(progress_pid(), [project_progress(), percent_progress()])
   end
 
   defp progress_pid do

apps/remote_control/lib/lexical/remote_control/progress.ex

@@ -0,0 +1,34 @@
+defmodule Lexical.RemoteControl.Progress do
+  alias Lexical.RemoteControl.Dispatch
+  import Lexical.RemoteControl.Api.Messages
+
+  defmacro __using__(_) do
+    quote do
+      import unquote(__MODULE__), only: [with_progress: 2]
+    end
+  end
+
+  def with_progress(label, func) when is_function(func, 0) do
+    try do
+      Dispatch.broadcast(project_progress(label: label, stage: :begin))
+      func.()
+    after
+      Dispatch.broadcast(project_progress(label: label, stage: :complete))
+    end
+  end
+
+  def with_percent_progress(label, max, func) when is_function(func, 1) do
+    report_progress = fn delta, message ->
+      Dispatch.broadcast(
+        percent_progress(label: label, message: message, delta: delta, stage: :report)
+      )
+    end
+
+    try do
+      Dispatch.broadcast(percent_progress(label: label, max: max, stage: :begin))
+      func.(report_progress)
+    after
+      Dispatch.broadcast(percent_progress(label: label, stage: :complete))
+    end
+  end
+end

apps/remote_control/lib/lexical/remote_control/search/indexer.ex

@@ -2,6 +2,7 @@ defmodule Lexical.RemoteControl.Search.Indexer do
   alias Lexical.Project
   alias Lexical.RemoteControl.Search.Indexer
 
+  import Lexical.RemoteControl.Progress
   @indexable_extensions "*.{ex,exs}"
 
   def create_index(%Project{} = project) do
@@ -90,14 +91,31 @@ defmodule Lexical.RemoteControl.Search.Indexer do
 
     # Shuffling the results helps speed in some projects, as larger files tend to clump
     # together, like when there are auto-generated elixir modules.
-    file_paths
-    |> path_to_sizes()
-    |> Enum.shuffle()
-    |> Stream.chunk_while(initial_state, chunk_fn, after_fn)
-    |> Task.async_stream(&Enum.map(&1, processor), timeout: timeout)
-    |> Enum.flat_map(fn
-      {:ok, entry_chunks} -> entry_chunks
-      _ -> []
+    paths_to_sizes =
+      file_paths
+      |> path_to_sizes()
+      |> Enum.shuffle()
+
+    path_to_size_map = Map.new(paths_to_sizes)
+
+    total_bytes = paths_to_sizes |> Enum.map(&elem(&1, 1)) |> Enum.sum()
+
+    with_percent_progress("Indexing source code", total_bytes, fn update_progress ->
+      paths_to_sizes
+      |> Stream.chunk_while(initial_state, chunk_fn, after_fn)
+      |> Task.async_stream(
+        fn chunk ->
+          block_bytes = chunk |> Enum.map(&Map.get(path_to_size_map, &1)) |> Enum.sum()
+          result = Enum.map(chunk, processor)
+          update_progress.(block_bytes, nil)
+          result
+        end,
+        timeout: timeout
+      )
+      |> Enum.flat_map(fn
+        {:ok, entry_chunks} -> entry_chunks
+        _ -> []
+      end)
     end)
   end
 

apps/remote_control/test/lexical/remote_control/dispatch/handlers/indexer_test.exs

@@ -20,6 +20,7 @@ defmodule Lexical.RemoteControl.Dispatch.Handlers.IndexingTest do
     update_index = &Search.Indexer.update_index/2
 
     start_supervised!({Search.Store, [project, create_index, update_index]})
+    start_supervised!(RemoteControl.Dispatch)
     start_supervised!(Lexical.Server.Application.document_store_child_spec())
 
     assert_eventually(Search.Store.loaded?(), 1500)

apps/remote_control/test/lexical/remote_control/build/progress_test.exs → apps/remote_control/test/lexical/remote_control/progress_test.exs

@@ -1,6 +1,6 @@
-defmodule Lexical.RemoteControl.Build.ProgressTest do
+defmodule Lexical.RemoteControl.ProgressTest do
   alias Lexical.RemoteControl
-  alias Lexical.RemoteControl.Build.Progress
+  alias Lexical.RemoteControl.Progress
 
   import Lexical.RemoteControl.Api.Messages
 

apps/remote_control/test/lexical/remote_control/search/indexer_test.exs

@@ -8,6 +8,7 @@ defmodule Lexical.RemoteControl.Search.IndexerTest do
 
   setup do
     project = project()
+    start_supervised(Lexical.RemoteControl.Dispatch)
     {:ok, project: project}
   end
 

apps/server/lib/lexical/server/project/progress.ex

@@ -30,6 +30,12 @@ defmodule Lexical.Server.Project.Progress do
     {:noreply, new_state}
   end
 
+  def handle_info(percent_progress(stage: stage) = message, %State{} = state) do
+    new_state = apply(State, stage, [state, message])
+
+    {:noreply, new_state}
+  end
+
   def name(%Project{} = project) do
     :"#{Project.name(project)}::progress"
   end

apps/server/lib/lexical/server/project/progress/percentage.ex

@@ -0,0 +1,67 @@
+defmodule Lexical.Server.Project.Progress.Percentage do
+  @moduledoc """
+  The backing data structure for percentage based progress reports
+  """
+  alias Lexical.Math
+  alias Lexical.Protocol.Notifications
+  alias Lexical.Protocol.Types.WorkDone
+
+  @enforce_keys [:token, :kind, :max]
+  defstruct [:token, :kind, :title, :message, :max, current: 0]
+
+  def begin(title, max) do
+    token = System.unique_integer([:positive])
+    %__MODULE__{token: token, kind: :begin, title: title, max: max}
+  end
+
+  def report(percentage, delta, message \\ "")
+
+  def report(%__MODULE__{} = percentage, delta, message) when is_integer(delta) and delta >= 0 do
+    new_current = percentage.current + delta
+
+    %__MODULE__{percentage | kind: :report, message: message, current: new_current}
+  end
+
+  def report(%__MODULE__{} = percentage, delta, _message) when is_integer(delta) do
+    percentage
+  end
+
+  def report(_, _, _) do
+    nil
+  end
+
+  def complete(%__MODULE__{} = percentage, message) do
+    %__MODULE__{percentage | kind: :end, current: percentage.max, message: message}
+  end
+
+  def to_protocol(%__MODULE__{kind: :begin} = value) do
+    Notifications.Progress.new(
+      token: value.token,
+      value: WorkDone.Progress.Begin.new(kind: "begin", title: value.title, percentage: 0)
+    )
+  end
+
+  def to_protocol(%__MODULE__{kind: :report} = value) do
+    percent_complete =
+      (value.current / value.max * 100)
+      |> round()
+      |> Math.clamp(0, 100)
+
+    Notifications.Progress.new(
+      token: value.token,
+      value:
+        WorkDone.Progress.Report.new(
+          kind: "report",
+          message: value.message,
+          percentage: percent_complete
+        )
+    )
+  end
+
+  def to_protocol(%__MODULE__{kind: :end} = value) do
+    Notifications.Progress.new(
+      token: value.token,
+      value: WorkDone.Progress.End.new(kind: "end", message: value.message)
+    )
+  end
+end

apps/server/lib/lexical/server/project/progress/state.ex

@@ -3,6 +3,7 @@ defmodule Lexical.Server.Project.Progress.State do
   alias Lexical.Protocol.Id
   alias Lexical.Protocol.Requests
   alias Lexical.Server.Configuration
+  alias Lexical.Server.Project.Progress.Percentage
   alias Lexical.Server.Project.Progress.Value
   alias Lexical.Server.Transport
 
@@ -21,7 +22,16 @@ defmodule Lexical.Server.Project.Progress.State do
     write_work_done(progress.token)
     write(progress)
 
-    %{state | progress_by_label: progress_by_label}
+    %__MODULE__{state | progress_by_label: progress_by_label}
+  end
+
+  def begin(%__MODULE__{} = state, percent_progress(label: label, max: max)) do
+    progress = Percentage.begin(label, max)
+    progress_by_label = Map.put(state.progress_by_label, label, progress)
+    write_work_done(progress.token)
+    write(progress)
+
+    %__MODULE__{state | progress_by_label: progress_by_label}
   end
 
   def report(%__MODULE__{} = state, project_progress(label: label, message: message)) do
@@ -32,15 +42,38 @@ defmodule Lexical.Server.Project.Progress.State do
       end)
 
     write(progress)
-    %{state | progress_by_label: progress_by_label}
+    %__MODULE__{state | progress_by_label: progress_by_label}
+  end
+
+  def report(
+        %__MODULE__{} = state,
+        percent_progress(label: label, message: message, delta: delta)
+      ) do
+    {progress, progress_by_label} =
+      Map.get_and_update(state.progress_by_label, label, fn old_percentage ->
+        new_percentage = Percentage.report(old_percentage, delta, message)
+        {new_percentage, new_percentage}
+      end)
+
+    write(progress)
+    %__MODULE__{state | progress_by_label: progress_by_label}
   end
 
   def complete(%__MODULE__{} = state, project_progress(label: label, message: message)) do
     {progress, progress_by_label} =
       Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end)
 
     progress |> Value.complete(message) |> write()
-    %{state | progress_by_label: progress_by_label}
+    %__MODULE__{state | progress_by_label: progress_by_label}
+  end
+
+  def complete(%__MODULE__{} = state, percent_progress(label: label, message: message)) do
+    {progress, progress_by_label} =
+      Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end)
+
+    progress |> Percentage.complete(message) |> write()
+
+    %__MODULE__{state | progress_by_label: progress_by_label}
   end
 
   defp write_work_done(token) do
@@ -50,9 +83,9 @@ defmodule Lexical.Server.Project.Progress.State do
     end
   end
 
-  defp write(%{token: token} = progress) when not is_nil(token) do
+  defp write(%progress_module{token: token} = progress) when not is_nil(token) do
     if Configuration.client_supports?(:work_done_progress) do
-      progress |> Value.to_protocol() |> Transport.write()
+      progress |> progress_module.to_protocol() |> Transport.write()
     end
   end
 

apps/server/lib/lexical/server/project/progress/support.ex

@@ -1,4 +1,5 @@
 defmodule Lexical.Server.Project.Progress.Support do
+  alias Lexical.Project
   alias Lexical.Server.Project.Progress
 
   import Lexical.RemoteControl.Api.Messages
@@ -19,4 +20,23 @@ defmodule Lexical.Server.Project.Progress.Support do
       send(dest, project_progress(label: label, stage: :complete))
     end
   end
+
+  def with_percentage_progress(%Project{} = project, label, max, func)
+      when is_function(func, 1) do
+    dest = Progress.name(project)
+
+    report_progress = fn delta, message ->
+      message =
+        percent_progress(label: label, max: max, message: message, delta: delta, stage: :report)
+
+      send(dest, message)
+    end
+
+    try do
+      send(dest, percent_progress(label: label, max: max, stage: :begin))
+      func.(report_progress)
+    after
+      send(dest, percent_progress(label: label, stage: :complete))
+    end
+  end
 end