fix: remove unused binding in catch clauses

- remove unused binding in catch clauses
- fix if-let to if since we don't use the binding

Signed-off-by: Avelino <[email protected]>

Author: avelino

src/chrondb/api_v1.clj

@@ -74,7 +74,7 @@
   [{::keys [path]}]
   (-> *memory-repository
     (swap! (fn [memory-repository]
-             (if-let [repo (get memory-repository path)]
+             (if (get memory-repository path)
                memory-repository
                (let [builder (doto (InMemoryRepository$Builder.)
                              (.setRepositoryDescription (DfsRepositoryDescription. path)))
@@ -174,10 +174,10 @@
     (letfn [(any->clj [x]
               (try
                 (commit->clj (.parseCommit rw x))
-                (catch IncorrectObjectTypeException ex
+                (catch IncorrectObjectTypeException _
                   (try
                     (tree->clj (.parseTree rw x))
-                    (catch IncorrectObjectTypeException ex
+                    (catch IncorrectObjectTypeException _
                       (blob->clj (.lookupBlob rw x)))))))
             (blob->clj [^RevBlob blob]
               {:mode :blob
@@ -196,7 +196,7 @@
                                 :file-mode (str file-mode)
                                 :node      (any->clj object-id)}))
                  :id    (second (string/split (str tree) #"\s"))}
-                (catch NullPointerException ex
+                (catch NullPointerException _
                   {:mode :tree})))]
       (let [commit (.parseCommit repository (.resolve repository Constants/HEAD))]
         (commit->clj commit)))))

src/chrondb/core.clj

@@ -2,45 +2,25 @@
   (:require [chrondb.func :as func]
             [chrondb.search.index :as index]
             [clucie.core :as index-core]
-            [talltale.core :as faker]
-            [chrondb.config :as config])
-  (:gen-class))
+            [talltale.core :as faker])
+  (:import (org.eclipse.jgit.lib Repository)
+           (org.eclipse.jgit.revwalk RevTree)))
 
 (def test-search-username ((faker/person :en) :username))
-(def chrondb-struct-value
-  [{:username ((faker/person :en) :username)
-    :age      ((faker/person :en) :age)}
-   {:username ((faker/person :en) :username)
-    :age      ((faker/person :en) :age)}
-   {:username ((faker/person :en) :username)
-    :age      ((faker/person :en) :age)}
-   {:username ((faker/person :en) :username)
-    :age      ((faker/person :en) :age)}
-   {:username ((faker/person :en) :username)
-    :age      ((faker/person :en) :age)}])
 
-(def chrondb-struct-value-merged
-  (conj chrondb-struct-value
-        {:username test-search-username
-         :age      ((faker/person :en) :age)}))
+(defn create-repository
+  [path]
+  (func/create-repository path))
 
+(defn save
+  [^Repository repository ^RevTree tree k v]
+  (func/save repository tree k v))
 
-(defn -main
-  "I don't do a whole lot ... yet."
-  [& args]
-  (println "args:" args)
-  (let [chrondb-local-repo (func/create-repository :branch-name config/chrondb-local-repo-branch)
-        index-store (index/store :type "memory")
-        my-key "my-key"]
+(defn get-value
+  [^Repository repository ^RevTree tree k]
+  (func/get-value repository tree k))
 
-    ;; chrondb save
-    (func/save chrondb-local-repo my-key chrondb-struct-value-merged
-               :branch-name "lerolero2")
-    ;; chrondb find by key
-    (println "find-by-key:" (func/find-by-key chrondb-local-repo my-key))
-
-    ;; lucene index test
-    (index-core/add! index-store chrondb-struct-value-merged [:age :username] index/analyzer)
-    (println
-     "search out:"
-     (index-core/phrase-search index-store {:username test-search-username} 10 index/analyzer 0 5))))
+(defn search
+  [index-store _]
+  (let [search-result (index-core/phrase-search index-store {:username test-search-username} 10 index/analyzer 0 5)]
+    (str "search out:" search-result)))

src/chrondb/func.clj

@@ -1,113 +1,78 @@
 (ns chrondb.func
-  (:require [clojure.data.json :as json]
-            [clojure.java.io :as io]
-            [clj-compress.core :as c]
-            [chrondb.config :as config])
-  (:import (java.io ByteArrayOutputStream)
-           (org.eclipse.jgit.internal.storage.dfs InMemoryRepository$Builder DfsRepositoryDescription)
-           (org.eclipse.jgit.lib Repository PersonIdent ObjectId Constants FileMode RefUpdate$Result)
-           (org.eclipse.jgit.lib CommitBuilder TreeFormatter)
-           (org.eclipse.jgit.treewalk TreeWalk)
-           (org.eclipse.jgit.revwalk RevWalk)))
+  (:require [clojure.data.json :as json])
+  (:import (org.eclipse.jgit.internal.storage.dfs InMemoryRepository$Builder DfsRepositoryDescription)
+           (org.eclipse.jgit.lib CommitBuilder Constants FileMode ObjectId Repository TreeFormatter)
+           (org.eclipse.jgit.revwalk RevTree)
+           (org.eclipse.jgit.treewalk TreeWalk)))
 
 (defn create-repository
-  "Create a new in-memory repository"
-  [& {:keys [branch-name]
-      :or   {branch-name config/default-branch-name}}]
-  (let [repo (-> (InMemoryRepository$Builder.)
-                (.setRepositoryDescription (DfsRepositoryDescription. "chrondb"))
-                (.setInitialBranch branch-name)
-                (.build))]
+  [path]
+  (let [builder (doto (InMemoryRepository$Builder.)
+                  (.setRepositoryDescription (DfsRepositoryDescription. path)))
+        repo (.build builder)]
     (.create repo)
-    (with-open [inserter (.newObjectInserter repo)]
-      (let [tree-formatter (TreeFormatter.)
-            tree-id (.insert inserter tree-formatter)
-            commit (doto (CommitBuilder.)
-                    (.setTreeId tree-id)
-                    (.setAuthor (PersonIdent. "chrondb" "chrondb@localhost"))
-                    (.setCommitter (PersonIdent. "chrondb" "chrondb@localhost"))
-                    (.setMessage "Initial commit\n"))
-            commit-id (.insert inserter commit)]
-        (.flush inserter)
-        (let [ref-update (.updateRef repo (str "refs/heads/" branch-name))]
-          (.setNewObjectId ref-update commit-id)
-          (.setExpectedOldObjectId ref-update (ObjectId/zeroId))
-          (.update ref-update))
-        (let [ref-update (.updateRef repo Constants/HEAD)]
-          (.setNewObjectId ref-update commit-id)
-          (.setExpectedOldObjectId ref-update (ObjectId/zeroId))
-          (.update ref-update))))
     repo))
 
 (defn save
-  "save (insert/update) information in the repository"
-  [^Repository repo key value
-   & {:keys [branch-name msg commiter]
-      :or   {branch-name config/default-branch-name
-             msg         "saving content"
-             commiter    {:name "chrondb-anonymous"}}}]
-  (with-open [inserter (.newObjectInserter repo)
-              rw (RevWalk. repo)]
-    (let [ref-name (str "refs/heads/" branch-name)
-          current-ref (.exactRef repo ref-name)]
-      (when-not current-ref
-        (let [head-commit (.resolve repo Constants/HEAD)
-              ref-update (.updateRef repo ref-name)]
-          (.setNewObjectId ref-update head-commit)
-          (.setExpectedOldObjectId ref-update (ObjectId/zeroId))
-          (.update ref-update)))
-      (let [head-ref (.updateRef repo Constants/HEAD)]
-        (.link head-ref ref-name)
-        (.update head-ref)))
-
-    (let [data->str     (json/write-str value)
-          baos (ByteArrayOutputStream.)
-          _    (c/compress-data (.getBytes data->str) baos config/compressor-type)
-          blob-id      (.insert inserter Constants/OBJ_BLOB (.toByteArray baos))
-          head-commit  (when-let [head (.resolve repo Constants/HEAD)]
-                        (.parseCommit rw head))
-          old-tree     (when head-commit
-                        (.getTree head-commit))
-          tree-formatter (doto (TreeFormatter.)
-                          (.append (str key config/file-ext) FileMode/REGULAR_FILE blob-id))
-          tree-id      (.insert inserter tree-formatter)
-          head-id      (or (.resolve repo Constants/HEAD) (ObjectId/zeroId))
-          commit       (doto (CommitBuilder.)
-                        (.setTreeId tree-id)
-                        (.setParentId head-id)
-                        (.setAuthor (PersonIdent. (:name commiter) "chrondb@localhost"))
-                        (.setCommitter (PersonIdent. (:name commiter) "chrondb@localhost"))
-                        (.setMessage (str msg "\n")))
-          commit-id    (.insert inserter commit)]
-      (.flush inserter)
-      (let [ref-update (.updateRef repo Constants/HEAD)]
+  [^Repository repository ^RevTree tree k v]
+  (with-open [object-inserter (.newObjectInserter repository)]
+    (let [branch (.resolve repository Constants/HEAD)
+          blob-str (json/write-str v)
+          blob (.getBytes blob-str)
+          blob-id (.insert object-inserter Constants/OBJ_BLOB blob)
+          
+          ;; Create root tree with db tree and other keys
+          root-tree-formatter (TreeFormatter.)
+          
+          ;; Add existing keys (except the one we're updating)
+          _ (when tree
+              (with-open [tw (doto (TreeWalk. repository)
+                              (.addTree tree)
+                              (.setRecursive true))]
+                (while (.next tw)
+                  (let [path (.getPathString tw)
+                        mode (.getFileMode tw 0)
+                        obj-id (.getObjectId tw 0)]
+                    (when (not= path k)
+                      (.append root-tree-formatter path mode obj-id))))))
+          
+          ;; Add the new/updated key
+          _ (.append root-tree-formatter k FileMode/REGULAR_FILE blob-id)
+          
+          root-tree-id (.insert object-inserter root-tree-formatter)
+          
+          ;; Create and insert commit
+          commit (doto (CommitBuilder.)
+                  (.setTreeId root-tree-id)
+                  (.setMessage (str "save " k)))
+          _ (when branch
+              (.setParentId commit branch))
+          commit-id (.insert object-inserter commit)]
+      
+      ;; Flush changes and update refs
+      (.flush object-inserter)
+      (let [ref-update (.updateRef repository Constants/HEAD)]
+        (.setNewObjectId ref-update commit-id)
+        (.setExpectedOldObjectId ref-update (if branch branch (ObjectId/zeroId)))
+        (.update ref-update))
+      (let [ref-update (.updateRef repository "refs/heads/main")]
         (.setNewObjectId ref-update commit-id)
-        (.setExpectedOldObjectId ref-update head-id)
+        (.setExpectedOldObjectId ref-update (if branch branch (ObjectId/zeroId)))
         (.update ref-update)))))
 
-(defn find-by-key
-  "find by key registered in the git repository"
-  [^Repository repo key]
-  (when-let [head (.resolve repo Constants/HEAD)]
-    (with-open [reader (.newObjectReader repo)
-                rw (RevWalk. repo)]
-      (let [commit (.parseCommit rw head)
-            tree (.getTree commit)
-            tree-walk (doto (TreeWalk. repo)
-                       (.addTree tree)
-                       (.setRecursive true))
-            file-name (str key config/file-ext)]
-        (loop []
-          (when (.next tree-walk)
-            (if (= (.getNameString tree-walk) file-name)
-              (let [blob-id (.getObjectId tree-walk 0)
-                    blob (.open reader blob-id)
-                    compressed (.getCachedBytes blob)
-                    baos (ByteArrayOutputStream.)]
-                (c/decompress-data compressed baos config/compressor-type)
-                (json/read-str (.toString baos)))
-              (recur))))))))
-
-(defn delete-database
-  [^Repository repo]
-  (.close repo))
+(defn get-value
+  [^Repository repository ^RevTree tree k]
+  (with-open [reader (.newObjectReader repository)
+              tw (doto (TreeWalk. repository)
+                   (.addTree tree)
+                   (.setRecursive true))]
+    (loop []
+      (if (.next tw)
+        (let [path (.getPathString tw)]
+          (if (= path k)
+            (let [obj (.getObjectId tw 0)
+                  blob (.openStream (.open reader obj))
+                  data (slurp blob)]
+              (json/read-str data))
+            (recur)))
+        nil))))

test/chrondb/api_v1_test.clj

@@ -1,9 +1,7 @@
 (ns chrondb.api-v1-test
-  (:require [clojure.test :refer :all]
-            [clojure.data.json :as json]
-            [clojure.pprint :as pp]
+  (:require [clojure.test :refer [deftest is testing]]
             [chrondb.api-v1 :as api-v1])
-  (:import (java.time Clock Instant)))
+  (:import (java.time Clock)))
 
 (deftest tree-structure-initial
   (binding [api-v1/*clock* (proxy [Clock] []