starting state with tests

Author: SophieDeBenedetto

assets/js/socket.js

@@ -1,9 +1,14 @@
 import { Socket, Presence } from 'phoenix'
+import updateUsers  from './users'
+
 const socket = new Socket('/socket', {params: {username: window.pointingParty.username}})
 socket.connect()
 
 let driving = false;
 
+// connect to Presence here
+// set up your syncDiff function using updateUsers as a callback
+
 const startButton = document.querySelector('.start-button')
 startButton.addEventListener('click', e => {
   driving = true;

assets/js/users.js

@@ -1,44 +1,33 @@
 import { forEach, isNil, map, none } from 'ramda'
 
+const usersElem = document.querySelector('.users')
+
 const updateUsers = presence => {
-  const usersElem = document.querySelector('.users')
   usersElem.innerHTML = ''
 
-  const users = presence.list(listBy)
-  forEach(addUser(usersElem))(users)
-
-  if (allHaveEstimated(users)) {
-    forEach(showPoints(usersElem))(users)
+  // let user = list presences with the help of a listBy function
+  for(let i = 0; i < users.length; i++) {
+    addUser(users[i])
   }
+
+  // implement a feature that
+  // 1. checks if all fo the users in the present list have voted, i.e. have points values that are not nil
+  // 2. displays the user's vote next to their name if so
 }
 
-const listBy = (username, { metas: [{ points }, ..._rest]}) => ({ username, points })
+const listBy = (username, { metas: [{ points }, ..._rest]}) => {
+  // build out the listBy function so that it returns a list of users
+  // where each user looks like this:
+  // {username: username, points: points}
+}
 
 const showPoints = usersElem => ({userId, points}) => {
   const userElem = document.querySelector(`.${userId}.user-estimate`)
   userElem.innerHTML = points
 }
 
-// const addUser = usersElem => ({userId, points}) => {
-//   const userElem = document.createElement('dt')
-//   userElem.appendChild(document.createTextNode(userId))
-//   userElem.setAttribute('class', 'col-8')
-//
-//   const estimateElem = document.createElement('dd')
-//   estimateElem.setAttribute('class', `${userId} user-estimate col-4`)
-//
-//   usersElem.appendChild(userElem)
-//   usersElem.appendChild(estimateElem)
-// }
-
-const allHaveEstimated = users => {
-  const pointsCollection = map(({ points }) => points)(users)
-
-  return none(isNil)(pointsCollection)
-}
-
 function addUser(user) {
-  document.createElement('dt')
+  const userElem = document.createElement('dt')
   userElem.appendChild(document.createTextNode(user.username))
   userElem.setAttribute('class', 'col-8')
 

lib/pointing_party_web/channels/room_channel.ex

@@ -1,99 +1,42 @@
 defmodule PointingPartyWeb.RoomChannel do
   use PointingPartyWeb, :channel
 
-  alias PointingParty.Card
-  alias PointingPartyWeb.Presence
-  alias PointingParty.VoteCalculator
-
   def join("room:lobby", _payload, socket) do
     send(self(), :after_join)
 
     {:ok, socket}
   end
 
   def handle_info(:after_join, socket) do
-    push(socket, "presence_state", Presence.list(socket))
-    {:ok, _} = Presence.track(socket, socket.assigns.username, %{})
-
+    # handle Presence listing and tracking here
     {:noreply, socket}
   end
 
   def handle_in("user_estimated", %{"points" => points}, socket) do
-    Presence.update(socket, socket.assigns.username, &(Map.put(&1, :points, points)))
-
-    if everyone_voted?(socket) do
-      finalize_voting(socket)
-    end
-
+    # update votes for user presence
+    # calculate votes if everyone voted with the help of the VoteCalculator
+    # broadcast the 'winner'/'tie' event with a payload of %{points: points}
     {:noreply, socket}
   end
 
   def handle_in("finalized_points", %{"points" => points}, socket) do
-    updated_socket = save_vote_next_card(points, socket)
-    broadcast!(updated_socket, "new_card", %{card: current_card(updated_socket)})
-    {:reply, :ok, updated_socket}
+    # update state by setting the current card to the next card
+    # broadcast the "new_card" message with a payload of %{card: new_current_card}
+    {:reply, :ok, socket}
   end
 
   def handle_in("start_pointing", _params, socket) do
     updated_socket = initialize_state(socket)
-    broadcast!(updated_socket, "new_card", %{card: current_card(updated_socket)})
+    # broadcast the "new_card" message with a payload of %{card: current_card}
     {:reply, :ok, updated_socket}
   end
 
-  intercept ["new_card"]
-
-  def handle_out("new_card", payload, socket) do
-    Presence.update(socket, socket.assigns.username, &(Map.put(&1, :points, nil)))
-    push(socket, "new_card", payload)
-    {:noreply, socket}
-  end
-
-
-  defp current_card(socket) do
-    socket.assigns
-    |> Map.get(:current)
-    |> Map.from_struct()
-    |> Map.drop([:__meta__])
-  end
-
-  defp everyone_voted?(socket) do
-    socket
-    |> Presence.list()
-    |> Enum.map(fn {_username, %{metas: [metas]}} -> Map.get(metas, :points) end)
-    |> Enum.all?(&(not is_nil(&1)))
-  end
-
-  defp finalize_voting(socket) do
-    current_users = Presence.list(socket)
-
-    {event, points} = VoteCalculator.calculate_votes(current_users)
-    broadcast!(socket, event, %{points: points})
-  end
-
   defp initialize_state(%{assigns: %{cards: _cards}} = socket), do: socket
   defp initialize_state(socket) do
     [first | cards] = Card.cards()
 
     socket
-    |> assign(:points, Card.points_range())
     |> assign(:unvoted, cards)
     |> assign(:current, first)
   end
-
-  defp save_vote_next_card(points, socket) do
-    latest_card =
-      socket.assigns
-      |> Map.get(:current)
-      |> Map.put(:points, points)
-
-    {next, remaining} =
-      socket.assigns
-      |> Map.get(:unvoted)
-      |> List.pop_at(0)
-
-    socket
-    |> assign(:unvoted, remaining)
-    |> assign(:current, next)
-    |> assign(:voted, [latest_card | socket.assigns[:voted]])
-  end
 end

lib/pointing_party_web/channels/user_socket.ex

@@ -15,8 +15,8 @@ defmodule PointingPartyWeb.UserSocket do
   #
   # See `Phoenix.Token` documentation for examples in
   # performing token verification on connect.
-  def connect(%{"username" => username}, socket, _connect_info) do
-    {:ok, assign(socket, :username, username)}
+  def connect(_params, socket, _connect_info) do
+    {:ok, socket}
   end
 
   # Socket id's are topics that allow you to identify all sockets for a given user:

mix.exs

@@ -8,7 +8,6 @@ defmodule PointingParty.MixProject do
       elixir: "~> 1.5",
       elixirc_paths: elixirc_paths(Mix.env()),
       compilers: [:phoenix, :gettext] ++ Mix.compilers(),
-      elixirc_options: [warnings_as_errors: true],
       start_permanent: Mix.env() == :prod,
       deps: deps()
     ]

priv/static/js/app.js

@@ -0,0 +1,23 @@
+defmodule PointingParty.VoteCalculatorTest do
+  use ExUnit.Case, async: true
+
+   @users_with_winner %{
+    "sean" => %{metas: [%{points: 1}]},
+    "michael" => %{metas: [%{points: 3}]},
+    "sophie" => %{metas: [%{points: 3}]}
+   }
+
+  @users_with_tie %{
+   "sean" => %{metas: [%{points: 1}]},
+   "michael" => %{metas: [%{points: 2}]},
+   "sophie" => %{metas: [%{points: 3}]}
+  }
+
+  test "calculate_votes/1 calculates when there is a winner" do
+    {"winner", 3} = PointingParty.VoteCalculator.calculate_votes(@users_with_winner)
+  end
+
+  test "calculate_votes/1 calculates when there is a tie" do
+    {"tie", [1,2]} = PointingParty.VoteCalculator.calculate_votes(@users_with_tie)
+  end
+end