russel/cl-git function documentation

cl-git-function-doc.mk

CL-GIT:AMBIGUOUS-ERROR
  [symbol]

AMBIGUOUS-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:AMBIGUOUS-ERROR>:
  Class precedence-list: AMBIGUOUS-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:AUTHOR
  [symbol]

AUTHOR names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the author's signature of OBJECT.
    
    A signature is a list with the keys :NAME :EMAIL and :TIME.  The :NAME
    and :EMAIL values are strings, and the :TIME value is LOCAL-TIME
    timestamp.

  Method-combination: STANDARD
  Methods:
    (AUTHOR (COMMIT))
      Documentation:
        Given a commit return the commit author's signature.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BARE-P
  [symbol]

BARE-P names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the repository is bare.
  Method-combination: STANDARD
  Methods:
    (BARE-P (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BAREREPO-ERROR
  [symbol]

BAREREPO-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:BAREREPO-ERROR>:
  Class precedence-list: BAREREPO-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:BASIC-ERROR
  [symbol]

BASIC-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:BASIC-ERROR>:
  Class precedence-list: BASIC-ERROR, SIMPLE-ERROR, SIMPLE-CONDITION,
                         ERROR, SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: SIMPLE-ERROR
  Direct subclasses: CONNECTION-ERROR, UNKNOWN-ERROR, STOP-ITERATION,
                     PASSTHROUGH, MERGE-CONFLICT-ERROR,
                     INVALID-SPEC-ERROR, NON-FAST-FORWARD-ERROR,
                     UNMERGED-ERROR, ORPHANEDHEAD-ERROR, BAREREPO-ERROR,
                     USER-ERROR, BUFFER-ERROR, AMBIGUOUS-ERROR, EXISTS,
                     NOT-FOUND
  Direct slots:
    MESSAGE
      Initargs: :MESSAGE
      Initform: 'NIL
      Readers: ERROR-MESSAGE
      Writers: (SETF ERROR-MESSAGE)
    CODE
      Initargs: :CODE
      Initform: 'NIL
      Readers: ERROR-CODE
      Writers: (SETF ERROR-CODE)
    CLASS
      Initargs: :CLASS
      Initform: 'NIL
      Readers: ERROR-CLASS
      Writers: (SETF ERROR-CLASS)

CL-GIT:BINARY-P
  [symbol]

BINARY-P names a generic function:
  Lambda-list: (BLOB)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the contents of the blob is binary.
  Method-combination: STANDARD
  Methods:
    (BINARY-P (BLOB))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BIND-GIT-COMMITS
  [symbol]

BIND-GIT-COMMITS names a macro:
  Lambda-list: ((BINDINGS REPOSITORY-OR-ODB) &BODY BODY)
  Documentation:
    Lookup commits specified in the bindings.  The bindings syntax is
    similar to the LET syntax except instead of needing to specify an
    initial form key arguments are used.  Atleast one key arguments SHA or
    HEAD must be specified.  SHA is a hash of the commit.  HEAD is a full
    ref path.
  Source file: /home/fv/Code/CL/cl-git/src/commit.lisp

CL-GIT:BLOB
  [symbol]

BLOB names the standard-class #<STANDARD-CLASS CL-GIT:BLOB>:
  Documentation:
    A git blob.
  Class precedence-list: BLOB, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  Direct subclasses: TREE-BLOB
  No direct slots.

CL-GIT:BLOB-CONTENT
  [symbol]

BLOB-CONTENT names a generic function:
  Lambda-list: (BLOB)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the content of the blob BLOB as an array of UNSIGNED-BYTE's
  Method-combination: STANDARD
  Methods:
    (BLOB-CONTENT (BLOB))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BLOB-SIZE
  [symbol]

BLOB-SIZE names a generic function:
  Lambda-list: (BLOB)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the size of the blob in bytes.
  Method-combination: STANDARD
  Methods:
    (BLOB-SIZE (BLOB))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BRANCH-P
  [symbol]

BRANCH-P names a generic function:
  Lambda-list: (REFERENCE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the reference is within the git heads namespace.
  Method-combination: STANDARD
  Methods:
    (BRANCH-P (STRING))
    (BRANCH-P (REFERENCE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:BUFFER-ERROR
  [symbol]

BUFFER-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:BUFFER-ERROR>:
  Class precedence-list: BUFFER-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:CLONE-REPOSITORY
  [symbol]

CLONE-REPOSITORY names a generic function:
  Lambda-list: (URL PATH &KEY CREDENTIALS)
  Argument precedence order: (URL PATH)
  Derived type: (FUNCTION (T T &KEY (:CREDENTIALS T)) *)
  Documentation:
    Clone a repository from URL to PATH. CREDENTIALS
  Method-combination: STANDARD
  Methods:
    (CLONE-REPOSITORY (STRING PATHNAME))
    (CLONE-REPOSITORY (STRING STRING))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:COMMIT
  [symbol]

COMMIT names the standard-class #<STANDARD-CLASS CL-GIT:COMMIT>:
  Documentation:
    Commit objects link the state of the tree with a
    description.  Commits contain a description of the author, commit
    author and a message about the commit.  They also contain state
    information about the current tree and links to any parent commits.
    Commits that have more then one parent are considered to be merges.
  Class precedence-list: COMMIT, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  Direct subclasses: TREE-COMMIT
  No direct slots.

CL-GIT:COMMIT-TREE
  [symbol]

COMMIT-TREE names a generic function:
  Lambda-list: (COMMIT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the TREE object of the commit.
  Method-combination: STANDARD
  Methods:
    (COMMIT-TREE (COMMIT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:COMMITTER
  [symbol]

COMMITTER names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the committer's signature of OBJECT.
    
    A signature is a list with the keys :NAME :EMAIL and :TIME.  The :NAME
    and :EMAIL values are strings, and the :TIME value is LOCAL-TIME
    timestamp.
  Method-combination: STANDARD
  Methods:
    (COMMITTER (COMMIT))
    (COMMITTER (REFLOG-ENTRY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:CONFIG
  [symbol]

CONFIG names the standard-class #<STANDARD-CLASS CL-GIT:CONFIG>:
  Class precedence-list: CONFIG, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:CONNECTION-ERROR
  [symbol]

CONNECTION-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:CONNECTION-ERROR>:
  Class precedence-list: CONNECTION-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:DIFF
  [symbol]

DIFF names a generic function:
  Lambda-list: (OBJECT-OLD OBJECT-NEW &OPTIONAL OPTIONS)
  Argument precedence order: (OBJECT-OLD OBJECT-NEW)
  Derived type: (FUNCTION (T T &OPTIONAL T) *)
  Documentation:
    Diff two objects.
  Method-combination: STANDARD
  Methods:
    (DIFF (COMMIT COMMIT))
    (DIFF (COMMIT INDEX))
    (DIFF (TREE INDEX))
    (DIFF (TREE TREE))
    (DIFF (REPOSITORY INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:DIFF-DELTAS-COUNT
  [symbol]

DIFF-DELTAS-COUNT names a generic function:
  Lambda-list: (DIFF-LIST)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (DIFF-DELTAS-COUNT (DIFF-LIST))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:DIFF-DELTAS-SUMMARY
  [symbol]

DIFF-DELTAS-SUMMARY names a generic function:
  Lambda-list: (DIFF-LIST)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (DIFF-DELTAS-SUMMARY (DIFF-LIST))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:EMPTY-P
  [symbol]

EMPTY-P names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the repository is empty and contains no
    references.
  Method-combination: STANDARD
  Methods:
    (EMPTY-P (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ENTRIES
  [symbol]

ENTRIES names a generic function:
  Lambda-list: (OBJECT &KEY START END)
  Derived type: (FUNCTION (T &KEY (:START T) (:END T)) *)
  Documentation:
    Returns the elements of the collection OBJECT as a
    list.  The start and end keyword arguments allow to retrieve a subset
    of all elements.  All entries with index satisfying
    
       START <= INDEX < END
    
    are returned.  If END is not specified or nil, no END condition
    exists.  start defaults to 0.
  Method-combination: STANDARD
  Methods:
    (ENTRIES (REFLOG))
    (ENTRIES (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ENTRY-BY-INDEX
  [symbol]

ENTRY-BY-INDEX names a generic function:
  Lambda-list: (OBJECT INDEX)
  Argument precedence order: (OBJECT INDEX)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Returns the element at position INDEX from the
    collection OBJECT.
  Method-combination: STANDARD
  Methods:
    (ENTRY-BY-INDEX (TREE T))
    (ENTRY-BY-INDEX (REFLOG T))
    (ENTRY-BY-INDEX (INDEX T))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ENTRY-COUNT
  [symbol]

ENTRY-COUNT names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the number elements in the collection OBJECT.

  Method-combination: STANDARD
  Methods:
    (ENTRY-COUNT (TREE))
    (ENTRY-COUNT (REFLOG))
    (ENTRY-COUNT (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:EXISTS
  [symbol]

EXISTS names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:EXISTS>:
  Class precedence-list: EXISTS, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:FILEMODE
  [symbol]

FILEMODE names a generic function:
  Lambda-list: (SB-PCL::OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (FILEMODE (TREE-LINK))
      Documentation:
        automatically generated reader method
    (FILEMODE (TREE-COMMIT))
      Documentation:
        automatically generated reader method
    (FILEMODE (TREE-TREE))
      Documentation:
        automatically generated reader method
    (FILEMODE (TREE-BLOB))
      Documentation:
        automatically generated reader method
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:FILENAME
  [symbol]

FILENAME names a generic function:
  Lambda-list: (SB-PCL::OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (FILENAME (PATHNAME-MIXIN))
      Documentation:
        automatically generated reader method
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:FREE
  [symbol]

FREE names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    TODO
  Method-combination: STANDARD
  Methods:
    (FREE (GIT-POINTER))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:FULL-NAME
  [symbol]

FULL-NAME names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the name of OBJECT, as a string.
    
    What exactly the name is depends on the type of the object.

  Method-combination: STANDARD
  Methods:
    (FULL-NAME (REMOTE))
      Documentation:
        The name of the remote.
    (FULL-NAME (TAG))
    (FULL-NAME (REFERENCE))
      Documentation:
        Return the full path to the REFERENCE as a STRING.
    (FULL-NAME (GIT-OBJECT))
  Source file: SYS:SRC;PCL;DLISP3.LISP

CL-GIT:GET-OBJECT
  [symbol]

GET-OBJECT names a generic function:
  Lambda-list: (CLASS ID/NAME REPOSITORY)
  Argument precedence order: (CLASS ID/NAME REPOSITORY)
  Derived type: (FUNCTION (T T T) *)
  Documentation:
    Return an object of type CLASS from the object database.  The
    lookup will use either an oid or a name to find the object.
  Method-combination: STANDARD
  Methods:
    (GET-OBJECT ((EQL ODB-OBJECT) T REPOSITORY))
    (GET-OBJECT ((EQL ODB-OBJECT) T ODB))
    (GET-OBJECT ((EQL REMOTE) T T))
    (GET-OBJECT ((EQL TAG) T T))
    (GET-OBJECT ((EQL COMMIT) T T))
    (GET-OBJECT ((EQL TREE) T T))
    (GET-OBJECT ((EQL BLOB) T T))
    (GET-OBJECT ((EQL REFERENCE) T T))
      Documentation:
        Find a reference by its full name e.g.: ref/heads/master
        Note that this function name clashes with the generic lookup function.
        We need to figure this out by using the type argument to do dispatch.
    (GET-OBJECT ((EQL OBJECT) T T))

CL-GIT:GET-TREE
  [symbol]

CL-GIT:GIT-CONFIG
  [symbol]

GIT-CONFIG names a generic function:
  Lambda-list: (OBJECT &KEY LEVEL)
  Derived type: (FUNCTION (T &KEY (:LEVEL T)) *)
  Documentation:
    Open a git config.  LEVEL can be used to limit the
    git config to a specific level.  Possible levels are :HIGHEST-LEVEL
    :SYSTEM :XDG :GLOBAL or :LOCAL
  Method-combination: STANDARD
  Methods:
    (GIT-CONFIG (CONFIG))
      Documentation:
        Returns the key value pairs in the config as an association list.
    (GIT-CONFIG (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:GIT-CONFIG-OPEN-LEVEL
  [symbol]

CL-GIT:GIT-HAS-LOG
  [symbol]

GIT-HAS-LOG names a compiled function:
  Lambda-list: (REPO REFERENCE)
  Derived type: (FUNCTION (T T) (VALUES BOOLEAN &OPTIONAL))
  Documentation:
    Returns t if there exists a REFLOG for the reference.
  Source file: /home/fv/Code/CL/cl-git/src/references.lisp

CL-GIT:GIT-VALUES
  [symbol]

GIT-VALUES names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    TODO
  Method-combination: STANDARD
  Methods:
    (GIT-VALUES (CONFIG))
      Documentation:
        Returns the key value pairs in the config as an association list.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:HEAD-DETACHED-P
  [symbol]

HEAD-DETACHED-P names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns T if the HEAD in the repository is detached, in other words,
    the HEAD reference is not a symbolic reference to a branch, but a
    direct commit.
  Method-combination: STANDARD
  Methods:
    (HEAD-DETACHED-P (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:HEAD-ORPHANED-P
  [symbol]

HEAD-ORPHANED-P names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns t if the HEAD points to a commit that
    doesn't exist.  This function is depreciated and will be removed in
    0.21.0.
  Method-combination: STANDARD
  Methods:
    (HEAD-ORPHANED-P (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:HEAD-P
  [symbol]

HEAD-P names a generic function:
  Lambda-list: (BRANCH)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns t is the current HEAD points to this branch.
    This means that this is the branch that is checked out.
  Method-combination: STANDARD
  Methods:
    (HEAD-P (REFERENCE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:HEAD-UNBORN-P
  [symbol]

HEAD-UNBORN-P names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns T if the HEAD points to a commit that
    doesn't exist.
  Method-combination: STANDARD
  Methods:
    (HEAD-UNBORN-P (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INDEX
  [symbol]

INDEX names the standard-class #<STANDARD-CLASS CL-GIT:INDEX>:
  Documentation:
    A git index
  Class precedence-list: INDEX, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:INDEX-ADD-FILE
  [symbol]

INDEX-ADD-FILE names a generic function:
  Lambda-list: (PATH INDEX)
  Argument precedence order: (PATH INDEX)
  Derived type: (FUNCTION (T T) *)
  Documentation:
    Adds the PATH to the INDEX.
  Method-combination: STANDARD
  Methods:
    (INDEX-ADD-FILE (LIST INDEX))
    (INDEX-ADD-FILE (PATHNAME INDEX))
    (INDEX-ADD-FILE (STRING INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INDEX-CLEAR
  [symbol]

INDEX-CLEAR names a generic function:
  Lambda-list: (INDEX)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Clear contents of the INDEX removing all entries.
    Changes need to be written back to disk to take effect.
  Method-combination: STANDARD
  Methods:
    (INDEX-CLEAR (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INDEX-CONFLICTS-P
  [symbol]

INDEX-CONFLICTS-P names a generic function:
  Lambda-list: (INDEX)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the index contains any conflicting
      changes.
  Method-combination: STANDARD
  Methods:
    (INDEX-CONFLICTS-P (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INDEX-ENTRIES
  [symbol]

CL-GIT:INDEX-REFRESH
  [symbol]

CL-GIT:INDEX-TO-TREE
  [symbol]

INDEX-TO-TREE names a generic function:
  Lambda-list: (INDEX)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Write the current index to a new tree object.
  Method-combination: STANDARD
  Methods:
    (INDEX-TO-TREE (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INDEX-WRITE
  [symbol]

INDEX-WRITE names a generic function:
  Lambda-list: (INDEX)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Write the INDEX back to the file system.
  Method-combination: STANDARD
  Methods:
    (INDEX-WRITE (INDEX))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INIT-REPOSITORY
  [symbol]

INIT-REPOSITORY names a generic function:
  Lambda-list: (PATH/NAME &KEY BARE)
  Derived type: (FUNCTION (T &KEY (:BARE T)) *)
  Documentation:
    Create a new Git repository.  PATH/NAME can be either an instance
    of a STRING or a PATHNAME.  A truthful value for the key BARE will
    init a repository that does not have a local checkout, it's normally
    appropriate for the basename of the path to end in '.git'.  A
    REPOSITORY instance is returned.
  Method-combination: STANDARD
  Methods:
    (INIT-REPOSITORY (PATHNAME))
    (INIT-REPOSITORY (STRING))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:INVALID-SPEC-ERROR
  [symbol]

INVALID-SPEC-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:INVALID-SPEC-ERROR>:
  Class precedence-list: INVALID-SPEC-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:LIBGIT2-FEATURES
  [symbol]

LIBGIT2-FEATURES names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL *)
  Documentation:
    Return a list of the libgit2 capabilities, possible values in the
    list return values are :THREADS and :HTTPS.
  Source file: /home/fv/Code/CL/cl-git/src/libgit2.lisp

CL-GIT:LIBGIT2-VERSION
  [symbol]

LIBGIT2-VERSION names a compiled function:
  Lambda-list: ()
  Derived type: (FUNCTION NIL (VALUES CONS &OPTIONAL))
  Documentation:
    Returns the libgit2 C-library version number as a list of three integers,
    (major minor revision).
  Source file: /home/fv/Code/CL/cl-git/src/libgit2.lisp

CL-GIT:LIST-OBJECTS
  [symbol]

LIST-OBJECTS names a generic function:
  Lambda-list: (CLASS REPOSITORY &KEY TEST TEST-NOT)
  Argument precedence order: (CLASS REPOSITORY)
  Derived type: (FUNCTION (T T &KEY (:TEST T) (:TEST-NOT T)) *)
  Method-combination: STANDARD
  Methods:
    (LIST-OBJECTS ((EQL :OID) REPOSITORY))
    (LIST-OBJECTS ((EQL :OID) ODB))
    (LIST-OBJECTS ((EQL REMOTE) T))
    (LIST-OBJECTS ((EQL TAG) T))
      Documentation:
        Returns a list of tag for the repository.  If the tag is an
        annotated tag then a TAG object will be returned, otherwise it will be
        a ref with the in the tag namespace.
    (LIST-OBJECTS ((EQL REFERENCE) T))
      Documentation:
        List all the refs the returned list can be filtered using a PREDICATE.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:LS-REMOTE
  [symbol]

LS-REMOTE names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Lists the current refs at the remote.  Return a
    list of the refs described by NAME, REMOTE-OID, LOCAL-OID and a
    LOCAL bool that is true if the ref has a local copy.
  Method-combination: STANDARD
  Methods:
    (LS-REMOTE (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:MAKE-COMMIT
  [symbol]

MAKE-COMMIT names a compiled function:
  Lambda-list: (TREE-OR-OID MESSAGE &KEY (UPDATE-REF "HEAD") AUTHOR
                COMMITTER PARENTS REPOSITORY)
  Derived type: (FUNCTION
                 (T T &KEY (:UPDATE-REF T) (:AUTHOR T) (:COMMITTER T)
                  (:PARENTS T) (:REPOSITORY T))
                 *)
  Documentation:
    Create a new commit from the tree with the OID specified and
    MESSAGE.  Optional :UPDATE-REF is the name of the reference that will
    be updated to point to this commit.  The default value "HEAD" will
    updote the head of the current branch.  If it's value is NULL then no
    reference will be updated.  :AUTHOR is an optional instance of a
    GIT-SIGNATURE that details the commit author.  :COMMITTER is an
    optional instance of a GIT-SIGNATURE the details the committer.
    :PARENTS is an optional list of parent commits sha1 hashes.
  Source file: /home/fv/Code/CL/cl-git/src/commit.lisp

CL-GIT:MAKE-OBJECT
  [symbol]

MAKE-OBJECT names a generic function:
  Lambda-list: (CLASS ID/NAME REPOSITORY &KEY &ALLOW-OTHER-KEYS)
  Argument precedence order: (CLASS ID/NAME REPOSITORY)
  Derived type: (FUNCTION
                 (T T T &KEY (:URL T) (:TYPE T) (:FORCE T) (:TARGET T)
                  (:SIGNATURE T) (:LOG-MESSAGE T) &ALLOW-OTHER-KEYS)
                 *)
  Method-combination: STANDARD
  Methods:
    (MAKE-OBJECT ((EQL REMOTE) T T))
      Documentation:
        Create a new remote.
    (MAKE-OBJECT ((EQL REFERENCE) T T))
      Documentation:
        Create a reference to TARGET.
        The type of reference depends on TYPE.  If TYPE is :OID the value of
        TARGET should be an OID and a direct reference is created.  If TYPE
        is :SYMBOLIC, a symbolic reference is created and TARGET should be a
        string. SIGNATURE should be a signature plist. LOG-MESSAGE should be a
        string.
        
        If FORCE is t the reference will be created, even if a reference with
        the same name already exists.  If FORCE is nil, it will return an
        error if that is the case.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:MAKE-PATCH
  [symbol]

MAKE-PATCH names a generic function:
  Lambda-list: (DIFF-LIST)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (MAKE-PATCH (DIFF-LIST))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:MAKE-TAG
  [symbol]

MAKE-TAG names a compiled function:
  Lambda-list: (NAME MESSAGE &KEY REPOSITORY TARGET TAGGER FORCE)
  Derived type: (FUNCTION
                 (T T &KEY (:REPOSITORY T) (:TARGET T) (:TAGGER T)
                  (:FORCE T))
                 *)
  Documentation:
    Create a tag that points to target.
    
    NAME is the name of the tag.  MESSAGE will set the message body of the
    tag.
    
    REPOSITORY is the repository that the tag will be added to.  TARGET is
    the object that the tag will point to.  TAGGER should be a signature
    plist.
    
    If FORCE is t the tag will be created, even if a tag with the same
    name already exists.  If FORCE is nil, it will return an error if that
    is the case.
  Source file: /home/fv/Code/CL/cl-git/src/tag.lisp

CL-GIT:MERGE-CONFLICT-ERROR
  [symbol]

MERGE-CONFLICT-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:MERGE-CONFLICT-ERROR>:
  Class precedence-list: MERGE-CONFLICT-ERROR, BASIC-ERROR,
                         SIMPLE-ERROR, SIMPLE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:MESSAGE
  [symbol]

MESSAGE names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the message associated with OBJECT.
    
    For example for commits this will return the commit message and for
    tags the message associated with the tag.
    

  Method-combination: STANDARD
  Methods:
    (MESSAGE (TAG))
    (MESSAGE (COMMIT))
      Documentation:
        Return a string containing the commit message.
    (MESSAGE (REFLOG-ENTRY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:MESSAGE-ENCODING
  [symbol]

MESSAGE-ENCODING names a generic function:
  Lambda-list: (COMMIT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return a KEYWORD containing the encoding of the commit message.
  Method-combination: STANDARD
  Methods:
    (MESSAGE-ENCODING (COMMIT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:NEXT-REVISION
  [symbol]

NEXT-REVISION names a generic function:
  Lambda-list: (WALKER)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the next object for the walker.  If no
    objects are available anymore return nil.
  Method-combination: STANDARD
  Methods:
    (NEXT-REVISION (REVISION-WALKER))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:NON-FAST-FORWARD-ERROR
  [symbol]

NON-FAST-FORWARD-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:NON-FAST-FORWARD-ERROR>:
  Class precedence-list: NON-FAST-FORWARD-ERROR, BASIC-ERROR,
                         SIMPLE-ERROR, SIMPLE-CONDITION, ERROR,
                         SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:NOT-FOUND
  [symbol]

NOT-FOUND names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:NOT-FOUND>:
  Class precedence-list: NOT-FOUND, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:OBJECT
  [symbol]

CL-GIT:OBJECT-TYPE
  [symbol]

OBJECT-TYPE names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (OBJECT-TYPE (GIT-OBJECT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ODB
  [symbol]

ODB names the standard-class #<STANDARD-CLASS CL-GIT:ODB>:
  Class precedence-list: ODB, GIT-POINTER, CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:ODB-DATA
  [symbol]

ODB-DATA names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (ODB-DATA (ODB-OBJECT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ODB-OBJECT
  [symbol]

ODB-OBJECT names the standard-class #<STANDARD-CLASS CL-GIT:ODB-OBJECT>:
  Class precedence-list: ODB-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:ODB-SIZE
  [symbol]

ODB-SIZE names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (ODB-SIZE (ODB-OBJECT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:ODB-TYPE
  [symbol]

ODB-TYPE names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (ODB-TYPE (ODB-OBJECT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:OID
  [symbol]

OID names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the identifier of OBJECT.
    The identifier is typically the SHA-1 checksum or hash code.
    
    Note that this is an integer, and not the string you typically see reported by git.
    
    To get the string representation use format like this:
    
        (format nil "~40,'0X" (oid object))
    
    or if you want lowercase hexadecimal digits:
    
        (format nil "~(~40,'0X~)" (oid object))
    

  Method-combination: STANDARD
  Methods:
    (OID (ODB-OBJECT))
    (OID (REFERENCE))
      Documentation:
        Returns the oid that this reference points to.  If this reference
        is a symbolic reference then it will be resolved to a real reference
        first.
    (OID (GIT-OBJECT))
  Source file: SYS:SRC;PCL;DLISP3.LISP

CL-GIT:OPEN-INDEX
  [symbol]

OPEN-INDEX names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns an index object for OBJECT (a repository)
  Method-combination: STANDARD
  Methods:
    (OPEN-INDEX (PATHNAME))
      Documentation:
        Open a new INDEX from a file.
    (OPEN-INDEX (STRING))
      Documentation:
        Open a new INDEX from a file.
    (OPEN-INDEX (REPOSITORY))
      Documentation:
        Return the index of the repository.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:OPEN-ODB
  [symbol]

OPEN-ODB names a generic function:
  Lambda-list: (PATH-OR-REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Open the ODB at the specified path or
    repository.
  Method-combination: STANDARD
  Methods:
    (OPEN-ODB (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:OPEN-REPOSITORY
  [symbol]

OPEN-REPOSITORY names a generic function:
  Lambda-list: (PATH/NAME)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Open an existing repository located at PATH/NAME. The repository
    object will be garbage collected.  If it's freed explicitly then all
    related objects will have undefined behaviour.
  Method-combination: STANDARD
  Methods:
    (OPEN-REPOSITORY (PATHNAME))
    (OPEN-REPOSITORY (STRING))

CL-GIT:ORPHANEDHEAD-ERROR
  [symbol]

ORPHANEDHEAD-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:ORPHANEDHEAD-ERROR>:
  Class precedence-list: ORPHANEDHEAD-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:PARENTS
  [symbol]

PARENTS names a generic function:
  Lambda-list: (COMMIT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns a list of oids identifying the parents of OBJECT.
  Method-combination: STANDARD
  Methods:
    (PARENTS (COMMIT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:PASSTHROUGH
  [symbol]

PASSTHROUGH names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:PASSTHROUGH>:
  Class precedence-list: PASSTHROUGH, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:PATCH-TO-STRING
  [symbol]

PATCH-TO-STRING names a generic function:
  Lambda-list: (PATCH)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (PATCH-TO-STRING (PATCH))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REFERENCE
  [symbol]

REFERENCE names the standard-class #<STANDARD-CLASS CL-GIT:REFERENCE>:
  Class precedence-list: REFERENCE, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  No subclasses.
  No direct slots.

CL-GIT:REFLOG
  [symbol]

REFLOG names a generic function:
  Lambda-list: (REFERENCE)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (REFLOG (REFERENCE))
  Source file: SYS:SRC;PCL;DFUN.LISP

REFLOG names the standard-class #<STANDARD-CLASS CL-GIT:REFLOG>:
  Class precedence-list: REFLOG, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:REMOTE
  [symbol]

REMOTE names the standard-class #<STANDARD-CLASS CL-GIT:REMOTE>:
  Class precedence-list: REMOTE, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  No subclasses.
  No direct slots.

CL-GIT:REMOTE-CONNECT
  [symbol]

REMOTE-CONNECT names a generic function:
  Lambda-list: (OBJECT &KEY DIRECTION)
  Derived type: (FUNCTION (T &KEY (:DIRECTION T)) *)
  Documentation:
    Opens the remote connection.
    The url used for the connection can be queried by GIT-URL.
    
    The opened connection is one way, either data is retrieved from the
    remote, or data is send to the remote.  The direction is specified
    with the DIRECTION argument, :FETCH is for retrieving data, :PUSH is
    for sending data.
  Method-combination: STANDARD
  Methods:
    (REMOTE-CONNECT (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-CONNECTED-P
  [symbol]

REMOTE-CONNECTED-P names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns t if the connection is open, nil otherwise.
  Method-combination: STANDARD
  Methods:
    (REMOTE-CONNECTED-P (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-DISCONNECT
  [symbol]

REMOTE-DISCONNECT names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Disconnects an opened connection.
  Method-combination: STANDARD
  Methods:
    (REMOTE-DISCONNECT (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-DOWNLOAD
  [symbol]

REMOTE-DOWNLOAD names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Download the required packfile from the remote to
    bring the repository into sync.
  Method-combination: STANDARD
  Methods:
    (REMOTE-DOWNLOAD (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-FETCH-REFSPECS
  [symbol]

REMOTE-FETCH-REFSPECS names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns a list of fetch specifications for the remote.
  Method-combination: STANDARD
  Methods:
    (REMOTE-FETCH-REFSPECS (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-P
  [symbol]

REMOTE-P names a generic function:
  Lambda-list: (REFERENCE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the reference is within the git remotes namespace.
  Method-combination: STANDARD
  Methods:
    (REMOTE-P (STRING))
    (REMOTE-P (REFERENCE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-PUSH-REFSPECS
  [symbol]

REMOTE-PUSH-REFSPECS names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns a list of push specifications of the remote.
  Method-combination: STANDARD
  Methods:
    (REMOTE-PUSH-REFSPECS (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-PUSH-URL
  [symbol]

REMOTE-PUSH-URL names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (REMOTE-PUSH-URL (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REMOTE-URL
  [symbol]

REMOTE-URL names a generic function:
  Lambda-list: (REMOTE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the url to the remote.
  Method-combination: STANDARD
  Methods:
    (REMOTE-URL (REMOTE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REPOSITORY
  [symbol]

REPOSITORY names the standard-class #<STANDARD-CLASS CL-GIT:REPOSITORY>:
  Documentation:
    Repository is the root type, it
    contains the object database.
  Class precedence-list: REPOSITORY, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-POINTER
  No subclasses.
  No direct slots.

CL-GIT:REPOSITORY-HEAD
  [symbol]

REPOSITORY-HEAD names a generic function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the resolved reference for HEAD.
  Method-combination: STANDARD
  Methods:
    (REPOSITORY-HEAD (REPOSITORY))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REPOSITORY-PATH
  [symbol]

REPOSITORY-PATH names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the path to the repository.  In the case
    where the repository isn't bare then it will be the location of the
    .git directory.
  Method-combination: STANDARD
  Methods:
    (REPOSITORY-PATH (REPOSITORY))
      Documentation:
        Returns the path the the .git directory of the repository.
        For a bare repository to the repository itself.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:REPOSITORY-STATUS
  [symbol]

REPOSITORY-STATUS names a compiled function:
  Lambda-list: (REPOSITORY)
  Derived type: (FUNCTION (T) (VALUES T &OPTIONAL))
  Documentation:
    Return the current status values for each of the object in the
    repository.  For each element of the list the FIRST is the name of the
    file and the CDR is a list of keywords that containing the current
    state of the file.  Possible states are: :CURRENT :INDEX-NEW :INDEX-MODIFIED
    :INDEX-DELETED :INDEX-RENAMED :INDEX-TYPECHANGE :WORKTREE-NEW :WORKTREE-MODIFIED
    :WORKTREE-DELETED :WORKTREE-TYPECHANGE or :IGNORED
  Source file: /home/fv/Code/CL/cl-git/src/status.lisp

CL-GIT:REPOSITORY-WORKDIR
  [symbol]

REPOSITORY-WORKDIR names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return the path to the root of the repository.
  Method-combination: STANDARD
  Methods:
    (REPOSITORY-WORKDIR (REPOSITORY))
      Documentation:
        Returns the working directory for the repository.  This is the
        directory that files are checked out into.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:RESOLVE
  [symbol]

RESOLVE names a generic function:
  Lambda-list: (OBJECT &OPTIONAL STOP-AT)
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Method-combination: STANDARD
  Methods:
    (RESOLVE (TAG))
      Documentation:
        Resolve the tag target until the target object is not a tag anymore.
        Basically calls TARGET on tag and result until there is a COMMIT
        returned.
        
        Using values returns the finally found object and a list of the
        traversed objects.
    (RESOLVE (REFERENCE))
      Documentation:
        Resolve the reference until the resulting object is a tag or
        commit.  The accumulated result is calling TARGET repeatedly is
        returned as using VALUES. By default the resolving will stop when a
        COMMIT or TAG is found.
  Source file: SYS:SRC;PCL;DLISP3.LISP

CL-GIT:REVISION-WALK
  [symbol]

REVISION-WALK names a compiled function:
  Lambda-list: (COMMITS &KEY (ORDERING :TIME))
  Derived type: (FUNCTION (T &KEY (:ORDERING T)) (VALUES T &OPTIONAL))
  Documentation:
    Create a revision walker starts iteration from the COMMITS listed.
    
    The ordering can be adjusted to :NONE :TOPOLOGICAL :REVERSE or :TIME,
    which is the default.
    
    Once created iteration over commits can be done with the method
    NEXT-REVISION method.
  Source file: /home/fv/Code/CL/cl-git/src/revwalk.lisp

CL-GIT:SHORT-NAME
  [symbol]

SHORT-NAME names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the short name of OBJECT, as a string.
    
    What exactly the name is depends on the type of the object.

  Method-combination: STANDARD
  Methods:
    (SHORT-NAME (REMOTE))
      Documentation:
        The name of the remote.
    (SHORT-NAME (TAG))
    (SHORT-NAME (REFERENCE))
      Documentation:
        Return the short name of the REFERENCE as a STRING.  This could for
        example be the text "master" or "HEAD".
    (SHORT-NAME (GIT-OBJECT))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:SSH-KEY
  [symbol]

SSH-KEY names the standard-class #<STANDARD-CLASS CL-GIT:SSH-KEY>:
  Documentation:
    An SSH-key credential, possibly with a nonstandard
      path.
  Direct superclasses: CREDENTIALS
  No subclasses.
  Not yet finalized.
  Direct slots:
    PUBLIC-KEY
      Initargs: :PUBLIC-KEY
      Readers: PUBLIC-KEY
      Writers: (SETF PUBLIC-KEY)
    PRIVATE-KEY
      Initargs: :PRIVATE-KEY
      Initform: (NAMESTRING
                 (MERGE-PATHNAMES ".ssh/id_rsa"
                                  (USER-HOMEDIR-PATHNAME)))
      Readers: PRIVATE-KEY
      Writers: (SETF PRIVATE-KEY)
    PASSPHRASE
      Initargs: :PASSPHRASE
      Readers: PASSPHRASE
      Writers: (SETF PASSPHRASE)

CL-GIT:SSH-KEY-FROM-AGENT
  [symbol]

CL-GIT:STOP-ITERATION
  [symbol]

STOP-ITERATION names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:STOP-ITERATION>:
  Class precedence-list: STOP-ITERATION, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:SYMBOLIC-P
  [symbol]

SYMBOLIC-P names a generic function:
  Lambda-list: (REFERENCE)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the reference is symbolic.
  Method-combination: STANDARD
  Methods:
    (SYMBOLIC-P (REFERENCE))
  Source file: SYS:SRC;PCL;DLISP3.LISP

CL-GIT:TAG
  [symbol]

TAG names the standard-class #<STANDARD-CLASS CL-GIT:TAG>:
  Documentation:
    Tags are used to identify interesting points in the
    repositories history.
  Class precedence-list: TAG, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  No subclasses.
  No direct slots.

CL-GIT:TAG-P
  [symbol]

TAG-P names a generic function:
  Lambda-list: (TAG)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Return T if the reference is within the git tag namespace.
  Method-combination: STANDARD
  Methods:
    (TAG-P (STRING))
    (TAG-P (TAG))
    (TAG-P (T))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:TAGGER
  [symbol]

TAGGER names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the signature of the tagger of OBJECT.
    
    The return value is a signature (a property list with
    keys :NAME, :EMAIL and :TIME.  If the tag is not annotated then nil
    will be returned.
  Method-combination: STANDARD
  Methods:
    (TAGGER (TAG))
    (TAGGER (REFERENCE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:TARGET
  [symbol]

TARGET names a generic function:
  Lambda-list: (OBJECT)
  Derived type: (FUNCTION (T) *)
  Documentation:
    Returns the target of OBJECT.
  Method-combination: STANDARD
  Methods:
    (TARGET (TAG))
      Documentation:
        Returns the target of a tag.
    (TARGET (REFERENCE))
      Documentation:
        Returns the Object that this reference points to.  If the reference
        is symbolic then the reference it points to will be returned.
  Source file: SYS:SRC;PCL;DLISP3.LISP

(SETF TARGET) names a compiled function:
  Lambda-list: (VAL REFERENCE &KEY SIGNATURE (LOG-MESSAGE ""))
  Derived type: (FUNCTION (T T &KEY (:SIGNATURE T) (:LOG-MESSAGE T)) *)
  Source file: /home/fv/Code/CL/cl-git/src/references.lisp

CL-GIT:TREE
  [symbol]

TREE names the standard-class #<STANDARD-CLASS CL-GIT:TREE>:
  Class precedence-list: TREE, GIT-OBJECT, GIT-POINTER,
                         CFFI::ENHANCED-FOREIGN-TYPE,
                         CFFI::TRANSLATABLE-FOREIGN-TYPE,
                         CFFI::FOREIGN-TYPE-ALIAS, CFFI::FOREIGN-TYPE,
                         STANDARD-OBJECT, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: GIT-OBJECT
  Direct subclasses: TREE-TREE
  No direct slots.

CL-GIT:TREE-BLOB
  [symbol]

TREE-BLOB names the standard-class #<STANDARD-CLASS CL-GIT:TREE-BLOB>:
  Documentation:
    A git tree blob.
  Direct superclasses: PATHNAME-MIXIN, BLOB
  No subclasses.
  Not yet finalized.
  Direct slots:
    FILEMODE
      Initargs: :FILEMODE
      Readers: FILEMODE

CL-GIT:TREE-DIRECTORY
  [symbol]

TREE-DIRECTORY names a generic function:
  Lambda-list: (TREE &OPTIONAL PATHNAME)
  Derived type: (FUNCTION (T &OPTIONAL T) *)
  Documentation:
    List objects from a tree.  Optional argument pathname a wild
    pathname that the entries must match.
  Method-combination: STANDARD
  Methods:
    (TREE-DIRECTORY (TREE))
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:TREE-TREE
  [symbol]

TREE-TREE names the standard-class #<STANDARD-CLASS CL-GIT:TREE-TREE>:
  Documentation:
    A git tree entry.
  Direct superclasses: PATHNAME-MIXIN, TREE
  No subclasses.
  Not yet finalized.
  Direct slots:
    FILEMODE
      Initargs: :FILEMODE
      Readers: FILEMODE

CL-GIT:UNKNOWN-ERROR
  [symbol]

UNKNOWN-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:UNKNOWN-ERROR>:
  Documentation:
    This return value is not expected.
  Class precedence-list: UNKNOWN-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:UNMERGED-ERROR
  [symbol]

UNMERGED-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:UNMERGED-ERROR>:
  Class precedence-list: UNMERGED-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:UNRESOLVED-REFERENCE-ERROR
  [symbol]

UNRESOLVED-REFERENCE-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:UNRESOLVED-REFERENCE-ERROR>:
  Class precedence-list: UNRESOLVED-REFERENCE-ERROR, ERROR,
                         SERIOUS-CONDITION, CONDITION,
                         SB-PCL::SLOT-OBJECT, T
  Direct superclasses: ERROR
  No subclasses.
  No direct slots.

CL-GIT:UPSTREAM
  [symbol]

UPSTREAM names a generic function:
  Lambda-list: (BRANCH)
  Derived type: (FUNCTION (T) *)
  Method-combination: STANDARD
  Methods:
    (UPSTREAM (REFERENCE))
      Documentation:
        Returns the reference for the remote tracking branch, corresponding
        to the local branch BRANCH.
  Source file: SYS:SRC;PCL;DFUN.LISP

CL-GIT:USER-ERROR
  [symbol]

USER-ERROR names the condition-class #<SB-PCL::CONDITION-CLASS CL-GIT:USER-ERROR>:
  Class precedence-list: USER-ERROR, BASIC-ERROR, SIMPLE-ERROR,
                         SIMPLE-CONDITION, ERROR, SERIOUS-CONDITION,
                         CONDITION, SB-PCL::SLOT-OBJECT, T
  Direct superclasses: BASIC-ERROR
  No subclasses.
  No direct slots.

CL-GIT:USERNAME-PASSWORD
  [symbol]

USERNAME-PASSWORD names the standard-class #<STANDARD-CLASS CL-GIT:USERNAME-PASSWORD>:
  Direct superclasses: CREDENTIALS
  No subclasses.
  Not yet finalized.
  Direct slots:
    USERNAME
      Initargs: :USERNAME
      Readers: USERNAME
      Writers: (SETF USERNAME)
    PASSWORD
      Initargs: :PASSWORD
      Initform: (ERROR "A password must be provided.")
      Readers: PASSWORD
      Writers: (SETF PASSWORD)

CL-GIT:WITH-INDEX
  [symbol]

WITH-INDEX names a macro:
  Lambda-list: ((VAR &OPTIONAL REPOSITORY-OR-PATH) &BODY BODY)
  Documentation:
    Load an index from a repository, path or if none is specified then
    an in-memory index is used.  The newly opened index is bound to the
    variable VAR.
  Source file: /home/fv/Code/CL/cl-git/src/index.lisp

CL-GIT:WITH-REPOSITORY
  [symbol]

WITH-REPOSITORY names a macro:
  Lambda-list: ((VAR PATHNAME-OR-STRING) &BODY BODY)
  Documentation:
    Evaluates the body with VAR bound to a newly opened located
    repository at PATHNAME-OR-STRING.  Repository is freed upon exit of
    this scope so any objects that leave this scope will no longer be able
    to access the repository.
  Source file: /home/fv/Code/CL/cl-git/src/repository.lisp