@@ -38,52 +38,52 @@

 *** Get the commit id of the master branch for a specific repository:

     #+BEGIN_SRC lisp :exports both :results verbatim

-      (git:in-repository "~/quicklisp/local-projects/cl-git")

-      (git:branch "master") ;; the argument to branch defaults to "master"

+      (co.fwoar.git:in-repository ".")

+      (co.fwoar.git:branch "master") ;; the argument to branch defaults to "master"

     #+END_SRC

     #+RESULTS:

-    : #<LOOSE-REF 657ab33 of ~/git_repos/git.fiddlerwoaroof.com/u/edwlan/cl-git/>

+    : #<LOOSE-REF 63b3f56 of .../u/edwlan/cl-git/>

 *** Show the commit message

     #+BEGIN_SRC lisp :exports both :results verbatim

-      (git:in-repository "~/quicklisp/local-projects/cl-git")

-      (git:component :message (git:branch "master"))

+      (co.fwoar.git:in-repository ".")

+      (co.fwoar.git:component :message (co.fwoar.git:branch "master"))

     #+END_SRC

     #+RESULTS:

-    : feat(blobs): introduce BLOB class

+    : Create CNAME

 *** Show the messages of the commit's parent

     #+BEGIN_SRC lisp :exports both :results verbatim

-      (git:in-repository "~/quicklisp/local-projects/cl-git")

-      (let* ((branch (git:branch "master"))

-             (parents (git:parents branch)))

+      (co.fwoar.git:in-repository ".")

+      (let* ((branch (co.fwoar.git:branch "master"))

+             (parents (co.fwoar.git:parents branch)))

         (mapcar (lambda (it)

-                  (git:component :message it))

+                  (co.fwoar.git:component :message it))

                 parents))

     #+END_SRC

     #+RESULTS:

-    : ("(bump)

+    : ("feat(docs): add docs

     : ")

 *** Show the files in a commit

     - Note taken on [2020-11-15 Sun 01:49] \\

       If the table comes out wrong, =*print-case*= must be =:downcase=

-    #+BEGIN_SRC lisp :exports both :results table :hlines yes

-      (git:in-repository "~/quicklisp/local-projects/cl-git")

-      (list* #("Name" "Mode" "Hash")

+    #+BEGIN_SRC lisp :exports both :results table :hlines yes :post proc

+      (co.fwoar.git:in-repository ".")

+      (list* '("Name" "Mode" "Hash")

              'hline

-             (git:git (branch "master")

-                      (component :tree :entries)

-                      (map (juxt (component :name)

-                                 (component :mode)

-                                 (component :hash)))))

+             (co.fwoar.git:git (branch "master")

+                               (component :tree :entries)

+                               (map (juxt (component :name)

+                                          (component :mode)

+                                          (component :hash)))))

     #+END_SRC

     #+RESULTS:

@@ -93,12 +93,13 @@

     | .gitignore      | 100644 | 8a9fe9f77149f74fed5c05388be8e5ffd4a31678 |

     | .projectile     | 100644 | e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 |

     | LICENSE         | 100644 | 0306819e780fa57dc3bf6b99a0a059670b605ae0 |

-    | README.org      | 100644 | 9889a8a1e253a446de953072db8ee9f13e90b716 |

+    | README.org      | 100644 | a9026cbd36491691fb9e05ea4ee066ca0283a6b7 |

     | branch.lisp     | 100644 | 6ee2b1e254e7895d55ecd534b2fa16267ec14389 |

     | cl-git.asd      | 100644 | 486920e6178e436fa993ce3a2bd23f60827c9fd5 |

     | commit.lisp     | 100644 | d6a83c1a351eb2c0f5315ceddcde37545b7781d6 |

     | delta.lisp      | 100644 | 1417d8b8d172824c38d95791c8b884393db273ae |

     | docker-run      |  40000 | acace4bb63832baa7e69e324e738eda7aae4ac2c |

+    | docs            |  40000 | 696965c69073891cb101697eb7ec97a1bc8a868b |

     | extract.lisp    | 100644 | 4bfb480eb2993cf516fded3adec49483322fdcf4 |

     | git.lisp        | 100644 | bad6f54787369609581669de923afaf378ed4002 |

     | graph.lisp      | 100644 | 31576396aff0fff28f69e0ef84571c0dc8cc43ec |

@@ -116,14 +117,14 @@

     - Note taken on [2020-11-15 Sun 01:49] \\

       If the table comes out wrong, =*print-case*= must be =:downcase=

-    #+BEGIN_SRC lisp :exports both :results table :hlines yes

-      (git:with-repository ("~/quicklisp/local-projects/cl-git/")

-        (let* ((branch (git:branch "master"))

-               (tree (git:tree branch))

-               (tree-entries (git:filter-tree "^.....?[.]lisp" tree)))

+    #+BEGIN_SRC lisp :exports both :results table :hlines yes :post proc

+      (co.fwoar.git:with-repository (".")

+        (let* ((branch (co.fwoar.git:branch "master"))

+               (tree (co.fwoar.git:tree branch))

+               (tree-entries (co.fwoar.git:filter-tree "^.....?[.]lisp" tree)))

           (flet ((component (component)

                    (lambda (it)

-                     (git:component component it))))

+                     (co.fwoar.git:component component it))))

             (list* '("Name" "Mode" "Hash")

                    'hline

                    (mapcar (data-lens:juxt (component :name)

@@ -178,3 +179,12 @@

 ** TODOs

 *** TODO start implementing Pharo-like git integration (read-only first, commits later)

+

+#+name: proc

+#+begin_src emacs-lisp

+  (mapcar (lambda (it)

+            (if (equal it 'HLINE)

+                'hline

+              it))

+          ,*this*)

+#+end_src

similarity index 96%

rename from cl-git.asd

rename to co.fwoar.cl-git.asd

@@ -1,7 +1,7 @@

 ;;; -*- Mode:Lisp; Syntax:ANSI-Common-Lisp; Package: ASDF-USER -*-

 (in-package :asdf-user)

-(defsystem :cl-git

+(defsystem :co.fwoar.cl-git

   :description "A pure-Lisp git implementation"

   :author "Ed L <edward@elangley.org>"

   :license "MIT"

@@ -36,7 +36,7 @@

                ;; stable programmer interface

                (:file "porcelain" :depends-on ("package" "git" "commit"))))

-(defsystem :cl-git/tests

+(defsystem :co.fwoar.cl-git/tests

   :description ""

   :author "Ed L <edward@elangley.org>"

   :license "MIT"

@@ -10,9 +10,9 @@

 (defpackage :cl-git-user

   (:use :cl :fwoar.cl-git))

-(defpackage :git

+(defpackage :co.fwoar.git

   (:use)

   (:export #:show #:branch #:branches #:commit-parents #:in-repository

            #:with-repository #:current-repository #:show-repository #:git

-           #:tree #:contents #:component

-           #:rev-list #:repository))

+           #:tree #:contents #:component #:rev-list #:repository

+           #:parents #:filter-tree))

@@ -8,33 +8,33 @@

 (defvar *git-encoding* :utf-8

   "The encoding to use when parsing git objects")

-(defun git:in-repository (root)

+(defun co.fwoar.git:in-repository (root)

   (setf *git-repository*

         (ensure-repository

          (truename root))))

-(defun git:repository ()

+(defun co.fwoar.git:repository ()

   *git-repository*)

-(defmacro git:with-repository ((root) &body body)

+(defmacro co.fwoar.git:with-repository ((root) &body body)

   `(let ((*git-repository* (ensure-repository ,root)))

      ,@body))

-(defun git:show-repository ()

+(defun co.fwoar.git:show-repository ()

   *git-repository*)

 (defun in-git-package (symbol)

   (intern (symbol-name symbol)

-          :git))

+          :co.fwoar.git))

 (defun handle-list (_1)

   (case (in-git-package (car _1))

-    (git::unwrap `(uiop:nest (car)

-                             (mapcar ,@(cdr _1))))

+    (co.fwoar.git::unwrap `(uiop:nest (car)

+                                      (mapcar ,@(cdr _1))))

     (t (cons (in-git-package (car _1))

              (cdr _1)))))

-(defun git::resolve-refish (it)

+(defun co.fwoar.git::resolve-refish (it)

   (flet ((hash-p (it)

            (and (> (length it) 32)

                 (every (serapeum:op

@@ -50,7 +50,7 @@

          nil))

       ((hash-p it) (ensure-ref it)))))

-(defmacro git:git (&rest commands)

+(defmacro co.fwoar.git:git (&rest commands)

   `(uiop:nest ,@(reverse

                  (funcall (data-lens:<>1

                            (data-lens:over (serapeum:op

@@ -59,20 +59,20 @@

                                                (list (handle-list _1)))))

                            (data-lens:transform-head (serapeum:op

                                                        (etypecase _1

-                                                         (string `(git::resolve-refish ,_1))

+                                                         (string `(co.fwoar.git::resolve-refish ,_1))

                                                          (t _1)))))

                           commands))))

-(defun git::ensure-ref (it)

+(defun co.fwoar.git::ensure-ref (it)

   (ensure-ref it))

-(defun git::decode (it)

+(defun co.fwoar.git::decode (it)

   (babel:octets-to-string it :encoding *git-encoding*))

-(defun git::<<= (fun &rest args)

+(defun co.fwoar.git::<<= (fun &rest args)

   (apply #'mapcan fun args))

-(defmacro git::map (fun list)

+(defmacro co.fwoar.git::map (fun list)

   (alexandria:once-only (list)

     (alexandria:with-gensyms (it)

       `(mapcar ,(if (consp fun)

@@ -83,7 +83,7 @@

                     `',(in-git-package fun))

                ,list))))

-(defmacro git::juxt (&rest args)

+(defmacro co.fwoar.git::juxt (&rest args)

   (let ((funs (butlast args))

         (arg (car (last args))))

     (alexandria:once-only (arg)

@@ -91,7 +91,7 @@

                          `(,@(alexandria:ensure-list f) ,arg))

                        funs)))))

-(defmacro git::pipe (&rest funs)

+(defmacro co.fwoar.git::pipe (&rest funs)

   (let ((funs (reverse (butlast funs)))

         (var (car (last funs))))

     `(uiop:nest ,@(mapcar (lambda (it)

@@ -101,28 +101,28 @@

                           funs)

                 ,var)))

-(defun git::filter (fun &rest args)

+(defun co.fwoar.git::filter (fun &rest args)

   (apply #'remove-if-not fun args))

-(defun git::object (thing)

+(defun co.fwoar.git::object (thing)

   (extract-object thing))

-(defun git:show (object)

+(defun co.fwoar.git:show (object)

   (extract-object object))

-(defun git:contents (object)

-  (git:show object))

+(defun co.fwoar.git:contents (object)

+  (co.fwoar.git:show object))

-(defun git:component (&rest args)

+(defun co.fwoar.git:component (&rest args)

   (let ((component-list (butlast args))

         (target (car (last args))))

     (fwoar.cl-git::component component-list target)))

-(defun git:tree (commit-object)

+(defun co.fwoar.git:tree (commit-object)

   (component :tree

              commit-object))

-(defun git::filter-tree (name-pattern tree)

+(defun co.fwoar.git::filter-tree (name-pattern tree)

   #+lispworks

   (declare (notinline serapeum:string-prefix-p))

   (let* ((tree-entries (component :entries tree))

@@ -132,7 +132,7 @@

                    tree-entries

                    :key #'te-name)))

-(defun git:branch (&optional (branch :master))

+(defun co.fwoar.git:branch (&optional (branch :master))

   #+lispworks

   (declare (notinline serapeum:assocadr))

   (let ((branches (branches *git-repository*)))

@@ -143,16 +143,16 @@

                             branches

                             :test 'equal))))

-(defun git:branches ()

+(defun co.fwoar.git:branches ()

   (branches *git-repository*))

-(defun git::parents (commit)

+(defun co.fwoar.git::parents (commit)

   (mapcar 'ensure-ref

           (component :parents commit)))

-(defun git:commit-parents (commit)

-  (git::parents commit))

+(defun co.fwoar.git:commit-parents (commit)

+  (co.fwoar.git::parents commit))

-(defun git:rev-list (ref-id &optional (limit nil limit-p))

+(defun co.fwoar.git:rev-list (ref-id &optional (limit nil limit-p))

   "Return the commits reachable from the ref."

   (when limit-p

     (rotatef ref-id limit))

@@ -163,7 +163,7 @@

                  accum

                  (destructuring-bind (next . rest) queue

                    (iterate (append rest

-                                    (git::parents next))

+                                    (co.fwoar.git::parents next))

                      (cons next accum)

                      (1+ count))))))

     (iterate (list (ensure-ref ref-id))