org-feed.el 26 KB

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