Update Reach lockfile

Author: dannote

packages/bridge/lib/pi/eval.ex

@@ -3,20 +3,10 @@ defmodule Pi.Eval do
 
   alias Pi.Bridge.Info
   alias Pi.Eval.{Evaluator, ExceptionInfo, Sandbox, Supervisor}
+  alias Pi.Eval.Output, as: EvalOutput
   alias Pi.Output
   alias Pi.Protocol.Tool.Eval, as: EvalPayload
   alias Pi.Protocol.Tool.OutputPart
-  alias Pi.Protocol.UI.Block
-  alias Pi.Protocol.UI.Display
-
-  @inspect_opts [charlists: :as_lists, limit: 50, pretty: true]
-  @preview_inspect_opts [
-    charlists: :as_lists,
-    limit: 20,
-    pretty: false,
-    printable_limit: 200,
-    width: 1_000_000
-  ]
 
   def sandbox(code, opts \\ []) when is_binary(code), do: Sandbox.eval(code, opts)
 
@@ -138,7 +128,7 @@ defmodule Pi.Eval do
 
   defp eval_with_captured_io(code, mode) do
     {{success?, result}, io} =
-      capture_io(fn ->
+      EvalOutput.capture_io(fn ->
         try do
           {result, _bindings} = Code.eval_string(code, [arguments: []], env())
           {true, result}
@@ -159,39 +149,50 @@ defmodule Pi.Eval do
     end
   end
 
-  defp error_text(%{text: text}) when is_binary(text), do: text
-  defp error_text(text) when is_binary(text), do: text
-
-  defp error_exception(%{exception: exception}) when is_map(exception), do: exception
-  defp error_exception(_), do: nil
-
   defp format_eval_result(result, success?, io) do
     case {result, success?, io} do
-      {:"do not show this result in output", true, io} -> {:ok, io}
-      {result, false, ""} -> {:error, error_text(result)}
-      {result, false, io} -> {:error, "IO:\n\n#{io}\n\nError:\n\n#{error_text(result)}"}
-      {result, true, ""} -> {:ok, inspect(result, @inspect_opts)}
-      {result, true, io} -> {:ok, "IO:\n\n#{io}\n\nResult:\n\n#{inspect(result, @inspect_opts)}"}
+      {:"do not show this result in output", true, io} ->
+        {:ok, io}
+
+      {result, false, ""} ->
+        {:error, EvalOutput.error_text(result)}
+
+      {result, false, io} ->
+        {:error, "IO:\n\n#{io}\n\nError:\n\n#{EvalOutput.error_text(result)}"}
+
+      {result, true, ""} ->
+        {:ok, EvalOutput.inspect_value(result)}
+
+      {result, true, io} ->
+        {:ok, "IO:\n\n#{io}\n\nResult:\n\n#{EvalOutput.inspect_value(result)}"}
     end
   end
 
   defp structured_eval_result(:"do not show this result in output", true, io, {:ok, text}) do
     parts = if io == "", do: [], else: [OutputPart.text(io)]
-    {:ok, %EvalPayload{io: io, result: nil, text: text, parts: parts, display: display(parts)}}
+
+    {:ok,
+     %EvalPayload{
+       io: io,
+       result: nil,
+       text: text,
+       parts: parts,
+       display: EvalOutput.display(parts)
+     }}
   end
 
   defp structured_eval_result(result, true, io, {:ok, text}) do
     explicit_text = Output.text_for(result)
-    inspected = explicit_text || inspect(result, @inspect_opts)
-    preview = inspect(result, @preview_inspect_opts)
+    inspected = explicit_text || EvalOutput.inspect_value(result)
+    preview = EvalOutput.preview(result)
 
     value_parts =
       Output.parts_for(result) ||
         [OutputPart.inspect(inspected, language: :elixir, title: preview)]
 
     parts =
       []
-      |> maybe_io_part(io)
+      |> EvalOutput.maybe_io_part(io)
       |> Kernel.++(value_parts)
 
     {:ok,
@@ -200,41 +201,27 @@ defmodule Pi.Eval do
        result: inspected,
        text: explicit_text || text,
        parts: parts,
-       display: display(parts)
+       display: EvalOutput.display(parts)
      }}
   end
 
   defp structured_eval_result(result, false, io, {:error, text}) do
     parts =
       []
-      |> maybe_io_part(io)
+      |> EvalOutput.maybe_io_part(io)
       |> Kernel.++([OutputPart.error(text)])
 
     {:error,
      %EvalPayload{
        io: io,
        error: text,
-       exception: error_exception(result),
+       exception: EvalOutput.error_exception(result),
        text: text,
        parts: parts,
-       display: display(parts)
+       display: EvalOutput.display(parts)
      }}
   end
 
-  defp maybe_io_part(parts, ""), do: parts
-  defp maybe_io_part(parts, io), do: parts ++ [OutputPart.text(io)]
-
-  defp display(parts) do
-    %Display{blocks: Enum.map(parts, &part_block/1)}
-  end
-
-  defp part_block(%OutputPart{kind: kind, body: body, language: language}) do
-    %Block{type: block_type(kind), text: body, language: language}
-  end
-
-  defp block_type(:code), do: :source
-  defp block_type(kind), do: kind
-
   defp normalize_names!(name) when is_atom(name), do: [name]
 
   defp normalize_names!(name) when is_binary(name), do: [String.to_existing_atom(name)]
@@ -251,24 +238,6 @@ defmodule Pi.Eval do
     __ENV__
   end
 
-  defp capture_io(fun) do
-    {:ok, pid} = StringIO.open("")
-    original = Application.get_env(:elixir, :ansi_enabled)
-    Application.put_env(:elixir, :ansi_enabled, false)
-    original_gl = Process.group_leader()
-    Process.group_leader(self(), pid)
-
-    try do
-      result = fun.()
-      {_, content} = StringIO.contents(pid)
-      {result, content}
-    after
-      Process.group_leader(self(), original_gl)
-      StringIO.close(pid)
-      Application.put_env(:elixir, :ansi_enabled, original)
-    end
-  end
-
   defp endpoints do
     for {app, _, _} <- Application.started_applications(),
         mod <- (Application.get_env(app, :phoenix_endpoint) || []) |> List.wrap() do

packages/bridge/lib/pi/eval/evaluator.ex

@@ -5,20 +5,11 @@ defmodule Pi.Eval.Evaluator do
 
   alias Pi.Bridge.Info
   alias Pi.Eval.{ExceptionInfo, Snapshot}
+  alias Pi.Eval.Output, as: EvalOutput
   alias Pi.Output
   alias Pi.Protocol.Tool.Eval, as: EvalPayload
   alias Pi.Protocol.Tool.OutputPart
-  alias Pi.Protocol.UI.Block
-  alias Pi.Protocol.UI.Display
-
-  @inspect_opts [charlists: :as_lists, limit: 50, pretty: true]
-  @preview_inspect_opts [
-    charlists: :as_lists,
-    limit: 20,
-    pretty: false,
-    printable_limit: 200,
-    width: 1_000_000
-  ]
+
   @control_key {Pi.Eval, :control}
   @binding_info_key {Pi.Eval, :binding_info}
   @session_id_key {Pi.Eval, :session_id}
@@ -111,7 +102,7 @@ defmodule Pi.Eval.Evaluator do
   end
 
   defp eval_with_captured_io(code, state) do
-    {{success?, result, state}, io} = capture_io(fn -> eval_code(code, state) end)
+    {{success?, result, state}, io} = EvalOutput.capture_io(fn -> eval_code(code, state) end)
 
     cond do
       success? ->
@@ -120,11 +111,17 @@ defmodule Pi.Eval.Evaluator do
         {{:ok, structured_result(result, io, state, persist_meta)}, state}
 
       io != "" ->
-        text = "IO:\n\n#{io}\n\nError:\n\n#{error_text(result)}"
-        {{:error, error_result(text, io, state, error_exception(result))}, state}
+        text = "IO:\n\n#{io}\n\nError:\n\n#{EvalOutput.error_text(result)}"
+        {{:error, error_result(text, io, state, EvalOutput.error_exception(result))}, state}
 
       true ->
-        {{:error, error_result(error_text(result), io, state, error_exception(result))}, state}
+        {{:error,
+          error_result(
+            EvalOutput.error_text(result),
+            io,
+            state,
+            EvalOutput.error_exception(result)
+          )}, state}
     end
   end
 
@@ -167,24 +164,24 @@ defmodule Pi.Eval.Evaluator do
       result: nil,
       text: io,
       parts: parts,
-      display: display(parts),
+      display: EvalOutput.display(parts),
       bindings: Snapshot.binding_info(state.binding),
       state: eval_state_meta(state, persist_meta)
     }
   end
 
   defp structured_result(result, io, state, persist_meta) do
     explicit_text = Output.text_for(result)
-    inspected = explicit_text || inspect(result, @inspect_opts)
-    preview = inspect(result, @preview_inspect_opts)
+    inspected = explicit_text || EvalOutput.inspect_value(result)
+    preview = EvalOutput.preview(result)
 
     value_parts =
       Output.parts_for(result) ||
         [OutputPart.inspect(inspected, language: :elixir, title: preview)]
 
     parts =
       []
-      |> maybe_io_part(io)
+      |> EvalOutput.maybe_io_part(io)
       |> Kernel.++(value_parts)
 
     text =
@@ -196,44 +193,27 @@ defmodule Pi.Eval.Evaluator do
       result: inspected,
       text: text,
       parts: parts,
-      display: display(parts),
+      display: EvalOutput.display(parts),
       bindings: Snapshot.binding_info(state.binding),
       state: eval_state_meta(state, persist_meta)
     }
   end
 
-  defp error_text(%{text: text}) when is_binary(text), do: text
-  defp error_text(text) when is_binary(text), do: text
-
-  defp error_exception(%{exception: exception}) when is_map(exception), do: exception
-  defp error_exception(_), do: nil
-
   defp error_result(text, io, state, exception) do
-    parts = [] |> maybe_io_part(io) |> Kernel.++([OutputPart.error(text)])
+    parts = [] |> EvalOutput.maybe_io_part(io) |> Kernel.++([OutputPart.error(text)])
 
     %EvalPayload{
       io: io,
       error: text,
       exception: exception,
       text: text,
       parts: parts,
-      display: display(parts),
+      display: EvalOutput.display(parts),
       bindings: Snapshot.binding_info(state.binding),
       state: eval_state_meta(state, %{persisted?: false})
     }
   end
 
-  defp maybe_io_part(parts, ""), do: parts
-  defp maybe_io_part(parts, io), do: parts ++ [OutputPart.text(io)]
-  defp display(parts), do: %Display{blocks: Enum.map(parts, &part_block/1)}
-
-  defp part_block(%OutputPart{} = part) do
-    struct(Block, type: block_type(part.kind), text: part.body, language: part.language)
-  end
-
-  defp block_type(:code), do: :source
-  defp block_type(kind), do: kind
-
   defp eval_state_meta(state, persist_meta) do
     %{
       sessionId: state.session_id,
@@ -312,24 +292,6 @@ defmodule Pi.Eval.Evaluator do
     end)
   end
 
-  defp capture_io(fun) do
-    {:ok, pid} = StringIO.open("")
-    original = Application.get_env(:elixir, :ansi_enabled)
-    original_gl = Process.group_leader()
-    Application.put_env(:elixir, :ansi_enabled, false)
-    Process.group_leader(self(), pid)
-
-    try do
-      result = fun.()
-      {_, content} = StringIO.contents(pid)
-      {result, content}
-    after
-      Process.group_leader(self(), original_gl)
-      StringIO.close(pid)
-      Application.put_env(:elixir, :ansi_enabled, original)
-    end
-  end
-
   defp eval_file(session_id), do: "pi://eval/" <> session_id
   defp via(session_id), do: {:via, Registry, {Pi.Eval.Registry, session_id}}
 

packages/bridge/lib/pi/eval/output.ex

@@ -0,0 +1,55 @@
+defmodule Pi.Eval.Output do
+  @moduledoc false
+
+  alias Pi.Protocol.Tool.OutputPart
+  alias Pi.Protocol.UI.Block
+  alias Pi.Protocol.UI.Display
+
+  @inspect_opts [charlists: :as_lists, limit: 50, pretty: true]
+  @preview_inspect_opts [
+    charlists: :as_lists,
+    limit: 20,
+    pretty: false,
+    printable_limit: 200,
+    width: 1_000_000
+  ]
+
+  def inspect_value(value), do: inspect(value, @inspect_opts)
+  def preview(value), do: inspect(value, @preview_inspect_opts)
+
+  def error_text(%{text: text}) when is_binary(text), do: text
+  def error_text(text) when is_binary(text), do: text
+
+  def error_exception(%{exception: exception}) when is_map(exception), do: exception
+  def error_exception(_), do: nil
+
+  def maybe_io_part(parts, ""), do: parts
+  def maybe_io_part(parts, io), do: parts ++ [OutputPart.text(io)]
+
+  def display(parts), do: %Display{blocks: Enum.map(parts, &part_block/1)}
+
+  def capture_io(fun) do
+    {:ok, pid} = StringIO.open("")
+    original = Application.get_env(:elixir, :ansi_enabled)
+    original_gl = Process.group_leader()
+    Application.put_env(:elixir, :ansi_enabled, false)
+    Process.group_leader(self(), pid)
+
+    try do
+      result = fun.()
+      {_, content} = StringIO.contents(pid)
+      {result, content}
+    after
+      Process.group_leader(self(), original_gl)
+      StringIO.close(pid)
+      Application.put_env(:elixir, :ansi_enabled, original)
+    end
+  end
+
+  defp part_block(%OutputPart{} = part) do
+    struct(Block, type: block_type(part.kind), text: part.body, language: part.language)
+  end
+
+  defp block_type(:code), do: :source
+  defp block_type(kind), do: kind
+end