add debugging streams with streams

Author: srzeszut

dev/components.ex

@@ -8,7 +8,8 @@ defmodule LiveDebuggerDev.Components do
     {"/messages", "Messages"},
     {"/embedded", "Embedded"},
     {"/embedded_in_controller", "EmbeddedInController"},
-    {"/endless_crash_reload", "EndlessCrashReload"}
+    {"/endless_crash_reload", "EndlessCrashReload"},
+    {"/stream", "Stream"}
   ]
 
   attr(:routes, :list, default: @routes)

dev/live_views/stream.ex

@@ -26,7 +26,7 @@ defmodule LiveDebuggerDev.LiveViews.Stream do
       <.button phx-click="insert_at_index">Insert At Index 4</.button>
       <.button phx-click="delete_item">Delete Last</.button>
       <.button phx-click="reset_items">Reset Stream</.button>
-      <.button phx-click="limit_stream">Limit Stream (5)</.button>
+      <%!-- <.button phx-click="limit_stream">Limit Stream (5)</.button> --%>
       <.button phx-click="async_load">Async Load Items</.button>
       <.button phx-click="delete_both_last">Delete Last From Both Streams</.button>
     </.box>
@@ -192,11 +192,6 @@ defmodule LiveDebuggerDev.LiveViews.Stream do
     {:noreply, socket}
   end
 
-  @impl true
-  def handle_info({:async_result, :items, {:ok, _}}, socket) do
-    {:noreply, assign(socket, :async_loaded?, true)}
-  end
-
   @impl true
   def handle_event("delete_both_last", _params, socket) do
     last_item_id = socket.assigns.current_id - 1
@@ -223,4 +218,9 @@ defmodule LiveDebuggerDev.LiveViews.Stream do
 
     {:noreply, socket}
   end
+
+  @impl true
+  def handle_info({:async_result, :items, {:ok, _}}, socket) do
+    {:noreply, assign(socket, :async_loaded?, true)}
+  end
 end

lib/live_debugger/app/debugger/node_state/queries.ex

@@ -63,9 +63,9 @@ defmodule LiveDebugger.App.Debugger.NodeState.Queries do
     end
   end
 
-  # def update_node_streams(_, stream_updates, current_stream_state_list) do
-  #   # StreamUtils.compute_diff([stream_updates], current_stream_state_list)
-  # end
+  def update_node_streams(_, stream_updates) do
+    StreamUtils.compute_diff([stream_updates])
+  end
 
   defp get_component_assigns(components, %Phoenix.LiveComponent.CID{cid: cid}) do
     components

lib/live_debugger/app/debugger/node_state/stream_utils.ex

@@ -1,43 +1,27 @@
 defmodule LiveDebugger.App.Debugger.NodeState.StreamUtils do
   @moduledoc """
-  Utilities for extracting and computing Phoenix LiveView stream diffs and state
+  Utilities for extracting Phoenix LiveView stream diffs and state
   from render traces.
   """
 
-  alias LiveDebugger.App.Utils.TermDiffer
-  alias LiveDebugger.App.Utils.TermDiffer.Diff
-  alias LiveDebugger.App.Utils.TermParser
-
-  @empty_diff %Diff{type: :map, ins: %{}, del: %{}, diff: %{}}
-
   @doc """
   Given a tuple of render traces, compute the base stream diff and stream state.
   """
   def build_initial_stream_diff({stream_updates, _trace}) do
     stream_traces = extract_stream_traces(stream_updates)
     stream_names = get_stream_names_map(stream_traces)
 
-    # base_diff = TermDiffer.diff(%{}, base_stream_state)
-
-    # {_, initial_term_tree} =
-    #   TermParser.update_by_diff(
-    #     TermParser.term_to_display_tree(%{}),
-    #     base_diff
-    #   )
-
     fun_list = collect_updates(stream_traces)
-    # stream_names = Enum.map(stream_traces, &elem(&1, 0))
+    config_list = collect_config(stream_traces)
 
-    # dbg({inserts, deletes})
-    # deletes = ensure_delete_keys_present(inserts, deletes)
+    dbg(fun_list)
 
-    # computed_lists = reconstruct_stream_lists(inserts, deletes)
-    # # dbg(computed_lists)
-    # stream_state = build_stream_state_map(computed_lists)
-    # # dbg(stream_state)
-    # final_diff = build_diff_from_computed_lists(computed_lists)
-    # dbg(final_diff)
+    {fun_list, config_list, stream_names}
+  end
 
+  def compute_diff(stream_updates) do
+    stream_names = get_stream_names_map(stream_updates)
+    fun_list = collect_updates(stream_updates)
     {fun_list, stream_names}
   end
 
@@ -49,14 +33,6 @@ defmodule LiveDebugger.App.Debugger.NodeState.StreamUtils do
     |> Enum.reject(&Enum.empty?/1)
   end
 
-  defp infer_base_stream_state([]), do: %{}
-
-  defp infer_base_stream_state([first_trace | _]) do
-    first_trace
-    |> Enum.filter(fn {_, val} -> match?(%Phoenix.LiveView.LiveStream{}, val) end)
-    |> Map.new(fn {key, _val} -> {key, []} end)
-  end
-
   defp get_stream_names_map(updates) do
     updates
     |> Enum.flat_map(fn update ->
@@ -76,21 +52,55 @@ defmodule LiveDebugger.App.Debugger.NodeState.StreamUtils do
     update_list
   end
 
+  defp collect_config(update_list) do
+    update_list =
+      update_list
+      |> Enum.map(&flatten_stream_config(&1))
+      # We only need the first render because config stays the same and cannot be changed
+      |> Enum.take(1)
+      |> List.flatten()
+
+    dbg(update_list)
+    update_list
+  end
+
   def map_stream_entry_to_stream_function(%Phoenix.LiveView.LiveStream{
         name: name,
         inserts: inserts,
         deletes: deletes,
         reset?: reset?,
-        consumable?: consumable?
+        consumable?: _consumable?
       }) do
     []
     |> maybe_add_reset(reset?, name)
-    |> maybe_add_inserts(inserts, name)
+    # Reverse to preserve the order of inserts
+    |> maybe_add_inserts(Enum.reverse(inserts), name)
     |> maybe_add_deletes(deletes, name)
   end
 
+  def map_stream_entry_to_stream_config(
+        %Phoenix.LiveView.LiveStream{
+          name: name
+        },
+        config
+      ) do
+    []
+    |> maybe_add_config(config, name)
+  end
+
+  defp maybe_add_config(functions, nil, _name), do: functions
+
+  defp maybe_add_config(functions, [dom_id: fun], name) do
+    functions ++ [fn socket -> Phoenix.LiveView.stream_configure(socket, name, dom_id: fun) end]
+  end
+
   defp maybe_add_reset(functions, true, name) do
-    functions ++ [fn socket -> Phoenix.LiveView.stream(socket, name, [], reset: true) end]
+    functions ++
+      [
+        fn socket ->
+          Phoenix.LiveView.stream(socket, name, [], reset: true)
+        end
+      ]
   end
 
   defp maybe_add_reset(functions, false, _name), do: functions
@@ -108,7 +118,7 @@ defmodule LiveDebugger.App.Debugger.NodeState.StreamUtils do
   end
 
   defp create_insert_functions(inserts, name) do
-    Enum.map(inserts, fn {dom_id, at, element, limit, update?} ->
+    Enum.map(inserts, fn {_dom_id, at, element, limit, update?} ->
       fn socket ->
         Phoenix.LiveView.stream_insert(socket, name, element,
           at: at,
@@ -121,151 +131,36 @@ defmodule LiveDebugger.App.Debugger.NodeState.StreamUtils do
 
   defp create_delete_functions(deletes, name) do
     Enum.map(deletes, fn dom_id ->
-      dbg(dom_id)
-
       fn socket ->
-        Phoenix.LiveView.stream_delete_by_dom_id(socket, name, dom_id)
+        # Problem with same_id because ids are reused and element is updated and then deleted
+        Process.send_after(self(), {:delete_stream_entry, name, dom_id, socket}, 1)
+        socket
       end
     end)
   end
 
   defp flatten_stream_updates(stream_entry) do
+    dbg(stream_entry)
+
     Enum.flat_map(stream_entry, fn
-      {stream_name, %Phoenix.LiveView.LiveStream{} = stream} ->
-        dbg(map_stream_entry_to_stream_function(stream))
+      {_stream_name, %Phoenix.LiveView.LiveStream{} = stream} ->
         map_stream_entry_to_stream_function(stream)
 
       _ ->
         []
     end)
   end
 
-  # defp reconstruct_stream_lists(inserts, deletes) do
-  #   inserts
-  #   |> Enum.map(fn {stream_name, stream_inserts} ->
-  #     list = build_stream_list_from_inserts(stream_inserts)
-  #     deleted_ids = Map.get(deletes, stream_name, [])
-  #     # dbg(list)
-  #     # dbg(deleted_ids)
-
-  #     cleaned =
-  #       Enum.reduce(deleted_ids, list, fn dom_id, acc ->
-  #         List.keydelete(acc, dom_id, 0)
-  #       end)
-
-  #     {stream_name, cleaned}
-  #   end)
-  # end
+  defp flatten_stream_config(stream_entry) do
+    configured = Map.get(stream_entry, :__configured__)
 
-  # defp build_stream_list_from_inserts(inserts) do
-  #   Enum.reduce(Enum.reverse(inserts), [], fn {dom_id, _, element, _, updated?}, acc ->
-  #     if updated? do
-  #       List.keyreplace(acc, dom_id, 0, {dom_id, element})
-  #     else
-  #       List.insert_at(acc, 0, {dom_id, element})
-  #     end
-  #   end)
-  # end
-
-  # defp build_stream_state_map(list_map) do
-  #   list_map
-  #   |> Enum.map(fn {stream_name, list} ->
-  #     stream_state =
-  #       Enum.with_index(list, fn {dom_id, _val}, idx ->
-  #         {dom_id, idx}
-  #       end)
-
-  #     {stream_name, stream_state}
-  #   end)
-  #   |> Map.new()
-  # end
-
-  # defp build_diff_from_computed_lists(list_map) do
-  #   diff_map =
-  #     Enum.reduce(list_map, %{}, fn {stream_name, list}, acc ->
-  #       inserts =
-  #         list
-  #         |> Enum.with_index()
-  #         |> Enum.into(%{}, fn {{_dom_id, val}, index} ->
-  #           {index, val}
-  #         end)
-
-  #       # dbg(inserts)
-
-  #       list_diff = %Diff{type: :list, ins: inserts, del: %{}, diff: %{}}
-  #       Map.put(acc, stream_name, list_diff)
-  #     end)
-
-  #   Map.put(@empty_diff, :diff, diff_map)
-  # end
-
-  # defp compute_stream_diff_update(inserts, deletes, current_state) do
-  #   deleted_ids = MapSet.new(deletes)
-
-  #   cleaned_state =
-  #     Enum.reject(current_state, fn {dom_id, _} -> dom_id in deleted_ids end)
-
-  #   reindexed_state =
-  #     cleaned_state
-  #     |> Enum.with_index()
-  #     |> Enum.map(fn {{dom_id, _}, idx} -> {dom_id, idx} end)
-
-  #   deleted_map =
-  #     deletes
-  #     |> Enum.map(fn dom_id ->
-  #       case List.keyfind(current_state, dom_id, 0) do
-  #         {^dom_id, idx} -> {idx, :deleted}
-  #         _ -> nil
-  #       end
-  #     end)
-  #     |> Enum.reject(&is_nil/1)
-  #     |> Enum.into(%{})
-
-  #   {insert_ops, updated_del_map, updated_state} =
-  #     Enum.reduce(inserts, {[], %{}, reindexed_state}, fn
-  #       {dom_id, index, value, _, true}, {ins_acc, del_acc, state_acc} ->
-  #         {_, original_index} = List.keyfind(current_state, dom_id, 0)
-
-  #         updated_del =
-  #           if original_index, do: Map.put(del_acc, original_index, :deleted), else: del_acc
-
-  #         # tu cos nie dzila jeszcze i kolejnosc jeszce jak insertujemy pod ten sam domid bez update to tez update xd i
-  #         #  insert at index jesli jest mniej elementow to na koniec(update)
-  #         updated_ins = List.insert_at(ins_acc, index, {dom_id, value})
-  #         new_state = List.keyreplace(state_acc, dom_id, 0, {dom_id, index})
-
-  #         {updated_ins, updated_del, new_state}
-
-  #       {dom_id, index, value, _, false}, {ins_acc, del_acc, state_acc} ->
-  #         {
-  #           List.insert_at(ins_acc, index, {dom_id, value}),
-  #           del_acc,
-  #           List.insert_at(state_acc, index, {dom_id, index})
-  #         }
-  #     end)
-
-  #   # dbg(ins_map)
-
-  #   final_state =
-  #     updated_state
-  #     |> Enum.with_index()
-  #     |> Enum.map(fn {{dom_id, _}, idx} -> {dom_id, idx} end)
-
-  #   # dbg({insert_ops, final_state})
-
-  #   ins_map =
-  #     insert_ops
-  #     |> Enum.map(fn {dom_id, val} ->
-  #       {Keyword.fetch!(final_state, dom_id), val}
-  #     end)
-  #     |> Map.new()
-
-  #   # dbg(ins_map)
+    Enum.flat_map(stream_entry, fn
+      {stream_name, %Phoenix.LiveView.LiveStream{} = stream} ->
+        name_config = Map.get(configured, stream_name)
+        map_stream_entry_to_stream_config(stream, name_config)
 
-  #   %{
-  #     ins: ins_map,
-  #     del: Map.merge(deleted_map, updated_del_map),
-  #     final_state: final_state
-  #   }
-  # end
+      _ ->
+        []
+    end)
+  end
 end