lisp/muse-journal.el

   1 ;;; muse-journal.el --- keep and publish a journal
   2
   3 ;; Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
   4
   5 ;; This file is part of Emacs Muse.  It is not part of GNU Emacs.
   6
   7 ;; Emacs Muse is free software; you can redistribute it and/or modify
   8 ;; it under the terms of the GNU General Public License as published
   9 ;; by the Free Software Foundation; either version 2, or (at your
  10 ;; option) any later version.
  11
  12 ;; Emacs Muse is distributed in the hope that it will be useful, but
  13 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 ;; General Public License for more details.
  16
  17 ;; You should have received a copy of the GNU General Public License
  18 ;; along with Emacs Muse; see the file COPYING.  If not, write to the
  19 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 ;; Boston, MA 02110-1301, USA.
  21
  22 ;;; Commentary:
  23
  24 ;; The module facilitates the keeping and publication of a journal.
  25 ;; When publishing to HTML, it assumes the form of a web log, or blog.
  26 ;;
  27 ;; The input format for each entry is as follows:
  28 ;;
  29 ;;   * 20040317: Title of entry
  30 ;;
  31 ;;   Text for the entry.
  32 ;;
  33 ;;   <qotd>
  34 ;;   "You know who you are. It comes down to a simple gut check: You
  35 ;;   either love what you do or you don't. Period." -- P. Bronson
  36 ;;   </qotd>
  37 ;;
  38 ;; The "qotd", or Quote of the Day, is entirely optional.  When
  39 ;; generated to HTML, this entry is rendered as:
  40 ;;
  41 ;;   <div class="entry">
  42 ;;     <div class="entry-qotd">
  43 ;;       <h3>Quote of the Day:</h3>
  44 ;;       <p>"You know who you are. It comes down to a simple gut
  45 ;;         check: You either love what you do or you don't. Period."
  46 ;;         -- P. Bronson</p>
  47 ;;     </div>
  48 ;;     <div class="entry-body">
  49 ;;       <div class="entry-head">
  50 ;;         <div class="entry-date">
  51 ;;           <span class="date">March 17, 2004</span>
  52 ;;         </div>
  53 ;;         <div class="entry-title">
  54 ;;           <h2>Title of entry</h2>
  55 ;;         </div>
  56 ;;       </div>
  57 ;;       <div class="entry-text">
  58 ;;         <p>Text for the entry.</p>
  59 ;;       </div>
  60 ;;     </div>
  61 ;;   </div>
  62 ;;
  63 ;; The plurality of "div" tags makes it possible to display the
  64 ;; entries in any form you wish, using a CSS style.
  65 ;;
  66 ;; Also, an .RDF file can be generated from your journal by publishing
  67 ;; it with the "rdf" style.  It uses the first two sentences of the
  68 ;; first paragraph of each entry as its "description", and
  69 ;; autogenerates tags for linking to the various entries.
  70
  71 ;;; Contributors:
  72
  73 ;;; Code:
  74
  75 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  76 ;;
  77 ;; Muse Journal Publishing
  78 ;;
  79 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  80
  81 (require 'muse-publish)
  82 (require 'muse-html)
  83 (require 'muse-latex)
  84 (require 'muse-book)
  85
  86 (defgroup muse-journal nil
  87   "Rules for transforming a journal into its final form."
  88   :group 'muse-publish)
  89
  90 (defcustom muse-journal-heading-regexp
  91   "\\(?:\\([0-9]+\\)\\(?:: \\)?\\)?\\(.+?\\)?"
  92   "A regexp that matches a journal heading.
  93 Paren group 1 is the ISO date, group 2 is the optional category,
  94 and group 3 is the optional heading for the entry."
  95   :type 'regexp
  96   :group 'muse-journal)
  97
  98 (defcustom muse-journal-date-format "%a, %e %b %Y"
  99   "Date format to use for journal entries."
 100   :type 'string
 101   :group 'muse-journal)
 102
 103 (defcustom muse-journal-html-heading-regexp
 104   (concat "^<h2[^>]*>" muse-journal-heading-regexp "</h2>$")
 105   "A regexp that matches a journal heading from an HTML document.
 106 Paren group 1 is the ISO date, group 2 is the optional category,
 107 and group 3 is the optional heading for the entry."
 108   :type 'regexp
 109   :group 'muse-journal)
 110
 111 (defcustom muse-journal-html-entry-template
 112   "<div class=\"entry\">
 113   <a name=\"%anchor%\" style=\"text-decoration: none\">&nbsp;</a>
 114   <div class=\"entry-body\">
 115     <div class=\"entry-head\">
 116       <div class=\"entry-date\">
 117         <span class=\"date\">%date%</span>
 118       </div>
 119       <div class=\"entry-title\">
 120         <h2>%title%</h2>
 121       </div>
 122     </div>
 123     <div class=\"entry-text\">
 124       <div class=\"entry-qotd\">
 125         <p>%qotd%</p>
 126       </div>
 127 %text%
 128     </div>
 129   </div>
 130 </div>\n\n"
 131   "Template used to publish individual journal entries as HTML."
 132   :type 'string
 133   :group 'muse-journal)
 134
 135 (defcustom muse-journal-latex-section
 136   "\\section*{%title% \\hfill {\\normalsize %date%}}
 137 \\addcontentsline{toc}{chapter}{%title%}"
 138   "Template used to publish a LaTeX section."
 139   :type 'string
 140   :group 'muse-journal)
 141
 142 (defcustom muse-journal-latex-subsection
 143   "\\subsection*{%title%}
 144 \\addcontentsline{toc}{section}{%title%}"
 145   "Template used to publish a LaTeX subsection."
 146   :type 'string
 147   :group 'muse-journal)
 148
 149 (defcustom muse-journal-latex-markup-tags
 150   '(("qotd" t nil muse-journal-latex-qotd-tag))
 151   "A list of tag specifications, for specially marking up LaTeX.
 152 See `muse-publish-markup-tags' for more info."
 153   :type '(repeat (list (string :tag "Markup tag")
 154                        (boolean :tag "Expect closing tag" :value t)
 155                        (boolean :tag "Parse attributes" :value nil)
 156                        function))
 157   :group 'muse-journal)
 158
 159 ;; FIXME: This doesn't appear to be used.
 160 (defun muse-journal-generate-pages ()
 161   (let ((output-dir (muse-style-element :path)))
 162     (goto-char (point-min))
 163     (while (re-search-forward muse-journal-heading-regexp nil t)
 164       (let* ((date (match-string 1))
 165              (category (match-string 1))
 166              (category-file (concat output-dir category "/index.html"))
 167              (heading (match-string 1)))
 168         t))))
 169
 170 (defcustom muse-journal-rdf-extension ".rdf"
 171   "Default file extension for publishing RDF (RSS 1.0) files."
 172   :type 'string
 173   :group 'muse-journal)
 174
 175 (defcustom muse-journal-rdf-base-url ""
 176   "The base URL of the website referenced by the RDF file."
 177   :type 'string
 178   :group 'muse-journal)
 179
 180 (defcustom muse-journal-rdf-header
 181   "<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\"
 182          xmlns=\"http://purl.org/rss/1.0/\"
 183          xmlns:dc=\"http://purl.org/dc/elements/1.1/\">
 184   <channel rdf:about=\"<lisp>(concat (muse-style-element :base-url)
 185                                      (muse-publish-link-name))</lisp>\">
 186     <title><lisp>(muse-publishing-directive \"title\")</lisp></title>
 187     <link><lisp>(concat (muse-style-element :base-url)
 188                        (concat (muse-page-name)
 189                                muse-html-extension))</lisp></link>
 190     <description><lisp>(muse-publishing-directive \"desc\")</lisp></description>
 191     <items>
 192       <rdf:Seq>
 193         <rdf:li resource=\"<lisp>
 194           (concat (muse-style-element :base-url)
 195                   (concat (muse-page-name)
 196                           muse-html-extension))</lisp>\"/>
 197       </rdf:Seq>
 198     </items>
 199   </channel>\n"
 200   "Header used for publishing RDF (RSS 1.0) files.
 201 This may be text or a filename."
 202   :type 'string
 203   :group 'muse-journal)
 204
 205 (defcustom muse-journal-rdf-footer
 206   "</rdf:RDF>\n"
 207   "Footer used for publishing RDF (RSS 1.0) files.
 208 This may be text or a filename."
 209   :type 'string
 210   :group 'muse-journal)
 211
 212 (defcustom muse-journal-rdf-date-format
 213   "%Y-%m-%dT%H:%M:%S"
 214   "Date format to use for RDF entries."
 215   :type 'string
 216   :group 'muse-journal)
 217
 218 (defcustom muse-journal-rdf-entry-template
 219   "  <item rdf:about=\"%link%#%anchor%\">
 220     <title>%title%</title>
 221     <description>
 222       %desc%
 223     </description>
 224     <link>%link%#%anchor%</link>
 225     <dc:date>%date%</dc:date>
 226     <dc:creator>%maintainer%</dc:creator>
 227   </item>\n"
 228   "Template used to publish individual journal entries as RDF."
 229   :type 'string
 230   :group 'muse-journal)
 231
 232 (defcustom muse-journal-rdf-summarize-entries t
 233   "If non-nil, include only summaries in the RDF file, not the full data."
 234   :type 'boolean
 235   :group 'muse-journal)
 236
 237 (defcustom muse-journal-rss-extension ".xml"
 238   "Default file extension for publishing RSS 2.0 files."
 239   :type 'string
 240   :group 'muse-journal)
 241
 242 (defcustom muse-journal-rss-base-url ""
 243   "The base URL of the website referenced by the RSS file."
 244   :type 'string
 245   :group 'muse-journal)
 246
 247 (defcustom muse-journal-rss-header
 248   "<\?xml version=\"1.0\" encoding=\"<lisp>
 249   (muse-html-encoding)</lisp>\"?>
 250 <rss version=\"2.0\">
 251   <channel>
 252     <title><lisp>(muse-publishing-directive \"title\")</lisp></title>
 253     <link><lisp>(concat (muse-style-element :base-url)
 254                         (concat (muse-page-name)
 255                                 muse-html-extension))</lisp></link>
 256     <description><lisp>(muse-publishing-directive \"desc\")</lisp></description>
 257     <language>en-us</language>
 258     <generator>Emacs Muse</generator>"
 259   "Header used for publishing RSS 2.0 files.  This may be text or a filename."
 260   :type 'string
 261   :group 'muse-journal)
 262
 263 (defcustom muse-journal-rss-footer
 264   "  </channel>
 265 </rss>\n"
 266   "Footer used for publishing RSS 2.0 files.  This may be text or a filename."
 267   :type 'string
 268   :group 'muse-journal)
 269
 270 (defcustom muse-journal-rss-date-format
 271   "%a, %d %b %Y %H:%M:%S %Z"
 272   "Date format to use for RSS 2.0 entries."
 273   :type 'string
 274   :group 'muse-journal)
 275
 276 (defcustom muse-journal-rss-entry-template
 277   "    <item>
 278       <title>%title%</title>
 279       <link>%link%#%anchor%</link>
 280       <description>%desc%</description>
 281       <author><lisp>(muse-publishing-directive \"author\")</lisp></author>
 282       <pubDate>%date%</pubDate>
 283       <guid>%link%#%anchor%</guid>
 284       %enclosure%
 285     </item>\n"
 286   "Template used to publish individual journal entries as RSS 2.0."
 287   :type 'string
 288   :group 'muse-journal)
 289
 290 (defcustom muse-journal-rss-enclosure-types-alist
 291   '(("mp3" . "audio/mpeg"))
 292   "File types that are accepted as RSS enclosures.
 293 This is an alist that maps file extension to content type.
 294 Useful for podcasting."
 295   :type '(alist :key-type string :value-type string)
 296   :group 'muse-journal)
 297
 298 (defcustom muse-journal-rss-summarize-entries nil
 299   "If non-nil, include only summaries in the RSS file, not the full data.
 300 Many RSS subscribers find this annoying."
 301   :type 'boolean
 302   :group 'muse-journal)
 303
 304 (defcustom muse-journal-rss-markup-regexps
 305   '((10000 muse-explicit-link-regexp 0 "\\2"))
 306   "List of markup rules for publishing a Muse journal page to RSS 2.0.
 307 For more information on the structure of this list, see
 308 `muse-publish-markup-regexps'."
 309   :type '(repeat (choice
 310                   (list :tag "Markup rule"
 311                         integer
 312                         (choice regexp symbol)
 313                         integer
 314                         (choice string function symbol))
 315                   function))
 316   :group 'muse-journal)
 317
 318 (defcustom muse-journal-rss-markup-functions
 319   '((email . ignore)
 320     (link  . ignore)
 321     (url   . ignore))
 322   "An alist of style types to custom functions for that kind of text.
 323 For more on the structure of this list, see
 324 `muse-publish-markup-functions'."
 325   :type '(alist :key-type symbol :value-type function)
 326   :group 'muse-journal)
 327
 328 (defun muse-journal-anchorize-title (title)
 329   (save-match-data
 330     (if (string-match "(" title)
 331         (setq title (substring title 0 (match-beginning 0))))
 332     (if (string-match "<[^>]+>" title)
 333         (setq title (replace-match "" nil nil title)))
 334     (downcase (muse-replace-regexp-in-string "[^a-zA-Z0-9_]" "" title))))
 335
 336 (defun muse-journal-sort-entries (&optional direction)
 337   (interactive "P")
 338   (sort-subr
 339    direction
 340    (function
 341     (lambda ()
 342       (if (re-search-forward "^\\* [0-9]+" nil t)
 343           (goto-char (match-beginning 0))
 344         (goto-char (point-max)))))
 345    (function
 346     (lambda ()
 347       (if (re-search-forward "^\\* [0-9]+" nil t)
 348           (goto-char (1- (match-beginning 0)))
 349         (goto-char (point-max)))))
 350    (function
 351     (lambda ()
 352       (forward-char 2)))
 353    (function
 354     (lambda ()
 355       (end-of-line)))))
 356
 357 (defun muse-journal-html-munge-buffer ()
 358   (goto-char (point-min))
 359   (let ((heading-regexp muse-journal-html-heading-regexp)
 360         (inhibit-read-only t))
 361     (while (re-search-forward heading-regexp nil t)
 362       (let* ((date (match-string 1))
 363              (orig-date date)
 364              (title (match-string 2))
 365              (clean-title title)
 366              datestamp qotd text)
 367         (delete-region (match-beginning 0) (match-end 0))
 368         (if clean-title
 369             (save-match-data
 370               (while (string-match "\\(^<[^>]+>\\|<[^>]+>$\\)" clean-title)
 371                 (setq clean-title (replace-match "" nil nil clean-title)))))
 372         (save-match-data
 373           (when (and date
 374                      (string-match
 375                       (concat "\\`\\([1-9][0-9][0-9][0-9]\\)[./]?"
 376                               "\\([0-1][0-9]\\)[./]?\\([0-3][0-9]\\)") date))
 377             (setq datestamp
 378                   (encode-time
 379                    0 0 0
 380                    (string-to-number (match-string 3 date))
 381                    (string-to-number (match-string 2 date))
 382                    (string-to-number (match-string 1 date))
 383                    (current-time-zone))
 384                   date (concat (format-time-string
 385                                 muse-journal-date-format datestamp)
 386                                (substring date (match-end 0))))))
 387         (save-restriction
 388           (narrow-to-region
 389            (point) (if (re-search-forward
 390                         (concat "\\(^<hr>$\\|"
 391                                 heading-regexp "\\)") nil t)
 392                        (match-beginning 0)
 393                      (point-max)))
 394           (goto-char (point-max))
 395           (while (and (not (bobp))
 396                       (eq ?\  (char-syntax (char-before))))
 397             (delete-char -1))
 398           (goto-char (point-min))
 399           (while (and (not (eobp))
 400                       (eq ?\  (char-syntax (char-after))))
 401             (delete-char 1))
 402           (save-excursion
 403             (when (search-forward "<qotd>" nil t)
 404               (let ((tag-beg (match-beginning 0))
 405                     (beg (match-end 0)))
 406                 (re-search-forward "</qotd>\n*")
 407                 (setq qotd (buffer-substring-no-properties
 408                             beg (match-beginning 0)))
 409                 (delete-region tag-beg (match-end 0)))))
 410           (setq text (buffer-string))
 411           (delete-region (point-min) (point-max))
 412           (let ((entry muse-journal-html-entry-template))
 413             (while (string-match "%date%" entry)
 414               (setq entry (replace-match (or date "") nil t entry)))
 415             (while (string-match "%title%" entry)
 416               (setq entry (replace-match (or title "&nbsp;") nil t entry)))
 417             (while (string-match "%anchor%" entry)
 418               (setq entry (replace-match
 419                            (muse-journal-anchorize-title
 420                             (or clean-title orig-date))
 421                            nil t entry)))
 422             (while (string-match "%qotd%" entry)
 423               (setq entry (replace-match (or qotd "") nil t entry)))
 424             (while (string-match "%text%" entry)
 425               (setq entry (replace-match text nil t entry)))
 426             (insert entry)
 427             (when (null qotd)
 428               (goto-char (point-min))
 429               (search-forward "<div class=\"entry-qotd\">")
 430               (let ((beg (match-beginning 0)))
 431                 (re-search-forward "</div>\n*")
 432                 (delete-region beg (point))))))))))
 433
 434 (defun muse-journal-latex-munge-buffer ()
 435   (goto-char (point-min))
 436   (let ((heading-regexp
 437          (concat "^" (regexp-quote (muse-markup-text 'section))
 438                  muse-journal-heading-regexp
 439                  (regexp-quote (muse-markup-text 'section-end)) "$"))
 440         (inhibit-read-only t))
 441     (when (re-search-forward heading-regexp nil t)
 442       (goto-char (match-beginning 0))
 443       (sort-subr nil
 444                  (function
 445                   (lambda ()
 446                     (if (re-search-forward heading-regexp nil t)
 447                         (goto-char (match-beginning 0))
 448                       (goto-char (point-max)))))
 449                  (function
 450                   (lambda ()
 451                     (if (re-search-forward heading-regexp nil t)
 452                         (goto-char (1- (match-beginning 0)))
 453                       (goto-char (point-max)))))
 454                  (function
 455                   (lambda ()
 456                     (forward-char 2)))
 457                  (function
 458                   (lambda ()
 459                     (end-of-line)))))
 460     (while (re-search-forward heading-regexp nil t)
 461       (let ((date (match-string 1))
 462             (title (match-string 2))
 463             ;; FIXME: Nothing is done with qotd
 464             qotd section)
 465         (save-match-data
 466           (when (and date
 467                      (string-match
 468                       (concat "\\([1-9][0-9][0-9][0-9]\\)[./]?"
 469                               "\\([0-1][0-9]\\)[./]?\\([0-3][0-9]\\)") date))
 470             (setq date (encode-time
 471                         0 0 0
 472                         (string-to-number (match-string 3 date))
 473                         (string-to-number (match-string 2 date))
 474                         (string-to-number (match-string 1 date))
 475                         (current-time-zone))
 476                   date (format-time-string
 477                         muse-journal-date-format date))))
 478         (save-match-data
 479           (setq section muse-journal-latex-section)
 480           (while (string-match "%title%" section)
 481             (setq section (replace-match (or title "Untitled")
 482                                          nil t section)))
 483           (while (string-match "%date%" section)
 484             (setq section (replace-match (or date "") nil t section))))
 485         (replace-match section nil t))))
 486   (goto-char (point-min))
 487   (let ((subheading-regexp
 488          (concat "^" (regexp-quote (muse-markup-text 'subsection))
 489                  "\\([^\n}]+\\)"
 490                  (regexp-quote (muse-markup-text 'subsection-end)) "$"))
 491         (inhibit-read-only t))
 492     (while (re-search-forward subheading-regexp nil t)
 493       (let ((subsection muse-journal-latex-subsection))
 494         (save-match-data
 495           (let ((title (match-string 1)))
 496             (while (string-match "%title%" subsection)
 497               (setq subsection (replace-match title nil t subsection)))))
 498         (replace-match subsection nil t)))))
 499
 500 (defun muse-journal-latex-qotd-tag (beg end)
 501   (goto-char beg)
 502   (insert (muse-markup-text 'begin-quote))
 503   (goto-char end)
 504   (insert (muse-markup-text 'end-quote)))
 505
 506 (defun muse-journal-rss-munge-buffer ()
 507   (goto-char (point-min))
 508   (let ((heading-regexp (concat "^\\* " muse-journal-heading-regexp "$"))
 509         (inhibit-read-only t))
 510     (while (re-search-forward heading-regexp nil t)
 511       (let* ((date (match-string 1))
 512              (orig-date date)
 513              (title (match-string 2))
 514              ;; FIXME: Nothing is done with qotd
 515              enclosure qotd desc)
 516         (if title
 517             (save-match-data
 518               (if (string-match muse-explicit-link-regexp title)
 519                   (setq enclosure (match-string 1 title)
 520                         title (match-string 2 title)))))
 521         (save-match-data
 522           (when (and date
 523                      (string-match
 524                       (concat "\\([1-9][0-9][0-9][0-9]\\)[./]?"
 525                               "\\([0-1][0-9]\\)[./]?\\([0-3][0-9]\\)") date))
 526             (setq date (encode-time 0 0 0
 527                                     (string-to-number (match-string 3 date))
 528                                     (string-to-number (match-string 2 date))
 529                                     (string-to-number (match-string 1 date))
 530                                     (current-time-zone))
 531                   date (format-time-string
 532                         (muse-style-element :date-format) date))))
 533         (save-restriction
 534           (narrow-to-region
 535            (match-beginning 0)
 536            (if (re-search-forward heading-regexp nil t)
 537                (match-beginning 0)
 538              (if (re-search-forward "^Footnotes:" nil t)
 539                  (match-beginning 0)
 540                (point-max))))
 541           (goto-char (point-min))
 542           (delete-region (point) (muse-line-end-position))
 543           (re-search-forward "</qotd>\n+" nil t)
 544           (while (and (char-after)
 545                       (eq ?\  (char-syntax (char-after))))
 546             (delete-char 1))
 547           (let ((beg (point)))
 548             (if (muse-style-element :summarize)
 549                 (progn
 550                   (forward-sentence 2)
 551                   (setq desc (concat (buffer-substring beg (point)) "...")))
 552               (save-restriction
 553                 (muse-publish-markup-buffer "rss-entry" "html")
 554                 (goto-char (point-min))
 555                 (re-search-forward "Page published by Emacs Muse")
 556                 (goto-char (muse-line-end-position))
 557                 (setq beg (point))
 558                 (re-search-forward "Page published by Emacs Muse")
 559                 (goto-char (muse-line-beginning-position))
 560                 (setq desc (concat "<![CDATA[" (buffer-substring beg (point))
 561                                    "]]>")))))
 562           (delete-region (point-min) (point-max))
 563           (let ((entry (muse-style-element :entry-template)))
 564             (while (string-match "%date%" entry)
 565               (setq entry (replace-match (or date "") nil t entry)))
 566             (while (string-match "%title%" entry)
 567               (setq entry (replace-match (or title "Untitled") nil t entry)))
 568             (while (string-match "%desc%" entry)
 569               (setq entry (replace-match desc nil t entry)))
 570             (while (string-match "%enclosure%" entry)
 571               (setq
 572                entry
 573                (replace-match
 574                 (if (null enclosure)
 575                     ""
 576                   (save-match-data
 577                     (format
 578                      "<enclosure url=\"%s\" %stype=\"%s\"/>"
 579                      (if (string-match "//" enclosure)
 580                          enclosure
 581                        (concat (muse-style-element :base-url)
 582                                enclosure))
 583                      (let ((file
 584                             (expand-file-name enclosure
 585                                               (muse-style-element :path))))
 586                        (if (file-readable-p file)
 587                            (format "length=\"%d\" "
 588                                    (nth 7 (file-attributes file)))
 589                          ""))
 590                      (if (string-match "\\.\\([^.]+\\)$" enclosure)
 591                          (let* ((ext (match-string 1 enclosure))
 592                                 (type
 593                                  (assoc
 594                                   ext muse-journal-rss-enclosure-types-alist)))
 595                            (if type
 596                                (cdr type)
 597                              "application/octet-stream"))))))
 598                 nil t entry)))
 599             (while (string-match "%link%" entry)
 600               (setq entry (replace-match
 601                            (concat (muse-style-element :base-url)
 602                                    (concat (muse-page-name)
 603                                            muse-html-extension))
 604                            nil t entry)))
 605             (while (string-match "%anchor%" entry)
 606               (setq entry (replace-match
 607                            (muse-journal-anchorize-title (or title orig-date))
 608                            nil t entry)))
 609             (while (string-match "%maintainer%" entry)
 610               (setq entry (replace-match
 611                            (or (muse-style-element :maintainer)
 612                                (concat "webmaster@" (system-name)))
 613                            nil t entry)))
 614             (insert entry)))))
 615     (unless (eobp)
 616       (delete-region (point) (point-max)))))
 617
 618 (unless (assoc "journal-html" muse-publishing-styles)
 619   (muse-derive-style "journal-html" "html"
 620                      :before-end 'muse-journal-html-munge-buffer)
 621
 622   (muse-derive-style "journal-xhtml" "xhtml"
 623                      :before-end 'muse-journal-html-munge-buffer)
 624
 625   (muse-derive-style "journal-latex" "latex"
 626                      :tags 'muse-journal-latex-markup-tags
 627                      :before-end 'muse-journal-latex-munge-buffer)
 628
 629   (muse-derive-style "journal-pdf" "pdf"
 630                      :tags 'muse-journal-latex-markup-tags
 631                      :before-end 'muse-journal-latex-munge-buffer)
 632
 633   (muse-derive-style "journal-book-latex" "book-latex"
 634                      ;;:nochapters
 635                      :tags 'muse-journal-latex-markup-tags
 636                      :before-end 'muse-journal-latex-munge-buffer)
 637
 638   (muse-derive-style "journal-book-pdf" "book-pdf"
 639                      ;;:nochapters
 640                      :tags 'muse-journal-latex-markup-tags
 641                      :before-end 'muse-journal-latex-munge-buffer)
 642
 643   (muse-define-style "journal-rdf"
 644                      :suffix         'muse-journal-rdf-extension
 645                      :regexps        'muse-journal-rss-markup-regexps
 646                      :functions      'muse-journal-rss-markup-functions
 647                      :before         'muse-journal-rss-munge-buffer
 648                      :header         'muse-journal-rdf-header
 649                      :footer         'muse-journal-rdf-footer
 650                      :date-format    'muse-journal-rdf-date-format
 651                      :entry-template 'muse-journal-rdf-entry-template
 652                      :base-url       'muse-journal-rdf-base-url
 653                      :summarize      'muse-journal-rdf-summarize-entries)
 654
 655   (muse-define-style "journal-rss"
 656                      :suffix         'muse-journal-rss-extension
 657                      :regexps        'muse-journal-rss-markup-regexps
 658                      :functions      'muse-journal-rss-markup-functions
 659                      :before         'muse-journal-rss-munge-buffer
 660                      :header         'muse-journal-rss-header
 661                      :footer         'muse-journal-rss-footer
 662                      :date-format    'muse-journal-rss-date-format
 663                      :entry-template 'muse-journal-rss-entry-template
 664                      :base-url       'muse-journal-rss-base-url
 665                      :summarize      'muse-journal-rss-summarize-entries))
 666
 667 (provide 'muse-journal)
 668
 669 ;;; muse-journal.el ends here