;ELC
|
;;; Compiled
|
;;; in Emacs version 26.1
|
;;; with all optimizations.
|
|
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
|
|
;;; This file does not contain utf-8 non-ASCII characters,
|
;;; and so can be loaded in Emacs versions earlier than 23.
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
(byte-code "\300\301!\210\300\302!\210\303\304\305\306#\210\303\304\307\310#\207" [require s dash put f-guard-error error-conditions (error f-guard-error) error-message "Destructive operation outside sandbox"] 4)
|
#@77 List of allowed paths to modify when guarded.
|
|
Do not modify this variable.
|
(defvar f--guard-paths nil (#$ . 621))
|
#@123 If PATH is allowed to be modified, yield BODY.
|
|
If PATH is not allowed to be modified, throw error.
|
|
(fn PATH &rest BODY)
|
(defalias 'f--destructive '(macro . #[385 "\300\301\300\302\303\304\305E\306\305 EE\307BB\310B\311\312\313 \314BBEFBBB\207" [if f--guard-paths --any\? or f-same\? it f-ancestor-of\? (f--guard-paths) progn signal 'f-guard-error list (f--guard-paths)] 12 (#$ . 743)]))
|
(byte-code "\300\301\302\303#\300\207" [function-put f--destructive lisp-indent-function 1] 4)
|
#@46 Join ARGS to a single path.
|
|
(fn &rest ARGS)
|
(defalias 'f-join #[128 "\300C\301@!\302\303\304\305\306\307!\310\"\311\312%\"\210\211\203\" \313\242!\202$ \242\207" [nil f-relative\? -map make-byte-code 257 "\300\301\300\242\"\240\207" vconcat vector [f-expand] 5 "\n\n(fn ARG)" f-relative] 10 (#$ . 1239)])
|
#@57 Split PATH and return list containing parts.
|
|
(fn PATH)
|
(defalias 'f-split #[257 "\300\301 \302#\303!\203 \301 B\211\262\202 \211\207" [s-split f-path-separator omit-nulls f-absolute\?] 5 (#$ . 1558)])
|
#@274 Expand PATH relative to DIR (or `default-directory').
|
PATH and DIR can be either a directory names or directory file
|
names. Return a directory name if PATH is a directory name, and
|
a directory file name otherwise. File name handlers are
|
ignored.
|
|
(fn PATH &optional DIR)
|
(defalias 'f-expand #[513 "\301\302\")\207" [file-name-handler-alist nil expand-file-name] 5 (#$ . 1773)])
|
#@37 Return the name of PATH.
|
|
(fn PATH)
|
(defalias 'f-filename #[257 "\300\301!!\207" [file-name-nondirectory directory-file-name] 4 (#$ . 2162)])
|
(defalias 'f-parent 'f-dirname)
|
#@49 Return the parent directory to PATH.
|
|
(fn PATH)
|
(defalias 'f-dirname #[257 "\301\302\303\"!!\304\"?\205 \305!\203 \306!\202 \302!\207" [default-directory file-name-directory directory-file-name f-expand f-same\? f-relative\? f-relative] 6 (#$ . 2343)])
|
#@66 Return the deepest common parent directory of PATHS.
|
|
(fn PATHS)
|
(defalias 'f-common-parent #[257 "\211\204 \300\207\211A\204 \301@!\207\302\303\"\211@@\300@\203e \304\304\305\203H \203H @\2045 \300\262\202< \211@\232\262\210\211T\262A\262\202! \266\306!\262\203e \302\307\"\262B\262@@\262\202 \211\204m \310\202\207 \211G\311U\203\200 \312@!\203\200 \313 \202\207 \314\315\237\"\316P\207" [nil f-parent -map f-split t 0 ---truthy\? cdr "" 1 f-root\? f-root apply f-join "/"] 11 (#$ . 2612)])
|
#@165 Return the file extension of PATH.
|
|
The extension, in a file name, is the part that follows the last
|
'.', excluding version numbers and backup suffixes.
|
|
(fn PATH)
|
(defalias 'f-ext #[257 "\300!\207" [file-name-extension] 3 (#$ . 3142)])
|
#@62 Return everything but the file extension of PATH.
|
|
(fn PATH)
|
(defalias 'f-no-ext #[257 "\300!\207" [file-name-sans-extension] 3 (#$ . 3386)])
|
#@93 Return PATH but with EXT as the new extension.
|
EXT must not be nil or empty.
|
|
(fn PATH EXT)
|
(defalias 'f-swap-ext #[514 "\300!\203\n \301\302!\207\303!\304Q\207" [s-blank\? error "Extension cannot be empty or nil" f-no-ext "."] 5 (#$ . 3535)])
|
#@70 Return the name of PATH, excluding the extension of file.
|
|
(fn PATH)
|
(defalias 'f-base #[257 "\300\301!!\207" [f-no-ext f-filename] 4 (#$ . 3788)])
|
#@55 Return PATH relative to DIR.
|
|
(fn PATH &optional DIR)
|
(defalias 'f-relative #[513 "\300\"\207" [file-relative-name] 5 (#$ . 3943)])
|
(defalias 'f-abbrev 'f-short)
|
#@64 Return abbrev of PATH. See `abbreviate-file-name'.
|
|
(fn PATH)
|
(defalias 'f-short #[257 "\300!\207" [abbreviate-file-name] 3 (#$ . 4113)])
|
#@41 Return long version of PATH.
|
|
(fn PATH)
|
(defalias 'f-long #[257 "\300!\207" [f-expand] 3 (#$ . 4259)])
|
#@47 Return the canonical name of PATH.
|
|
(fn PATH)
|
(defalias 'f-canonical #[257 "\300!\207" [file-truename] 3 (#$ . 4369)])
|
#@131 Append slash to PATH unless one already.
|
|
Some functions, such as `call-process' requires there to be an
|
ending slash.
|
|
(fn PATH)
|
(defalias 'f-slash #[257 "\300!\203\n \301!\207\207" [f-dir\? file-name-as-directory] 3 (#$ . 4496)])
|
#@61 Return absolute path to PATH, with ending slash.
|
|
(fn PATH)
|
(defalias 'f-full #[257 "\300\301!!\207" [f-slash f-long] 4 (#$ . 4736)])
|
#@61 Helper for `f-uniquify' and `f-uniquify-alist'.
|
|
(fn PATHS)
|
(defalias 'f--uniquify #[257 "\211G\300\301\"\302\303\"GU\204! \302\303\304\305\300\306\"\"\"\262\202\n \207" [mapcar #[257 "\211\300!B\207" [f-filename] 4 "\n\n(fn IT)"] -group-by cdr apply append #[257 "\211A\211G\300V\203 \301\302\"\202 \211\207" [1 mapcar #[257 "\211@\300\301A@\"!\302 AQB\207" [f-filename s-chop-suffix f-path-separator] 6 "\n\n(fn IT)"]] 5 "\n\n(fn IT)"]] 11 (#$ . 4877)])
|
#@89 Return unique suffixes of FILES.
|
|
This function expects no duplicate paths.
|
|
(fn FILES)
|
(defalias 'f-uniquify #[257 "\300\301\302!\"\207" [-map car f--uniquify] 5 (#$ . 5353)])
|
#@112 Return alist mapping FILES to unique suffixes of FILES.
|
|
This function expects no duplicate paths.
|
|
(fn FILES)
|
(defalias 'f-uniquify-alist #[257 "\300\301\302!\"\207" [-map cadr f--uniquify] 5 (#$ . 5538)])
|
#@83 Read binary data from PATH.
|
|
Return the binary data as unibyte string.
|
|
(fn PATH)
|
(defalias 'f-read-bytes #[257 "\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216\312\313!\210\314\315!\210\316ed\"*\207" [buffer-file-coding-system generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte nil binary insert-file-contents-literally buffer-substring-no-properties] 8 (#$ . 5752)])
|
(defalias 'f-read 'f-read-text)
|
#@139 Read text with PATH, using CODING.
|
|
CODING defaults to `utf-8'.
|
|
Return the decoded text as multibyte string.
|
|
(fn PATH &optional CODING)
|
(defalias 'f-read-text #[513 "\300\301!\206 \302\"\207" [decode-coding-string f-read-bytes utf-8] 5 (#$ . 6262)])
|
(defalias 'f-write 'f-write-text)
|
#@167 Write TEXT with CODING to PATH.
|
|
TEXT is a multibyte string. CODING is a coding system to encode
|
TEXT with. PATH is a file name to write to.
|
|
(fn TEXT CODING PATH)
|
(defalias 'f-write-text #[771 "\300\301\"\"\207" [f-write-bytes encode-coding-string] 7 (#$ . 6558)])
|
#@50 Determine whether S is a unibyte string.
|
|
(fn S)
|
(defalias 'f-unibyte-string-p #[257 "\300!?\207" [multibyte-string-p] 3 (#$ . 6835)])
|
#@105 Write binary DATA to PATH.
|
|
DATA is a unibyte string. PATH is a file name to write to.
|
|
(fn DATA PATH)
|
(defalias 'f-write-bytes #[514 "\203\211 \304\305\306\307\2038 \2038 @\203 \305\262\202, \310\"\206* \311\"\262\210\211T\262A\262\202 \266\211\262!\203\202 \312!\204N \313\314\312D\"\210\305\315\211\316\317\320!!\321\307\322\323\324!\325\"\326$\216r\211q\210\315\327\305!\210c)rq\210\330\305\211\305\307%\210*\266\202*\207\313\331D\"\207\312!\204\226 \313\314\312D\"\210\305\315\211\316\317\320!!\321\307\322\323\324!\332\"\326$\216r\211q\210\315\327\305!\210c)rq\210\330\305\211\305\307%\210*\266\202*\207" [f--guard-paths coding-system-for-write file-coding-system-alist buffer-file-coding-system ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-unibyte-string-p signal wrong-type-argument binary get-buffer-create generate-new-buffer-name " *temp file*" make-byte-code "\301\300!\205 \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte write-region f-guard-error [buffer-name kill-buffer]] 11 (#$ . 6978)])
|
(defalias 'f-append 'f-append-text)
|
#@97 Append TEXT with CODING to PATH.
|
|
If PATH does not exist, it is created.
|
|
(fn TEXT CODING PATH)
|
(defalias 'f-append-text #[771 "\300\301\"\"\207" [f-append-bytes encode-coding-string] 7 (#$ . 8101)])
|
#@85 Append binary DATA to PATH.
|
|
If PATH does not exist, it is created.
|
|
(fn DATA PATH)
|
(defalias 'f-append-bytes #[514 "\300!\203\f \301!\202 \302\303P\"\207" [f-file\? f-read-bytes "" f-write-bytes] 6 (#$ . 8310)])
|
#@43 Create directories DIRS.
|
|
(fn &rest DIRS)
|
(defalias 'f-mkdir #[128 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\207" [nil -each make-byte-code 257 "\300\302\300\242\"\240\210\303\300\242!?\205b \203^ \304\305 \306\307\203H \203H @\203- \305\262\202< \310\300\242\"\206: \311\300\242\"\262\210\211T\262A\262\202 \266\211\262!\203V \312\300\242!\207\313\314\300\242 D\"\207\312\300\242!\207" vconcat vector [f--guard-paths f-expand f-directory\? ---truthy\? nil t 0 f-same\? f-ancestor-of\? make-directory signal f-guard-error] 10 "\n\n(fn DIR)"] 10 (#$ . 8535)])
|
#@130 Delete PATH, which can be file or directory.
|
|
If FORCE is t, a directory will be deleted recursively.
|
|
(fn PATH &optional FORCE)
|
(defalias 'f-delete #[513 "\203] \301\302\303\304\2038 \2038 @\203 \302\262\202, \305 \"\206* \306 \"\262\210\211T\262A\262\202 \266\211\262!\203V \307!\204M \310!\203Q \311!\207\312\"\207\313\314D\"\207\307!\204i \310!\203m \311!\207\312\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? f-symlink\? delete-file delete-directory signal f-guard-error] 11 (#$ . 9127)])
|
#@57 Create a symlink to SOURCE from PATH.
|
|
(fn SOURCE PATH)
|
(defalias 'f-symlink #[514 "\203M \301\302\303\304\2038 \2038 @\203 \302\262\202, \305\"\206* \306\"\262\210\211T\262A\262\202 \266\211\262!\203F \307\"\207\310\311D\"\207\307\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? make-symbolic-link signal f-guard-error] 11 (#$ . 9689)])
|
#@88 Move or rename FROM to TO.
|
If TO is a directory name, move FROM into TO.
|
|
(fn FROM TO)
|
(defalias 'f-move #[514 "\203N \301\302\303\304\2038 \2038 @\203 \302\262\202, \305\"\206* \306\"\262\210\211T\262A\262\202 \266\211\262!\203G \307\303#\207\310\311D\"\207\307\303#\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? rename-file signal f-guard-error] 11 (#$ . 10080)])
|
#@141 Copy file or directory FROM to TO.
|
If FROM names a directory and TO is a directory name, copy FROM
|
into TO as a subdirectory.
|
|
(fn FROM TO)
|
(defalias 'f-copy #[514 "\203{ \302\303\304\305\2038 \2038 @\203 \303\262\202, \306\"\206* \307\"\262\210\211T\262A\262\202 \266\211\262!\203t \310!\203L \311\"\207 \312V\203W \313\"\207\314!\203o \315\316\317!\"\210\320\321!\"\313\"\207\313\"\207\322\323D\"\207\310!\203\206 \311\"\207 \312V\203\221 \313\"\207\314!\203\251 \315\316\317!\"\210\320\321!\"\313\"\207\313\"\207" [f--guard-paths emacs-major-version ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? copy-file 23 copy-directory f-dir\? apply f-mkdir f-split f-expand f-filename signal f-guard-error] 11 (#$ . 10500)])
|
#@65 Copy contents in directory FROM, to directory TO.
|
|
(fn FROM TO)
|
(defalias 'f-copy-contents #[514 "\300!\204 \301\302\"\210\303!\204 \301\304\"\210\305!\306\2054 @\307\310!\"\266\211T\262A\262\202 \207" [f-exists\? error "Cannot copy contents to non existing directory %s" f-dir\? "Cannot copy contents as %s is a file" f-entries 0 f-copy file-name-as-directory] 9 (#$ . 11280)])
|
#@79 Update PATH last modification date or create if it does not exist.
|
|
(fn PATH)
|
(defalias 'f-touch #[257 "\203W \301\302\303\304\2038 \2038 @\203 \302\262\202, \305\"\206* \306\"\262\210\211T\262A\262\202 \266\211\262!\203P \307!\203K \310!\207\311\312\"\207\313\314D\"\207\307!\203a \310!\207\311\312\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? set-file-times f-write-bytes "" signal f-guard-error] 10 (#$ . 11682)])
|
#@54 Return t if PATH exists, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-exists\? #[257 "\300!\207" [file-exists-p] 3 (#$ . 12166)])
|
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\303\"\207" [defalias f-exists-p f-exists\? f-dir\? f-directory\? f-dir-p] 3)
|
#@60 Return t if PATH is directory, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-directory\? #[257 "\300!\207" [file-directory-p] 3 (#$ . 12433)])
|
(defalias 'f-directory-p 'f-directory\?)
|
#@55 Return t if PATH is file, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-file\? #[257 "\300!\207" [file-regular-p] 3 (#$ . 12619)])
|
(defalias 'f-file-p 'f-file\?)
|
#@58 Return t if PATH is symlink, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-symlink\? #[257 "\300!??\207" [file-symlink-p] 3 (#$ . 12783)])
|
(defalias 'f-symlink-p 'f-symlink\?)
|
#@59 Return t if PATH is readable, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-readable\? #[257 "\300!\207" [file-readable-p] 3 (#$ . 12961)])
|
(defalias 'f-readable-p 'f-readable\?)
|
#@59 Return t if PATH is writable, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-writable\? #[257 "\300!\207" [file-writable-p] 3 (#$ . 13142)])
|
(defalias 'f-writable-p 'f-writable\?)
|
#@61 Return t if PATH is executable, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-executable\? #[257 "\300!\207" [file-executable-p] 3 (#$ . 13323)])
|
(defalias 'f-executable-p 'f-executable\?)
|
#@59 Return t if PATH is absolute, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-absolute\? #[257 "\300!\207" [file-name-absolute-p] 3 (#$ . 13514)])
|
(defalias 'f-absolute-p 'f-absolute\?)
|
#@59 Return t if PATH is relative, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-relative\? #[257 "\300!?\207" [f-absolute\?] 3 (#$ . 13700)])
|
(defalias 'f-relative-p 'f-relative\?)
|
#@65 Return t if PATH is root directory, false otherwise.
|
|
(fn PATH)
|
(defalias 'f-root\? #[257 "\300!?\207" [f-parent] 3 (#$ . 13879)])
|
(defalias 'f-root-p 'f-root\?)
|
#@279 Return t if extension of PATH is EXT, false otherwise.
|
|
If EXT is nil or omitted, return t if PATH has any extension,
|
false otherwise.
|
|
The extension, in a file name, is the part that follows the last
|
'.', excluding version numbers and backup suffixes.
|
|
(fn PATH &optional EXT)
|
(defalias 'f-ext\? #[513 "\211\203\n \300!\230\207\300!\301=?\207" [f-ext nil] 4 (#$ . 14049)])
|
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\303\"\207" [defalias f-ext-p f-ext\? f-equal\? f-same\? f-equal-p] 3)
|
#@80 Return t if PATH-A and PATH-B are references to same file.
|
|
(fn PATH-A PATH-B)
|
(defalias 'f-same\? #[514 "\300!\205 \300!\205 \301\302\303!!!\301\302\303!!!\232\207" [f-exists\? f-canonical directory-file-name f-expand] 7 (#$ . 14559)])
|
(defalias 'f-same-p 'f-same\?)
|
#@61 Return t if PATH-A is parent of PATH-B.
|
|
(fn PATH-A PATH-B)
|
(defalias 'f-parent-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 14839)])
|
(defalias 'f-parent-of-p 'f-parent-of\?)
|
#@60 Return t if PATH-A is child of PATH-B.
|
|
(fn PATH-A PATH-B)
|
(defalias 'f-child-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 15045)])
|
(defalias 'f-child-of-p 'f-child-of\?)
|
#@63 Return t if PATH-A is ancestor of PATH-B.
|
|
(fn PATH-A PATH-B)
|
(defalias 'f-ancestor-of\? #[514 "\300\"?\205 \301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15247)])
|
(defalias 'f-ancestor-of-p 'f-ancestor-of\?)
|
#@64 Return t if PATH-A is desendant of PATH-B.
|
|
(fn PATH-A PATH-B)
|
(defalias 'f-descendant-of\? #[514 "\300\"?\205 \301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15484)])
|
(defalias 'f-descendant-of-p 'f-descendant-of\?)
|
#@55 Return t if PATH is hidden, nil otherwise.
|
|
(fn PATH)
|
(defalias 'f-hidden\? #[257 "\300!\204 \301\302\"\210\211\303\304O\305\230\207" [f-exists\? error "Path does not exist: %s" 0 1 "."] 4 (#$ . 15728)])
|
(defalias 'f-hidden-p 'f-hidden\?)
|
#@158 If PATH is a file, return t if the file in PATH is empty, nil otherwise.
|
If PATH is directory, return t if directory has no files, nil otherwise.
|
|
(fn PATH)
|
(defalias 'f-empty\? #[257 "\300!\203 \301\302\303#\302\232\207\304!\305U\207" [f-directory\? f-files nil t f-size 0] 5 (#$ . 15977)])
|
(defalias 'f-empty-p 'f-empty\?)
|
#@135 Return size of PATH.
|
|
If PATH is a file, return size of that file. If PATH is
|
directory, return sum of all files in PATH.
|
|
(fn PATH)
|
(defalias 'f-size #[257 "\300!\203 \301\302\303\304\305\306#\"!\207\307\310!8\207" [f-directory\? -sum -map f-size f-files nil t 7 file-attributes] 8 (#$ . 16313)])
|
#@195 Return the depth of PATH.
|
|
At first, PATH is expanded with `f-expand'. Then the full path is used to
|
detect the depth.
|
'/' will be zero depth, '/usr' will be one depth. And so on.
|
|
(fn PATH)
|
(defalias 'f-depth #[257 "\300\301!!GS\207" [f-split f-expand] 4 (#$ . 16623)])
|
#@27 Return path to this file.
|
(defalias 'f-this-file #[0 "\203 \207\303\302!\203 \n\203 \n\207\304 \207" [load-in-progress load-file-name byte-compile-current-file boundp buffer-file-name] 2 (#$ . 16904)])
|
#@51 A variable to cache result of `f-path-separator'.
|
(defvar f--path-separator nil (#$ . 17117))
|
#@24 Return path separator.
|
(defalias 'f-path-separator #[0 "\206 \301\302\303\"\304\305O\211\207" [f--path-separator f-join "x" "y" 1 2] 3 (#$ . 17217)])
|
#@52 Find PATTERN in PATH.
|
|
(fn PATTERN &optional PATH)
|
(defalias 'f-glob #[513 "\301\302\206 \"!\207" [default-directory file-expand-wildcards f-join] 6 (#$ . 17376)])
|
#@23
|
|
(fn PATH RECURSIVE)
|
(defalias 'f--collect-entries #[514 "\300C\301\302\303\304\"\"\203# \305\306\307\310\311\312\"\313\"\314\315%\"\210\202' \240\210\242\207" [nil -reject #[257 "\300!\301\232\206 \300!\302\232\207" [f-filename "." ".."] 3 "\n\n(fn FILE)"] directory-files t -map make-byte-code 257 "\302!\203 \301\301\242B\240\207\303!\205$ \301\301\242B\240\210\301\304\301\242\305\300\"\"\240\207" vconcat vector [f-file\? f-directory\? append f--collect-entries] 7 "\n\n(fn ENTRY)"] 12 (#$ . 17550)])
|
#@71 Anaphoric version of `f-entries'.
|
|
(fn PATH BODY &optional RECURSIVE)
|
(defalias 'f--entries '(macro . #[770 "\300\301\302\303\304EEF\207" [f-entries lambda (path) let ((it path))] 10 (#$ . 18082)]))
|
#@247 Find all files and directories in PATH.
|
|
FN - called for each found file and directory. If FN returns a thruthy
|
value, file or directory will be included.
|
RECURSIVE - Search for files and directories recursive.
|
|
(fn PATH &optional FN RECURSIVE)
|
(defalias 'f-entries #[769 "\300\"\203 \301\"\202 \211\207" [f--collect-entries -select] 7 (#$ . 18292)])
|
#@75 Anaphoric version of `f-directories'.
|
|
(fn PATH BODY &optional RECURSIVE)
|
(defalias 'f--directories '(macro . #[770 "\300\301\302\303\304EEF\207" [f-directories lambda (path) let ((it path))] 10 (#$ . 18657)]))
|
#@83 Find all directories in PATH. See `f-entries'.
|
|
(fn PATH &optional FN RECURSIVE)
|
(defalias 'f-directories #[769 "\300\301\302\"\"\203 \300\"\202 \211\207" [-select f-directory\? f--collect-entries] 8 (#$ . 18878)])
|
#@69 Anaphoric version of `f-files'.
|
|
(fn PATH BODY &optional RECURSIVE)
|
(defalias 'f--files '(macro . #[770 "\300\301\302\303\304EEF\207" [f-files lambda (path) let ((it path))] 10 (#$ . 19107)]))
|
#@77 Find all files in PATH. See `f-entries'.
|
|
(fn PATH &optional FN RECURSIVE)
|
(defalias 'f-files #[769 "\300\301\302\"\"\203 \300\"\202 \211\207" [-select f-file\? f--collect-entries] 8 (#$ . 19310)])
|
#@70 Anaphoric version of `f-traverse-upwards'.
|
|
(fn BODY &optional PATH)
|
(defalias 'f--traverse-upwards '(macro . #[513 "\300\301\302\303\304EEE\207" [f-traverse-upwards lambda (dir) let ((it dir))] 8 (#$ . 19522)]))
|
#@224 Traverse up as long as FN return nil, starting at PATH.
|
|
If FN returns a non-nil value, the path sent as argument to FN is
|
returned. If no function callback return a non-nil value, nil is
|
returned.
|
|
(fn FN &optional PATH)
|
(defalias 'f-traverse-upwards #[513 "\211\204 \262\301!\203 \302!\262!\203 \207\303!?\205& \304\305!\"\207" [default-directory f-relative\? f-expand f-root\? f-traverse-upwards f-parent] 6 (#$ . 19745)])
|
#@23 Return absolute root.
|
(defalias 'f-root #[0 "\300\301!\207" [f-traverse-upwards f-root\?] 2 (#$ . 20191)])
|
#@96 Only allow PATH-OR-PATHS and decendants to be modified in BODY.
|
|
(fn PATH-OR-PATHS &rest BODY)
|
(defalias 'f-with-sandbox '(macro . #[385 "\300\301\302\303D\304DFDC\305\300\306BB\307BBE\207" [let paths if listp list unwind-protect ((f--guard-paths paths)) ((setq f--guard-paths nil))] 9 (#$ . 20304)]))
|
(byte-code "\300\301\302\303#\304\305!\207" [function-put f-with-sandbox lisp-indent-function 1 provide f] 4)
|
