Commit | Line | Data |
---|---|---|
271672fa | 1 | ;;; ox-publish.el --- Publish Related Org Mode Files as a Website |
ba318903 | 2 | ;; Copyright (C) 2006-2014 Free Software Foundation, Inc. |
271672fa BG |
3 | |
4 | ;; Author: David O'Toole <dto@gnu.org> | |
5 | ;; Maintainer: Carsten Dominik <carsten DOT dominik AT gmail DOT com> | |
6 | ;; Keywords: hypermedia, outlines, wp | |
7 | ||
8 | ;; This file is part of GNU Emacs. | |
9 | ;; | |
10 | ;; GNU Emacs is free software: you can redistribute it and/or modify | |
11 | ;; it under the terms of the GNU General Public License as published by | |
12 | ;; the Free Software Foundation, either version 3 of the License, or | |
13 | ;; (at your option) any later version. | |
14 | ||
15 | ;; GNU Emacs is distributed in the hope that it will be useful, | |
16 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | ;; GNU General Public License for more details. | |
19 | ||
20 | ;; You should have received a copy of the GNU General Public License | |
21 | ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. | |
22 | ||
23 | ;;; Commentary: | |
24 | ||
25 | ;; This program allow configurable publishing of related sets of | |
26 | ;; Org mode files as a complete website. | |
27 | ;; | |
28 | ;; ox-publish.el can do the following: | |
29 | ;; | |
30 | ;; + Publish all one's Org files to a given export back-end | |
31 | ;; + Upload HTML, images, attachments and other files to a web server | |
32 | ;; + Exclude selected private pages from publishing | |
33 | ;; + Publish a clickable sitemap of pages | |
34 | ;; + Manage local timestamps for publishing only changed files | |
35 | ;; + Accept plugin functions to extend range of publishable content | |
36 | ;; | |
37 | ;; Documentation for publishing is in the manual. | |
38 | ||
39 | ;;; Code: | |
40 | ||
41 | (eval-when-compile (require 'cl)) | |
42 | (require 'format-spec) | |
43 | (require 'ox) | |
44 | ||
45 | ||
46 | \f | |
47 | ;;; Variables | |
48 | ||
49 | (defvar org-publish-temp-files nil | |
50 | "Temporary list of files to be published.") | |
51 | ||
52 | ;; Here, so you find the variable right before it's used the first time: | |
53 | (defvar org-publish-cache nil | |
54 | "This will cache timestamps and titles for files in publishing projects. | |
55 | Blocks could hash sha1 values here.") | |
56 | ||
57 | (defgroup org-publish nil | |
58 | "Options for publishing a set of Org-mode and related files." | |
59 | :tag "Org Publishing" | |
60 | :group 'org) | |
61 | ||
62 | (defcustom org-publish-project-alist nil | |
63 | "Association list to control publishing behavior. | |
64 | Each element of the alist is a publishing 'project.' The CAR of | |
65 | each element is a string, uniquely identifying the project. The | |
66 | CDR of each element is in one of the following forms: | |
67 | ||
68 | 1. A well-formed property list with an even number of elements, | |
69 | alternating keys and values, specifying parameters for the | |
70 | publishing process. | |
71 | ||
72 | \(:property value :property value ... ) | |
73 | ||
74 | 2. A meta-project definition, specifying of a list of | |
75 | sub-projects: | |
76 | ||
77 | \(:components (\"project-1\" \"project-2\" ...)) | |
78 | ||
79 | When the CDR of an element of org-publish-project-alist is in | |
80 | this second form, the elements of the list after `:components' | |
81 | are taken to be components of the project, which group together | |
82 | files requiring different publishing options. When you publish | |
83 | such a project with \\[org-publish], the components all publish. | |
84 | ||
85 | When a property is given a value in `org-publish-project-alist', | |
86 | its setting overrides the value of the corresponding user | |
87 | variable (if any) during publishing. However, options set within | |
88 | a file override everything. | |
89 | ||
90 | Most properties are optional, but some should always be set: | |
91 | ||
92 | `:base-directory' | |
93 | ||
94 | Directory containing publishing source files. | |
95 | ||
96 | `:base-extension' | |
97 | ||
98 | Extension (without the dot!) of source files. This can be | |
99 | a regular expression. If not given, \"org\" will be used as | |
100 | default extension. | |
101 | ||
102 | `:publishing-directory' | |
103 | ||
104 | Directory (possibly remote) where output files will be | |
105 | published. | |
106 | ||
107 | The `:exclude' property may be used to prevent certain files from | |
108 | being published. Its value may be a string or regexp matching | |
109 | file names you don't want to be published. | |
110 | ||
111 | The `:include' property may be used to include extra files. Its | |
112 | value may be a list of filenames to include. The filenames are | |
113 | considered relative to the base directory. | |
114 | ||
115 | When both `:include' and `:exclude' properties are given values, | |
116 | the exclusion step happens first. | |
117 | ||
118 | One special property controls which back-end function to use for | |
119 | publishing files in the project. This can be used to extend the | |
120 | set of file types publishable by `org-publish', as well as the | |
121 | set of output formats. | |
122 | ||
123 | `:publishing-function' | |
124 | ||
125 | Function to publish file. Each back-end may define its | |
126 | own (i.e. `org-latex-publish-to-pdf', | |
127 | `org-html-publish-to-html'). May be a list of functions, in | |
128 | which case each function in the list is invoked in turn. | |
129 | ||
130 | Another property allows you to insert code that prepares | |
131 | a project for publishing. For example, you could call GNU Make | |
132 | on a certain makefile, to ensure published files are built up to | |
133 | date. | |
134 | ||
135 | `:preparation-function' | |
136 | ||
137 | Function to be called before publishing this project. This | |
138 | may also be a list of functions. | |
139 | ||
140 | `:completion-function' | |
141 | ||
142 | Function to be called after publishing this project. This | |
143 | may also be a list of functions. | |
144 | ||
145 | Some properties control details of the Org publishing process, | |
146 | and are equivalent to the corresponding user variables listed in | |
147 | the right column. Back-end specific properties may also be | |
148 | included. See the back-end documentation for more information. | |
149 | ||
150 | :author `user-full-name' | |
151 | :creator `org-export-creator-string' | |
152 | :email `user-mail-address' | |
153 | :exclude-tags `org-export-exclude-tags' | |
154 | :headline-levels `org-export-headline-levels' | |
155 | :language `org-export-default-language' | |
156 | :preserve-breaks `org-export-preserve-breaks' | |
157 | :section-numbers `org-export-with-section-numbers' | |
158 | :select-tags `org-export-select-tags' | |
159 | :time-stamp-file `org-export-time-stamp-file' | |
160 | :with-archived-trees `org-export-with-archived-trees' | |
161 | :with-author `org-export-with-author' | |
162 | :with-creator `org-export-with-creator' | |
163 | :with-date `org-export-with-date' | |
164 | :with-drawers `org-export-with-drawers' | |
165 | :with-email `org-export-with-email' | |
166 | :with-emphasize `org-export-with-emphasize' | |
167 | :with-entities `org-export-with-entities' | |
168 | :with-fixed-width `org-export-with-fixed-width' | |
169 | :with-footnotes `org-export-with-footnotes' | |
170 | :with-inlinetasks `org-export-with-inlinetasks' | |
171 | :with-latex `org-export-with-latex' | |
172 | :with-priority `org-export-with-priority' | |
173 | :with-smart-quotes `org-export-with-smart-quotes' | |
174 | :with-special-strings `org-export-with-special-strings' | |
175 | :with-statistics-cookies' `org-export-with-statistics-cookies' | |
176 | :with-sub-superscript `org-export-with-sub-superscripts' | |
177 | :with-toc `org-export-with-toc' | |
178 | :with-tables `org-export-with-tables' | |
179 | :with-tags `org-export-with-tags' | |
180 | :with-tasks `org-export-with-tasks' | |
181 | :with-timestamps `org-export-with-timestamps' | |
182 | :with-planning `org-export-with-planning' | |
183 | :with-todo-keywords `org-export-with-todo-keywords' | |
184 | ||
185 | The following properties may be used to control publishing of | |
186 | a site-map of files or summary page for a given project. | |
187 | ||
188 | `:auto-sitemap' | |
189 | ||
190 | Whether to publish a site-map during | |
191 | `org-publish-current-project' or `org-publish-all'. | |
192 | ||
193 | `:sitemap-filename' | |
194 | ||
195 | Filename for output of sitemap. Defaults to \"sitemap.org\". | |
196 | ||
197 | `:sitemap-title' | |
198 | ||
199 | Title of site-map page. Defaults to name of file. | |
200 | ||
201 | `:sitemap-function' | |
202 | ||
203 | Plugin function to use for generation of site-map. Defaults | |
204 | to `org-publish-org-sitemap', which generates a plain list of | |
205 | links to all files in the project. | |
206 | ||
207 | `:sitemap-style' | |
208 | ||
209 | Can be `list' (site-map is just an itemized list of the | |
210 | titles of the files involved) or `tree' (the directory | |
211 | structure of the source files is reflected in the site-map). | |
212 | Defaults to `tree'. | |
213 | ||
214 | `:sitemap-sans-extension' | |
215 | ||
216 | Remove extension from site-map's file-names. Useful to have | |
217 | cool URIs (see http://www.w3.org/Provider/Style/URI). | |
218 | Defaults to nil. | |
219 | ||
220 | If you create a site-map file, adjust the sorting like this: | |
221 | ||
222 | `:sitemap-sort-folders' | |
223 | ||
224 | Where folders should appear in the site-map. Set this to | |
225 | `first' (default) or `last' to display folders first or last, | |
226 | respectively. Any other value will mix files and folders. | |
227 | ||
228 | `:sitemap-sort-files' | |
229 | ||
230 | The site map is normally sorted alphabetically. You can | |
3c8b09ca | 231 | change this behaviour setting this to `anti-chronologically', |
271672fa BG |
232 | `chronologically', or nil. |
233 | ||
234 | `:sitemap-ignore-case' | |
235 | ||
236 | Should sorting be case-sensitive? Default nil. | |
237 | ||
238 | The following property control the creation of a concept index. | |
239 | ||
240 | `:makeindex' | |
241 | ||
242 | Create a concept index. The file containing the index has to | |
243 | be called \"theindex.org\". If it doesn't exist in the | |
244 | project, it will be generated. Contents of the index are | |
245 | stored in the file \"theindex.inc\", which can be included in | |
246 | \"theindex.org\". | |
247 | ||
248 | Other properties affecting publication. | |
249 | ||
250 | `:body-only' | |
251 | ||
252 | Set this to t to publish only the body of the documents." | |
253 | :group 'org-export-publish | |
254 | :type 'alist) | |
255 | ||
256 | (defcustom org-publish-use-timestamps-flag t | |
257 | "Non-nil means use timestamp checking to publish only changed files. | |
258 | When nil, do no timestamp checking and always publish all files." | |
259 | :group 'org-export-publish | |
260 | :type 'boolean) | |
261 | ||
262 | (defcustom org-publish-timestamp-directory | |
263 | (convert-standard-filename "~/.org-timestamps/") | |
264 | "Name of directory in which to store publishing timestamps." | |
265 | :group 'org-export-publish | |
266 | :type 'directory) | |
267 | ||
268 | (defcustom org-publish-list-skipped-files t | |
269 | "Non-nil means show message about files *not* published." | |
270 | :group 'org-export-publish | |
271 | :type 'boolean) | |
272 | ||
273 | (defcustom org-publish-sitemap-sort-files 'alphabetically | |
274 | "Method to sort files in site-maps. | |
275 | Possible values are `alphabetically', `chronologically', | |
276 | `anti-chronologically' and nil. | |
277 | ||
278 | If `alphabetically', files will be sorted alphabetically. If | |
279 | `chronologically', files will be sorted with older modification | |
280 | time first. If `anti-chronologically', files will be sorted with | |
281 | newer modification time first. nil won't sort files. | |
282 | ||
283 | You can overwrite this default per project in your | |
284 | `org-publish-project-alist', using `:sitemap-sort-files'." | |
285 | :group 'org-export-publish | |
286 | :type 'symbol) | |
287 | ||
288 | (defcustom org-publish-sitemap-sort-folders 'first | |
289 | "A symbol, denoting if folders are sorted first in sitemaps. | |
290 | Possible values are `first', `last', and nil. | |
291 | If `first', folders will be sorted before files. | |
292 | If `last', folders are sorted to the end after the files. | |
293 | Any other value will not mix files and folders. | |
294 | ||
295 | You can overwrite this default per project in your | |
296 | `org-publish-project-alist', using `:sitemap-sort-folders'." | |
297 | :group 'org-export-publish | |
298 | :type 'symbol) | |
299 | ||
300 | (defcustom org-publish-sitemap-sort-ignore-case nil | |
301 | "Non-nil when site-map sorting should ignore case. | |
302 | ||
303 | You can overwrite this default per project in your | |
304 | `org-publish-project-alist', using `:sitemap-ignore-case'." | |
305 | :group 'org-export-publish | |
306 | :type 'boolean) | |
307 | ||
308 | (defcustom org-publish-sitemap-date-format "%Y-%m-%d" | |
309 | "Format for printing a date in the sitemap. | |
310 | See `format-time-string' for allowed formatters." | |
311 | :group 'org-export-publish | |
312 | :type 'string) | |
313 | ||
314 | (defcustom org-publish-sitemap-file-entry-format "%t" | |
315 | "Format string for site-map file entry. | |
316 | You could use brackets to delimit on what part the link will be. | |
317 | ||
318 | %t is the title. | |
319 | %a is the author. | |
320 | %d is the date formatted using `org-publish-sitemap-date-format'." | |
321 | :group 'org-export-publish | |
322 | :type 'string) | |
323 | ||
324 | ||
325 | \f | |
326 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
327 | ;;; Timestamp-related functions | |
328 | ||
329 | (defun org-publish-timestamp-filename (filename &optional pub-dir pub-func) | |
330 | "Return path to timestamp file for filename FILENAME." | |
331 | (setq filename (concat filename "::" (or pub-dir "") "::" | |
332 | (format "%s" (or pub-func "")))) | |
333 | (concat "X" (if (fboundp 'sha1) (sha1 filename) (md5 filename)))) | |
334 | ||
335 | (defun org-publish-needed-p | |
336 | (filename &optional pub-dir pub-func true-pub-dir base-dir) | |
337 | "Non-nil if FILENAME should be published in PUB-DIR using PUB-FUNC. | |
338 | TRUE-PUB-DIR is where the file will truly end up. Currently we | |
339 | are not using this - maybe it can eventually be used to check if | |
340 | the file is present at the target location, and how old it is. | |
341 | Right now we cannot do this, because we do not know under what | |
342 | file name the file will be stored - the publishing function can | |
343 | still decide about that independently." | |
344 | (let ((rtn (if (not org-publish-use-timestamps-flag) t | |
345 | (org-publish-cache-file-needs-publishing | |
346 | filename pub-dir pub-func base-dir)))) | |
347 | (if rtn (message "Publishing file %s using `%s'" filename pub-func) | |
348 | (when org-publish-list-skipped-files | |
349 | (message "Skipping unmodified file %s" filename))) | |
350 | rtn)) | |
351 | ||
352 | (defun org-publish-update-timestamp | |
353 | (filename &optional pub-dir pub-func base-dir) | |
354 | "Update publishing timestamp for file FILENAME. | |
355 | If there is no timestamp, create one." | |
356 | (let ((key (org-publish-timestamp-filename filename pub-dir pub-func)) | |
357 | (stamp (org-publish-cache-ctime-of-src filename))) | |
358 | (org-publish-cache-set key stamp))) | |
359 | ||
360 | (defun org-publish-remove-all-timestamps () | |
361 | "Remove all files in the timestamp directory." | |
362 | (let ((dir org-publish-timestamp-directory) | |
363 | files) | |
364 | (when (and (file-exists-p dir) (file-directory-p dir)) | |
365 | (mapc 'delete-file (directory-files dir 'full "[^.]\\'")) | |
366 | (org-publish-reset-cache)))) | |
367 | ||
368 | ||
369 | \f | |
370 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
371 | ;;; Getting project information out of `org-publish-project-alist' | |
372 | ||
373 | (defun org-publish-expand-projects (projects-alist) | |
374 | "Expand projects in PROJECTS-ALIST. | |
375 | This splices all the components into the list." | |
376 | (let ((rest projects-alist) rtn p components) | |
377 | (while (setq p (pop rest)) | |
378 | (if (setq components (plist-get (cdr p) :components)) | |
379 | (setq rest (append | |
380 | (mapcar (lambda (x) (assoc x org-publish-project-alist)) | |
381 | components) | |
382 | rest)) | |
383 | (push p rtn))) | |
384 | (nreverse (delete-dups (delq nil rtn))))) | |
385 | ||
386 | (defvar org-publish-sitemap-sort-files) | |
387 | (defvar org-publish-sitemap-sort-folders) | |
388 | (defvar org-publish-sitemap-ignore-case) | |
389 | (defvar org-publish-sitemap-requested) | |
390 | (defvar org-publish-sitemap-date-format) | |
391 | (defvar org-publish-sitemap-file-entry-format) | |
392 | (defun org-publish-compare-directory-files (a b) | |
393 | "Predicate for `sort', that sorts folders and files for sitemap." | |
394 | (let ((retval t)) | |
395 | (when (or org-publish-sitemap-sort-files org-publish-sitemap-sort-folders) | |
396 | ;; First we sort files: | |
397 | (when org-publish-sitemap-sort-files | |
398 | (case org-publish-sitemap-sort-files | |
399 | (alphabetically | |
400 | (let* ((adir (file-directory-p a)) | |
401 | (aorg (and (string-match "\\.org$" a) (not adir))) | |
402 | (bdir (file-directory-p b)) | |
403 | (borg (and (string-match "\\.org$" b) (not bdir))) | |
404 | (A (if aorg (concat (file-name-directory a) | |
405 | (org-publish-find-title a)) a)) | |
406 | (B (if borg (concat (file-name-directory b) | |
407 | (org-publish-find-title b)) b))) | |
408 | (setq retval (if org-publish-sitemap-ignore-case | |
409 | (not (string-lessp (upcase B) (upcase A))) | |
410 | (not (string-lessp B A)))))) | |
411 | ((anti-chronologically chronologically) | |
412 | (let* ((adate (org-publish-find-date a)) | |
413 | (bdate (org-publish-find-date b)) | |
414 | (A (+ (lsh (car adate) 16) (cadr adate))) | |
415 | (B (+ (lsh (car bdate) 16) (cadr bdate)))) | |
416 | (setq retval | |
417 | (if (eq org-publish-sitemap-sort-files 'chronologically) (<= A B) | |
418 | (>= A B))))))) | |
419 | ;; Directory-wise wins: | |
420 | (when org-publish-sitemap-sort-folders | |
421 | ;; a is directory, b not: | |
422 | (cond | |
423 | ((and (file-directory-p a) (not (file-directory-p b))) | |
424 | (setq retval (equal org-publish-sitemap-sort-folders 'first))) | |
425 | ;; a is not a directory, but b is: | |
426 | ((and (not (file-directory-p a)) (file-directory-p b)) | |
427 | (setq retval (equal org-publish-sitemap-sort-folders 'last)))))) | |
428 | retval)) | |
429 | ||
430 | (defun org-publish-get-base-files-1 | |
431 | (base-dir &optional recurse match skip-file skip-dir) | |
432 | "Set `org-publish-temp-files' with files from BASE-DIR directory. | |
433 | If RECURSE is non-nil, check BASE-DIR recursively. If MATCH is | |
434 | non-nil, restrict this list to the files matching the regexp | |
435 | MATCH. If SKIP-FILE is non-nil, skip file matching the regexp | |
436 | SKIP-FILE. If SKIP-DIR is non-nil, don't check directories | |
437 | matching the regexp SKIP-DIR when recursing through BASE-DIR." | |
438 | (mapc (lambda (f) | |
439 | (let ((fd-p (file-directory-p f)) | |
440 | (fnd (file-name-nondirectory f))) | |
441 | (if (and fd-p recurse | |
442 | (not (string-match "^\\.+$" fnd)) | |
443 | (if skip-dir (not (string-match skip-dir fnd)) t)) | |
444 | (org-publish-get-base-files-1 | |
445 | f recurse match skip-file skip-dir) | |
446 | (unless (or fd-p ;; this is a directory | |
447 | (and skip-file (string-match skip-file fnd)) | |
448 | (not (file-exists-p (file-truename f))) | |
449 | (not (string-match match fnd))) | |
450 | ||
451 | (pushnew f org-publish-temp-files))))) | |
452 | (let ((all-files (if (not recurse) (directory-files base-dir t match) | |
453 | ;; If RECURSE is non-nil, we want all files | |
454 | ;; matching MATCH and sub-directories. | |
455 | (org-remove-if-not | |
456 | (lambda (file) | |
457 | (or (file-directory-p file) | |
458 | (and match (string-match match file)))) | |
459 | (directory-files base-dir t))))) | |
460 | (if (not org-publish-sitemap-requested) all-files | |
461 | (sort all-files 'org-publish-compare-directory-files))))) | |
462 | ||
463 | (defun org-publish-get-base-files (project &optional exclude-regexp) | |
464 | "Return a list of all files in PROJECT. | |
465 | If EXCLUDE-REGEXP is set, this will be used to filter out | |
466 | matching filenames." | |
467 | (let* ((project-plist (cdr project)) | |
468 | (base-dir (file-name-as-directory | |
469 | (plist-get project-plist :base-directory))) | |
470 | (include-list (plist-get project-plist :include)) | |
471 | (recurse (plist-get project-plist :recursive)) | |
472 | (extension (or (plist-get project-plist :base-extension) "org")) | |
473 | ;; sitemap-... variables are dynamically scoped for | |
474 | ;; org-publish-compare-directory-files: | |
475 | (org-publish-sitemap-requested | |
476 | (plist-get project-plist :auto-sitemap)) | |
477 | (sitemap-filename | |
478 | (or (plist-get project-plist :sitemap-filename) "sitemap.org")) | |
479 | (org-publish-sitemap-sort-folders | |
480 | (if (plist-member project-plist :sitemap-sort-folders) | |
481 | (plist-get project-plist :sitemap-sort-folders) | |
482 | org-publish-sitemap-sort-folders)) | |
483 | (org-publish-sitemap-sort-files | |
484 | (cond ((plist-member project-plist :sitemap-sort-files) | |
485 | (plist-get project-plist :sitemap-sort-files)) | |
486 | ;; For backward compatibility: | |
487 | ((plist-member project-plist :sitemap-alphabetically) | |
488 | (if (plist-get project-plist :sitemap-alphabetically) | |
489 | 'alphabetically nil)) | |
490 | (t org-publish-sitemap-sort-files))) | |
491 | (org-publish-sitemap-ignore-case | |
492 | (if (plist-member project-plist :sitemap-ignore-case) | |
493 | (plist-get project-plist :sitemap-ignore-case) | |
494 | org-publish-sitemap-sort-ignore-case)) | |
495 | (match (if (eq extension 'any) "^[^\\.]" | |
496 | (concat "^[^\\.].*\\.\\(" extension "\\)$")))) | |
497 | ;; Make sure `org-publish-sitemap-sort-folders' has an accepted | |
498 | ;; value. | |
499 | (unless (memq org-publish-sitemap-sort-folders '(first last)) | |
500 | (setq org-publish-sitemap-sort-folders nil)) | |
501 | ||
502 | (setq org-publish-temp-files nil) | |
503 | (if org-publish-sitemap-requested | |
504 | (pushnew (expand-file-name (concat base-dir sitemap-filename)) | |
505 | org-publish-temp-files)) | |
506 | (org-publish-get-base-files-1 base-dir recurse match | |
507 | ;; FIXME distinguish exclude regexp | |
508 | ;; for skip-file and skip-dir? | |
509 | exclude-regexp exclude-regexp) | |
510 | (mapc (lambda (f) | |
511 | (pushnew | |
512 | (expand-file-name (concat base-dir f)) | |
513 | org-publish-temp-files)) | |
514 | include-list) | |
515 | org-publish-temp-files)) | |
516 | ||
517 | (defun org-publish-get-project-from-filename (filename &optional up) | |
518 | "Return the project that FILENAME belongs to." | |
519 | (let* ((filename (expand-file-name filename)) | |
520 | project-name) | |
521 | ||
522 | (catch 'p-found | |
523 | (dolist (prj org-publish-project-alist) | |
524 | (unless (plist-get (cdr prj) :components) | |
525 | ;; [[info:org:Selecting%20files]] shows how this is supposed to work: | |
526 | (let* ((r (plist-get (cdr prj) :recursive)) | |
527 | (b (expand-file-name (file-name-as-directory | |
528 | (plist-get (cdr prj) :base-directory)))) | |
529 | (x (or (plist-get (cdr prj) :base-extension) "org")) | |
530 | (e (plist-get (cdr prj) :exclude)) | |
531 | (i (plist-get (cdr prj) :include)) | |
532 | (xm (concat "^" b (if r ".+" "[^/]+") "\\.\\(" x "\\)$"))) | |
533 | (when | |
534 | (or (and i | |
535 | (member filename | |
536 | (mapcar (lambda (file) | |
537 | (expand-file-name file b)) | |
538 | i))) | |
539 | (and (not (and e (string-match e filename))) | |
540 | (string-match xm filename))) | |
541 | (setq project-name (car prj)) | |
542 | (throw 'p-found project-name)))))) | |
543 | (when up | |
544 | (dolist (prj org-publish-project-alist) | |
545 | (if (member project-name (plist-get (cdr prj) :components)) | |
546 | (setq project-name (car prj))))) | |
547 | (assoc project-name org-publish-project-alist))) | |
548 | ||
549 | ||
550 | \f | |
551 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
552 | ;;; Tools for publishing functions in back-ends | |
553 | ||
554 | (defun org-publish-org-to (backend filename extension plist &optional pub-dir) | |
555 | "Publish an Org file to a specified back-end. | |
556 | ||
557 | BACKEND is a symbol representing the back-end used for | |
558 | transcoding. FILENAME is the filename of the Org file to be | |
559 | published. EXTENSION is the extension used for the output | |
560 | string, with the leading dot. PLIST is the property list for the | |
561 | given project. | |
562 | ||
563 | Optional argument PUB-DIR, when non-nil is the publishing | |
564 | directory. | |
565 | ||
566 | Return output file name." | |
567 | (unless (or (not pub-dir) (file-exists-p pub-dir)) (make-directory pub-dir t)) | |
568 | ;; Check if a buffer visiting FILENAME is already open. | |
569 | (let* ((org-inhibit-startup t) | |
570 | (visitingp (find-buffer-visiting filename)) | |
571 | (work-buffer (or visitingp (find-file-noselect filename)))) | |
572 | (prog1 (with-current-buffer work-buffer | |
573 | (let ((output-file | |
574 | (org-export-output-file-name extension nil pub-dir)) | |
575 | (body-p (plist-get plist :body-only))) | |
576 | (org-export-to-file backend output-file | |
577 | nil nil nil body-p | |
578 | ;; Add `org-publish-collect-numbering' and | |
579 | ;; `org-publish-collect-index' to final output | |
580 | ;; filters. The latter isn't dependent on | |
581 | ;; `:makeindex', since we want to keep it up-to-date | |
582 | ;; in cache anyway. | |
583 | (org-combine-plists | |
584 | plist | |
585 | `(:filter-final-output | |
586 | ,(cons 'org-publish-collect-numbering | |
587 | (cons 'org-publish-collect-index | |
588 | (plist-get plist :filter-final-output)))))))) | |
589 | ;; Remove opened buffer in the process. | |
590 | (unless visitingp (kill-buffer work-buffer))))) | |
591 | ||
592 | (defun org-publish-attachment (plist filename pub-dir) | |
593 | "Publish a file with no transformation of any kind. | |
594 | ||
595 | FILENAME is the filename of the Org file to be published. PLIST | |
596 | is the property list for the given project. PUB-DIR is the | |
597 | publishing directory. | |
598 | ||
599 | Return output file name." | |
600 | (unless (file-directory-p pub-dir) | |
601 | (make-directory pub-dir t)) | |
602 | (or (equal (expand-file-name (file-name-directory filename)) | |
603 | (file-name-as-directory (expand-file-name pub-dir))) | |
604 | (copy-file filename | |
605 | (expand-file-name (file-name-nondirectory filename) pub-dir) | |
606 | t))) | |
607 | ||
608 | ||
609 | \f | |
610 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
611 | ;;; Publishing files, sets of files, and indices | |
612 | ||
613 | (defun org-publish-file (filename &optional project no-cache) | |
614 | "Publish file FILENAME from PROJECT. | |
615 | If NO-CACHE is not nil, do not initialize org-publish-cache and | |
616 | write it to disk. This is needed, since this function is used to | |
617 | publish single files, when entire projects are published. | |
618 | See `org-publish-projects'." | |
619 | (let* ((project | |
620 | (or project | |
621 | (or (org-publish-get-project-from-filename filename) | |
622 | (error "File %s not part of any known project" | |
623 | (abbreviate-file-name filename))))) | |
624 | (project-plist (cdr project)) | |
625 | (ftname (expand-file-name filename)) | |
626 | (publishing-function | |
627 | (or (plist-get project-plist :publishing-function) | |
628 | (error "No publishing function chosen"))) | |
629 | (base-dir | |
630 | (file-name-as-directory | |
631 | (expand-file-name | |
632 | (or (plist-get project-plist :base-directory) | |
633 | (error "Project %s does not have :base-directory defined" | |
634 | (car project)))))) | |
635 | (pub-dir | |
636 | (file-name-as-directory | |
637 | (file-truename | |
638 | (or (eval (plist-get project-plist :publishing-directory)) | |
639 | (error "Project %s does not have :publishing-directory defined" | |
640 | (car project)))))) | |
641 | tmp-pub-dir) | |
642 | ||
643 | (unless no-cache (org-publish-initialize-cache (car project))) | |
644 | ||
645 | (setq tmp-pub-dir | |
646 | (file-name-directory | |
647 | (concat pub-dir | |
648 | (and (string-match (regexp-quote base-dir) ftname) | |
649 | (substring ftname (match-end 0)))))) | |
650 | (if (listp publishing-function) | |
651 | ;; allow chain of publishing functions | |
652 | (mapc (lambda (f) | |
653 | (when (org-publish-needed-p | |
654 | filename pub-dir f tmp-pub-dir base-dir) | |
655 | (funcall f project-plist filename tmp-pub-dir) | |
656 | (org-publish-update-timestamp filename pub-dir f base-dir))) | |
657 | publishing-function) | |
658 | (when (org-publish-needed-p | |
659 | filename pub-dir publishing-function tmp-pub-dir base-dir) | |
660 | (funcall publishing-function project-plist filename tmp-pub-dir) | |
661 | (org-publish-update-timestamp | |
662 | filename pub-dir publishing-function base-dir))) | |
663 | (unless no-cache (org-publish-write-cache-file)))) | |
664 | ||
665 | (defun org-publish-projects (projects) | |
666 | "Publish all files belonging to the PROJECTS alist. | |
667 | If `:auto-sitemap' is set, publish the sitemap too. If | |
668 | `:makeindex' is set, also produce a file theindex.org." | |
669 | (mapc | |
670 | (lambda (project) | |
671 | ;; Each project uses its own cache file: | |
672 | (org-publish-initialize-cache (car project)) | |
673 | (let* ((project-plist (cdr project)) | |
674 | (exclude-regexp (plist-get project-plist :exclude)) | |
675 | (sitemap-p (plist-get project-plist :auto-sitemap)) | |
676 | (sitemap-filename (or (plist-get project-plist :sitemap-filename) | |
677 | "sitemap.org")) | |
678 | (sitemap-function (or (plist-get project-plist :sitemap-function) | |
679 | 'org-publish-org-sitemap)) | |
680 | (org-publish-sitemap-date-format | |
681 | (or (plist-get project-plist :sitemap-date-format) | |
682 | org-publish-sitemap-date-format)) | |
683 | (org-publish-sitemap-file-entry-format | |
684 | (or (plist-get project-plist :sitemap-file-entry-format) | |
685 | org-publish-sitemap-file-entry-format)) | |
686 | (preparation-function | |
687 | (plist-get project-plist :preparation-function)) | |
688 | (completion-function (plist-get project-plist :completion-function)) | |
689 | (files (org-publish-get-base-files project exclude-regexp)) | |
690 | (theindex | |
691 | (expand-file-name "theindex.org" | |
692 | (plist-get project-plist :base-directory)))) | |
693 | (when preparation-function (run-hooks 'preparation-function)) | |
694 | (if sitemap-p (funcall sitemap-function project sitemap-filename)) | |
695 | ;; Publish all files from PROJECT excepted "theindex.org". Its | |
696 | ;; publishing will be deferred until "theindex.inc" is | |
697 | ;; populated. | |
698 | (dolist (file files) | |
699 | (unless (equal file theindex) | |
700 | (org-publish-file file project t))) | |
701 | ;; Populate "theindex.inc", if needed, and publish | |
702 | ;; "theindex.org". | |
703 | (when (plist-get project-plist :makeindex) | |
704 | (org-publish-index-generate-theindex | |
705 | project (plist-get project-plist :base-directory)) | |
706 | (org-publish-file theindex project t)) | |
707 | (when completion-function (run-hooks 'completion-function)) | |
708 | (org-publish-write-cache-file))) | |
709 | (org-publish-expand-projects projects))) | |
710 | ||
711 | (defun org-publish-org-sitemap (project &optional sitemap-filename) | |
712 | "Create a sitemap of pages in set defined by PROJECT. | |
713 | Optionally set the filename of the sitemap with SITEMAP-FILENAME. | |
714 | Default for SITEMAP-FILENAME is 'sitemap.org'." | |
715 | (let* ((project-plist (cdr project)) | |
716 | (dir (file-name-as-directory | |
717 | (plist-get project-plist :base-directory))) | |
718 | (localdir (file-name-directory dir)) | |
719 | (indent-str (make-string 2 ?\ )) | |
720 | (exclude-regexp (plist-get project-plist :exclude)) | |
721 | (files (nreverse | |
722 | (org-publish-get-base-files project exclude-regexp))) | |
723 | (sitemap-filename (concat dir (or sitemap-filename "sitemap.org"))) | |
724 | (sitemap-title (or (plist-get project-plist :sitemap-title) | |
725 | (concat "Sitemap for project " (car project)))) | |
726 | (sitemap-style (or (plist-get project-plist :sitemap-style) | |
727 | 'tree)) | |
728 | (sitemap-sans-extension | |
729 | (plist-get project-plist :sitemap-sans-extension)) | |
730 | (visiting (find-buffer-visiting sitemap-filename)) | |
731 | (ifn (file-name-nondirectory sitemap-filename)) | |
732 | file sitemap-buffer) | |
733 | (with-current-buffer | |
734 | (let ((org-inhibit-startup t)) | |
735 | (setq sitemap-buffer | |
736 | (or visiting (find-file sitemap-filename)))) | |
737 | (erase-buffer) | |
738 | (insert (concat "#+TITLE: " sitemap-title "\n\n")) | |
739 | (while (setq file (pop files)) | |
740 | (let ((fn (file-name-nondirectory file)) | |
741 | (link (file-relative-name file dir)) | |
742 | (oldlocal localdir)) | |
743 | (when sitemap-sans-extension | |
744 | (setq link (file-name-sans-extension link))) | |
745 | ;; sitemap shouldn't list itself | |
746 | (unless (equal (file-truename sitemap-filename) | |
747 | (file-truename file)) | |
748 | (if (eq sitemap-style 'list) | |
749 | (message "Generating list-style sitemap for %s" sitemap-title) | |
750 | (message "Generating tree-style sitemap for %s" sitemap-title) | |
751 | (setq localdir (concat (file-name-as-directory dir) | |
752 | (file-name-directory link))) | |
753 | (unless (string= localdir oldlocal) | |
754 | (if (string= localdir dir) | |
755 | (setq indent-str (make-string 2 ?\ )) | |
756 | (let ((subdirs | |
757 | (split-string | |
758 | (directory-file-name | |
759 | (file-name-directory | |
760 | (file-relative-name localdir dir))) "/")) | |
761 | (subdir "") | |
762 | (old-subdirs (split-string | |
763 | (file-relative-name oldlocal dir) "/"))) | |
764 | (setq indent-str (make-string 2 ?\ )) | |
765 | (while (string= (car old-subdirs) (car subdirs)) | |
766 | (setq indent-str (concat indent-str (make-string 2 ?\ ))) | |
767 | (pop old-subdirs) | |
768 | (pop subdirs)) | |
769 | (dolist (d subdirs) | |
770 | (setq subdir (concat subdir d "/")) | |
771 | (insert (concat indent-str " + " d "\n")) | |
772 | (setq indent-str (make-string | |
773 | (+ (length indent-str) 2) ?\ ))))))) | |
774 | ;; This is common to 'flat and 'tree | |
775 | (let ((entry | |
776 | (org-publish-format-file-entry | |
777 | org-publish-sitemap-file-entry-format file project-plist)) | |
778 | (regexp "\\(.*\\)\\[\\([^][]+\\)\\]\\(.*\\)")) | |
779 | (cond ((string-match-p regexp entry) | |
780 | (string-match regexp entry) | |
781 | (insert (concat indent-str " + " (match-string 1 entry) | |
782 | "[[file:" link "][" | |
783 | (match-string 2 entry) | |
784 | "]]" (match-string 3 entry) "\n"))) | |
785 | (t | |
786 | (insert (concat indent-str " + [[file:" link "][" | |
787 | entry | |
788 | "]]\n")))))))) | |
789 | (save-buffer)) | |
790 | (or visiting (kill-buffer sitemap-buffer)))) | |
791 | ||
792 | (defun org-publish-format-file-entry (fmt file project-plist) | |
793 | (format-spec | |
794 | fmt | |
795 | `((?t . ,(org-publish-find-title file t)) | |
796 | (?d . ,(format-time-string org-publish-sitemap-date-format | |
797 | (org-publish-find-date file))) | |
798 | (?a . ,(or (plist-get project-plist :author) user-full-name))))) | |
799 | ||
800 | (defun org-publish-find-title (file &optional reset) | |
801 | "Find the title of FILE in project." | |
802 | (or | |
803 | (and (not reset) (org-publish-cache-get-file-property file :title nil t)) | |
804 | (let* ((org-inhibit-startup t) | |
805 | (visiting (find-buffer-visiting file)) | |
806 | (buffer (or visiting (find-file-noselect file)))) | |
807 | (with-current-buffer buffer | |
808 | (org-mode) | |
809 | (let ((title | |
810 | (let ((property (plist-get (org-export-get-environment) :title))) | |
30cb51f1 BG |
811 | (if property |
812 | (org-no-properties (org-element-interpret-data property)) | |
271672fa BG |
813 | (file-name-nondirectory (file-name-sans-extension file)))))) |
814 | (unless visiting (kill-buffer buffer)) | |
815 | (org-publish-cache-set-file-property file :title title) | |
816 | title))))) | |
817 | ||
818 | (defun org-publish-find-date (file) | |
819 | "Find the date of FILE in project. | |
820 | This function assumes FILE is either a directory or an Org file. | |
821 | If FILE is an Org file and provides a DATE keyword use it. In | |
822 | any other case use the file system's modification time. Return | |
823 | time in `current-time' format." | |
824 | (if (file-directory-p file) (nth 5 (file-attributes file)) | |
825 | (let* ((visiting (find-buffer-visiting file)) | |
826 | (file-buf (or visiting (find-file-noselect file nil))) | |
827 | (date (plist-get | |
828 | (with-current-buffer file-buf | |
829 | (let ((org-inhibit-startup t)) (org-mode)) | |
830 | (org-export-get-environment)) | |
831 | :date))) | |
832 | (unless visiting (kill-buffer file-buf)) | |
833 | ;; DATE is either a timestamp object or a secondary string. If it | |
834 | ;; is a timestamp or if the secondary string contains a timestamp, | |
835 | ;; convert it to internal format. Otherwise, use FILE | |
836 | ;; modification time. | |
837 | (cond ((eq (org-element-type date) 'timestamp) | |
838 | (org-time-string-to-time (org-element-interpret-data date))) | |
839 | ((let ((ts (and (consp date) (assq 'timestamp date)))) | |
840 | (and ts | |
841 | (let ((value (org-element-interpret-data ts))) | |
842 | (and (org-string-nw-p value) | |
843 | (org-time-string-to-time value)))))) | |
844 | ((file-exists-p file) (nth 5 (file-attributes file))) | |
845 | (t (error "No such file: \"%s\"" file)))))) | |
846 | ||
847 | ||
848 | \f | |
849 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
850 | ;;; Interactive publishing functions | |
851 | ||
852 | ;;;###autoload | |
853 | (defalias 'org-publish-project 'org-publish) | |
854 | ||
855 | ;;;###autoload | |
856 | (defun org-publish (project &optional force async) | |
857 | "Publish PROJECT. | |
858 | ||
859 | PROJECT is either a project name, as a string, or a project | |
860 | alist (see `org-publish-project-alist' variable). | |
861 | ||
862 | When optional argument FORCE is non-nil, force publishing all | |
863 | files in PROJECT. With a non-nil optional argument ASYNC, | |
864 | publishing will be done asynchronously, in another process." | |
865 | (interactive | |
866 | (list | |
867 | (assoc (org-icompleting-read | |
868 | "Publish project: " | |
869 | org-publish-project-alist nil t) | |
870 | org-publish-project-alist) | |
871 | current-prefix-arg)) | |
872 | (let ((project-alist (if (not (stringp project)) (list project) | |
873 | ;; If this function is called in batch mode, | |
874 | ;; project is still a string here. | |
875 | (list (assoc project org-publish-project-alist))))) | |
876 | (if async | |
877 | (org-export-async-start 'ignore | |
878 | `(let ((org-publish-use-timestamps-flag | |
879 | (if ',force nil ,org-publish-use-timestamps-flag))) | |
880 | (org-publish-projects ',project-alist))) | |
881 | (save-window-excursion | |
882 | (let* ((org-publish-use-timestamps-flag | |
883 | (if force nil org-publish-use-timestamps-flag))) | |
884 | (org-publish-projects project-alist)))))) | |
885 | ||
886 | ;;;###autoload | |
887 | (defun org-publish-all (&optional force async) | |
888 | "Publish all projects. | |
889 | With prefix argument FORCE, remove all files in the timestamp | |
890 | directory and force publishing all projects. With a non-nil | |
891 | optional argument ASYNC, publishing will be done asynchronously, | |
892 | in another process." | |
893 | (interactive "P") | |
894 | (if async | |
895 | (org-export-async-start 'ignore | |
896 | `(progn | |
897 | (when ',force (org-publish-remove-all-timestamps)) | |
898 | (let ((org-publish-use-timestamps-flag | |
899 | (if ',force nil ,org-publish-use-timestamps-flag))) | |
900 | (org-publish-projects ',org-publish-project-alist)))) | |
901 | (when force (org-publish-remove-all-timestamps)) | |
902 | (save-window-excursion | |
903 | (let ((org-publish-use-timestamps-flag | |
904 | (if force nil org-publish-use-timestamps-flag))) | |
905 | (org-publish-projects org-publish-project-alist))))) | |
906 | ||
907 | ||
908 | ;;;###autoload | |
909 | (defun org-publish-current-file (&optional force async) | |
910 | "Publish the current file. | |
911 | With prefix argument FORCE, force publish the file. When | |
912 | optional argument ASYNC is non-nil, publishing will be done | |
913 | asynchronously, in another process." | |
914 | (interactive "P") | |
915 | (let ((file (buffer-file-name (buffer-base-buffer)))) | |
916 | (if async | |
917 | (org-export-async-start 'ignore | |
918 | `(let ((org-publish-use-timestamps-flag | |
919 | (if ',force nil ,org-publish-use-timestamps-flag))) | |
920 | (org-publish-file ,file))) | |
921 | (save-window-excursion | |
922 | (let ((org-publish-use-timestamps-flag | |
923 | (if force nil org-publish-use-timestamps-flag))) | |
924 | (org-publish-file file)))))) | |
925 | ||
926 | ;;;###autoload | |
927 | (defun org-publish-current-project (&optional force async) | |
928 | "Publish the project associated with the current file. | |
929 | With a prefix argument, force publishing of all files in | |
930 | the project." | |
931 | (interactive "P") | |
932 | (save-window-excursion | |
933 | (let ((project (org-publish-get-project-from-filename | |
934 | (buffer-file-name (buffer-base-buffer)) 'up))) | |
935 | (if project (org-publish project force async) | |
936 | (error "File %s is not part of any known project" | |
937 | (buffer-file-name (buffer-base-buffer))))))) | |
938 | ||
939 | ||
940 | \f | |
941 | ;;; Index generation | |
942 | ||
943 | (defun org-publish-collect-index (output backend info) | |
944 | "Update index for a file in cache. | |
945 | ||
946 | OUTPUT is the output from transcoding current file. BACKEND is | |
947 | the back-end that was used for transcoding. INFO is a plist | |
948 | containing publishing and export options. | |
949 | ||
950 | The index relative to current file is stored as an alist. An | |
951 | association has the following shape: (TERM FILE-NAME PARENT), | |
952 | where TERM is the indexed term, as a string, FILE-NAME is the | |
953 | original full path of the file where the term in encountered, and | |
954 | PARENT is a reference to the headline, if any, containing the | |
955 | original index keyword. When non-nil, this reference is a cons | |
956 | cell. Its CAR is a symbol among `id', `custom-id' and `name' and | |
957 | its CDR is a string." | |
958 | (let ((file (plist-get info :input-file))) | |
959 | (org-publish-cache-set-file-property | |
960 | file :index | |
961 | (delete-dups | |
962 | (org-element-map (plist-get info :parse-tree) 'keyword | |
963 | (lambda (k) | |
964 | (when (equal (org-element-property :key k) "INDEX") | |
965 | (let ((parent (org-export-get-parent-headline k))) | |
966 | (list (org-element-property :value k) | |
967 | file | |
968 | (cond | |
969 | ((not parent) nil) | |
970 | ((let ((id (org-element-property :ID parent))) | |
971 | (and id (cons 'id id)))) | |
972 | ((let ((id (org-element-property :CUSTOM_ID parent))) | |
973 | (and id (cons 'custom-id id)))) | |
974 | (t (cons 'name | |
975 | ;; Remove statistics cookie. | |
976 | (replace-regexp-in-string | |
977 | "\\[[0-9]+%\\]\\|\\[[0-9]+/[0-9]+\\]" "" | |
978 | (org-element-property :raw-value parent))))))))) | |
979 | info)))) | |
980 | ;; Return output unchanged. | |
981 | output) | |
982 | ||
983 | (defun org-publish-index-generate-theindex (project directory) | |
984 | "Retrieve full index from cache and build \"theindex.org\". | |
985 | PROJECT is the project the index relates to. DIRECTORY is the | |
986 | publishing directory." | |
987 | (let ((all-files (org-publish-get-base-files | |
988 | project (plist-get (cdr project) :exclude))) | |
989 | full-index) | |
990 | ;; Compile full index and sort it alphabetically. | |
991 | (dolist (file all-files | |
992 | (setq full-index | |
993 | (sort (nreverse full-index) | |
994 | (lambda (a b) (string< (downcase (car a)) | |
995 | (downcase (car b))))))) | |
996 | (let ((index (org-publish-cache-get-file-property file :index))) | |
997 | (dolist (term index) | |
998 | (unless (member term full-index) (push term full-index))))) | |
999 | ;; Write "theindex.inc" in DIRECTORY. | |
1000 | (with-temp-file (expand-file-name "theindex.inc" directory) | |
1001 | (let ((current-letter nil) (last-entry nil)) | |
1002 | (dolist (idx full-index) | |
1003 | (let* ((entry (org-split-string (car idx) "!")) | |
1004 | (letter (upcase (substring (car entry) 0 1))) | |
1005 | ;; Transform file into a path relative to publishing | |
1006 | ;; directory. | |
1007 | (file (file-relative-name | |
1008 | (nth 1 idx) | |
1009 | (plist-get (cdr project) :base-directory)))) | |
1010 | ;; Check if another letter has to be inserted. | |
1011 | (unless (string= letter current-letter) | |
1012 | (insert (format "* %s\n" letter))) | |
1013 | ;; Compute the first difference between last entry and | |
1014 | ;; current one: it tells the level at which new items | |
1015 | ;; should be added. | |
1016 | (let* ((rank (if (equal entry last-entry) (1- (length entry)) | |
1017 | (loop for n from 0 to (length entry) | |
1018 | unless (equal (nth n entry) (nth n last-entry)) | |
1019 | return n))) | |
1020 | (len (length (nthcdr rank entry)))) | |
1021 | ;; For each term after the first difference, create | |
1022 | ;; a new sub-list with the term as body. Moreover, | |
1023 | ;; linkify the last term. | |
1024 | (dotimes (n len) | |
1025 | (insert | |
1026 | (concat | |
1027 | (make-string (* (+ rank n) 2) ? ) " - " | |
1028 | (if (not (= (1- len) n)) (nth (+ rank n) entry) | |
1029 | ;; Last term: Link it to TARGET, if possible. | |
1030 | (let ((target (nth 2 idx))) | |
1031 | (format | |
1032 | "[[%s][%s]]" | |
1033 | ;; Destination. | |
1034 | (case (car target) | |
1035 | ('nil (format "file:%s" file)) | |
1036 | (id (format "id:%s" (cdr target))) | |
1037 | (custom-id (format "file:%s::#%s" file (cdr target))) | |
1038 | (otherwise (format "file:%s::*%s" file (cdr target)))) | |
1039 | ;; Description. | |
1040 | (car (last entry))))) | |
1041 | "\n")))) | |
1042 | (setq current-letter letter last-entry entry)))) | |
1043 | ;; Create "theindex.org", if it doesn't exist yet, and provide | |
1044 | ;; a default index file. | |
1045 | (let ((index.org (expand-file-name "theindex.org" directory))) | |
1046 | (unless (file-exists-p index.org) | |
1047 | (with-temp-file index.org | |
1048 | (insert "#+TITLE: Index\n\n#+INCLUDE: \"theindex.inc\"\n\n"))))))) | |
1049 | ||
1050 | ||
1051 | \f | |
1052 | ;;; External Fuzzy Links Resolution | |
1053 | ;; | |
1054 | ;; This part implements tools to resolve [[file.org::*Some headline]] | |
1055 | ;; links, where "file.org" belongs to the current project. | |
1056 | ||
1057 | (defun org-publish-collect-numbering (output backend info) | |
1058 | (org-publish-cache-set-file-property | |
1059 | (plist-get info :input-file) :numbering | |
1060 | (mapcar (lambda (entry) | |
1061 | (cons (org-split-string | |
1062 | (replace-regexp-in-string | |
1063 | "\\[[0-9]+%\\]\\|\\[[0-9]+/[0-9]+\\]" "" | |
1064 | (org-element-property :raw-value (car entry)))) | |
1065 | (cdr entry))) | |
1066 | (plist-get info :headline-numbering))) | |
1067 | ;; Return output unchanged. | |
1068 | output) | |
1069 | ||
1070 | (defun org-publish-resolve-external-fuzzy-link (file fuzzy) | |
1071 | "Return numbering for headline matching FUZZY search in FILE. | |
1072 | ||
1073 | Return value is a list of numbers, or nil. This function allows | |
1074 | to resolve external fuzzy links like: | |
1075 | ||
3c8b09ca | 1076 | [[file.org::*fuzzy][description]]" |
271672fa BG |
1077 | (when org-publish-cache |
1078 | (cdr (assoc (org-split-string | |
1079 | (if (eq (aref fuzzy 0) ?*) (substring fuzzy 1) fuzzy)) | |
1080 | (org-publish-cache-get-file-property | |
1081 | (expand-file-name file) :numbering nil t))))) | |
1082 | ||
1083 | ||
1084 | \f | |
1085 | ;;; Caching functions | |
1086 | ||
1087 | (defun org-publish-write-cache-file (&optional free-cache) | |
1088 | "Write `org-publish-cache' to file. | |
1089 | If FREE-CACHE, empty the cache." | |
1090 | (unless org-publish-cache | |
1091 | (error "`org-publish-write-cache-file' called, but no cache present")) | |
1092 | ||
1093 | (let ((cache-file (org-publish-cache-get ":cache-file:"))) | |
1094 | (unless cache-file | |
1095 | (error "Cannot find cache-file name in `org-publish-write-cache-file'")) | |
1096 | (with-temp-file cache-file | |
1097 | (let (print-level print-length) | |
1098 | (insert "(setq org-publish-cache (make-hash-table :test 'equal :weakness nil :size 100))\n") | |
1099 | (maphash (lambda (k v) | |
1100 | (insert | |
1101 | (format (concat "(puthash %S " | |
1102 | (if (or (listp v) (symbolp v)) | |
1103 | "'" "") | |
1104 | "%S org-publish-cache)\n") k v))) | |
1105 | org-publish-cache))) | |
1106 | (when free-cache (org-publish-reset-cache)))) | |
1107 | ||
1108 | (defun org-publish-initialize-cache (project-name) | |
1109 | "Initialize the projects cache if not initialized yet and return it." | |
1110 | ||
1111 | (unless project-name | |
1112 | (error "Cannot initialize `org-publish-cache' without projects name in `org-publish-initialize-cache'")) | |
1113 | ||
1114 | (unless (file-exists-p org-publish-timestamp-directory) | |
1115 | (make-directory org-publish-timestamp-directory t)) | |
1116 | (unless (file-directory-p org-publish-timestamp-directory) | |
1117 | (error "Org publish timestamp: %s is not a directory" | |
1118 | org-publish-timestamp-directory)) | |
1119 | ||
1120 | (unless (and org-publish-cache | |
1121 | (string= (org-publish-cache-get ":project:") project-name)) | |
1122 | (let* ((cache-file | |
1123 | (concat | |
1124 | (expand-file-name org-publish-timestamp-directory) | |
1125 | project-name ".cache")) | |
1126 | (cexists (file-exists-p cache-file))) | |
1127 | ||
1128 | (when org-publish-cache (org-publish-reset-cache)) | |
1129 | ||
1130 | (if cexists (load-file cache-file) | |
1131 | (setq org-publish-cache | |
1132 | (make-hash-table :test 'equal :weakness nil :size 100)) | |
1133 | (org-publish-cache-set ":project:" project-name) | |
1134 | (org-publish-cache-set ":cache-file:" cache-file)) | |
1135 | (unless cexists (org-publish-write-cache-file nil)))) | |
1136 | org-publish-cache) | |
1137 | ||
1138 | (defun org-publish-reset-cache () | |
1139 | "Empty org-publish-cache and reset it nil." | |
1140 | (message "%s" "Resetting org-publish-cache") | |
1141 | (when (hash-table-p org-publish-cache) | |
1142 | (clrhash org-publish-cache)) | |
1143 | (setq org-publish-cache nil)) | |
1144 | ||
1145 | (defun org-publish-cache-file-needs-publishing | |
1146 | (filename &optional pub-dir pub-func base-dir) | |
1147 | "Check the timestamp of the last publishing of FILENAME. | |
1148 | Return non-nil if the file needs publishing. Also check if | |
1149 | any included files have been more recently published, so that | |
1150 | the file including them will be republished as well." | |
1151 | (unless org-publish-cache | |
1152 | (error | |
1153 | "`org-publish-cache-file-needs-publishing' called, but no cache present")) | |
1154 | (let* ((case-fold-search t) | |
1155 | (key (org-publish-timestamp-filename filename pub-dir pub-func)) | |
1156 | (pstamp (org-publish-cache-get key)) | |
1157 | (org-inhibit-startup t) | |
1158 | (visiting (find-buffer-visiting filename)) | |
1159 | included-files-ctime buf) | |
1160 | ||
1161 | (when (equal (file-name-extension filename) "org") | |
1162 | (setq buf (find-file (expand-file-name filename))) | |
1163 | (with-current-buffer buf | |
1164 | (goto-char (point-min)) | |
1165 | (while (re-search-forward | |
1166 | "^#\\+INCLUDE:[ \t]+\"\\([^\t\n\r\"]*\\)\"[ \t]*.*$" nil t) | |
1167 | (let* ((included-file (expand-file-name (match-string 1)))) | |
1168 | (add-to-list 'included-files-ctime | |
1169 | (org-publish-cache-ctime-of-src included-file) t)))) | |
1170 | (unless visiting (kill-buffer buf))) | |
1171 | (if (null pstamp) t | |
1172 | (let ((ctime (org-publish-cache-ctime-of-src filename))) | |
1173 | (or (< pstamp ctime) | |
1174 | (when included-files-ctime | |
1175 | (not (null (delq nil (mapcar (lambda(ct) (< ctime ct)) | |
1176 | included-files-ctime)))))))))) | |
1177 | ||
1178 | (defun org-publish-cache-set-file-property | |
1179 | (filename property value &optional project-name) | |
1180 | "Set the VALUE for a PROPERTY of file FILENAME in publishing cache to VALUE. | |
1181 | Use cache file of PROJECT-NAME. If the entry does not exist, it | |
1182 | will be created. Return VALUE." | |
1183 | ;; Evtl. load the requested cache file: | |
1184 | (if project-name (org-publish-initialize-cache project-name)) | |
1185 | (let ((pl (org-publish-cache-get filename))) | |
1186 | (if pl (progn (plist-put pl property value) value) | |
1187 | (org-publish-cache-get-file-property | |
1188 | filename property value nil project-name)))) | |
1189 | ||
1190 | (defun org-publish-cache-get-file-property | |
1191 | (filename property &optional default no-create project-name) | |
1192 | "Return the value for a PROPERTY of file FILENAME in publishing cache. | |
1193 | Use cache file of PROJECT-NAME. Return the value of that PROPERTY | |
1194 | or DEFAULT, if the value does not yet exist. If the entry will | |
1195 | be created, unless NO-CREATE is not nil." | |
1196 | ;; Evtl. load the requested cache file: | |
1197 | (if project-name (org-publish-initialize-cache project-name)) | |
1198 | (let ((pl (org-publish-cache-get filename)) retval) | |
1199 | (if pl | |
1200 | (if (plist-member pl property) | |
1201 | (setq retval (plist-get pl property)) | |
1202 | (setq retval default)) | |
1203 | ;; no pl yet: | |
1204 | (unless no-create | |
1205 | (org-publish-cache-set filename (list property default))) | |
1206 | (setq retval default)) | |
1207 | retval)) | |
1208 | ||
1209 | (defun org-publish-cache-get (key) | |
1210 | "Return the value stored in `org-publish-cache' for key KEY. | |
1211 | Returns nil, if no value or nil is found, or the cache does not | |
1212 | exist." | |
1213 | (unless org-publish-cache | |
1214 | (error "`org-publish-cache-get' called, but no cache present")) | |
1215 | (gethash key org-publish-cache)) | |
1216 | ||
1217 | (defun org-publish-cache-set (key value) | |
1218 | "Store KEY VALUE pair in `org-publish-cache'. | |
1219 | Returns value on success, else nil." | |
1220 | (unless org-publish-cache | |
1221 | (error "`org-publish-cache-set' called, but no cache present")) | |
1222 | (puthash key value org-publish-cache)) | |
1223 | ||
1224 | (defun org-publish-cache-ctime-of-src (file) | |
1225 | "Get the ctime of FILE as an integer." | |
1226 | (let ((attr (file-attributes | |
1227 | (expand-file-name (or (file-symlink-p file) file) | |
1228 | (file-name-directory file))))) | |
73d3db82 BG |
1229 | (if (not attr) (error "No such file: \"%s\"" file) |
1230 | (+ (lsh (car (nth 5 attr)) 16) | |
1231 | (cadr (nth 5 attr)))))) | |
271672fa BG |
1232 | |
1233 | ||
1234 | (provide 'ox-publish) | |
1235 | ||
1236 | ;; Local variables: | |
1237 | ;; generated-autoload-file: "org-loaddefs.el" | |
1238 | ;; End: | |
1239 | ||
1240 | ;;; ox-publish.el ends here |