remove _sync from public interface

Author: ckampfe

lib/b4.ex

@@ -8,11 +8,11 @@ defmodule B4 do
     end
   end
 
-  def insert_sync(directory, key, value) do
+  def insert(directory, key, value) do
     Writer.insert_sync(directory, key, value)
   end
 
-  def fetch_sync(directory, key) do
+  def fetch(directory, key) do
     tid = KeydirOwner.get_keydir_tid(directory)
 
     case Keydir.fetch(tid, key) do
@@ -46,7 +46,7 @@ defmodule B4 do
     end
   end
 
-  def delete_sync(directory, key) do
+  def delete(directory, key) do
     Writer.delete_sync(directory, key)
   end
 

test/b4_test.exs

@@ -14,58 +14,58 @@ defmodule B4Test do
 
   test "trivial roundtrip", %{dir: dir} do
     assert :ok = B4.new(dir)
-    assert :ok = B4.insert_sync(dir, "a", "b")
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
+    assert :ok = B4.insert(dir, "a", "b")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
   end
 
   test "loads existing data from one file", %{dir: dir} do
     assert :ok = B4.new(dir)
-    assert :ok = B4.insert_sync(dir, "a", "b")
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
+    assert :ok = B4.insert(dir, "a", "b")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
 
     assert :ok = B4.close(dir)
     assert :ok = B4.new(dir)
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
   end
 
   test "loads from multiple files", %{dir: dir} do
     Enum.each([{"a", "b"}, {"c", "d"}, {"e", "f"}], fn {k, v} ->
       assert :ok = B4.new(dir)
-      assert :ok = B4.insert_sync(dir, k, v)
-      assert {:ok, ^v} = B4.fetch_sync(dir, k)
+      assert :ok = B4.insert(dir, k, v)
+      assert {:ok, ^v} = B4.fetch(dir, k)
       assert :ok = B4.close(dir)
     end)
 
     assert :ok = B4.new(dir)
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
-    assert {:ok, "d"} = B4.fetch_sync(dir, "c")
-    assert {:ok, "f"} = B4.fetch_sync(dir, "e")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
+    assert {:ok, "d"} = B4.fetch(dir, "c")
+    assert {:ok, "f"} = B4.fetch(dir, "e")
   end
 
   test "loads from multiple files with deletes", %{dir: dir} do
     assert :ok = B4.new(dir)
-    assert :ok = B4.insert_sync(dir, "a", "b")
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
+    assert :ok = B4.insert(dir, "a", "b")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
     assert :ok = B4.close(dir)
 
     # DELETE HERE, for "c" key
     assert :ok = B4.new(dir)
-    assert :ok = B4.insert_sync(dir, "c", "d")
-    assert {:ok, "d"} = B4.fetch_sync(dir, "c")
-    assert :ok = B4.delete_sync(dir, "c")
-    assert :error = B4.fetch_sync(dir, "c")
+    assert :ok = B4.insert(dir, "c", "d")
+    assert {:ok, "d"} = B4.fetch(dir, "c")
+    assert :ok = B4.delete(dir, "c")
+    assert :error = B4.fetch(dir, "c")
     assert :ok = B4.close(dir)
 
     assert :ok = B4.new(dir)
-    assert :ok = B4.insert_sync(dir, "e", "f")
-    assert {:ok, "f"} = B4.fetch_sync(dir, "e")
-    assert :error = B4.fetch_sync(dir, "c")
+    assert :ok = B4.insert(dir, "e", "f")
+    assert {:ok, "f"} = B4.fetch(dir, "e")
+    assert :error = B4.fetch(dir, "c")
     assert :ok = B4.close(dir)
 
     assert :ok = B4.new(dir)
-    assert {:ok, "b"} = B4.fetch_sync(dir, "a")
-    assert :error = B4.fetch_sync(dir, "c")
-    assert {:ok, "f"} = B4.fetch_sync(dir, "e")
+    assert {:ok, "b"} = B4.fetch(dir, "a")
+    assert :error = B4.fetch(dir, "c")
+    assert {:ok, "f"} = B4.fetch(dir, "e")
   end
 
   test "loads large values", %{dir: dir} do
@@ -74,29 +74,29 @@ defmodule B4Test do
     large_2 = :rand.bytes(20000)
     large_3 = :rand.bytes(20000)
 
-    assert :ok = B4.insert_sync(dir, "a", large_1)
-    assert :ok = B4.insert_sync(dir, "b", large_2)
+    assert :ok = B4.insert(dir, "a", large_1)
+    assert :ok = B4.insert(dir, "b", large_2)
 
-    assert {:ok, ^large_1} = B4.fetch_sync(dir, "a")
-    assert {:ok, ^large_2} = B4.fetch_sync(dir, "b")
+    assert {:ok, ^large_1} = B4.fetch(dir, "a")
+    assert {:ok, ^large_2} = B4.fetch(dir, "b")
 
-    assert :ok = B4.insert_sync(dir, "b", large_3)
-    assert {:ok, ^large_3} = B4.fetch_sync(dir, "b")
+    assert :ok = B4.insert(dir, "b", large_3)
+    assert {:ok, ^large_3} = B4.fetch(dir, "b")
   end
 
   test "creates new write file when target_file_size", %{dir: dir} do
     target_file_size = 50
     assert :ok = B4.new(dir, target_file_size: target_file_size)
     assert Enum.count(File.ls!(dir)) == 1
 
-    assert :ok = B4.insert_sync(dir, "a", :rand.bytes(50))
+    assert :ok = B4.insert(dir, "a", :rand.bytes(50))
     assert Enum.count(File.ls!(dir)) == 1
 
     # file creation happens on the subsequent write above the limit
-    assert :ok = B4.insert_sync(dir, "a", :rand.bytes(50))
+    assert :ok = B4.insert(dir, "a", :rand.bytes(50))
     assert Enum.count(File.ls!(dir)) == 2
 
-    assert :ok = B4.insert_sync(dir, "a", :rand.bytes(50))
+    assert :ok = B4.insert(dir, "a", :rand.bytes(50))
     assert Enum.count(File.ls!(dir)) == 3
 
     assert Enum.all?(File.ls!(dir), fn path ->
@@ -109,16 +109,16 @@ defmodule B4Test do
     assert :ok = B4.new(dir)
     assert [] = B4.keys(dir)
 
-    assert :ok = B4.insert_sync(dir, "a", "b")
+    assert :ok = B4.insert(dir, "a", "b")
     assert ["a"] = B4.keys(dir)
 
-    assert :ok = B4.insert_sync(dir, "c", "d")
+    assert :ok = B4.insert(dir, "c", "d")
     assert ["a", "c"] = Enum.sort(B4.keys(dir))
 
-    assert :ok = B4.delete_sync(dir, "a")
+    assert :ok = B4.delete(dir, "a")
     assert ["c"] = Enum.sort(B4.keys(dir))
 
-    assert :ok = B4.delete_sync(dir, "c")
+    assert :ok = B4.delete(dir, "c")
     assert [] = Enum.sort(B4.keys(dir))
   end
 end