refactor server

clear function not working

README.md

@@ -58,7 +58,7 @@
 
 28. pragstudio-elixir-24-stateful-server-3 - [Stateful Server 3](https://github.com/skedaddl3/elixir-pragstudio/commit/f578de42d114949943d687a9d3e3b07df2307780)
 
-29. pragstudio-elixir-24-stateful-server-4 - [Stateful Server 4]()
+29. pragstudio-elixir-24-stateful-server-4 - [Stateful Server 4](https://github.com/skedaddl3/elixir-pragstudio/commit/e32ac32727280835725a155c6c9da6c44ba2ee46)
 
 30. pragstudio-elixir-25-refactor-server - [Refactor Server]()
 

lib/pledge_server.ex

@@ -1,62 +1,85 @@
-defmodule Servy.PledgeServer do
-  @name :pledge_server
-
-  def start do
-    IO.puts("Starting the pledge server...")
-    pid = spawn(__MODULE__, :listen_loop, [[]])
-    Process.register(pid, @name)
+defmodule Servy.GenericServer do
+  def start(callback_module, initial_state, name) do
+    pid = spawn(__MODULE__, :listen_loop, [initial_state, callback_module])
+    Process.register(pid, name)
     pid
   end
 
-  def create_pledge(name, amount) do
-    send(@name, {self(), :create_pledge, name, amount})
+  def call(pid, message) do
+    send(pid, {:call, self(), message})
 
     receive do
-      {:response, status} -> status
+      {:response, response} -> response
     end
   end
 
-  # Server
+  def cast(pid, message) do
+    send(pid, {:cast, message})
+  end
 
-  def listen_loop(state) do
+  def listen_loop(state, callback_module) do
     receive do
-      {sender, :create_pledge, name, amount} ->
-        {:ok, id} = send_pledge_to_service(name, amount)
-        most_recent_pledges = Enum.take(state, 2)
-        new_state = [{name, amount} | most_recent_pledges]
-        send(sender, {:response, id})
-        listen_loop(new_state)
-
-      {sender, :recent_pledges} ->
-        send(sender, {:response, state})
-        listen_loop(state)
-
-      {sender, :total_pledged} ->
-        total = Enum.map(state, &elem(&1, 1)) |> Enum.sum()
-        send(sender, {:response, total})
-        listen_loop(state)
+      {:call, sender, message} when is_pid(sender) ->
+        {response, new_state} = callback_module.handle_call(message, state)
+        send(sender, {:response, response})
+        listen_loop(new_state, callback_module)
+
+      {:cast, message} ->
+        new_state = callback_module.handle_cast(message, state)
+        listen_loop(new_state, callback_module)
 
       unexpected ->
         IO.puts("Unexpected messaged: #{inspect(unexpected)}")
-        listen_loop(state)
+        listen_loop(state, callback_module)
     end
   end
+end
 
-  def recent_pledges do
-    send(@name, {self(), :recent_pledges})
+defmodule Servy.PledgeServer do
+  @name :pledge_server
+  alias Servy.GenericServer
 
-    # blocking
-    receive do
-      {:response, pledges} -> IO.inspect(pledges)
-    end
+  def start do
+    IO.puts("Starting the pledge server...")
+    GenericServer.start(__MODULE__, [], @name)
+  end
+
+  def create_pledge(name, amount) do
+    GenericServer.call(@name, {:create_pledge, name, amount})
+  end
+
+  def recent_pledges do
+    GenericServer.call(@name, :recent_pledges)
   end
 
   def total_pledged do
-    send(@name, {self(), :total_pledged})
+    GenericServer.call(@name, :total_pledged)
+  end
 
-    receive do
-      {:response, total} -> total
-    end
+  def clear do
+    GenericServer.cast(@name, :clear)
+  end
+
+  # Server Callbacks
+
+  def handle_cast(:clear, _state) do
+    []
+  end
+
+  def handle_call(:total_pledged, state) do
+    total = Enum.map(state, &elem(&1, 1)) |> Enum.sum()
+    {total, state}
+  end
+
+  def handle_call(:recent_pledges, state) do
+    {state, state}
+  end
+
+  def handle_call({:create_pledge, name, amount}, state) do
+    {:ok, id} = send_pledge_to_service(name, amount)
+    most_recent_pledges = Enum.take(state, 2)
+    new_state = [{name, amount} | most_recent_pledges]
+    {id, new_state}
   end
 
   defp send_pledge_to_service(_name, _amount) do
@@ -80,4 +103,6 @@ IO.inspect(PledgeServer.create_pledge("grace", 50))
 IO.inspect(PledgeServer.recent_pledges())
 IO.inspect(PledgeServer.total_pledged())
 
+PledgeServer.clear()
+
 IO.inspect(Process.info(pid, :messages))