✨ Improve code convetion related to changes protocol

Partial work, still pending to make changes to other related
changes definitions

common/src/app/common/files/changes.cljc

@@ -382,13 +382,13 @@
       [:set-group-path [:vector :string]]
       [:set-group-fname :string]]]
 
-    [:move-token-set-before
-     [:map {:title "MoveTokenSetBefore"}
-      [:type [:= :move-token-set-before]]
+    [:move-token-set
+     [:map {:title "MoveTokenSet"}
+      [:type [:= :move-token-set]]
       [:from-path [:vector :string]]
       [:to-path [:vector :string]]
       [:before-path [:maybe [:vector :string]]]
-      [:before-group? [:maybe :boolean]]]]
+      [:before-group [:maybe :boolean]]]]
 
     [:move-token-set-group-before
      [:map {:title "MoveTokenSetGroupBefore"}
@@ -1051,11 +1051,11 @@
                                  (ctob/ensure-tokens-lib)
                                  (ctob/rename-set-group set-group-path set-group-fname)))))
 
-(defmethod process-change :move-token-set-before
-  [data {:keys [from-path to-path before-path before-group?] :as changes}]
+(defmethod process-change :move-token-set
+  [data {:keys [from-path to-path before-path before-group] :as changes}]
   (update data :tokens-lib #(-> %
                                 (ctob/ensure-tokens-lib)
-                                (ctob/move-set from-path to-path before-path before-group?))))
+                                (ctob/move-set from-path to-path before-path before-group))))
 
 (defmethod process-change :move-token-set-group-before
   [data {:keys [from-path to-path before-path before-group?]}]

common/src/app/common/files/changes_builder.cljc

@@ -809,19 +809,19 @@
         (update :undo-changes conj {:type :rename-token-set-group :set-group-path undo-path :set-group-fname undo-fname})
         (apply-changes-local))))
 
-(defn move-token-set-before
+(defn move-token-set
   [changes {:keys [from-path to-path before-path before-group? prev-before-path prev-before-group?] :as opts}]
   (-> changes
-      (update :redo-changes conj {:type :move-token-set-before
+      (update :redo-changes conj {:type :move-token-set
                                   :from-path from-path
                                   :to-path to-path
                                   :before-path before-path
-                                  :before-group? before-group?})
-      (update :undo-changes conj {:type :move-token-set-before
+                                  :before-group before-group?})
+      (update :undo-changes conj {:type :move-token-set
                                   :from-path to-path
                                   :to-path from-path
                                   :before-path prev-before-path
-                                  :before-group? prev-before-group?})
+                                  :before-group prev-before-group?})
       (apply-changes-local)))
 
 (defn move-token-set-group-before

common/src/app/common/logic/tokens.cljc

@@ -1,11 +1,21 @@
+;; This Source Code Form is subject to the terms of the Mozilla Public
+;; License, v. 2.0. If a copy of the MPL was not distributed with this
+;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
+;;
+;; Copyright (c) KALEIDOS INC
+
 (ns app.common.logic.tokens
   (:require
    [app.common.files.changes-builder :as pcb]
    [app.common.types.tokens-lib :as ctob]))
 
 (defn generate-update-active-sets
-  "Copy the active sets from the currently active themes and move them to the hidden token theme and update the theme with `update-theme-fn`.
-  Use this for managing sets active state without having to modify a user created theme (\"no themes selected\" state in the ui)."
+  "Copy the active sets from the currently active themes and move them
+  to the hidden token theme and update the theme with
+  `update-theme-fn`.
+
+  Use this for managing sets active state without having to modify a
+  user created theme (\"no themes selected\" state in the ui)."
   [changes tokens-lib update-theme-fn]
   (let [prev-active-token-themes (ctob/get-active-theme-paths tokens-lib)
         active-token-set-names   (ctob/get-active-themes-set-names tokens-lib)
@@ -21,7 +31,8 @@
                              hidden-token-theme))))
 
 (defn generate-toggle-token-set
-  "Toggle a token set at `set-name` in `tokens-lib` without modifying a user theme."
+  "Toggle a token set at `set-name` in `tokens-lib` without modifying a
+  user theme."
   [changes tokens-lib set-name]
   (generate-update-active-sets changes tokens-lib #(ctob/toggle-set % set-name)))
 
@@ -121,9 +132,9 @@
 (defn generate-move-token-set
   "Create changes for dropping a token set or token set.
   Throws for impossible moves."
-  [changes tokens-lib drop-opts]
-  (if-let [drop-opts' (calculate-move-token-set-or-set-group tokens-lib drop-opts)]
-    (pcb/move-token-set-before changes drop-opts')
+  [changes tokens-lib params]
+  (if-let [params (calculate-move-token-set-or-set-group tokens-lib params)]
+    (pcb/move-token-set changes params)
     changes))
 
 (defn generate-move-token-set-group

common/src/app/common/types/tokens_lib.cljc

@@ -945,14 +945,21 @@ Will return a value that matches this schema:
     (let [prefixed-from-path (set-full-path->set-prefixed-full-path from-path)
           prev-set (get-in sets prefixed-from-path)]
       (if (instance? TokenSet prev-set)
-        (let [prefixed-to-path (set-full-path->set-prefixed-full-path to-path)
-              prefixed-before-path (when before-path
-                                     (if before-group?
-                                       (mapv add-set-path-group-prefix before-path)
-                                       (set-full-path->set-prefixed-full-path before-path)))
+        (let [prefixed-to-path
+              (set-full-path->set-prefixed-full-path to-path)
+
+              prefixed-before-path
+              (when before-path
+                (if before-group?
+                  (mapv add-set-path-group-prefix before-path)
+                  (set-full-path->set-prefixed-full-path before-path)))
+
+              set
+              (assoc prev-set :name (join-set-path to-path))
+
+              reorder?
+              (= prefixed-from-path prefixed-to-path)
 
-              set (assoc prev-set :name (join-set-path to-path))
-              reorder? (= prefixed-from-path prefixed-to-path)
               sets'
               (if reorder?
                 (d/oreorder-before sets
@@ -964,6 +971,7 @@ Will return a value that matches this schema:
                       (d/oassoc-in-before sets prefixed-before-path prefixed-to-path set)
                       (d/oassoc-in sets prefixed-to-path set))
                     (d/dissoc-in prefixed-from-path)))]
+
           (TokensLib. sets'
                       (if reorder?
                         themes

common/test/common_tests/types/tokens_lib_test.cljc

@@ -84,52 +84,65 @@
     (t/is (thrown-with-msg? #?(:cljs js/Error :clj Exception) #"expected valid params for token-set"
                             (ctob/make-token-set params)))))
 
-(t/deftest move-token-set
-  (t/testing "flat"
-    (let [tokens-lib (-> (ctob/make-tokens-lib)
-                         (ctob/add-set (ctob/make-token-set :name "A"))
-                         (ctob/add-set (ctob/make-token-set :name "B"))
-                         (ctob/add-set (ctob/make-token-set :name "Move")))
-          move (fn [from-path to-path before-path before-group?]
-                 (->> (ctob/move-set tokens-lib from-path to-path before-path before-group?)
-                      (ctob/get-ordered-set-names)
-                      (into [])))]
-      (t/testing "move to top"
-        (t/is (= ["Move" "A" "B"] (move ["Move"] ["Move"] ["A"] false))))
+(t/deftest move-token-set-flat
+  (let [tokens-lib (-> (ctob/make-tokens-lib)
+                       (ctob/add-set (ctob/make-token-set :name "A"))
+                       (ctob/add-set (ctob/make-token-set :name "B"))
+                       (ctob/add-set (ctob/make-token-set :name "Move")))
+        move (fn [from-path to-path before-path before-group?]
+               (->> (ctob/move-set tokens-lib from-path to-path before-path before-group?)
+                    (ctob/get-ordered-set-names)
+                    (into [])))]
+    (t/testing "move to top"
+      (t/is (= ["Move" "A" "B"] (move ["Move"] ["Move"] ["A"] false))))
 
-      (t/testing "move in-between"
-        (t/is (= ["A" "Move" "B"] (move ["Move"] ["Move"] ["B"] false))))
+    (t/testing "move in-between"
+      (t/is (= ["A" "Move" "B"] (move ["Move"] ["Move"] ["B"] false))))
 
-      (t/testing "move to bottom"
-        (t/is (= ["A" "B" "Move"] (move ["Move"] ["Move"] nil false))))))
+    (t/testing "move to bottom"
+      (t/is (= ["A" "B" "Move"] (move ["Move"] ["Move"] nil false))))))
 
-  (t/testing "nested"
-    (let [tokens-lib (-> (ctob/make-tokens-lib)
-                         (ctob/add-set (ctob/make-token-set :name "Foo/Baz"))
-                         (ctob/add-set (ctob/make-token-set :name "Foo/Bar"))
-                         (ctob/add-set (ctob/make-token-set :name "Foo")))
-          move (fn [from-path to-path before-path before-group?]
-                 (->> (ctob/move-set tokens-lib from-path to-path before-path before-group?)
-                      (ctob/get-ordered-set-names)
-                      (into [])))]
-      (t/testing "move outside of group"
-        (t/is (= ["Foo/Baz" "Bar" "Foo"] (move ["Foo" "Bar"] ["Bar"] ["Foo"] false)))
-        (t/is (= ["Bar" "Foo/Baz" "Foo"] (move ["Foo" "Bar"] ["Bar"] ["Foo" "Baz"] true)))
-        (t/is (= ["Foo/Baz" "Foo" "Bar"] (move ["Foo" "Bar"] ["Bar"] nil false))))
+(t/deftest move-token-set-nested
+  (let [tokens-lib (-> (ctob/make-tokens-lib)
+                       (ctob/add-set (ctob/make-token-set :name "Foo/Baz"))
+                       (ctob/add-set (ctob/make-token-set :name "Foo/Bar"))
+                       (ctob/add-set (ctob/make-token-set :name "Foo")))
+        move (fn [from-path to-path before-path before-group?]
+               (->> (ctob/move-set tokens-lib from-path to-path before-path before-group?)
+                    (ctob/get-ordered-set-names)
+                    (into [])))]
+    (t/testing "move outside of group"
+      (t/is (= ["Foo/Baz" "Bar" "Foo"] (move ["Foo" "Bar"] ["Bar"] ["Foo"] false)))
+      (t/is (= ["Bar" "Foo/Baz" "Foo"] (move ["Foo" "Bar"] ["Bar"] ["Foo" "Baz"] true)))
+      (t/is (= ["Foo/Baz" "Foo" "Bar"] (move ["Foo" "Bar"] ["Bar"] nil false))))
 
-      (t/testing "move inside of group"
-        (t/is (= ["Foo/Foo" "Foo/Baz" "Foo/Bar"] (move ["Foo"] ["Foo" "Foo"] ["Foo" "Baz"] false)))
-        (t/is (= ["Foo/Baz" "Foo/Bar" "Foo/Foo"] (move ["Foo"] ["Foo" "Foo"] nil false))))))
+    (t/testing "move inside of group"
+      (t/is (= ["Foo/Foo" "Foo/Baz" "Foo/Bar"] (move ["Foo"] ["Foo" "Foo"] ["Foo" "Baz"] false)))
+      (t/is (= ["Foo/Baz" "Foo/Bar" "Foo/Foo"] (move ["Foo"] ["Foo" "Foo"] nil false))))))
 
-  ;; FIXME
-  (t/testing "updates theme set names"
-    (let [tokens-lib (-> (ctob/make-tokens-lib)
-                         (ctob/add-set (ctob/make-token-set :name "Foo/Bar/Baz"))
-                         (ctob/add-set (ctob/make-token-set :name "Other"))
-                         (ctob/add-theme (ctob/make-token-theme :name "Theme"
-                                                                :sets #{"Foo/Bar/Baz"}))
-                         (ctob/move-set ["Foo" "Bar" "Baz"] ["Other/Baz"] nil nil))]
-      (t/is (= #{"Other/Baz"} (:sets (ctob/get-theme tokens-lib "" "Theme")))))))
+
+(t/deftest move-token-set-nested-2
+  (let [tokens-lib (-> (ctob/make-tokens-lib)
+                       (ctob/add-set (ctob/make-token-set :name "a/b"))
+                       (ctob/add-set (ctob/make-token-set :name "a/a"))
+                       (ctob/add-set (ctob/make-token-set :name "b/a"))
+                       (ctob/add-set (ctob/make-token-set :name "b/b")))
+        move (fn [from-path to-path before-path before-group?]
+               (->> (ctob/move-set tokens-lib from-path to-path before-path before-group?)
+                    (ctob/get-ordered-set-names)
+                    (vec)))]
+    (t/testing "move within group"
+      (t/is (= ["a/b" "a/a" "b/a" "b/b"] (vec (ctob/get-ordered-set-names tokens-lib))))
+      (t/is (= ["a/a" "a/b" "b/a" "b/b"] (move ["a" "b"] ["a" "b"] nil true))))))
+
+(t/deftest move-token-set-nested-3
+  (let [tokens-lib (-> (ctob/make-tokens-lib)
+                       (ctob/add-set (ctob/make-token-set :name "Foo/Bar/Baz"))
+                       (ctob/add-set (ctob/make-token-set :name "Other"))
+                       (ctob/add-theme (ctob/make-token-theme :name "Theme"
+                                                              :sets #{"Foo/Bar/Baz"}))
+                       (ctob/move-set ["Foo" "Bar" "Baz"] ["Other/Baz"] nil nil))]
+    (t/is (= #{"Other/Baz"} (:sets (ctob/get-theme tokens-lib "" "Theme"))))))
 
 (t/deftest move-token-set-group
   (t/testing "reordering"

frontend/src/app/main/data/tokens.cljs

@@ -252,6 +252,8 @@
                       :level :error
                       :timeout 9000})))))))
 
+;; FIXME: add schema for params
+
 (defn drop-token-set-group [drop-opts]
   (ptk/reify ::drop-token-set-group
     ptk/WatchEvent
@@ -265,17 +267,21 @@
           (rx/of
            (drop-error (ex-data e))))))))
 
-(defn drop-token-set [drop-opts]
+;; FIXME: add schema for params
+
+(defn drop-token-set
+  [params]
   (ptk/reify ::drop-token-set
     ptk/WatchEvent
     (watch [it state _]
       (try
-        (when-let [changes (clt/generate-move-token-set (pcb/empty-changes it) (get-tokens-lib state) drop-opts)]
+        (let [tokens-lib (get-tokens-lib state)
+              changes    (-> (pcb/empty-changes it)
+                             (clt/generate-move-token-set tokens-lib params))]
           (rx/of (dch/commit-changes changes)
                  (wtu/update-workspace-tokens)))
-        (catch :default e
-          (rx/of
-           (drop-error (ex-data e))))))))
+        (catch :default cause
+          (rx/of (drop-error (ex-data cause))))))))
 
 (defn- create-token-with-set
   "A special case when a first token is created and no set exists"

frontend/src/app/main/ui/workspace/tokens/sets.cljs

@@ -368,13 +368,13 @@
         (mf/use-fn
          (mf/deps collapsed-paths)
          (fn [tree-index position data]
-           (let [props {:from-index (:index data)
-                        :to-index tree-index
-                        :position position
-                        :collapsed-paths collapsed-paths}]
+           (let [params {:from-index (:index data)
+                         :to-index tree-index
+                         :position position
+                         :collapsed-paths collapsed-paths}]
              (if (:is-group data)
-               (st/emit! (dt/drop-token-set-group props))
-               (st/emit! (dt/drop-token-set props))))))
+               (st/emit! (dt/drop-token-set-group params))
+               (st/emit! (dt/drop-token-set params))))))
 
         on-toggle-collapse
         (mf/use-fn