From 62ab2b96884553b613410745d9ce9e1280cfb1a7 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Thu, 13 Jul 2017 14:39:15 -0500 Subject: [PATCH 1/7] Added GenServer Koans --- lib/koans/19_genservers.ex | 141 +++++++++++++++++++++++++++ lib/runner.ex | 1 + test/koans/genservers_koans_test.exs | 21 ++++ 3 files changed, 163 insertions(+) create mode 100644 lib/koans/19_genservers.ex create mode 100644 test/koans/genservers_koans_test.exs diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex new file mode 100644 index 0000000..537e72d --- /dev/null +++ b/lib/koans/19_genservers.ex @@ -0,0 +1,141 @@ +defmodule GenServers do + use Koans + + @intro "GenServers" + + defmodule BicycleLock do + use GenServer + + @init_password 1234 + + ##### + # External API + + def start_link(init_password \\ @init_password) do + # The __MODULE__ macro returns the current module name as an atom + GenServer.start_link(__MODULE__, init_password, name: __MODULE__) + end + + def unlock(password) do + GenServer.call(__MODULE__, {:unlock, password}) + end + + def password_reset(old_password, new_password) do + GenServer.cast(__MODULE__, {:reset, old_password, new_password}) + end + + def owner_info do + GenServer.call(__MODULE__, :get_owner_info) + end + + #### + # GenServer implementation + + def init(args) do + {:ok, args && args || @init_password} + end + + def handle_call(:get_password, _from, current_password) do + {:reply, current_password, current_password} + end + + def handle_call(:get_bike_brand, _from, current_state) do + {:reply, "Tribe Bicycle Co.", current_state} + end + + def handle_call(:get_bike_name, _from, current_state) do + {:reply, "CRMO Series", current_state} + end + + def handle_call(:get_owner_info, _from, current_state) do + {:reply, {:ok, "Argh...Jack Sparrow's password is: #{current_state}"}, current_state} + end + + def handle_call(:get_multi, _from, current_state) do + {:reply, {:ok, ["this", "is", "sparta"]}, current_state} + end + + def handle_call(:name_check, _from, current_state) do + {:reply, "Congrats! Your process was successfully named.", current_state} + end + + def handle_call({:unlock, password}, _from, current_password) do + case password do + password when password === current_password -> + {:reply, {:ok, "Bicycle unlocked!"}, current_password} + _ -> + {:reply, {:error, "Incorrect password!"}, current_password} + end + end + + def handle_cast({:reset, old_password, new_password}, current_password) do + case old_password do + old_password when old_password == current_password -> + {:noreply, new_password} + _ -> + {:noreply, current_password} + end + end + end + + koan "Servers that are created and initialized successfully returns a tuple that holds the PID of the server" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + assert is_pid(pid) == ___ + end + + koan "When starting a GenServer you can set it's initial state" do + {:ok, pid} = GenServer.start_link(BicycleLock, "Hey Arnold!") + assert GenServer.call(pid, :get_password) == ___ + end + + koan "The handle_call callback is synchronous so it will block until a reply is received" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + assert GenServer.call(pid, :get_password) == ___ + end + + koan "A server can support multiple actions by implementing multiple handle_call functions" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + assert GenServer.call(pid, :get_bike_brand) == ___ + assert GenServer.call(pid, :get_bike_name) == ___ + end + + koan "A handler can return multiple values" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + {:ok, multi_values} = GenServer.call(pid, :get_multi) + assert multi_values == ___ + end + + koan "The handle_cast callback handles asynchronous messages" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + GenServer.cast(pid, {:reset, 1234, "Hello"}) + assert GenServer.call(pid, :get_password) == ___ + end + + koan "Handlers can also return error responses" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil) + assert GenServer.call(pid, {:unlock, 2017}) == ___ + end + + koan "Referencing processes by their PID gets old pretty quickly, so let's name them" do + {:ok, pid} = GenServer.start_link(BicycleLock, nil, name: :bike_lock) + assert GenServer.call(:bike_lock, :name_check) == ___ + end + + koan "Our server works but it's pretty ugly to use; so lets use a cleaner interface" do + BicycleLock.start_link + assert BicycleLock.unlock(1234) == ___ + end + + koan "Let's use the remaining functions in the external API" do + BicycleLock.start_link(31337) + {_, response} = BicycleLock.unlock(31337) + assert response == ___ + + BicycleLock.password_reset(31337, "Elixir") + {_, response} = BicycleLock.unlock(31337) + assert response == ___ + + {_, response} = BicycleLock.owner_info + assert response == ___ + end +end \ No newline at end of file diff --git a/lib/runner.ex b/lib/runner.ex index be1d0ae..5f1d98b 100644 --- a/lib/runner.ex +++ b/lib/runner.ex @@ -18,6 +18,7 @@ defmodule Runner do Tasks, Agents, Protocols, + GenServers, ] def koan?(koan), do: Enum.member?(@modules, koan) diff --git a/test/koans/genservers_koans_test.exs b/test/koans/genservers_koans_test.exs new file mode 100644 index 0000000..7175ea6 --- /dev/null +++ b/test/koans/genservers_koans_test.exs @@ -0,0 +1,21 @@ +defmodule GenServersTests do + use ExUnit.Case + import TestHarness + + test "GenServers" do + answers = [ + true, + "Hey Arnold!", + 1234, + {:multiple, ["Tribe Bicycle Co.", "CRMO Series"]}, + ["this", "is", "sparta"], + "Hello", + {:error, "Incorrect password!"}, + "Congrats! Your process was successfully named.", + {:ok, "Bicycle unlocked!"}, + {:multiple, ["Bicycle unlocked!", "Incorrect password!", "Argh...Jack Sparrow's password is: Elixir"]}, + ] + + test_all(GenServers, answers) + end +end From 78d0181ccebf53c7ff1a6cd27c0bf33502d1a3a5 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Fri, 14 Jul 2017 15:51:12 -0500 Subject: [PATCH 2/7] Updated 19_genservers.ex w/code review suggestions and updated genservers_koans_test answer values --- lib/koans/19_genservers.ex | 46 +++++++++++++--------------- test/koans/genservers_koans_test.exs | 4 +-- 2 files changed, 23 insertions(+), 27 deletions(-) diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex index 537e72d..ab635bc 100644 --- a/lib/koans/19_genservers.ex +++ b/lib/koans/19_genservers.ex @@ -6,12 +6,10 @@ defmodule GenServers do defmodule BicycleLock do use GenServer - @init_password 1234 - ##### # External API - def start_link(init_password \\ @init_password) do + def start_server(init_password) do # The __MODULE__ macro returns the current module name as an atom GenServer.start_link(__MODULE__, init_password, name: __MODULE__) end @@ -20,8 +18,8 @@ defmodule GenServers do GenServer.call(__MODULE__, {:unlock, password}) end - def password_reset(old_password, new_password) do - GenServer.cast(__MODULE__, {:reset, old_password, new_password}) + def change_password(old_password, new_password) do + GenServer.cast(__MODULE__, {:change_password, old_password, new_password}) end def owner_info do @@ -30,10 +28,6 @@ defmodule GenServers do #### # GenServer implementation - - def init(args) do - {:ok, args && args || @init_password} - end def handle_call(:get_password, _from, current_password) do {:reply, current_password, current_password} @@ -52,7 +46,7 @@ defmodule GenServers do end def handle_call(:get_multi, _from, current_state) do - {:reply, {:ok, ["this", "is", "sparta"]}, current_state} + {:reply, {:ok, ["this", "is", "sparta"], 369, :hello_world}, current_state} end def handle_call(:name_check, _from, current_state) do @@ -68,7 +62,7 @@ defmodule GenServers do end end - def handle_cast({:reset, old_password, new_password}, current_password) do + def handle_cast({:change_password, old_password, new_password}, current_password) do case old_password do old_password when old_password == current_password -> {:noreply, new_password} @@ -89,7 +83,7 @@ defmodule GenServers do end koan "The handle_call callback is synchronous so it will block until a reply is received" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) + {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") assert GenServer.call(pid, :get_password) == ___ end @@ -99,40 +93,42 @@ defmodule GenServers do assert GenServer.call(pid, :get_bike_name) == ___ end - koan "A handler can return multiple values" do + koan "A handler can return multiple values and of different types" do {:ok, pid} = GenServer.start_link(BicycleLock, nil) - {:ok, multi_values} = GenServer.call(pid, :get_multi) - assert multi_values == ___ + {:ok, string_list, num, atom} = GenServer.call(pid, :get_multi) + assert string_list == ___ + assert num == ___ + assert atom == ___ end koan "The handle_cast callback handles asynchronous messages" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) - GenServer.cast(pid, {:reset, 1234, "Hello"}) + {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") + GenServer.cast(pid, {:change_password, "3kr3t!", "Hello"}) assert GenServer.call(pid, :get_password) == ___ end koan "Handlers can also return error responses" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) + {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") assert GenServer.call(pid, {:unlock, 2017}) == ___ end koan "Referencing processes by their PID gets old pretty quickly, so let's name them" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil, name: :bike_lock) + {:ok, _} = GenServer.start_link(BicycleLock, nil, name: :bike_lock) assert GenServer.call(:bike_lock, :name_check) == ___ end koan "Our server works but it's pretty ugly to use; so lets use a cleaner interface" do - BicycleLock.start_link - assert BicycleLock.unlock(1234) == ___ + BicycleLock.start_server("EL!73") + assert BicycleLock.unlock("EL!73") == ___ end koan "Let's use the remaining functions in the external API" do - BicycleLock.start_link(31337) - {_, response} = BicycleLock.unlock(31337) + BicycleLock.start_server("EL!73") + {_, response} = BicycleLock.unlock("EL!73") assert response == ___ - BicycleLock.password_reset(31337, "Elixir") - {_, response} = BicycleLock.unlock(31337) + BicycleLock.change_password("EL!73", "Elixir") + {_, response} = BicycleLock.unlock("EL!73") assert response == ___ {_, response} = BicycleLock.owner_info diff --git a/test/koans/genservers_koans_test.exs b/test/koans/genservers_koans_test.exs index 7175ea6..55c06e0 100644 --- a/test/koans/genservers_koans_test.exs +++ b/test/koans/genservers_koans_test.exs @@ -6,9 +6,9 @@ defmodule GenServersTests do answers = [ true, "Hey Arnold!", - 1234, + "3kr3t!", {:multiple, ["Tribe Bicycle Co.", "CRMO Series"]}, - ["this", "is", "sparta"], + {:multiple, [["this", "is", "sparta"], 369, :hello_world]}, "Hello", {:error, "Incorrect password!"}, "Congrats! Your process was successfully named.", From cb98ca1c522bcb0ab416c004361c087ddedf8c97 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Sat, 15 Jul 2017 00:49:52 -0500 Subject: [PATCH 3/7] Renamed start_server/1 to start_link/1 and updated a password. --- lib/koans/19_genservers.ex | 8 ++++---- test/koans/genservers_koans_test.exs | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex index ab635bc..4e10321 100644 --- a/lib/koans/19_genservers.ex +++ b/lib/koans/19_genservers.ex @@ -9,7 +9,7 @@ defmodule GenServers do ##### # External API - def start_server(init_password) do + def start_link(init_password) do # The __MODULE__ macro returns the current module name as an atom GenServer.start_link(__MODULE__, init_password, name: __MODULE__) end @@ -78,7 +78,7 @@ defmodule GenServers do end koan "When starting a GenServer you can set it's initial state" do - {:ok, pid} = GenServer.start_link(BicycleLock, "Hey Arnold!") + {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") assert GenServer.call(pid, :get_password) == ___ end @@ -118,12 +118,12 @@ defmodule GenServers do end koan "Our server works but it's pretty ugly to use; so lets use a cleaner interface" do - BicycleLock.start_server("EL!73") + BicycleLock.start_link("EL!73") assert BicycleLock.unlock("EL!73") == ___ end koan "Let's use the remaining functions in the external API" do - BicycleLock.start_server("EL!73") + BicycleLock.start_link("EL!73") {_, response} = BicycleLock.unlock("EL!73") assert response == ___ diff --git a/test/koans/genservers_koans_test.exs b/test/koans/genservers_koans_test.exs index 55c06e0..9a61ca6 100644 --- a/test/koans/genservers_koans_test.exs +++ b/test/koans/genservers_koans_test.exs @@ -5,7 +5,7 @@ defmodule GenServersTests do test "GenServers" do answers = [ true, - "Hey Arnold!", + "3kr3t!", "3kr3t!", {:multiple, ["Tribe Bicycle Co.", "CRMO Series"]}, {:multiple, [["this", "is", "sparta"], 369, :hello_world]}, From 8495a4871712f4ccac46ee9e7e1af7d37ae1583b Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Sat, 15 Jul 2017 01:33:16 -0500 Subject: [PATCH 4/7] Changed GenServer from BicycleLock to Laptop so examples will flow better --- lib/koans/19_genservers.ex | 68 ++++++++++++++-------------- test/koans/genservers_koans_test.exs | 8 ++-- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex index 4e10321..6eeb53d 100644 --- a/lib/koans/19_genservers.ex +++ b/lib/koans/19_genservers.ex @@ -3,7 +3,7 @@ defmodule GenServers do @intro "GenServers" - defmodule BicycleLock do + defmodule Laptop do use GenServer ##### @@ -22,8 +22,8 @@ defmodule GenServers do GenServer.cast(__MODULE__, {:change_password, old_password, new_password}) end - def owner_info do - GenServer.call(__MODULE__, :get_owner_info) + def owner_name do + GenServer.call(__MODULE__, :get_owner_name) end #### @@ -33,20 +33,20 @@ defmodule GenServers do {:reply, current_password, current_password} end - def handle_call(:get_bike_brand, _from, current_state) do - {:reply, "Tribe Bicycle Co.", current_state} + def handle_call(:get_manufacturer, _from, current_state) do + {:reply, "Apple Inc.", current_state} end - def handle_call(:get_bike_name, _from, current_state) do - {:reply, "CRMO Series", current_state} + def handle_call(:get_type, _from, current_state) do + {:reply, "MacBook Pro", current_state} end - def handle_call(:get_owner_info, _from, current_state) do - {:reply, {:ok, "Argh...Jack Sparrow's password is: #{current_state}"}, current_state} + def handle_call(:get_owner_name, _from, current_state) do + {:reply, {:ok, "Jack Sparrow"}, current_state} end - def handle_call(:get_multi, _from, current_state) do - {:reply, {:ok, ["this", "is", "sparta"], 369, :hello_world}, current_state} + def handle_call(:get_specs, _from, current_state) do + {:reply, {:ok, ["2.9 GHz Intel Core i5"], 8192, :intel_iris_graphics}, current_state} end def handle_call(:name_check, _from, current_state) do @@ -56,7 +56,7 @@ defmodule GenServers do def handle_call({:unlock, password}, _from, current_password) do case password do password when password === current_password -> - {:reply, {:ok, "Bicycle unlocked!"}, current_password} + {:reply, {:ok, "Laptop unlocked!"}, current_password} _ -> {:reply, {:error, "Incorrect password!"}, current_password} end @@ -73,65 +73,65 @@ defmodule GenServers do end koan "Servers that are created and initialized successfully returns a tuple that holds the PID of the server" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") assert is_pid(pid) == ___ end koan "When starting a GenServer you can set it's initial state" do - {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") assert GenServer.call(pid, :get_password) == ___ end koan "The handle_call callback is synchronous so it will block until a reply is received" do - {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") assert GenServer.call(pid, :get_password) == ___ end koan "A server can support multiple actions by implementing multiple handle_call functions" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) - assert GenServer.call(pid, :get_bike_brand) == ___ - assert GenServer.call(pid, :get_bike_name) == ___ + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") + assert GenServer.call(pid, :get_manufacturer) == ___ + assert GenServer.call(pid, :get_type) == ___ end koan "A handler can return multiple values and of different types" do - {:ok, pid} = GenServer.start_link(BicycleLock, nil) - {:ok, string_list, num, atom} = GenServer.call(pid, :get_multi) - assert string_list == ___ - assert num == ___ - assert atom == ___ + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") + {:ok, processor, memory, graphics} = GenServer.call(pid, :get_specs) + assert processor == ___ + assert memory == ___ + assert graphics == ___ end koan "The handle_cast callback handles asynchronous messages" do - {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") GenServer.cast(pid, {:change_password, "3kr3t!", "Hello"}) assert GenServer.call(pid, :get_password) == ___ end koan "Handlers can also return error responses" do - {:ok, pid} = GenServer.start_link(BicycleLock, "3kr3t!") + {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") assert GenServer.call(pid, {:unlock, 2017}) == ___ end koan "Referencing processes by their PID gets old pretty quickly, so let's name them" do - {:ok, _} = GenServer.start_link(BicycleLock, nil, name: :bike_lock) - assert GenServer.call(:bike_lock, :name_check) == ___ + {:ok, _} = GenServer.start_link(Laptop, "3kr3t!", name: :macbook) + assert GenServer.call(:macbook, :name_check) == ___ end koan "Our server works but it's pretty ugly to use; so lets use a cleaner interface" do - BicycleLock.start_link("EL!73") - assert BicycleLock.unlock("EL!73") == ___ + Laptop.start_link("EL!73") + assert Laptop.unlock("EL!73") == ___ end koan "Let's use the remaining functions in the external API" do - BicycleLock.start_link("EL!73") - {_, response} = BicycleLock.unlock("EL!73") + Laptop.start_link("EL!73") + {_, response} = Laptop.unlock("EL!73") assert response == ___ - BicycleLock.change_password("EL!73", "Elixir") - {_, response} = BicycleLock.unlock("EL!73") + Laptop.change_password("EL!73", "Elixir") + {_, response} = Laptop.unlock("EL!73") assert response == ___ - {_, response} = BicycleLock.owner_info + {_, response} = Laptop.owner_name assert response == ___ end end \ No newline at end of file diff --git a/test/koans/genservers_koans_test.exs b/test/koans/genservers_koans_test.exs index 9a61ca6..908c080 100644 --- a/test/koans/genservers_koans_test.exs +++ b/test/koans/genservers_koans_test.exs @@ -7,13 +7,13 @@ defmodule GenServersTests do true, "3kr3t!", "3kr3t!", - {:multiple, ["Tribe Bicycle Co.", "CRMO Series"]}, - {:multiple, [["this", "is", "sparta"], 369, :hello_world]}, + {:multiple, ["Apple Inc.", "MacBook Pro"]}, + {:multiple, [["2.9 GHz Intel Core i5"], 8192, :intel_iris_graphics]}, "Hello", {:error, "Incorrect password!"}, "Congrats! Your process was successfully named.", - {:ok, "Bicycle unlocked!"}, - {:multiple, ["Bicycle unlocked!", "Incorrect password!", "Argh...Jack Sparrow's password is: Elixir"]}, + {:ok, "Laptop unlocked!"}, + {:multiple, ["Laptop unlocked!", "Incorrect password!", "Jack Sparrow"]}, ] test_all(GenServers, answers) From c5a332a2f85591cc4e6f4dd9e34a9871d447a1ab Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Sat, 15 Jul 2017 01:45:33 -0500 Subject: [PATCH 5/7] Added remaining handlers to the External API --- lib/koans/19_genservers.ex | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex index 6eeb53d..e9a1bb7 100644 --- a/lib/koans/19_genservers.ex +++ b/lib/koans/19_genservers.ex @@ -18,14 +18,30 @@ defmodule GenServers do GenServer.call(__MODULE__, {:unlock, password}) end - def change_password(old_password, new_password) do - GenServer.cast(__MODULE__, {:change_password, old_password, new_password}) - end - def owner_name do GenServer.call(__MODULE__, :get_owner_name) end + def manufacturer do + GenServer.call(__MODULE__, :get_manufacturer) + end + + def laptop_type do + GenServer.call(__MODULE__, :get_type) + end + + def retrieve_password do + GenServer.call(__MODULE__, :get_password) + end + + def laptop_specs do + GenServer.call(__MODULE__, :get_specs) + end + + def change_password(old_password, new_password) do + GenServer.cast(__MODULE__, {:change_password, old_password, new_password}) + end + #### # GenServer implementation From 3f1eb8f3975d8710cede1705f06815be473f2931 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Mon, 17 Jul 2017 21:15:50 -0500 Subject: [PATCH 6/7] Updated password strings --- lib/koans/19_genservers.ex | 4 ++-- test/koans/genservers_koans_test.exs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/koans/19_genservers.ex b/lib/koans/19_genservers.ex index e9a1bb7..8ad4589 100644 --- a/lib/koans/19_genservers.ex +++ b/lib/koans/19_genservers.ex @@ -119,13 +119,13 @@ defmodule GenServers do koan "The handle_cast callback handles asynchronous messages" do {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") - GenServer.cast(pid, {:change_password, "3kr3t!", "Hello"}) + GenServer.cast(pid, {:change_password, "3kr3t!", "73x7!n9"}) assert GenServer.call(pid, :get_password) == ___ end koan "Handlers can also return error responses" do {:ok, pid} = GenServer.start_link(Laptop, "3kr3t!") - assert GenServer.call(pid, {:unlock, 2017}) == ___ + assert GenServer.call(pid, {:unlock, "81u3pr!n7"}) == ___ end koan "Referencing processes by their PID gets old pretty quickly, so let's name them" do diff --git a/test/koans/genservers_koans_test.exs b/test/koans/genservers_koans_test.exs index 908c080..b8cae92 100644 --- a/test/koans/genservers_koans_test.exs +++ b/test/koans/genservers_koans_test.exs @@ -9,7 +9,7 @@ defmodule GenServersTests do "3kr3t!", {:multiple, ["Apple Inc.", "MacBook Pro"]}, {:multiple, [["2.9 GHz Intel Core i5"], 8192, :intel_iris_graphics]}, - "Hello", + "73x7!n9", {:error, "Incorrect password!"}, "Congrats! Your process was successfully named.", {:ok, "Laptop unlocked!"}, From 33d0892c7ad4597ff49d5ebfa5e8b7f7b05f6531 Mon Sep 17 00:00:00 2001 From: Eric Anderson Date: Wed, 19 Jul 2017 19:28:57 -0500 Subject: [PATCH 7/7] GenServers swapped lesson position with Protocols --- lib/koans/{19_genservers.ex => 18_genservers.ex} | 0 lib/koans/{18_protocols.ex => 19_protocols.ex} | 0 lib/runner.ex | 2 +- 3 files changed, 1 insertion(+), 1 deletion(-) rename lib/koans/{19_genservers.ex => 18_genservers.ex} (100%) rename lib/koans/{18_protocols.ex => 19_protocols.ex} (100%) diff --git a/lib/koans/19_genservers.ex b/lib/koans/18_genservers.ex similarity index 100% rename from lib/koans/19_genservers.ex rename to lib/koans/18_genservers.ex diff --git a/lib/koans/18_protocols.ex b/lib/koans/19_protocols.ex similarity index 100% rename from lib/koans/18_protocols.ex rename to lib/koans/19_protocols.ex diff --git a/lib/runner.ex b/lib/runner.ex index 5f1d98b..0c7664c 100644 --- a/lib/runner.ex +++ b/lib/runner.ex @@ -17,8 +17,8 @@ defmodule Runner do Processes, Tasks, Agents, - Protocols, GenServers, + Protocols, ] def koan?(koan), do: Enum.member?(@modules, koan)