;; Copyright (C) 2002 Free Software Foundation, Inc.
-;; Author: Thomas Link aka t.link (at gmx at)
-;; Time-stamp: <2002-03-22>
+;; Author: Thomas Link <t.link@gmx.at>
+;; Maintainer: FSF
;; Keywords: filesets convenience
+;; This file is part of GNU Emacs.
+
;; 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 2, or (at your option)
;; program's author or from the Free Software Foundation, Inc., 675 Mass
;; Ave, Cambridge, MA 02139, USA.
-(defvar filesets-version "1.8.1")
+(defvar filesets-version "1.8.4")
(defvar filesets-homepage
"http://members.a1.net/t.link/CompEmacsFilesets.html")
;;; Commentary:
-;;Define filesets, which can be opened or saved with the power one or
-;;two mouse clicks only. A fileset is either a list of files, a file
-;;pattern, a base directory and a search pattern (for files), or an
-;;inclusion group (i.e. a base file including other files).
+;; Define filesets, which can be opened or saved with the power of one or
+;; two mouse clicks only. A fileset is either a list of files, a file
+;; pattern, a base directory and a search pattern (for files), or an
+;; inclusion group (i.e. a base file including other files).
-;;Usage: 1. Put (require 'filesets) into your start-up file. 2. Type
-;;M-x filesets-edit or choose "Edit Filesets" from the menu. 3. Save
-;;your customizations.
+;; Usage:
+;; 1. Put (require 'filesets) and (filesets-init) in your .emacs file.
+;; 2. Type ;; M-x filesets-edit or choose "Edit Filesets" from the menu.
+;; 3. Save your customizations.
-;;Caveat: Fileset names have to be unique.
+;; Caveat: Fileset names have to be unique.
-;;Filesets.el adds a nifty filesets menu to your menubar. If you change
-;;your filesets on the fly, don't forget to select "Save Filesets" from
-;;the menu.
+;; Filesets.el adds a nifty filesets menu to your menubar. If you change
+;; your filesets on the fly, don't forget to select "Save Filesets" from
+;; the menu.
-;;Pressing on the first item in the submenu will open all files at once.
-;;Define your own function, e.g. browse-url, for opening a fileset's
-;;files. Or define external viewers for opening files with other
-;;programs. See `filesets-external-viewers'.
+;; Pressing on the first item in the submenu will open all files at once.
+;; Define your own function, e.g. browse-url, for opening a fileset's
+;; files. Or define external viewers for opening files with other
+;; programs. See `filesets-external-viewers'.
-;;BTW, if you close a fileset, files, which have been changed, will
-;;be silently saved. Change this behaviour by setting
-;;`filesets-save-buffer-fn'.
+;; BTW, if you close a fileset, files, which have been changed, will
+;; be silently saved. Change this behaviour by setting
+;; `filesets-save-buffer-fn'.
;;; Supported modes for inclusion groups (`filesets-ingroup-patterns'):
;; - Elisp
;;- better handling of different customization scenarios
+;; Data gathering should be better separated from building the menu
+;; so that one could (1) use filesets without installing the menu
+;; and (2) create new "frontends" to speedbar and others.
+
+;; The functionality to call external viewers should be isolated in
+;; an extra package and possibly integrated with the MIME
+;; handling.
;;; Credits:
;;; Some variables
-(unless (boundp 'filesets-running-xemacs)
+(eval-and-compile
(defvar filesets-running-xemacs (string-match "XEmacs\\|Lucid" emacs-version)
- "Non-nil means we are runninn XEmacs."))
+ "Non-nil means we are running XEmacs."))
(defvar filesets-menu-cache nil
"The whole filesets menu.")
(defvar filesets-ingroup-cache nil
"A plist containing files and their ingroup data.")
-(defvar filesets-ingroup-paths nil
- "A temporary list of path already processed when searching for
-included files.")
+(defvar filesets-ingroup-files nil
+ "List of files already processed when searching for included files.")
(defvar filesets-has-changed-flag t
"Non-nil means some fileset definition has changed.")
Is buffer local variable.")
(defvar filesets-verbosity 1
- "An integer defining the level of verbosity. 0 means no messages
-at all.")
+ "An integer defining the level of verbosity.
+0 means no messages at all.")
(defvar filesets-menu-ensure-use-cached
(and filesets-running-xemacs
(when (funcall cond-fn elt)
(setq rv (append rv (list elt)))))))
+(defun filesets-ormap (fsom-pred lst)
+ "Return the tail of FSOM-LST for the head of which FSOM-PRED is non-nil."
+ (let ((fsom-lst lst)
+ (fsom-rv nil))
+ (while (and (not (null fsom-lst))
+ (null fsom-rv))
+ (if (funcall fsom-pred (car fsom-lst))
+ (setq fsom-rv fsom-lst)
+ (setq fsom-lst (cdr fsom-lst))))
+ fsom-rv))
+
+(defun filesets-some (fss-pred fss-lst)
+ "Return non-nil if FSS-PRED is non-nil for any element of FSS-LST.
+Like `some', return the first value of FSS-PRED that is non-nil."
+ (catch 'exit
+ (dolist (fss-this fss-lst nil)
+ (let ((fss-rv (funcall fss-pred fss-this)))
+ (when fss-rv
+ (throw 'exit fss-rv))))))
+;(fset 'filesets-some 'some) ;; or use the cl function
+
+(defun filesets-member (fsm-item fsm-lst &rest fsm-keys)
+ "Find the first occurrence of FSM-ITEM in FSM-LST.
+It is supposed to work like cl's `member*'. At the moment only the :test
+key is supported."
+ (let ((fsm-test (or (plist-get fsm-keys ':test)
+ (function equal))))
+ (filesets-ormap (lambda (fsm-this)
+ (funcall fsm-test fsm-item fsm-this))
+ fsm-lst)))
+;(fset 'filesets-member 'member*) ;; or use the cl function
+
(defun filesets-sublist (lst beg &optional end)
"Get the sublist of LST from BEG to END - 1."
(let ((rv nil)
(let ((this (shell-command-to-string
(format "which --skip-alias %s 2> /dev/null | head -n 1"
cmd-list))))
- (if (equal this "")
+ (if (equal this "")
nil
(file-name-nondirectory (substring this 0 (- (length this) 1))))))
(setq filesets-has-changed-flag t)))
; (filesets-reset-fileset nil t)))
+(defvar filesets-data)
+
(defun filesets-data-set-default (sym val)
"Set the default for `filesets-data'."
(if filesets-menu-use-cached-flag
(dolist (x modified-filesets)
(filesets-reset-fileset (car x))))))
(filesets-set-default sym val))
-
-
-
+\f
;;; configuration
(defgroup filesets nil
"The fileset swapper."
:prefix "filesets-"
- :group 'convenience)
+ :group 'convenience
+ :version "22.1")
(defcustom filesets-menu-name "Filesets"
"*Filesets' menu name."
:type 'sexp
:group 'filesets)
-(defcustom filesets-menu-path nil
- "*The menu under which the filesets menu should be inserted.
+(if filesets-running-xemacs
+ (progn
+ (defcustom filesets-menu-path nil
+ "*The menu under which the filesets menu should be inserted.
XEmacs specific; see `add-submenu' for documentation."
- :set (function filesets-set-default)
- :type 'sexp
- :group 'filesets)
+ :set (function filesets-set-default)
+ :type 'sexp
+ :group 'filesets)
-(defcustom filesets-menu-before "File"
- "*The name of a menu before which this menu should be added.
+ (defcustom filesets-menu-before "File"
+ "*The name of a menu before which this menu should be added.
XEmacs specific; see `add-submenu' for documentation."
- :set (function filesets-set-default)
- :type 'sexp
- :group 'filesets)
+ :set (function filesets-set-default)
+ :type 'sexp
+ :group 'filesets)
-(defcustom filesets-menu-in-menu nil
- "*Use that instead of `current-menubar' as the menu to change.
+ (defcustom filesets-menu-in-menu nil
+ "*Use that instead of `current-menubar' as the menu to change.
XEmacs specific; see `add-submenu' for documentation."
- :set (function filesets-set-default)
- :type 'sexp
- :group 'filesets)
+ :set (function filesets-set-default)
+ :type 'sexp
+ :group 'filesets))
+ (defvar filesets-menu-path nil)
+ (defvar filesets-menu-before nil)
+ (defvar filesets-menu-in-menu nil))
(defcustom filesets-menu-shortcuts-flag t
"*Non-nil means to prepend menus with hopefully unique shortcuts."
(if filesets-running-xemacs
"~/.xemacs/filesets-cache.el"
"~/.filesets-cache.el")
- "*File to be used for saving the filesets menu between (X)Emacs
-sessions. Set this to \"\", to disable caching of menus.
+ "*File to be used for saving the filesets menu between sessions.
+Set this to \"\", to disable caching of menus.
Don't forget to check out `filesets-menu-ensure-use-cached'."
:set (function filesets-set-default)
:type 'file
:group 'filesets)
+(put 'filesets-menu-cache-file 'risky-local-variable t)
(defcustom filesets-menu-cache-contents
'(filesets-be-docile-flag
filesets-submenus
- filesets-menu-cache
+ filesets-menu-cache
filesets-ingroup-cache)
"*Stuff we want to save in `filesets-menu-cache-file'.
:group 'filesets)
(defcustom filesets-cache-hostname-flag nil
- "*Non-nil means cache the hostname. If the current name differs from
-the cached one, rebuild the menu and create a new cache file."
+ "*Non-nil means cache the hostname.
+If the current name differs from the cached one,
+rebuild the menu and create a new cache file."
:set (function filesets-set-default)
:type 'boolean
:group 'filesets)
:type 'integer
:group 'filesets)
-(defcustom filesets-browse-dir-fn 'dired
+(defcustom filesets-browse-dir-function 'dired
"*A function or command used for browsing directories.
When using an external command, \"%s\" will be replaced with the
directory's name.
:value nil))
:group 'filesets)
-(defcustom filesets-open-file-fn 'filesets-find-or-display-file
+(defcustom filesets-open-file-function 'filesets-find-or-display-file
"*The function used for opening files.
`filesets-find-or-display-file' ... Filesets' default function for
:value nil))
:group 'filesets)
-(defcustom filesets-save-buffer-fn 'save-buffer
+(defcustom filesets-save-buffer-function 'save-buffer
"*The function used to save a buffer.
Caveat: Changes will take effect after rebuilding the menu."
:set (function filesets-set-default)
(defcustom filesets-tree-max-level 3
"*Maximum scan depth for directory trees.
A :tree fileset is defined by a base directory the contents of which
-will be recursively added to the menu. filesets-tree-max-level tells up
+will be recursively added to the menu. `filesets-tree-max-level' tells up
to which level the directory structure should be scanned/listed,
i.e. how deep the menu should be. Try something like
(function :tag "Function"
:value nil)))))
:group 'filesets)
+(put 'filesets-commands 'risky-local-variable t)
(defcustom filesets-external-viewers
(let
:constraintp FUNCTION ... use this viewer only if FUNCTION returns non-nil
-:constraint-flag SYMBOL ... use this viewer only if SYMBOL is non-nil
+:constraint-flag SEXP ... use this viewer only if SEXP evaluates to non-nil
:open-hook HOOK ... run hooks after spawning the viewer -- mainly useful
in conjunction with :capture-output
:value (:constraint-flag)
(const :format ""
:value :constraint-flag)
- (symbol :tag "Symbol"))
+ (sexp :tag "Symbol"))
(list :tag ":ignore-on-open-all"
:value (:ignore-on-open-all t)
(const :format ""
:value :capture-output)
(boolean :tag "Boolean"))))))
:group 'filesets)
-
+(put 'filesets-external-viewers 'risky-local-variable t)
(defcustom filesets-ingroup-patterns
'(("^.+\\.tex$" t
(:get-file-name (lambda (master file)
(filesets-which-file master
(concat file ".sty")
- (filesets-convert-path-list
+ (filesets-convert-path-list
(or (getenv "MY_TEXINPUTS")
(getenv "TEXINPUTS")))))))
((:name "Include")
(:get-file-name (lambda (master file)
(filesets-which-file master
(concat file ".tex")
- (filesets-convert-path-list
+ (filesets-convert-path-list
(or (getenv "MY_TEXINPUTS")
(getenv "TEXINPUTS"))))))
(:scan-depth 5))
(:get-file-name (lambda (master file)
(filesets-which-file master
(concat file ".tex")
- (filesets-convert-path-list
+ (filesets-convert-path-list
(or (getenv "MY_TEXINPUTS")
(getenv "TEXINPUTS"))))))
(:scan-depth 5))
(:get-file-name (lambda (master file)
(filesets-which-file master
(concat file ".bib")
- (filesets-convert-path-list
+ (filesets-convert-path-list
(or (getenv "MY_BIBINPUTS")
(getenv "BIBINPUTS")))))))))
("^.+\\.el$" t
(const :format "" :value :preprocess)
(function :tag "Function")))))))
:group 'filesets)
+(put 'filesets-ingroup-patterns 'risky-local-variable t)
(defcustom filesets-data
nil
:filter-dirs-flag BOOLEAN ... is only used in conjunction with :tree.
:tree-max-level INTEGER ... recurse into directories this many levels
-(see `filesets-tree-max-level' for a full explanation)
+\(see `filesets-tree-max-level' for a full explanation)
:dormant-flag BOOLEAN ... non-nil means don't show this item in the
menu; dormant filesets can still be manipulated via commands available
In conjunction with the :tree tag, :save is void. :open refers to the
function used for opening files in a directory, not for opening the
-directory. For browsing directories, `filesets-browse-dir-fn' is used.
+directory. For browsing directories, `filesets-browse-dir-function' is used.
Before using :ingroup, make sure that the file type is already
defined in `filesets-ingroup-patterns'."
:value (:open)
(const :format "" :value :open)
(function :tag "Function")))))))
+(put 'filesets-data 'risky-local-variable t)
(defcustom filesets-query-user-limit 15
:set (function filesets-set-default)
:type 'integer
:group 'filesets)
-
-
-(defun filesets-error (class &rest args)
- "`error' wrapper."
- (error (apply 'concat
- (mapcar (lambda (x) (format "%s " x))
- args))))
-
+\f
;;; Emacs compatibility
(eval-and-compile
(if filesets-running-xemacs
(progn
+ (fset 'filesets-error 'error)
(fset 'filesets-add-submenu 'add-submenu))
-
- (progn
- (require 'easymenu)
-
- ;; This should work for 21.1 Emacs
- (defun filesets-add-submenu (menu-path submenu &optional
- before in-menu)
- "`easy-menu-define' wrapper."
- (easy-menu-define
- filesets-submenu global-map "Filesets menu" submenu))
- )))
+ (require 'easymenu)
-;;; helper
-;(defmacro filesets-testing (feature messagep &rest body)
-; (cond
-; ((equal filesets-version "testing")
-; `(progn ,@body))
-; (messagep
-; (message "Filestats: feature `%s' is disabled." feature)
-; nil)
-; (t
-; nil)))
+ (defun filesets-error (class &rest args)
+ "`error' wrapper."
+ (error (mapconcat 'identity args " ")))
-;(defun filesets-not-yet-implemented (feature)
-; (message "Filestats: `%s' is not yet implemented." feature))
+ ;; This should work for 21.1 Emacs
+ (defun filesets-add-submenu (menu-path submenu &optional
+ before in-menu)
+ "`easy-menu-define' wrapper."
+ (easy-menu-define
+ filesets-submenu global-map "Filesets menu" submenu))
+ ))
(defun filesets-filter-dir-names (lst &optional negative)
"Remove non-directory names from a list of strings. If NEGATIVE is
(lambda (a b)
(string< (upcase (funcall fni a))
(upcase (funcall fni b)))))))
- (sort (copy-list lst) fn))
+ (sort (copy-sequence lst) fn))
lst))
(defun filesets-directory-files (dir &optional
(let ((files nil)
(dirs nil))
(dolist (this (file-name-all-completions "" dir))
- (cond
+ (cond
((string-match "^\\.+/$" this)
nil)
((string-match "[:/\\]$" this)
(when (or (not match-dirs-flag)
(not pattern)
(string-match pattern this))
- (filesets-message 5 "Filesets: matched dir %S with pattern %S"
+ (filesets-message 5 "Filesets: matched dir %S with pattern %S"
this pattern)
(setq dirs (cons this dirs))))
(t
(when (or (not pattern)
(string-match pattern this))
- (filesets-message 5 "Filesets: matched file %S with pattern %S"
+ (filesets-message 5 "Filesets: matched file %S with pattern %S"
this pattern)
(setq files (cons (if full-flag
(concat (file-name-as-directory dir) this)
filename)))
(if (file-exists-p f)
f
- (some (lambda (dir)
- (let ((dir (file-name-as-directory dir))
- (files (if (file-exists-p dir)
- (filesets-directory-files dir nil ':files)
- nil)))
- (some (lambda (file)
- (if (equal filename (file-name-nondirectory file))
- (concat dir file)
- nil))
- files)))
- path-list))))
+ (filesets-some
+ (lambda (dir)
+ (let ((dir (file-name-as-directory dir))
+ (files (if (file-exists-p dir)
+ (filesets-directory-files dir nil ':files)
+ nil)))
+ (filesets-some (lambda (file)
+ (if (equal filename (file-name-nondirectory file))
+ (concat dir file)
+ nil))
+ files)))
+ path-list))))
(defun filesets-eviewer-get-props (entry)
(defun filesets-get-external-viewer (file)
"Find an external viewer for FILE."
(let ((filename (file-name-nondirectory file)))
- (some
+ (filesets-some
(lambda (entry)
(when (and (string-match (nth 0 entry) filename)
(filesets-eviewer-constraint-p entry))
(defun filesets-get-external-viewer-by-name (name)
"Get the external viewer definition called NAME."
(when name
- (some
+ (filesets-some
(lambda (entry)
(when (and (string-equal (nth 1 entry) name)
(filesets-eviewer-constraint-p entry))
(filesets-get-external-viewer filename)))))
(when def
(filesets-alist-get def property nil t))))
-
+
(defun filesets-reset-filename-on-change ()
"Reset a buffer's filename if the buffer is being modified."
(when filesets-output-buffer-flag
(run-hooks 'oh))
(set-buffer-modified-p nil)
(setq buffer-read-only t)
- (beginning-of-buffer))
+ (goto-char (point-min)))
(when oh
(run-hooks 'oh))))
(filesets-error 'error
(filesets-spawn-external-viewer file external-viewer-def)
(filesets-find-file file))))
-(defun fsfind-file-using ()
+(defun filesets-find-file-using ()
"Select a viewer and call `filesets-find-or-display-file'."
(interactive)
(let* ((lst (mapcar (lambda (this)
(filesets-find-or-display-file nil (cadr (assoc viewer lst))))))
(defun filesets-browser-name ()
- "Get the directory browser's name as defined in `filesets-browse-dir-fn'."
+ "Get the directory browser's name as defined in `filesets-browse-dir-function'."
(cond
- ((listp filesets-browse-dir-fn)
- (car filesets-browse-dir-fn))
+ ((listp filesets-browse-dir-function)
+ (car filesets-browse-dir-function))
(t
- filesets-browse-dir-fn)))
+ filesets-browse-dir-function)))
(defun filesets-browse-dir (dir)
- "Browse DIR using `filesets-browse-dir-fn'."
- (if (functionp filesets-browse-dir-fn)
- (funcall filesets-browse-dir-fn dir)
- (let ((name (car filesets-browse-dir-fn))
- (args (format (cadr filesets-browse-dir-fn) (expand-file-name dir))))
+ "Browse DIR using `filesets-browse-dir-function'."
+ (if (functionp filesets-browse-dir-function)
+ (funcall filesets-browse-dir-function dir)
+ (let ((name (car filesets-browse-dir-function))
+ (args (format (cadr filesets-browse-dir-function) (expand-file-name dir))))
(with-temp-buffer
(start-process (concat "Filesets:" name)
"*Filesets external directory browser*"
"Return fileset ENTRY's mode: :files, :file, :tree, :pattern, or :ingroup.
See `filesets-data'."
(let ((data (filesets-data-get-data entry)))
- (some (lambda (x)
- (if (assoc x data)
- x))
- '(:files :tree :pattern :ingroup :file))))
+ (filesets-some
+ (lambda (x)
+ (if (assoc x data)
+ x))
+ '(:files :tree :pattern :ingroup :file))))
(defun filesets-entry-get-open-fn (fileset-name &optional fileset-entry)
"Get the open-function for FILESET-NAME.
Use FILESET-ENTRY for finding the open function, if provided."
(filesets-data-get (or fileset-entry
(filesets-get-fileset-from-name fileset-name))
- ':open filesets-open-file-fn t))
+ ':open filesets-open-file-function t))
(defun filesets-entry-get-save-fn (fileset-name &optional fileset-entry)
"Get the save-function for FILESET-NAME.
Use FILESET-ENTRY for finding the save function, if provided."
(filesets-data-get (or fileset-entry
(filesets-get-fileset-from-name fileset-name))
- ':save filesets-save-buffer-fn t))
+ ':save filesets-save-buffer-function t))
(defun filesets-entry-get-files (entry)
"Get the file list for fileset ENTRY."
(filesets-data-get entry ':ingroup nil t))
(defun filesets-file-open (open-function file-name &optional fileset-name)
- "Open FILE-NAME using OPEN-FUNCTION. If OPEN-FUNCTION is nil, it's
-value will be deduced from FILESET-NAME"
+ "Open FILE-NAME using OPEN-FUNCTION. If OPEN-FUNCTION is nil, its
+value will be deduced from FILESET-NAME."
(let ((open-function (or open-function
(filesets-entry-get-open-fn fileset-name))))
(if (file-readable-p file-name)
(cond
((and (symbolp this) (fboundp this))
(let ((x (funcall this)))
- (setq rv (append rv (if (listp x) x (list x))))))
+ (setq rv (append rv (if (listp x) x (list x))))))
(t
(setq rv (append rv (list this))))))))
(defun filesets-cmd-show-result (cmd output)
"Show OUTPUT of CMD (a shell command)."
(pop-to-buffer "*Filesets: Shell Command Output*")
- (end-of-buffer)
+ (with-no-warnings
+ (end-of-buffer))
(insert "*** ")
(insert cmd)
(newline)
(or (equal mode ':ingroup)
(equal mode ':tree)))
(filesets-get-filelist fileset mode event)
- (filesets-get-filelist
+ (filesets-get-filelist
(filesets-get-fileset-from-name name)
mode event))))
(when files
(save-restriction
(let ((buffer (filesets-find-file this)))
(when buffer
- (beginning-of-buffer)
+ (goto-char (point-min))
(let ()
(cond
((stringp fn)
(if (equal txt "") "" " ")
(format "%s" this))))))))
(cmd (concat fn " " args)))
- (filesets-cmd-show-result
+ (filesets-cmd-show-result
cmd (shell-command-to-string cmd))))
((symbolp fn)
(let ((args
(if entry
(let* ((files (filesets-entry-get-files entry))
(this (buffer-file-name buffer))
- (inlist (member* this files :test 'filesets-files-equalp)))
+ (inlist (filesets-member this files
+ :test 'filesets-files-equalp)))
(cond
(inlist
(message "Filesets: '%s' is already in '%s'" this name))
- ((and (equal (filesets-entry-mode entry) ':files)
+ ((and (equal (filesets-entry-mode entry) ':files)
this)
(filesets-entry-set-files entry (cons this files) t)
(filesets-set-config name 'filesets-data filesets-data))
(if entry
(let* ((files (filesets-entry-get-files entry))
(this (buffer-file-name buffer))
- (inlist (member* this files :test 'filesets-files-equalp)))
+ (inlist (filesets-member this files
+ :test 'filesets-files-equalp)))
;;(message "%s %s %s" files this inlist)
(if (and files this inlist)
(let ((new (list (cons ':files (delete (car inlist) files)))))
(if (null (cdr x))
""
", "))))
- (setq rv
+ (setq rv
(concat
rv
(if filesets-menu-shortcuts-flag
(and (stringp a)
(stringp b)
(string-match a b))))))
- (some (lambda (x)
- (if (funcall fn (car x) masterfile)
- (nth pos x)
- nil))
- filesets-ingroup-patterns)))
+ (filesets-some (lambda (x)
+ (if (funcall fn (car x) masterfile)
+ (nth pos x)
+ nil))
+ filesets-ingroup-patterns)))
(defun filesets-ingroup-get-pattern (master)
"Access to `filesets-ingroup-patterns'. Extract patterns."
((not this-patt)
(filesets-error 'error "Filesets: malformed :ingroup definition "
this-def))
- ((<= this-sd 0)
- (setq rv (nconc rv `(((,master ,this-name))))))
+ ((< this-sd 0)
+ nil)
(t
(with-temp-buffer
(insert-file-contents master)
(when (and f
(not (member f flist))
(or (not remdupl-flag)
- (not (member*
- f filesets-ingroup-paths
+ (not (filesets-member
+ f filesets-ingroup-files
:test 'filesets-files-equalp))))
(let ((no-stub-flag
(and (not this-stub-flag)
t))))
(setq count (+ count 1))
(setq flist (cons f flist))
- (setq filesets-ingroup-paths
- (cons f filesets-ingroup-paths))
+ (setq filesets-ingroup-files
+ (cons f filesets-ingroup-files))
(when no-stub-flag
(filesets-ingroup-cache-put master f))
(setq lst (append lst (list f))))))))
(append rv
(if files
`((,nm
- [,(concat "Inclusion Group: "
+ [,(concat "Inclusion Group: "
(file-name-nondirectory master))
(filesets-open ':ingroup ',master ',fsn)]
"---"
(mapcar
(lambda (this)
(setq count (+ count 1))
- (let ((ff (filesets-ingroup-collect-build-menu
+ (let ((ff (filesets-ingroup-collect-build-menu
fs (list this) count)))
(if (= (length ff) 1)
(car ff)
"Build a :ingroup submenu for file MASTER."
(if (file-readable-p master)
(let ((remdupl-flag (filesets-ingroup-get-remdupl-p master)))
- (setq filesets-ingroup-paths (list master))
+ (setq filesets-ingroup-files (list master))
(filesets-ingroup-collect lookup-name remdupl-flag master))
(if filesets-be-docile-flag
(progn
(let* ((x (file-name-as-directory x))
(xx (concat dir x))
(dd (filesets-build-dir-submenu-now
- (+ level 1) depth entry
+ (+ level 1) depth entry
lookup-name xx patt fd))
(nm (concat (filesets-get-shortcut count)
x)))
(append
dirsmenu
filesmenu))
- (filesets-get-menu-epilog `(,dir ,patt) ':tree
+ (filesets-get-menu-epilog `(,dir ,patt) ':tree
lookup-name rebuild-flag)))
nil))
filesets-menu-in-menu)
(setq filesets-updated-buffers
(cons cb filesets-updated-buffers))
- (message nil)
+ ;; This wipes out other messages in the echo area.
+ ;; (message nil)
;;(message "Filesets updated: %s" cb)
)))
(with-temp-buffer
(dolist (this filesets-menu-cache-contents)
(if (get this 'custom-type)
- (progn
+ (progn
(insert (format "(setq-default %s '%S)" this (eval this)))
(when filesets-menu-ensure-use-cached
(newline)
\(\"Test\" (:pattern \"~/dir/^pattern$\"))
--> \(\"Test\" (:pattern \"~/dir/\" \"^pattern$\"))
-2. `filesets-data': Change all occurances of \":document\" to \":ingroup\":
+2. `filesets-data': Change all occurrences of \":document\" to \":ingroup\":
\(\(\"Test\" \(:document \"~/dir/file\"))
--> \(\(\"Test\" \(:ingroup \"~/dir/file\"))
(filesets-build-menu)))
-;;; run
-(filesets-init)
-
(provide 'filesets)
;;; Local Variables:
-;;; time-stamp-format:"%:y-%02m-%02d"
;;; sentence-end-double-space:t
;;; End:
+;;; arch-tag: 2c03f85f-c3df-4cec-b0a3-b46fd5592d70
;;; filesets.el ends here