style(outliner): update code

src/test/frontend/modules/outliner/generator.cljs

@@ -0,0 +1,66 @@
+(ns frontend.modules.outliner.generator
+  (:require [nano-id.core :as nano]
+            [frontend.modules.outliner.tree-test :as tt]
+            [frontend.db.conn :as conn]
+            [frontend.modules.outliner.tree :as tree]
+            [datascript.core :as d]))
+
+
+(defn generate-parent-relation
+  [number root-id]
+  (let [node-seq (repeatedly number nano/nano-id)
+        root {:id root-id}
+        parent-coll (atom [root])]
+    (doseq [n node-seq]
+      (let [size (count @parent-coll)
+            parent-id (->> (dec size)
+                        (rand-int)
+                        (get @parent-coll)
+                        :id)
+            new-node {:id n :parent parent-id}]
+        (swap! parent-coll conj new-node)))
+    @parent-coll))
+
+(defn generate-tree-node
+  [node-id parent-relation]
+  (let [children-record (filter #(= (:parent %) node-id) parent-relation)]
+    (if (seq children-record)
+      (let [rest-parent-relation
+            (remove #(= (:parent %) node-id) parent-relation)
+            children
+            (keep #(generate-tree-node (:id %) rest-parent-relation) children-record)]
+        {:id node-id :children children})
+      {:id node-id :children nil})))
+
+(defn generate-random-tree
+  [node-num]
+  (let [root-id "2"]
+    (->>
+      (generate-parent-relation node-num root-id)
+      (generate-tree-node root-id)
+      (tt/build-db-records))))
+
+(defn generate-random-block
+  [num]
+  (dotimes [i num]
+    (prn i)
+    (let [block (tt/build-block (nano/nano-id))]
+      (tree/-save block))))
+
+(comment
+  (let [fresh-db (conn/create-outliner-db)]
+    (reset! conn/outliner-db @fresh-db)
+    (generate-random-tree 10))
+
+  conn/outliner-db
+
+  (generate-random-block 10e4)
+
+  (generate-random-tree 10)
+
+  (d/q '[:find (count ?id) .
+         :where
+         [?e :block/id ?id]]
+    @conn/outliner-db)
+
+  )

src/test/frontend/modules/outliner/tree_test.cljs

@@ -7,6 +7,7 @@
             [frontend.modules.outliner.utils :as outliner-u]
             [frontend.modules.outliner.core]
             [frontend.fixtures :as fixtures]
+            [nano-id.core :as nano]
             [cljs-run-test]))
 
 (use-fixtures :each
@@ -24,7 +25,7 @@
                           (outliner-u/->block-lookup-ref parent-id)
                           :block/left-id
                           (outliner-u/->block-lookup-ref left-id)
-                          :block/content (str id)})
+                          :block/content (apply str (repeat 100 (str id)))})
              (remove #(nil? (val %)))
              (into {}))]
      (outliner-u/->Block m))))
@@ -52,9 +53,11 @@
               (tree/-save block)
               (when (seq queue)
                 (build (first queue) (rest queue)))))]
-    (let [root (assoc tree-record :left nil :parent nil)]
+    (let [root (assoc tree-record :left "1" :parent "1")]
+      (tree/-save (build-block "1"))
       (build root '()))))
 
+
 (def tree [1 [[2 [[3 [[4]
                       [5]]]
                   [6 [[7 [[8]]]]]
@@ -386,3 +389,5 @@
                        [15]]]
                   [16 [[17]]]]]]
             @result)))))
+
+