From: Christopher <chris@entropealabs.com>
Date: Mon, 23 Mar 2020 02:16:11 +0000 (-0500)
Subject: handle functions return structs instead of tuples
X-Git-Url: http://git.entropealabs.com/?a=commitdiff_plain;h=7ef957cbcef37770e10cc73c6855a1504baf07f9;p=wampex.git

handle functions return structs instead of tuples
---

diff --git a/lib/roles/broker.ex b/lib/roles/broker.ex
index 89036b4..27beb2b 100644
--- a/lib/roles/broker.ex
+++ b/lib/roles/broker.ex
@@ -3,6 +3,8 @@ defmodule Wampex.Roles.Broker do
   Handles requests and responses for a Broker
   """
   alias Wampex.Role
+  alias Wampex.Roles.Publisher.Publish
+  alias Wampex.Roles.Subscriber.{Subscribe, Unsubscribe}
   @behaviour Role
 
   @publish 16
@@ -16,14 +18,14 @@ defmodule Wampex.Roles.Broker do
   defmodule Event do
     @moduledoc false
     @enforce_keys [:subscription_id, :publication_id]
-    defstruct [:subscription_id, :publication_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:subscription_id, :publication_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             subscription_id: integer(),
             publication_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
@@ -70,7 +72,7 @@ defmodule Wampex.Roles.Broker do
         publication_id: pi,
         arg_list: al,
         arg_kw: akw,
-        options: opts
+        details: opts
       }) do
     [@event, si, pi, opts, al, akw]
   end
@@ -93,13 +95,13 @@ defmodule Wampex.Roles.Broker do
   @impl true
   def handle([@subscribe, request_id, opts, topic]) do
     {[{:next_event, :internal, :subscribe}], request_id,
-     {:update, :subscribe, {:subscribe, request_id, opts, topic}}}
+     {:update, :subscribe, %Subscribe{request_id: request_id, options: opts, topic: topic}}}
   end
 
   @impl true
   def handle([@unsubscribe, request_id, id]) do
     {[{:next_event, :internal, :unsubscribe}], request_id,
-     {:update, :unsubscribe, {:unsubscribe, request_id, id}}}
+     {:update, :unsubscribe, %Unsubscribe{request_id: request_id, subscription_id: id}}}
   end
 
   @impl true
@@ -115,6 +117,7 @@ defmodule Wampex.Roles.Broker do
   @impl true
   def handle([@publish, id, opts, topic, arg_l, arg_kw]) do
     {[{:next_event, :internal, :publish}], id,
-     {:update, :publish, {:publish, id, opts, topic, arg_l, arg_kw}}}
+     {:update, :publish,
+      %Publish{request_id: id, options: opts, topic: topic, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 end
diff --git a/lib/roles/callee.ex b/lib/roles/callee.ex
index 8b34613..1df2741 100644
--- a/lib/roles/callee.ex
+++ b/lib/roles/callee.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Callee do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Dealer.{Invocation, Result}
   @behaviour Role
 
   @register 64
@@ -17,9 +18,11 @@ defmodule Wampex.Roles.Callee do
   defmodule Register do
     @moduledoc false
     @enforce_keys [:procedure]
-    defstruct [:procedure, options: %{}]
+    defstruct [:request_id, :registration_id, :procedure, options: %{}]
 
     @type t :: %__MODULE__{
+            registration_id: integer() | nil,
+            request_id: integer() | nil,
             procedure: binary(),
             options: map()
           }
@@ -28,9 +31,10 @@ defmodule Wampex.Roles.Callee do
   defmodule Unregister do
     @moduledoc false
     @enforce_keys [:registration_id]
-    defstruct [:registration_id]
+    defstruct [:request_id, :registration_id]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             registration_id: integer()
           }
   end
@@ -68,6 +72,11 @@ defmodule Wampex.Roles.Callee do
     [@yield, ri, opts, al, akw]
   end
 
+  @impl true
+  def handle(<<@unregistered, request_id>>) do
+    {[{:next_event, :internal, :established}], request_id, {:ok, request_id}}
+  end
+
   @impl true
   def handle([@unregistered, request_id]) do
     {[{:next_event, :internal, :established}], request_id, {:ok, request_id}}
@@ -91,7 +100,14 @@ defmodule Wampex.Roles.Callee do
   @impl true
   def handle([@invocation, id, reg_id, dets, arg_l, arg_kw]) do
     {[{:next_event, :internal, :invocation}], id,
-     {:update, :invocation, {:invocation, id, reg_id, dets, arg_l, arg_kw}}}
+     {:update, :invocation,
+      %Invocation{
+        request_id: id,
+        registration_id: reg_id,
+        details: dets,
+        arg_list: arg_l,
+        arg_kw: arg_kw
+      }}}
   end
 
   @impl true
diff --git a/lib/roles/caller.ex b/lib/roles/caller.ex
index 068eb28..e28a44f 100644
--- a/lib/roles/caller.ex
+++ b/lib/roles/caller.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Caller do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Dealer.Result
   alias Wampex.Roles.Peer.Error
   @behaviour Role
 
@@ -16,9 +17,10 @@ defmodule Wampex.Roles.Caller do
     @moduledoc false
     @enforce_keys [:procedure]
 
-    defstruct [:procedure, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :procedure, arg_list: [], arg_kw: %{}, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             procedure: binary(),
             arg_list: list(any()),
             arg_kw: map(),
@@ -69,6 +71,7 @@ defmodule Wampex.Roles.Caller do
 
   @impl true
   def handle([@result, id, dets, arg_l, arg_kw]) do
-    {[{:next_event, :internal, :established}], id, {:ok, dets, arg_l, arg_kw}}
+    {[{:next_event, :internal, :established}], id,
+     %Result{request_id: id, details: dets, arg_list: arg_l, arg_kw: arg_kw}}
   end
 end
diff --git a/lib/roles/dealer.ex b/lib/roles/dealer.ex
index d8e9ae0..fe94d22 100644
--- a/lib/roles/dealer.ex
+++ b/lib/roles/dealer.ex
@@ -3,6 +3,8 @@ defmodule Wampex.Roles.Dealer do
   Handles requests and responses for a Dealer
   """
   alias Wampex.Role
+  alias Wampex.Roles.Callee.{Unregister, Yield, Register}
+  alias Wampex.Roles.Caller.{Call, Cancel}
   @behaviour Role
 
   @call 48
@@ -38,27 +40,27 @@ defmodule Wampex.Roles.Dealer do
   defmodule Result do
     @moduledoc false
     @enforce_keys [:request_id]
-    defstruct [:request_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             request_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
   defmodule Invocation do
     @moduledoc false
     @enforce_keys [:request_id, :registration_id]
-    defstruct [:request_id, :registration_id, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :registration_id, arg_list: [], arg_kw: %{}, details: %{}]
 
     @type t :: %__MODULE__{
             request_id: integer(),
             registration_id: integer(),
             arg_list: list(any()),
             arg_kw: map(),
-            options: map()
+            details: map()
           }
   end
 
@@ -81,7 +83,7 @@ defmodule Wampex.Roles.Dealer do
   def invocation(%Invocation{
         request_id: ri,
         registration_id: reg_id,
-        options: opts,
+        details: opts,
         arg_list: al,
         arg_kw: akw
       }) do
@@ -93,51 +95,53 @@ defmodule Wampex.Roles.Dealer do
         request_id: ri,
         arg_list: al,
         arg_kw: akw,
-        options: opts
+        details: dets
       }) do
-    [@result, ri, opts, al, akw]
+    [@result, ri, dets, al, akw]
   end
 
   @impl true
   def handle([@unregister, request_id, registration_id]) do
     {[{:next_event, :internal, :unregister}], request_id,
-     {:update, :unregister, {:unregister, request_id, registration_id}}}
+     {:update, :unregister, %Unregister{request_id: request_id, registration_id: registration_id}}}
   end
 
   @impl true
   def handle([@register, request_id, opts, procedure]) do
     {[{:next_event, :internal, :register}], request_id,
-     {:update, :register, {:register, request_id, opts, procedure}}}
+     {:update, :register, %Register{request_id: request_id, options: opts, procedure: procedure}}}
   end
 
   @impl true
-  def handle([@call, id, dets, proc]) do
-    handle([@call, id, dets, proc, [], %{}])
+  def handle([@call, id, opts, proc]) do
+    handle([@call, id, opts, proc, [], %{}])
   end
 
   @impl true
-  def handle([@call, id, dets, proc, arg_l]) do
-    handle([@call, id, dets, proc, arg_l, %{}])
+  def handle([@call, id, opts, proc, arg_l]) do
+    handle([@call, id, opts, proc, arg_l, %{}])
   end
 
   @impl true
-  def handle([@call, id, dets, proc, arg_l, arg_kw]) do
+  def handle([@call, id, opts, proc, arg_l, arg_kw]) do
     {[{:next_event, :internal, :call}], id,
-     {:update, :call, {:call, id, dets, proc, arg_l, arg_kw}}}
+     {:update, :call,
+      %Call{request_id: id, options: opts, procedure: proc, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 
   @impl true
-  def handle([@yield, id, dets]) do
-    handle([@yield, id, dets, [], %{}])
+  def handle([@yield, id, opts]) do
+    handle([@yield, id, opts, [], %{}])
   end
 
   @impl true
-  def handle([@yield, id, dets, arg_l]) do
-    handle([@yield, id, dets, arg_l, %{}])
+  def handle([@yield, id, opts, arg_l]) do
+    handle([@yield, id, opts, arg_l, %{}])
   end
 
   @impl true
-  def handle([@yield, id, dets, arg_l, arg_kw]) do
-    {[{:next_event, :internal, :yield}], id, {:update, :yield, {:yield, id, dets, arg_l, arg_kw}}}
+  def handle([@yield, id, opts, arg_l, arg_kw]) do
+    {[{:next_event, :internal, :yield}], id,
+     {:update, :yield, %Yield{request_id: id, options: opts, arg_list: arg_l, arg_kw: arg_kw}}}
   end
 end
diff --git a/lib/roles/peer.ex b/lib/roles/peer.ex
index 23552fe..ed33e8b 100644
--- a/lib/roles/peer.ex
+++ b/lib/roles/peer.ex
@@ -40,11 +40,11 @@ defmodule Wampex.Roles.Peer do
   defmodule Challenge do
     @moduledoc false
     @enforce_keys [:auth_method]
-    defstruct [:auth_method, options: %{}]
+    defstruct [:auth_method, extra: %{}]
 
     @type t :: %__MODULE__{
             auth_method: String.t(),
-            options: %{}
+            extra: %{}
           }
   end
 
@@ -117,8 +117,8 @@ defmodule Wampex.Roles.Peer do
   end
 
   @spec challenge(Challenge.t()) :: Wampex.message()
-  def challenge(%Challenge{auth_method: am, options: opts}) do
-    [@challenge, am, opts]
+  def challenge(%Challenge{auth_method: am, extra: ext}) do
+    [@challenge, am, ext]
   end
 
   @spec goodbye(Goodbye.t()) :: Wampex.message()
@@ -132,14 +132,21 @@ defmodule Wampex.Roles.Peer do
   end
 
   @impl true
-  def handle([@hello, realm, dets]) do
-    {[{:next_event, :internal, :hello}], nil, {:update, :hello, {:hello, realm, dets}}}
+  def handle([@hello, realm, opts]) do
+    {[{:next_event, :internal, :hello}], nil,
+     {:update, :hello,
+      %Hello{
+        realm: realm,
+        options: opts,
+        roles: get_in(opts, ["roles"]),
+        agent: get_in(opts, ["agent"])
+      }}}
   end
 
   @impl true
-  def handle([@authenticate, sig, dets]) do
+  def handle([@authenticate, sig, extra]) do
     {[{:next_event, :internal, :authenticate}], nil,
-     {:update, :authenticate, {:authenticate, sig, dets}}}
+     {:update, :authenticate, %Authenticate{signature: sig, extra: extra}}}
   end
 
   @impl true
@@ -159,7 +166,8 @@ defmodule Wampex.Roles.Peer do
 
   @impl true
   def handle([@challenge, auth_method, extra]) do
-    {[{:next_event, :internal, :challenge}], nil, {:update, :challenge, {auth_method, extra}}}
+    {[{:next_event, :internal, :challenge}], nil,
+     {:update, :challenge, %Challenge{auth_method: auth_method, extra: extra}}}
   end
 
   @impl true
diff --git a/lib/roles/publisher.ex b/lib/roles/publisher.ex
index d31d7ca..3f0d71b 100644
--- a/lib/roles/publisher.ex
+++ b/lib/roles/publisher.ex
@@ -12,9 +12,10 @@ defmodule Wampex.Roles.Publisher do
   defmodule Publish do
     @moduledoc false
     @enforce_keys [:topic]
-    defstruct [:topic, arg_list: [], arg_kw: %{}, options: %{}]
+    defstruct [:request_id, :topic, arg_list: [], arg_kw: %{}, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             topic: binary(),
             arg_list: list(any()),
             arg_kw: map(),
diff --git a/lib/roles/subscriber.ex b/lib/roles/subscriber.ex
index db3e86f..8bda154 100644
--- a/lib/roles/subscriber.ex
+++ b/lib/roles/subscriber.ex
@@ -4,6 +4,7 @@ defmodule Wampex.Roles.Subscriber do
   """
 
   alias Wampex.Role
+  alias Wampex.Roles.Broker.Event
   @behaviour Role
 
   @subscribe 32
@@ -15,9 +16,10 @@ defmodule Wampex.Roles.Subscriber do
   defmodule Subscribe do
     @moduledoc false
     @enforce_keys [:topic]
-    defstruct [:topic, options: %{}]
+    defstruct [:request_id, :topic, options: %{}]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             topic: binary(),
             options: map()
           }
@@ -26,9 +28,10 @@ defmodule Wampex.Roles.Subscriber do
   defmodule Unsubscribe do
     @moduledoc false
     @enforce_keys [:subscription_id]
-    defstruct [:subscription_id]
+    defstruct [:request_id, :subscription_id]
 
     @type t :: %__MODULE__{
+            request_id: integer() | nil,
             subscription_id: integer()
           }
   end
@@ -76,6 +79,13 @@ defmodule Wampex.Roles.Subscriber do
   @impl true
   def handle([@event, sub_id, pub_id, dets, arg_l, arg_kw]) do
     {[{:next_event, :internal, :event}], nil,
-     {:update, :event, {:event, sub_id, pub_id, dets, arg_l, arg_kw}}}
+     {:update, :event,
+      %Event{
+        subscription_id: sub_id,
+        publication_id: pub_id,
+        details: dets,
+        arg_list: arg_l,
+        arg_kw: arg_kw
+      }}}
   end
 end
diff --git a/lib/wampex.ex b/lib/wampex.ex
index bdf7f14..ce0bab5 100644
--- a/lib/wampex.ex
+++ b/lib/wampex.ex
@@ -2,63 +2,38 @@ defmodule Wampex do
   @moduledoc """
   Types for wampex
   """
+  alias Wampex.Roles
+  alias Roles.{Broker, Callee, Caller, Dealer, Peer, Publisher, Subscriber}
+  alias Broker.{Event, Subscribed, Unsubscribed, Published}
+  alias Callee.{Register, Unregister, Yield}
+  alias Caller.{Call, Cancel}
+  alias Dealer.{Registered, Unregistered, Result, Invocation}
+  alias Peer.{Hello, Welcome, Challenge, Goodbye, Authenticate, Abort, Error}
+
   @type message_part :: integer() | binary() | map() | list()
   @type message :: nonempty_list(message_part())
   @type arg_list :: [] | nonempty_list(any())
   @type arg_keyword :: map()
 
-  @type hello :: {:hello, realm :: String.t(), details :: map()}
-
-  @type authenticate :: {:authenticate, signature :: binary(), details :: map()}
-
-  @type call ::
-          {:call, request_id :: integer(), details :: map(), procedure :: String.t(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-
-  @type yield ::
-          {:yield, request_id :: integer(), details :: map(), arg_list :: arg_list(),
-           arg_keywords :: arg_keyword()}
-
-  @type publish ::
-          {:publish, request_id :: integer(), details :: map(), topic :: String.t(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-
-  @type register ::
-          {:register, request_id :: integer(), details :: map(), procedure :: String.t()}
-
-  @type unregister :: {:unregister, request_id :: integer(), registration_id :: integer()}
-
-  @type unsubscribe ::
-          {:unsubscribe, request_id :: integer(), id :: integer()}
-
-  @type subscribe ::
-          {:subscribe, request_id :: integer(), details :: map(), topic :: String.t()}
-  @type invocation ::
-          {:invocation, request_id :: integer(), registration_id :: integer(), details :: map(),
-           arg_list :: arg_list(), arg_keywords :: arg_keyword()}
-  @type event ::
-          {:event, subscription_id :: integer(), publication_id :: integer(), details :: map(),
-           arg_list :: arg_list(), arg_keyword :: arg_keyword()}
   @type error ::
           {:error, reason :: binary()}
-          | {:error, type :: integer(), error :: binary(), details :: map(),
-             arg_list :: arg_list(), arg_keyword :: arg_keyword()}
+          | Error.t()
   @type messages ::
-          publish()
-          | hello()
-          | authenticate()
-          | unsubscribe()
-          | subscribe()
-          | invocation()
-          | register()
-          | unregister()
-          | call()
-          | yield()
-          | error()
-          | event()
+          Publish.t()
+          | Hello.t()
+          | Authenticate.t()
+          | Unsubscribe.t()
+          | Subscribe.t()
+          | Invocation.t()
+          | Register.t()
+          | Unregister.t()
+          | Call.t()
+          | Yield.t()
+          | Error.t()
+          | Event.t()
 
   @type handle_response ::
           {:ok, integer()}
-          | {:ok, details :: map(), arg_list :: arg_list(), arg_keyword :: arg_keyword()}
+          | {:ok, details :: map(), arg_list :: arg_list(), arg_kw :: arg_keyword()}
           | {:update, atom(), messages()}
 end