512 lines
18 KiB
EmacsLisp
512 lines
18 KiB
EmacsLisp
;;; discoursel.el --- A Discourse client for Emacs
|
|
|
|
;; Copyright 2024 Sergio Durigan Junior <sergiodj (at) sergiodj (dot) net>
|
|
;; Author: Sergio Durigan Junior <sergiodj (at) sergiodj (dot) net>
|
|
;; Version: 0.1
|
|
;; Homepage: https://git.sergiodj.net/sergiodj/discoursel
|
|
;; Keywords: discourse client emacs
|
|
;; Package-Requires: ((emacs "24") (plz "0.7") markdown-mode message rx)
|
|
|
|
;; This file is not part of GNU Emacs.
|
|
|
|
;; This file 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, or (at your
|
|
;; option) any later version.
|
|
|
|
;; This file 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 this file. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; discoursel is a Discourse client for Emacs.
|
|
|
|
;;; Installation:
|
|
|
|
;; - Make sure you configured 'browse-url' correctly, i.e., that
|
|
;; you're able to open links if you hit RET on them. For example,
|
|
;; if you use Firefox you might want to include this in your Emacs
|
|
;; init file:
|
|
;;
|
|
;; (setq browse-url-browser-function 'browse-url-firefox)
|
|
;; (setq browse-url-firefox-new-window-is-tab t)
|
|
;; (setq browse-url-firefox-program "firefox")
|
|
|
|
;;; Usage:
|
|
|
|
;; Available keybindings are:
|
|
;;
|
|
|
|
;;; Code:
|
|
|
|
(require 'json)
|
|
(require 'plz)
|
|
(require 'message)
|
|
(require 'rx)
|
|
(require 'markdown-mode)
|
|
|
|
(defgroup discoursel nil
|
|
"Discourse TODO")
|
|
|
|
(defcustom discoursel-instances
|
|
'((ubuntu
|
|
:url "https://discourse.ubuntu.com"
|
|
:name "Ubuntu")
|
|
(fedora
|
|
:url "https://discussion.fedoraproject.org"
|
|
:name "Fedora"))
|
|
"The Discourse instance."
|
|
:group 'discoursel
|
|
:type 'string)
|
|
|
|
(defcustom discoursel-fetch-all-posts-from-topic t
|
|
"Whether to fetch all posts from a certain topic.
|
|
|
|
If t, the default, all posts are fetched (which may take a while
|
|
depending on the topic's length).
|
|
|
|
If nil, pagination is enabled and the user needs to ask for more
|
|
posts manually and incrementally."
|
|
:group 'discoursel
|
|
:type 'boolean)
|
|
|
|
(defvar discoursel-buffer-list nil
|
|
"List of discoursel buffers.")
|
|
|
|
(defface discoursel-topic-face
|
|
'((((class color) (background light)) (:foreground "#000"))
|
|
(((class color) (background dark)) (:foreground "#fff")))
|
|
"Face used for topics."
|
|
:group 'discoursel)
|
|
|
|
(defface discoursel-username-face
|
|
'((((class color) (background light)) (:foreground "#aa0"))
|
|
(((class color) (background dark)) (:foreground "#ff0")))
|
|
"Face used for usernames."
|
|
:group 'discoursel)
|
|
|
|
(defface discoursel-code-face
|
|
'((((class color) (background light)) (:background "#cdcecc" :extend t))
|
|
(((class color) (background dark)) (:background "#17211c" :extend t)))
|
|
"Face used for code blocks."
|
|
:group 'discoursel)
|
|
|
|
(defun discoursel--parse-pre (tag)
|
|
(let ((p (point))
|
|
(shr-folding-mode 'none))
|
|
(shr-ensure-newline)
|
|
(shr-generic tag)
|
|
(shr-ensure-newline)
|
|
(add-text-properties p (point)
|
|
'(pre-tag t face discoursel-code-face))))
|
|
|
|
(defun discoursel--get (instance endpoint &optional args)
|
|
(condition-case plzerror
|
|
(let* ((instance-url (plist-get (cdr instance) ':url))
|
|
(full-url (concat instance-url "/" endpoint ".json")))
|
|
(plz 'get (concat full-url
|
|
(when args
|
|
(concat "?"
|
|
(mapconcat (lambda (elt)
|
|
(concat (car elt) "=" (cdr elt)))
|
|
args "&"))))
|
|
:as #'json-read))
|
|
(plz-error
|
|
(error "Could not query endpoint '%s': '%s'"
|
|
endpoint (plz-error-message plzerror)))))
|
|
|
|
(defun discoursel--get-invisibility-spec (instance &optional section)
|
|
(let* ((instance-name (symbol-name (car instance)))
|
|
(spec-str (concat "discoursel-visibility-" instance-name
|
|
(when section
|
|
(concat "-" section)))))
|
|
(intern spec-str)))
|
|
|
|
(defun discoursel--latest-topics (instance)
|
|
(let* ((r (discoursel--get instance "latest"))
|
|
(instance-symbol (car instance))
|
|
(topics (alist-get 'topics (alist-get 'topic_list r)))
|
|
(users (alist-get 'users r))
|
|
(initial-point (point)))
|
|
(insert (propertize ">> Latest topics" 'invisible (discoursel--get-invisibility-spec instance)))
|
|
(insert
|
|
(with-temp-buffer
|
|
(insert "\n")
|
|
(cl-map 'vector
|
|
(lambda (topic)
|
|
(let* ((userid (alist-get 'user_id (aref (alist-get 'posters topic) 0)))
|
|
(username (seq-find
|
|
(lambda (v)
|
|
(= (alist-get 'id v) userid))
|
|
users))
|
|
(inhibit-read-only t))
|
|
(insert
|
|
(propertize (format " %s (by %s)\n"
|
|
(propertize (alist-get 'title topic)
|
|
'face 'discoursel-topic-face)
|
|
(propertize (alist-get 'name username)
|
|
'face 'discoursel-username-face))
|
|
'discoursel-topic-slug (alist-get 'slug topic)
|
|
'discoursel-topic-id (alist-get 'id topic)))))
|
|
topics)
|
|
(put-text-property (point-min) (point-max)
|
|
'invisible `(,(discoursel--get-invisibility-spec instance "latest")
|
|
,(discoursel--get-invisibility-spec instance)))
|
|
(buffer-string)))
|
|
(add-text-properties (1- initial-point) (point-max)
|
|
`(discoursel-section "latest"
|
|
discoursel-instance ,instance-symbol))))
|
|
|
|
(defun discoursel-update ()
|
|
(interactive)
|
|
(with-current-buffer (discoursel-get-create-buffer)
|
|
(save-excursion
|
|
(let ((inhibit-read-only t))
|
|
(erase-buffer)
|
|
(dolist (instance discoursel-instances)
|
|
(let* ((instance-symbol (car instance))
|
|
(instance-plist (cdr instance))
|
|
(instance-name (plist-get instance-plist ':name)))
|
|
(insert (propertize (format "💻 %s" instance-name)
|
|
'discoursel-instance instance-symbol))
|
|
(insert (propertize "\n" 'invisible (discoursel--get-invisibility-spec instance)))
|
|
;; (let ((latest-topic-initial-point (point))
|
|
;; (latest-topic-final-point))
|
|
;; (insert ">> Latest topics")
|
|
;; (setq latest-topic-final-point (point))
|
|
;; (insert "\n")
|
|
(discoursel--latest-topics instance)
|
|
(insert "\n")))
|
|
(kill-line -2)))))
|
|
; (put-text-property latest-topic-final-point (point) 'invisible 'latest-topics))))))
|
|
;; (put-text-property latest-topic-initial-point
|
|
;; latest-topic-final-point
|
|
;; 'overlay (make-overlay (1+ latest-topic-final-point) (point-max))))))))
|
|
|
|
(defun discoursel-toggle-heading ()
|
|
(interactive)
|
|
(when-let* ((instance-to-toggle (get-text-property (point) 'discoursel-instance))
|
|
(instance (assoc instance-to-toggle discoursel-instances)))
|
|
(let* ((section-to-toggle (get-text-property (point) 'discoursel-section))
|
|
(spec (cons (discoursel--get-invisibility-spec instance
|
|
section-to-toggle)
|
|
t))
|
|
(invisible-p (and (listp buffer-invisibility-spec)
|
|
(member spec buffer-invisibility-spec))))
|
|
(if invisible-p
|
|
(remove-from-invisibility-spec spec)
|
|
(add-to-invisibility-spec spec)))))
|
|
|
|
(defun discoursel--get-name-or-username (post)
|
|
(let ((name (alist-get 'display_username post)))
|
|
(if (and name (not (string-empty-p name)))
|
|
name
|
|
(alist-get 'username post))))
|
|
|
|
(defun discoursel--parse-heading (dom)
|
|
"Prepend <hN> tag (DOM) with the equivalent number of sharp (#)
|
|
characters."
|
|
(let* ((idx (1- (length dom)))
|
|
;; This is a bit hacky and assumes that the text will always
|
|
;; be available as the last item in the list.
|
|
(tagname (symbol-name (car dom)))
|
|
(level (string-to-number
|
|
(string-remove-prefix "h" tagname)))
|
|
(sharps (make-string level ?#))
|
|
(face (intern (concat "shr-" tagname)))
|
|
(possible-text (nth idx dom)))
|
|
(when (stringp possible-text)
|
|
(setf (nth idx dom) (concat sharps " " possible-text)))
|
|
(shr-heading dom face)))
|
|
|
|
(defun discoursel-topic-next-entry ()
|
|
(interactive)
|
|
(let ((pos (point)))
|
|
(save-excursion
|
|
(setq pos (next-single-char-property-change pos 'discoursel-post-id))
|
|
(goto-char pos)
|
|
(while (and (not (eobp))
|
|
(not (looking-at-p (rx line-start "Author:"))))
|
|
(setq pos (next-single-char-property-change pos 'discoursel-post-id))
|
|
(goto-char pos))
|
|
(when (eobp)
|
|
(setq pos nil)))
|
|
(when pos
|
|
(goto-char pos))))
|
|
|
|
(defun discoursel-topic-previous-entry ()
|
|
(interactive)
|
|
(let ((pos (point)))
|
|
(setq pos (or (previous-single-property-change pos 'discoursel-post-id)
|
|
(point-min)))
|
|
(goto-char pos)
|
|
(while (and (not (bobp))
|
|
(not (looking-at-p (rx line-start (or "Author:" "Title:")))))
|
|
(setq pos (or (previous-single-property-change pos 'discoursel-post-id)
|
|
(point-min)))
|
|
(goto-char pos))))
|
|
|
|
(defun discoursel--insert-post (instance post &optional post-title)
|
|
(let* ((post-slug (alist-get 'topic_slug post))
|
|
(post-id (alist-get 'id post))
|
|
(post-number (alist-get 'post_number post))
|
|
(post-date (alist-get 'created_at post))
|
|
(post-date-string
|
|
(format-time-string "%c"
|
|
(encode-time
|
|
(parse-time-string post-date))))
|
|
(post-author-name (discoursel--get-name-or-username post))
|
|
(post-author-username (alist-get 'username post))
|
|
(post-html-content (alist-get 'cooked post))
|
|
(instance-symbol (car instance)))
|
|
(save-excursion
|
|
(insert
|
|
(with-temp-buffer
|
|
(when post-title
|
|
(insert (format (propertize "Title: %s\n" 'face 'message-header-name)
|
|
(propertize post-title 'face 'message-header-subject))))
|
|
(insert (format (propertize "Author: %s\n" 'face 'message-header-name)
|
|
(propertize post-author-name 'face 'message-header-to)))
|
|
(insert (format (propertize "Date: %s\n" 'face 'message-header-name)
|
|
(propertize post-date-string 'face 'message-header-other)))
|
|
(insert "\n")
|
|
(save-excursion
|
|
(insert post-html-content))
|
|
(let ((shr-use-fonts nil)
|
|
(shr-external-rendering-functions
|
|
'((pre . discoursel--parse-pre)
|
|
(h1 . discoursel--parse-heading)
|
|
(h2 . discoursel--parse-heading)
|
|
(h3 . discoursel--parse-heading)
|
|
(h4 . discoursel--parse-heading)
|
|
(h5 . discoursel--parse-heading)
|
|
(h6 . discoursel--parse-heading))))
|
|
(shr-render-region (point) (point-max)))
|
|
(add-text-properties (point-min) (point-max)
|
|
`(discoursel-post-id ,post-id
|
|
discoursel-post-number ,post-number
|
|
discoursel-post-author-username ,post-author-username
|
|
discoursel-post-author-name ,post-author-name
|
|
discoursel-instance ,instance-symbol))
|
|
(buffer-string))))))
|
|
|
|
(defun discoursel-render-posts-from-topic (instance topic &optional start-idx)
|
|
(let* ((posts (alist-get 'posts (alist-get 'post_stream topic)))
|
|
(topic-slug (alist-get 'slug topic))
|
|
(buf (discoursel-get-create-buffer topic-slug))
|
|
(startidx (or start-idx 0)))
|
|
(with-current-buffer buf
|
|
(save-excursion
|
|
(let ((inhibit-read-only t))
|
|
(cl-loop for idx from startidx to (1- (length posts)) do
|
|
(goto-char (point-max))
|
|
(insert
|
|
"\n"
|
|
(with-temp-buffer
|
|
(insert "<hr>")
|
|
(shr-render-region (point-min) (point-max))
|
|
(buffer-string)))
|
|
(discoursel--insert-post instance (aref posts idx))))))))
|
|
|
|
(defun discoursel--fetch-all-posts-from-topic (instance topic-id number-of-pages)
|
|
(cl-loop for page from 2 to number-of-pages do
|
|
(with-delayed-message (2 (format "Rendering page %d out of %d..." page number-of-pages))
|
|
(let ((topic (discoursel--get instance
|
|
(concat "t/" topic-id)
|
|
`(("page" . ,(number-to-string page))))))
|
|
(discoursel-render-posts-from-topic instance topic)))))
|
|
|
|
(defun discoursel--open-topic (&optional instance id)
|
|
(interactive)
|
|
(when (and (not (eq major-mode 'discoursel-mode))
|
|
(not id))
|
|
(user-error "You must be in a discoursel buffer"))
|
|
(let* ((instance-name (or instance
|
|
(get-text-property (point) 'discoursel-instance)
|
|
(user-error "You must select a topic to open")))
|
|
(instance-data (assoc instance-name discoursel-instances))
|
|
(topic-id (number-to-string
|
|
(or id (get-text-property (point) 'discoursel-topic-id))))
|
|
(topic (discoursel--get instance-data (concat "t/" topic-id)))
|
|
(posts (alist-get 'posts (alist-get 'post_stream topic)))
|
|
(first-post (aref posts 0))
|
|
(topic-slug (alist-get 'slug topic))
|
|
(topic-title (alist-get 'title topic))
|
|
(buf (discoursel-get-create-buffer topic-slug))
|
|
(number-of-pages (ceiling (/ (float (alist-get 'posts_count topic))
|
|
(float (alist-get 'chunk_size topic))))))
|
|
(switch-to-buffer buf)
|
|
(with-current-buffer buf
|
|
(discoursel-topic-mode)
|
|
(save-excursion
|
|
(let ((inhibit-read-only t))
|
|
(erase-buffer)
|
|
(discoursel--insert-post instance-data first-post topic-title)
|
|
(discoursel-render-posts-from-topic instance-data topic 1)
|
|
(when (> number-of-pages 1)
|
|
(if discoursel-fetch-all-posts-from-topic
|
|
(discoursel--fetch-all-posts-from-topic instance-data
|
|
topic-id
|
|
number-of-pages)
|
|
(message "TODO")))
|
|
(put-text-property (point-min) (point-max)
|
|
'discoursel-topic-id (string-to-number topic-id)))))))
|
|
|
|
(defun discoursel-reply-to-post (&optional arg)
|
|
(interactive "P")
|
|
(let* ((post-id (or (get-text-property (point) 'discoursel-post-id)
|
|
(user-error "You must choose a post to reply to")))
|
|
(instance (assoc (get-text-property (point) 'discoursel-instance)
|
|
discoursel-instances))
|
|
(buf (discoursel-get-create-buffer (number-to-string post-id)))
|
|
(original-topic-point (point))
|
|
(original-topic-buffer (current-buffer)))
|
|
(switch-to-buffer-other-window buf)
|
|
(with-current-buffer buf
|
|
(when arg
|
|
(let ((post-raw-contents
|
|
(alist-get 'raw
|
|
(discoursel--get instance (concat "posts/"
|
|
(number-to-string post-id)))))
|
|
(post-author-username (get-text-property original-topic-point
|
|
'discoursel-post-author-username
|
|
original-topic-buffer))
|
|
(post-number (get-text-property original-topic-point
|
|
'discoursel-post-number
|
|
original-topic-buffer))
|
|
(topic-id (get-text-property original-topic-point
|
|
'discoursel-topic-id
|
|
original-topic-buffer)))
|
|
(insert (format "[quote=\"%s, post:%d, topic:%d\"]\n"
|
|
post-author-username
|
|
post-number
|
|
topic-id))
|
|
(insert post-raw-contents)
|
|
(goto-char (point-min))
|
|
;; We can't quote the [quote...] tag.
|
|
(next-line)
|
|
(while (re-search-forward (rx line-start) nil t)
|
|
(replace-match "> " t t))
|
|
(goto-char (point-max))
|
|
(insert "\n\n")))
|
|
(discoursel-post-reply-mode))
|
|
(message "Type C-c C-c to post reply, C-c C-k to discard it")))
|
|
|
|
(defun discoursel-open-topic (instance id)
|
|
(interactive "nInstance: \nnTopic ID: ")
|
|
(discoursel--open-topic instance id))
|
|
|
|
(defun discoursel-get-create-buffer (&optional name)
|
|
(let* ((bufname (concat "*discoursel"
|
|
(when name (concat "-" name))
|
|
"*"))
|
|
(buf (get-buffer-create bufname)))
|
|
(prog1 buf
|
|
(unless (memq buf discoursel-buffer-list)
|
|
(add-to-list 'discoursel-buffer-list buf)))))
|
|
|
|
(defun discoursel-kill-buffer (&optional buf)
|
|
(interactive)
|
|
(let* ((tmpb (or buf (current-buffer)))
|
|
(b (get-buffer tmpb)))
|
|
(unless b
|
|
(error "Invalid buffer %s" b))
|
|
(with-current-buffer b
|
|
(unless (derived-mode-p 'discoursel-mode)
|
|
(error "Cannot kill buffer %s: not a discoursel buffer" (buffer-name))))
|
|
(kill-buffer b)
|
|
(setq discoursel-buffer-list (remove b discoursel-buffer-list))))
|
|
|
|
(defun discoursel-exit ()
|
|
(interactive)
|
|
(dolist (buf discoursel-buffer-list)
|
|
(kill-buffer buf))
|
|
(setq discoursel-buffer-list nil))
|
|
|
|
(defvar discoursel-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(prog1 map
|
|
(suppress-keymap map)
|
|
(define-key map "n" #'next-line)
|
|
(define-key map "p" #'previous-line)
|
|
(define-key map (kbd "RET") #'discoursel--open-topic)
|
|
(define-key map "j" #'discoursel-open-topic)
|
|
(define-key map (kbd "TAB") #'discoursel-toggle-heading)
|
|
(define-key map "q" #'discoursel-exit)
|
|
(define-key map "g" #'discoursel-update)))
|
|
"Keymap for `discoursel-mode'.")
|
|
|
|
(defvar discoursel-topic-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(prog1 map
|
|
(suppress-keymap map)
|
|
(define-key map "n" #'next-line)
|
|
(define-key map "p" #'previous-line)
|
|
(define-key map (kbd "M-n") #'discoursel-topic-next-entry)
|
|
(define-key map (kbd "M-p") #'discoursel-topic-previous-entry)
|
|
(define-key map (kbd "C-c C-r") #'discoursel-reply-to-post)
|
|
(define-key map "q" #'discoursel-kill-buffer)))
|
|
"Keymap for `discoursel-topic-mode'.")
|
|
|
|
(defvar discoursel-post-reply-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(prog1 map
|
|
(define-key map (kbd "C-c C-k") #'kill-buffer-and-window)))
|
|
"Keymap for `discoursel-post-reply-mode.")
|
|
|
|
(define-derived-mode discoursel-mode special-mode "Discourse client"
|
|
"Major mode for interacting with Discourse instances.
|
|
\\{discoursel-mode-map}"
|
|
(use-local-map discoursel-mode-map))
|
|
|
|
(define-derived-mode discoursel-topic-mode discoursel-mode "Discoursel topic"
|
|
"Major mode for interacting with Discourse topics.
|
|
\\{discoursel-topic-mode-map}"
|
|
(use-local-map discoursel-topic-mode-map))
|
|
|
|
(define-derived-mode discoursel-post-reply-mode markdown-mode "Discoursel post reply"
|
|
"Major mode for replying to Discourse posts.
|
|
\\{discoursel-post-reply-mode-map}"
|
|
(use-local-map discoursel-post-reply-mode-map))
|
|
|
|
(defun discoursel ()
|
|
"Enter discoursel."
|
|
(interactive)
|
|
(switch-to-buffer (discoursel-get-create-buffer))
|
|
(unless (eq major-mode 'discoursel-mode)
|
|
(discoursel-mode))
|
|
(setq buffer-invisibility-spec nil)
|
|
(discoursel-update))
|
|
|
|
|
|
;; TODO
|
|
;; (with-current-buffer (get-buffer-create "test-discourse")
|
|
;; (insert (plz 'get "https://discourse.ubuntu.com/raw/39765"))
|
|
;; (markdown-mode)
|
|
;; (setq buffer-read-only t))
|
|
|
|
;; (with-current-buffer (get-buffer-create "test-discourse4")
|
|
;; (let* ((ttt (plz 'get "https://discourse.ubuntu.com/latest.json" :as #'json-read))
|
|
;; (topics (alist-get 'topics (alist-get 'topic_list ttt)))
|
|
;; (users (alist-get 'users ttt)))
|
|
;; (cl-map 'vector
|
|
;; (lambda (topic)
|
|
;; (let* ((uid (alist-get 'user_id (aref (alist-get 'posters topic) 0)))
|
|
;; (user (seq-find (lambda (v) (= (alist-get 'id v) uid))
|
|
;; users)))
|
|
;; (insert
|
|
;; (propertize (format "%s [%s]\n" (alist-get 'title topic) (alist-get 'name user))
|
|
;; 'discoursel-slug (alist-get 'slug topic)))))
|
|
;; topics)))
|
|
|
|
|
|
|
|
(provide 'discoursel)
|
|
|
|
;;; discoursel.el ends here
|