Refactors models and packages

src/com/github/tavlima/nubank/reward/invitations/controller.clj

@@ -1,13 +1,17 @@
 (ns com.github.tavlima.nubank.reward.invitations.controller
-  (require [clojure.zip :as z]
+  (require [com.github.tavlima.nubank.reward.tree.domain
+            [location :as z]
+            [tree :as t]]
+           [com.github.tavlima.nubank.reward.invitations.domain
+            [user :as u]
+            [usertree :as ut]]
            [com.github.tavlima.nubank.reward
             [util :as util]
-            [compare :as compare]]
-           [com.github.tavlima.nubank.reward.invitations.domain :as domain]))
+            [compare :as compare]]))
 
 (defn- ^{:testable true} update-score [loc level]
   (if (>= level 0)
-    (z/edit loc domain/add-score (util/exp 1/2 level))
+    (z/update loc #(u/addScore % (util/exp 1/2 level)))
     loc))
 
 (defn- ^{:testable true} update-parents-scores [zipper]
@@ -19,60 +23,65 @@
         updated-loc
         (recur parent-loc (inc level))))))
 
-(defn- ^{:testable true} verify! [inviter]
-  (z/root (if (domain/verified? (z/node inviter))
-            inviter
-            (let [updatedInviter (z/edit inviter #(merge % {:verified true}))
-                  parent (z/up updatedInviter)]
-              (if (nil? parent)
-                updatedInviter
-                (update-parents-scores parent))))))
+(defn- ^{:testable true} verify! [loc]
+  (-> (if (u/verified? (z/node loc))
+        loc
+        (let [updatedLoc (z/update loc u/verify!)
+              parentLoc (z/up updatedLoc)]
+          (if (nil? parentLoc)
+            updatedLoc
+            (update-parents-scores parentLoc))))
+      (z/root)
+      (z/node)))
 
 (defn- ^{:testable true} add-user
   [tree inviterId inviteeId]
-  (let [inviter (-> (domain/zipper (:root tree))
-                    (domain/find-first-by-id inviterId))
-        updatedParent (if (domain/has-user? tree inviteeId)
-                        inviter
-                        (z/append-child inviter (domain/create-user inviteeId)))]
-    (-> updatedParent
-        (verify!)
-        (domain/create-tree (conj (:users tree) inviteeId)))))
+  (cond (t/empty? tree)
+        (-> tree
+            (t/replaceRoot (u/create-user inviterId))
+            (t/add inviterId)
+            (recur inviterId inviteeId))
+
+        ((complement t/containsUid?) tree inviterId)
+        tree
+
+        :else
+        (let [inviterLoc (t/findFirst tree inviterId)
+              updatedInviterLoc (if (t/containsUid? tree inviteeId)
+                                  inviterLoc
+                                  (z/append-child inviterLoc (u/create-user inviteeId)))
+                verifiedInviter (verify! updatedInviterLoc)]
+            (-> (t/replaceRoot tree verifiedInviter)
+                (t/add inviteeId)))))
 
 (defn- ^{:testable true} scores-map [zipper]
   (reduce (fn [result node]
             (merge result {(:id node) (:score node)}))
           {}
-          (domain/nodes zipper)))
+          (ut/users zipper)))
 
 (defn- ^{:testable true} by-score-id
   [x y]
   ;; by score (DESC) -> by id (ASC)
   (compare/cc-cmp [(:score y) (:id x)]
-               [(:score x) (:id y)]))
+                  [(:score x) (:id y)]))
 
 (defn create-tree []
-  (domain/create-tree))
+  (t/create-tree))
 
 (defn get-user [tree userId]
-  (if (domain/has-user? tree userId)
-    (-> (domain/find-first-by-id (domain/zipper (:root tree)) userId)
+  (if (t/containsUid? tree userId)
+    (-> (t/findFirst tree userId)
         (z/node))
     nil))
 
 (defn invite [tree inviter invitee]
-  (let [populated-tree (if (or (nil? tree)
-                               (nil? (:root tree)))
-                         (domain/create-tree-with-user inviter)
-                         tree)]
-    (if ((complement domain/has-user?) populated-tree inviter)
-      populated-tree
-      (add-user populated-tree inviter invitee))))
+  (if (nil? tree)
+    (recur (t/create-tree) inviter invitee)
+    (add-user tree inviter invitee)))
 
 (defn ranking [tree]
   (if (or (nil? tree) (nil? (:root tree)))
     {}
-    (-> (:root tree)
-        (domain/zipper)
-        (domain/nodes [:id :score])
+    (-> (t/nodes tree [:id :score])
         ((partial sort by-score-id)))))

src/com/github/tavlima/nubank/reward/invitations/domain/user.clj

@@ -0,0 +1,32 @@
+(ns com.github.tavlima.nubank.reward.invitations.domain.user
+  (:require [com.github.tavlima.nubank.reward.tree.domain
+             [location :as l]
+             [treenode :as n]
+             [zippable :as z]]))
+
+(defprotocol User
+  (addScore [user delta])
+  (verified? [user])
+  (verify! [user])
+  (addInvited [user invited]))
+
+(defrecord UserImpl [id score invited verified]
+  n/TreeNode
+  (match? [_ matchId] (= id matchId))
+  (uid [_] id)
+  (fields [node ks]
+    (select-keys node ks))
+
+  z/Zippable
+  (children [_] invited)
+  (make [user children] (assoc user :invited children))
+  (zipper [user] (l/->LocationImpl user [:nil] [:nil] [:nil]))
+
+  User
+  (addScore [user delta] (assoc user :score (+ score delta)))
+  (verified? [_] verified)
+  (verify! [user] (assoc user :verified true))
+  (addInvited [user invitedUser] (assoc user :invited (conj invited invitedUser))))
+
+(defn create-user [id]
+  (->UserImpl id 0 [] false))

src/com/github/tavlima/nubank/reward/invitations/domain/usertree.clj

@@ -0,0 +1,11 @@
+(ns com.github.tavlima.nubank.reward.invitations.domain.usertree
+  (:require [com.github.tavlima.nubank.reward.tree.domain.tree :as t])
+  (:import (com.github.tavlima.nubank.reward.tree.domain.tree TreeImpl)))
+
+(defprotocol UserTree
+  (users [tree]))
+
+(extend-protocol UserTree
+  TreeImpl
+  (users [tree]
+    (t/nodes tree [:id :score :verified])))

src/com/github/tavlima/nubank/reward/invitations/port.clj

@@ -1,14 +1,14 @@
 (ns com.github.tavlima.nubank.reward.invitations.port
-  (require [com.github.tavlima.nubank.reward.invitations.altcontroller :as controller]))
+  (require [com.github.tavlima.nubank.reward.invitations.controller :as c]))
 
 (defn invite [tree inviterId inviteeId]
-  (controller/invite tree inviterId inviteeId))
+  (c/invite tree inviterId inviteeId))
 
 (defn create-tree []
-  (controller/create-tree))
+  (c/create-tree))
 
 (defn ranking [tree]
-  (controller/ranking tree))
+  (c/ranking tree))
 
 (defn get-user [tree userId]
-  (controller/get-user tree userId))
+  (c/get-user tree userId))