anchor.diff:  
   (defparameter *github-cld-repository*
     `(make-instance 'http-cld-repository
  -		  :name "Github repository"
  -		  :url "http://mmontone.github.io/cldm-repo/cld"))
  +                  :name "Github repository"
  +                  :url "http://mmontone.github.io/cldm-repo/cld"))
   
   (defparameter *cld-repositories* (list *github-cld-repository*))
  +
  +(defun verbose-msg (msg &rest args)
  +  (when *verbose-mode*
  +    (apply #'format t (cons msg args))))
   
   (defun call-with-repositories-directory (pathname function)
     (let ((*repositories-directory* pathname))
  
positive.code: 
  (defclass http-cld-address (cld-address)
    ((url :initarg :url
  	:initform (error "Provide the cld url") 
  	:accessor cld-url
  	:documentation "The cld http url"))
    (:documentation "A cld in an http url"))
  
  (defmethod print-object ((cld-address http-cld-address) stream)
  
negative.code: 
  (defclass directory-repository-address (repository-address)
    ((directory :initarg :directory
                :initform (error "Provide the filesystem directory")
                :accessor repository-directory
                :documentation "The repository filesystem directory"))
    (:documentation "A repository in a file system directory"))
  
  (defclass git-repository-address (repository-address)
    ((url :initarg :url
          :initform (error "Provide the git url")
          :accessor url
          :documentation "The git url")
     (branch :initarg :branch
             :initform "master"
             :accessor branch
             :documentation "Git repository branch")
     (commit :initarg :commit
             :initform nil
             :accessor commit
             :documentation "Commit to fetch"))
    (:documentation "A git repository"))
  
  (defclass url-repository-address (repository-address)
    ((url :initarg :url
          :initform (error "Provide the repository package url")
          :accessor url
          :documentation "The repository url"))
    (:documentation "A remote repository package"))
  
  (defun parse-version-repository-address (address)
    (cond
      ((pathnamep address)
       `(make-instance 'directory-repository-address
                       :directory ,address))
      ((and (listp address)
            (equalp (first address) :directory))
       `(make-instance 'directory-repository-address
                       :directory ,(second address)))
      ((and (listp address)
            (equalp (first address) :git))
       (destructuring-bind (url &rest args)
           (rest address)
         `(make-instance 'git-repository-address
                         :url ,url
                         ,@args)))
      ((and (listp address)
            (equalp (first address)
                    :url))
       `(make-instance 'url-repository-address
                       :url ,(second address)))
      (t (error "Invalid repository ~A" address))))
  
  (defun setup (library-name &optional version)
    "Setup an already loaded (cld) library and its dependencies"
    (let ((library (find-cld-library library-name)))
      (verbose-msg "Loading ~A.~%" library)
      (let ((library-version (if version
                                 (find-cld-library-version library version)
                                 (first (library-versions library)))))
        ;; Load libraries metadata
        (load-library-version library-version)
  
        ;; Calculate list of library-versions to load
        (let ((library-versions
               (calculate-library-versions library-version)))
          (verbose-msg "Libraries to load: ~A~%" library-versions)
  
          ;; Validate the library versions list
          (validate-library-versions-list library-versions)
  
          ;; Remove duplicates in depdency list
          (setf library-versions
                (clean-library-versions-list library-versions))
  
          ;; Check the version existance and download if not
          ;; After that, push to asdf:*central-registry*
          (loop for version in (cons library-version library-versions)
             do
               (let ((pathname (cache-library-version version)))
                 (push pathname asdf:*central-registry*))))))
    (verbose-msg "Done.~%"))
  
  (defun load-library (library-name &key version cld
  				    (verbose *verbose-mode*))
    "Tries to find a cld for the library and load it.
     Then setup the library and its dependencies"
    (let ((*verbose-mode* verbose))
      (if cld
  	(progn
  	  (load-cld cld)
  	  (setup library-name version))
  	;; else
  	(if (find-cld-library library-name nil)
  	    (setup library-name version)
  	    ;; else
  	    (progn
  	      (loop
  		 for cld-repository in *cld-repositories*
  		 while (not cld)
  		 do (let ((cld-repository (eval cld-repository)))
  		      (setf cld (find-cld cld-repository
  					  library-name))
  		      (when cld
  			(verbose-msg "~A cld found in ~A~%"
  				     library-name
  				     cld-repository))))
  	      (if cld
  		  (progn
  		    (load-cld cld)
  		    (setup library-name version))
  		  (error "Couldn't find a cld for ~S library~%" library-name)))))))
  
  (defun load-library-version (library-version &key reload)
    (verbose-msg "Loading ~A.~%" library-version)
    (labels ((load-dependency-cld (dependency cld)
               (verbose-msg "Loading cld: ~A~%" cld)
               (load-cld cld)
               (let ((library (find-cld-library (library-name dependency))))
                 (let ((library-version
                        (if (not (library-version dependency))
                            ;; No library version specified in the dependency
                            ;; Use the latest version
                            (first (library-versions library))
                            ;; else, use the library version specified
                            (find-cld-library-version
                             library
                             (library-version dependency)))))
                   (load-library-version library-version :reload reload))))
             (load-dependency (dependency)
               (let ((cld (cld dependency)))
                 (if (not cld)
                     (progn
                       (verbose-msg "No cld specified.~%")
                       (loop
                          for cld-repository in *cld-repositories*
                          while (not cld)
                          do (let ((cld-repository (eval cld-repository)))
                               (setf cld (find-cld cld-repository
                                                   (library-name dependency)))
                               (when cld
                                 (verbose-msg "~A cld found in ~A~%"
                                              (library-name dependency)
                                              cld-repository))))
                       (when cld
                         (load-dependency-cld dependency cld)))
                                          ;else
                     (load-dependency-cld dependency cld)))))
      (loop for dependency in (dependencies library-version)
         do (progn
              (verbose-msg "Handling ~A.~%" dependency)
              (if (find-cld-library (library-name dependency) nil)
                  (progn
                    (verbose-msg "Metadata for ~A is already loaded~%" (library-name dependency))
                    (when reload
                      (verbose-msg "Reloading...")
                      (load-dependency dependency)))
                  ;; else
                  (load-dependency dependency))))))
  
  (defun calculate-library-versions (library-version &optional visited)
    (loop for dependency in (dependencies library-version)
       appending
         (if (find (library-name dependency) visited
                   :key #'library-name
                   :test #'equalp)
             (error "Cyclic dependency on ~A" dependency)
                                          ;else
             (let ((library (find-cld-library (library-name dependency) nil)))
               (if library
                   (let ((library-version
                          (if (library-version dependency)
                              (find-cld-library-version
                               library
                               (library-version dependency))
                                          ; else, use the latest version
                              (first (library-versions library)))))
                     (cons library-version
                           (calculate-library-versions library-version (cons dependency visited))))
                                          ;else
                   (verbose-msg "WARNING: no ASDF system is being loaded by CLDM for ~A~%"
                                dependency))))))
  
  (defun validate-library-versions-list (versions-list)
    (loop for i from 0 to (1- (length versions-list))
       for vi = (elt versions-list i)
       do
         (loop for j from 1 to (1- (length versions-list))
            for vj = (elt versions-list j)
            when (and (not (equalp i j))
                      (and (equalp (library-name (library vi))
                                   (library-name (library vj)))
                           (and (version vi)
                                (version vj)
                                (not (equalp (version vi)
                                             (version vj))))))
            do (error "Cannot load ~A and ~A" vi vj))))
  
  (defun clean-library-versions-list (versions-list)
    ;; TODO
  