Repo backup

Author: technusm1

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,26 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+toy_robot-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/

.idea/.gitignore

@@ -0,0 +1,21 @@
+# ToyRobot
+
+**TODO: Add description**
+
+## Installation
+
+If [available in Hex](https://hex.pm/docs/publish), the package can be installed
+by adding `toy_robot` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:toy_robot, "~> 0.1.0"}
+  ]
+end
+```
+
+Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
+and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
+be found at <https://hexdocs.pm/toy_robot>.
+

.idea/libraries/benchfella.xml

@@ -0,0 +1,18 @@
+defmodule ToyRobot do
+  @moduledoc """
+  Documentation for `ToyRobot`.
+  """
+
+  @doc """
+  Hello world.
+
+  ## Examples
+
+      iex> ToyRobot.hello()
+      :world
+
+  """
+  def hello do
+    :world
+  end
+end

.idea/libraries/earmark.xml

@@ -0,0 +1,11 @@
+defmodule ToyRobot.Application do
+  use Application
+
+  def start(_type, _args) do
+    children = [
+      ToyRobot.Game.PlayerSupervisor
+    ]
+    opts = [strategy: :one_for_one, name: ToyRobot.Supervisor]
+    Supervisor.start_link(children, opts)
+  end
+end

.idea/libraries/ex_doc.xml

@@ -0,0 +1,15 @@
+defmodule ToyRobot.CLI do
+  def main([file_name]) do
+    if File.exists?(file_name) do
+      file_name
+      |> File.stream!()
+      |> Enum.map(&String.trim/1)
+      |> ToyRobot.CommandInterpreter.interpret()
+      |> ToyRobot.CommandRunner.run()
+    else
+      IO.puts "The file #{file_name} does not exist"
+    end
+  end
+
+  def main(_), do: IO.puts("Usage: toy_robot commands.txt")
+end

.idea/libraries/uuid.xml

@@ -0,0 +1,52 @@
+defmodule ToyRobot.CommandInterpreter do
+  @doc """
+  Interprets commands from a commands list and prepares them for execution.
+
+  ## Examples
+      iex> alias ToyRobot.CommandInterpreter
+      ToyRobot.CommandInterpreter
+      iex> commands = ["PLACE 1,2,NORTH", "MOVE", "LEFT", "RIGHT", "REPORT", "SPIN", "EXTERMINATE", "PLACE 1, 2, NORTH", "mOvE"]
+      ["PLACE 1,2,NORTH", "MOVE", "LEFT", "RIGHT", "REPORT", "SPIN", "EXTERMINATE", "PLACE 1, 2, NORTH", "mOvE"]
+      iex> commands |> CommandInterpreter.interpret
+      [
+        {:place, %{x: 1, y: 2, f: :north}},
+        :move,
+        :turn_left,
+        :turn_right,
+        :report,
+        {:invalid, "SPIN"},
+        {:invalid, "EXTERMINATE"},
+        {:invalid, "PLACE 1, 2, NORTH"},
+        {:invalid, "mOvE"}
+      ]
+  """
+  def interpret(commands_list) do
+    commands_list |> Enum.map(&do_interpret/1)
+  end
+
+  defp do_interpret(("PLACE" <> _rest) = command) do
+    format = ~r/\APLACE (\d+),(\d+),(NORTH|EAST|SOUTH|WEST)\z/
+    case Regex.run(format, command) do
+      [_command, x, y, f] -> {
+        :place,
+        %{
+          x: String.to_integer(x),
+          y: String.to_integer(y),
+          f: f |> String.downcase |> String.to_atom
+        }
+      }
+      nil -> {:invalid, command}
+    end
+
+  end
+
+  defp do_interpret(command) do
+    case command do
+      "MOVE" -> :move
+      "LEFT" -> :turn_left
+      "RIGHT" -> :turn_right
+      "REPORT" -> :report
+      invalid_command -> {:invalid, invalid_command}
+    end
+  end
+end

.idea/misc.xml

@@ -0,0 +1,47 @@
+defmodule ToyRobot.CommandRunner do
+  alias ToyRobot.SimulationDriver
+  alias ToyRobot.Table
+
+  def run([{:place, placement} | rest]) do
+    table = %Table{north_boundary: 4, east_boundary: 4}
+    case SimulationDriver.place(table, placement) do
+      {:ok, simulation} -> run(rest, simulation)
+      {:error, :invalid_placement} -> run(rest)
+    end
+  end
+
+  def run([]), do: nil # Empty case
+  def run([_command | rest]), do: run(rest) # Consumes everything until the first valid place command is encountered
+
+  defp run([:move | rest], simulation) do
+    case simulation |> SimulationDriver.move do
+      {:ok, new_simulation} -> run(rest, new_simulation)
+      {:error, :at_table_boundary} -> run(rest, simulation)
+    end
+  end
+
+  defp run([:turn_left | rest], simulation) do
+    {:ok, simulation} = simulation |> SimulationDriver.turn_left
+    run(rest, simulation)
+  end
+
+  defp run([:turn_right | rest], simulation) do
+    {:ok, simulation} = simulation |> SimulationDriver.turn_right
+    run(rest, simulation)
+  end
+
+  defp run([:report | rest], simulation) do
+    %{x: x, y: y, f: f} = SimulationDriver.report(simulation)
+    facing = f |> Atom.to_string |> String.upcase
+    IO.puts("The robot is at (#{x}, #{y}) and is facing #{facing}")
+    run(rest, simulation)
+  end
+
+  defp run([{:invalid, _} | rest], simulation) do
+    run(rest, simulation)
+  end
+
+  defp run([], simulation) do
+    simulation
+  end
+end

.idea/modules.xml

@@ -0,0 +1,51 @@
+defmodule ToyRobot.Game do
+  alias ToyRobot.Game.Server
+
+  def start([north_boundary: north_boundary, east_boundary: east_boundary]) do
+    Server.start_link([north_boundary: north_boundary, east_boundary: east_boundary])
+  end
+
+  def place(game, position, name) do
+    # This is to see if the position is within bounds, so no data races should be occuring with valid_position alone.
+    # But if we use position_available, a data race can occur if place(game, position, name) is called from multiple processes,
+    # i.e. if we try to place multiple players in the game, its possible we get :ok for both valid_position and position_available
+    # Eventually, both processes will call :place, which could potentially put multiple players on same coordinates (even though it is serialized).
+    with :ok <- game |> valid_position(position),
+         :ok <- game |> position_available(position) do
+      GenServer.call(game, {:place, position, name})
+    else
+      error -> error
+    end
+  end
+
+  def move(game, name) do
+    # One guy stands on (0, 1, :east). Other stands on(0, 3, :west)
+    # next_position should return (0, 2) for both and that position can be available for both,
+    # since move(game, name) is not serialized call.
+    next_pos = next_position(game, name)
+    game
+    |> position_available(next_pos)
+    |> case do
+      :ok -> GenServer.call(game, {:move, name})
+      error -> error
+    end
+  end
+
+  defp next_position(game, name) do
+    GenServer.call(game, {:next_position, name})
+  end
+
+  defp position_available(game, position) do
+    GenServer.call(game, {:position_available, position})
+  end
+
+  defp valid_position(game, position), do: GenServer.call(game, {:valid_position, position})
+
+  def player_count(game) do
+    GenServer.call(game, :player_count)
+  end
+
+  def report(game, name) do
+    GenServer.call(game, {:report, name})
+  end
+end

README.md

@@ -0,0 +1,64 @@
+defmodule ToyRobot.Game.Player do
+  use GenServer
+  alias ToyRobot.Game.Players
+  alias ToyRobot.SimulationDriver
+
+  def start_link([registry_id: registry_id, table: table, robot: robot, name: name]) do
+    name = process_name(registry_id, name)
+    GenServer.start_link(__MODULE__, [registry_id: registry_id, table: table, robot: robot, name: name], name: name)
+  end
+
+  def process_name(registry_id, name), do: {:via, Registry, {registry_id, name}}
+
+  def report(player_pid) do
+    GenServer.call(player_pid, :report)
+  end
+
+  def move(player_pid) do
+    GenServer.cast(player_pid, :move)
+  end
+
+  def next_position(player_pid) do
+    GenServer.call(player_pid, :next_position)
+  end
+
+  @impl GenServer
+  def init([registry_id: registry_id, table: table, robot: robot, name: name]) do
+    robot =
+      registry_id
+      |> Players.all
+      |> Players.except(name)
+      |> Players.positions
+      |> Players.change_position_if_occupied(table, robot)
+    simulation = %SimulationDriver{
+      robot: robot,
+      table: table
+    }
+    {:ok, simulation}
+  end
+
+  def init([table: table, robot: robot]) do
+    simulation = %SimulationDriver{
+      robot: robot,
+      table: table
+    }
+    {:ok, simulation}
+  end
+
+  @impl GenServer
+  def handle_call(:report, _from, simulation) do
+    {:reply, simulation |> SimulationDriver.report, simulation}
+  end
+
+  @impl GenServer
+  def handle_call(:next_position, _from, simulation) do
+    next_position = simulation |> SimulationDriver.next_position()
+    {:reply, next_position, simulation}
+  end
+
+  @impl GenServer
+  def handle_cast(:move, simulation) do
+    {:ok, new_simulation} = simulation |> SimulationDriver.move
+    {:noreply, new_simulation}
+  end
+end