Merge pull request wistia#5 from edennis/fix-warnings-for-1.4

Fix warnings for 1.4

Author: MaxPower15

.gitignore

@@ -3,3 +3,4 @@
 /deps
 erl_crash.dump
 *.ez
+test/data_paths

lib/nsq/conn_info.ex

@@ -70,9 +70,9 @@ defmodule NSQ.ConnInfo do
     Agent.get agent_pid, fn(data) ->
       conn_map = data[conn_id] || %{}
       if is_list(keys) do
-        Enum.map keys, &Dict.get(conn_map, &1)
+        Enum.map keys, &Map.get(conn_map, &1)
       else
-        Dict.get(conn_map, keys)
+        Map.get(conn_map, keys)
       end
     end
   end
@@ -96,7 +96,7 @@ defmodule NSQ.ConnInfo do
   """
   def update(agent_pid, conn_id, func) when is_pid(agent_pid) and is_function(func) do
     Agent.update agent_pid, fn(data) ->
-      Dict.put(data, conn_id, func.(data[conn_id] || %{}))
+      Map.put(data, conn_id, func.(data[conn_id] || %{}))
     end
   end
 
@@ -107,8 +107,8 @@ defmodule NSQ.ConnInfo do
   """
   def update(agent_pid, conn_id, map) when is_pid(agent_pid) and is_map(map) do
     Agent.update agent_pid, fn(data) ->
-      new_conn_data = Dict.merge(data[conn_id] || %{}, map)
-      Dict.put(data, conn_id, new_conn_data)
+      new_conn_data = Map.merge(data[conn_id] || %{}, map)
+      Map.put(data, conn_id, new_conn_data)
     end
   end
 
@@ -130,7 +130,7 @@ defmodule NSQ.ConnInfo do
   connection is terminated.
   """
   def delete(agent_pid, conn_id) when is_pid(agent_pid) do
-    Agent.update(agent_pid, fn(data) -> Dict.delete(data, conn_id) end)
+    Agent.update(agent_pid, fn(data) -> Map.delete(data, conn_id) end)
   end
 
 
@@ -147,7 +147,7 @@ defmodule NSQ.ConnInfo do
       rdy_count: 0,
       last_rdy: 0,
       messages_in_flight: 0,
-      last_msg_timestamp: now,
+      last_msg_timestamp: now(),
       retry_rdy_pid: nil,
       finished_count: 0,
       requeued_count: 0,

lib/nsq/connection.ex

@@ -199,7 +199,7 @@ defmodule NSQ.Connection do
         Logger.error "#{inspect conn}: Timed out waiting for messages to finish. Exiting anyway."
     end
 
-    Process.exit(self, :normal)
+    Process.exit(self(), :normal)
   end
 
   @doc """

lib/nsq/connection/buffer.ex

@@ -40,7 +40,7 @@ defmodule NSQ.Connection.Buffer do
           state = %{state | compression: :deflate}
           case state.type do
             :reader ->
-              %{state | zin: open_zin!} |> convert_plaintext_buffer(:deflate)
+              %{state | zin: open_zin!()} |> convert_plaintext_buffer(:deflate)
             :writer ->
               %{state | zout: open_zout!(level)}
           end

lib/nsq/connection/initializer.ex

@@ -33,21 +33,21 @@ defmodule NSQ.Connection.Initializer do
           {:ok, %{state | connected: true}}
         {:error, reason} ->
           if length(state.config.nsqlookupds) > 0 do
-            Logger.warn "(#{inspect self}) connect failed; #{reason}; discovery loop should respawn"
+            Logger.warn "(#{inspect self()}) connect failed; #{reason}; discovery loop should respawn"
             {{:error, reason}, %{state | connect_attempts: state.connect_attempts + 1}}
           else
             if state.config.max_reconnect_attempts > 0 do
-              Logger.warn "(#{inspect self}) connect failed; #{reason}; discovery loop should respawn"
+              Logger.warn "(#{inspect self()}) connect failed; #{reason}; discovery loop should respawn"
               {{:error, reason}, %{state | connect_attempts: state.connect_attempts + 1}}
             else
-              Logger.error "(#{inspect self}) connect failed; #{reason}; reconnect turned off; terminating connection"
-              Process.exit(self, :connect_failed)
+              Logger.error "(#{inspect self()}) connect failed; #{reason}; reconnect turned off; terminating connection"
+              Process.exit(self(), :connect_failed)
             end
           end
       end
     else
-      Logger.error "#{inspect self}: Failed to connect; terminating connection"
-      Process.exit(self, :connect_failed)
+      Logger.error "#{inspect self()}: Failed to connect; terminating connection"
+      Process.exit(self(), :connect_failed)
     end
   end
 
@@ -77,14 +77,14 @@ defmodule NSQ.Connection.Initializer do
 
   @spec send_magic_v2(C.state) :: :ok
   defp send_magic_v2(conn_state) do
-    Logger.debug("(#{inspect self}) sending magic v2...")
+    Logger.debug("(#{inspect self()}) sending magic v2...")
     conn_state |> Buffer.send!(encode(:magic_v2))
   end
 
 
   @spec identify(C.state) :: {:ok, binary}
   defp identify(conn_state) do
-    Logger.debug("(#{inspect self}) identifying...")
+    Logger.debug("(#{inspect self()}) identifying...")
     identify_obj = encode({:identify, identify_props(conn_state)})
     conn_state |> Buffer.send!(identify_obj)
     {:response, json} = recv_nsq_response(conn_state)
@@ -186,10 +186,10 @@ defmodule NSQ.Connection.Initializer do
 
   @spec subscribe(C.state) :: {:ok, binary}
   defp subscribe(%{topic: topic, channel: channel} = conn_state) do
-    Logger.debug "(#{inspect self}) subscribe to #{topic} #{channel}"
+    Logger.debug "(#{inspect self()}) subscribe to #{topic} #{channel}"
     conn_state |> Buffer.send!(encode({:sub, topic, channel}))
 
-    Logger.debug "(#{inspect self}) wait for subscription acknowledgment"
+    Logger.debug "(#{inspect self()}) wait for subscription acknowledgment"
     conn_state |> wait_for_ok!
   end
 
@@ -203,7 +203,7 @@ defmodule NSQ.Connection.Initializer do
 
 
   defp wait_for_ok!(state) do
-    expected = ok_msg
+    expected = ok_msg()
     ^expected = state |> Buffer.recv!(byte_size(expected))
   end
 
@@ -233,9 +233,9 @@ defmodule NSQ.Connection.Initializer do
 
   @spec start_receiving_messages(C.state) :: {:ok, C.state}
   defp start_receiving_messages(state) do
-    reader_pid = spawn_link(MessageHandling, :recv_nsq_messages, [state, self])
+    reader_pid = spawn_link(MessageHandling, :recv_nsq_messages, [state, self()])
     state = %{state | reader_pid: reader_pid}
-    GenServer.cast(self, :flush_cmd_queue)
+    GenServer.cast(self(), :flush_cmd_queue)
     {:ok, state}
   end
   defp start_receiving_messages!(state) do

lib/nsq/connection/message_handling.ex

@@ -106,7 +106,7 @@ defmodule NSQ.Connection.MessageHandling do
     message = NSQ.Message.from_data(data)
     state = received_message(state)
     message = %NSQ.Message{message |
-      connection: self,
+      connection: self(),
       consumer: state.parent,
       reader: state.reader,
       writer: state.writer,
@@ -127,7 +127,7 @@ defmodule NSQ.Connection.MessageHandling do
       %{info |
         rdy_count: info.rdy_count - 1,
         messages_in_flight: info.messages_in_flight + 1,
-        last_msg_timestamp: now
+        last_msg_timestamp: now()
       }
     end
     state

lib/nsq/consumer.ex

@@ -176,7 +176,7 @@ defmodule NSQ.Consumer do
 
     cons_state = %{cons_state | max_in_flight: cons_state.config.max_in_flight}
 
-    {:ok, _cons_state} = Connections.discover_nsqds_and_connect(self, cons_state)
+    {:ok, _cons_state} = Connections.discover_nsqds_and_connect(self(), cons_state)
   end
 
 
@@ -187,7 +187,7 @@ defmodule NSQ.Consumer do
   @spec handle_call(:redistribute_rdy, {reference, pid}, cons_state) ::
     {:reply, :ok, cons_state}
   def handle_call(:redistribute_rdy, _from, cons_state) do
-    {:reply, :ok, RDY.redistribute!(self, cons_state)}
+    {:reply, :ok, RDY.redistribute!(self(), cons_state)}
   end
 
 
@@ -218,14 +218,14 @@ defmodule NSQ.Consumer do
   @spec handle_call({:start_stop_continue_backoff, atom}, {reference, pid}, cons_state) ::
     {:reply, :ok, cons_state}
   def handle_call({:start_stop_continue_backoff, backoff_flag}, _from, cons_state) do
-    {:reply, :ok, Backoff.start_stop_continue!(self, backoff_flag, cons_state)}
+    {:reply, :ok, Backoff.start_stop_continue!(self(), backoff_flag, cons_state)}
   end
 
 
   @spec handle_call({:update_rdy, connection, integer}, {reference, pid}, cons_state) ::
     {:reply, :ok, cons_state}
   def handle_call({:update_rdy, conn, count}, _from, cons_state) do
-    {:reply, :ok, RDY.update!(self, conn, count, cons_state)}
+    {:reply, :ok, RDY.update!(self(), conn, count, cons_state)}
   end
 
 
@@ -290,7 +290,7 @@ defmodule NSQ.Consumer do
   """
   @spec handle_cast(:resume, cons_state) :: {:noreply, cons_state}
   def handle_cast(:resume, state) do
-    {:noreply, Backoff.resume!(self, state)}
+    {:noreply, Backoff.resume!(self(), state)}
   end
 
 
@@ -301,8 +301,8 @@ defmodule NSQ.Consumer do
   @spec handle_cast({:maybe_update_rdy, host_with_port}, cons_state) ::
     {:noreply, cons_state}
   def handle_cast({:maybe_update_rdy, {_host, _port} = nsqd}, cons_state) do
-    conn = conn_from_nsqd(self, nsqd, cons_state)
-    {:noreply, RDY.maybe_update!(self, conn, cons_state)}
+    conn = conn_from_nsqd(self(), nsqd, cons_state)
+    {:noreply, RDY.maybe_update!(self(), conn, cons_state)}
   end
 
 

lib/nsq/consumer/connections.ex

@@ -22,7 +22,7 @@ defmodule NSQ.Consumer.Connections do
       lookupd_poll_interval: poll_interval,
       lookupd_poll_jitter: poll_jitter
     } = cons_state.config
-    delay = poll_interval + round(poll_interval * poll_jitter * :random.uniform)
+    delay = poll_interval + round(poll_interval * poll_jitter * :rand.uniform)
     :timer.sleep(delay)
 
     GenServer.call(cons, :discover_nsqds)
@@ -31,7 +31,7 @@ defmodule NSQ.Consumer.Connections do
 
 
   def close(cons_state) do
-    Logger.info "Closing connections for consumer #{inspect self}"
+    Logger.info "Closing connections for consumer #{inspect self()}"
     connections = get(cons_state)
     Enum.map connections, fn({_, conn_pid}) ->
       Task.start_link(NSQ.Connection, :close, [conn_pid])
@@ -48,7 +48,7 @@ defmodule NSQ.Consumer.Connections do
   def refresh(cons_state) do
     {:ok, cons_state} = delete_dead(cons_state)
     {:ok, cons_state} = reconnect_failed(cons_state)
-    {:ok, cons_state} = discover_nsqds_and_connect(self, cons_state)
+    {:ok, cons_state} = discover_nsqds_and_connect(self(), cons_state)
     {:ok, cons_state}
   end
 
@@ -67,12 +67,12 @@ defmodule NSQ.Consumer.Connections do
   def discover_nsqds_and_connect(cons, cons_state) do
     nsqds = cond do
       length(cons_state.config.nsqlookupds) > 0 ->
-        Logger.debug "(#{inspect self}) Discovering nsqds via nsqlookupds #{inspect cons_state.config.nsqlookupds}"
+        Logger.debug "(#{inspect self()}) Discovering nsqds via nsqlookupds #{inspect cons_state.config.nsqlookupds}"
         cons_state.config.nsqlookupds
         |> NSQ.Lookupd.nsqds_with_topic(cons_state.topic)
 
       length(cons_state.config.nsqds) > 0 ->
-        Logger.debug "(#{inspect self}) Using configured nsqds #{inspect cons_state.config.nsqds}"
+        Logger.debug "(#{inspect self()}) Using configured nsqds #{inspect cons_state.config.nsqds}"
         cons_state.config.nsqds
 
       true ->
@@ -196,7 +196,7 @@ defmodule NSQ.Consumer.Connections do
   Not for external use.
   """
   @spec cleanup_connection(pid, C.host_with_port, C.state) :: {:ok, C.state}
-  def cleanup_connection(cons, conn_id, cons_state) do
+  def cleanup_connection(_cons, conn_id, cons_state) do
     # If a connection is terminated normally or non-normally, it will still be
     # listed in the supervision tree. Let's remove it when we clean up.
     Supervisor.delete_child(cons_state.conn_sup_pid, conn_id)
@@ -284,7 +284,7 @@ defmodule NSQ.Consumer.Connections do
     if is_integer(active) do
       active
     else
-      Logger.warn "(#{inspect self}) non-integer #{inspect active} returned counting connections, returning 0 instead"
+      Logger.warn "(#{inspect self()}) non-integer #{inspect active} returned counting connections, returning 0 instead"
       0
     end
   end
@@ -322,7 +322,7 @@ defmodule NSQ.Consumer.Connections do
       [last_msg_t, rdy_count] = ConnInfo.fetch(
         cons_state, conn_id, [:last_msg_timestamp, :rdy_count]
       )
-      sec_since_last_msg = now - last_msg_t
+      sec_since_last_msg = now() - last_msg_t
       ms_since_last_msg = sec_since_last_msg * 1000
 
       Logger.debug(

lib/nsq/message.ex

@@ -37,7 +37,7 @@ defmodule NSQ.Message do
 
   def init(message) do
     # Process the message asynchronously after init.
-    GenServer.cast(self, :process)
+    GenServer.cast(self(), :process)
     {:ok, message}
   end
 
@@ -70,7 +70,7 @@ defmodule NSQ.Message do
   def process(message) do
     # Kick off processing in a separate process, so we can kill it if it takes
     # too long.
-    message = %{message | parent: self}
+    message = %{message | parent: self()}
     {:ok, pid} = Task.start_link fn ->
       process_without_timeout(message)
     end
@@ -85,7 +85,7 @@ defmodule NSQ.Message do
     send(message.connection, result)
 
     # Nothing more for this process to do.
-    Process.exit(self, :normal)
+    Process.exit(self(), :normal)
   end
 
 
@@ -253,7 +253,7 @@ defmodule NSQ.Message do
 
   defp calculate_delay(attempts, max_requeue_delay) do
     exponential_backoff = :math.pow(2, attempts) * 1000
-    jitter = round(0.3 * :random.uniform * exponential_backoff)
+    jitter = round(0.3 * :rand.uniform * exponential_backoff)
     min(
       exponential_backoff + jitter,
       max_requeue_delay

lib/nsq/producer.ex

@@ -102,7 +102,7 @@ defmodule NSQ.Producer do
       end
     pro_state = %{pro_state | event_manager_pid: manager}
 
-    {:ok, _pro_state} = connect_to_nsqds(pro_state.config.nsqds, self, pro_state)
+    {:ok, _pro_state} = connect_to_nsqds(pro_state.config.nsqds, self(), pro_state)
   end