Added COPYING (GPL3)

[elinstall.git] / elinstall.el

;;;_ elinstall.el --- Automatically and flexibly install elisp files

;;;_. Headers
;;;_ , License
;; Copyright (C) 2010  Tom Breton (Tehom)

;; Author: Tom Breton (Tehom) <tehom@panix.com>
;; Keywords: maint, tools, internal

;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;;_ , Commentary:

;; Entry points:
;; elinstall  Use this for overall loading
;;
;; elinstall-link-on-emacs-start - Use this for non-autogenerated
;; files that need to be linked in.

;;;_ , Requires

(require 'autoload)
(require 'pp)
(require 'cus-edit)  ;;Because we save "installedness" manually


;;;_. Body
;;;_ , Customizations
(defgroup elinstall
   '()
   "Customizations for elinstall"
   :group 'elinstall)

(defcustom elinstall-default-priority 
   50
   "Default priority for site-start" 
   :group 'elinstall
   :type 'integer)

(defcustom elinstall-default-target-dir
   "~/.emacs.d/site-start.d/"
   "Default target for registering autoloads" 
   :group 'elinstall
   :type
   '(choice 
       (const  "~/.emacs.d/site-start.d/")
       (const  "/etc/emacs/site-start.d/")
       (directory "" )
       (const 'dot-emacs)))


(defcustom elinstall-already-installed
   '()
   "Things that have already been installed.
This exists for recording what has been installed.  User interaction is not
contemplated at this time." )

;;;_ , Utilities
;;;_  . elinstall-directory-true-name
(defun elinstall-directory-true-name ()
   "Get the true name of the directory the calling code lives in.
CAUTION:  This is sensitive to where it's called.  That's the point of it."
   (file-name-directory
      (if load-file-name
         (file-truename load-file-name)
         (file-truename buffer-file-name))))
;;;_  . Checking installedness
;;;_   , elinstall-already-installed
(defun elinstall-already-installed (project-name)
   "Return non-nil if PROJECT-NAME has been installed."
   (member project-name elinstall-already-installed))

;;;_   , elinstall-record-installed
(defun elinstall-record-installed (project-name)
   "Record that PROJECT-NAME has been installed."

   (add-to-list 'elinstall-already-installed project-name)
   (customize-save-variable 
      'elinstall-already-installed 
      elinstall-already-installed
      "Set by elinstall-record-installed"))

;;;_   , Regular expressions
;;;_    . elinstall-elisp-regexp
(defconst elinstall-elisp-regexp
   (let ((tmp nil))
      (dolist 
         (suf (get-load-suffixes))
         (unless (string-match "\\.elc" suf) (push suf tmp)))
      (concat "^[^=.].*" (regexp-opt tmp t) "\\'"))
   "Regular expression that matches elisp files" )

;;;_ , Work
;;;_  . Doing actions
;;;_   , elinstall-insert-add-to-path
(defun elinstall-insert-add-to-path (new path-sym)
   "Insert code to add NEW to PATH-SYM.
Insert this at point in current buffer."
   (insert "\n")
   (pp
      `(add-to-list ',path-sym
          (expand-file-name ,new
             (if load-file-name
                (file-name-directory
                   (file-truename load-file-name)))))
      (current-buffer)))

;;;_   , elinstall-insert-add-to-load-path
(defun elinstall-insert-add-to-load-path (new)
   "Insert code to add NEW to load-path.
Insert this at point in current buffer."
   (elinstall-insert-add-to-path new 'load-path))

;;;_   , elinstall-insert-add-to-info-path
(defun elinstall-insert-add-to-info-path (new)
   "Insert code to add NEW to info-path.
Insert this at point in current buffer."
   (elinstall-insert-add-to-path new 'Info-default-directory-list))

;;;_   , Linking on start
;;;_    . elinstall-insert-dir-autoloads
(defun elinstall-symlink-on-emacs-start 
   (filename target-basename target-dir &optional priority force)
   "Symlink to TARGET-BASENAME.el in TARGET-DIR

If PRIORITY is given, it will be used as the priority prefix,
otherwise elinstall-default-priority will be.
PRIORITY must be an integer or nil.
If FORCE is `t', do it regardless of timestamps etc.
Other non-nil cases of FORCE are reserved for future development."
   (let*
      (  
         (priority   (or priority elinstall-default-priority))
         (target-name-nodir
            (format
               "%d%s.el"
               priority
               target-basename))
         (target 
            (expand-file-name target-name-nodir target-dir)))
      
      
      (cond
         ;;Path should already exist.
         ((not
             (file-exists-p target-dir))
            (message "The target directory doesn't exist."))
         ;;Target shouldn't already exist, but if force is given, let
         ;;user override.
         ((and
             (file-exists-p target)
             (or
                (not force)
                (not
                   (yes-or-no-p 
                      (format "Really overwrite %s? " project-name))))
             (message "No symlink made to %s" target)))
         
         (t
            (make-symbolic-link 
               filename
               target
               nil)))))

;;;_    . elinstall-add-to-dot-emacs
(defun elinstall-add-to-dot-emacs (dot-emacs-name filename force &rest r)
   "Add code to load FILENAME to .emacs.
FILENAME should not have an extension"

   ;;Visit .emacs
   (with-current-buffer (find-file-noselect dot-emacs-name)
      (save-excursion
         ;;add at end of file
         (goto-char (point-max))
         (insert "\n;;Added by elinstall")
         (insert "\n;;Consider using my-site-start to manage .emacs\n")
         (pp `(load ,filename) (current-buffer))
         (save-buffer))))


;;;_    . elinstall-link-on-emacs-start
;;;###autoload
(defun elinstall-link-on-emacs-start (filename force basename priority)
   ""

   ;;Figure out parameters, using defaults when needed.
   (let* 
      (  (target-dir elinstall-default-target-dir))
      
      ;;Dispatch the possibilities.
      (cond
         ((eq target-dir 'dot-emacs)
            (elinstall-add-to-dot-emacs "~/.emacs" filename))
         ((stringp target-dir)
            (elinstall-symlink-on-emacs-start 
               filename basename target-dir priority force))

         (t
            (message "I don't recognize that")))))

;;;_   , elinstall-insert-dir-autoloads
(defun elinstall-insert-dir-autoloads (autoloads-file directory)
   "Generate autoloads for DIRECTORY into AUTOLOADS-FILE."
   (declare (special generated-autoload-file))
   (let ((generated-autoload-file autoloads-file))
      (elinstall-update-directory-autoloads directory)))

;;;_   , elinstall-segregate-actions
(defun elinstall-segregate-actions (actions)
   "Return actions segregated by deffile.

Returns a list whose elements are each a cons of:
 * deffile filename or nil
 * A list of actions to be done for that deffile."

   (let
      ((segment-list '()))
      (dolist (act actions)
         (when act
            (let*
               (  (deffile-name 
                     (case (car act)
                        ((add-file-autoloads 
                            add-to-info-path
                            add-to-load-path) 
                           (second act))
                        (preload-file nil)))
               
                  (cell (assoc deffile-name segment-list)))
               (if cell
                  (setcdr cell (cons act (cdr cell)))
                  (setq segment-list
                     (cons
                        (cons
                           deffile-name
                           (list act))
                        segment-list))))))
      segment-list))


;;;_   , elinstall-do-segment
(defun elinstall-do-segment (segment force)
   ""
   
   (let*
      ((deffile (car segment)))
      (if deffile
         nil ;;
         ;;Do other actions, which will be all link-in actions.
         (mapcar
            #'(lambda (act)
                 (apply #'elinstall-link-on-emacs-start force (cdr action))
                 )
            (cdr segment)))))



;;;_  . Overrides (All adapted from autoload.el)
;;;_   , elinstall-generate-file-autoloads 
;;override to allow slashed load-paths
;;Quick and dirty: We just adapt `generate-file-autoloads' and add
;;a new arg. 
;;`relative-to' can be:
;; * nil: act as at present.  Assume that FILE's immediate directory
;;is in load-path. 
;; * t :: use default-directory
;; * a string :: relative to it, as a filename

(defun elinstall-generate-file-autoloads (file load-name)
  "Insert at point a loaddefs autoload section for FILE.
Autoloads are generated for defuns and defmacros in FILE
marked by `generate-autoload-cookie' (which see).
If FILE is being visited in a buffer, the contents of the buffer
are used.
Return non-nil in the case where no autoloads were added at point."
  (interactive "fGenerate autoloads for file: ")
  (let ((outbuf (current-buffer))
        (autoloads-done '())
        (print-length nil)
        (print-readably t)              ; This does something in Lucid Emacs.
        (float-output-format nil)
        (done-any nil)
        (visited (get-file-buffer file))
        output-start)

    ;; If the autoload section we create here uses an absolute
    ;; file name for FILE in its header, and then Emacs is installed
    ;; under a different path on another system,
    ;; `update-autoloads-here' won't be able to find the files to be
    ;; autoloaded.  So, if FILE is in the same directory or a
    ;; subdirectory of the current buffer's directory, we'll make it
    ;; relative to the current buffer's directory.
    (setq file (expand-file-name file))
    (let* ((source-truename (file-truename file))
           (dir-truename (file-name-as-directory
                          (file-truename default-directory)))
           (len (length dir-truename)))
      (if (and (< len (length source-truename))
               (string= dir-truename (substring source-truename 0 len)))
          (setq file (substring source-truename len))))

    (with-current-buffer (or visited
                             ;; It is faster to avoid visiting the file.
                             (autoload-find-file file))
      ;; Obey the no-update-autoloads file local variable.
      (unless no-update-autoloads
        (message "Generating autoloads for %s..." file)
        (setq output-start (with-current-buffer outbuf (point)))
        (save-excursion
          (save-restriction
            (widen)
            (goto-char (point-min))
            (while (not (eobp))
              (skip-chars-forward " \t\n\f")
              (cond
               ((looking-at (regexp-quote generate-autoload-cookie))
                (search-forward generate-autoload-cookie)
                (skip-chars-forward " \t")
                (setq done-any t)
                (if (eolp)
                    ;; Read the next form and make an autoload.
                    (let* ((form (prog1 (read (current-buffer))
                                   (or (bolp) (forward-line 1))))
                           (autoload (make-autoload form load-name)))
                      (if autoload
                          (push (nth 1 form) autoloads-done)
                        (setq autoload form))
                      (let ((autoload-print-form-outbuf outbuf))
                        (autoload-print-form autoload)))

                  ;; Copy the rest of the line to the output.
                  (princ (buffer-substring
                          (progn
                            ;; Back up over whitespace, to preserve it.
                            (skip-chars-backward " \f\t")
                            (if (= (char-after (1+ (point))) ? )
                                ;; Eat one space.
                                (forward-char 1))
                            (point))
                          (progn (forward-line 1) (point)))
                         outbuf)))
               ((looking-at ";")
                ;; Don't read the comment.
                (forward-line 1))
               (t
                (forward-sexp 1)
                (forward-line 1))))))

        (when done-any
          (with-current-buffer outbuf
            (save-excursion
              ;; Insert the section-header line which lists the file name
              ;; and which functions are in it, etc.
              (goto-char output-start)
              (autoload-insert-section-header
               outbuf autoloads-done load-name file
               (nth 5 (file-attributes file)))
              (insert ";;; Generated autoloads from "
                      (autoload-trim-file-name file) "\n"))
            (insert generate-autoload-section-trailer)))
        (message "Generating autoloads for %s...done" file))
      (or visited
          ;; We created this buffer, so we should kill it.
          (kill-buffer (current-buffer))))
    (not done-any)))
;;
;;;_   , elinstall-old-prepare-deffile
;;Old code from autoload.
(defun elinstall-old-prepare-deffile (deffile)
   ""
   
   (autoload-ensure-default-file deffile)
   (with-current-buffer (find-file-noselect deffile)

         
      ;; We must read/write the file without any code conversion,
      ;; but still decode EOLs.
      (let ((coding-system-for-read 'raw-text))

         ;; This is to make generated-autoload-file have Unix EOLs, so
         ;; that it is portable to all platforms.
         (setq buffer-file-coding-system 'raw-text-unix))
      (or (> (buffer-size) 0)
         (error "Autoloads file %s does not exist" buffer-file-name))
      (or (file-writable-p buffer-file-name)
         (error "Autoloads file %s is not writable"
            buffer-file-name))))

;;;_   , elinstall-old-get-deffile
;;Old code from autoload.

(defun elinstall-old-get-deffile (file)
   "Return the appropriate loaddefs file for FILE."

   (save-excursion
      (let* 
         ((existing-buffer (get-file-buffer file)))

         ;; We want to get a value for generated-autoload-file from
         ;; the local variables section if it's there.
         ;;But if it's not loaded, we don't?  Maybe should use
         ;; `autoload-find-file' and load it.
         (if existing-buffer
            (set-buffer existing-buffer))
         ;;No, we only want it if a local variable forces it to this
         ;; value. 
         (expand-file-name generated-autoload-file
            (expand-file-name "lisp"
               source-directory)))))



;;;_   , elinstall-deffile-insert
;;This now operates in the current buffer.  We already did most of
;;this checking on setup.
;; Removed 
;; * buffer optional save, 
;; * converting file to load-name
;; * checking for timestamp
(defun elinstall-deffile-insert-x (file load-name)
   "Update the autoloads for FILE in `generated-autoload-file'
\(which FILE might bind in its local variables).

LOAD-NAME is the full name of the file


Return FILE if there was no autoload cookie in it, else nil."
   (let (
           (found nil)
           (no-autoloads nil))

      (save-excursion
         (save-restriction
            (widen)
            (goto-char (point-min))
            ;; Look for the section for FILE
            (while (and (not found)
                      (search-forward generate-autoload-section-header nil t))
               (let ((form (autoload-read-section-header)))
                  (cond 
                     ((string= (nth 2 form) file)
                        ;; We found the section for this file.
                        ;; Check if it is up to date.
                        (let ((begin (match-beginning 0)))
                           (progn
                              (search-forward generate-autoload-section-trailer)
                              (delete-region begin (point))
                              (setq found t))))
                     ((string< file (nth 2 form))
                        ;; We've come to a section alphabetically later than
                        ;; FILE.  We assume the file is in order and so
                        ;; there must be no section for FILE.  We will
                        ;; insert one before the section here.
                        (goto-char (match-beginning 0))
                        (setq found 'new)))))
            (unless found
               (progn
                  (setq found 'new)
                  ;; No later sections in the file.  Put before the last page.
                  (goto-char (point-max))
                  (search-backward "\f" nil t)))
            (setq no-autoloads 
               (elinstall-generate-file-autoloads file load-name))))

      (if no-autoloads file nil)))

;;;_   , elinstall-deffile-insert

(defun elinstall-deffile-insert (action)
   "Insert autoloads or similar into current file according to ACTION.
The format of ACTION is described in the design docs.

Return filename if this action belongs in the no-autoload section."

   (when action
      (case (car action)
         (let
            ((filename 
                (third action)))
            (add-file-autoloads
               (elinstall-deffile-insert-x
                  filename
                  (expand-file-name
                     filename
                     (fourth action)))))
      
         (add-to-load-path
            ;;Go to the right position, then call:
            '(elinstall-insert-add-to-load-path)
            nil)
      
         ;;Similar, but for info-path.
         (add-to-info-path
            'elinstall-insert-add-to-info-path
            nil)
         
         (preload-file
            (error "This case should not come here.")))))


;;;_   , elinstall-remove-autogen-action
(defun elinstall-remove-autogen-action (file actions)
   "Return ACTIONS minus any add-file-autoloads on FILE removed."

   (delq nil
      (mapcar
         #'(lambda (act)
              (case (car act)
                 (add-file-autoloads
                    (if (equal file (third act))
                       nil
                       act))))
         actions)))
;;;_   , elinstall-get-autogen-action
(defun elinstall-get-autogen-action (file actions)
   ""
   (let
      ((the-act))
      (dolist (act actions)
         (case (car act)
            (add-file-autoloads
               (when (equal file (third act))
                  (setq the-act act)))))
      the-act))

;;;_   , elinstall-update-deffile

;;Adapted from autoload.el `update-directory-autoloads'.
;;Still being adapted:

;; * Still need to treat add-to-info-path and
;;add-to-load-path. Both recognize them and insert them.
;; * Adapt `elinstall-update-file-autoloads' to understand actions.

;; * Finding "file" among actions is rickety.  Maybe knowing the
;;   respective load-path element would help.

(defun elinstall-update-deffile (target actions &optional
                                   use-load-path force)
  "\
Update file TARGET with current autoloads as specified by ACTIONS.
Also remove any old definitions pointing to libraries that can no
longer be found.

ACTIONS must be a list of actions (See the format doc).  Each one's
filename must be relative to some element of load-path.

USE-LOAD-PATH is a list to use as load-path.  It should include
any new load-path that we are arranging to create.  If it's not given,
load-path itself is used.

If FORCE is `t', do it regardless of timestamps etc. (Not implemented)
Other non-nil cases of FORCE are reserved for future development.

This uses `update-file-autoloads' (which see) to do its work.
In an interactive call, you must give one argument, the name
of a single directory."
  (let
     (
        (use-load-path (or use-load-path load-path))
        (this-time (current-time))
        ;;files with no autoload cookies.
        (no-autoloads nil))
     

     (with-current-buffer
        (find-file-noselect target)
        (save-excursion
           (setq actions
              (elinstall-remove-autogen-action
                 (autoload-trim-file-name target) 
                 actions))

           (goto-char (point-min))
           (while (search-forward generate-autoload-section-header nil t)
              (let* ((form (autoload-read-section-header))
                       (file (nth 3 form)))
                 (cond ((and (consp file) (stringp (car file)))
                          ;; This is a list of files that have no
                          ;; autoload cookies.
                          ;; There shouldn't be more than one such entry.
                          ;; Remove the obsolete section.
                          (autoload-remove-section (match-beginning 0))
                          (let ((last-time (nth 4 form)))
                             (dolist (file file)
                                (let ((file-time (nth 5 (file-attributes file))))
                                   (when (and file-time
                                            (not (time-less-p last-time file-time)))
                                      ;; file unchanged
                                      (push file no-autoloads)
                                      (setq actions
                                         (elinstall-remove-autogen-action
                                            file actions)))))))
                    ((not (stringp file)))
                    (t
                       (let
                          ((file-path
                              (locate-library file nil use-load-path)))
                          (cond
                             ;;File doesn't exist, so remove its
                             ;;section.
                             ((not file-path)
                                (autoload-remove-section 
                                   (match-beginning 0)))

                             ;; File hasn't changed, so do nothing.
                             ((equal 
                                 (nth 4 form) 
                                 (nth 5 (file-attributes file-path)))
                                nil)
                             (t
                                (elinstall-deffile-insert
                                   (elinstall-get-autogen-action file))))

                          (setq actions
                             (elinstall-remove-autogen-action
                                file actions))))))))

        ;; Remaining actions have no existing autoload sections yet.
        (setq no-autoloads
           (append no-autoloads
              (delq nil (mapcar #'elinstall-deffile-insert actions))))
        (when no-autoloads
           ;; Sort them for better readability.
           (setq no-autoloads (sort no-autoloads 'string<))
           ;; Add the `no-autoloads' section.
           (goto-char (point-max))
           (search-backward "\f" nil t)
           (autoload-insert-section-header
              (current-buffer) nil nil no-autoloads this-time)
           (insert generate-autoload-section-trailer))
        (save-buffer))))

;;;_  . Finding actions
;;;_   , Treating the parameter list
;;;_    . elinstall-add-parameter
(defun elinstall-add-parameter (alist key new-value)
   "Add a new value for KEY to ALIST"

   (cons
      (cons key new-value)
      (assq-delete-all key (copy-list alist))))

;;;_    . elinstall-get-parameter
(defun elinstall-get-parameter (alist key)
   "Get the value of KEY from ALIST"
   
   (cdr (assq key alist)))
;;;_    . elinstall-expand-filename
(defun elinstall-expand-filename (filename alist)
   "Expand FILENAME by the value of `path' in ALIST"
   
   (expand-file-name 
      filename
      (elinstall-get-parameter alist 'path)))

;;;_   , elinstall-find-actions-by-spec

(defun elinstall-find-actions-by-spec (spec load-path-element path parameters)
   "Return a list of actions to do, controlled by SPEC and PARAMETERS.

LOAD-PATH-ELEMENT is the conceptual element of load-path that
surrounds PATH.  It may not yet have been added to load-path."
   (if (consp spec)
      ;;$$IMPROVE ME by adding the other cases in the design.
      (case (car spec)
         (in
            (let
               ((new-path
                   (expand-filename
                      (second spec)
                      path)))
               
               (elinstall-find-actions-by-spec
                  (third spec)
                  load-path-element
                  new-path
                  parameters)))
         
         (all
            (apply #'append
               (mapcar
                  #'(lambda (sub-spec)
                       (elinstall-find-actions-by-spec 
                          sub-spec
                          load-path-element 
                          path
                          parameters))
                  (cdr spec))))
         
         (dir
            (let
               ((dirname 
                   (expand-filename
                      (second spec) 
                      path))
                  (load-path-here
                     (not
                        (elinstall-get-parameter 
                           parameters 'block-add-to-load-path))))
               (cons
                  (if load-path-here
                     `(add-to-load-path
                         ,(elinstall-get-parameter 
                             parameters 'def-file)
                         ,dirname)
                     '())
                  ;;$$IMPROVE ME
                  ;; We want to get a value for generated-autoload-file
                  ;; from the local variables section if it's there.
                  ;; Otherwise we'll use `def-file' in parameters.

                  ;;$$FIXME This isn't quite right.  If directory
                  ;;itself is not in load-path, this will be wrong.
                  ;;Gotta know where our encompassing part of
                  ;;load-path is.
                  (mapcar
                     #'(lambda (filename)
                          `(add-file-autoloads
                              ,(elinstall-get-parameter 
                                  parameters 'def-file)
                              (file-relative-name
                                 (expand-filename filename path)
                                 load-path-element)
                              load-path-element))
                  
                     (directory-files
                        dirname 
                        nil ;;Relative filenames
                        elinstall-elisp-regexp)))))
         
         (def-file
            (let
               ((new-def-file
                   (elinstall-expand-filename
                      (second spec) 
                      parameters)))
               (elinstall-find-actions-by-spec
                  (third spec)
                  load-path-element 
                  path
                  (elinstall-add-parameter parameters 
                     'def-file new-def-file)))))
      
      ;;$$IMPROVE ME by adding the other cases in the design.
      (case spec
         (t))))

;;;_  . Cleaning up
;;Nothing yet
;;;_  . elinstall-x
(defun elinstall-x (dir spec &optional target force)
   ""

   (let*
      ()
      
      ))
;;;_ , Entry points
(defun elinstall (project-name dir spec &optional target force)
   "Install elisp files.

They need not be presented as a package.

Parameters:
PROJECT-NAME - the name of the project
DIR - the root directory of the project.
  Suggestion: (elinstall-directory-true-name)

SPEC - a spec for the autoloads etc to make.  It can be as simple as
  `(in DIRECTORY t).  
  Suggestion: `(in ,(elinstall-directory-true-name) t)
TARGET is where the autoload files are to be symlinked in.  If
`nil' `elinstall-default-target' is used instead.

If FORCE is t, install a package even if it has already been
installed.
Other non-nil cases of FORCE are reserved for future development."
   
   (when
      (and
         (or 
            force
            (not (elinstall-already-installed project-name)))
         ;;$$REMOVE ME - I commented it out just for development.
         '(yes-or-no-p (format "Install %s " project-name)))
      (let *
         ((actions
             (elinstall-find-actions-by-spec
                spec
                nil
                dir
                `(
                    ;;$$RETHINK ME - maybe hand this work off to autoload?
                    ;;This is just the default loaddefs file, spec actually
                    ;;controls it.
                    (def-file . "elinstall-loaddefs.el" ))))
            (segment-list (elinstall-segregate-actions actions)))
         
         (mapcar 
            #'(lambda (segment)
                 (elinstall-do-segment segment force))
            segment-list)
         ;;$$REMOVE ME - I commented it out just for development.
         '(elinstall-record-installed project-name))))


;;;_   , elinstall-update-directory-autoloads
;;$$PUNT
(defun elinstall-update-directory-autoloads (dir)
   ""
   
   (interactive "DUpdate autoloads from directory: ")

   (elinstall 
      ;;$$IMPROVE ME make DIR absolute
      (format "Elisp files of %s" dir) 
      dir
      '(dir ".")
      (autoload-ensure-default-file 
         (expand-file-name generated-autoload-file
            (expand-file-name "lisp" source-directory)))))


;;;_   , elinstall-update-file-autoloads
;;$$PUNT
(defun elinstall-update-file-autoloads (file &optional save-after)
   ""
   
   (interactive "fUpdate autoloads for file: \np")
   (elinstall 
      (format "Elisp file %s" file) 
      dir
      `(file ,file)
      (autoload-ensure-default-file 
         (expand-file-name generated-autoload-file
            (expand-file-name "lisp" source-directory))))
   )




;;;_. Footers
;;;_ , Provides

(provide 'elinstall)

;;;_ * Local emacs vars.
;;;_  + Local variables:
;;;_  + mode: allout
;;;_  + End:

;;;_ , End
;;; elinstall.el ends here