anchor.diff:    (print-unreadable-object (repository-address stream :type t :identity t)
       (format stream "~A" (address repository-address))))
   
  -(defgeneric install-repository-from-address (repository-address repository target-directory)
  -  (:documentation "Cache the given repository from repository-address to target-directory.
  +(defgeneric install-repository-from-address (repository-address repository install-directory)
  +  (:documentation "Cache the given repository from repository-address to install-directory.
                      Methods of this generic function should return T on success, or NIL on failure."))
   
   (defmethod install-repository-from-address ((repository-address directory-repository-address)
  -                                            repository target-directory)
  +                                            repository install-directory)
     (multiple-value-bind (result code status)
         (ecase *address-cache-operation*
           (:symlink
  -         (let ((linkname (subseq (princ-to-string target-directory)
  +         (let ((linkname (subseq (princ-to-string install-directory)
                                    0
  -                                 (1- (length (princ-to-string target-directory))))))
  +                                 (1- (length (princ-to-string install-directory))))))
              (verbose-msg "Symlinking ~A to ~A~%"
                           (repository-directory repository-address)
                           linkname)
  
positive.code:     (info-msg "Cloning repository: ~A...~%" (url repository-address))
      (run-or-fail (format nil "git clone ~A ~A"
                           (url repository-address)
                           (princ-to-string target-directory)))
      (when (branch repository-address)
        (info-msg "Checking out ~A branch.~%" (branch repository-address))
        (run-or-fail (format nil "cd ~A; git checkout ~A"
                             target-directory
                             (branch repository-address))))
      (when (commit repository-address)
        (info-msg "Checking out commit ~A~%" (commit repository-address))
        (let ((command  (format nil "cd ~A; git checkout ~A"
                                (princ-to-string target-directory)
                                (commit repository-address))))
          (verbose-msg "~A~%" command)
          (run-or-fail command)))
      (when (tag repository-address)
        (info-msg "Checking out tag ~A~%" (tag repository-address))
        (let ((command  (format nil "cd ~A; git checkout tags/~A"
                                (princ-to-string target-directory)
                                (tag repository-address))))
          (verbose-msg "~A~%" command)
          (run-or-fail command)))
  
negative.code:         (install-library-version library-version (libraries-directory project)))))
  
  (defun update-repository (installed-library-version library-version)
    (let ((updated-p
  	 (update-repository-from-address
  	  (repository-address (repository installed-library-version))
  	  (repository installed-library-version)
  	  (install-directory installed-library-version)
  	  library-version)))
      (when (not updated-p)
        (error "Error updating ~A to ~A" 
  	     installed-library-version
  	     library-version))
      (make-instance 'installed-library-version
  		   :name (library-name library-version)
  		   :version (version library-version)
  		   :install-directory (install-directory installed-library-version)
  		   :repository (repository installed-library-version))))
  
  (defmethod install-repository (repository directory)
    (install-repository-from-address (repository-address repository)
  