patch => diff

Author: ericmj

lib/diff/storage/gcs.ex

@@ -5,9 +5,9 @@ defmodule Diff.Storage.GCS do
 
   @gs_xml_url "https://storage.googleapis.com"
 
-  def get_patch(package, from_version, to_version, patch_id) do
+  def get_diff(package, from_version, to_version, diff_id) do
     with {:ok, hash} <- combined_checksum(package, from_version, to_version),
-         url = url(patch_key(package, from_version, to_version, hash, patch_id)),
+         url = url(diff_key(package, from_version, to_version, hash, diff_id)),
          {:ok, 200, _headers, body} <-
            Diff.HTTP.retry("gs", fn -> Diff.HTTP.get(url, headers()) end) do
       {:ok, body}
@@ -16,37 +16,37 @@ defmodule Diff.Storage.GCS do
         {:error, :not_found}
 
       {:ok, status, _headers, _body} ->
-        Logger.error("Failed to get patch from storage. Status #{status}")
+        Logger.error("Failed to get diff from storage. Status #{status}")
         {:error, :not_found}
 
       {:error, reason} ->
-        Logger.error("Failed to get patch from storage. Reason #{inspect(reason)}")
+        Logger.error("Failed to get diff from storage. Reason #{inspect(reason)}")
         {:error, :not_found}
     end
   end
 
-  def put_patch(package, from_version, to_version, patch_id, patch_data) do
+  def put_diff(package, from_version, to_version, diff_id, diff_data) do
     with {:ok, hash} <- combined_checksum(package, from_version, to_version),
-         url = url(patch_key(package, from_version, to_version, hash, patch_id)),
+         url = url(diff_key(package, from_version, to_version, hash, diff_id)),
          {:ok, 200, _headers, _body} <-
-           Diff.HTTP.retry("gs", fn -> Diff.HTTP.put(url, headers(), patch_data) end) do
+           Diff.HTTP.retry("gs", fn -> Diff.HTTP.put(url, headers(), diff_data) end) do
       :ok
     else
       {:ok, status, _headers, _body} ->
-        Logger.error("Failed to put patch to storage. Status #{status}")
+        Logger.error("Failed to put diff to storage. Status #{status}")
         {:error, :storage_error}
 
       error ->
-        Logger.error("Failed to put patch to storage. Reason #{inspect(error)}")
+        Logger.error("Failed to put diff to storage. Reason #{inspect(error)}")
         error
     end
   end
 
-  def list_patches(package, from_version, to_version) do
+  def list_diffs(package, from_version, to_version) do
     case get_metadata(package, from_version, to_version) do
-      {:ok, %{total_patches: total_patches}} ->
-        patch_ids = 0..(total_patches - 1) |> Enum.map(&"patch-#{&1}")
-        {:ok, patch_ids}
+      {:ok, %{total_diffs: total_diffs}} ->
+        diff_ids = 0..(total_diffs - 1) |> Enum.map(&"diff-#{&1}")
+        {:ok, diff_ids}
 
       {:error, :not_found} ->
         {:ok, []}
@@ -112,8 +112,8 @@ defmodule Diff.Storage.GCS do
     end
   end
 
-  defp patch_key(package, from_version, to_version, hash, patch_id) do
-    "diffs/patches/#{package}-#{from_version}-#{to_version}-#{hash}-#{patch_id}.patch"
+  defp diff_key(package, from_version, to_version, hash, diff_id) do
+    "diffs/diffs/#{package}-#{from_version}-#{to_version}-#{hash}-#{diff_id}.json"
   end
 
   defp metadata_key(package, from_version, to_version, hash) do

lib/diff/storage/local.ex

@@ -3,11 +3,11 @@ defmodule Diff.Storage.Local do
 
   @behaviour Diff.Storage
 
-  def get_patch(package, from_version, to_version, patch_id) do
+  def get_diff(package, from_version, to_version, diff_id) do
     case combined_checksum(package, from_version, to_version) do
       {:ok, hash} ->
-        filename = patch_key(package, from_version, to_version, hash, patch_id)
-        path = Path.join([dir(), package, "patches", filename])
+        filename = diff_key(package, from_version, to_version, hash, diff_id)
+        path = Path.join([dir(), package, "diffs", filename])
 
         if File.regular?(path) do
           {:ok, File.read!(path)}
@@ -20,40 +20,40 @@ defmodule Diff.Storage.Local do
     end
   end
 
-  def put_patch(package, from_version, to_version, patch_id, patch_data) do
+  def put_diff(package, from_version, to_version, diff_id, diff_data) do
     with {:ok, hash} <- combined_checksum(package, from_version, to_version),
-         filename = patch_key(package, from_version, to_version, hash, patch_id),
-         path = Path.join([dir(), package, "patches", filename]),
+         filename = diff_key(package, from_version, to_version, hash, diff_id),
+         path = Path.join([dir(), package, "diffs", filename]),
          :ok <- File.mkdir_p(Path.dirname(path)) do
-      File.write!(path, patch_data)
+      File.write!(path, diff_data)
       :ok
     else
       {:error, reason} ->
-        Logger.error("Failed to store patch. Reason: #{inspect(reason)}.")
+        Logger.error("Failed to store diff. Reason: #{inspect(reason)}.")
         {:error, reason}
     end
   end
 
-  def list_patches(package, from_version, to_version) do
+  def list_diffs(package, from_version, to_version) do
     case combined_checksum(package, from_version, to_version) do
       {:ok, hash} ->
-        patches_dir = Path.join([dir(), package, "patches"])
+        diffs_dir = Path.join([dir(), package, "diffs"])
         prefix = "#{package}-#{from_version}-#{to_version}-#{hash}-"
 
-        if File.dir?(patches_dir) do
-          patch_ids =
-            patches_dir
+        if File.dir?(diffs_dir) do
+          diff_ids =
+            diffs_dir
             |> File.ls!()
             |> Enum.filter(&String.starts_with?(&1, prefix))
             |> Enum.map(fn filename ->
               filename
               |> String.replace_prefix(prefix, "")
-              |> String.replace_suffix(".patch", "")
+              |> String.replace_suffix(".diff", "")
             end)
-            |> Enum.sort_by(fn patch_id ->
-              # Extract numeric part for proper sorting (e.g., "patch-10" -> 10)
-              case String.split(patch_id, "-") do
-                ["patch", num_str] ->
+            |> Enum.sort_by(fn diff_id ->
+              # Extract numeric part for proper sorting (e.g., "diff-10" -> 10)
+              case String.split(diff_id, "-") do
+                ["diff", num_str] ->
                   case Integer.parse(num_str) do
                     {num, _} -> num
                     :error -> 0
@@ -64,7 +64,7 @@ defmodule Diff.Storage.Local do
               end
             end)
 
-          {:ok, patch_ids}
+          {:ok, diff_ids}
         else
           {:ok, []}
         end
@@ -121,8 +121,8 @@ defmodule Diff.Storage.Local do
     end
   end
 
-  defp patch_key(package, from_version, to_version, hash, patch_id) do
-    "#{package}-#{from_version}-#{to_version}-#{hash}-#{patch_id}.patch"
+  defp diff_key(package, from_version, to_version, hash, diff_id) do
+    "#{package}-#{from_version}-#{to_version}-#{hash}-#{diff_id}.diff"
   end
 
   defp metadata_key(package, from_version, to_version, hash) do

lib/diff/storage/storage.ex

@@ -2,21 +2,21 @@ defmodule Diff.Storage do
   @type package :: String.t()
   @type from_version :: String.t()
   @type to_version :: String.t()
-  @type patch_id :: String.t()
-  @type patch_html :: String.t()
+  @type diff_id :: String.t()
+  @type diff_html :: String.t()
   @type diff_metadata :: %{
-          total_patches: non_neg_integer(),
+          total_diffs: non_neg_integer(),
           total_additions: non_neg_integer(),
           total_deletions: non_neg_integer(),
           files_changed: non_neg_integer()
         }
 
-  # New patch-level storage callbacks
-  @callback get_patch(package, from_version, to_version, patch_id) ::
-              {:ok, patch_html} | {:error, term}
-  @callback put_patch(package, from_version, to_version, patch_id, patch_html) ::
+  # New diff-level storage callbacks
+  @callback get_diff(package, from_version, to_version, diff_id) ::
+              {:ok, diff_html} | {:error, term}
+  @callback put_diff(package, from_version, to_version, diff_id, diff_html) ::
               :ok | {:error, term}
-  @callback list_patches(package, from_version, to_version) :: {:ok, [patch_id]} | {:error, term}
+  @callback list_diffs(package, from_version, to_version) :: {:ok, [diff_id]} | {:error, term}
 
   # Metadata storage callbacks
   @callback get_metadata(package, from_version, to_version) ::
@@ -25,16 +25,16 @@ defmodule Diff.Storage do
 
   defp impl(), do: Application.get_env(:diff, :storage_impl)
 
-  def get_patch(package, from_version, to_version, patch_id) do
-    impl().get_patch(package, from_version, to_version, patch_id)
+  def get_diff(package, from_version, to_version, diff_id) do
+    impl().get_diff(package, from_version, to_version, diff_id)
   end
 
-  def put_patch(package, from_version, to_version, patch_id, patch_html) do
-    impl().put_patch(package, from_version, to_version, patch_id, patch_html)
+  def put_diff(package, from_version, to_version, diff_id, diff_html) do
+    impl().put_diff(package, from_version, to_version, diff_id, diff_html)
   end
 
-  def list_patches(package, from_version, to_version) do
-    impl().list_patches(package, from_version, to_version)
+  def list_diffs(package, from_version, to_version) do
+    impl().list_diffs(package, from_version, to_version)
   end
 
   def get_metadata(package, from_version, to_version) do