lisp/org-feed.el

   1 ;;; org-feed.el --- Add RSS feed items to Org files  -*- lexical-binding: t; -*-
   2 ;;
   3 ;; Copyright (C) 2009-2019 Free Software Foundation, Inc.
   4 ;;
   5 ;; Author: Carsten Dominik <carsten at orgmode dot org>
   6 ;; Keywords: outlines, hypermedia, calendar, wp
   7 ;; Homepage: https://orgmode.org
   8 ;;
   9 ;; This file is part of GNU Emacs.
  10 ;;
  11 ;; GNU Emacs is free software: you can redistribute it and/or modify
  12 ;; it under the terms of the GNU General Public License as published by
  13 ;; the Free Software Foundation, either version 3 of the License, or
  14 ;; (at your option) any later version.
  15
  16 ;; GNU Emacs is distributed in the hope that it will be useful,
  17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 ;; GNU General Public License for more details.
  20
  21 ;; You should have received a copy of the GNU General Public License
  22 ;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
  23 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  24 ;;
  25 ;;; Commentary:
  26 ;;
  27 ;;  This module allows entries to be created and changed in an Org mode
  28 ;;  file triggered by items in an RSS feed.  The basic functionality
  29 ;;  is geared toward simply adding new items found in a feed as
  30 ;;  outline nodes to an Org file.  Using hooks, arbitrary actions can
  31 ;;  be triggered for new or changed items.
  32 ;;
  33 ;;  Selecting feeds and target locations
  34 ;;  ------------------------------------
  35 ;;
  36 ;;  This module is configured through a single variable, `org-feed-alist'.
  37 ;;  Here is an example, using a notes/tasks feed from reQall.com.
  38 ;;
  39 ;;    (setq org-feed-alist
  40 ;;          '(("ReQall"
  41 ;;             "http://www.reqall.com/user/feeds/rss/a1b2c3....."
  42 ;;             "~/org/feeds.org" "ReQall Entries")
  43 ;;
  44 ;;  With this setup, the command `M-x org-feed-update-all' will
  45 ;;  collect new entries in the feed at the given URL and create
  46 ;;  entries as subheadings under the "ReQall Entries" heading in the
  47 ;;  file "~/org/feeds.org".  Each feed should normally have its own
  48 ;;  heading - however see the `:drawer' parameter.
  49 ;;
  50 ;;  Besides these standard elements that need to be specified for each
  51 ;;  feed, keyword-value pairs can set additional options.  For example,
  52 ;;  to de-select transitional entries with a title containing
  53 ;;
  54 ;;                   "reQall is typing what you said",
  55 ;;
  56 ;;  you could use the `:filter' argument:
  57 ;;
  58 ;;    (setq org-feed-alist
  59 ;;          '(("ReQall"
  60 ;;             "http://www.reqall.com/user/feeds/rss/a1b2c3....."
  61 ;;             "~/org/feeds.org" "ReQall Entries"
  62 ;;             :filter my-reqall-filter)))
  63 ;;
  64 ;;    (defun my-reqall-filter (e)
  65 ;;       (if (string-match "reQall is typing what you said"
  66 ;;                         (plist-get e :title))
  67 ;;           nil
  68 ;;         e))
  69 ;;
  70 ;;  See the docstring for `org-feed-alist' for more details.
  71 ;;
  72 ;;
  73 ;;  Keeping track of previously added entries
  74 ;;  -----------------------------------------
  75 ;;
  76 ;;  Since Org allows you to delete, archive, or move outline nodes,
  77 ;;  org-feed.el needs to keep track of which feed items have been handled
  78 ;;  before, so that they will not be handled again.  For this, org-feed.el
  79 ;;  stores information in a special drawer, FEEDSTATUS, under the heading
  80 ;;  that received the input of the feed.
  81 ;;
  82 ;;
  83 ;;  Acknowledgments
  84 ;;  ---------------
  85 ;;
  86 ;;  org-feed.el is based on ideas by Brad Bozarth who implemented a
  87 ;;  similar mechanism using shell and awk scripts.
  88
  89 ;;; Code:
  90
  91 (require 'org)
  92 (require 'sha1)
  93
  94 (declare-function url-retrieve-synchronously "url"
  95                   (url &optional silent inhibit-cookies timeout))
  96 (declare-function xml-node-children "xml" (node))
  97 (declare-function xml-get-children "xml" (node child-name))
  98 (declare-function xml-get-attribute "xml" (node attribute))
  99 (declare-function xml-get-attribute-or-nil "xml" (node attribute))
 100 (declare-function xml-substitute-special "xml" (string))
 101
 102 (declare-function org-capture-escaped-% "org-capture" ())
 103 (declare-function org-capture-expand-embedded-elisp "org-capture" (&optional mark))
 104 (declare-function org-capture-inside-embedded-elisp-p "org-capture" ())
 105
 106 (defgroup org-feed  nil
 107   "Options concerning RSS feeds as inputs for Org files."
 108   :tag "Org Feed"
 109   :group 'org)
 110
 111 (defcustom org-feed-alist nil
 112   "Alist specifying RSS feeds that should create inputs for Org.
 113 Each entry in this list specified an RSS feed tat should be queried
 114 to create inbox items in Org.  Each entry is a list with the following items:
 115
 116 name         a custom name for this feed
 117 URL          the Feed URL
 118 file         the target Org file where entries should be listed, when
 119              nil the target becomes the current buffer (may be an
 120              indirect buffer) each time the feed update is invoked
 121 headline     the headline under which entries should be listed
 122
 123 Additional arguments can be given using keyword-value pairs.  Many of these
 124 specify functions that receive one or a list of \"entries\" as their single
 125 argument.  An entry is a property list that describes a feed item.  The
 126 property list has properties for each field in the item, for example `:title'
 127 for the `<title>' field and `:pubDate' for the publication date.  In addition,
 128 it contains the following properties:
 129
 130 `:item-full-text'   the full text in the <item> tag
 131 `:guid-permalink'   t when the guid property is a permalink
 132
 133 Here are the keyword-value pair allows in `org-feed-alist'.
 134
 135 :drawer drawer-name
 136      The name of the drawer for storing feed information.  The default is
 137      \"FEEDSTATUS\".  Using different drawers for different feeds allows
 138      several feeds to target the same inbox heading.
 139
 140 :filter filter-function
 141      A function to select interesting entries in the feed.  It gets a single
 142      entry as parameter.  It should return the entry if it is relevant, or
 143      nil if it is not.
 144
 145 :template template-string
 146      The default action on new items in the feed is to add them as children
 147      under the headline for the feed.  The template describes how the entry
 148      should be formatted.  If not given, it defaults to
 149      `org-feed-default-template'.
 150
 151 :formatter formatter-function
 152      Instead of relying on a template, you may specify a function to format
 153      the outline node to be inserted as a child.  This function gets passed
 154      a property list describing a single feed item, and it should return a
 155      string that is a properly formatted Org outline node of level 1.
 156
 157 :new-handler function
 158      If adding new items as children to the outline is not what you want
 159      to do with new items, define a handler function that is called with
 160      a list of all new items in the feed, each one represented as a property
 161      list.  The handler should do what needs to be done, and org-feed will
 162      mark all items given to this handler as \"handled\", i.e. they will not
 163      be passed to this handler again in future readings of the feed.
 164      When the handler is called, point will be at the feed headline.
 165
 166 :changed-handler function
 167      This function gets passed a list of all entries that have been
 168      handled before, but are now still in the feed and have *changed*
 169      since last handled (as evidenced by a different sha1 hash).
 170      When the handler is called, point will be at the feed headline.
 171
 172 :parse-feed function
 173      This function gets passed a buffer, and should return a list
 174      of entries, each being a property list containing the
 175      `:guid' and `:item-full-text' keys.  The default is
 176      `org-feed-parse-rss-feed'; `org-feed-parse-atom-feed' is an
 177      alternative.
 178
 179 :parse-entry function
 180      This function gets passed an entry as returned by the parse-feed
 181      function, and should return the entry with interesting properties added.
 182      The default is `org-feed-parse-rss-entry'; `org-feed-parse-atom-entry'
 183      is an alternative."
 184   :group 'org-feed
 185   :type '(repeat
 186           (list :value ("" "http://" "" "")
 187                 (string :tag "Name")
 188                 (string :tag "Feed URL")
 189                 (file :tag "File for inbox")
 190                 (string :tag "Headline for inbox")
 191                 (repeat :inline t
 192                         (choice
 193                          (list :inline t :tag "Filter"
 194                                (const :filter)
 195                                (symbol :tag "Filter Function"))
 196                          (list :inline t :tag "Template"
 197                                (const :template)
 198                                (string :tag "Template"))
 199                          (list :inline t :tag "Formatter"
 200                                (const :formatter)
 201                                (symbol :tag "Formatter Function"))
 202                          (list :inline t :tag "New items handler"
 203                                (const :new-handler)
 204                                (symbol :tag "Handler Function"))
 205                          (list :inline t :tag "Changed items"
 206                                (const :changed-handler)
 207                                (symbol :tag "Handler Function"))
 208                          (list :inline t :tag "Parse Feed"
 209                                (const :parse-feed)
 210                                (symbol :tag "Parse Feed Function"))
 211                          (list :inline t :tag "Parse Entry"
 212                                (const :parse-entry)
 213                                (symbol :tag "Parse Entry Function"))
 214                          )))))
 215
 216 (defcustom org-feed-drawer "FEEDSTATUS"
 217   "The name of the drawer for feed status information.
 218 Each feed may also specify its own drawer name using the `:drawer'
 219 parameter in `org-feed-alist'."
 220   :group 'org-feed
 221   :type '(string :tag "Drawer Name"))
 222
 223 (defcustom org-feed-default-template "\n* %h\n  %U\n  %description\n  %a\n"
 224   "Template for the Org node created from RSS feed items.
 225 This is just the default, each feed can specify its own.
 226 Any fields from the feed item can be interpolated into the template with
 227 %name, for example %title, %description, %pubDate etc.  In addition, the
 228 following special escapes are valid as well:
 229
 230 %h      The title, or the first line of the description
 231 %t      The date as a stamp, either from <pubDate> (if present), or
 232         the current date
 233 %T      Date and time
 234 %u,%U   Like %t,%T, but inactive time stamps
 235 %a      A link, from <guid> if that is a permalink, else from <link>
 236 %(sexp) Evaluate elisp `(sexp)' and replace with the result, the simple
 237         %-escapes above can be used as arguments, e.g. %(capitalize \\\"%h\\\")"
 238   :group 'org-feed
 239   :type '(string :tag "Template"))
 240
 241 (defcustom org-feed-save-after-adding t
 242   "Non-nil means save buffer after adding new feed items."
 243   :group 'org-feed
 244   :type 'boolean)
 245
 246 (defcustom org-feed-retrieve-method 'url-retrieve-synchronously
 247   "The method to be used to retrieve a feed URL.
 248 This can be `curl' or `wget' to call these external programs, or it can be
 249 an Emacs Lisp function that will return a buffer containing the content
 250 of the file pointed to by the URL."
 251   :group 'org-feed
 252   :type '(choice
 253           (const :tag "Internally with url.el" url-retrieve-synchronously)
 254           (const :tag "Externally with curl" curl)
 255           (const :tag "Externally with wget" wget)
 256           (function :tag "Function")))
 257
 258 (defcustom org-feed-before-adding-hook nil
 259   "Hook that is run before adding new feed items to a file.
 260 You might want to commit the file in its current state to version control,
 261 for example."
 262   :group 'org-feed
 263   :type 'hook)
 264
 265 (defcustom org-feed-after-adding-hook nil
 266   "Hook that is run after new items have been added to a file.
 267 Depending on `org-feed-save-after-adding', the buffer will already
 268 have been saved."
 269   :group 'org-feed
 270   :type 'hook)
 271
 272 (defvar org-feed-buffer "*Org feed*"
 273   "The buffer used to retrieve a feed.")
 274
 275 ;;;###autoload
 276 (defun org-feed-update-all ()
 277   "Get inbox items from all feeds in `org-feed-alist'."
 278   (interactive)
 279   (let ((entries 0)
 280         (errors 0)
 281         (total-feeds (length org-feed-alist)))
 282     (dolist (feed org-feed-alist)
 283       (let ((items (ignore-errors (org-feed-update feed))))
 284         (if items (cl-incf entries items)
 285           (cl-incf errors))))
 286     (message "%s from %d %s%s"
 287              (pcase entries
 288                (0 "No new entries")
 289                (1 "1 new entry")
 290                (_ (format "%d new entries" entries)))
 291              total-feeds
 292              (if (= total-feeds 1) "feed" "feeds")
 293              (if (= 0 errors) "" (format " (unavailable feeds: %d)" errors)))))
 294
 295 ;;;###autoload
 296 (defun org-feed-update (feed &optional retrieve-only)
 297   "Get inbox items from FEED.
 298 FEED can be a string with an association in `org-feed-alist', or
 299 it can be a list structured like an entry in `org-feed-alist'."
 300   (interactive (list (org-completing-read "Feed name: " org-feed-alist)))
 301   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 302   (unless feed
 303     (error "No such feed in `org-feed-alist"))
 304   (catch 'exit
 305     (let ((name (car feed))
 306           (url (nth 1 feed))
 307           (file (or (nth 2 feed) (buffer-file-name (or (buffer-base-buffer)
 308                                                        (current-buffer)))))
 309           (headline (nth 3 feed))
 310           (filter (nth 1 (memq :filter feed)))
 311           (formatter (nth 1 (memq :formatter feed)))
 312           (new-handler (nth 1 (memq :new-handler feed)))
 313           (changed-handler (nth 1 (memq :changed-handler feed)))
 314           (template (or (nth 1 (memq :template feed))
 315                         org-feed-default-template))
 316           (drawer (or (nth 1 (memq :drawer feed))
 317                       org-feed-drawer))
 318           (parse-feed (or (nth 1 (memq :parse-feed feed))
 319                           'org-feed-parse-rss-feed))
 320           (parse-entry (or (nth 1 (memq :parse-entry feed))
 321                            'org-feed-parse-rss-entry))
 322           feed-buffer inbox-pos new-formatted
 323           entries old-status status new changed guid-alist guid olds)
 324       (setq feed-buffer (org-feed-get-feed url))
 325       (unless (and feed-buffer (bufferp (get-buffer feed-buffer)))
 326         (error "Cannot get feed %s" name))
 327       (when retrieve-only
 328         (throw 'exit feed-buffer))
 329       (setq entries (funcall parse-feed feed-buffer))
 330       (ignore-errors (kill-buffer feed-buffer))
 331       (save-excursion
 332         (save-window-excursion
 333           (setq inbox-pos (org-feed-goto-inbox-internal file headline))
 334           (setq old-status (org-feed-read-previous-status inbox-pos drawer))
 335           ;; Add the "handled" status to the appropriate entries
 336           (setq entries (mapcar (lambda (e)
 337                                   (setq e
 338                                         (plist-put e :handled
 339                                                    (nth 1 (assoc
 340                                                            (plist-get e :guid)
 341                                                            old-status)))))
 342                                 entries))
 343           ;; Find out which entries are new and which are changed
 344           (dolist (e entries)
 345             (if (not (plist-get e :handled))
 346                 (push e new)
 347               (setq olds (nth 2 (assoc (plist-get e :guid) old-status)))
 348               (if (and olds
 349                        (not (string= (sha1
 350                                       (plist-get e :item-full-text))
 351                                      olds)))
 352                   (push e changed))))
 353
 354           ;; Parse the relevant entries fully
 355           (setq new     (mapcar parse-entry new)
 356                 changed (mapcar parse-entry changed))
 357
 358           ;; Run the filter
 359           (when filter
 360             (setq new     (delq nil (mapcar filter new))
 361                   changed (delq nil (mapcar filter new))))
 362
 363           (when (not (or new changed))
 364             (message "No new items in feed %s" name)
 365             (throw 'exit 0))
 366
 367           ;; Get alist based on guid, to look up entries
 368           (setq guid-alist
 369                 (append
 370                  (mapcar (lambda (e) (list (plist-get e :guid) e)) new)
 371                  (mapcar (lambda (e) (list (plist-get e :guid) e)) changed)))
 372
 373           ;; Construct the new status
 374           (setq status
 375                 (mapcar
 376                  (lambda (e)
 377                    (setq guid (plist-get e :guid))
 378                    (list guid
 379                          ;; things count as handled if we handle them now,
 380                          ;; or if they were handled previously
 381                          (if (assoc guid guid-alist) t (plist-get e :handled))
 382                          ;; A hash, to detect changes
 383                          (sha1 (plist-get e :item-full-text))))
 384                  entries))
 385
 386           ;; Handle new items in the feed
 387           (when new
 388             (if new-handler
 389                 (progn
 390                   (goto-char inbox-pos)
 391                   (funcall new-handler new))
 392               ;; No custom handler, do the default adding
 393               ;; Format the new entries into an alist with GUIDs in the car
 394               (setq new-formatted
 395                     (mapcar
 396                      (lambda (e) (org-feed-format-entry e template formatter))
 397                      new)))
 398
 399             ;; Insert the new items
 400             (org-feed-add-items inbox-pos new-formatted))
 401
 402           ;; Handle changed items in the feed
 403           (when (and changed-handler changed)
 404             (goto-char inbox-pos)
 405             (funcall changed-handler changed))
 406
 407           ;; Write the new status
 408           ;; We do this only now, in case something goes wrong above, so
 409           ;; that would would end up with a status that does not reflect
 410           ;; which items truely have been handled
 411           (org-feed-write-status inbox-pos drawer status)
 412
 413           ;; Normalize the visibility of the inbox tree
 414           (goto-char inbox-pos)
 415           (org-flag-subtree t)
 416           (org-show-children)
 417
 418           ;; Hooks and messages
 419           (when org-feed-save-after-adding (save-buffer))
 420           (message "Added %d new item%s from feed %s to file %s, heading %s"
 421                    (length new) (if (> (length new) 1) "s" "")
 422                    name
 423                    (file-name-nondirectory file) headline)
 424           (run-hooks 'org-feed-after-adding-hook)
 425           (length new))))))
 426
 427 ;;;###autoload
 428 (defun org-feed-goto-inbox (feed)
 429   "Go to the inbox that captures the feed named FEED."
 430   (interactive
 431    (list (if (= (length org-feed-alist) 1)
 432              (car org-feed-alist)
 433            (org-completing-read "Feed name: " org-feed-alist))))
 434   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 435   (unless feed
 436     (error "No such feed in `org-feed-alist"))
 437   (org-feed-goto-inbox-internal (nth 2 feed) (nth 3 feed)))
 438
 439 ;;;###autoload
 440 (defun org-feed-show-raw-feed (feed)
 441   "Show the raw feed buffer of a feed."
 442   (interactive
 443    (list (if (= (length org-feed-alist) 1)
 444              (car org-feed-alist)
 445            (org-completing-read "Feed name: " org-feed-alist))))
 446   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 447   (unless feed
 448     (error "No such feed in `org-feed-alist"))
 449   (pop-to-buffer-same-window
 450    (org-feed-update feed 'retrieve-only))
 451   (goto-char (point-min)))
 452
 453 (defun org-feed-goto-inbox-internal (file heading)
 454   "Find or create HEADING in FILE.
 455 Switch to that buffer, and return the position of that headline."
 456   (find-file file)
 457   (widen)
 458   (goto-char (point-min))
 459   (if (re-search-forward
 460        (concat "^\\*+[ \t]+" heading "[ \t]*\\(:.*?:[ \t]*\\)?$")
 461        nil t)
 462       (goto-char (match-beginning 0))
 463     (goto-char (point-max))
 464     (insert "\n\n* " heading "\n\n")
 465     (org-back-to-heading t))
 466   (point))
 467
 468 (defun org-feed-read-previous-status (pos drawer)
 469   "Get the alist of old GUIDs from the entry at POS.
 470 This will find DRAWER and extract the alist."
 471   (save-excursion
 472     (goto-char pos)
 473     (let ((end (save-excursion (org-end-of-subtree t t))))
 474       (if (re-search-forward
 475            (concat "^[ \t]*:" drawer ":[ \t]*\n\\([^\000]*?\\)\n[ \t]*:END:")
 476            end t)
 477           (read (match-string 1))
 478         nil))))
 479
 480 (defun org-feed-write-status (pos drawer status)
 481   "Write the feed STATUS to DRAWER in entry at POS."
 482   (save-excursion
 483     (goto-char pos)
 484     (let ((end (save-excursion (org-end-of-subtree t t))))
 485       (if (re-search-forward (concat "^[ \t]*:" drawer ":[ \t]*\n")
 486                              end t)
 487           (progn
 488             (goto-char (match-end 0))
 489             (delete-region (point)
 490                            (save-excursion
 491                              (and (re-search-forward "^[ \t]*:END:" nil t)
 492                                   (match-beginning 0)))))
 493         (outline-next-heading)
 494         (insert "  :" drawer ":\n  :END:\n")
 495         (beginning-of-line 0))
 496       (insert (pp-to-string status)))))
 497
 498 (defun org-feed-add-items (pos entries)
 499   "Add the formatted items to the headline as POS."
 500   (let (entry level)
 501     (save-excursion
 502       (goto-char pos)
 503       (unless (looking-at org-complex-heading-regexp)
 504         (error "Wrong position"))
 505       (setq level (org-get-valid-level (length (match-string 1)) 1))
 506       (org-end-of-subtree t t)
 507       (skip-chars-backward " \t\n")
 508       (beginning-of-line 2)
 509       (setq pos (point))
 510       (while (setq entry (pop entries))
 511         (org-paste-subtree level entry 'yank))
 512       (org-mark-ring-push pos))))
 513
 514 (defun org-feed-format-entry (entry template formatter)
 515   "Format ENTRY so that it can be inserted into an Org file.
 516 ENTRY is a property list.  This function adds a `:formatted-for-org' property
 517 and returns the full property list.
 518 If that property is already present, nothing changes."
 519   (require 'org-capture)
 520   (if formatter (funcall formatter entry)
 521     (let* ((dlines
 522             (org-split-string (or (plist-get entry :description) "???")
 523                               "\n"))
 524            (time (or (if (plist-get entry :pubDate)
 525                          (org-read-date t t (plist-get entry :pubDate)))
 526                      (current-time)))
 527            (v-h (or (plist-get entry :title) (car dlines) "???"))
 528            (v-t (format-time-string (org-time-stamp-format nil nil) time))
 529            (v-T (format-time-string (org-time-stamp-format t   nil) time))
 530            (v-u (format-time-string (org-time-stamp-format nil t)   time))
 531            (v-U (format-time-string (org-time-stamp-format t   t)   time))
 532            (v-a (let ((tmp (or (and (plist-get entry :guid-permalink)
 533                                     (plist-get entry :guid))
 534                                (plist-get entry :link))))
 535                   (if tmp (format "[[%s]]\n" tmp ) ""))))
 536       (with-temp-buffer
 537         (insert template)
 538         (goto-char (point-min))
 539
 540         ;; Mark %() embedded elisp for later evaluation.
 541         (org-capture-expand-embedded-elisp 'mark)
 542
 543         ;; Simple %-escapes.  `org-capture-escaped-%' may modify
 544         ;; buffer and cripple match-data.  Use markers instead.
 545         (while (re-search-forward "%\\([a-zA-Z]+\\)" nil t)
 546           (let ((key (match-string 1))
 547                 (beg (copy-marker (match-beginning 0)))
 548                 (end (copy-marker (match-end 0))))
 549             (unless (org-capture-escaped-%)
 550               (delete-region beg end)
 551               (set-marker beg nil)
 552               (set-marker end nil)
 553               (let ((replacement
 554                      (pcase key
 555                        ("h" v-h)
 556                        ("t" v-t)
 557                        ("T" v-T)
 558                        ("u" v-u)
 559                        ("U" v-U)
 560                        ("a" v-a)
 561                        (name
 562                         (let ((v (plist-get entry (intern (concat ":" name)))))
 563                           (save-excursion
 564                             (save-match-data
 565                               (beginning-of-line)
 566                               (if (looking-at
 567                                    (concat "^\\([ \t]*\\)%" name "[ \t]*$"))
 568                                   (org-feed-make-indented-block
 569                                    v (current-indentation))
 570                                 v))))))))
 571                 (when replacement
 572                   (insert
 573                    ;; Escape string delimiters within embedded lisp.
 574                    (if (org-capture-inside-embedded-elisp-p)
 575                        (replace-regexp-in-string "\"" "\\\\\"" replacement)
 576                      replacement)))))))
 577
 578         ;; %() embedded elisp
 579         (org-capture-expand-embedded-elisp)
 580
 581         (decode-coding-string
 582          (buffer-string) (detect-coding-region (point-min) (point-max) t))))))
 583
 584 (defun org-feed-make-indented-block (s n)
 585   "Add indentation of N spaces to a multiline string S."
 586   (if (not (string-match "\n" s))
 587       s
 588     (mapconcat 'identity
 589                (org-split-string s "\n")
 590                (concat "\n" (make-string n ?\ )))))
 591
 592 (defun org-feed-skip-http-headers (buffer)
 593   "Remove HTTP headers from BUFFER, and return it.
 594 Assumes headers are indeed present!"
 595   (with-current-buffer buffer
 596     (widen)
 597     (goto-char (point-min))
 598     (search-forward "\n\n")
 599     (delete-region (point-min) (point))
 600     buffer))
 601
 602 (defun org-feed-get-feed (url)
 603   "Get the RSS feed file at URL and return the buffer."
 604   (cond
 605    ((eq org-feed-retrieve-method 'url-retrieve-synchronously)
 606     (org-feed-skip-http-headers (url-retrieve-synchronously url)))
 607    ((eq org-feed-retrieve-method 'curl)
 608     (ignore-errors (kill-buffer org-feed-buffer))
 609     (call-process "curl" nil org-feed-buffer nil "--silent" url)
 610     org-feed-buffer)
 611    ((eq org-feed-retrieve-method 'wget)
 612     (ignore-errors (kill-buffer org-feed-buffer))
 613     (call-process "wget" nil org-feed-buffer nil "-q" "-O" "-" url)
 614     org-feed-buffer)
 615    ((functionp org-feed-retrieve-method)
 616     (funcall org-feed-retrieve-method url))))
 617
 618 (defun org-feed-parse-rss-feed (buffer)
 619   "Parse BUFFER for RSS feed entries.
 620 Returns a list of entries, with each entry a property list,
 621 containing the properties `:guid' and `:item-full-text'."
 622   (require 'xml)
 623   (let ((case-fold-search t)
 624         entries beg end item guid entry)
 625     (with-current-buffer buffer
 626       (widen)
 627       (goto-char (point-min))
 628       (while (re-search-forward "<item\\>.*?>" nil t)
 629         (setq beg (point)
 630               end (and (re-search-forward "</item>" nil t)
 631                        (match-beginning 0)))
 632         (setq item (buffer-substring beg end)
 633               guid (if (string-match "<guid\\>.*?>\\([^\000]*?\\)</guid>" item)
 634                        (xml-substitute-special (match-string-no-properties 1 item))))
 635         (setq entry (list :guid guid :item-full-text item))
 636         (push entry entries)
 637         (widen)
 638         (goto-char end))
 639       (nreverse entries))))
 640
 641 (defun org-feed-parse-rss-entry (entry)
 642   "Parse the `:item-full-text' field for xml tags and create new properties."
 643   (require 'xml)
 644   (with-temp-buffer
 645     (insert (plist-get entry :item-full-text))
 646     (goto-char (point-min))
 647     (while (re-search-forward "<\\([a-zA-Z]+\\>\\).*?>\\([^\000]*?\\)</\\1>"
 648                               nil t)
 649       (setq entry (plist-put entry
 650                              (intern (concat ":" (match-string 1)))
 651                              (xml-substitute-special (match-string 2)))))
 652     (goto-char (point-min))
 653     (unless (re-search-forward "isPermaLink[ \t]*=[ \t]*\"false\"" nil t)
 654       (setq entry (plist-put entry :guid-permalink t))))
 655   entry)
 656
 657 (defun org-feed-parse-atom-feed (buffer)
 658   "Parse BUFFER for Atom feed entries.
 659 Returns a list of entries, with each entry a property list,
 660 containing the properties `:guid' and `:item-full-text'.
 661
 662 The `:item-full-text' property actually contains the sexp
 663 formatted as a string, not the original XML data."
 664   (require 'xml)
 665   (with-current-buffer buffer
 666     (widen)
 667     (let ((feed (car (xml-parse-region (point-min) (point-max)))))
 668       (mapcar
 669        (lambda (entry)
 670          (list
 671           :guid (car (xml-node-children (car (xml-get-children entry 'id))))
 672           :item-full-text (prin1-to-string entry)))
 673        (xml-get-children feed 'entry)))))
 674
 675 (defun org-feed-parse-atom-entry (entry)
 676   "Parse the `:item-full-text' as a sexp and create new properties."
 677   (let ((xml (car (read-from-string (plist-get entry :item-full-text)))))
 678     ;; Get first <link href='foo'/>.
 679     (setq entry (plist-put entry :link
 680                            (xml-get-attribute
 681                             (car (xml-get-children xml 'link))
 682                             'href)))
 683     ;; Add <title/> as :title.
 684     (setq entry (plist-put entry :title
 685                            (xml-substitute-special
 686                             (car (xml-node-children
 687                                   (car (xml-get-children xml 'title)))))))
 688     (let* ((content (car (xml-get-children xml 'content)))
 689            (type (xml-get-attribute-or-nil content 'type)))
 690       (when content
 691         (cond
 692          ((string= type "text")
 693           ;; We like plain text.
 694           (setq entry (plist-put entry :description
 695                                  (xml-substitute-special
 696                                   (car (xml-node-children content))))))
 697          ((string= type "html")
 698           ;; TODO: convert HTML to Org markup.
 699           (setq entry (plist-put entry :description
 700                                  (xml-substitute-special
 701                                   (car (xml-node-children content))))))
 702          ((string= type "xhtml")
 703           ;; TODO: convert XHTML to Org markup.
 704           (setq entry (plist-put entry :description
 705                                  (prin1-to-string
 706                                   (xml-node-children content)))))
 707          (t
 708           (setq entry (plist-put entry :description
 709                                  (format-message
 710                                   "Unknown `%s' content." type)))))))
 711     entry))
 712
 713 (provide 'org-feed)
 714
 715 ;; Local variables:
 716 ;; generated-autoload-file: "org-loaddefs.el"
 717 ;; End:
 718
 719 ;;; org-feed.el ends here