refactor: remove redundant new method from modules

lib/elasticlunr/bloom/stackable.ex

@@ -25,14 +25,16 @@ defmodule Elasticlunr.Bloom.Stackable do
   @spec new(keyword()) :: t()
   def new(opts \\ []) do
     # TODO: Allow parameters to be configured by user
-    fp_rate = Keyword.get(opts, :fp_rate, 0.01)
-    capacity = Keyword.get(opts, :capacity, 500_000)
+    opts = Keyword.validate!(opts, fp_rate: 0.01, capacity: 500_000, expansion: 2)
+
+    fp_rate = opts[:fp_rate]
+    capacity = opts[:capacity]
 
     attrs = %{
       count: 0,
       fp_rate: fp_rate,
       capacity: capacity,
-      expansion: Keyword.get(opts, :expansion, 2),
+      expansion: opts[:expansion],
       bloom_filters: [Bloom.new_optimal(capacity, fp_rate)]
     }
 

lib/elasticlunr/index/writer.ex

@@ -113,7 +113,7 @@ defmodule Elasticlunr.Index.Writer do
   defp recover_from_logs(%{log_files: []} = state) do
     state
     |> Map.put(:compactions, 0)
-    |> Map.put(:mem_table, MemTable.new())
+    |> Map.put(:mem_table, %MemTable{})
     |> then(&{:ok, &1})
   end
 
@@ -126,7 +126,7 @@ defmodule Elasticlunr.Index.Writer do
       dir: dir,
       options: options,
       manifest: manifest,
-      mem_table: MemTable.new(),
+      mem_table: %MemTable{},
       last_log_number: List.last(log_files),
       max_buffer_size: options.max_buffer_size
     }
@@ -199,7 +199,7 @@ defmodule Elasticlunr.Index.Writer do
 
       with {true, mt} <- {MemTable.size(mt) >= mbs, mt},
            {:ok, manifest} <- flush_mt.(mt, dir, manifest, options) do
-        {:cont, %{acc | mem_table: MemTable.new(), manifest: manifest, compactions: c + 1}}
+        {:cont, %{acc | mem_table: %MemTable{}, manifest: manifest, compactions: c + 1}}
       else
         {false, mem_table} -> {:cont, Map.put(acc, :mem_table, mem_table)}
         error -> {:halt, error}
@@ -212,7 +212,7 @@ defmodule Elasticlunr.Index.Writer do
         # See `Elasticlunr.Server.Writer.flush_async/1`
         {:ok, manifest} = flush_mt.(mt, dir, manifest, options)
 
-        %{p | compactions: 1, mem_table: MemTable.new(), manifest: manifest}
+        %{p | compactions: 1, mem_table: %MemTable{}, manifest: manifest}
 
       %{} = p ->
         p

lib/elasticlunr/mem_table.ex

@@ -8,9 +8,6 @@ defmodule Elasticlunr.MemTable do
           size: non_neg_integer()
         }
 
-  @spec new() :: t()
-  def new, do: struct!(__MODULE__)
-
   @spec length(t()) :: non_neg_integer()
   def length(%__MODULE__{entries: entries}), do: Treex.size(entries)
 
@@ -37,7 +34,7 @@ defmodule Elasticlunr.MemTable do
     case Treex.lookup(entries, key) do
       :none ->
         size = size + IO.iodata_length(key) + IO.iodata_length(value) + 16 + 1
-        entry = Entry.new(key, value, false, timestamp)
+        entry = %Entry{key: key, value: value, deleted: false, timestamp: timestamp}
 
         entries = Treex.insert!(entries, key, entry)
 
@@ -63,7 +60,7 @@ defmodule Elasticlunr.MemTable do
       :none ->
         size = size + IO.iodata_length(key) + 16 + 1
 
-        entry = Entry.new(key, nil, true, timestamp)
+        entry = %Entry{key: key, value: nil, deleted: true, timestamp: timestamp}
         entries = Treex.insert!(entries, key, entry)
 
         %{mem_table | entries: entries, size: size}

lib/elasticlunr/mem_table/entry.ex

@@ -8,15 +8,4 @@ defmodule Elasticlunr.MemTable.Entry do
           deleted: boolean(),
           timestamp: pos_integer()
         }
-
-  def new(key, value, deleted, timestamp) do
-    attrs = %{
-      key: key,
-      value: value,
-      deleted: deleted,
-      timestamp: timestamp
-    }
-
-    struct!(__MODULE__, attrs)
-  end
 end

lib/elasticlunr/server/writer.ex

@@ -191,7 +191,7 @@ defmodule Elasticlunr.Server.Writer do
   defp gen_new_space(%{dir: dir, manifest: manifest} = writer) do
     number = Manifest.new_file_number(manifest)
 
-    %{writer | wal: Wal.create(dir, number), mem_table: MemTable.new()}
+    %{writer | wal: Wal.create(dir, number), mem_table: %MemTable{}}
   end
 
   defp wait_for_task(task) do

lib/elasticlunr/ss_table.ex

@@ -13,6 +13,7 @@ defmodule Elasticlunr.SSTable do
   alias Elasticlunr.Workflow.OpenSSTable
   alias Elasticlunr.Workflow.WriteSSTable
 
+  @enforce_keys [:path, :bloom_filter, :offsets]
   defstruct [:path, :bloom_filter, :offsets]
 
   @type t :: %__MODULE__{
@@ -25,17 +26,6 @@ defmodule Elasticlunr.SSTable do
   @flush_event :flush_sstable
   @merge_event :merge_sstable
 
-  @spec new(Path.t(), BloomFilter.t(), Offsets.t()) :: t()
-  def new(path, bloom_filter, offsets) do
-    attrs = %{
-      path: path,
-      offsets: offsets,
-      bloom_filter: bloom_filter
-    }
-
-    struct!(__MODULE__, attrs)
-  end
-
   @spec from_path(FileMeta.t()) :: {:ok, t()} | {:error, File.posix()}
   def from_path(%FileMeta{dir: dir, number: number} = file_meta) do
     metadata = %{

lib/elasticlunr/ss_table/offsets.ex

@@ -6,13 +6,10 @@ defmodule Elasticlunr.SSTable.Offsets do
   """
   alias Elasticlunr.Encoding
 
-  defstruct [:entries]
+  defstruct entries: Treex.empty()
 
   @type t :: %__MODULE__{entries: Treex.t()}
 
-  @spec new() :: t()
-  def new, do: struct!(__MODULE__, entries: Treex.empty())
-
   @spec set(t(), binary(), pos_integer()) :: t()
   def set(%__MODULE__{entries: e} = m, key, offset) do
     %{m | entries: Treex.enter(e, key, offset)}
@@ -57,7 +54,7 @@ defmodule Elasticlunr.SSTable.Offsets do
     end
 
     binary
-    |> fun.(fun, new())
+    |> fun.(fun, %__MODULE__{})
     |> then(&%{&1 | entries: Treex.balance(&1.entries)})
   end
 

lib/elasticlunr/wal.ex

@@ -67,7 +67,7 @@ defmodule Elasticlunr.Wal do
       {wal, mem_table, total_size} =
         Enum.reduce(
           wals,
-          {create(dir), MemTable.new(), 0},
+          {create(dir), %MemTable{}, 0},
           fn path, {new_wal, mem_table, total_size} ->
             wal = from_path(path)
             %File.Stat{size: size} = File.stat!(path)

lib/elasticlunr/workflow/open_ss_table.ex

@@ -77,7 +77,7 @@ defmodule Elasticlunr.Workflow.OpenSSTable do
 
   defp close_file(%{fd: fd, path: path, offsets: offsets, bloom_filter: bloom_filter}) do
     with :ok <- File.close(fd) do
-      {:ok, SSTable.new(path, bloom_filter, offsets)}
+      {:ok, %SSTable{path: path, bloom_filter: bloom_filter, offsets: offsets}}
     end
   end
 end

lib/elasticlunr/workflow/write_ss_table.ex

@@ -108,7 +108,7 @@ defmodule Elasticlunr.Workflow.WriteSSTable do
       |> Map.put(:fd, fd)
       |> Map.put(:offset, 0)
       |> Map.put(:file_meta, file_meta)
-      |> Map.put(:offsets, Offsets.new())
+      |> Map.put(:offsets, %Offsets{})
       |> Map.put(:bloom_filter, BloomFilter.new())
       |> then(&{:ok, &1})
     end

test/mem_table_test.exs

@@ -6,7 +6,7 @@ defmodule Elasticlunr.MemTableTest do
 
   setup do
     mem_table =
-      MemTable.new()
+      %MemTable{}
       |> MemTable.set("key", "value", 1)
       |> MemTable.set("key1", "value1", 2)
 

test/server/writer_test.exs

@@ -96,7 +96,7 @@ defmodule Elasticlunr.Server.WriterTest do
   end
 
   test "flushing empty memtable generates no file", %{dir: dir} do
-    assert {:ok, []} = SSTable.flush(MemTable.new(), dir, &Utils.now/0)
+    assert {:ok, []} = SSTable.flush(%MemTable{}, dir, &Utils.now/0)
   end
 
   test "retrieve document from old memtable", %{pid: pid} do

test/ss_table_test.exs

@@ -13,7 +13,7 @@ defmodule Elasticlunr.SSTableTest do
     dir = tmp_dir!()
 
     mem_table =
-      MemTable.new()
+      %MemTable{}
       |> MemTable.set("key", "value", 1)
       |> MemTable.set("key1", "value1", 2)
 
@@ -64,21 +64,21 @@ defmodule Elasticlunr.SSTableTest do
       |> DateTime.to_unix(:microsecond)
 
     mem_table1 =
-      MemTable.new()
+      %MemTable{}
       |> MemTable.set("handbag", "8786", Utils.now())
       |> MemTable.set("handful", "40308", Utils.now())
       |> MemTable.set("handicap", "65995", Utils.now())
       |> MemTable.set("handkerchief", "16324", Utils.now())
 
     mem_table2 =
-      MemTable.new()
+      %MemTable{}
       |> MemTable.set("handcuffs", "2729", Utils.now())
       |> MemTable.set("handful", "42307", Utils.now())
       |> MemTable.set("handicap", "67884", Utils.now())
       |> MemTable.set("handkerchief", "20952", Utils.now())
 
     mem_table3 =
-      MemTable.new()
+      %MemTable{}
       |> MemTable.set("handful", "44662", Utils.now())
       |> MemTable.set("handicap", "70836", Utils.now())
       |> MemTable.set("handiwork", "45521", Utils.now())

test/support/fixture.ex

@@ -27,7 +27,7 @@ defmodule Elasticlunr.Fixture do
   def new_sstable(count \\ 10) do
     0
     |> Range.new(count - 1)
-    |> Enum.reduce(MemTable.new(), fn _, mem_table ->
+    |> Enum.reduce(%MemTable{}, fn _, mem_table ->
       MemTable.set(mem_table, Pokemon.name(), Pokemon.location(), Utils.now())
     end)
     |> SSTable.flush(tmp_dir!(), &Utils.now/0)