-;;; elpher.el --- A friendly gopher client. -*- lexical-binding:t -*-
+;;; elpher.el --- A friendly gopher client -*- lexical-binding:t -*-
;; Copyright (C) 2019 Tim Vaughan
-;; Author: Tim Vaughan <tgvaughan@gmail.com>
+;; Author: Tim Vaughan <plugd@thelambdalab.xyz>
;; Created: 11 April 2019
-;; Version: 2.4.4
+;; Version: 2.7.4
;; Keywords: comm gopher
;; Homepage: http://thelambdalab.xyz/elpher
;; Package-Requires: ((emacs "26"))
;; - direct visualisation of image files,
;; - a simple bookmark management system,
;; - connections using TLS encryption,
-;; - support for the fledgling Gemini protocol.
+;; - the fledgling Gemini protocol,
+;; - the greybeard Finger protocol.
;; To launch Elpher, simply use 'M-x elpher'. This will open a start
;; page containing information on key bindings and suggested starting
(require 'url-util)
(require 'subr-x)
(require 'dns)
+(require 'ansi-color)
+(require 'nsm)
;;; Global constants
;;
-(defconst elpher-version "2.4.4"
+(defconst elpher-version "2.7.4"
"Current version of elpher.")
(defconst elpher-margin-width 6
"Width of left-hand margin used when rendering indicies.")
(defconst elpher-type-map
- '(((gopher ?0) elpher-get-gopher-node elpher-render-text "txt" elpher-text)
- ((gopher ?1) elpher-get-gopher-node elpher-render-index "/" elpher-index)
- ((gopher ?4) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?5) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?7) elpher-get-gopher-query-node elpher-render-index "?" elpher-search)
- ((gopher ?9) elpher-get-gopher-node elpher-render-download "bin" elpher-binary)
- ((gopher ?g) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?p) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?I) elpher-get-gopher-node elpher-render-image "img" elpher-image)
- ((gopher ?d) elpher-get-gopher-node elpher-render-download "doc" elpher-binary)
- ((gopher ?P) elpher-get-gopher-node elpher-render-download "doc" elpher-binary)
- ((gopher ?s) elpher-get-gopher-node elpher-render-download "snd" elpher-binary)
- ((gopher ?h) elpher-get-gopher-node elpher-render-html "htm" elpher-html)
- (gemini elpher-get-gemini-node elpher-render-gemini "gem" elpher-gemini)
- (telnet elpher-get-telnet-node nil "tel" elpher-telnet)
- (other-url elpher-get-other-url-node nil "url" elpher-other-url)
- ((special bookmarks) elpher-get-bookmarks-node nil "/" elpher-index)
- ((special start) elpher-get-start-node nil))
+ '(((gopher ?0) elpher-get-gopher-page elpher-render-text "txt" elpher-text)
+ ((gopher ?1) elpher-get-gopher-page elpher-render-index "/" elpher-index)
+ ((gopher ?4) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?5) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?7) elpher-get-gopher-query-page elpher-render-index "?" elpher-search)
+ ((gopher ?9) elpher-get-gopher-page elpher-render-download "bin" elpher-binary)
+ ((gopher ?g) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?p) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?I) elpher-get-gopher-page elpher-render-image "img" elpher-image)
+ ((gopher ?d) elpher-get-gopher-page elpher-render-download "doc" elpher-binary)
+ ((gopher ?P) elpher-get-gopher-page elpher-render-download "doc" elpher-binary)
+ ((gopher ?s) elpher-get-gopher-page elpher-render-download "snd" elpher-binary)
+ ((gopher ?h) elpher-get-gopher-page elpher-render-html "htm" elpher-html)
+ (gemini elpher-get-gemini-page elpher-render-gemini "gem" elpher-gemini)
+ (finger elpher-get-finger-page elpher-render-text "txt" elpher-text)
+ (telnet elpher-get-telnet-page nil "tel" elpher-telnet)
+ (other-url elpher-get-other-url-page nil "url" elpher-other-url)
+ ((special bookmarks) elpher-get-bookmarks-page nil "/" elpher-index)
+ ((special start) elpher-get-start-page nil))
"Association list from types to getters, renderers, margin codes and index faces.")
"A gopher client."
:group 'applications)
+;; General appearance and customizations
+
+(defcustom elpher-open-urls-with-eww nil
+ "If non-nil, open URL selectors using eww.
+Otherwise, use the system browser via the BROWSE-URL function."
+ :type '(boolean))
+
+(defcustom elpher-use-header t
+ "If non-nil, display current page information in buffer header."
+ :type '(boolean))
+
+(defcustom elpher-auto-disengage-TLS nil
+ "If non-nil, automatically disengage TLS following an unsuccessful connection.
+While enabling this may seem convenient, it is also potentially dangerous as it
+allows switching from an encrypted channel back to plain text without user input."
+ :type '(boolean))
+
+(defcustom elpher-connection-timeout 5
+ "Specifies the number of seconds to wait for a network connection to time out."
+ :type '(integer))
+
+(defcustom elpher-filter-ansi-from-text nil
+ "If non-nil, filter ANSI escape sequences from text.
+The default behaviour is to use the ansi-color package to interpret these
+sequences."
+ :type '(boolean))
+
+(defcustom elpher-gemini-TLS-cert-checks nil
+ "If non-nil, verify gemini server TLS certs using the default security level.
+Otherwise, certificate verification is disabled.
+
+This defaults to off because it is standard practice for Gemini servers
+to use self-signed certificates, meaning that most servers provide what
+EMACS considers to be an invalid certificate."
+ :type '(boolean))
+
+(defcustom elpher-gemini-max-fill-width 80
+ "Specify the maximum default width (in columns) of text/gemini documents.
+The actual width used is the minimum of this value and the window width at
+the time when the text is rendered."
+ :type '(integer))
+
+(defcustom elpher-bookmarks-file (locate-user-emacs-file "elpher-bookmarks")
+ "Specify the name of the file where elpher bookmarks will be saved."
+ :type '(file))
+
;; Face customizations
+(defgroup elpher-faces nil
+ "Elpher face customizations."
+ :group 'elpher)
+
(defface elpher-index
'((t :inherit font-lock-keyword-face))
"Face used for directory type directory records.")
(defface elpher-gemini
'((t :inherit font-lock-regexp-grouping-backslash))
- "Face used for html type directory records.")
+ "Face used for Gemini type directory records.")
(defface elpher-other-url
'((t :inherit font-lock-comment-face))
'((t :inherit shadow))
"Face used for brackets around directory margin key.")
-;; Other customizations
+(defface elpher-gemini-heading1
+ '((t :inherit bold :height 1.8))
+ "Face used for gemini heading level 1.")
-(defcustom elpher-open-urls-with-eww nil
- "If non-nil, open URL selectors using eww.
-Otherwise, use the system browser via the BROWSE-URL function."
- :type '(boolean))
-
-(defcustom elpher-buttonify-urls-in-directories t
- "If non-nil, turns URLs matched in directories into clickable buttons."
- :type '(boolean))
-
-(defcustom elpher-use-header t
- "If non-nil, display current node information in buffer header."
- :type '(boolean))
-
-(defcustom elpher-auto-disengage-TLS nil
- "If non-nil, automatically disengage TLS following an unsuccessful connection.
-While enabling this may seem convenient, it is also potentially dangerous as it
-allows switching from an encrypted channel back to plain text without user input."
- :type '(boolean))
+(defface elpher-gemini-heading2
+ '((t :inherit bold :height 1.5))
+ "Face used for gemini heading level 2.")
-(defcustom elpher-connection-timeout 5
- "Specifies the number of seconds to wait for a network connection to time out."
- :type '(integer))
+(defface elpher-gemini-heading3
+ '((t :inherit bold :height 1.2))
+ "Face used for gemini heading level 3.")
;;; 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)))
selector)))))
(defun elpher-make-special-address (type)
- "Create an ADDRESS object corresponding to the given special page symbol TYPE."
+ "Create an ADDRESS object corresponding to the given special address symbol TYPE."
type)
(defun elpher-address-to-url (address)
'gemini)
((equal protocol "telnet")
'telnet)
+ ((equal protocol "finger")
+ 'finger)
(t 'other-url)))))
(defun elpher-address-protocol (address)
"Retrieve host from ADDRESS object."
(url-host address))
+(defun elpher-address-user (address)
+ "Retrieve user from ADDRESS object."
+ (url-user address))
+
(defun elpher-address-port (address)
"Retrieve port from ADDRESS object.
If no address is defined, returns 0. (This is for compatibility with the URL library.)"
""
(substring (url-filename address) 2)))
-;; Node
-
-(defun elpher-make-node (display-string address &optional parent)
- "Create a node in the page hierarchy.
-
-DISPLAY-STRING records the display string used for the page.
-
-ADDRESS specifies the address object of the page.
-
-The optional PARENT specifies the parent node in the hierarchy.
-This is set every time the node is visited, so while it forms
-an important part of the node data there is no need to set it
-initially."
- (list display-string address parent))
-
-(defun elpher-node-display-string (node)
- "Retrieve the display string of NODE."
- (elt node 0))
-
-(defun elpher-node-address (node)
- "Retrieve the ADDRESS object of NODE."
- (elt node 1))
-
-(defun elpher-node-parent (node)
- "Retrieve the parent node of NODE."
- (elt node 2))
-
-(defun elpher-set-node-parent (node parent)
- "Set the parent node of NODE to be PARENT."
- (setcar (cdr (cdr node)) parent))
;; Cache
"Set the cursor position cache for ADDRESS to POS."
(puthash address pos elpher-pos-cache))
-;; Node graph traversal
-(defvar elpher-current-node nil)
+;; Page
+
+(defun elpher-make-page (display-string address)
+ "Create a page with DISPLAY-STRING and ADDRESS."
+ (list display-string address))
+
+(defun elpher-page-display-string (page)
+ "Retrieve the display string corresponding to PAGE."
+ (elt page 0))
-(defun elpher-visit-node (node &optional renderer preserve-parent)
- "Visit NODE using its own renderer or RENDERER, if non-nil.
-Additionally, set the parent of NODE to `elpher-current-node',
-unless PRESERVE-PARENT is non-nil."
+(defun elpher-page-address (page)
+ "Retrieve the address corresponding to PAGE."
+ (elt page 1))
+
+(defun elpher-page-set-address (page new-address)
+ "Set the address corresponding to PAGE to NEW-ADDRESS."
+ (setcar (cdr page) new-address))
+
+(defvar elpher-current-page nil)
+(defvar elpher-history nil)
+
+(defun elpher-visit-page (page &optional renderer no-history)
+ "Visit PAGE using its own renderer or RENDERER, if non-nil.
+Additionally, push PAGE onto the stack of previously-visited pages,
+unless NO-HISTORY is non-nil."
(elpher-save-pos)
(elpher-process-cleanup)
- (unless preserve-parent
- (if (and (elpher-node-parent elpher-current-node)
- (equal (elpher-node-address elpher-current-node)
- (elpher-node-address node)))
- (elpher-set-node-parent node (elpher-node-parent elpher-current-node))
- (elpher-set-node-parent node elpher-current-node)))
- (setq elpher-current-node node)
- (let* ((address (elpher-node-address node))
+ (unless (or no-history
+ (equal (elpher-page-address elpher-current-page)
+ (elpher-page-address page)))
+ (push elpher-current-page elpher-history))
+ (setq elpher-current-page page)
+ (let* ((address (elpher-page-address page))
(type (elpher-address-type address))
(type-record (cdr (assoc type elpher-type-map))))
(if type-record
(if renderer
renderer
(cadr type-record)))
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(pcase type
(`(gopher ,type-char)
(error "Unsupported gopher selector type '%c' for '%s'"
(error "Unsupported address type '%S' for '%s'"
other (elpher-address-to-url address)))))))
-(defun elpher-visit-parent-node ()
- "Visit the parent of the current node."
- (let ((parent-node (elpher-node-parent elpher-current-node)))
- (when parent-node
- (elpher-visit-node parent-node nil t))))
+(defun elpher-visit-previous-page ()
+ "Visit the previous page in the history."
+ (let ((previous-page (pop elpher-history)))
+ (if previous-page
+ (elpher-visit-page previous-page nil t)
+ (error "No previous page"))))
-(defun elpher-reload-current-node ()
- "Reload the current node, discarding any existing cached content."
- (elpher-cache-content (elpher-node-address elpher-current-node) nil)
- (elpher-visit-node elpher-current-node))
+(defun elpher-reload-current-page ()
+ "Reload the current page, discarding any existing cached content."
+ (elpher-cache-content (elpher-page-address elpher-current-page) nil)
+ (elpher-visit-page elpher-current-page))
(defun elpher-save-pos ()
- "Save the current position of point to the current node."
- (when elpher-current-node
- (elpher-cache-pos (elpher-node-address elpher-current-node) (point))))
+ "Save the current position of point to the current page."
+ (when elpher-current-page
+ (elpher-cache-pos (elpher-page-address elpher-current-page) (point))))
(defun elpher-restore-pos ()
- "Restore the position of point to that cached in the current node."
- (let ((pos (elpher-get-cached-pos (elpher-node-address elpher-current-node))))
+ "Restore the position of point to that cached in the current page."
+ (let ((pos (elpher-get-cached-pos (elpher-page-address elpher-current-page))))
(if pos
(goto-char pos)
(goto-char (point-min)))))
;;
(defun elpher-update-header ()
- "If `elpher-use-header' is true, display current node info in window header."
+ "If `elpher-use-header' is true, display current page info in window header."
(if elpher-use-header
- (let* ((display-string (elpher-node-display-string elpher-current-node))
- (address (elpher-node-address elpher-current-node))
+ (let* ((display-string (elpher-page-display-string elpher-current-page))
+ (address (elpher-page-address elpher-current-page))
(tls-string (if (and (not (elpher-address-special-p address))
(member (elpher-address-protocol address)
'("gophers" "gemini")))
(list 'with-current-buffer "*elpher*"
'(elpher-mode)
(append (list 'let '((inhibit-read-only t))
+ '(setq-local network-security-level
+ (default-value 'network-security-level))
'(erase-buffer)
'(elpher-update-header))
args)))
(let* ((kill-buffer-query-functions nil)
(port (elpher-address-port address))
(host (elpher-address-host address))
- (selector-string "")
+ (selector-string-parts nil)
+ (bytes-received 0)
+ (hkbytes-received 0)
(proc (open-network-stream "elpher-process"
nil
(if force-ipv4 (dns-query host) host)
(set-process-coding-system proc 'binary)
(set-process-filter proc
(lambda (_proc string)
- (cancel-timer timer)
- (setq selector-string
- (concat selector-string string))))
+ (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
(lambda (_proc event)
(condition-case the-error
(concat (elpher-gopher-address-selector address)
"\r\n"))))
(t
- (cancel-timer timer)
- (funcall renderer selector-string)
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
+ (funcall renderer (apply #'concat
+ (reverse selector-string-parts)))
(elpher-restore-pos)))
(error
(elpher-network-error address the-error))))))
(error
(error "Error initiating connection to server"))))
-(defun elpher-get-gopher-node (renderer)
- "Getter function for gopher nodes.
-The RENDERER procedure is used to display the contents of the node
+(defun elpher-get-gopher-page (renderer)
+ "Getter function for gopher pages.
+The RENDERER procedure is used to display the contents of the page
once they are retrieved from the gopher server."
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address)))
(if (and content (funcall renderer nil))
(elpher-with-clean-buffer
(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-node-button-help (node)
- "Return a string containing the help text for a button corresponding to NODE."
- (let ((address (elpher-node-address node)))
+(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)))))
(if type-map-entry
(let* ((margin-code (elt type-map-entry 2))
(face (elt type-map-entry 3))
- (node (elpher-make-node display-string address)))
+ (filtered-display-string (ansi-color-filter-apply display-string))
+ (page (elpher-make-page filtered-display-string address)))
(elpher-insert-margin margin-code)
- (insert-text-button display-string
+ (insert-text-button filtered-display-string
'face face
- 'elpher-node node
+ 'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-node-button-help node)))
+ 'help-echo (elpher-page-button-help page)))
(pcase type
- ((or '(gopher ?i) 'nil) ;; Information
+ ('nil ;; Information
(elpher-insert-margin)
(let ((propertized-display-string
(propertize display-string 'face 'elpher-info)))
- (insert (if elpher-buttonify-urls-in-directories
- (elpher-buttonify-urls propertized-display-string)
- propertized-display-string))))
+ (insert (elpher-process-text-for-display propertized-display-string))))
(`(gopher ,selector-type) ;; Unknown
(elpher-insert-margin (concat (char-to-string selector-type) "?"))
(insert (propertize display-string
(defun elpher-click-link (button)
"Function called when the gopher link BUTTON is activated (via mouse or keypress)."
- (let ((node (button-get button 'elpher-node)))
- (elpher-visit-node node)))
+ (let ((page (button-get button 'elpher-page)))
+ (elpher-visit-page page)))
(defun elpher-render-index (data &optional _mime-type-string)
"Render DATA as an index. MIME-TYPE-STRING is unused."
(if (not data)
t
(elpher-insert-index data)
- (elpher-cache-content (elpher-node-address elpher-current-node)
+ (elpher-cache-content (elpher-page-address elpher-current-page)
(buffer-string)))))
;; Text rendering
(defconst elpher-url-regex
- "\\([a-zA-Z]+\\)://\\([a-zA-Z0-9.\-]*[a-zA-Z0-9\-]\\|\[[a-zA-Z0-9:]+\]\\)\\(:[0-9]+\\)?\\(/\\([0-9a-zA-Z\-_~?/@|:.%#]*[0-9a-zA-Z\-_~?/@|#]\\)?\\)?"
- "Regexp used to locate and buttniofy URLs in text files loaded by elpher.")
+ "\\([a-zA-Z]+\\)://\\([a-zA-Z0-9.\-]*[a-zA-Z0-9\-]\\|\[[a-zA-Z0-9:]+\]\\)\\(:[0-9]+\\)?\\(/\\([0-9a-zA-Z\-_~?/@|:.%#=&]*[0-9a-zA-Z\-_~?/@|#]\\)?\\)?"
+ "Regexp used to locate and buttinofy URLs in text files loaded by elpher.")
(defun elpher-buttonify-urls (string)
"Turn substrings which look like urls in STRING into clickable buttons."
(insert string)
(goto-char (point-min))
(while (re-search-forward elpher-url-regex nil t)
- (let ((node (elpher-make-node (substring-no-properties (match-string 0))
+ (let ((page (elpher-make-page (substring-no-properties (match-string 0))
(elpher-address-from-url (match-string 0)))))
(make-text-button (match-beginning 0)
(match-end 0)
- 'elpher-node node
+ 'elpher-page page
'action #'elpher-click-link
'follow-link t
- 'help-echo (elpher-node-button-help node)
+ 'help-echo (elpher-page-button-help page)
'face 'button)))
(buffer-string)))
+(defconst elpher-ansi-regex "\x1b\\[[^m]*m"
+ "Wildly incomplete regexp used to strip out some troublesome ANSI escape sequences.")
+
+(defun elpher-process-text-for-display (string)
+ "Perform any desired processing of STRING prior to display as text.
+Currently includes buttonifying URLs and processing ANSI escape codes."
+ (elpher-buttonify-urls (if elpher-filter-ansi-from-text
+ (ansi-color-filter-apply string)
+ (ansi-color-apply string))))
+
(defun elpher-render-text (data &optional _mime-type-string)
"Render DATA as text. MIME-TYPE-STRING is unused."
(elpher-with-clean-buffer
(if (not data)
t
- (insert (elpher-buttonify-urls (elpher-preprocess-text-response data)))
+ (insert (elpher-process-text-for-display (elpher-preprocess-text-response data)))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string)))))
;; Image retrieval
;; Search retrieval and rendering
-(defun elpher-get-gopher-query-node (renderer)
+(defun elpher-get-gopher-query-page (renderer)
"Getter for gopher addresses requiring input.
The response is rendered using the rendering function RENDERER."
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address))
(aborted t))
(if (and content (funcall renderer nil))
(insert "LOADING RESULTS... (use 'u' to cancel)"))
(elpher-get-selector search-address renderer))
(if aborted
- (elpher-visit-parent-node))))))
+ (elpher-visit-previous-page))))))
;; Raw server response rendering
"Save DATA to file. MIME-TYPE-STRING is unused."
(if (not data)
nil
- (let* ((address (elpher-node-address elpher-current-node))
- (selector (elpher-gopher-address-selector address)))
- (elpher-visit-parent-node) ; Do first in case of non-local exits.
+ (let* ((address (elpher-page-address elpher-current-page))
+ (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: "
nil nil nil
(libxml-parse-html-region (point-min) (point-max)))))
(shr-insert-document dom)))))
-;; Gemini node retrieval
+;; Gemini page retrieval
(defvar elpher-gemini-redirect-chain)
"Retrieve gemini ADDRESS, then render using RENDERER.
If FORCE-IPV4 is non-nil, explicitly look up and use IPv4 address corresponding
to ADDRESS."
+ (unless elpher-gemini-TLS-cert-checks
+ (setq-local network-security-level 'low))
(if (not (gnutls-available-p))
(error "Cannot establish gemini connection: GnuTLS not available")
(unless (< (elpher-address-port address) 65536)
(let* ((kill-buffer-query-functions nil)
(port (elpher-address-port address))
(host (elpher-address-host address))
- (response-string "")
+ (response-string-parts nil)
+ (bytes-received 0)
+ (hkbytes-received 0)
(proc (open-network-stream "elpher-process"
nil
(if force-ipv4 (dns-query host) host)
(set-process-coding-system proc 'binary)
(set-process-filter proc
(lambda (_proc string)
- (cancel-timer timer)
- (setq response-string
- (concat response-string string))))
+ (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
(lambda (proc event)
(condition-case the-error
(concat (elpher-address-to-url address)
"\r\n"))))
((string-prefix-p "deleted" event)) ; do nothing
- ((and (string-empty-p response-string)
+ ((and (not response-string-parts)
(not force-ipv4))
; Try again with IPv4
(message "Connection failed. Retrying with IPv4.")
(elpher-get-gemini-response address renderer t))
(t
(funcall #'elpher-process-gemini-response
- response-string
+ (apply #'concat (reverse response-string-parts))
renderer)
(elpher-restore-pos)))
(error
- (elpher-network-error address the-error))))))
+ (elpher-network-error address the-error))))))
(error
(error "Error initiating connection to server")))))
(elpher-with-clean-buffer
(insert "Gemini server is requesting input."))
(let* ((query-string (read-string (concat response-meta ": ")))
- (url (elpher-address-to-url (elpher-node-address elpher-current-node)))
+ (url (elpher-address-to-url (elpher-page-address elpher-current-page)))
(query-address (elpher-address-from-url (concat url "?" query-string))))
(elpher-get-gemini-response query-address renderer)))
(?2 ; Normal response
"gemini"))
(error "Server tried to automatically redirect to non-gemini URL: %s"
response-meta))
+ (elpher-page-set-address elpher-current-page redirect-address)
(add-to-list 'elpher-gemini-redirect-chain redirect-address)
(elpher-get-gemini-response redirect-address renderer)))
(?4 ; Temporary failure
(error "Gemini server response unknown: %s %s"
response-code response-meta))))))
-(defun elpher-get-gemini-node (renderer)
- "Getter which retrieves and renders a Gemini node and renders it using RENDERER."
- (let* ((address (elpher-node-address elpher-current-node))
+(defun elpher-get-gemini-page (renderer)
+ "Getter which retrieves and renders a Gemini page and renders it using RENDERER."
+ (let* ((address (elpher-page-address elpher-current-page))
(content (elpher-get-cached-content address)))
(condition-case the-error
(if (and content (funcall renderer nil))
(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))))))
-
-(defun elpher-gemini-get-link-url (line)
- "Extract the url portion of LINE, a gemini map file link line."
- (string-trim (elt (split-string (substring line 2)) 0)))
-
-(defun elpher-gemini-get-link-display-string (line)
- "Extract the display string portion of LINE, a gemini map file link line."
- (let* ((rest (string-trim (elt (split-string line "=>") 1)))
+ (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.
+Returns nil in the event that the contents of the line following the
+=> prefix are empty."
+ (let ((l (split-string (substring link-line 2))))
+ (if l
+ (string-trim (elt l 0))
+ nil)))
+
+(defun elpher-gemini-get-link-display-string (link-line)
+ "Extract the display string portion of LINK-LINE, a gemini map file link line.
+Returns the url portion in the event that the display-string portion is empty."
+ (let* ((rest (string-trim (elt (split-string link-line "=>") 1)))
(idx (string-match "[ \t]" rest)))
- (if idx
- (string-trim (substring rest (+ idx 1)))
- "")))
+ (string-trim (if idx
+ (substring rest (+ idx 1))
+ rest))))
(defun elpher-collapse-dot-sequences (filename)
"Collapse dot sequences in FILENAME.
(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-node-address elpher-current-node)))
+ (setf (url-host address) (url-host (elpher-page-address elpher-current-page)))
(unless (string-prefix-p "/" (url-filename address)) ;deal with relative links
(setf (url-filename address)
(concat (file-name-directory
- (url-filename (elpher-node-address elpher-current-node)))
+ (url-filename (elpher-page-address elpher-current-page)))
(url-filename address)))))
(unless (url-type address)
(setf (url-type address) "gemini"))
(elpher-collapse-dot-sequences (url-filename address)))))
address))
+(defun elpher-gemini-insert-link (link-line)
+ "Insert link described by LINK-LINE into a text/gemini document."
+ (let* ((url (elpher-gemini-get-link-url link-line))
+ (display-string (elpher-gemini-get-link-display-string link-line))
+ (address (elpher-address-from-gemini-url url))
+ (type (if address (elpher-address-type address) nil))
+ (type-map-entry (cdr (assoc type elpher-type-map))))
+ (when display-string
+ (insert "→ ")
+ (if type-map-entry
+ (let* ((face (elt type-map-entry 3))
+ (filtered-display-string (ansi-color-filter-apply display-string))
+ (page (elpher-make-page filtered-display-string address)))
+ (insert-text-button filtered-display-string
+ 'face face
+ 'elpher-page page
+ 'action #'elpher-click-link
+ 'follow-link t
+ 'help-echo (elpher-page-button-help page)))
+ (insert (propertize display-string 'face 'elpher-unknown)))
+ (insert "\n"))))
+
+(defun elpher-gemini-insert-header (header-line)
+ "Insert header described by HEADER-LINE into a text/gemini document.
+The gemini map file line describing the header is given
+by HEADER-LINE."
+ (when (string-match "^\\(#+\\)[ \t]*" header-line)
+ (let ((level (length (match-string 1 header-line)))
+ (header (substring header-line (match-end 0))))
+ (unless (display-graphic-p)
+ (insert (make-string level ?#) " "))
+ (insert (propertize header 'face
+ (pcase level
+ (1 'elpher-gemini-heading1)
+ (2 'elpher-gemini-heading2)
+ (3 'elpher-gemini-heading3)
+ (_ 'default)))
+ "\n"))))
+
(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"))
- (if (string-prefix-p "=>" line)
- (let* ((url (elpher-gemini-get-link-url line))
- (display-string (elpher-gemini-get-link-display-string line))
- (address (elpher-address-from-gemini-url url)))
- (if (> (length display-string) 0)
- (elpher-insert-index-record display-string address)
- (elpher-insert-index-record url address)))
- (elpher-insert-index-record line)))
+ (let ((preformatted nil))
+ (auto-fill-mode 1)
+ (setq-local fill-column (min (window-width) elpher-gemini-max-fill-width))
+ (dolist (line (split-string data "\n"))
+ (cond
+ ((string-prefix-p "```" line) (setq preformatted (not preformatted)))
+ (preformatted (insert (elpher-process-text-for-display line) "\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)))))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string))))
(defun elpher-render-gemini-plain-text (data _parameters)
"Render DATA as plain text file. PARAMETERS is currently unused."
(elpher-with-clean-buffer
- (insert (elpher-buttonify-urls data))
+ (insert (elpher-process-text-for-display data))
(elpher-cache-content
- (elpher-node-address elpher-current-node)
+ (elpher-page-address elpher-current-page)
(buffer-string))))
-;; Other URL node opening
+;; Finger page connection
-(defun elpher-get-other-url-node (renderer)
- "Getter which attempts to open the URL specified by the current node (RENDERER must be nil)."
+(defun elpher-get-finger-page (renderer &optional force-ipv4)
+ "Opens a finger connection to the current page address and renders it using RENDERER."
+ (let* ((address (elpher-page-address elpher-current-page))
+ (content (elpher-get-cached-content address)))
+ (if (and content (funcall renderer nil))
+ (elpher-with-clean-buffer
+ (insert content)
+ (elpher-restore-pos))
+ (elpher-with-clean-buffer
+ (insert "LOADING... (use 'u' to cancel)\n"))
+ (condition-case the-error
+ (let* ((kill-buffer-query-functions nil)
+ (user (let ((filename (elpher-address-filename address)))
+ (if (> (length filename) 1)
+ (substring filename 1)
+ (elpher-address-user address))))
+ (port (let ((given-port (elpher-address-port address)))
+ (if (> given-port 0) given-port 79)))
+ (host (elpher-address-host address))
+ (selector-string-parts nil)
+ (proc (open-network-stream "elpher-process"
+ nil
+ (if force-ipv4 (dns-query host) host)
+ port
+ :type 'plain
+ :nowait t))
+ (timer (run-at-time elpher-connection-timeout
+ nil
+ (lambda ()
+ (pcase (process-status proc)
+ ('connect
+ (elpher-process-cleanup)
+ (unless 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)
+ (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
+ (cond
+ ((string-prefix-p "deleted" event))
+ ((string-prefix-p "open" event)
+ (let ((inhibit-eol-conversion t))
+ (process-send-string
+ proc
+ (concat user "\r\n"))))
+ (t
+ (when timer
+ (cancel-timer timer)
+ (setq timer nil))
+ (funcall renderer (apply #'concat
+ (reverse selector-string-parts)))
+ (elpher-restore-pos)))))))
+ (error
+ (elpher-network-error address the-error))))))
+
+
+;; Other URL page opening
+
+(defun elpher-get-other-url-page (renderer)
+ "Getter which attempts to open the URL specified by the current page (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for general URLs"))
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(url (elpher-address-to-url address)))
(progn
- (elpher-visit-parent-node) ; Do first in case of non-local exits.
+ (elpher-visit-previous-page) ; Do first in case of non-local exits.
(message "Opening URL...")
(if elpher-open-urls-with-eww
(browse-web url)
(browse-url url)))))
-;; Telnet node connection
+;; Telnet page connection
-(defun elpher-get-telnet-node (renderer)
- "Opens a telnet connection to the current node address (RENDERER must be nil)."
+(defun elpher-get-telnet-page (renderer)
+ "Opens a telnet connection to the current page address (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for telnet URLs"))
- (let* ((address (elpher-node-address elpher-current-node))
+ (let* ((address (elpher-page-address elpher-current-page))
(host (elpher-address-host address))
(port (elpher-address-port address)))
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(if (> port 0)
(telnet host port)
(telnet host))))
-;; Start page node retrieval
+;; Start page page retrieval
-(defun elpher-get-start-node (renderer)
+(defun elpher-get-start-page (renderer)
"Getter which displays the start page (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for start page"))
(elpher-with-clean-buffer
(insert " --------------------------------------------\n"
'face 'shadow))
(elpher-restore-pos)))
-;; Bookmarks page node retrieval
+;; Bookmarks page page retrieval
-(defun elpher-get-bookmarks-node (renderer)
+(defun elpher-get-bookmarks-page (renderer)
"Getter to load and display the current bookmark list (RENDERER must be nil)."
(when renderer
- (elpher-visit-parent-node)
+ (elpher-visit-previous-page)
(error "Command not supported for bookmarks page"))
(elpher-with-clean-buffer
(insert "---- Bookmark list ----\n\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)))
(interactive)
(push-button))
-(defun elpher-go ()
- "Go to a particular gopher site read from the minibuffer."
- (interactive)
- (let ((node
- (let ((host-or-url (read-string "Gopher or Gemini URL: ")))
- (elpher-make-node host-or-url
- (elpher-address-from-url host-or-url)))))
+(defun elpher-go (host-or-url)
+ "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))))
(switch-to-buffer "*elpher*")
- (elpher-visit-node node)))
+ (elpher-visit-page page)
+ '()))
(defun elpher-go-current ()
"Go to a particular site read from the minibuffer, initialized with the current URL."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page)))
(if (elpher-address-special-p address)
(error "Command invalid for this page")
(let ((url (read-string "Gopher or Gemini URL: " (elpher-address-to-url address))))
- (elpher-visit-node (elpher-make-node url (elpher-address-from-url url)))))))
+ (elpher-visit-page (elpher-make-page url (elpher-address-from-url url)))))))
(defun elpher-redraw ()
"Redraw current page."
(interactive)
- (if elpher-current-node
- (elpher-visit-node elpher-current-node)
- (message "No current site.")))
+ (elpher-visit-page elpher-current-page))
(defun elpher-reload ()
"Reload current page."
(interactive)
- (if elpher-current-node
- (elpher-reload-current-node)
- (message "No current site.")))
+ (elpher-reload-current-page))
(defun elpher-toggle-tls ()
"Toggle TLS encryption mode for gopher."
(defun elpher-view-raw ()
"View raw server response for current page."
(interactive)
- (if elpher-current-node
- (if (elpher-address-special-p (elpher-node-address elpher-current-node))
- (error "This page was not generated by a server")
- (elpher-visit-node elpher-current-node
- #'elpher-render-raw))
- (message "No current site.")))
+ (if (elpher-address-special-p (elpher-page-address elpher-current-page))
+ (error "This page was not generated by a server")
+ (elpher-visit-page elpher-current-page
+ #'elpher-render-raw)))
(defun elpher-back ()
"Go to previous site."
(interactive)
- (if (elpher-node-parent elpher-current-node)
- (elpher-visit-parent-node)
- (error "No previous site")))
+ (elpher-visit-previous-page))
(defun elpher-download ()
"Download the link at point."
(interactive)
(let ((button (button-at (point))))
(if button
- (let ((node (button-get button 'elpher-node)))
- (if (elpher-address-special-p (elpher-node-address node))
+ (let ((page (button-get button 'elpher-page)))
+ (if (elpher-address-special-p (elpher-page-address page))
(error "Cannot download %s"
- (elpher-node-display-string node))
- (elpher-visit-node (button-get button 'elpher-node)
+ (elpher-page-display-string page))
+ (elpher-visit-page (button-get button 'elpher-page)
#'elpher-render-download)))
(error "No link selected"))))
(defun elpher-download-current ()
"Download the current page."
(interactive)
- (if (elpher-address-special-p (elpher-node-address elpher-current-node))
+ (if (elpher-address-special-p (elpher-page-address elpher-current-page))
(error "Cannot download %s"
- (elpher-node-display-string elpher-current-node))
- (elpher-visit-node (elpher-make-node
- (elpher-node-display-string elpher-current-node)
- (elpher-node-address elpher-current-node)
- elpher-current-node)
+ (elpher-page-display-string elpher-current-page))
+ (elpher-visit-page (elpher-make-page
+ (elpher-page-display-string elpher-current-page)
+ (elpher-page-address elpher-current-page))
#'elpher-render-download
t)))
(defun elpher-build-link-map ()
- "Build alist mapping link names to destination nodes in current buffer."
+ "Build alist mapping link names to destination pages in current buffer."
(let ((link-map nil)
(b (next-button (point-min) t)))
(while b
(defun elpher-root-dir ()
"Visit root of current server."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page)))
(if (not (elpher-address-special-p address))
(if (or (member (url-filename address) '("/" ""))
(and (elpher-address-gopher-p address)
(let ((address-copy (elpher-address-from-url
(elpher-address-to-url address))))
(setf (url-filename address-copy) "")
- (elpher-visit-node
- (elpher-make-node (elpher-address-to-url address-copy)
- address-copy))))
- (error "Command invalid for %s" (elpher-node-display-string elpher-current-node)))))
+ (elpher-go (elpher-address-to-url address-copy))))
+ (error "Command invalid for %s" (elpher-page-display-string elpher-current-page)))))
(defun elpher-bookmarks-current-p ()
- "Return non-nil if current node is a bookmarks page."
- (equal (elpher-address-type (elpher-node-address elpher-current-node))
+ "Return non-nil if current page is a bookmarks page."
+ (equal (elpher-address-type (elpher-page-address elpher-current-page))
'(special bookmarks)))
(defun elpher-reload-bookmarks ()
- "Reload bookmarks if current node is a bookmarks page."
+ "Reload bookmarks if current page is a bookmarks page."
(if (elpher-bookmarks-current-p)
- (elpher-reload-current-node)))
+ (elpher-reload-current-page)))
(defun elpher-bookmark-current ()
- "Bookmark the current node."
+ "Bookmark the current page."
(interactive)
- (let ((address (elpher-node-address elpher-current-node))
- (display-string (elpher-node-display-string elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page))
+ (display-string (elpher-page-display-string elpher-current-page)))
(if (not (elpher-address-special-p address))
(let ((bookmark-display-string (read-string "Bookmark display string: "
display-string)))
(interactive)
(let ((button (button-at (point))))
(if button
- (let* ((node (button-get button 'elpher-node))
- (address (elpher-node-address node))
- (display-string (elpher-node-display-string node)))
+ (let* ((page (button-get button 'elpher-page))
+ (address (elpher-page-address page))
+ (display-string (elpher-page-display-string page)))
(if (not (elpher-address-special-p address))
(let ((bookmark-display-string (read-string "Bookmark display string: "
display-string)))
(error "No link selected"))))
(defun elpher-unbookmark-current ()
- "Remove bookmark for the current node."
+ "Remove bookmark for the current page."
(interactive)
- (let ((address (elpher-node-address elpher-current-node)))
+ (let ((address (elpher-page-address elpher-current-page)))
(unless (elpher-address-special-p address)
(elpher-remove-address-bookmark address)
(message "Bookmark removed."))))
(interactive)
(let ((button (button-at (point))))
(if button
- (let ((node (button-get button 'elpher-node)))
- (elpher-remove-address-bookmark (elpher-node-address node))
+ (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"))))
"Visit bookmarks page."
(interactive)
(switch-to-buffer "*elpher*")
- (elpher-visit-node
- (elpher-make-node "Bookmarks Page" (elpher-make-special-address 'bookmarks))))
+ (elpher-visit-page
+ (elpher-make-page "Bookmarks Page" (elpher-make-special-address 'bookmarks))))
-(defun elpher-info-node (node)
- "Display information on NODE."
- (let ((display-string (elpher-node-display-string node))
- (address (elpher-node-address node)))
+(defun elpher-info-page (page)
+ "Display information on PAGE."
+ (let ((display-string (elpher-page-display-string page))
+ (address (elpher-page-address page)))
(if (elpher-address-special-p address)
(message "Special page: %s" display-string)
(message "%s" (elpher-address-to-url address)))))
(defun elpher-info-link ()
- "Display information on node corresponding to link at point."
+ "Display information on page corresponding to link at point."
(interactive)
(let ((button (button-at (point))))
(if button
- (elpher-info-node (button-get button 'elpher-node))
+ (elpher-info-page (button-get button 'elpher-page))
(error "No item selected"))))
(defun elpher-info-current ()
- "Display information on current node."
+ "Display information on current page."
(interactive)
- (elpher-info-node elpher-current-node))
+ (elpher-info-page elpher-current-page))
-(defun elpher-copy-node-url (node)
- "Copy URL representation of address of NODE to `kill-ring'."
- (let ((address (elpher-node-address node)))
+(defun elpher-copy-page-url (page)
+ "Copy URL representation of address of PAGE to `kill-ring'."
+ (let ((address (elpher-page-address page)))
(if (elpher-address-special-p address)
- (error (format "Cannot represent %s as URL" (elpher-node-display-string node)))
+ (error (format "Cannot represent %s as URL" (elpher-page-display-string page)))
(let ((url (elpher-address-to-url address)))
(message "Copied \"%s\" to kill-ring/clipboard." url)
(kill-new url)))))
(interactive)
(let ((button (button-at (point))))
(if button
- (elpher-copy-node-url (button-get button 'elpher-node))
+ (elpher-copy-page-url (button-get button 'elpher-page))
(error "No item selected"))))
(defun elpher-copy-current-url ()
- "Copy URL of current node to `kill-ring'."
+ "Copy URL of current page to `kill-ring'."
(interactive)
- (elpher-copy-node-url elpher-current-node))
+ (elpher-copy-page-url elpher-current-page))
(defun elpher-set-gopher-coding-system ()
"Specify an explicit character coding system for gopher selectors."
(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 [mouse-3] 'elpher-back)
(define-key map (kbd "O") 'elpher-root-dir)
(if (get-buffer "*elpher*")
(switch-to-buffer "*elpher*")
(switch-to-buffer "*elpher*")
- (setq elpher-current-node nil)
- (let ((start-node (elpher-make-node "Elpher Start Page"
+ (setq elpher-current-page nil)
+ (let ((start-page (elpher-make-page "Elpher Start Page"
(elpher-make-special-address 'start))))
- (elpher-visit-node start-node)))
+ (elpher-visit-page start-page)))
"Started Elpher.") ; Otherwise (elpher) evaluates to start page string.
;;; elpher.el ends here
The Lambda Lab / projects / elpher.git / blobdiff