-;;; elpher.el --- A friendly gopher client -*- lexical-binding:t -*-
+;;; elpher.el --- A friendly gopher and gemini client -*- lexical-binding:t -*-
;; Copyright (C) 2019 Tim Vaughan
-;; Author: Tim Vaughan <timv@ughan.xyz>
+;; Author: Tim Vaughan <plugd@thelambdalab.xyz>
;; Created: 11 April 2019
-;; Version: 2.7.1
+;; Version: 2.7.9
;; Keywords: comm gopher
;; Homepage: http://thelambdalab.xyz/elpher
;; Package-Requires: ((emacs "26"))
;;; Commentary:
-;; Elpher aims to provide a practical and friendly gopher, gemini,
-;; and finger client for GNU Emacs. It supports:
+;; Elpher aims to provide a practical and friendly gopher and gemini
+;; client for GNU Emacs. It supports:
;; - intuitive keyboard and mouse-driven browsing,
;; - out-of-the-box compatibility with evil-mode,
;; - pleasant and configurable colouring of Gopher directories,
;; - direct visualisation of image files,
;; - a simple bookmark management system,
-;; - connections using TLS encryption,
+;; - gopher connections using TLS encryption,
;; - the fledgling Gemini protocol,
;; - the greybeard Finger protocol.
;;; Global constants
;;
-(defconst elpher-version "2.7.1"
+(defconst elpher-version "2.7.9"
"Current version of elpher.")
(defconst elpher-margin-width 6
the time when the text is rendered."
:type '(integer))
+(defcustom elpher-gemini-link-string "→ "
+ "Specify the string used to indicate links when rendering gemini maps.
+May be empty."
+ :type '(string))
+
+(defcustom elpher-gemini-bullet-string "•"
+ "Specify the string used for bullets when rendering gemini maps."
+ :type '(string))
+
+(defcustom elpher-bookmarks-file (locate-user-emacs-file "elpher-bookmarks")
+ "Specify the name of the file where elpher bookmarks will be saved."
+ :type '(file))
+
+(defcustom elpher-ipv4-always nil
+ "If non-nil, elpher will always use IPv4 to establish network connections.
+This can be useful when browsing from a computer that supports IPv6, because
+some servers which do not support IPv6 can take a long time to time-out."
+ :type '(boolean))
+
;; Face customizations
(defgroup elpher-faces nil
(defface elpher-gemini-heading1
'((t :inherit bold :height 1.8))
- "Face used for brackets around directory margin key.")
+ "Face used for gemini heading level 1.")
(defface elpher-gemini-heading2
'((t :inherit bold :height 1.5))
- "Face used for brackets around directory margin key.")
+ "Face used for gemini heading level 2.")
(defface elpher-gemini-heading3
'((t :inherit bold :height 1.2))
- "Face used for brackets around directory margin key.")
+ "Face used for gemini heading level 3.")
+
+(defface elpher-gemini-preformatted
+ '((t :inherit fixed-pitch))
+ "Face used for pre-formatted gemini text blocks.")
;;; Model
;;
If the optional attribute TLS is non-nil, the address will be marked as
requiring gopher-over-TLS."
(cond
+ ((equal type ?i) nil)
((and (equal type ?h)
(string-prefix-p "URL:" selector))
(elpher-address-from-url (elt (split-string selector "URL:") 1)))
(defun elpher-address-to-url (address)
"Get string representation of ADDRESS, or nil if ADDRESS is special."
- (if (not (elpher-address-special-p address))
- (url-encode-url (url-recreate-url address))
- nil))
+ (if (elpher-address-special-p address)
+ nil
+ (let* ((port (url-port address))
+ (address-to-convert
+ (if (= port 0)
+ address
+ (let ((address-copy (seq-copy address))
+ (protocol (url-type address)))
+ (if (or (and (equal protocol "gopher")
+ (= port 70))
+ (and (equal protocol "gemini")
+ (= port 1965))
+ (and (equal protocol "http")
+ (= port 80))
+ (and (equal protocol "finger")
+ (= port 79)))
+ (setf (url-port address-copy) 0))
+ address-copy))))
+ (url-encode-url (url-recreate-url address-to-convert)))))
(defun elpher-address-type (address)
"Retrieve type of ADDRESS object.
"Retrieve gopher selector from ADDRESS object."
(if (member (url-filename address) '("" "/"))
""
- (substring (url-filename address) 2)))
+ (url-unhex-string (substring (url-filename address) 2))))
;; Cache
(error "Cannot retrieve TLS gopher selector: GnuTLS not available")))
(unless (< (elpher-address-port address) 65536)
(error "Cannot retrieve gopher selector: port number > 65536"))
+ (defvar gnutls-verify-error)
(condition-case nil
(let* ((kill-buffer-query-functions nil)
+ (gnutls-verify-error nil) ; We use the NSM for verification
(port (elpher-address-port address))
(host (elpher-address-host address))
(selector-string-parts nil)
+ (bytes-received 0)
+ (hkbytes-received 0)
(proc (open-network-stream "elpher-process"
nil
- (if force-ipv4 (dns-query host) host)
+ (if (or elpher-ipv4-always force-ipv4)
+ (dns-query host)
+ host)
(if (> port 0) port 70)
:type (if elpher-use-tls 'tls 'plain)
:nowait t))
(elpher-network-error address "Could not establish encrypted connection")))
('connect
(elpher-process-cleanup)
- (unless force-ipv4
+ (unless (or elpher-ipv4-always force-ipv4)
(message "Connection timed out. Retrying with IPv4 address.")
(elpher-get-selector address renderer t))))))))
(setq elpher-network-timer timer)
(set-process-coding-system proc 'binary)
(set-process-filter proc
(lambda (_proc string)
- (cancel-timer timer)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
+ (setq bytes-received (+ bytes-received (length string)))
+ (let ((new-hkbytes-received (/ bytes-received 102400)))
+ (when (> new-hkbytes-received hkbytes-received)
+ (setq hkbytes-received new-hkbytes-received)
+ (with-current-buffer "*elpher*"
+ (let ((inhibit-read-only t))
+ (goto-char (point-min))
+ (beginning-of-line 2)
+ (delete-region (point) (point-max))
+ (insert "("
+ (number-to-string (/ hkbytes-received 10.0))
+ " MB read)")))))
(setq selector-string-parts
(cons string selector-string-parts))))
(set-process-sentinel proc
(concat (elpher-gopher-address-selector address)
"\r\n"))))
(t
- (cancel-timer timer)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
(funcall renderer (apply #'concat
(reverse selector-string-parts)))
(elpher-restore-pos)))
(insert content)
(elpher-restore-pos))
(elpher-with-clean-buffer
- (insert "LOADING... (use 'u' to cancel)"))
+ (insert "LOADING... (use 'u' to cancel)\n"))
(condition-case the-error
(elpher-get-selector address renderer)
(error
(insert " "))
(insert (make-string elpher-margin-width ?\s))))
-(defun elpher-page-button-help (page)
- "Return a string containing the help text for a button corresponding to PAGE."
- (let ((address (elpher-page-address page)))
- (format "mouse-1, RET: open '%s'" (if (elpher-address-special-p address)
- address
- (elpher-address-to-url address)))))
+(defun elpher--page-button-help (_window buffer pos)
+ "Function called by Emacs to generate mouse-over text.
+The arguments specify the BUFFER and the POS within the buffer of the item
+for which help is required. The function returns the help to be
+displayed. The _WINDOW argument is currently unused."
+ (with-current-buffer buffer
+ (let ((button (button-at pos)))
+ (when button
+ (let* ((page (button-get button 'elpher-page))
+ (address (elpher-page-address page)))
+ (format "mouse-1, RET: open '%s'" (if (elpher-address-special-p address)
+ address
+ (url-recreate-url address))))))))
(defun elpher-insert-index-record (display-string &optional address)
"Function to insert an index record into the current buffer.
'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-page-button-help page)))
+ 'help-echo #'elpher--page-button-help))
(pcase type
- ((or '(gopher ?i) 'nil) ;; Information
+ ('nil ;; Information
(elpher-insert-margin)
(let ((propertized-display-string
(propertize display-string 'face 'elpher-info)))
'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-page-button-help page)
+ 'help-echo #'elpher--page-button-help
'face 'button)))
(buffer-string)))
(if (not data)
nil
(let* ((address (elpher-page-address elpher-current-page))
- (selector (elpher-gopher-address-selector address)))
+ (selector (if (elpher-address-gopher-p address)
+ (elpher-gopher-address-selector address)
+ (elpher-address-filename address))))
(elpher-visit-previous-page) ; Do first in case of non-local exits.
(let* ((filename-proposal (file-name-nondirectory selector))
(filename (read-file-name "Download complete. Save file as: "
(error "Cannot establish gemini connection: GnuTLS not available")
(unless (< (elpher-address-port address) 65536)
(error "Cannot establish gemini connection: port number > 65536"))
+ (defvar gnutls-verify-error)
(condition-case nil
(let* ((kill-buffer-query-functions nil)
+ (gnutls-verify-error nil) ; We use the NSM for verification
(port (elpher-address-port address))
(host (elpher-address-host address))
(response-string-parts nil)
+ (bytes-received 0)
+ (hkbytes-received 0)
(proc (open-network-stream "elpher-process"
nil
- (if force-ipv4 (dns-query host) host)
+ (if (or elpher-ipv4-always force-ipv4)
+ (dns-query host)
+ host)
(if (> port 0) port 1965)
:type 'tls
:nowait t))
(timer (run-at-time elpher-connection-timeout nil
(lambda ()
(elpher-process-cleanup)
- (unless force-ipv4
+ (unless (or elpher-ipv4-always force-ipv4)
; Try again with IPv4
(message "Connection timed out. Retrying with IPv4.")
(elpher-get-gemini-response address renderer t))))))
(when timer
(cancel-timer timer)
(setq timer nil))
+ (setq bytes-received (+ bytes-received (length string)))
+ (let ((new-hkbytes-received (/ bytes-received 102400)))
+ (when (> new-hkbytes-received hkbytes-received)
+ (setq hkbytes-received new-hkbytes-received)
+ (with-current-buffer "*elpher*"
+ (let ((inhibit-read-only t))
+ (goto-char (point-min))
+ (beginning-of-line 2)
+ (delete-region (point) (point-max))
+ (insert "("
+ (number-to-string (/ hkbytes-received 10.0))
+ " MB read)")))))
(setq response-string-parts
(cons string response-string-parts))))
(set-process-sentinel proc
"\r\n"))))
((string-prefix-p "deleted" event)) ; do nothing
((and (not response-string-parts)
- (not force-ipv4))
+ (not (or elpher-ipv4-always force-ipv4)))
; Try again with IPv4
(message "Connection failed. Retrying with IPv4.")
(cancel-timer timer)
renderer)
(elpher-restore-pos)))
(error
- (elpher-network-error address the-error))))))
+ (elpher-network-error address the-error))))))
(error
(error "Error initiating connection to server")))))
(meta (string-trim (substring header 2))))
(list code meta body))
(error "Malformed response: No response status found in header %s" header)))
- (error "Malformed response: No CRLF-delimited header found"))))
+ (error "Malformed response: No CRLF-delimited header found in response %s" response))))
(defun elpher-process-gemini-response (response-string renderer)
"Process the gemini response RESPONSE-STRING and pass the result to RENDERER."
(insert content)
(elpher-restore-pos))
(elpher-with-clean-buffer
- (insert "LOADING GEMINI... (use 'u' to cancel)"))
+ (insert "LOADING GEMINI... (use 'u' to cancel)\n"))
(setq elpher-gemini-redirect-chain nil)
(elpher-get-gemini-response address renderer))
(error
((pred (string-prefix-p "image/"))
(elpher-render-image body))
(_other
- (error "Unsupported MIME type %S" mime-type))))))
+ (elpher-render-download body))))))
(defun elpher-gemini-get-link-url (link-line)
"Extract the url portion of LINK-LINE, a gemini map file link line.
(defun elpher-address-from-gemini-url (url)
"Extract address from URL with defaults as per gemini map files."
- (let ((address (url-generic-parse-url url)))
+ (let ((address (url-generic-parse-url url))
+ (current-address (elpher-page-address elpher-current-page)))
(unless (and (url-type address) (not (url-fullness address))) ;avoid mangling mailto: urls
(setf (url-fullness address) t)
(if (url-host address) ;if there is an explicit host, filenames are absolute
(if (string-empty-p (url-filename address))
(setf (url-filename address) "/")) ;ensure empty filename is marked as absolute
- (setf (url-host address) (url-host (elpher-page-address elpher-current-page)))
+ (setf (url-host address) (url-host current-address))
+ (setf (url-port address) (url-port current-address))
(unless (string-prefix-p "/" (url-filename address)) ;deal with relative links
(setf (url-filename address)
- (concat (file-name-directory
- (url-filename (elpher-page-address elpher-current-page)))
+ (concat (file-name-directory (url-filename current-address))
(url-filename address)))))
(unless (url-type address)
(setf (url-type address) "gemini"))
(type (if address (elpher-address-type address) nil))
(type-map-entry (cdr (assoc type elpher-type-map))))
(when display-string
- (insert "→ ")
+ (insert elpher-gemini-link-string)
(if type-map-entry
(let* ((face (elt type-map-entry 3))
(filtered-display-string (ansi-color-filter-apply display-string))
'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-page-button-help page)))
+ 'help-echo #'elpher--page-button-help))
(insert (propertize display-string 'face 'elpher-unknown)))
(insert "\n"))))
(_ 'default)))
"\n"))))
+(defun elpher-gemini-insert-text (text-line)
+ "Insert a plain non-preformatted TEXT-LINE into a text/gemini document.
+This function uses Emacs' auto-fill to wrap text sensibly to a maximum
+width defined by elpher-gemini-max-fill-width."
+ (string-match "\\(^[ \t]*\\)\\(\*[ \t]\\)?" text-line)
+ (let* ((processed-text-line (if (match-string 2 text-line)
+ (concat
+ (replace-regexp-in-string "\*"
+ elpher-gemini-bullet-string
+ (match-string 0 text-line))
+ (substring text-line (match-end 0)))
+ text-line))
+ (fill-prefix (if (match-string 1 text-line)
+ (replace-regexp-in-string "\*" " " (match-string 0 text-line))
+ nil)))
+ (insert (elpher-process-text-for-display processed-text-line))
+ (newline)))
+
(defun elpher-render-gemini-map (data _parameters)
"Render DATA as a gemini map file, PARAMETERS is currently unused."
(elpher-with-clean-buffer
(dolist (line (split-string data "\n"))
(cond
((string-prefix-p "```" line) (setq preformatted (not preformatted)))
- (preformatted (insert (elpher-process-text-for-display line) "\n"))
+ (preformatted (insert (elpher-process-text-for-display
+ (propertize line 'face 'elpher-gemini-preformatted))
+ "\n"))
((string-prefix-p "=>" line) (elpher-gemini-insert-link line))
((string-prefix-p "#" line) (elpher-gemini-insert-header line))
- (t (insert (elpher-process-text-for-display line)) (newline)))))
+ (t (elpher-gemini-insert-text line)))))
(elpher-cache-content
(elpher-page-address elpher-current-page)
(buffer-string))))
;; Finger page connection
(defun elpher-get-finger-page (renderer &optional force-ipv4)
- "Opens a finger connection to the current page address and renders it using RENDERER."
+ "Opens a finger connection to the current page address.
+The result is rendered using RENDERER. When the optional argument
+FORCE-IPV4 or the variable `elpher-ipv4-always' are non-nil, the
+IPv4 address returned by a DNS lookup will be used explicitly in
+making the connection."
(let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address)))
(if (and content (funcall renderer nil))
(insert content)
(elpher-restore-pos))
(elpher-with-clean-buffer
- (insert "LOADING... (use 'u' to cancel)"))
+ (insert "LOADING... (use 'u' to cancel)\n"))
(condition-case the-error
(let* ((kill-buffer-query-functions nil)
(user (let ((filename (elpher-address-filename address)))
(selector-string-parts nil)
(proc (open-network-stream "elpher-process"
nil
- (if force-ipv4 (dns-query host) host)
+ (if (or elpher-ipv4-always force-ipv4)
+ (dns-query host)
+ host)
port
:type 'plain
:nowait t))
(pcase (process-status proc)
('connect
(elpher-process-cleanup)
- (unless force-ipv4
+ (unless (or elpher-ipv4-always force-ipv4)
(message "Connection timed out. Retrying with IPv4 address.")
(elpher-get-finger-page renderer t))))))))
(setq elpher-network-timer timer)
(set-process-coding-system proc 'binary)
(set-process-filter proc
(lambda (_proc string)
- (cancel-timer timer)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
(setq selector-string-parts
(cons string selector-string-parts))))
(set-process-sentinel proc
(lambda (_proc event)
- (condition-case the-error
+ (condition-case _the-error
(cond
((string-prefix-p "deleted" event))
((string-prefix-p "open" event)
proc
(concat user "\r\n"))))
(t
- (cancel-timer timer)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
(funcall renderer (apply #'concat
(reverse selector-string-parts)))
(elpher-restore-pos)))))))
(error "Command not supported for start page"))
(elpher-with-clean-buffer
(insert " --------------------------------------------\n"
- " Elpher Gopher Client \n"
+ " Elpher Gopher and Gemini Client \n"
" version " elpher-version "\n"
" --------------------------------------------\n"
"\n"
" - TAB/Shift-TAB: next/prev item on current page\n"
" - RET/mouse-1: open item under cursor\n"
" - m: select an item on current page by name (autocompletes)\n"
- " - u/mouse-3: return to previous page\n"
+ " - u/mouse-3/U: return to previous page or to the start page\n"
" - o/O: visit different selector or the root menu of the current server\n"
" - g: go to a particular address (gopher, gemini, finger)\n"
" - d/D: download item under cursor or current page\n"
" - T: toggle TLS gopher mode\n"
" - .: display the raw server response for the current page\n"
"\n"
- "Start your exploration of gopher space:\n")
+ "Start your exploration of gopher space and gemini:\n")
(elpher-insert-index-record "Floodgap Systems Gopher Server"
(elpher-make-gopher-address ?1 "" "gopher.floodgap.com" 70))
+ (elpher-insert-index-record "Project Gemini home page"
+ (elpher-address-from-url "gemini://gemini.circumlunar.space/"))
(insert "\n"
"Alternatively, select a search engine and enter some search terms:\n")
- (elpher-insert-index-record "Veronica-2 Gopher Search Engine"
+ (elpher-insert-index-record "Gopher Search Engine (Veronica-2)"
(elpher-make-gopher-address ?7 "/v2/vs" "gopher.floodgap.com" 70))
- (elpher-insert-index-record "GUS Gemini Search Engine"
+ (elpher-insert-index-record "Gemini Search Engine (GUS)"
(elpher-address-from-url "gemini://gus.guru/search"))
(insert "\n"
"This page contains your bookmarked sites (also visit with B):\n")
"- a: rename selected bookmark\n"
"\n"
"Bookmarks are stored in the file ")
- (let ((filename (locate-user-emacs-file "elpher-bookmarks"))
+ (let ((filename elpher-bookmarks-file)
(help-string "RET,mouse-1: Open bookmarks file in new buffer for editing."))
(insert-text-button filename
'face 'link
(defun elpher-save-bookmarks (bookmarks)
"Record the bookmark list BOOKMARKS to the user's bookmark file.
Beware that this completely replaces the existing contents of the file."
- (with-temp-file (locate-user-emacs-file "elpher-bookmarks")
+ (with-temp-file elpher-bookmarks-file
(erase-buffer)
(insert "; Elpher bookmarks file\n\n"
"; Bookmarks are stored as a list of (label URL) items.\n"
(let ((bookmarks
(with-temp-buffer
(ignore-errors
- (insert-file-contents (locate-user-emacs-file "elpher-bookmarks"))
+ (insert-file-contents elpher-bookmarks-file)
(goto-char (point-min))
(read (current-buffer))))))
(if (and bookmarks (listp (cadar bookmarks)))
"Go to a particular gopher site HOST-OR-URL.
When run interactively HOST-OR-URL is read from the minibuffer."
(interactive "sGopher or Gemini URL: ")
- (let ((page (elpher-make-page host-or-url
- (elpher-address-from-url host-or-url))))
+ (let* ((cleaned-host-or-url (string-trim host-or-url))
+ (address (elpher-address-from-url cleaned-host-or-url))
+ (page (elpher-make-page cleaned-host-or-url address)))
(switch-to-buffer "*elpher*")
(elpher-visit-page page)
- '()))
+ nil))
(defun elpher-go-current ()
"Go to a particular site read from the minibuffer, initialized with the current URL."
(interactive)
(elpher-visit-previous-page))
+(defun elpher-back-to-start ()
+ "Go all the way back to the start page."
+ (interactive)
+ (setq elpher-current-page nil)
+ (setq elpher-history nil)
+ (let ((start-page (elpher-make-page "Elpher Start Page"
+ (elpher-make-special-address 'start))))
+ (elpher-visit-page start-page)))
+
(defun elpher-download ()
"Download the link at point."
(interactive)
"Remove bookmark for the current page."
(interactive)
(let ((address (elpher-page-address elpher-current-page)))
- (unless (elpher-address-special-p address)
+ (when (and (not (elpher-address-special-p address))
+ (y-or-n-p "Really remove bookmark for the current page? "))
(elpher-remove-address-bookmark address)
(message "Bookmark removed."))))
(interactive)
(let ((button (button-at (point))))
(if button
- (let ((page (button-get button 'elpher-page)))
- (elpher-remove-address-bookmark (elpher-page-address page))
- (elpher-reload-bookmarks)
- (message "Bookmark removed."))
+ (when (y-or-n-p "Really remove bookmark for this link? ")
+ (let ((page (button-get button 'elpher-page)))
+ (elpher-remove-address-bookmark (elpher-page-address page))
+ (elpher-reload-bookmarks)
+ (message "Bookmark removed.")))
(error "No link selected"))))
(defun elpher-bookmarks ()
(let ((map (make-sparse-keymap)))
(define-key map (kbd "TAB") 'elpher-next-link)
(define-key map (kbd "<backtab>") 'elpher-prev-link)
+ (define-key map (kbd "C-M-i") 'elpher-prev-link)
(define-key map (kbd "u") 'elpher-back)
+ (define-key map (kbd "U") 'elpher-back-to-start)
(define-key map [mouse-3] 'elpher-back)
(define-key map (kbd "O") 'elpher-root-dir)
(define-key map (kbd "g") 'elpher-go)
(kbd "C-") 'elpher-follow-current-link
(kbd "C-t") 'elpher-back
(kbd "u") 'elpher-back
+ (kbd "U") 'elpher-back-to-start
[mouse-3] 'elpher-back
(kbd "g") 'elpher-go
(kbd "o") 'elpher-go-current
(switch-to-buffer "*elpher*")
(switch-to-buffer "*elpher*")
(setq elpher-current-page nil)
+ (setq elpher-history nil)
(let ((start-page (elpher-make-page "Elpher Start Page"
(elpher-make-special-address 'start))))
(elpher-visit-page start-page)))
The Lambda Lab / projects / elpher.git / blobdiff