Merge conflict

1 files changed, 0 insertions, 719 deletions

diff --git a/elpa/org-9.5.2/org-feed.el b/elpa/org-9.5.2/org-feed.el
deleted file mode 100644
index 5df3b69..0000000
--- a/elpa/org-9.5.2/org-feed.el
+++ /dev/null
@@ -1,719 +0,0 @@
-;;; org-feed.el --- Add RSS feed items to Org files  -*- lexical-binding: t; -*-
-;;
-;; Copyright (C) 2009-2021 Free Software Foundation, Inc.
-;;
-;; Author: Carsten Dominik <carsten.dominik@gmail.com>
-;; Keywords: outlines, hypermedia, calendar, wp
-;; Homepage: https://orgmode.org
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-;;
-;;  This module allows entries to be created and changed in an Org mode
-;;  file triggered by items in an RSS feed.  The basic functionality
-;;  is geared toward simply adding new items found in a feed as
-;;  outline nodes to an Org file.  Using hooks, arbitrary actions can
-;;  be triggered for new or changed items.
-;;
-;;  Selecting feeds and target locations
-;;  ------------------------------------
-;;
-;;  This module is configured through a single variable, `org-feed-alist'.
-;;  Here is an example, using a notes/tasks feed from reQall.com.
-;;
-;;    (setq org-feed-alist
-;;          '(("ReQall"
-;;             "http://www.reqall.com/user/feeds/rss/a1b2c3....."
-;;             "~/org/feeds.org" "ReQall Entries")
-;;
-;;  With this setup, the command `M-x org-feed-update-all' will
-;;  collect new entries in the feed at the given URL and create
-;;  entries as subheadings under the "ReQall Entries" heading in the
-;;  file "~/org/feeds.org".  Each feed should normally have its own
-;;  heading - however see the `:drawer' parameter.
-;;
-;;  Besides these standard elements that need to be specified for each
-;;  feed, keyword-value pairs can set additional options.  For example,
-;;  to de-select transitional entries with a title containing
-;;
-;;                   "reQall is typing what you said",
-;;
-;;  you could use the `:filter' argument:
-;;
-;;    (setq org-feed-alist
-;;          '(("ReQall"
-;;             "http://www.reqall.com/user/feeds/rss/a1b2c3....."
-;;             "~/org/feeds.org" "ReQall Entries"
-;;             :filter my-reqall-filter)))
-;;
-;;    (defun my-reqall-filter (e)
-;;       (if (string-match "reQall is typing what you said"
-;;                         (plist-get e :title))
-;;           nil
-;;         e))
-;;
-;;  See the docstring for `org-feed-alist' for more details.
-;;
-;;
-;;  Keeping track of previously added entries
-;;  -----------------------------------------
-;;
-;;  Since Org allows you to delete, archive, or move outline nodes,
-;;  org-feed.el needs to keep track of which feed items have been handled
-;;  before, so that they will not be handled again.  For this, org-feed.el
-;;  stores information in a special drawer, FEEDSTATUS, under the heading
-;;  that received the input of the feed.
-;;
-;;
-;;  Acknowledgments
-;;  ---------------
-;;
-;;  org-feed.el is based on ideas by Brad Bozarth who implemented a
-;;  similar mechanism using shell and awk scripts.
-
-;;; Code:
-
-(require 'org)
-(require 'sha1)
-
-(declare-function url-retrieve-synchronously "url"
-                  (url &optional silent inhibit-cookies timeout))
-(declare-function xml-node-children "xml" (node))
-(declare-function xml-get-children "xml" (node child-name))
-(declare-function xml-get-attribute "xml" (node attribute))
-(declare-function xml-get-attribute-or-nil "xml" (node attribute))
-(declare-function xml-substitute-special "xml" (string))
-
-(declare-function org-capture-escaped-% "org-capture" ())
-(declare-function org-capture-expand-embedded-elisp "org-capture" (&optional mark))
-(declare-function org-capture-inside-embedded-elisp-p "org-capture" ())
-
-(defgroup org-feed  nil
-  "Options concerning RSS feeds as inputs for Org files."
-  :tag "Org Feed"
-  :group 'org)
-
-(defcustom org-feed-alist nil
-  "Alist specifying RSS feeds that should create inputs for Org.
-Each entry in this list specified an RSS feed tat should be queried
-to create inbox items in Org.  Each entry is a list with the following items:
-
-name         a custom name for this feed
-URL          the Feed URL
-file         the target Org file where entries should be listed, when
-             nil the target becomes the current buffer (may be an
-             indirect buffer) each time the feed update is invoked
-headline     the headline under which entries should be listed
-
-Additional arguments can be given using keyword-value pairs.  Many of these
-specify functions that receive one or a list of \"entries\" as their single
-argument.  An entry is a property list that describes a feed item.  The
-property list has properties for each field in the item, for example `:title'
-for the `<title>' field and `:pubDate' for the publication date.  In addition,
-it contains the following properties:
-
-`:item-full-text'   the full text in the <item> tag
-`:guid-permalink'   t when the guid property is a permalink
-
-Here are the keyword-value pair allows in `org-feed-alist'.
-
-:drawer drawer-name
-     The name of the drawer for storing feed information.  The default is
-     \"FEEDSTATUS\".  Using different drawers for different feeds allows
-     several feeds to target the same inbox heading.
-
-:filter filter-function
-     A function to select interesting entries in the feed.  It gets a single
-     entry as parameter.  It should return the entry if it is relevant, or
-     nil if it is not.
-
-:template template-string
-     The default action on new items in the feed is to add them as children
-     under the headline for the feed.  The template describes how the entry
-     should be formatted.  If not given, it defaults to
-     `org-feed-default-template'.
-
-:formatter formatter-function
-     Instead of relying on a template, you may specify a function to format
-     the outline node to be inserted as a child.  This function gets passed
-     a property list describing a single feed item, and it should return a
-     string that is a properly formatted Org outline node of level 1.
-
-:new-handler function
-     If adding new items as children to the outline is not what you want
-     to do with new items, define a handler function that is called with
-     a list of all new items in the feed, each one represented as a property
-     list.  The handler should do what needs to be done, and org-feed will
-     mark all items given to this handler as \"handled\", i.e. they will not
-     be passed to this handler again in future readings of the feed.
-     When the handler is called, point will be at the feed headline.
-
-:changed-handler function
-     This function gets passed a list of all entries that have been
-     handled before, but are now still in the feed and have *changed*
-     since last handled (as evidenced by a different sha1 hash).
-     When the handler is called, point will be at the feed headline.
-
-:parse-feed function
-     This function gets passed a buffer, and should return a list
-     of entries, each being a property list containing the
-     `:guid' and `:item-full-text' keys.  The default is
-     `org-feed-parse-rss-feed'; `org-feed-parse-atom-feed' is an
-     alternative.
-
-:parse-entry function
-     This function gets passed an entry as returned by the parse-feed
-     function, and should return the entry with interesting properties added.
-     The default is `org-feed-parse-rss-entry'; `org-feed-parse-atom-entry'
-     is an alternative."
-  :group 'org-feed
-  :type '(repeat
-	  (list :value ("" "http://" "" "")
-		(string :tag "Name")
-		(string :tag "Feed URL")
-		(file :tag "File for inbox")
-		(string :tag "Headline for inbox")
-		(repeat :inline t
-			(choice
-			 (list :inline t :tag "Filter"
-			       (const :filter)
-			       (symbol :tag "Filter Function"))
-			 (list :inline t :tag "Template"
-			       (const :template)
-			       (string :tag "Template"))
-			 (list :inline t :tag "Formatter"
-			       (const :formatter)
-			       (symbol :tag "Formatter Function"))
-			 (list :inline t :tag "New items handler"
-			       (const :new-handler)
-			       (symbol :tag "Handler Function"))
-			 (list :inline t :tag "Changed items"
-			       (const :changed-handler)
-			       (symbol :tag "Handler Function"))
-			 (list :inline t :tag "Parse Feed"
-			       (const :parse-feed)
-			       (symbol :tag "Parse Feed Function"))
-			 (list :inline t :tag "Parse Entry"
-			       (const :parse-entry)
-			       (symbol :tag "Parse Entry Function"))
-			 )))))
-
-(defcustom org-feed-drawer "FEEDSTATUS"
-  "The name of the drawer for feed status information.
-Each feed may also specify its own drawer name using the `:drawer'
-parameter in `org-feed-alist'."
-  :group 'org-feed
-  :type '(string :tag "Drawer Name"))
-
-(defcustom org-feed-default-template "\n* %h\n  %U\n  %description\n  %a\n"
-  "Template for the Org node created from RSS feed items.
-This is just the default, each feed can specify its own.
-Any fields from the feed item can be interpolated into the template with
-%name, for example %title, %description, %pubDate etc.  In addition, the
-following special escapes are valid as well:
-
-%h      The title, or the first line of the description
-%t      The date as a stamp, either from <pubDate> (if present), or
-        the current date
-%T      Date and time
-%u,%U   Like %t,%T, but inactive time stamps
-%a      A link, from <guid> if that is a permalink, else from <link>
-%(sexp) Evaluate elisp `(sexp)' and replace with the result, the simple
-        %-escapes above can be used as arguments, e.g. %(capitalize \\\"%h\\\")"
-  :group 'org-feed
-  :type '(string :tag "Template"))
-
-(defcustom org-feed-save-after-adding t
-  "Non-nil means save buffer after adding new feed items."
-  :group 'org-feed
-  :type 'boolean)
-
-(defcustom org-feed-retrieve-method 'url-retrieve-synchronously
-  "The method to be used to retrieve a feed URL.
-This can be `curl' or `wget' to call these external programs, or it can be
-an Emacs Lisp function that will return a buffer containing the content
-of the file pointed to by the URL."
-  :group 'org-feed
-  :type '(choice
-	  (const :tag "Internally with url.el" url-retrieve-synchronously)
-	  (const :tag "Externally with curl" curl)
-	  (const :tag "Externally with wget" wget)
-	  (function :tag "Function")))
-
-(defcustom org-feed-before-adding-hook nil
-  "Hook that is run before adding new feed items to a file.
-You might want to commit the file in its current state to version control,
-for example."
-  :group 'org-feed
-  :type 'hook)
-
-(defcustom org-feed-after-adding-hook nil
-  "Hook that is run after new items have been added to a file.
-Depending on `org-feed-save-after-adding', the buffer will already
-have been saved."
-  :group 'org-feed
-  :type 'hook)
-
-(defvar org-feed-buffer "*Org feed*"
-  "The buffer used to retrieve a feed.")
-
-;;;###autoload
-(defun org-feed-update-all ()
-  "Get inbox items from all feeds in `org-feed-alist'."
-  (interactive)
-  (let ((entries 0)
-	(errors 0)
-	(total-feeds (length org-feed-alist)))
-    (dolist (feed org-feed-alist)
-      (let ((items (ignore-errors (org-feed-update feed))))
-	(if items (cl-incf entries items)
-	  (cl-incf errors))))
-    (message "%s from %d %s%s"
-	     (pcase entries
-	       (0 "No new entries")
-	       (1 "1 new entry")
-	       (_ (format "%d new entries" entries)))
-	     total-feeds
-	     (if (= total-feeds 1) "feed" "feeds")
-	     (if (= 0 errors) "" (format " (unavailable feeds: %d)" errors)))))
-
-;;;###autoload
-(defun org-feed-update (feed &optional retrieve-only)
-  "Get inbox items from FEED.
-FEED can be a string with an association in `org-feed-alist', or
-it can be a list structured like an entry in `org-feed-alist'."
-  (interactive (list (org-completing-read "Feed name: " org-feed-alist)))
-  (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
-  (unless feed
-    (error "No such feed in `org-feed-alist"))
-  (catch 'exit
-    (let ((name (car feed))
-	  (url (nth 1 feed))
-	  (file (or (nth 2 feed) (buffer-file-name (or (buffer-base-buffer)
-						       (current-buffer)))))
-	  (headline (nth 3 feed))
-	  (filter (nth 1 (memq :filter feed)))
-	  (formatter (nth 1 (memq :formatter feed)))
-	  (new-handler (nth 1 (memq :new-handler feed)))
-	  (changed-handler (nth 1 (memq :changed-handler feed)))
-	  (template (or (nth 1 (memq :template feed))
-			org-feed-default-template))
-	  (drawer (or (nth 1 (memq :drawer feed))
-		      org-feed-drawer))
-	  (parse-feed (or (nth 1 (memq :parse-feed feed))
-			  'org-feed-parse-rss-feed))
-	  (parse-entry (or (nth 1 (memq :parse-entry feed))
-			   'org-feed-parse-rss-entry))
-	  feed-buffer inbox-pos new-formatted
-	  entries old-status status new changed guid-alist guid olds)
-      (setq feed-buffer (org-feed-get-feed url))
-      (unless (and feed-buffer (bufferp (get-buffer feed-buffer)))
-	(error "Cannot get feed %s" name))
-      (when retrieve-only
-	(throw 'exit feed-buffer))
-      (setq entries (funcall parse-feed feed-buffer))
-      (ignore-errors (kill-buffer feed-buffer))
-      (save-excursion
-	(save-window-excursion
-	  (setq inbox-pos (org-feed-goto-inbox-internal file headline))
-	  (setq old-status (org-feed-read-previous-status inbox-pos drawer))
-	  ;; Add the "handled" status to the appropriate entries
-	  (setq entries (mapcar (lambda (e)
-				  (setq e
-					(plist-put e :handled
-						   (nth 1 (assoc
-							   (plist-get e :guid)
-							   old-status)))))
-				entries))
-	  ;; Find out which entries are new and which are changed
-	  (dolist (e entries)
-	    (if (not (plist-get e :handled))
-		(push e new)
-	      (setq olds (nth 2 (assoc (plist-get e :guid) old-status)))
-	      (if (and olds
-		       (not (string= (sha1
-				      (plist-get e :item-full-text))
-				     olds)))
-		  (push e changed))))
-
-	  ;; Parse the relevant entries fully
-	  (setq new     (mapcar parse-entry new)
-		changed (mapcar parse-entry changed))
-
-	  ;; Run the filter
-	  (when filter
-	    (setq new     (delq nil (mapcar filter new))
-		  changed (delq nil (mapcar filter new))))
-
-	  (when (not (or new changed))
-	    (message "No new items in feed %s" name)
-	    (throw 'exit 0))
-
-	  ;; Get alist based on guid, to look up entries
-	  (setq guid-alist
-		(append
-		 (mapcar (lambda (e) (list (plist-get e :guid) e)) new)
-		 (mapcar (lambda (e) (list (plist-get e :guid) e)) changed)))
-
-	  ;; Construct the new status
-	  (setq status
-		(mapcar
-		 (lambda (e)
-		   (setq guid (plist-get e :guid))
-		   (list guid
-			 ;; things count as handled if we handle them now,
-			 ;; or if they were handled previously
-			 (if (assoc guid guid-alist) t (plist-get e :handled))
-			 ;; A hash, to detect changes
-			 (sha1 (plist-get e :item-full-text))))
-		 entries))
-
-	  ;; Handle new items in the feed
-	  (when new
-	    (if new-handler
-		(progn
-		  (goto-char inbox-pos)
-		  (funcall new-handler new))
-	      ;; No custom handler, do the default adding
-	      ;; Format the new entries into an alist with GUIDs in the car
-	      (setq new-formatted
-		    (mapcar
-		     (lambda (e) (org-feed-format-entry e template formatter))
-		     new)))
-
-	    ;; Insert the new items
-	    (org-feed-add-items inbox-pos new-formatted))
-
-	  ;; Handle changed items in the feed
-	  (when (and changed-handler changed)
-	    (goto-char inbox-pos)
-	    (funcall changed-handler changed))
-
-	  ;; Write the new status
-	  ;; We do this only now, in case something goes wrong above, so
-	  ;; that would would end up with a status that does not reflect
-	  ;; which items truly have been handled
-	  (org-feed-write-status inbox-pos drawer status)
-
-	  ;; Normalize the visibility of the inbox tree
-	  (goto-char inbox-pos)
-	  (org-flag-subtree t)
-	  (org-show-children)
-
-	  ;; Hooks and messages
-	  (when org-feed-save-after-adding (save-buffer))
-	  (message "Added %d new item%s from feed %s to file %s, heading %s"
-		   (length new) (if (> (length new) 1) "s" "")
-		   name
-		   (file-name-nondirectory file) headline)
-	  (run-hooks 'org-feed-after-adding-hook)
-	  (length new))))))
-
-;;;###autoload
-(defun org-feed-goto-inbox (feed)
-  "Go to the inbox that captures the feed named FEED."
-  (interactive
-   (list (if (= (length org-feed-alist) 1)
-	     (car org-feed-alist)
-	   (org-completing-read "Feed name: " org-feed-alist))))
-  (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
-  (unless feed
-    (error "No such feed in `org-feed-alist"))
-  (org-feed-goto-inbox-internal (nth 2 feed) (nth 3 feed)))
-
-;;;###autoload
-(defun org-feed-show-raw-feed (feed)
-  "Show the raw feed buffer of a feed."
-  (interactive
-   (list (if (= (length org-feed-alist) 1)
-	     (car org-feed-alist)
-	   (org-completing-read "Feed name: " org-feed-alist))))
-  (if (stringp feed) (setq feed (assoc feed org-feed-alist)))
-  (unless feed
-    (error "No such feed in `org-feed-alist"))
-  (pop-to-buffer-same-window
-   (org-feed-update feed 'retrieve-only))
-  (goto-char (point-min)))
-
-(defun org-feed-goto-inbox-internal (file heading)
-  "Find or create HEADING in FILE.
-Switch to that buffer, and return the position of that headline."
-  (find-file file)
-  (widen)
-  (goto-char (point-min))
-  (if (re-search-forward
-       (concat "^\\*+[ \t]+" heading "[ \t]*\\(:.*?:[ \t]*\\)?$")
-       nil t)
-      (goto-char (match-beginning 0))
-    (goto-char (point-max))
-    (insert "\n\n* " heading "\n\n")
-    (org-back-to-heading t))
-  (point))
-
-(defun org-feed-read-previous-status (pos drawer)
-  "Get the alist of old GUIDs from the entry at POS.
-This will find DRAWER and extract the alist."
-  (save-excursion
-    (goto-char pos)
-    (let ((end (save-excursion (org-end-of-subtree t t))))
-      (if (re-search-forward
-	   (concat "^[ \t]*:" drawer ":[ \t]*\n\\([^\000]*?\\)\n[ \t]*:END:")
-	   end t)
-	  (read (match-string 1))
-	nil))))
-
-(defun org-feed-write-status (pos drawer status)
-  "Write the feed STATUS to DRAWER in entry at POS."
-  (save-excursion
-    (goto-char pos)
-    (let ((end (save-excursion (org-end-of-subtree t t))))
-      (if (re-search-forward (concat "^[ \t]*:" drawer ":[ \t]*\n")
-			     end t)
-	  (progn
-	    (goto-char (match-end 0))
-	    (delete-region (point)
-			   (save-excursion
-			     (and (re-search-forward "^[ \t]*:END:" nil t)
-				  (match-beginning 0)))))
-	(outline-next-heading)
-	(insert "  :" drawer ":\n  :END:\n")
-	(beginning-of-line 0))
-      (insert (pp-to-string status)))))
-
-(defun org-feed-add-items (pos entries)
-  "Add the formatted items to the headline as POS."
-  (let (entry level)
-    (save-excursion
-      (goto-char pos)
-      (unless (looking-at org-complex-heading-regexp)
-	(error "Wrong position"))
-      (setq level (org-get-valid-level (length (match-string 1)) 1))
-      (org-end-of-subtree t t)
-      (skip-chars-backward " \t\n")
-      (beginning-of-line 2)
-      (setq pos (point))
-      (while (setq entry (pop entries))
-	(org-paste-subtree level entry 'yank))
-      (org-mark-ring-push pos))))
-
-(defun org-feed-format-entry (entry template formatter)
-  "Format ENTRY so that it can be inserted into an Org file.
-ENTRY is a property list.  This function adds a `:formatted-for-org' property
-and returns the full property list.
-If that property is already present, nothing changes."
-  (require 'org-capture)
-  (if formatter (funcall formatter entry)
-    (let* ((dlines
-            (org-split-string (or (plist-get entry :description) "???")
-                              "\n"))
-           (time (or (if (plist-get entry :pubDate)
-                         (org-read-date t t (plist-get entry :pubDate)))
-                     (current-time)))
-           (v-h (or (plist-get entry :title) (car dlines) "???"))
-           (v-t (format-time-string (org-time-stamp-format nil nil) time))
-           (v-T (format-time-string (org-time-stamp-format t   nil) time))
-           (v-u (format-time-string (org-time-stamp-format nil t)   time))
-           (v-U (format-time-string (org-time-stamp-format t   t)   time))
-           (v-a (let ((tmp (or (and (plist-get entry :guid-permalink)
-				    (plist-get entry :guid))
-			       (plist-get entry :link))))
-		  (if tmp (format "[[%s]]\n" tmp ) ""))))
-      (with-temp-buffer
-        (insert template)
-        (goto-char (point-min))
-
-        ;; Mark %() embedded elisp for later evaluation.
-        (org-capture-expand-embedded-elisp 'mark)
-
-        ;; Simple %-escapes.  `org-capture-escaped-%' may modify
-	;; buffer and cripple match-data.  Use markers instead.
-        (while (re-search-forward "%\\([a-zA-Z]+\\)" nil t)
-          (let ((key (match-string 1))
-		(beg (copy-marker (match-beginning 0)))
-		(end (copy-marker (match-end 0))))
-	    (unless (org-capture-escaped-%)
-	      (delete-region beg end)
-	      (set-marker beg nil)
-	      (set-marker end nil)
-	      (let ((replacement
-		     (pcase key
-		       ("h" v-h)
-		       ("t" v-t)
-		       ("T" v-T)
-		       ("u" v-u)
-		       ("U" v-U)
-		       ("a" v-a)
-		       (name
-			(let ((v (plist-get entry (intern (concat ":" name)))))
-			  (save-excursion
-			    (save-match-data
-			      (beginning-of-line)
-			      (if (looking-at
-				   (concat "^\\([ \t]*\\)%" name "[ \t]*$"))
-				  (org-feed-make-indented-block
-				   v (current-indentation))
-				v))))))))
-		(when replacement
-		  (insert
-		   ;; Escape string delimiters within embedded lisp.
-		   (if (org-capture-inside-embedded-elisp-p)
-		       (replace-regexp-in-string "\"" "\\\\\"" replacement)
-		     replacement)))))))
-
-        ;; %() embedded elisp
-        (org-capture-expand-embedded-elisp)
-
-        (decode-coding-string
-         (buffer-string) (detect-coding-region (point-min) (point-max) t))))))
-
-(defun org-feed-make-indented-block (s n)
-  "Add indentation of N spaces to a multiline string S."
-  (if (not (string-match "\n" s))
-      s
-    (mapconcat 'identity
-               (org-split-string s "\n")
-               (concat "\n" (make-string n ?\ )))))
-
-(defun org-feed-skip-http-headers (buffer)
-  "Remove HTTP headers from BUFFER, and return it.
-Assumes headers are indeed present!"
-  (with-current-buffer buffer
-    (widen)
-    (goto-char (point-min))
-    (search-forward "\n\n")
-    (delete-region (point-min) (point))
-    buffer))
-
-(defun org-feed-get-feed (url)
-  "Get the RSS feed file at URL and return the buffer."
-  (cond
-   ((eq org-feed-retrieve-method 'url-retrieve-synchronously)
-    (org-feed-skip-http-headers (url-retrieve-synchronously url)))
-   ((eq org-feed-retrieve-method 'curl)
-    (ignore-errors (kill-buffer org-feed-buffer))
-    (call-process "curl" nil org-feed-buffer nil "--silent" url)
-    org-feed-buffer)
-   ((eq org-feed-retrieve-method 'wget)
-    (ignore-errors (kill-buffer org-feed-buffer))
-    (call-process "wget" nil org-feed-buffer nil "-q" "-O" "-" url)
-    org-feed-buffer)
-   ((functionp org-feed-retrieve-method)
-    (funcall org-feed-retrieve-method url))))
-
-(defun org-feed-parse-rss-feed (buffer)
-  "Parse BUFFER for RSS feed entries.
-Returns a list of entries, with each entry a property list,
-containing the properties `:guid' and `:item-full-text'."
-  (require 'xml)
-  (let ((case-fold-search t)
-	entries beg end item guid entry)
-    (with-current-buffer buffer
-      (widen)
-      (goto-char (point-min))
-      (while (re-search-forward "<item\\>.*?>" nil t)
-	(setq beg (point)
-	      end (and (re-search-forward "</item>" nil t)
-		       (match-beginning 0)))
-	(setq item (buffer-substring beg end)
-	      guid (if (string-match "<guid\\>.*?>\\([^\000]*?\\)</guid>" item)
-		       (xml-substitute-special (match-string-no-properties 1 item))))
-	(setq entry (list :guid guid :item-full-text item))
-	(push entry entries)
-	(widen)
-	(goto-char end))
-      (nreverse entries))))
-
-(defun org-feed-parse-rss-entry (entry)
-  "Parse the `:item-full-text' field for xml tags and create new properties."
-  (require 'xml)
-  (with-temp-buffer
-    (insert (plist-get entry :item-full-text))
-    (goto-char (point-min))
-    (while (re-search-forward "<\\([a-zA-Z]+\\>\\).*?>\\([^\000]*?\\)</\\1>"
-			      nil t)
-      (setq entry (plist-put entry
-			     (intern (concat ":" (match-string 1)))
-			     (xml-substitute-special (match-string 2)))))
-    (goto-char (point-min))
-    (unless (re-search-forward "isPermaLink[ \t]*=[ \t]*\"false\"" nil t)
-      (setq entry (plist-put entry :guid-permalink t))))
-  entry)
-
-(defun org-feed-parse-atom-feed (buffer)
-  "Parse BUFFER for Atom feed entries.
-Returns a list of entries, with each entry a property list,
-containing the properties `:guid' and `:item-full-text'.
-
-The `:item-full-text' property actually contains the sexp
-formatted as a string, not the original XML data."
-  (require 'xml)
-  (with-current-buffer buffer
-    (widen)
-    (let ((feed (car (xml-parse-region (point-min) (point-max)))))
-      (mapcar
-       (lambda (entry)
-	 (list
-	  :guid (car (xml-node-children (car (xml-get-children entry 'id))))
-	  :item-full-text (prin1-to-string entry)))
-       (xml-get-children feed 'entry)))))
-
-(defun org-feed-parse-atom-entry (entry)
-  "Parse the `:item-full-text' as a sexp and create new properties."
-  (let ((xml (car (read-from-string (plist-get entry :item-full-text)))))
-    ;; Get first <link href='foo'/>.
-    (setq entry (plist-put entry :link
-			   (xml-get-attribute
-			    (car (xml-get-children xml 'link))
-			    'href)))
-    ;; Add <title/> as :title.
-    (setq entry (plist-put entry :title
-			   (xml-substitute-special
-			    (car (xml-node-children
-				  (car (xml-get-children xml 'title)))))))
-    (let* ((content (car (xml-get-children xml 'content)))
-	   (type (xml-get-attribute-or-nil content 'type)))
-      (when content
-	(cond
-	 ((string= type "text")
-	  ;; We like plain text.
-	  (setq entry (plist-put entry :description
-				 (xml-substitute-special
-				  (car (xml-node-children content))))))
-	 ((string= type "html")
-	  ;; TODO: convert HTML to Org markup.
-	  (setq entry (plist-put entry :description
-				 (xml-substitute-special
-				  (car (xml-node-children content))))))
-	 ((string= type "xhtml")
-	  ;; TODO: convert XHTML to Org markup.
-	  (setq entry (plist-put entry :description
-				 (prin1-to-string
-				  (xml-node-children content)))))
-	 (t
-	  (setq entry (plist-put entry :description
-				 (format-message
-                                  "Unknown `%s' content." type)))))))
-    entry))
-
-(provide 'org-feed)
-
-;; Local variables:
-;; generated-autoload-file: "org-loaddefs.el"
-;; End:
-
-;;; org-feed.el ends here