Add tests and reference implementation

Author: Chris Doggett

config.json

@@ -45,6 +45,7 @@
     "prime-factors",
     "sieve",
     "wordy",
+    "robot-simulator",
     "atbash-cipher",
     "bank-account",
     "largest-series-product",

exercises/robot-simulator/example.exs

@@ -0,0 +1,72 @@
+defmodule RobotSimulator do
+  defstruct direction: nil, position: nil
+
+  @valid_directions [:north, :east, :south, :west]
+
+  @doc """
+  Create a Robot Simulator given an initial direction and position.
+
+  Valid directions are: `:north`, `:east`, `:south`, `:west`
+
+  ## Examples
+
+  iex> RobotSimulator.create(:north, {0, 0})
+  { :ok, %RobotSimulator{ direction: :north, position: {0, 0} } }
+
+  iex> RobotSimulator.create(:invalid, {0, 0})
+  { :error, "invalid direction" }
+
+  iex> RobotSimulator.create(:north, "invalid")
+  { :error, "invalid position" }
+  """
+  @spec create(direction :: atom, position :: {integer, integer}) :: { atom, any }
+  def create(direction \\ :north, position \\ {0, 0}) do
+    { :ok, %RobotSimulator{} } |> place(position) |> orient(direction)
+  end
+
+  @doc """
+  Simulate the robot's movement given a string of instructions.
+
+  Valid instructions are: "R" (turn right), "L", (turn left), and "A" (advance)
+
+  ## Examples
+
+  iex> { :ok, robot } = RobotSimulator.create
+  iex> robot |> RobotSimulator.simulate("RRLAAR")
+  { :ok, %RobotSimulator{direction: :south, position: {2, 0}} }
+
+  iex> { :ok, robot } = RobotSimulator.create
+  iex> robot |> RobotSimulator.simulate("RRLAUR")
+  { :error, "invalid instruction" }
+  """
+  @spec simulate(robot :: %RobotSimulator{}, instructions :: String.t ) :: { atom, any }
+  def simulate(%RobotSimulator{} = robot, instructions) do
+    instructions |> String.graphemes |> Enum.reduce({ :ok, robot }, &move/2)
+  end
+
+  defp orient({ :ok, %RobotSimulator{} = robot }, direction) when direction in @valid_directions do
+    { :ok, %RobotSimulator{ robot | direction: direction } }
+  end
+  defp orient({ :error, _ } = error, _), do: error
+  defp orient(_, _), do: { :error, "invalid direction" }
+
+  defp place({ :ok, %RobotSimulator{} = robot }, { x, y } = position) when is_integer(x) and is_integer(y) do
+    { :ok, %RobotSimulator{ robot | position: position } }
+  end
+  defp place({ :error, _ } = error, _), do: error
+  defp place(_, _), do: { :error, "invalid position" }
+
+  defp move("R", { :ok, %RobotSimulator{ direction: direction } } = robot), do: robot |> orient(direction |> rotate_right)
+  defp move("L", { :ok, %RobotSimulator{ direction: direction } } = robot), do: robot |> orient(direction |> rotate_left)
+  defp move("A", { :ok, %RobotSimulator{ direction: :north, position: { x, y } } } = robot), do: robot |> place({ x, y + 1 })
+  defp move("A", { :ok, %RobotSimulator{ direction: :east, position: { x, y } } } = robot), do: robot |> place({ x + 1, y })
+  defp move("A", { :ok, %RobotSimulator{ direction: :south, position: { x, y } } } = robot), do: robot |> place({ x, y - 1 })
+  defp move("A", { :ok, %RobotSimulator{ direction: :west, position: { x, y } } } = robot), do: robot |> place({ x - 1, y })
+  defp move(_, { :error, _ } = error), do: error
+  defp move(_, _), do: { :error, "invalid instruction" }
+
+  for [curr, right] <- @valid_directions |> Stream.cycle |> Enum.take(5) |> Enum.chunk(2, 1) do
+    defp rotate_right(unquote(curr)), do: unquote(right)
+    defp rotate_left(unquote(right)), do: unquote(curr)
+  end
+end

exercises/robot-simulator/robot_simulator.exs

@@ -0,0 +1,42 @@
+defmodule RobotSimulator do
+  defstruct direction: nil, position: nil
+
+  @doc """
+  Create a Robot Simulator given an initial direction and position.
+
+  Valid directions are: `:north`, `:east`, `:south`, `:west`
+
+  ## Examples
+
+  iex> RobotSimulator.create(:north, {0, 0})
+  { :ok, %RobotSimulator{ direction: :north, position: {0, 0} } }
+
+  iex> RobotSimulator.create(:invalid, {0, 0})
+  { :error, "invalid direction" }
+
+  iex> RobotSimulator.create(:north, "invalid")
+  { :error, "invalid position" }
+  """
+  @spec create(direction :: atom, position :: {integer, integer}) :: { atom, any }
+  def create(direction, position) do
+  end
+
+  @doc """
+  Simulate the robot's movement given a string of instructions.
+
+  Valid instructions are: "R" (turn right), "L", (turn left), and "A" (advance)
+
+  ## Examples
+
+  iex> { :ok, robot } = RobotSimulator.create
+  iex> robot |> RobotSimulator.simulate("RRLAAR")
+  { :ok, %RobotSimulator{direction: :south, position: {2, 0}} }
+
+  iex> { :ok, robot } = RobotSimulator.create
+  iex> robot |> RobotSimulator.simulate("RRLAUR")
+  { :error, "invalid instruction" }
+  """
+  @spec simulate(robot :: %RobotSimulator{}, instructions :: String.t ) :: { atom, any }
+  def simulate(%RobotSimulator{} = robot, instructions) do
+  end
+end

exercises/robot-simulator/robot_simulator_test.exs

@@ -0,0 +1,77 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("robot_simulator.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule RobotMacros do
+  defmacro __using__(_options) do
+    quote do
+      import unquote(__MODULE__)
+    end
+  end
+
+  defmacro ok_sim(direction, position) do
+    quote do
+      { :ok, %RobotSimulator{ direction: unquote(direction), position: unquote(position) } }
+    end
+  end
+end
+
+defmodule RobotSimulatorTest do
+  use ExUnit.Case
+  use RobotMacros
+
+  test "create has sensible defaults" do
+    assert RobotSimulator.create == ok_sim(:north, {0, 0})
+  end
+
+  @tag :pending
+  test "create works with valid arguments" do
+    assert RobotSimulator.create(:north, {0, 0}) == ok_sim(:north, {0, 0})
+    assert RobotSimulator.create(:south, {-10, 0}) == ok_sim(:south, {-10, 0})
+    assert RobotSimulator.create(:east, {0, 10}) == ok_sim(:east, {0, 10})
+    assert RobotSimulator.create(:west, {100, -100}) == ok_sim(:west, {100, -100})
+  end
+
+  @tag :pending
+  test "create errors if invalid direction given" do
+    assert RobotSimulator.create(:invalid, {0, 0}) == { :error, "invalid direction" }
+    assert RobotSimulator.create(0, {-10, 0}) == { :error, "invalid direction" }
+    assert RobotSimulator.create("east", {0, 10}) == { :error, "invalid direction" }
+  end
+
+  @tag :pending
+  test "create errors if invalid position given" do
+    assert RobotSimulator.create(:north, "invalid") == { :error, "invalid position" }
+    assert RobotSimulator.create(:north, 0 ) == { :error, "invalid position" }
+    assert RobotSimulator.create(:north, [0, 0]) == { :error, "invalid position" }
+    assert RobotSimulator.create(:north, nil) == { :error, "invalid position" }
+  end
+
+  @tag :pending
+  test "simulate single robot" do
+    { :ok, robot } = RobotSimulator.create(:east, { -2, 1 })
+
+    assert RobotSimulator.simulate(robot, "RLAALAL") == ok_sim(:west, { 0, 2 })
+  end
+
+  @tag :pending
+  test "simulate many robots" do
+    { :ok, robot1 } = RobotSimulator.create(:north, { 0, 0 })
+    { :ok, robot2 } = RobotSimulator.create(:east, { 2, -7 })
+    { :ok, robot3 } = RobotSimulator.create(:south, { 8, 4 })
+
+    assert RobotSimulator.simulate(robot1, "LAAARALA") == ok_sim(:west, { -4, 1 })
+    assert RobotSimulator.simulate(robot2, "RRAAAAALA") == ok_sim(:south, { -3, -8 })
+    assert RobotSimulator.simulate(robot3, "LAAARRRALLLL") == ok_sim(:north, { 11, 5 })
+  end
+
+  @tag :pending
+  test "simulate errors on invalid instructions" do
+    { :ok, robot } = RobotSimulator.create
+
+    assert RobotSimulator.simulate(robot, "UUDDLRLRBASTART") == { :error, "invalid instruction" }
+  end
+end