689 lines
30 KiB
EmacsLisp
689 lines
30 KiB
EmacsLisp
;;; nxhtml-web-vcs.el --- nXhtml things for web-vcs.el
|
|
;;
|
|
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
|
|
;; Created: 2010-01-13 Wed
|
|
;; Version:
|
|
;; Last-Updated:
|
|
;; URL:
|
|
;; Keywords:
|
|
;; Compatibility:
|
|
;;
|
|
;; Features that might be required by this library:
|
|
;;
|
|
;; None
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Change log:
|
|
;;
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;; This program 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 3, or
|
|
;; (at your option) any later version.
|
|
;;
|
|
;; This program 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 this program; see the file COPYING. If not, write to
|
|
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
|
|
;; Floor, Boston, MA 02110-1301, USA.
|
|
;;
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;
|
|
;;; Code:
|
|
|
|
(eval-when-compile (require 'cl))
|
|
(eval-when-compile (require 'nxhtml-base nil t))
|
|
;;(eval-when-compile (require 'nxhtmlmaint nil t))
|
|
(eval-when-compile (require 'web-vcs nil t))
|
|
|
|
(defvar nxhtml-web-vcs-file (or load-file-name
|
|
(when (boundp 'bytecomp-filename) bytecomp-filename)
|
|
buffer-file-name)
|
|
"This file.")
|
|
|
|
(defun nxhtml-require-base ()
|
|
(require 'nxhtml-base nil t)
|
|
(unless (featurep 'nxhtml-base)
|
|
;; At startup, need to load it by hand.
|
|
(let ((load-path load-path))
|
|
(add-to-list 'load-path (file-name-directory nxhtml-web-vcs-file))
|
|
(require 'nxhtml-base))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; Repository URL
|
|
|
|
|
|
;;(nxhtml-default-download-directory)
|
|
(defun nxhtml-default-download-directory ()
|
|
(let* ((ur (expand-file-name "" "~"))
|
|
(ur-len (length ur))
|
|
(full (if (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir)
|
|
nxhtml-install-dir
|
|
(file-name-as-directory
|
|
(expand-file-name ""
|
|
(web-vcs-default-download-directory)))))
|
|
(full-len (length full)))
|
|
(if (and (> full-len ur-len)
|
|
(string= ur (substring full 0 ur-len)))
|
|
(concat "~" (substring full ur-len))
|
|
full)))
|
|
|
|
|
|
(defun nxhtml-web-vcs-read-dl-dir (prompt)
|
|
"Return current nXhtml install dir or read dir."
|
|
(or (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir)
|
|
(let* ((pr (concat
|
|
"A directory named 'nxhtml' will be created below the root you give."
|
|
"\n"
|
|
prompt))
|
|
(root (read-directory-name pr (nxhtml-default-download-directory))))
|
|
(when root
|
|
(expand-file-name "nxhtml" root)))))
|
|
|
|
;;(call-interactively 'nxhtml-setup-install)
|
|
;; (read-key "Prompt: ")
|
|
;; (y-or-n-p "Prompt")
|
|
;;;###autoload
|
|
(defun nxhtml-setup-install (way)
|
|
"Setup and start nXhtml installation.
|
|
|
|
This is for installation and updating directly from the nXhtml
|
|
development sources.
|
|
|
|
There are two different ways to install:
|
|
|
|
(1) Download all at once: `nxhtml-setup-download-all'
|
|
(2) Automatically download part by part: `nxhtml-setup-auto-download'
|
|
|
|
You can convert between those ways by calling this function again.
|
|
You can also do this by setting the option `nxhtml-autoload-web' yourself.
|
|
|
|
When you have nXhtml installed you can update it:
|
|
|
|
(3) Update new files in nXhtml: `nxhtml-update-existing-files'
|
|
|
|
To learn more about nXhtml visit its home page at URL
|
|
`http://www.emacswiki.com/NxhtmlMode/'.
|
|
|
|
If you want to test auto download \(but not use it further) there
|
|
is a special function for that, you answer T here:
|
|
|
|
(T) Test automatic download part by part: `nxhtml-setup-test-auto-download'
|
|
|
|
======
|
|
*Note*
|
|
If you want to download a zip file with latest released version instead then
|
|
please see URL `http://ourcomments.org/Emacs/nXhtml/doc/nxhtml.html'."
|
|
(interactive (let ((curr-cfg (current-window-configuration)))
|
|
(describe-function 'nxhtml-setup-install)
|
|
(select-window (get-buffer-window (help-buffer)))
|
|
(delete-other-windows)
|
|
(list
|
|
(let* ((key nil)
|
|
(has-nxhtml (and (boundp 'nxhtml-install-dir) nxhtml-install-dir))
|
|
(current-way (if has-nxhtml
|
|
(if (and (boundp 'nxhtml-autoload-web)
|
|
nxhtml-autoload-web)
|
|
"Your current setup is to download part by part from the web."
|
|
"Your current setup it to download all of nXhtml at once.")
|
|
"(You have not currently installed nXhtml.)"))
|
|
(prompt (concat "Setup nXhtml install."
|
|
"\n" current-way
|
|
"\n"
|
|
"\n(1) Download whole at once, or (2) part by part as needed"
|
|
(if has-nxhtml "\n(3) Update your existing nXhtml" "")
|
|
"\n(T) For temporary testing downloading part by part"
|
|
"\n"
|
|
"\n(? for help, q to quit): "))
|
|
(allowed-keys (if has-nxhtml
|
|
'(?1 ?2 ?3 ?T ?q 7)
|
|
'(?1 ?2 ?T ?q 7)))
|
|
(please nil))
|
|
(while (not (member key allowed-keys))
|
|
(if (not (member key '(??)))
|
|
(when key
|
|
(unless please
|
|
(setq prompt (concat "Please answer with one of the alternatives.\n\n"
|
|
prompt))
|
|
(setq please t)))
|
|
(describe-function 'nxhtml-setup-install)
|
|
(select-window (get-buffer-window (help-buffer)))
|
|
(delete-other-windows))
|
|
(setq key (web-vcs-read-key prompt))
|
|
;;(message "key = %S" key) (sit-for 1)
|
|
)
|
|
(case key
|
|
(7 (set-window-configuration curr-cfg)
|
|
nil)
|
|
(?1 'whole)
|
|
(?2 'part-by-part)
|
|
(?3 'update-existing)
|
|
(?T 'test-part-by-part)
|
|
)))))
|
|
(message "")
|
|
(case way
|
|
(whole (call-interactively 'nxhtml-setup-download-all))
|
|
(part-by-part (call-interactively 'nxhtml-setup-auto-download))
|
|
(update-existing (call-interactively 'nxhtml-update-existing-files))
|
|
(test-part-by-part (call-interactively 'nxhtml-setup-test-auto-download))
|
|
((eq nil way) nil)
|
|
(t (error "Unknown way = %S" way))))
|
|
|
|
(defvar nxhtml-basic-files '(
|
|
"nxhtml-base.el"
|
|
"nxhtml-loaddefs.el"
|
|
"web-autoload.el"
|
|
"etc/schema/schema-path-patch.el"
|
|
"nxhtml/nxhtml-autoload.el"
|
|
"autostart.el"
|
|
))
|
|
|
|
;;;###autoload
|
|
(defun nxhtml-setup-auto-download (dl-dir)
|
|
"Set up to autoload nXhtml files from the web.
|
|
|
|
This function will download some initial files and then setup to
|
|
download the rest when you need them.
|
|
|
|
Files will be downloaded under the directory root you specify in
|
|
DL-DIR.
|
|
|
|
Note that files will not be upgraded automatically. The auto
|
|
downloading is just for files you are missing. (This may change a
|
|
bit in the future.) If you want to upgrade those files that you
|
|
have downloaded you can just call `nxhtml-update-existing-files'.
|
|
|
|
You can easily switch between this mode of downloading or
|
|
downloading the whole of nXhtml by once. To switch just call the
|
|
command `nxhtml-setup-install'.
|
|
|
|
See also the command `nxhtml-setup-download-all'.
|
|
|
|
Note: If your nXhtml is to old you can't use this function
|
|
directly. You have to upgrade first, se the function
|
|
above. Version 2.07 or above is good for this."
|
|
(interactive (progn
|
|
(describe-function 'nxhtml-setup-auto-download)
|
|
(select-window (get-buffer-window (help-buffer)))
|
|
(delete-other-windows)
|
|
(nxhtml-check-convert-to-part-by-part)
|
|
(list
|
|
(progn
|
|
(when (and (boundp 'nxhtml-autoload-web)
|
|
(not nxhtml-autoload-web))
|
|
(unless (yes-or-no-p "Convert to updating nXhtml part by part? ")
|
|
(throw 'command-level nil)))
|
|
(nxhtml-web-vcs-read-dl-dir "Download nXhtml part by part to directory: ")))))
|
|
(catch 'command-level
|
|
(if (not dl-dir)
|
|
(unless (with-no-warnings (called-interactively-p))
|
|
(error "dl-dir should be a directory"))
|
|
(nxhtml-check-convert-to-part-by-part)
|
|
(when (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir)
|
|
(unless (string= (file-truename dl-dir)
|
|
(file-truename nxhtml-install-dir))
|
|
(error "Download dir must be same as nxhtml-install-dir=%S" nxhtml-install-dir)))
|
|
(let* (;; Need some files:
|
|
(web-vcs-el-src (concat (file-name-sans-extension web-vcs-el-this) ".el"))
|
|
(web-vcs-el (expand-file-name (file-name-nondirectory web-vcs-el-src)
|
|
dl-dir))
|
|
(vcs 'lp)
|
|
(base-url (nxhtml-download-root-url nil))
|
|
(byte-comp (if (boundp 'web-autoload-autocompile)
|
|
web-autoload-autocompile
|
|
t))
|
|
(has-nxhtml (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir))
|
|
(web-vcs-folder-cache nil))
|
|
(setq nxhtml-install-dir dl-dir)
|
|
(let ((root (file-name-directory dl-dir)))
|
|
(unless (file-exists-p root)
|
|
(unless (yes-or-no-p (format "Directory %S does not exist, create it? " root))
|
|
(error "Aborted by user"))))
|
|
(make-directory dl-dir t)
|
|
(setq message-log-max t)
|
|
(view-echo-area-messages)
|
|
(message "")
|
|
(message "")
|
|
(web-vcs-message-with-face 'web-vcs-green "==== Starting nXhtml part by part state ====")
|
|
(message "has-nxhtml=%s" has-nxhtml)
|
|
;; Fix-me: First copy this file and web-vcs.el to its destination:
|
|
(unless (string= (file-truename dl-dir)
|
|
(file-truename (file-name-directory nxhtml-web-vcs-file)))
|
|
(dolist (f (list web-vcs-el-src nxhtml-web-vcs-file))
|
|
(copy-file f (expand-file-name (file-name-nondirectory f) dl-dir)
|
|
'ok-overwrite)))
|
|
(when byte-comp (web-vcs-byte-compile-newer-file web-vcs-el t))
|
|
;; Get basic file list:
|
|
(catch 'web-autoload-comp-restart
|
|
;;(let ((file-mask (regexp-opt nxhtml-basic-files)))
|
|
;; (web-vcs-get-missing-matching-files vcs base-url dl-dir file-mask))
|
|
(dolist (f nxhtml-basic-files)
|
|
(web-vcs-get-missing-matching-files vcs base-url dl-dir f))
|
|
;; Autostart.el has not run yet, add download dir to load-path.
|
|
(let ((load-path (cons (file-name-directory web-vcs-el) load-path)))
|
|
(when byte-comp
|
|
(dolist (file nxhtml-basic-files)
|
|
(let ((el-file (expand-file-name file dl-dir)))
|
|
(web-vcs-byte-compile-newer-file el-file nil)))))
|
|
(let ((autostart-file (expand-file-name "autostart" dl-dir)))
|
|
;;(ad-deactivate 'require)
|
|
(web-vcs-set&save-option 'nxhtml-autoload-web t)
|
|
(web-vcs-log nil nil "* nXhtml: Download Part by Part as Needed\n")
|
|
(load autostart-file)
|
|
(unless (ad-is-active 'require) (ad-activate 'require))
|
|
(web-vcs-log-save)
|
|
(web-vcs-message-with-face 'web-vcs-green "==== Basic files for nXhtml part by part are now installed ====")
|
|
(web-vcs-display-messages t)
|
|
(unless has-nxhtml (nxhtml-add-loading-to-custom-file autostart-file t))))))))
|
|
|
|
;;(call-interactively 'nxhtml-download)
|
|
;;;###autoload
|
|
(defun nxhtml-setup-download-all (dl-dir)
|
|
"Download or update all of nXhtml.
|
|
|
|
You can download all if nXhtml with this command.
|
|
|
|
To update existing files use `nxhtml-update-existing-files'.
|
|
|
|
If you want to download only those files you are actually using
|
|
then call `nxhtml-setup-auto-download' instead.
|
|
|
|
See the command `nxhtml-setup-install' for a convenient way to
|
|
call these commands.
|
|
|
|
For more information about auto download of nXhtml files see
|
|
`nxhtml-setup-auto-download'."
|
|
(interactive (progn
|
|
(describe-function 'nxhtml-setup-auto-download)
|
|
(select-window (get-buffer-window (help-buffer)))
|
|
(delete-other-windows)
|
|
;;(nxhtml-check-convert-to-part-by-part)
|
|
(list
|
|
(nxhtml-web-vcs-read-dl-dir "Download whole nXhtml to directory: "))))
|
|
|
|
(let ((root (file-name-directory dl-dir)))
|
|
(unless (file-exists-p root)
|
|
(unless (yes-or-no-p (format "Directory %S does not exist, create it? " root))
|
|
(error "Aborted by user"))))
|
|
(make-directory dl-dir t)
|
|
(let ((msg (concat "Downloading nXhtml through Launchpad web interface will take rather long\n"
|
|
"time (5-15 minutes) so you may want to do it in a separate Emacs session.\n\n"
|
|
"Do you want to download using this Emacs session? "
|
|
)))
|
|
(if (not (y-or-n-p msg))
|
|
(message "Aborted")
|
|
(setq message-log-max t)
|
|
(let ((do-byte (y-or-n-p "Do you want to byte compile the files after downloading? ")))
|
|
(nxhtml-download-1 dl-dir nil do-byte)))))
|
|
|
|
|
|
(defun nxhtml-download-1 (dl-dir revision do-byte)
|
|
"Download nXhtml to directory DL-DIR.
|
|
If REVISION is nil download latest revision, otherwise the
|
|
specified one.
|
|
|
|
If DO-BYTE is non-nil byte compile nXhtml after download."
|
|
(let* ((has-nxhtml (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir))
|
|
(base-url nxhtml-web-vcs-base-url)
|
|
(files-url (concat base-url "files/"))
|
|
;;(revs-url (concat base-url "changes/"))
|
|
(rev-part (if revision (number-to-string revision) "head%3A/"))
|
|
(full-root-url (concat files-url rev-part))
|
|
(web-vcs-folder-cache nil)
|
|
(web-autoload-paranoid nil))
|
|
;;(nxhtml-require-base)
|
|
(when (web-vcs-get-files-from-root 'lp full-root-url dl-dir)
|
|
(web-vcs-display-messages t)
|
|
(web-vcs-log nil nil "* nXhtml: Download All\n")
|
|
(web-vcs-set&save-option 'nxhtml-autoload-web nil)
|
|
(message "")
|
|
(web-vcs-message-with-face 'web-vcs-green "==== Starting downloading whole nXhtml ====")
|
|
(let ((autostart-file (expand-file-name "autostart" dl-dir)))
|
|
(load autostart-file)
|
|
(web-vcs-log-save)
|
|
(web-vcs-message-with-face 'web-vcs-green "==== All files for nXhtml are now installed ====")
|
|
(nxhtmlmaint-byte-recompile)
|
|
(unless has-nxhtml (nxhtml-add-loading-to-custom-file autostart-file nil))))))
|
|
|
|
(defun nxhtml-check-convert-to-part-by-part ()
|
|
(when (and (boundp 'nxhtml-install-dir)
|
|
nxhtml-install-dir)
|
|
(unless (and (boundp 'nxhtml-autoload-web)
|
|
nxhtml-autoload-web)
|
|
(if (not (boundp 'nxhtml-menu:version))
|
|
(error "nxhtml-install-dir set but no version found")
|
|
(unless (string-match "[\.0-9]+" nxhtml-menu:version)
|
|
(error "Can't find current version nxhtml-menu:version=%S" nxhtml-menu:version))
|
|
(let* ((ver-str (match-string 0 nxhtml-menu:version))
|
|
(ver-num (string-to-number ver-str)))
|
|
(when (< ver-num 2.07)
|
|
(web-vcs-message-with-face 'web-vcs-red "Too old nXhtml for download part by part.")
|
|
(throw 'command-level nil)))))))
|
|
|
|
|
|
;;(directory-files default-directory nil "\\el$")
|
|
;;(directory-files default-directory nil "[^#~]$")
|
|
;;;###autoload
|
|
(defun nxhtml-update-existing-files ()
|
|
"Update existing nXhtml files from the development sources.
|
|
Only files you already have will be updated.
|
|
|
|
Note that this works both if you have setup nXhtml to auto
|
|
download files as you need them or if you have downloaded all of
|
|
nXhtml at once.
|
|
|
|
For more information about installing and updating nXhtml see the
|
|
command `nxhtml-setup-install'."
|
|
;; Fix-me: download new files too if you are not auto downloading.
|
|
(interactive)
|
|
(when (y-or-n-p "Do you want to update your nXhtml files? ")
|
|
(message "")
|
|
(web-vcs-display-messages t)
|
|
(web-vcs-message-with-face 'web-vcs-yellow "*\nStarting updating your nXhtml files.\n*\n")
|
|
(message nil)
|
|
(web-vcs-clear-folder-cache)
|
|
(let ((vcs 'lp)
|
|
(base-url (nxhtml-download-root-url nil))
|
|
(dl-dir nxhtml-install-dir)
|
|
web-vcs-folder-cache)
|
|
(setq dl-dir (file-name-as-directory dl-dir))
|
|
(web-vcs-update-existing-files vcs base-url dl-dir dl-dir)
|
|
(web-vcs-clear-folder-cache))
|
|
(display-buffer (get-buffer-create "*Compile-Log*"))
|
|
(nxhtmlmaint-byte-recompile)
|
|
(web-vcs-log-save)
|
|
(web-vcs-message-with-face 'web-vcs-yellow "*\nFinished updating your nXhtml files.\n*\n")
|
|
(message nil)))
|
|
|
|
|
|
;;(nxhtml-maybe-download-files (expand-file-name "nxhtml/doc/img/" nxhtml-install-dir) nil)
|
|
;;;###autoload
|
|
(defun nxhtml-get-missing-files (sub-dir file-name-list)
|
|
(let (file-mask
|
|
(root-url (nxhtml-download-root-url nil))
|
|
files-regexp
|
|
(full-dir (expand-file-name sub-dir nxhtml-install-dir))
|
|
miss-names)
|
|
(if file-name-list
|
|
(progn
|
|
(dolist (f file-name-list)
|
|
(let ((full-f (expand-file-name f full-dir)))
|
|
(unless (file-exists-p full-f)
|
|
(setq miss-names (cons f miss-names)))))
|
|
(setq files-regexp (regexp-opt miss-names)))
|
|
(setq files-regexp ".*"))
|
|
;;(unless (file-exists-p full-dir) (make-directory full-dir t))
|
|
(setq file-mask
|
|
(concat (file-relative-name (file-name-as-directory full-dir)
|
|
nxhtml-install-dir)
|
|
files-regexp))
|
|
(let ((web-vcs-folder-cache nil))
|
|
(web-vcs-get-missing-matching-files 'lp root-url nxhtml-install-dir
|
|
file-mask))))
|
|
|
|
;; Fix-me: Does not work, Emacs Bug
|
|
;; Maybe use wget? http://gnuwin32.sourceforge.net/packages/wget.htm
|
|
;; http://emacsbugs.donarmstrong.com/cgi-bin/bugreport.cgi?bug=5103
|
|
;; (nxhtml-get-release-revision)
|
|
(defun nxhtml-get-release-revision ()
|
|
"Get revision number for last release."
|
|
(let* ((all-rev-url "http://code.launchpad.net/%7Enxhtml/nxhtml/main")
|
|
(url-buf (url-retrieve-synchronously all-rev-url))
|
|
(vcs-rec (or (assq 'lp web-vcs-links-regexp)
|
|
(error "Does not know web-vcs 'lp")))
|
|
(rel-ver-regexp (nth 6 vcs-rec))
|
|
)
|
|
(message "%S" url-buf)
|
|
(with-current-buffer url-buf
|
|
(when (re-search-forward rel-ver-regexp nil t)
|
|
(match-string 1)))))
|
|
|
|
;;;###autoload
|
|
(defun nxhtml-byte-compile-file (file &optional load)
|
|
(let ((extra-load-path (when nxhtml-install-dir
|
|
(mapcar (lambda (p)
|
|
(file-name-as-directory
|
|
(expand-file-name p nxhtml-install-dir)))
|
|
'("tests" "related" "nxhtml" "util" ".")))))
|
|
;; (message "nxhtml-byte-compile-file:extra-load-path=%s" extra-load-path)
|
|
(web-vcs-byte-compile-file file load extra-load-path)))
|
|
|
|
;; fix-me: change web-vcs-byte-compile-file instead
|
|
;;;###autoload
|
|
(defun nxhtml-byte-recompile-file (file &optional load)
|
|
"Byte recompile FILE file if necessary.
|
|
For more information see `nxhtml-byte-compile-file'.
|
|
Loading is done if recompiled and LOAD is t."
|
|
(interactive (list (buffer-file-name)
|
|
t))
|
|
(let ((elc-file (byte-compile-dest-file file)))
|
|
(if (file-newer-than-file-p file elc-file)
|
|
(nxhtml-byte-compile-file file load)
|
|
(message "Byte compilation of this file is up to date."))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; Add to custom file
|
|
|
|
|
|
(defvar nxhtml-handheld-wincfg nil)
|
|
(defun nxhtml-handheld-restore-wincg ()
|
|
(when nxhtml-handheld-wincfg
|
|
(set-window-configuration nxhtml-handheld-wincfg)
|
|
(setq nxhtml-handheld-wincfg nil)))
|
|
|
|
;;(nxhtml-handheld-add-loading-to-custom-file "TEST-ME")
|
|
(defun nxhtml-handheld-add-loading-to-custom-file (file-to-load)
|
|
(setq nxhtml-handheld-wincfg (current-window-configuration))
|
|
(delete-other-windows)
|
|
(let ((info-buf (get-buffer-create "Information about how to add nXhtml to (custom-file)"))
|
|
(load-str (format "(load %S)" file-to-load)))
|
|
(with-current-buffer info-buf
|
|
(add-hook 'kill-buffer-hook 'nxhtml-handheld-restore-wincg nil t)
|
|
(insert "Insert the following line to (custom-file), ie the file in the other window:\n\n")
|
|
(let ((here (point)))
|
|
(insert " "
|
|
(propertize load-str 'face 'secondary-selection)
|
|
"\n")
|
|
(copy-region-as-kill here (point))
|
|
(insert "\nThe line above is in the clipboard so you can just paste it where you want it.\n")
|
|
(insert "When ready kill this buffer.")
|
|
(goto-char here))
|
|
(setq buffer-read-only t)
|
|
(set-buffer-modified-p nil))
|
|
(set-window-buffer (selected-window) info-buf)
|
|
(find-file-other-window (custom-file))))
|
|
|
|
;; (nxhtml-add-loading-to-custom-file "test-file")
|
|
(defun nxhtml-add-loading-to-custom-file (file-to-load part-by-part)
|
|
(message "")
|
|
(require 'cus-edit)
|
|
(if (not (condition-case nil (custom-file) (error nil)))
|
|
(progn
|
|
(message "\n\n")
|
|
(web-vcs-message-with-face
|
|
'web-vcs-red
|
|
(concat "Since you have started this Emacs session without running your init files"
|
|
"\nthey are unknown and the installation can not add the statement below."
|
|
"\nTo finish the setup of nXhtml you must add"
|
|
"\n\n (load %S)"
|
|
"\n\nto your custom-file if you have not done it yet."
|
|
"\nYou must also customize the variable `nxhtml-autoload-web' to tell that"
|
|
(if part-by-part
|
|
"\nyou want to download nXhml files as you need them."
|
|
"\nyou do not want to allow automatic downloading of nXhtml files."
|
|
)
|
|
"\n")
|
|
file-to-load)
|
|
(message "")
|
|
(web-vcs-display-messages t))
|
|
(let ((prompt (concat "Basic setup of nXhtml is done, but it must be loaded from (custom-file)."
|
|
"\nShould I add loading of nXhtml to (custom-file) for you? ")))
|
|
(if (yes-or-no-p prompt)
|
|
(nxhtml-add-loading-to-custom-file-auto file-to-load)
|
|
(if (yes-or-no-p "Should I guide you through how to do it? ")
|
|
(nxhtml-handheld-add-loading-to-custom-file file-to-load)
|
|
(web-vcs-message-with-face 'web-vcs-green
|
|
"OK. You need to add (load %S) to your init file" file-to-load))))))
|
|
|
|
;; Fix-me: really do this? Is it safe enough?
|
|
(defun nxhtml-add-loading-to-custom-file-auto (file-to-load)
|
|
(unless (file-name-absolute-p file-to-load)
|
|
(error "nxhtml-add-loading-to-custom-file: Not abs file name: %S" file-to-load))
|
|
(let ((old-buf (find-buffer-visiting (custom-file)))
|
|
(full-to-load (expand-file-name file-to-load)))
|
|
(with-current-buffer (or old-buf (find-file-noselect (custom-file)))
|
|
(save-restriction
|
|
(widen)
|
|
(catch 'done
|
|
(while (progn
|
|
(while (progn (skip-chars-forward " \t\n\^l")
|
|
(looking-at ";"))
|
|
(forward-line 1))
|
|
(not (eobp)))
|
|
(let ((start (point))
|
|
(form (read (current-buffer))))
|
|
(when (eq (nth 0 form) 'load)
|
|
(let* ((form-file (nth 1 form))
|
|
(full-form-file (expand-file-name form-file)))
|
|
(when (string= full-form-file full-to-load)
|
|
(throw 'done nil))
|
|
(when (and (string= (file-name-nondirectory full-form-file)
|
|
(file-name-nondirectory full-to-load))
|
|
(not (string= full-form-file full-to-load)))
|
|
(if (yes-or-no-p "Replace current nXhtml loading in (custom-file)? ")
|
|
(progn
|
|
(goto-char start) ;; at form start now
|
|
(forward-char (length "(load "))
|
|
(skip-chars-forward " \t\n\^l") ;; at start of string
|
|
(setq start (point))
|
|
(setq form (read (current-buffer)))
|
|
(delete-region start (point))
|
|
(insert (format "%S" full-to-load))
|
|
(basic-save-buffer))
|
|
(web-vcs-message-with-face 'web-vcs-red "Can't continue then")
|
|
(web-vcs-display-messages t)
|
|
(throw 'command-level nil)))))))
|
|
;; At end of file
|
|
(insert (format "\n(load %S)\n" file-to-load))
|
|
(basic-save-buffer))
|
|
(unless old-buf (kill-buffer old-buf))))))
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;;;;; Start Testing function
|
|
(defun emacs-Q-no-nxhtml (&rest args)
|
|
(let* ((old-env-load-path (getenv "EMACSLOADPATH"))
|
|
sub-env-load-path
|
|
(elp-list (or (when old-env-load-path
|
|
;;(split-string old-env-load-path ";"))
|
|
(split-string old-env-load-path path-separator))
|
|
load-path))
|
|
(sub-elp-list nil)
|
|
ret
|
|
(this-emacs-exe (locate-file invocation-name
|
|
(list invocation-directory)
|
|
exec-suffixes)))
|
|
(dolist (p elp-list)
|
|
(when (file-exists-p p)
|
|
(unless (string= nxhtml-install-dir p)
|
|
(let* ((dir (file-name-directory p))
|
|
(last (file-name-nondirectory p))
|
|
(last-dir (file-name-nondirectory
|
|
(directory-file-name dir))))
|
|
(unless (and (string= "nxhtml" last-dir)
|
|
(member last '("util" "test" "nxhtml" "related" "alt")))
|
|
(setq sub-elp-list (cons p sub-elp-list)))))))
|
|
;;(setq sub-env-load-path (mapconcat 'identity (reverse sub-elp-list) ";"))
|
|
(setq sub-env-load-path (mapconcat 'identity (reverse sub-elp-list) path-separator))
|
|
(setenv "EMACSLOADPATH" sub-env-load-path)
|
|
(setq ret (apply 'call-process this-emacs-exe nil 0 nil "-Q" args))
|
|
(setenv "EMACSLOADPATH" old-env-load-path)
|
|
ret))
|
|
|
|
;; (call-interactively-p 'nxhtml-setup-test-auto-download)
|
|
;; (nxhtml-setup-test-auto-download "c:/test2/")
|
|
(defun nxhtml-setup-test-auto-download (test-dir)
|
|
"Test autoload in a new emacs, started with 'emacs -Q'.
|
|
You can choose where to download the files and just delete them
|
|
when you have tested enough."
|
|
(interactive (list (read-directory-name "Directory for test of auto download of nXhtml: ")))
|
|
(let ((this-dir (file-name-directory web-vcs-el-this))
|
|
(this-name (file-name-nondirectory web-vcs-el-this))
|
|
that-file)
|
|
(when (and (file-exists-p test-dir)
|
|
(not (y-or-n-p (format "Directory %S exists, really test there? " test-dir))))
|
|
(error "Aborted"))
|
|
(unless (file-exists-p test-dir) (make-directory test-dir))
|
|
(setq that-file (expand-file-name this-name test-dir))
|
|
(when (file-exists-p that-file) (delete-file that-file))
|
|
(copy-file web-vcs-el-this that-file)
|
|
(emacs-Q-no-nxhtml "-l" that-file "-f" "nxhtml-setup-test-auto-download-do-it-here")))
|
|
|
|
(defun nxhtml-setup-test-auto-download-do-it-here ()
|
|
"Helper for `nxhtml-setup-test-auto-down-load'."
|
|
(let ((this-dir (file-name-directory web-vcs-el-this)))
|
|
(nxhtml-setup-auto-download this-dir)))
|
|
|
|
(defun web-vcs-check-if-modified ()
|
|
(let (
|
|
(t1 (format-time-string "%Y-%m-%dT%T%z" (date-to-time "2010-01-01 18:20")))
|
|
(t2 (format-time-string "%Y-%m-%dT%T%z" (date-to-time "Mon, 28 Dec 2009 08:57:44 GMT")))
|
|
(url-request-extra-headers
|
|
(list
|
|
(cons "If-Modified-Since"
|
|
(format-time-string
|
|
;;"%Y-%m-%dT%T%z"
|
|
"%a, %e %b %Y %H:%M:%S GMT"
|
|
(nth 5 (file-attributes "c:/test/temp.el" )))
|
|
)))
|
|
xb)
|
|
(setq xb (url-retrieve-synchronously "http://www.emacswiki.org/emacs/download/anything.el"))
|
|
(switch-to-buffer xb)
|
|
))
|
|
;; (emacs-Q-no-nxhtml "web-vcs.el" "-l" "c:/test/d27/web-autostart.el")
|
|
;; (emacs-Q-no-nxhtml "web-vcs.el" "-l" "c:/test/d27/autostart.el")
|
|
;; (emacs-Q-no-nxhtml "web-vcs.el" "-f" "eval-buffer" "-f" "nxhtml-temp-setup-auto-download")
|
|
;; (emacs-Q-no-nxhtml "-l" "c:/test/d27/web-vcs" "-l" "c:/test/d27/nxhtml-web-vcs" "-f" "nxhtml-temp-setup-auto-download")
|
|
;; (emacs-Q-no-nxhtml "-l" "c:/test/d27/nxhtml-web-vcs" "-f" "nxhtml-temp-setup-auto-download")
|
|
;; (emacs-Q-no-nxhtml "--geometry=200x50+100+100" "-l" "c:/test/d27/web-vcs" "-f" "web-vcs-nxhtml")
|
|
(defun nxhtml-temp-setup-auto-download ()
|
|
;;(when (fboundp 'w32-send-sys-command) (w32-send-sys-command #xf030) (sit-for 2))
|
|
(set-frame-size (selected-frame)
|
|
(/ 1024 (frame-char-width))
|
|
(/ 512 (frame-char-height))
|
|
)
|
|
(tool-bar-mode -1)
|
|
(set-frame-position (selected-frame) 100 50)
|
|
(when (y-or-n-p "Do nXhtml? ")
|
|
(view-echo-area-messages)
|
|
(setq truncate-lines t)
|
|
(split-window-horizontally)
|
|
(let ((load-path (cons default-directory load-path)))
|
|
(require 'web-vcs))
|
|
;(nxhtml-setup-auto-download "c:/test/d27")
|
|
(call-interactively 'nxhtml-setup-auto-download)
|
|
))
|
|
;;;;;; End Testing function
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
(provide 'nxhtml-web-vcs)
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;;; nxhtml-web-vcs.el ends here
|