Merge pull request andrewvy#30 from andrewvy/feature/jason

Switch from `poison` -> `jason`

Author: andrewvy

lib/chrome_remote_interface.ex

@@ -7,14 +7,14 @@ defmodule ChromeRemoteInterface do
 
   @protocol_env_key "CRI_PROTOCOL_VERSION"
   @protocol_versions ["1-2", "1-3", "tot"]
-  @protocol_version (
-    if (vsn = System.get_env(@protocol_env_key)) in @protocol_versions do
-      vsn
-    else
-      "1-3"
-    end
+  @protocol_version (if (vsn = System.get_env(@protocol_env_key)) in @protocol_versions do
+                       vsn
+                     else
+                       "1-3"
+                     end)
+  IO.puts(
+    "Compiling ChromeRemoteInterface with Chrome DevTools Protocol version: '#{@protocol_version}'"
   )
-  IO.puts("Compiling ChromeRemoteInterface with Chrome DevTools Protocol version: '#{@protocol_version}'")
 
   @doc """
   Gets the current version of the Chrome Debugger Protocol
@@ -25,12 +25,11 @@ defmodule ChromeRemoteInterface do
 
   protocol =
     File.read!("priv/#{@protocol_version}/protocol.json")
-    |> Poison.decode!()
-
+    |> Jason.decode!()
 
   # Generate ChromeRemoteInterface.RPC Modules
 
-  Enum.each(protocol["domains"], fn(domain) ->
+  Enum.each(protocol["domains"], fn domain ->
     defmodule Module.concat(ChromeRemoteInterface.RPC, domain["domain"]) do
       @domain domain
       @moduledoc domain["description"]
@@ -40,10 +39,11 @@ defmodule ChromeRemoteInterface do
       for command <- @domain["commands"] do
         name = command["name"]
         description = command["description"]
+
         arg_doc =
           command["parameters"]
           |> List.wrap()
-          |> Enum.map(fn(param) ->
+          |> Enum.map(fn param ->
             "#{param["name"]} - <#{param["$ref"] || param["type"]}> - #{param["description"]}"
           end)
 
@@ -54,21 +54,26 @@ defmodule ChromeRemoteInterface do
         #{arg_doc}
         """
         def unquote(:"#{name}")(page_pid) do
-          page_pid |> PageSession.execute_command(
+          page_pid
+          |> PageSession.execute_command(
             unquote("#{domain["domain"]}.#{name}"),
             %{},
             []
           )
         end
+
         def unquote(:"#{name}")(page_pid, parameters) do
-          page_pid |> PageSession.execute_command(
+          page_pid
+          |> PageSession.execute_command(
             unquote("#{domain["domain"]}.#{name}"),
             parameters,
             []
           )
         end
+
         def unquote(:"#{name}")(page_pid, parameters, opts) when is_list(opts) do
-          page_pid |> PageSession.execute_command(
+          page_pid
+          |> PageSession.execute_command(
             unquote("#{domain["domain"]}.#{name}"),
             parameters,
             opts

lib/http.ex

@@ -3,10 +3,11 @@ defmodule ChromeRemoteInterface.HTTP do
   This module handles communicating with the DevTools HTTP JSON API.
   """
 
-  @type success_http_response :: {:ok, Map.t}
+  @type success_http_response :: {:ok, Map.t()}
   @type error_http_response :: {:error, any()}
 
-  @spec call(ChromeRemoteInterface.Server.t, String.t) :: success_http_response | error_http_response
+  @spec call(ChromeRemoteInterface.Server.t(), String.t()) ::
+          success_http_response | error_http_response
   def call(server, path) do
     server
     |> execute_request(path)
@@ -22,15 +23,15 @@ defmodule ChromeRemoteInterface.HTTP do
   end
 
   defp execute_request(server, path) do
-    :hackney.request(:get, http_url(server, path), [], <<>>, [path_encode_fun: &(&1)])
+    :hackney.request(:get, http_url(server, path), [], <<>>, path_encode_fun: & &1)
   end
 
   defp handle_response({:ok, status_code, _response_headers, client_ref}) do
     with true <- status_code >= 200 && status_code < 300,
-      {:ok, body} <- :hackney.body(client_ref),
-      {:ok, formatted_body} <- format_body(body),
-      {:ok, json} <- decode(formatted_body) do
-        {:ok, json}
+         {:ok, body} <- :hackney.body(client_ref),
+         {:ok, formatted_body} <- format_body(body),
+         {:ok, json} <- decode(formatted_body) do
+      {:ok, json}
     else
       error -> error
     end
@@ -48,7 +49,7 @@ defmodule ChromeRemoteInterface.HTTP do
   defp format_body(body), do: {:ok, body}
 
   defp decode(body) do
-    case Poison.decode(body) do
+    case Jason.decode(body) do
       {:ok, json} -> {:ok, json}
       {:error, _reason} -> {:ok, body}
     end

lib/page_session.ex

@@ -9,13 +9,11 @@ defmodule ChromeRemoteInterface.PageSession do
 
   use GenServer
 
-  defstruct [
-    url: "",
-    socket: nil,
-    callbacks: [],
-    event_subscribers: %{},
-    ref_id: 1
-  ]
+  defstruct url: "",
+            socket: nil,
+            callbacks: [],
+            event_subscribers: %{},
+            ref_id: 1
 
   # ---
   # Public API
@@ -25,6 +23,7 @@ defmodule ChromeRemoteInterface.PageSession do
   Connect to a Page's 'webSocketDebuggerUrl'.
   """
   def start_link(%{"webSocketDebuggerUrl" => url}), do: start_link(url)
+
   def start_link(url) do
     GenServer.start_link(__MODULE__, url)
   end
@@ -58,15 +57,15 @@ defmodule ChromeRemoteInterface.PageSession do
      "params" => %{"timestamp" => 1012329.888558}}}
   ```
   """
-  @spec subscribe(pid(), String.t, pid()) :: any()
+  @spec subscribe(pid(), String.t(), pid()) :: any()
   def subscribe(pid, event, subscriber_pid \\ self()) do
     GenServer.call(pid, {:subscribe, event, subscriber_pid})
   end
 
   @doc """
   Unsubscribes from an event.
   """
-  @spec unsubscribe(pid(), String.t, pid()) :: any()
+  @spec unsubscribe(pid(), String.t(), pid()) :: any()
   def unsubscribe(pid, event, subscriber_pid \\ self()) do
     GenServer.call(pid, {:unsubscribe, event, subscriber_pid})
   end
@@ -121,6 +120,7 @@ defmodule ChromeRemoteInterface.PageSession do
 
   def init(url) do
     {:ok, socket} = ChromeRemoteInterface.Websocket.start_link(url)
+
     state = %__MODULE__{
       url: url,
       socket: socket
@@ -156,7 +156,7 @@ defmodule ChromeRemoteInterface.PageSession do
     new_event_subscribers =
       state
       |> Map.get(:event_subscribers, %{})
-      |> Map.update(event, [subscriber_pid], fn(subscriber_pids) ->
+      |> Map.update(event, [subscriber_pid], fn subscriber_pids ->
         [subscriber_pid | subscriber_pids]
       end)
 
@@ -169,7 +169,7 @@ defmodule ChromeRemoteInterface.PageSession do
     new_event_subscribers =
       state
       |> Map.get(:event_subscribers, %{})
-      |> Map.update(event, [], fn(subscriber_pids) ->
+      |> Map.update(event, [], fn subscriber_pids ->
         List.delete(subscriber_pids, subscriber_pid)
       end)
 
@@ -182,7 +182,7 @@ defmodule ChromeRemoteInterface.PageSession do
     new_event_subscribers =
       state
       |> Map.get(:event_subscribers, %{})
-      |> Enum.map(fn({key, subscriber_pids}) ->
+      |> Enum.map(fn {key, subscriber_pids} ->
         {key, List.delete(subscriber_pids, subscriber_pid)}
       end)
       |> Enum.into(%{})
@@ -200,7 +200,7 @@ defmodule ChromeRemoteInterface.PageSession do
   # If the frame is an event:
   #   - Forward the event to any subscribers.
   def handle_info({:message, frame_data}, state) do
-    json = Poison.decode!(frame_data)
+    json = Jason.decode!(frame_data)
     id = json["id"]
     method = json["method"]
 
@@ -227,14 +227,14 @@ defmodule ChromeRemoteInterface.PageSession do
       "params" => params
     }
 
-    json = Poison.encode!(message)
+    json = Jason.encode!(message)
     WebSockex.send_frame(socket, {:text, json})
     {:noreply, state}
   end
 
   defp add_callback(state, from) do
     state
-    |> Map.update(:callbacks, [{state.ref_id, from}], fn(callbacks) ->
+    |> Map.update(:callbacks, [{state.ref_id, from}], fn callbacks ->
       [{state.ref_id, from} | callbacks]
     end)
   end
@@ -252,18 +252,20 @@ defmodule ChromeRemoteInterface.PageSession do
   defp send_rpc_response(callbacks, id, json) do
     error = json["error"]
 
-    Enum.find(callbacks, fn({ref_id, _from}) ->
+    Enum.find(callbacks, fn {ref_id, _from} ->
       ref_id == id
     end)
     |> case do
       {_ref_id, {:cast, method, from}} = callback ->
         event = {:chrome_remote_interface, method, json}
         send(from, event)
         remove_callback(callbacks, callback)
+
       {_ref_id, {:call, from}} = callback ->
         status = if error, do: :error, else: :ok
         GenServer.reply(from, {status, json})
         remove_callback(callbacks, callback)
+
       _ ->
         callbacks
     end
@@ -277,7 +279,7 @@ defmodule ChromeRemoteInterface.PageSession do
       |> Map.get(event_name, [])
 
     pids_subscribed_to_event
-    |> Enum.each(&(send(&1, event)))
+    |> Enum.each(&send(&1, event))
   end
 
   def terminate(_reason, state) do

mix.exs

@@ -25,7 +25,7 @@ defmodule ChromeRemoteInterface.Mixfile do
   # Run "mix help deps" to learn about dependencies.
   defp deps do
     [
-      {:poison, "~> 3.1"},
+      {:jason, "~> 1.1"},
       {:hackney, "~> 1.8 or ~> 1.7 or ~> 1.6"},
       {:websockex, "~> 0.4.0"},
       {:ex_doc, "~> 0.19", only: :dev, runtime: false}

mix.lock

@@ -6,6 +6,7 @@
   "httpipe": {:hex, :httpipe, "0.9.0", "4db66493b0ec2a86d142ea959a62e221d6ddb23ab48a676b691be3a16c38a415", [:mix], []},
   "httpipe_adapters_hackney": {:hex, :httpipe_adapters_hackney, "0.11.0", "35c31b96fd6fea117f9ba6ca70467ada111dffb9f2fa7fca0bfc7e12bb166e8e", [:mix], [{:hackney, "~> 1.8 or ~> 1.7 or ~> 1.6", [hex: :hackney, optional: false]}, {:httpipe, "~> 0.9.0", [hex: :httpipe, optional: false]}]},
   "idna": {:hex, :idna, "5.1.0", "d72b4effeb324ad5da3cab1767cb16b17939004e789d8c0ad5b70f3cea20c89a", [:rebar3], [{:unicode_util_compat, "0.3.1", [hex: :unicode_util_compat, optional: false]}]},
+  "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
   "makeup": {:hex, :makeup, "0.8.0", "9cf32aea71c7fe0a4b2e9246c2c4978f9070257e5c9ce6d4a28ec450a839b55f", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
   "makeup_elixir": {:hex, :makeup_elixir, "0.13.0", "be7a477997dcac2e48a9d695ec730b2d22418292675c75aa2d34ba0909dcdeda", [:mix], [{:makeup, "~> 0.8", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
   "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], []},

test/page_session_test.exs

@@ -16,11 +16,12 @@ defmodule ChromeRemoteInterface.PageSessionTest do
       state = %PageSession{}
       state = subscribe_to_test_event(state)
 
-      {:reply, :ok, state} = PageSession.handle_call(
-       {:unsubscribe, "TestEvent", self()},
-       self(),
-       state
-      )
+      {:reply, :ok, state} =
+        PageSession.handle_call(
+          {:unsubscribe, "TestEvent", self()},
+          self(),
+          state
+        )
 
       fire_test_event(state)
 
@@ -31,11 +32,12 @@ defmodule ChromeRemoteInterface.PageSessionTest do
       state = %PageSession{}
       state = subscribe_to_test_event(state)
 
-      {:reply, :ok, state} = PageSession.handle_call(
-       {:unsubscribe_all, self()},
-       self(),
-       state
-      )
+      {:reply, :ok, state} =
+        PageSession.handle_call(
+          {:unsubscribe_all, self()},
+          self(),
+          state
+        )
 
       fire_test_event(state)
 
@@ -49,7 +51,9 @@ defmodule ChromeRemoteInterface.PageSessionTest do
       from = {make_ref(), self()}
 
       state = %PageSession{socket: websocket}
-      {:noreply, state} = PageSession.handle_call({:call_command, "TestCommand", %{}}, from, state)
+
+      {:noreply, state} =
+        PageSession.handle_call({:call_command, "TestCommand", %{}}, from, state)
 
       assert [{_ref, {:call, _from}}] = state.callbacks
     end
@@ -59,37 +63,41 @@ defmodule ChromeRemoteInterface.PageSessionTest do
       from = {self(), make_ref()}
 
       state = %PageSession{socket: websocket}
-      {:noreply, state} = PageSession.handle_call({:call_command, "TestCommand", %{}}, from, state)
+
+      {:noreply, state} =
+        PageSession.handle_call({:call_command, "TestCommand", %{}}, from, state)
 
       assert [{ref, {:call, _from}}] = state.callbacks
 
-      frame = %{"id" => ref, "result" => %{"data" => %{"foo" => "bar"}}} |> Poison.encode!()
+      frame = %{"id" => ref, "result" => %{"data" => %{"foo" => "bar"}}} |> Jason.encode!()
       {:noreply, state} = PageSession.handle_info({:message, frame}, state)
 
       assert [] = state.callbacks
     end
   end
 
   def subscribe_to_test_event(state) do
-    {:reply, :ok, state} = PageSession.handle_call(
-     {:subscribe, "TestEvent", self()},
-     self(),
-     state
-    )
+    {:reply, :ok, state} =
+      PageSession.handle_call(
+        {:subscribe, "TestEvent", self()},
+        self(),
+        state
+      )
 
     state
   end
 
   def fire_test_event(state) do
-    json = Poison.encode!(%{
-      method: "TestEvent"
-    })
+    json =
+      Jason.encode!(%{
+        method: "TestEvent"
+      })
 
     PageSession.handle_info({:message, json}, state)
   end
 
   def spawn_fake_websocket() do
-    spawn_link(fn() ->
+    spawn_link(fn ->
       receive do
         {:"$websockex_send", from, _frame} -> GenServer.reply(from, :ok)
       end