Allow resolving git repo from subdir

Currently if the kmono workspace is a subdirectory of a git repo then
kmono will fail to properly interact with the git repository.

This patch contains a fix which ensures the repository is resolved
upwards from the current working directory (or repository root).

Author: julienvincent

packages/kmono-git/resources/META-INF/clj-kondo.exports/k16.kmono/git/config.edn

@@ -0,0 +1 @@
+{:lint-as {k16.kmono.git/with-repo clojure.core/with-open}}

packages/kmono-git/src/k16/kmono/git.clj

@@ -1,26 +1,31 @@
 (ns k16.kmono.git
   (:import
    [java.io File]
-   [org.eclipse.jgit.api Git]
-   [org.eclipse.jgit.errors RepositoryNotFoundException]))
+   [org.eclipse.jgit.errors RepositoryNotFoundException]
+   [org.eclipse.jgit.lib RepositoryBuilder]))
 
 (set! *warn-on-reflection* true)
 
 (def ^:dynamic ^:private *repo* nil)
 
-(defmacro with-open-repo [repo-path f]
-  `(if-let [[git# repo#] (var-get #'k16.kmono.git/*repo*)]
-     (~f git# repo#)
-     (try (with-open [git# (Git/open (File. (str ~repo-path)))]
-            (let [repo# (Git/.getRepository git#)]
-              (binding [k16.kmono.git/*repo* [git# repo#]]
-                (~f git# repo#))))
-          (catch RepositoryNotFoundException ex#
-            (throw (ex-info "Project is not in a git repository"
-                            {:type :kmono/no-git-repository
-                             :path (str ~repo-path)}
-                            ex#))))))
+(defn- with-repo* [repo-path f]
+  (if *repo*
+    (f *repo*)
+    (try (with-open [repo (-> (RepositoryBuilder.)
+                              (RepositoryBuilder/.findGitDir (File. repo-path))
+                              RepositoryBuilder/.readEnvironment
+                              RepositoryBuilder/.build)]
+           (binding [*repo* repo]
+             (f repo)))
+         (catch RepositoryNotFoundException ex
+           (throw (ex-info "Project is not in a git repository"
+                           {:type :kmono/no-git-repository
+                            :path (str repo-path)}
+                           ex))))))
 
-(defmacro with-pre-open-repo [repo-path & body]
-  `(with-open-repo ~repo-path
-     (fn [_# _#] ~@body)))
+(defmacro with-repo [[var repo-path] & body]
+  (let [fn-name '-with-git]
+    `(let [f# (fn ~fn-name [git#]
+                (let [~var git#]
+                  ~@body))]
+       (#'k16.kmono.git/with-repo* ~repo-path f#))))

packages/kmono-git/src/k16/kmono/git/commit.clj

@@ -3,7 +3,6 @@
    [clojure.string :as str]
    [k16.kmono.git :as git])
   (:import
-   [java.io File]
    [org.eclipse.jgit.api Git LogCommand]
    [org.eclipse.jgit.lib
     AbbreviatedObjectId
@@ -56,21 +55,19 @@
   "Returns the current commit (HEAD) of the repository at `repo`.
 
    Returns `nil` if the commit cannot be resolved."
-  [^String repo]
-  (with-open [git (Git/open (File. repo))]
-    (let [repository (Git/.getRepository git)]
-      (some-> (Repository/.resolve repository Constants/HEAD)
-              (ObjectId/.getName)))))
+  [^String repo-path]
+  (git/with-repo [repo repo-path]
+    (some-> (Repository/.resolve repo Constants/HEAD)
+            (ObjectId/.getName))))
 
 (defn get-current-commit-short
   "Like [[get-current-commit]] but returns the abbreviated commit sha instead"
-  [^String repo]
-  (with-open [git (Git/open (File. repo))]
-    (let [repository (Git/.getRepository git)]
-      (with-open [reader (Repository/.newObjectReader repository)]
-        (some->> (Repository/.resolve repository Constants/HEAD)
-                 (ObjectReader/.abbreviate reader)
-                 (AbbreviatedObjectId/.name))))))
+  [^String repo-path]
+  (git/with-repo [repo repo-path]
+    (with-open [reader (Repository/.newObjectReader repo)]
+      (some->> (Repository/.resolve repo Constants/HEAD)
+               (ObjectReader/.abbreviate reader)
+               (AbbreviatedObjectId/.name)))))
 
 (defn- commit->map [^RevCommit commit]
   (let [full (RevCommit/.getFullMessage commit)
@@ -90,16 +87,16 @@
 (defn find-commits-since
   "Find all commits since a given `ref` (or all, if excluded) and optionally
    filter by the commits which affect the provided `subdir`."
-  [^String repo {:keys [ref subdir]}]
-  (git/with-open-repo repo
-    (fn with-open-repo [git repo]
-      (let [log (Git/.log git)]
-        (when ref
-          (let [since (resolve-commit-id repo ref)
-                head (resolve-commit-id repo Constants/HEAD)]
-            (LogCommand/.addRange log since head)))
+  [^String repo-path {:keys [ref subdir]}]
+  (git/with-repo [repo repo-path]
+    (let [git (Git. repo)
+          log (Git/.log git)]
+      (when ref
+        (let [since (resolve-commit-id repo ref)
+              head (resolve-commit-id repo Constants/HEAD)]
+          (LogCommand/.addRange log since head)))
 
-        (when subdir
-          (LogCommand/.addPath log subdir))
+      (when subdir
+        (LogCommand/.addPath log subdir))
 
-        (mapv commit->map (LogCommand/.call log))))))
+      (mapv commit->map (LogCommand/.call log)))))

packages/kmono-git/src/k16/kmono/git/files.clj

@@ -1,9 +1,9 @@
 (ns k16.kmono.git.files
   (:require
-   [clojure.string :as str])
+   [clojure.string :as str]
+   [k16.kmono.git :as git])
   (:import
-   [java.io ByteArrayOutputStream File]
-   [org.eclipse.jgit.api Git]
+   [java.io ByteArrayOutputStream]
    [org.eclipse.jgit.diff DiffEntry DiffFormatter]
    [org.eclipse.jgit.lib Constants Repository]))
 
@@ -12,11 +12,9 @@
 (defn find-changed-files-since
   "Return a seq of changed file paths since `ref` up to HEAD. If `subdir` is
    provided, only include files within that subdir."
-  [^String repo {:keys [ref subdir]}]
-  (with-open [git (Git/open (File. repo))]
-    (let [repo (Git/.getRepository git)
-
-          start-commit (Repository/.resolve repo ref)
+  [^String repo-path {:keys [ref subdir]}]
+  (git/with-repo [repo repo-path]
+    (let [start-commit (Repository/.resolve repo ref)
           end-commit (Repository/.resolve repo Constants/HEAD)
 
           subdir (when subdir

packages/kmono-git/src/k16/kmono/git/tags.clj

@@ -1,6 +1,7 @@
 (ns k16.kmono.git.tags
+  (:require
+   [k16.kmono.git :as git])
   (:import
-   java.io.File
    org.eclipse.jgit.api.Git
    org.eclipse.jgit.api.ListTagCommand
    org.eclipse.jgit.api.TagCommand
@@ -26,40 +27,40 @@
    first)"
   ([^String repo-path] (get-sorted-tags repo-path Constants/HEAD))
   ([^String repo-path rev]
-   (with-open [git (Git/open (File. repo-path))
-               repo (.getRepository git)
-               walk (RevWalk. repo)]
-     (let [rev (.resolve repo rev)]
-       (when (nil? rev)
-         (throw (ex-info (str "Cannot resolve rev: " rev) {:rev rev})))
+   (git/with-repo [repo repo-path]
+     (with-open [walk (RevWalk. repo)]
+       (let [rev (.resolve repo rev)
+             git (Git. repo)]
+         (when (nil? rev)
+           (throw (ex-info (str "Cannot resolve rev: " rev) {:rev rev})))
 
-       (let [^RevCommit rev-commit (RevWalk/.parseCommit walk rev)
-             tags (into []
-                        (keep (fn [^Ref ref]
-                                (let [obj-id (Ref/.getObjectId ref)
-                                      any-object (RevWalk/.parseAny walk obj-id)
-                                      ;; If annotated tag, unwrap to commit
-                                      tag-commit (cond
-                                                   (instance? RevTag any-object)
-                                                   (->> any-object
-                                                        (RevTag/.getObject)
-                                                        (RevWalk/.parseCommit walk))
+         (let [^RevCommit rev-commit (RevWalk/.parseCommit walk rev)
+               tags (into []
+                          (keep (fn [^Ref ref]
+                                  (let [obj-id (Ref/.getObjectId ref)
+                                        any-object (RevWalk/.parseAny walk obj-id)
+                                        ;; If annotated tag, unwrap to commit
+                                        tag-commit (cond
+                                                     (instance? RevTag any-object)
+                                                     (->> any-object
+                                                          (RevTag/.getObject)
+                                                          (RevWalk/.parseCommit walk))
 
-                                                   (instance? RevCommit any-object)
-                                                   any-object
+                                                     (instance? RevCommit any-object)
+                                                     any-object
 
-                                                   :else nil)]
-                                  (when (and tag-commit
-                                             (RevWalk/.isMergedInto walk
-                                                                    tag-commit
-                                                                    rev-commit))
-                                    [(shorten-tag-name (.getName ref))
-                                     (RevCommit/.getCommitTime tag-commit)]))))
-                        (-> git Git/.tagList ListTagCommand/.call))]
+                                                     :else nil)]
+                                    (when (and tag-commit
+                                               (RevWalk/.isMergedInto walk
+                                                                      tag-commit
+                                                                      rev-commit))
+                                      [(shorten-tag-name (.getName ref))
+                                       (RevCommit/.getCommitTime tag-commit)]))))
+                          (-> git Git/.tagList ListTagCommand/.call))]
 
-         (into []
-               (map first)
-               (sort-by second #(compare %2 %1) tags)))))))
+           (into []
+                 (map first)
+                 (sort-by second #(compare %2 %1) tags))))))))
 
 (defn- resolve-object
   [^Repository repo ref]
@@ -81,8 +82,8 @@
                                [:tags [:sequential :string]]]
                   :nil]}
   [^String repo-root {:keys [ref annotated tags]}]
-  (with-open [git (Git/open (File. repo-root))]
-    (let [repo (Git/.getRepository git)
+  (git/with-repo [repo repo-root]
+    (let [git (Git. repo)
           obj (resolve-object repo ref)]
       (doseq [tag tags]
         (let [cmd (Git/.tag git)]

packages/kmono-git/test/k16/kmono/git_test.clj

@@ -0,0 +1,13 @@
+(ns k16.kmono.git-test
+  (:require
+   [babashka.fs :as fs]
+   [clojure.test :refer [deftest is use-fixtures]]
+   [k16.kmono.git.commit :as git.commit]
+   [k16.kmono.test.helpers.repo :refer [*repo* with-test-repo] :as helpers.repo]))
+
+(use-fixtures :each with-test-repo)
+
+(deftest open-repo-subdir-test
+  (let [dir (fs/file *repo* "subdir")]
+    (fs/create-dir dir)
+    (is (string? (git.commit/get-current-commit (str dir))))))

packages/kmono-version/src/k16/kmono/version.clj

@@ -70,7 +70,7 @@
 
 (defn- -resolve-package-changes-since
   [project-root packages rev-fn]
-  (git/with-pre-open-repo project-root
+  (git/with-repo [_ project-root]
     (into {}
           (core.thread/batch
            (fn find-commits [[pkg-name pkg]]