Add decoding and encoding to string for Graph

lib/imageflow/graph.ex

@@ -90,6 +90,18 @@ defmodule Imageflow.Graph do
     |> append_node(%{decode: %{io_id: io_id}})
   end
 
+  @doc """
+  Appends a string to be decoded
+  """
+  @spec decode_string(t, binary) :: t
+  def decode_string(%{io_count: io_count} = graph, string) do
+    io_id = io_count + 1
+
+    graph
+    |> add_input(io_id, {:bytes, string})
+    |> append_node(%{decode: %{io_id: io_id}})
+  end
+
   @doc """
   Specifies a destination file for the current branch of the pipeline
 
@@ -120,6 +132,37 @@ defmodule Imageflow.Graph do
     |> append_node(%{encode: %{io_id: io_id, preset: preset_for(encoder, opts)}})
   end
 
+  @doc """
+  Returns the converted image as a string.
+
+  No further processing operations should be appended at the current branch after this call.
+
+  The last two arguments specify the encoder and optional encoding parameters.
+
+  The following parameters are valid encoders:
+  * `:jpg`: Alias to `:mozjpeg`
+  * `:jpeg`: Alias to `:mozjpeg`
+  * `:png`: Alias to `:lodepng`
+  * `:webp: Alias to `:webplossless
+  * `:mozjpeg`
+  * `:gif`
+  * `:lodepng`: Lossless PNG
+  * `:pngquant`: Lossy PNG
+  * `:webplossy`: Lossy WebP
+  * `:webplossless`: Lossless WebP
+
+  Check the official [encoding documentation](https://docs.imageflow.io/json/encode.html) to see the parameters available to each encoder
+  """
+
+  @spec encode_to_string(t, binary | atom, map) :: t
+  def encode_to_string(%{io_count: io_count} = graph, encoder \\ :png, opts \\ %{}) do
+    io_id = io_count + 1
+
+    graph
+    |> add_output(io_id, :bytes)
+    |> append_node(%{encode: %{io_id: io_id, preset: preset_for(encoder, opts)}})
+  end
+
   @doc """
   Creates a new branch, allowing you do add multiple paths and outputs to the
   graph

lib/imageflow/graph_runner.ex

@@ -7,8 +7,8 @@ defmodule Imageflow.GraphRunner do
          :ok <- add_outputs(job, graph.outputs),
          :ok <- send_task(job, graph),
          :ok <- save_outputs(job, graph.outputs),
-         :ok <- Native.destroy(job) do
-      :ok
+         {:ok, results} <- print_results(job, graph.outputs) do
+      if results == [], do: :ok, else: {:ok, results}
     end
   end
 
@@ -18,6 +18,7 @@ defmodule Imageflow.GraphRunner do
       {id, value}, :ok ->
         case value do
           {:file, path} -> Native.add_input_file(job, id, path)
+          {:bytes, blob} -> Native.add_input_buffer(job, id, blob)
         end
         |> case do
           :ok -> {:cont, :ok}
@@ -29,10 +30,13 @@ defmodule Imageflow.GraphRunner do
   defp add_outputs(job, inputs) do
     inputs
     |> Enum.reduce_while(:ok, fn
-      {id, _}, :ok ->
-        with :ok <- Native.add_output_buffer(job, id) do
-          {:cont, :ok}
-        else
+      {id, value}, :ok ->
+        case value do
+          {:file, _path} -> Native.add_output_buffer(job, id)
+          :bytes -> Native.add_output_buffer(job, id)
+        end
+        |> case do
+          :ok -> {:cont, :ok}
           {:error, _} = error -> {:halt, error}
         end
     end)
@@ -44,6 +48,8 @@ defmodule Imageflow.GraphRunner do
       {id, value}, :ok ->
         case value do
           {:file, path} -> Native.save_output_to_file(job, id, path)
+          # skip
+          :bytes -> :ok
         end
         |> case do
           :ok -> {:cont, :ok}
@@ -52,6 +58,22 @@ defmodule Imageflow.GraphRunner do
     end)
   end
 
+  def print_results(job, outputs) do
+    outputs
+    |> Enum.reduce_while({:ok, []}, fn {id, value}, {:ok, acc} ->
+      case value do
+        :bytes -> Native.get_output_buffer(job, id)
+        # skip
+        {:file, _} -> :skip
+      end
+      |> case do
+        :skip -> {:cont, {:ok, acc}}
+        {:ok, results} -> {:cont, {:ok, :binary.list_to_bin(results)}}
+        {:error, _} = error -> {:halt, error}
+      end
+    end)
+  end
+
   defp send_task(job, graph) do
     with {:ok, _response} <- Native.message(job, "v0.1/execute", graph) do
       :ok

test/imageflow/graph_test.exs

@@ -9,7 +9,7 @@ defmodule Imageflow.GraphTest do
     end
   end
 
-  describe "decode_file/1" do
+  describe "decode_file/2" do
     test "appends a new input" do
       graph = Graph.new() |> Graph.decode_file("file.png")
 
@@ -23,7 +23,23 @@ defmodule Imageflow.GraphTest do
     end
   end
 
-  describe "encode_file/1" do
+  describe "decode_string/2" do
+    test "appends a new input" do
+      {:ok, string} = File.read("test/fixtures/elixir-logo.jpg")
+      graph = Graph.new() |> Graph.decode_string(string)
+
+      assert %{io_count: 1, inputs: %{1 => {:bytes, _string}}} = graph
+    end
+
+    test "appends a file decoding operation" do
+      {:ok, string} = File.read("test/fixtures/elixir-logo.jpg")
+      graph = Graph.new() |> Graph.decode_string(string)
+
+      assert %{nodes: %{1 => %{decode: %{io_id: 1}}}} = graph
+    end
+  end
+
+  describe "encode_to_file/2" do
     test "appends a new output" do
       graph = Graph.new() |> Graph.encode_to_file("file.png")
 
@@ -91,6 +107,74 @@ defmodule Imageflow.GraphTest do
     end
   end
 
+  describe "encode_to_string/2" do
+    test "appends a new output" do
+      graph = Graph.new() |> Graph.encode_to_string()
+
+      assert %{io_count: 1, outputs: %{1 => :bytes}} = graph
+    end
+
+    test "appends a file encoding operation" do
+      graph = Graph.new() |> Graph.encode_to_string()
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1}}}} = graph
+    end
+
+    test "allows appending jpg outputs" do
+      graph = Graph.new() |> Graph.encode_to_string(:jpg)
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: %{mozjpeg: %{quality: 90}}}}}} = graph
+    end
+
+    test "allows appending jpg outputs with custom parameters" do
+      graph = Graph.new() |> Graph.encode_to_string(:jpg, %{quality: 10})
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: %{mozjpeg: %{quality: 10}}}}}} = graph
+    end
+
+    test "allows appending png outputs" do
+      graph = Graph.new() |> Graph.encode_to_string(:png)
+
+      assert %{
+               nodes: %{
+                 1 => %{encode: %{io_id: 1, preset: %{lodepng: %{maximum_deflate: false}}}}
+               }
+             } = graph
+    end
+
+    test "allows appending png outputs with custom parameters" do
+      graph = Graph.new() |> Graph.encode_to_string(:png, %{maximum_deflate: true})
+
+      assert %{
+               nodes: %{1 => %{encode: %{io_id: 1, preset: %{lodepng: %{maximum_deflate: true}}}}}
+             } = graph
+    end
+
+    test "allows appending gif outputs" do
+      graph = Graph.new() |> Graph.encode_to_string(:gif)
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: :gif}}}} = graph
+    end
+
+    test "allows appending gif outputs with custom parameters" do
+      graph = Graph.new() |> Graph.encode_to_string(:gif, %{a: :b})
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: :gif}}}} = graph
+    end
+
+    test "allows appending webp outputs" do
+      graph = Graph.new() |> Graph.encode_to_string(:webp)
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: :webplossless}}}} = graph
+    end
+
+    test "allows appending webp outputs with custom parameters" do
+      graph = Graph.new() |> Graph.encode_to_string(:webp, %{a: :b})
+
+      assert %{nodes: %{1 => %{encode: %{io_id: 1, preset: :webplossless}}}} = graph
+    end
+  end
+
   describe "constrain/4" do
     test "appends a constrain operation" do
       graph = Graph.new() |> Graph.constrain(10, 20)