Expose hope_kv_list:presence_violations_to_list/1

[hope.git] / src / hope_kv_list.erl

diff --git a/src/hope_kv_list.erl b/src/hope_kv_list.erl
index d9a8177..2000098 100644 (file)
--- a/src/hope_kv_list.erl
+++ b/src/hope_kv_list.erl
@@ -3,6 +3,8 @@
 %%%----------------------------------------------------------------------------
 -module(hope_kv_list).
 
+-include_lib("hope_kv_list.hrl").
+
 -behavior(hope_gen_dictionary).
 
 -export_type(
@@ -22,14 +24,27 @@
     , fold/3
     , of_kv_list/1
     , to_kv_list/1
-    , validate_unique_presence/2  % Assume default optional parameter(s)
-    , validate_unique_presence/3  % Specify optional parameter(s)
+    , find_unique_presence_violations/2  % No optional keys
+    , find_unique_presence_violations/3  % Specify optional keys
+    , validate_unique_presence/2  % No optional keys
+    , validate_unique_presence/3  % Specify optional keys
+    , presence_violations_to_list/1
     ]).
 
 
 -type t(K, V) ::
     [{K, V}].
 
+-type presence_violations(A) ::
+    % This is a hack to effectively parametarize the types of record fields.
+    % IMPORTANT: Make sure that the order of fields matches the definition of
+    % #hope_kv_list_presence_violations
+    { hope_kv_list_presence_violations
+    , [A]  % keys_missing
+    , [A]  % keys_duplicated
+    , [A]  % keys_unsupported
+    }.
+
 -type presence_error(A) ::
       {keys_missing     , [A]}
     | {keys_duplicated  , [A]}
@@ -125,34 +140,61 @@ validate_unique_presence(T, KeysRequired) ->
 -spec validate_unique_presence(t(K, _V), [K], [K]) ->
     hope_result:t(ok, [presence_error(K)]).
 validate_unique_presence(T, KeysRequired, KeysOptional) ->
+    case find_unique_presence_violations(T, KeysRequired, KeysOptional)
+    of  #hope_kv_list_presence_violations
+        { keys_missing     = []
+        , keys_duplicated  = []
+        , keys_unsupported = []
+        } ->
+            {ok, ok}
+    ;   #hope_kv_list_presence_violations{}=Violations ->
+            {error, presence_violations_to_list(Violations)}
+    end.
+
+-spec find_unique_presence_violations(t(K, _V), [K]) ->
+    presence_violations(K).
+find_unique_presence_violations(T, KeysRequired) ->
+    KeysOptional = [],
+    find_unique_presence_violations(T, KeysRequired, KeysOptional).
+
+-spec find_unique_presence_violations(t(K, _V), [K], [K]) ->
+    presence_violations(K).
+find_unique_presence_violations(T, KeysRequired, KeysOptional) ->
     KeysSupported   = KeysRequired ++ KeysOptional,
     KeysGiven       = [K || {K, _V} <- T],
     KeysGivenUnique = lists:usort(KeysGiven),
-    KeysDups        = lists:usort(KeysGiven -- KeysGivenUnique),
+    KeysDuplicated  = lists:usort(KeysGiven -- KeysGivenUnique),
     KeysMissing     = KeysRequired -- KeysGivenUnique,
     KeysUnsupported = KeysGivenUnique -- KeysSupported,
-    case {KeysDups, KeysMissing, KeysUnsupported}
-    of  {[], [], []} ->
-            {ok, ok}
-    ;   {Dups, Missing, Unsupported} ->
-            ErrorDups =
-                case Dups
-                of  []    -> []
-                ;   [_|_] -> [{keys_duplicated, Dups}]
-                end,
-            ErrorMissing =
-                case Missing
-                of  []    -> []
-                ;   [_|_] -> [{keys_missing, Missing}]
-                end,
-            ErrorUnsupported =
-                case Unsupported
-                of  []    -> []
-                ;   [_|_] -> [{keys_unsupported, Unsupported}]
-                end,
-            Errors = ErrorDups ++ ErrorMissing ++ ErrorUnsupported,
-            {error, Errors}
-    end.
+    #hope_kv_list_presence_violations
+    { keys_missing     = KeysMissing
+    , keys_duplicated  = KeysDuplicated
+    , keys_unsupported = KeysUnsupported
+    }.
+
+-spec presence_violations_to_list(presence_violations(K)) ->
+    [presence_error(K)].
+presence_violations_to_list(#hope_kv_list_presence_violations
+{ keys_missing     = KeysMissing
+, keys_duplicated  = KeysDuplicated
+, keys_unsupported = KeysUnsupported
+}) ->
+    ErrorMissing =
+        case KeysMissing
+        of  []    -> []
+        ;   [_|_] -> [{keys_missing, KeysMissing}]
+        end,
+    ErrorDups =
+        case KeysDuplicated
+        of  []    -> []
+        ;   [_|_] -> [{keys_duplicated, KeysDuplicated}]
+        end,
+    ErrorUnsupported =
+        case KeysUnsupported
+        of  []    -> []
+        ;   [_|_] -> [{keys_unsupported, KeysUnsupported}]
+        end,
+    ErrorDups ++ ErrorMissing ++ ErrorUnsupported.
 
 
 %% ============================================================================