| commit | author | age | ||
| 5cb5f7 | 1 | ;ELC |
| C | 2 | ;;; Compiled |
| 3 | ;;; in Emacs version 26.1 | |
| 4 | ;;; with all optimizations. | |
| 5 | ||
| 6 | ;;; This file uses dynamic docstrings, first added in Emacs 19.29. | |
| 7 | ||
| 8 | ;;; This file does not contain utf-8 non-ASCII characters, | |
| 9 | ;;; and so can be loaded in Emacs versions earlier than 23. | |
| 10 | ||
| 11 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 12 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
| 13 | ||
| 14 | ||
| 15 | (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) | |
| 16 | #@77 List of allowed paths to modify when guarded. | |
| 17 | ||
| 18 | Do not modify this variable. | |
| 19 | (defvar f--guard-paths nil (#$ . 621)) | |
| 20 | #@123 If PATH is allowed to be modified, yield BODY. | |
| 21 | ||
| 22 | If PATH is not allowed to be modified, throw error. | |
| 23 | ||
| 24 | (fn PATH &rest BODY) | |
| 25 | (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)])) | |
| 26 | (byte-code "\300\301\302\303#\300\207" [function-put f--destructive lisp-indent-function 1] 4) | |
| 27 | #@46 Join ARGS to a single path. | |
| 28 | ||
| 29 | (fn &rest ARGS) | |
| 30 | (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)]) | |
| 31 | #@57 Split PATH and return list containing parts. | |
| 32 | ||
| 33 | (fn PATH) | |
| 34 | (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)]) | |
| 35 | #@274 Expand PATH relative to DIR (or `default-directory'). | |
| 36 | PATH and DIR can be either a directory names or directory file | |
| 37 | names. Return a directory name if PATH is a directory name, and | |
| 38 | a directory file name otherwise. File name handlers are | |
| 39 | ignored. | |
| 40 | ||
| 41 | (fn PATH &optional DIR) | |
| 42 | (defalias 'f-expand #[513 "\301\302\")\207" [file-name-handler-alist nil expand-file-name] 5 (#$ . 1773)]) | |
| 43 | #@37 Return the name of PATH. | |
| 44 | ||
| 45 | (fn PATH) | |
| 46 | (defalias 'f-filename #[257 "\300\301!!\207" [file-name-nondirectory directory-file-name] 4 (#$ . 2162)]) | |
| 47 | (defalias 'f-parent 'f-dirname) | |
| 48 | #@49 Return the parent directory to PATH. | |
| 49 | ||
| 50 | (fn PATH) | |
| 51 | (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)]) | |
| 52 | #@66 Return the deepest common parent directory of PATHS. | |
| 53 | ||
| 54 | (fn PATHS) | |
| 55 | (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)]) | |
| 56 | #@165 Return the file extension of PATH. | |
| 57 | ||
| 58 | The extension, in a file name, is the part that follows the last | |
| 59 | '.', excluding version numbers and backup suffixes. | |
| 60 | ||
| 61 | (fn PATH) | |
| 62 | (defalias 'f-ext #[257 "\300!\207" [file-name-extension] 3 (#$ . 3142)]) | |
| 63 | #@62 Return everything but the file extension of PATH. | |
| 64 | ||
| 65 | (fn PATH) | |
| 66 | (defalias 'f-no-ext #[257 "\300!\207" [file-name-sans-extension] 3 (#$ . 3386)]) | |
| 67 | #@93 Return PATH but with EXT as the new extension. | |
| 68 | EXT must not be nil or empty. | |
| 69 | ||
| 70 | (fn PATH EXT) | |
| 71 | (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)]) | |
| 72 | #@70 Return the name of PATH, excluding the extension of file. | |
| 73 | ||
| 74 | (fn PATH) | |
| 75 | (defalias 'f-base #[257 "\300\301!!\207" [f-no-ext f-filename] 4 (#$ . 3788)]) | |
| 76 | #@55 Return PATH relative to DIR. | |
| 77 | ||
| 78 | (fn PATH &optional DIR) | |
| 79 | (defalias 'f-relative #[513 "\300\"\207" [file-relative-name] 5 (#$ . 3943)]) | |
| 80 | (defalias 'f-abbrev 'f-short) | |
| 81 | #@64 Return abbrev of PATH. See `abbreviate-file-name'. | |
| 82 | ||
| 83 | (fn PATH) | |
| 84 | (defalias 'f-short #[257 "\300!\207" [abbreviate-file-name] 3 (#$ . 4113)]) | |
| 85 | #@41 Return long version of PATH. | |
| 86 | ||
| 87 | (fn PATH) | |
| 88 | (defalias 'f-long #[257 "\300!\207" [f-expand] 3 (#$ . 4259)]) | |
| 89 | #@47 Return the canonical name of PATH. | |
| 90 | ||
| 91 | (fn PATH) | |
| 92 | (defalias 'f-canonical #[257 "\300!\207" [file-truename] 3 (#$ . 4369)]) | |
| 93 | #@131 Append slash to PATH unless one already. | |
| 94 | ||
| 95 | Some functions, such as `call-process' requires there to be an | |
| 96 | ending slash. | |
| 97 | ||
| 98 | (fn PATH) | |
| 99 | (defalias 'f-slash #[257 "\300!\203\n \301!\207\207" [f-dir\? file-name-as-directory] 3 (#$ . 4496)]) | |
| 100 | #@61 Return absolute path to PATH, with ending slash. | |
| 101 | ||
| 102 | (fn PATH) | |
| 103 | (defalias 'f-full #[257 "\300\301!!\207" [f-slash f-long] 4 (#$ . 4736)]) | |
| 104 | #@61 Helper for `f-uniquify' and `f-uniquify-alist'. | |
| 105 | ||
| 106 | (fn PATHS) | |
| 107 | (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)]) | |
| 108 | #@89 Return unique suffixes of FILES. | |
| 109 | ||
| 110 | This function expects no duplicate paths. | |
| 111 | ||
| 112 | (fn FILES) | |
| 113 | (defalias 'f-uniquify #[257 "\300\301\302!\"\207" [-map car f--uniquify] 5 (#$ . 5353)]) | |
| 114 | #@112 Return alist mapping FILES to unique suffixes of FILES. | |
| 115 | ||
| 116 | This function expects no duplicate paths. | |
| 117 | ||
| 118 | (fn FILES) | |
| 119 | (defalias 'f-uniquify-alist #[257 "\300\301\302!\"\207" [-map cadr f--uniquify] 5 (#$ . 5538)]) | |
| 120 | #@83 Read binary data from PATH. | |
| 121 | ||
| 122 | Return the binary data as unibyte string. | |
| 123 | ||
| 124 | (fn PATH) | |
| 125 | (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)]) | |
| 126 | (defalias 'f-read 'f-read-text) | |
| 127 | #@139 Read text with PATH, using CODING. | |
| 128 | ||
| 129 | CODING defaults to `utf-8'. | |
| 130 | ||
| 131 | Return the decoded text as multibyte string. | |
| 132 | ||
| 133 | (fn PATH &optional CODING) | |
| 134 | (defalias 'f-read-text #[513 "\300\301!\206 \302\"\207" [decode-coding-string f-read-bytes utf-8] 5 (#$ . 6262)]) | |
| 135 | (defalias 'f-write 'f-write-text) | |
| 136 | #@167 Write TEXT with CODING to PATH. | |
| 137 | ||
| 138 | TEXT is a multibyte string. CODING is a coding system to encode | |
| 139 | TEXT with. PATH is a file name to write to. | |
| 140 | ||
| 141 | (fn TEXT CODING PATH) | |
| 142 | (defalias 'f-write-text #[771 "\300\301\"\"\207" [f-write-bytes encode-coding-string] 7 (#$ . 6558)]) | |
| 143 | #@50 Determine whether S is a unibyte string. | |
| 144 | ||
| 145 | (fn S) | |
| 146 | (defalias 'f-unibyte-string-p #[257 "\300!?\207" [multibyte-string-p] 3 (#$ . 6835)]) | |
| 147 | #@105 Write binary DATA to PATH. | |
| 148 | ||
| 149 | DATA is a unibyte string. PATH is a file name to write to. | |
| 150 | ||
| 151 | (fn DATA PATH) | |
| 152 | (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)]) | |
| 153 | (defalias 'f-append 'f-append-text) | |
| 154 | #@97 Append TEXT with CODING to PATH. | |
| 155 | ||
| 156 | If PATH does not exist, it is created. | |
| 157 | ||
| 158 | (fn TEXT CODING PATH) | |
| 159 | (defalias 'f-append-text #[771 "\300\301\"\"\207" [f-append-bytes encode-coding-string] 7 (#$ . 8101)]) | |
| 160 | #@85 Append binary DATA to PATH. | |
| 161 | ||
| 162 | If PATH does not exist, it is created. | |
| 163 | ||
| 164 | (fn DATA PATH) | |
| 165 | (defalias 'f-append-bytes #[514 "\300!\203\f \301!\202 \302\303P\"\207" [f-file\? f-read-bytes "" f-write-bytes] 6 (#$ . 8310)]) | |
| 166 | #@43 Create directories DIRS. | |
| 167 | ||
| 168 | (fn &rest DIRS) | |
| 169 | (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)]) | |
| 170 | #@130 Delete PATH, which can be file or directory. | |
| 171 | ||
| 172 | If FORCE is t, a directory will be deleted recursively. | |
| 173 | ||
| 174 | (fn PATH &optional FORCE) | |
| 175 | (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)]) | |
| 176 | #@57 Create a symlink to SOURCE from PATH. | |
| 177 | ||
| 178 | (fn SOURCE PATH) | |
| 179 | (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)]) | |
| 180 | #@88 Move or rename FROM to TO. | |
| 181 | If TO is a directory name, move FROM into TO. | |
| 182 | ||
| 183 | (fn FROM TO) | |
| 184 | (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)]) | |
| 185 | #@141 Copy file or directory FROM to TO. | |
| 186 | If FROM names a directory and TO is a directory name, copy FROM | |
| 187 | into TO as a subdirectory. | |
| 188 | ||
| 189 | (fn FROM TO) | |
| 190 | (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)]) | |
| 191 | #@65 Copy contents in directory FROM, to directory TO. | |
| 192 | ||
| 193 | (fn FROM TO) | |
| 194 | (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)]) | |
| 195 | #@79 Update PATH last modification date or create if it does not exist. | |
| 196 | ||
| 197 | (fn PATH) | |
| 198 | (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)]) | |
| 199 | #@54 Return t if PATH exists, false otherwise. | |
| 200 | ||
| 201 | (fn PATH) | |
| 202 | (defalias 'f-exists\? #[257 "\300!\207" [file-exists-p] 3 (#$ . 12166)]) | |
| 203 | (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) | |
| 204 | #@60 Return t if PATH is directory, false otherwise. | |
| 205 | ||
| 206 | (fn PATH) | |
| 207 | (defalias 'f-directory\? #[257 "\300!\207" [file-directory-p] 3 (#$ . 12433)]) | |
| 208 | (defalias 'f-directory-p 'f-directory\?) | |
| 209 | #@55 Return t if PATH is file, false otherwise. | |
| 210 | ||
| 211 | (fn PATH) | |
| 212 | (defalias 'f-file\? #[257 "\300!\207" [file-regular-p] 3 (#$ . 12619)]) | |
| 213 | (defalias 'f-file-p 'f-file\?) | |
| 214 | #@58 Return t if PATH is symlink, false otherwise. | |
| 215 | ||
| 216 | (fn PATH) | |
| 217 | (defalias 'f-symlink\? #[257 "\300!??\207" [file-symlink-p] 3 (#$ . 12783)]) | |
| 218 | (defalias 'f-symlink-p 'f-symlink\?) | |
| 219 | #@59 Return t if PATH is readable, false otherwise. | |
| 220 | ||
| 221 | (fn PATH) | |
| 222 | (defalias 'f-readable\? #[257 "\300!\207" [file-readable-p] 3 (#$ . 12961)]) | |
| 223 | (defalias 'f-readable-p 'f-readable\?) | |
| 224 | #@59 Return t if PATH is writable, false otherwise. | |
| 225 | ||
| 226 | (fn PATH) | |
| 227 | (defalias 'f-writable\? #[257 "\300!\207" [file-writable-p] 3 (#$ . 13142)]) | |
| 228 | (defalias 'f-writable-p 'f-writable\?) | |
| 229 | #@61 Return t if PATH is executable, false otherwise. | |
| 230 | ||
| 231 | (fn PATH) | |
| 232 | (defalias 'f-executable\? #[257 "\300!\207" [file-executable-p] 3 (#$ . 13323)]) | |
| 233 | (defalias 'f-executable-p 'f-executable\?) | |
| 234 | #@59 Return t if PATH is absolute, false otherwise. | |
| 235 | ||
| 236 | (fn PATH) | |
| 237 | (defalias 'f-absolute\? #[257 "\300!\207" [file-name-absolute-p] 3 (#$ . 13514)]) | |
| 238 | (defalias 'f-absolute-p 'f-absolute\?) | |
| 239 | #@59 Return t if PATH is relative, false otherwise. | |
| 240 | ||
| 241 | (fn PATH) | |
| 242 | (defalias 'f-relative\? #[257 "\300!?\207" [f-absolute\?] 3 (#$ . 13700)]) | |
| 243 | (defalias 'f-relative-p 'f-relative\?) | |
| 244 | #@65 Return t if PATH is root directory, false otherwise. | |
| 245 | ||
| 246 | (fn PATH) | |
| 247 | (defalias 'f-root\? #[257 "\300!?\207" [f-parent] 3 (#$ . 13879)]) | |
| 248 | (defalias 'f-root-p 'f-root\?) | |
| 249 | #@279 Return t if extension of PATH is EXT, false otherwise. | |
| 250 | ||
| 251 | If EXT is nil or omitted, return t if PATH has any extension, | |
| 252 | false otherwise. | |
| 253 | ||
| 254 | The extension, in a file name, is the part that follows the last | |
| 255 | '.', excluding version numbers and backup suffixes. | |
| 256 | ||
| 257 | (fn PATH &optional EXT) | |
| 258 | (defalias 'f-ext\? #[513 "\211\203\n \300!\230\207\300!\301=?\207" [f-ext nil] 4 (#$ . 14049)]) | |
| 259 | (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) | |
| 260 | #@80 Return t if PATH-A and PATH-B are references to same file. | |
| 261 | ||
| 262 | (fn PATH-A PATH-B) | |
| 263 | (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)]) | |
| 264 | (defalias 'f-same-p 'f-same\?) | |
| 265 | #@61 Return t if PATH-A is parent of PATH-B. | |
| 266 | ||
| 267 | (fn PATH-A PATH-B) | |
| 268 | (defalias 'f-parent-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 14839)]) | |
| 269 | (defalias 'f-parent-of-p 'f-parent-of\?) | |
| 270 | #@60 Return t if PATH-A is child of PATH-B. | |
| 271 | ||
| 272 | (fn PATH-A PATH-B) | |
| 273 | (defalias 'f-child-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 15045)]) | |
| 274 | (defalias 'f-child-of-p 'f-child-of\?) | |
| 275 | #@63 Return t if PATH-A is ancestor of PATH-B. | |
| 276 | ||
| 277 | (fn PATH-A PATH-B) | |
| 278 | (defalias 'f-ancestor-of\? #[514 "\300\"?\205 \301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15247)]) | |
| 279 | (defalias 'f-ancestor-of-p 'f-ancestor-of\?) | |
| 280 | #@64 Return t if PATH-A is desendant of PATH-B. | |
| 281 | ||
| 282 | (fn PATH-A PATH-B) | |
| 283 | (defalias 'f-descendant-of\? #[514 "\300\"?\205 \301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15484)]) | |
| 284 | (defalias 'f-descendant-of-p 'f-descendant-of\?) | |
| 285 | #@55 Return t if PATH is hidden, nil otherwise. | |
| 286 | ||
| 287 | (fn PATH) | |
| 288 | (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)]) | |
| 289 | (defalias 'f-hidden-p 'f-hidden\?) | |
| 290 | #@158 If PATH is a file, return t if the file in PATH is empty, nil otherwise. | |
| 291 | If PATH is directory, return t if directory has no files, nil otherwise. | |
| 292 | ||
| 293 | (fn PATH) | |
| 294 | (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)]) | |
| 295 | (defalias 'f-empty-p 'f-empty\?) | |
| 296 | #@135 Return size of PATH. | |
| 297 | ||
| 298 | If PATH is a file, return size of that file. If PATH is | |
| 299 | directory, return sum of all files in PATH. | |
| 300 | ||
| 301 | (fn PATH) | |
| 302 | (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)]) | |
| 303 | #@195 Return the depth of PATH. | |
| 304 | ||
| 305 | At first, PATH is expanded with `f-expand'. Then the full path is used to | |
| 306 | detect the depth. | |
| 307 | '/' will be zero depth, '/usr' will be one depth. And so on. | |
| 308 | ||
| 309 | (fn PATH) | |
| 310 | (defalias 'f-depth #[257 "\300\301!!GS\207" [f-split f-expand] 4 (#$ . 16623)]) | |
| 311 | #@27 Return path to this file. | |
| 312 | (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)]) | |
| 313 | #@51 A variable to cache result of `f-path-separator'. | |
| 314 | (defvar f--path-separator nil (#$ . 17117)) | |
| 315 | #@24 Return path separator. | |
| 316 | (defalias 'f-path-separator #[0 "\206 \301\302\303\"\304\305O\211\207" [f--path-separator f-join "x" "y" 1 2] 3 (#$ . 17217)]) | |
| 317 | #@52 Find PATTERN in PATH. | |
| 318 | ||
| 319 | (fn PATTERN &optional PATH) | |
| 320 | (defalias 'f-glob #[513 "\301\302\206 \"!\207" [default-directory file-expand-wildcards f-join] 6 (#$ . 17376)]) | |
| 321 | #@23 | |
| 322 | ||
| 323 | (fn PATH RECURSIVE) | |
| 324 | (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)]) | |
| 325 | #@71 Anaphoric version of `f-entries'. | |
| 326 | ||
| 327 | (fn PATH BODY &optional RECURSIVE) | |
| 328 | (defalias 'f--entries '(macro . #[770 "\300\301\302\303\304EEF\207" [f-entries lambda (path) let ((it path))] 10 (#$ . 18082)])) | |
| 329 | #@247 Find all files and directories in PATH. | |
| 330 | ||
| 331 | FN - called for each found file and directory. If FN returns a thruthy | |
| 332 | value, file or directory will be included. | |
| 333 | RECURSIVE - Search for files and directories recursive. | |
| 334 | ||
| 335 | (fn PATH &optional FN RECURSIVE) | |
| 336 | (defalias 'f-entries #[769 "\300\"\203 \301\"\202 \211\207" [f--collect-entries -select] 7 (#$ . 18292)]) | |
| 337 | #@75 Anaphoric version of `f-directories'. | |
| 338 | ||
| 339 | (fn PATH BODY &optional RECURSIVE) | |
| 340 | (defalias 'f--directories '(macro . #[770 "\300\301\302\303\304EEF\207" [f-directories lambda (path) let ((it path))] 10 (#$ . 18657)])) | |
| 341 | #@83 Find all directories in PATH. See `f-entries'. | |
| 342 | ||
| 343 | (fn PATH &optional FN RECURSIVE) | |
| 344 | (defalias 'f-directories #[769 "\300\301\302\"\"\203 \300\"\202 \211\207" [-select f-directory\? f--collect-entries] 8 (#$ . 18878)]) | |
| 345 | #@69 Anaphoric version of `f-files'. | |
| 346 | ||
| 347 | (fn PATH BODY &optional RECURSIVE) | |
| 348 | (defalias 'f--files '(macro . #[770 "\300\301\302\303\304EEF\207" [f-files lambda (path) let ((it path))] 10 (#$ . 19107)])) | |
| 349 | #@77 Find all files in PATH. See `f-entries'. | |
| 350 | ||
| 351 | (fn PATH &optional FN RECURSIVE) | |
| 352 | (defalias 'f-files #[769 "\300\301\302\"\"\203 \300\"\202 \211\207" [-select f-file\? f--collect-entries] 8 (#$ . 19310)]) | |
| 353 | #@70 Anaphoric version of `f-traverse-upwards'. | |
| 354 | ||
| 355 | (fn BODY &optional PATH) | |
| 356 | (defalias 'f--traverse-upwards '(macro . #[513 "\300\301\302\303\304EEE\207" [f-traverse-upwards lambda (dir) let ((it dir))] 8 (#$ . 19522)])) | |
| 357 | #@224 Traverse up as long as FN return nil, starting at PATH. | |
| 358 | ||
| 359 | If FN returns a non-nil value, the path sent as argument to FN is | |
| 360 | returned. If no function callback return a non-nil value, nil is | |
| 361 | returned. | |
| 362 | ||
| 363 | (fn FN &optional PATH) | |
| 364 | (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)]) | |
| 365 | #@23 Return absolute root. | |
| 366 | (defalias 'f-root #[0 "\300\301!\207" [f-traverse-upwards f-root\?] 2 (#$ . 20191)]) | |
| 367 | #@96 Only allow PATH-OR-PATHS and decendants to be modified in BODY. | |
| 368 | ||
| 369 | (fn PATH-OR-PATHS &rest BODY) | |
| 370 | (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)])) | |
| 371 | (byte-code "\300\301\302\303#\304\305!\207" [function-put f-with-sandbox lisp-indent-function 1 provide f] 4) | |
