lisp/org-feed.el

   1 ;;; org-feed.el --- Add RSS feed items to Org files  -*- lexical-binding: t; -*-
   2 ;;
   3 ;; Copyright (C) 2009-2016 Free Software Foundation, Inc.
   4 ;;
   5 ;; Author: Carsten Dominik <carsten at orgmode dot org>
   6 ;; Keywords: outlines, hypermedia, calendar, wp
   7 ;; Homepage: http://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 <http://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 ((nfeeds (length org-feed-alist))
 280         (nnew (apply '+  (mapcar 'org-feed-update org-feed-alist))))
 281     (message "%s from %d %s"
 282              (cond ((= nnew 0) "No new entries")
 283                    ((= nnew 1) "1 new entry")
 284                    (t (format "%d new entries" nnew)))
 285              nfeeds
 286              (if (= nfeeds 1) "feed" "feeds"))))
 287
 288 ;;;###autoload
 289 (defun org-feed-update (feed &optional retrieve-only)
 290   "Get inbox items from FEED.
 291 FEED can be a string with an association in `org-feed-alist', or
 292 it can be a list structured like an entry in `org-feed-alist'."
 293   (interactive (list (org-completing-read "Feed name: " org-feed-alist)))
 294   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 295   (unless feed
 296     (error "No such feed in `org-feed-alist"))
 297   (catch 'exit
 298     (let ((name (car feed))
 299           (url (nth 1 feed))
 300           (file (or (nth 2 feed) (buffer-file-name (or (buffer-base-buffer)
 301                                                        (current-buffer)))))
 302           (headline (nth 3 feed))
 303           (filter (nth 1 (memq :filter feed)))
 304           (formatter (nth 1 (memq :formatter feed)))
 305           (new-handler (nth 1 (memq :new-handler feed)))
 306           (changed-handler (nth 1 (memq :changed-handler feed)))
 307           (template (or (nth 1 (memq :template feed))
 308                         org-feed-default-template))
 309           (drawer (or (nth 1 (memq :drawer feed))
 310                       org-feed-drawer))
 311           (parse-feed (or (nth 1 (memq :parse-feed feed))
 312                           'org-feed-parse-rss-feed))
 313           (parse-entry (or (nth 1 (memq :parse-entry feed))
 314                            'org-feed-parse-rss-entry))
 315           feed-buffer inbox-pos new-formatted
 316           entries old-status status new changed guid-alist guid olds)
 317       (setq feed-buffer (org-feed-get-feed url))
 318       (unless (and feed-buffer (bufferp (get-buffer feed-buffer)))
 319         (error "Cannot get feed %s" name))
 320       (when retrieve-only
 321         (throw 'exit feed-buffer))
 322       (setq entries (funcall parse-feed feed-buffer))
 323       (ignore-errors (kill-buffer feed-buffer))
 324       (save-excursion
 325         (save-window-excursion
 326           (setq inbox-pos (org-feed-goto-inbox-internal file headline))
 327           (setq old-status (org-feed-read-previous-status inbox-pos drawer))
 328           ;; Add the "handled" status to the appropriate entries
 329           (setq entries (mapcar (lambda (e)
 330                                   (setq e
 331                                         (plist-put e :handled
 332                                                    (nth 1 (assoc
 333                                                            (plist-get e :guid)
 334                                                            old-status)))))
 335                                 entries))
 336           ;; Find out which entries are new and which are changed
 337           (dolist (e entries)
 338             (if (not (plist-get e :handled))
 339                 (push e new)
 340               (setq olds (nth 2 (assoc (plist-get e :guid) old-status)))
 341               (if (and olds
 342                        (not (string= (sha1
 343                                       (plist-get e :item-full-text))
 344                                      olds)))
 345                   (push e changed))))
 346
 347           ;; Parse the relevant entries fully
 348           (setq new     (mapcar parse-entry new)
 349                 changed (mapcar parse-entry changed))
 350
 351           ;; Run the filter
 352           (when filter
 353             (setq new     (delq nil (mapcar filter new))
 354                   changed (delq nil (mapcar filter new))))
 355
 356           (when (not (or new changed))
 357             (message "No new items in feed %s" name)
 358             (throw 'exit 0))
 359
 360           ;; Get alist based on guid, to look up entries
 361           (setq guid-alist
 362                 (append
 363                  (mapcar (lambda (e) (list (plist-get e :guid) e)) new)
 364                  (mapcar (lambda (e) (list (plist-get e :guid) e)) changed)))
 365
 366           ;; Construct the new status
 367           (setq status
 368                 (mapcar
 369                  (lambda (e)
 370                    (setq guid (plist-get e :guid))
 371                    (list guid
 372                          ;; things count as handled if we handle them now,
 373                          ;; or if they were handled previously
 374                          (if (assoc guid guid-alist) t (plist-get e :handled))
 375                          ;; A hash, to detect changes
 376                          (sha1 (plist-get e :item-full-text))))
 377                  entries))
 378
 379           ;; Handle new items in the feed
 380           (when new
 381             (if new-handler
 382                 (progn
 383                   (goto-char inbox-pos)
 384                   (funcall new-handler new))
 385               ;; No custom handler, do the default adding
 386               ;; Format the new entries into an alist with GUIDs in the car
 387               (setq new-formatted
 388                     (mapcar
 389                      (lambda (e) (org-feed-format-entry e template formatter))
 390                      new)))
 391
 392             ;; Insert the new items
 393             (org-feed-add-items inbox-pos new-formatted))
 394
 395           ;; Handle changed items in the feed
 396           (when (and changed-handler changed)
 397             (goto-char inbox-pos)
 398             (funcall changed-handler changed))
 399
 400           ;; Write the new status
 401           ;; We do this only now, in case something goes wrong above, so
 402           ;; that would would end up with a status that does not reflect
 403           ;; which items truely have been handled
 404           (org-feed-write-status inbox-pos drawer status)
 405
 406           ;; Normalize the visibility of the inbox tree
 407           (goto-char inbox-pos)
 408           (outline-hide-subtree)
 409           (org-show-children)
 410           (org-cycle-hide-drawers 'children)
 411
 412           ;; Hooks and messages
 413           (when org-feed-save-after-adding (save-buffer))
 414           (message "Added %d new item%s from feed %s to file %s, heading %s"
 415                    (length new) (if (> (length new) 1) "s" "")
 416                    name
 417                    (file-name-nondirectory file) headline)
 418           (run-hooks 'org-feed-after-adding-hook)
 419           (length new))))))
 420
 421 ;;;###autoload
 422 (defun org-feed-goto-inbox (feed)
 423   "Go to the inbox that captures the feed named FEED."
 424   (interactive
 425    (list (if (= (length org-feed-alist) 1)
 426              (car org-feed-alist)
 427            (org-completing-read "Feed name: " org-feed-alist))))
 428   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 429   (unless feed
 430     (error "No such feed in `org-feed-alist"))
 431   (org-feed-goto-inbox-internal (nth 2 feed) (nth 3 feed)))
 432
 433 ;;;###autoload
 434 (defun org-feed-show-raw-feed (feed)
 435   "Show the raw feed buffer of a feed."
 436   (interactive
 437    (list (if (= (length org-feed-alist) 1)
 438              (car org-feed-alist)
 439            (org-completing-read "Feed name: " org-feed-alist))))
 440   (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
 441   (unless feed
 442     (error "No such feed in `org-feed-alist"))
 443   (pop-to-buffer-same-window
 444    (org-feed-update feed 'retrieve-only))
 445   (goto-char (point-min)))
 446
 447 (defun org-feed-goto-inbox-internal (file heading)
 448   "Find or create HEADING in FILE.
 449 Switch to that buffer, and return the position of that headline."
 450   (find-file file)
 451   (widen)
 452   (goto-char (point-min))
 453   (if (re-search-forward
 454        (concat "^\\*+[ \t]+" heading "[ \t]*\\(:.*?:[ \t]*\\)?$")
 455        nil t)
 456       (goto-char (match-beginning 0))
 457     (goto-char (point-max))
 458     (insert "\n\n* " heading "\n\n")
 459     (org-back-to-heading t))
 460   (point))
 461
 462 (defun org-feed-read-previous-status (pos drawer)
 463   "Get the alist of old GUIDs from the entry at POS.
 464 This will find DRAWER and extract the alist."
 465   (save-excursion
 466     (goto-char pos)
 467     (let ((end (save-excursion (org-end-of-subtree t t))))
 468       (if (re-search-forward
 469            (concat "^[ \t]*:" drawer ":[ \t]*\n\\([^\000]*?\\)\n[ \t]*:END:")
 470            end t)
 471           (read (match-string 1))
 472         nil))))
 473
 474 (defun org-feed-write-status (pos drawer status)
 475   "Write the feed STATUS to DRAWER in entry at POS."
 476   (save-excursion
 477     (goto-char pos)
 478     (let ((end (save-excursion (org-end-of-subtree t t))))
 479       (if (re-search-forward (concat "^[ \t]*:" drawer ":[ \t]*\n")
 480                              end t)
 481           (progn
 482             (goto-char (match-end 0))
 483             (delete-region (point)
 484                            (save-excursion
 485                              (and (re-search-forward "^[ \t]*:END:" nil t)
 486                                   (match-beginning 0)))))
 487         (outline-next-heading)
 488         (insert "  :" drawer ":\n  :END:\n")
 489         (beginning-of-line 0))
 490       (insert (pp-to-string status)))))
 491
 492 (defun org-feed-add-items (pos entries)
 493   "Add the formatted items to the headline as POS."
 494   (let (entry level)
 495     (save-excursion
 496       (goto-char pos)
 497       (unless (looking-at org-complex-heading-regexp)
 498         (error "Wrong position"))
 499       (setq level (org-get-valid-level (length (match-string 1)) 1))
 500       (org-end-of-subtree t t)
 501       (skip-chars-backward " \t\n")
 502       (beginning-of-line 2)
 503       (setq pos (point))
 504       (while (setq entry (pop entries))
 505         (org-paste-subtree level entry 'yank))
 506       (org-mark-ring-push pos))))
 507
 508 (defun org-feed-format-entry (entry template formatter)
 509   "Format ENTRY so that it can be inserted into an Org file.
 510 ENTRY is a property list.  This function adds a `:formatted-for-org' property
 511 and returns the full property list.
 512 If that property is already present, nothing changes."
 513   (require 'org-capture)
 514   (if formatter (funcall formatter entry)
 515     (let* ((dlines
 516             (org-split-string (or (plist-get entry :description) "???")
 517                               "\n"))
 518            (time (or (if (plist-get entry :pubDate)
 519                          (org-read-date t t (plist-get entry :pubDate)))
 520                      (current-time)))
 521            (v-h (or (plist-get entry :title) (car dlines) "???"))
 522            (v-t (format-time-string (org-time-stamp-format nil nil) time))
 523            (v-T (format-time-string (org-time-stamp-format t   nil) time))
 524            (v-u (format-time-string (org-time-stamp-format nil t)   time))
 525            (v-U (format-time-string (org-time-stamp-format t   t)   time))
 526            (v-a (let ((tmp (or (and (plist-get entry :guid-permalink)
 527                                     (plist-get entry :guid))
 528                                (plist-get entry :link))))
 529                   (if tmp (format "[[%s]]\n" tmp ) ""))))
 530       (with-temp-buffer
 531         (insert template)
 532         (goto-char (point-min))
 533
 534         ;; Mark %() embedded elisp for later evaluation.
 535         (org-capture-expand-embedded-elisp 'mark)
 536
 537         ;; Simple %-escapes.  `org-capture-escaped-%' may modify
 538         ;; buffer and cripple match-data.  Use markers instead.
 539         (while (re-search-forward "%\\([a-zA-Z]+\\)" nil t)
 540           (let ((key (match-string 1))
 541                 (beg (copy-marker (match-beginning 0)))
 542                 (end (copy-marker (match-end 0))))
 543             (unless (org-capture-escaped-%)
 544               (delete-region beg end)
 545               (set-marker beg nil)
 546               (set-marker end nil)
 547               (let ((replacement
 548                      (pcase key
 549                        ("h" v-h)
 550                        ("t" v-t)
 551                        ("T" v-T)
 552                        ("u" v-u)
 553                        ("U" v-U)
 554                        ("a" v-a)
 555                        (name
 556                         (let ((v (plist-get entry (intern (concat ":" name)))))
 557                           (save-excursion
 558                             (save-match-data
 559                               (beginning-of-line)
 560                               (if (looking-at
 561                                    (concat "^\\([ \t]*\\)%" name "[ \t]*$"))
 562                                   (org-feed-make-indented-block
 563                                    v (org-get-indentation))
 564                                 v))))))))
 565                 (when replacement
 566                   (insert
 567                    ;; Escape string delimiters within embedded lisp.
 568                    (if (org-capture-inside-embedded-elisp-p)
 569                        (replace-regexp-in-string "\"" "\\\\\"" replacement)
 570                      replacement)))))))
 571
 572         ;; %() embedded elisp
 573         (org-capture-expand-embedded-elisp)
 574
 575         (decode-coding-string
 576          (buffer-string) (detect-coding-region (point-min) (point-max) t))))))
 577
 578 (defun org-feed-make-indented-block (s n)
 579   "Add indentation of N spaces to a multiline string S."
 580   (if (not (string-match "\n" s))
 581       s
 582     (mapconcat 'identity
 583                (org-split-string s "\n")
 584                (concat "\n" (make-string n ?\ )))))
 585
 586 (defun org-feed-skip-http-headers (buffer)
 587   "Remove HTTP headers from BUFFER, and return it.
 588 Assumes headers are indeed present!"
 589   (with-current-buffer buffer
 590     (widen)
 591     (goto-char (point-min))
 592     (search-forward "\n\n")
 593     (delete-region (point-min) (point))
 594     buffer))
 595
 596 (defun org-feed-get-feed (url)
 597   "Get the RSS feed file at URL and return the buffer."
 598   (cond
 599    ((eq org-feed-retrieve-method 'url-retrieve-synchronously)
 600     (org-feed-skip-http-headers (url-retrieve-synchronously url)))
 601    ((eq org-feed-retrieve-method 'curl)
 602     (ignore-errors (kill-buffer org-feed-buffer))
 603     (call-process "curl" nil org-feed-buffer nil "--silent" url)
 604     org-feed-buffer)
 605    ((eq org-feed-retrieve-method 'wget)
 606     (ignore-errors (kill-buffer org-feed-buffer))
 607     (call-process "wget" nil org-feed-buffer nil "-q" "-O" "-" url)
 608     org-feed-buffer)
 609    ((functionp org-feed-retrieve-method)
 610     (funcall org-feed-retrieve-method url))))
 611
 612 (defun org-feed-parse-rss-feed (buffer)
 613   "Parse BUFFER for RSS feed entries.
 614 Returns a list of entries, with each entry a property list,
 615 containing the properties `:guid' and `:item-full-text'."
 616   (require 'xml)
 617   (let ((case-fold-search t)
 618         entries beg end item guid entry)
 619     (with-current-buffer buffer
 620       (widen)
 621       (goto-char (point-min))
 622       (while (re-search-forward "<item\\>.*?>" nil t)
 623         (setq beg (point)
 624               end (and (re-search-forward "</item>" nil t)
 625                        (match-beginning 0)))
 626         (setq item (buffer-substring beg end)
 627               guid (if (string-match "<guid\\>.*?>\\(.*?\\)</guid>" item)
 628                        (xml-substitute-special (match-string-no-properties 1 item))))
 629         (setq entry (list :guid guid :item-full-text item))
 630         (push entry entries)
 631         (widen)
 632         (goto-char end))
 633       (nreverse entries))))
 634
 635 (defun org-feed-parse-rss-entry (entry)
 636   "Parse the `:item-full-text' field for xml tags and create new properties."
 637   (require 'xml)
 638   (with-temp-buffer
 639     (insert (plist-get entry :item-full-text))
 640     (goto-char (point-min))
 641     (while (re-search-forward "<\\([a-zA-Z]+\\>\\).*?>\\([^\000]*?\\)</\\1>"
 642                               nil t)
 643       (setq entry (plist-put entry
 644                              (intern (concat ":" (match-string 1)))
 645                              (xml-substitute-special (match-string 2)))))
 646     (goto-char (point-min))
 647     (unless (re-search-forward "isPermaLink[ \t]*=[ \t]*\"false\"" nil t)
 648       (setq entry (plist-put entry :guid-permalink t))))
 649   entry)
 650
 651 (defun org-feed-parse-atom-feed (buffer)
 652   "Parse BUFFER for Atom feed entries.
 653 Returns a list of entries, with each entry a property list,
 654 containing the properties `:guid' and `:item-full-text'.
 655
 656 The `:item-full-text' property actually contains the sexp
 657 formatted as a string, not the original XML data."
 658   (require 'xml)
 659   (with-current-buffer buffer
 660     (widen)
 661     (let ((feed (car (xml-parse-region (point-min) (point-max)))))
 662       (mapcar
 663        (lambda (entry)
 664          (list
 665           :guid (car (xml-node-children (car (xml-get-children entry 'id))))
 666           :item-full-text (prin1-to-string entry)))
 667        (xml-get-children feed 'entry)))))
 668
 669 (defun org-feed-parse-atom-entry (entry)
 670   "Parse the `:item-full-text' as a sexp and create new properties."
 671   (let ((xml (car (read-from-string (plist-get entry :item-full-text)))))
 672     ;; Get first <link href='foo'/>.
 673     (setq entry (plist-put entry :link
 674                            (xml-get-attribute
 675                             (car (xml-get-children xml 'link))
 676                             'href)))
 677     ;; Add <title/> as :title.
 678     (setq entry (plist-put entry :title
 679                            (xml-substitute-special
 680                             (car (xml-node-children
 681                                   (car (xml-get-children xml 'title)))))))
 682     (let* ((content (car (xml-get-children xml 'content)))
 683            (type (xml-get-attribute-or-nil content 'type)))
 684       (when content
 685         (cond
 686          ((string= type "text")
 687           ;; We like plain text.
 688           (setq entry (plist-put entry :description
 689                                  (xml-substitute-special
 690                                   (car (xml-node-children content))))))
 691          ((string= type "html")
 692           ;; TODO: convert HTML to Org markup.
 693           (setq entry (plist-put entry :description
 694                                  (xml-substitute-special
 695                                   (car (xml-node-children content))))))
 696          ((string= type "xhtml")
 697           ;; TODO: convert XHTML to Org markup.
 698           (setq entry (plist-put entry :description
 699                                  (prin1-to-string
 700                                   (xml-node-children content)))))
 701          (t
 702           (setq entry (plist-put entry :description
 703                                  (format-message
 704                                   "Unknown `%s' content." type)))))))
 705     entry))
 706
 707 (provide 'org-feed)
 708
 709 ;; Local variables:
 710 ;; generated-autoload-file: "org-loaddefs.el"
 711 ;; End:
 712
 713 ;;; org-feed.el ends here