fronde 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa9e00cb764be5f63bca69b6d11b338955a38c9c371b848e4bbe15b5f9c27a3e
-  data.tar.gz: ca6b276ee9fa2df53886ee26452ae3a3f80ac892d4e47ee67afdc4e7d6f0a54f
+  metadata.gz: 4f351a91fd7e7e674a9e7b3120725960cd36cc02a4c7d6d39715f760f4527b75
+  data.tar.gz: 4b371b41a1658aed730c2cb533bc8f68178d3a0d1ae791fb598aa7ab9eda5372
 SHA512:
-  metadata.gz: 657a9f2db5b42239358e92594377f3c2da9c0b2ae2aca2218e04108a462617fdb94e4ca4c71b43c4d236863126383471d699caae0d611c49196064d25c3439a8
-  data.tar.gz: 9a6db63382ac26264e1e6661d942693958137f0502fdc0616a2e7b6c86cace6a461d8dbb13b91fb219a973e7f021b21e9f35198df621299c7eff8424371f72fa
+  metadata.gz: bb1c612a0e6139a16ef798847579018494a171965e05b4535621906c4c488f62796fbbaa234b2b6566596335c47b9bce49d32d47eda772941ae8829e3ee2443f
+  data.tar.gz: 10b549865a13777b2e37e8beff967603b030d51bb7e3d7ea1bd664e2883d4b9c5c13271c1c6c718d8d6f6b8e70064ed5e032e81e7a84aecb70d3fc95e7480685

data/lib/fronde/cli/commands.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'shellwords'
 require_relative 'helpers'
 require_relative 'opt_parse'
 require_relative '../slug'
@@ -47,8 +48,7 @@ module Fronde
       end
 
       def fronde_open
-        editor = ENV['EDITOR'] || ENV['VISUAL'] || 'emacs'
-        cmd = [editor]
+        cmd = (ENV['EDITOR'] || ENV['VISUAL'] || 'emacs').shellsplit
         file_path = @argv.first || Dir.pwd
         unless File.file?(file_path)
           # file_path may be updated with title given in options
@@ -58,7 +58,7 @@ module Fronde
           cmd << '+6'
         end
         cmd << file_path
-        system(*cmd)
+        system(*cmd, exception: true)
       end
 
       def fronde_publish

data/lib/fronde/config/data/org-config.el

@@ -21,5 +21,5 @@
         ("website" :components ("{{ all_projects | map: 'name' | join: '" "' | remove: '" "tags' }}"))))
 
 ;; Load fronde lib
-(load-file (expand-file-name "ox-gmi.el" "{{ work_dir }}/lib"))
+(load-file (expand-file-name "ox-gmi.el" "{{ fronde_data_dir }}"))
 (load-file (expand-file-name "ox-fronde.el" "{{ fronde_data_dir }}"))

data/lib/fronde/config/data/ox-fronde.el

@@ -97,7 +97,7 @@ INFO is a plist used as a communication channel."
           output)
     (push `(?l . ,(org-export-data (plist-get info :language) info)) output)
     (push `(?n . ,(format "Fronde %s" fronde-version)) output)
-    (push `(?N . ,(format "<a href=\"https://etienne.depar.is/fronde/\">Fronde</a> %s" fronde-version)) output)
+    (push `(?N . ,(format "<a href=\"https://etienne.pflieger.bzh/fronde/\">Fronde</a> %s" fronde-version)) output)
     (push `(?x . ,(org-export-data (plist-get info :description) info)) output)
     (push `(?X . ,(format "<p>%s</p>"
                     (org-export-data (plist-get info :description) info)))

data/lib/fronde/config/data/ox-gmi.el

@@ -0,0 +1,654 @@
+;;; ox-gmi.el --- Gemini Back-End for Org Export Engine -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2020 Étienne Pflieger
+
+;; Author: Étienne Pflieger <etienne@pflieger.bzh>
+;; Created: 29 November 2020
+;; Version: 0.2
+;; Package-Requires: ((emacs "27.1"))
+;; Keywords: wp
+;; Homepage: https://git.umaneti.net/ox-gmi.el/
+
+;;; License:
+
+;; This file is not part of GNU Emacs.
+;; However, it is distributed under the same license.
+
+;; 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, 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 library implements a Gemini back-end for Org exporter, based on
+;; `markdown' back-end.  It also heavily depends on the `ascii' back-end.
+
+;;; Installation:
+
+;; Obviously, this package depends on `org-mode', which must be loaded first.
+
+;; You first need to download this file.  We recommend you to put it
+;; somewhere under your `user-emacs-directory' folder (often ~/.emacs.d).
+
+;; cd ~/.emacs.d
+;; curl -O https://git.umaneti.net/fronde/plain/lib/fronde/config/data/ox-gmi.el
+
+;; Then, you may want to compile it. You can do so with the Emacs command
+;; M-x byte-compile-file RET ~/.emacs.d/ox-gmi.el
+
+;; When it's done, you can add the following line in your GNU Emacs config
+;; file:
+;; (load-file "~/.emacs.d/ox-gmi.elc")
+
+;; And everything should be fine.
+
+
+;;; Code:
+
+(require 'ox-ascii)
+(require 'ox-publish)
+
+(declare-function gemini-mode "gemini")
+
+
+;;; Define Back-End
+
+(org-export-define-derived-backend 'gmi 'ascii
+  :menu-entry
+  '(?g "Export to Gemini"
+       ((?G "To temporary buffer"
+            (lambda (a s v b) (org-gmi-export-as-gemini a s v)))
+        (?g "To file"
+            (lambda (a s v b) (org-gmi-export-to-gemini a s v)))
+        (?o "To file and open"
+            (lambda (a s v b)
+              (if a (org-gmi-export-to-gemini t s v)
+                (org-open-file (org-gmi-export-to-gemini nil s v)))))))
+  :translate-alist '((center-block . org-gmi-center)
+                     (example-block . org-gmi-preformatted-block)
+                     (export-block . org-gmi-export-block)
+                     (fixed-width . org-gmi-preformatted-block)
+                     (footnote-reference . org-gmi-footnote-reference)
+                     (headline . org-gmi-headline)
+                     (inner-template . org-gmi-inner-template)
+                     (item . org-gmi-item)
+                     (keyword . org-gmi-keyword)
+                     (line-break . org-gmi-line-break)
+                     (link . org-gmi-link)
+                     (paragraph . org-gmi-paragraph)
+                     (quote-block . org-gmi-quote-block)
+                     (section . org-gmi-section)
+                     (src-block . org-gmi-preformatted-block)
+                     (template . org-gmi-template))
+  :options-alist '((:creator "CREATOR" nil org-gmi-creator-string)
+                   (:description "DESCRIPTION" nil nil parse)
+                   (:keywords "KEYWORDS" nil nil parse)
+                   (:subtitle "SUBTITLE" nil nil parse)
+                   (:gemini-postamble
+                    nil "gemini-postamble" org-gmi-postamble)
+                   (:gemini-timestamp-format
+                    nil nil org-gmi-timestamp-format)
+                   (:gemini-postamble-format
+                    nil nil org-gmi-postamble-format)))
+
+
+
+;;; Inner Variables
+
+(defvar org-gmi--links-in-section '()
+  "AList storing all links in current section.")
+
+
+
+;;; User Configuration Variables
+
+(defgroup org-export-gmi nil
+  "Options for exporting Org mode files to Gemini."
+  :tag "Org Export Gemini"
+  :group 'org-export)
+
+(defcustom org-gmi-postamble 't
+  "Non-nil means insert a postamble in Gemini export.
+
+When set to `auto', check against the
+`org-export-with-author/email/creator/date' variables to set the
+content of the postamble.  When set to a string, use this string
+as the postamble.  When t, insert a string as defined by the
+formatting string in `org-gmi-postamble-format'.
+
+When set to a function, apply this function and insert the
+returned string.  The function takes the property list of export
+options as its only argument.
+
+Setting :gemini-postamble in publishing projects will take
+precedence over this variable."
+  :group 'org-export-gmi
+  :type '(choice (const :tag "No postamble" nil)
+                 (const :tag "Auto postamble" auto)
+                 (const :tag "Default formatting string" t)
+                 (string :tag "Custom formatting string")
+                 (function :tag "Function (must return a string)")))
+
+(defcustom org-gmi-postamble-format
+  '(("en" "📝 %a with %c\n📅 %d")
+    ("fr" "📝 %a avec %c\n📅 %d"))
+  "Alist of languages and format strings for the Gemini postamble.
+
+The first element of each list is the language code, as used for
+the LANGUAGE keyword.  See `org-export-default-language'.
+
+The second element of each list is a format string to format the
+postamble itself.  This format string can contain these elements:
+
+  %t stands for the title.
+  %s stands for the subtitle.
+  %a stands for the author's name.
+  %e stands for the author's email.
+  %d stands for the date.
+  %k stands for the keywords list.
+  %l stands for the language code name.
+  %x stands for the description.
+  %c will be replaced by `org-gmi-creator-string'.
+  %T will be replaced by the export time.
+  %C will be replaced by the last modification time.
+
+If you need to use a \"%\" character, you need to escape it
+like that: \"%%\"."
+  :group 'org-export-gmi
+  :type '(repeat
+          (list (string :tag "Language")
+                (string :tag "Format string"))))
+
+(defcustom org-gmi-creator-string
+  (format "GNU/Emacs %s (Org mode %s)"
+          emacs-version
+          (if (fboundp 'org-version) (org-version) "unknown version"))
+  "Information about the creator of the Gemini document.
+This option can also be set on with the CREATOR keyword."
+  :group 'org-export-gmi
+  :type '(string :tag "Creator string"))
+
+(defcustom org-gmi-timestamp-format "%Y-%m-%d %a %H:%M"
+  "Format used for timestamps in postamble.
+See `format-time-string' for more information on its components."
+  :group 'org-export-gmi
+  :type 'string)
+
+
+
+;;; Inner Functions
+
+(defun org-gmi--build-headline (level title &optional tags)
+  "Generate a headline TITLE for the given LEVEL.
+TAGS are the tags set on the section."
+  (let ((level-mark (make-string level ?#)))
+    (concat level-mark " " title tags "\n\n")))
+
+(defun org-gmi--build-links-list (links)
+  "Return a string describing a list of links.
+LINKS is an alist like `org-gmi--links-in-section'"
+  (let (links-list)
+    (string-trim-right
+     (apply #'concat
+            (reverse
+             (dolist (link-data links links-list)
+               (push (apply #'org-gmi--format-link link-data)
+                     links-list)))))))
+
+(defun org-gmi--build-toc (info &optional depth)
+  "Return a table of contents.
+INFO is a plist used as a communication channel.
+Optional argument DEPTH, when non-nil, is an integer specifying the
+depth of the table."
+  (mapconcat
+   (lambda (headline)
+     (let* ((prefix
+             (if (not (org-export-numbered-headline-p headline info)) ""
+               (concat
+                (mapconcat 'number-to-string
+                           (org-export-get-headline-number headline info)
+                           ".")
+                ". ")))
+            (title (org-export-data-with-backend
+                    (org-export-get-alt-title headline info)
+                    (org-export-toc-entry-backend 'gmi)
+                    info))
+            (tags (and (plist-get info :with-tags)
+                       (not (eq 'not-in-toc (plist-get info :with-tags)))
+                       (org-make-tag-string
+                        (org-export-get-tags headline info)))))
+       (concat prefix title tags)))
+   (org-export-collect-headlines info depth) "\n"))
+
+(defun org-gmi--build-postamble (info)
+  "Return document postamble as a string, or nil.
+INFO is a plist used as a communication channel."
+  (let ((section (plist-get info :gemini-postamble))
+        (spec (org-gmi--format-spec info)))
+    (when section
+      (let ((section-contents
+             (if (functionp section) (funcall section info)
+               (cond
+                ((stringp section) (format-spec section spec))
+                ((eq section 'auto)
+                 (let ((date (cdr (assq ?d spec)))
+                       (author (cdr (assq ?a spec)))
+                       (email (cdr (assq ?e spec)))
+                       (creator (cdr (assq ?c spec))))
+                   (concat
+                    (and (plist-get info :with-date)
+                         (org-string-nw-p date)
+                         (format "📅 %s\n" date))
+                    (and (plist-get info :with-author)
+                         (org-string-nw-p author)
+                         (format "📝 %s\n" author))
+                    (and (plist-get info :with-email)
+                         (org-string-nw-p email)
+                         (format "💌 %s\n" email))
+                    (and (plist-get info :time-stamp-file)
+                         (format
+                          "🕓 %s\n"
+                          (format-time-string
+                           (plist-get info :gemini-timestamp-format))))
+                    (and (plist-get info :with-creator)
+                         (org-string-nw-p creator)
+                         (format "⚙ %s\n" creator)))))
+                (t
+                 (let ((formats (plist-get info :gemini-postamble-format))
+                       (language (plist-get info :language)))
+                   (format-spec
+                    (cadr (or (assoc-string language formats t)
+                              (assoc-string "en" formats t)))
+                    spec)))))))
+        (when (org-string-nw-p section-contents)
+          (format "\n\n--\n%s\n"
+                  (org-element-normalize-string section-contents)))))))
+
+(defun org-gmi--format-spec (info)
+  "Return format specification for postamble.
+INFO is a plist used as a communication channel."
+  (let ((timestamp-format (plist-get info :gemini-timestamp-format)))
+    `((?t . ,(org-export-data (plist-get info :title) info))
+      (?s . ,(org-export-data (plist-get info :subtitle) info))
+      (?d . ,(org-export-data (org-export-get-date info timestamp-format) info))
+      (?T . ,(format-time-string timestamp-format))
+      (?a . ,(org-export-data (plist-get info :author) info))
+      (?e . ,(org-export-data (plist-get info :email) info))
+      (?c . ,(plist-get info :creator))
+      (?C . ,(let ((file (plist-get info :input-file)))
+               (format-time-string
+                timestamp-format
+                (and file (file-attribute-modification-time
+                           (file-attributes file))))))
+      (?k . ,(org-export-data (plist-get info :keywords) info))
+      (?l . ,(org-export-data (plist-get info :language) info))
+      (?x . ,(org-export-data (plist-get info :description) info)))))
+
+(defun org-gmi--format-paragraph (paragraph &optional prefix)
+  "Transcode PARAGRAPH into Gemini format.
+If PREFIX is non-nil, add it at the beginning of each lines."
+  (replace-regexp-in-string
+   "^\\s-?" (or prefix "")
+   (org-trim
+    (replace-regexp-in-string "\r?\n\\([^\r\n]\\)" " \\1" paragraph))))
+
+(defun org-gmi--format-link (dest label &optional reference)
+  "Return a formatted link pointing to DEST with the given LABEL.
+
+When REFERENCE is given, it is added between bracket to generate single link
+entry in a links list."
+  (if reference
+      (format "=> %s [%d] %s\n" dest reference label)
+    (format "=> %s %s\n" dest label)))
+
+(defun org-gmi--link-alone-on-line-p (link)
+  "Return t if the given LINK occupies its whole line."
+  (let* ((link-start (org-element-property :begin link))
+         (link-end (org-element-property :end link))
+         (full-link (buffer-substring-no-properties link-start link-end))
+         (raw-link (org-element-property :raw-link link)))
+    (save-excursion
+      (org-goto-line (org-current-line link-start))
+      (let ((line-content (org-trim (thing-at-point 'line t))))
+        (or (string= raw-link line-content)
+            (string= full-link line-content))))))
+
+(defun org-gmi--extract-picture-label (link info)
+  "Extract a worthy label for the given LINK, when HREF points to a picture."
+  (let* ((paragraph (org-element-parent link))
+         (alt (plist-get
+               (org-export-read-attribute :attr_gmi paragraph)
+               :alt))
+         (caption (org-export-data (org-export-get-caption paragraph) info)))
+    (if (org-string-nw-p caption)
+        caption
+      alt)))
+
+(defun org-gmi--number-to-utf8-exponent (number)
+  "Convert a NUMBER to its utf8 exponent display."
+  (let ((exponents '((?1 . "¹")
+                     (?2 . "²")
+                     (?3 . "³")
+                     (?4 . "⁴")
+                     (?5 . "⁵")
+                     (?6 . "⁶")
+                     (?7 . "⁷")
+                     (?8 . "⁸")
+                     (?9 . "⁹")
+                     (?0 . "⁰"))))
+    (mapconcat
+     (lambda (digit) (cdr (assoc digit exponents)))
+     (number-to-string number)
+     "")))
+
+
+;;; Transcode Functions
+
+(defun org-gmi-preformatted-block (block _contents info)
+  "Transcode BLOCK element into Gemini format.
+INFO is a plist used as a communication channel."
+  (let ((language (org-export-data (org-element-property :language block) info))
+        (caption (org-export-data (org-export-get-caption block) info)))
+    (setq caption (if (org-string-nw-p caption)
+                      (format "%s - %s" language caption)
+                    language))
+    (format "```%s\n%s```\n"
+            caption
+            (org-remove-indentation
+             (org-export-format-code-default block info)))))
+
+(defun org-gmi-export-block (export-block _contents _info)
+  "Transcode a EXPORT-BLOCK element from Org to Gemini."
+  (if (member (org-element-property :type export-block) '("GEMINI" "GMI"))
+      (org-remove-indentation (org-element-property :value export-block))))
+
+(defun org-gmi-center (_center contents info)
+  "Transcode a CENTER block from Org to Gemini.
+CONTENTS is the block value.  INFO is a plist holding contextual
+information."
+  (format "```\n%s```"
+          (org-ascii--fill-string contents 80 info 'center)))
+
+(defun org-gmi-entity (_entity contents _info)
+  "Transcode an ENTITY object from Org to Gemini.
+CONTENTS is the entity itself."
+  contents)
+
+(defun org-gmi-footnote-reference (footnote-reference _contents info)
+  "Transcode a FOOTNOTE-REFERENCE element from Org to Gemini.
+CONTENTS is nil.  INFO is a plist holding contextual information."
+  (org-gmi--number-to-utf8-exponent
+   (org-export-get-footnote-number footnote-reference info)))
+
+(defun org-gmi-headline (headline contents info)
+  "Transcode HEADLINE element into Gemini format.
+CONTENTS is the headline value.  INFO is a plist used as
+a communication channel."
+  (let* ((level (1+ (org-export-get-relative-level headline info)))
+         (title (org-export-data (org-element-property :title headline) info))
+         (todo (and (plist-get info :with-todo-keywords)
+                    (let ((todo (org-element-property :todo-keyword
+                                                      headline)))
+                      (and todo (concat (org-export-data todo info) " ")))))
+         (tags (and (plist-get info :with-tags)
+                    (let ((tag-list (org-export-get-tags headline info)))
+                      (and tag-list
+                           (concat "     " (org-make-tag-string tag-list))))))
+         (priority
+          (and (plist-get info :with-priority)
+               (let ((char (org-element-property :priority headline)))
+                 (and char (format "[#%c] " char)))))
+         ;; Headline text without tags.
+         (heading (concat todo priority title)))
+    (if
+        ;; Cannot create a headline.  Fall-back to a list.
+        (or (org-export-low-level-p headline info)
+            (> level 3)) ;; Gemtext only allow 3 levels of title
+        (let ((bullet
+               (if (not (org-export-numbered-headline-p headline info)) "*"
+                 (concat (number-to-string
+                          (car (last (org-export-get-headline-number
+                                      headline info))))
+                         "."))))
+          (concat bullet (make-string (- 4 (length bullet)) ?\s)
+                  heading tags "\n\n" contents))
+      ;; Else
+      (concat (org-gmi--build-headline level heading tags) contents))))
+
+(defun org-gmi-inner-template (contents info)
+  "Return body of document after converting it to Gemini syntax.
+CONTENTS is the transcoded contents string.  INFO is a plist
+holding export options."
+  (concat
+   ;; Document contents.
+   contents
+   ;; Footnotes section.
+   (let ((definitions (org-export-collect-footnote-definitions info)))
+     (when definitions
+       (concat
+        "\n\n"
+        (org-gmi--build-headline
+         2 (org-ascii--translate "Footnotes" info))
+        (mapconcat
+         (lambda (ref)
+           (let ((id (car ref))
+                 (def (nth 2 ref)))
+             (format "%s %s" (org-gmi--number-to-utf8-exponent id)
+                     (replace-regexp-in-string
+                      "\r?\n" " "
+                      (org-trim (org-export-data def info))))))
+         definitions "\n\n"))))))
+
+(defun org-gmi-template (contents info)
+  "Return body of document after converting it to Gemini syntax.
+CONTENTS is the transcoded contents string.  INFO is a plist
+holding export options."
+  (concat
+   ;; Document title.
+   (org-gmi--build-headline
+    1 (org-export-data (plist-get info :title) info))
+   ;; TOC
+   (let* ((depth (plist-get info :with-toc))
+          (toc-contents (when depth
+                          (org-gmi--build-toc
+                           info (and (wholenump depth) depth)))))
+     (when (org-string-nw-p toc-contents)
+       (concat
+        (org-gmi--build-headline 2 (org-ascii--translate "Table of Contents" info))
+        toc-contents
+        "\n\n\n")))
+   ;; Document contents.
+   contents
+   ;; Postamble
+   (org-gmi--build-postamble info)))
+
+(defun org-gmi-item (item contents info)
+  "Transcode ITEM element into Gemini format.
+CONTENTS is the item value.  INFO is a plist used as a
+communication channel."
+  (let* ((type (org-element-property :type (org-export-get-parent item)))
+         (struct (org-element-property :structure item))
+         (bullet (if (not (eq type 'ordered)) "*"
+                   (concat (number-to-string
+                            (car (last (org-list-get-item-number
+                                        (org-element-property :begin item)
+                                        struct
+                                        (org-list-prevs-alist struct)
+                                        (org-list-parents-alist struct)))))
+                           "."))))
+    (concat bullet
+            " "
+            (pcase (org-element-property :checkbox item)
+              (`on "[X] ")
+              (`trans "[-] ")
+              (`off "[ ] "))
+            (let ((tag (org-element-property :tag item)))
+              (and tag (format "%s: " (org-export-data tag info))))
+            (and contents (org-trim contents)))))
+
+(defun org-gmi-keyword (keyword _contents _info)
+  "Transcode a KEYWORD element into Gemini format.
+CONTENTS is nil.  INFO is a plist used as a communication
+channel."
+  (when (member (org-element-property :key keyword) '("GEMINI" "GMI"))
+    (org-element-property :value keyword)))
+
+(defun org-gmi-line-break (_line-break _contents _info)
+  "Transcode LINE-BREAK object into Gemini format.
+CONTENTS is nil.  INFO is a plist used as a communication
+channel."
+  " ")
+
+(defun org-gmi-link (link desc info)
+  "Transcode a LINK object from Org to Gemini.
+DESC is the description part of the link, or the empty string."
+  (let ((link-type (org-element-property :type link))
+        (link-path (org-element-property :path link))
+        href lang)
+    ;; Cleanup path
+    (setq href
+          (if (member link-type '("file" "fuzzy"))
+              (if (string= ".org" (downcase (file-name-extension link-path ".")))
+                  ;; Replace local org file to gmi files during publication
+                  (format "%s.gmi" (file-name-sans-extension link-path))
+                link-path)
+            (org-element-property :raw-link link)))
+    (when (string= (substring href 0 5) "i18n:")
+      (pcase-let ((`(,path ,raw-lang) (split-string (substring href 5) "::")))
+        (setq href path lang raw-lang)))
+    (let* ((scheme (car (split-string href ":" t)))
+           ;; Avoid cut lines in link labels
+           (raw-label (replace-regexp-in-string "\r?\n" " " (or desc href)))
+           (label (if (and (not (member href (list desc scheme))) ;; relative link
+                           (not (member (downcase scheme)
+                                        '("gemini" "file"))))
+                      (format "%s (%s)" raw-label (upcase scheme))
+                    raw-label)))
+      (when lang (setq label (format "%s [%s]" label lang)))
+      ;; Handle pictures
+      (let* ((dest-ext (file-name-extension href))
+             (found-label
+              (when (and (not desc)
+                         (member (or (and dest-ext (downcase dest-ext)) "")
+                                 '("jpeg" "jpg" "png" "gif" "svg" "webp" "avif")))
+                (org-gmi--extract-picture-label link info))))
+        (when found-label (setq label found-label)))
+      ;; Do we need to add the link at the end of the section or should it be
+      ;; directly printed in its own line?
+      (if (org-gmi--link-alone-on-line-p link)
+          (org-gmi--format-link href label)
+        ;; As links are specific for a section, which should not be that long (?),
+        ;; we will always use the first label encountered for a link as
+        ;; reference.
+        (let ((link-data (assoc href org-gmi--links-in-section)))
+          (unless link-data
+            (setq link-data (list href label
+                                  ;; Default next-reference
+                                  (1+ (length org-gmi--links-in-section))))
+            (add-to-list 'org-gmi--links-in-section link-data t))
+          (format "%s[%d]" raw-label (caddr link-data)))))))
+
+(defun org-gmi-paragraph (_paragraph contents _info)
+  "Transcode PARAGRAPH element into Gemini format.
+CONTENTS is the paragraph value."
+  (org-gmi--format-paragraph contents))
+
+(defun org-gmi-quote-block (_quote-block contents _info)
+  "Transcode QUOTE-BLOCK element into Gemini format.
+CONTENTS is the quote-block value."
+  (org-gmi--format-paragraph contents "> "))
+
+(defun org-gmi-section (_section contents _info)
+  "Transcode SECTION into Gemini format.
+CONTENTS is the section value."
+  (let ((output
+         (format "%s\n%s"
+          contents
+          (org-gmi--build-links-list org-gmi--links-in-section))))
+    (setq org-gmi--links-in-section '()) ;; Reset link list
+    output))
+
+
+;;; Interactive function
+
+;;;###autoload
+(defun org-gmi-export-as-gemini (&optional async subtreep visible-only)
+  "Export current buffer to a Gemini buffer.
+
+If narrowing is active in the current buffer, only export its
+narrowed part.
+
+If a region is active, export that region.
+
+A non-nil optional argument ASYNC means the process should happen
+asynchronously.  The resulting buffer should be accessible
+through the `org-export-stack' interface.
+
+When optional argument SUBTREEP is non-nil, export the sub-tree
+at point, extracting information from the headline properties
+first.
+
+When optional argument VISIBLE-ONLY is non-nil, don't export
+contents of hidden elements.
+
+Export is done in a buffer named \"*Org Gemini Export*\", which will
+be displayed when `org-export-show-temporary-export-buffer' is
+non-nil."
+  (interactive)
+  (org-export-to-buffer
+    'gmi "*Org Gemini Export*"
+    async subtreep visible-only nil nil
+    (lambda ()
+      (if (featurep 'gemini-mode)
+          (gemini-mode)
+        (text-mode)))))
+
+;;;###autoload
+(defun org-gmi-export-to-gemini (&optional async subtreep visible-only)
+  "Export current buffer to a Gemini file.
+
+If narrowing is active in the current buffer, only export its
+narrowed part.
+
+If a region is active, export that region.
+
+A non-nil optional argument ASYNC means the process should happen
+asynchronously.  The resulting file should be accessible through
+the `org-export-stack' interface.
+
+When optional argument SUBTREEP is non-nil, export the sub-tree
+at point, extracting information from the headline properties
+first.
+
+When optional argument VISIBLE-ONLY is non-nil, don't export
+contents of hidden elements.
+
+Return output file's name."
+  (interactive)
+  (let ((outfile (org-export-output-file-name ".gmi" subtreep)))
+    (org-export-to-file 'gmi outfile async subtreep visible-only)))
+
+
+;;;###autoload
+(defun org-gmi-publish-to-gemini (plist filename pub-dir)
+  "Publish an org file to Gemini.
+
+FILENAME is the filename of the Org file to be published.  PLIST
+is the property list for the given project.  PUB-DIR is the
+publishing directory.
+
+Return output file name."
+  (org-publish-org-to 'gmi filename ".gmi" plist pub-dir))
+
+(provide 'ox-gmi)
+
+;;; ox-gmi.el ends here

data/lib/fronde/config/helpers.rb

@@ -59,4 +59,4 @@ module Fronde
   end
 end
 
-Liquid::Template.register_filter(Fronde::Config::Filters)
+Liquid::Environment.default.register_filter(Fronde::Config::Filters)

data/lib/fronde/config/lisp.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'open-uri'
 require_relative '../version'
 require_relative '../org'
 require_relative 'helpers'
@@ -11,6 +10,19 @@ module Fronde
     # This module contains utilitary methods to ease ~org-config.el~
     # file generation
     module Lisp
+      class << self
+        def theme_directory(theme)
+          # User theme first to allow overwriting
+          directory = File.expand_path("themes/#{theme}")
+          return directory if Dir.exist? directory
+
+          directory = File.expand_path("data/themes/#{theme}", __dir__)
+          return directory if Dir.exist? directory
+
+          raise Errno::ENOENT, "Theme #{theme} not found"
+        end
+      end
+
       # Generate emacs lisp configuration file for Org and write it.
       #
       # This method saves the generated configuration in the file
@@ -41,19 +53,8 @@ module Fronde
 
       private
 
-      def theme_directory(theme)
-        # User theme first to allow overwriting
-        directory = File.expand_path("themes/#{theme}")
-        return directory if Dir.exist? directory
-
-        directory = File.expand_path("data/themes/#{theme}", __dir__)
-        return directory if Dir.exist? directory
-
-        raise Errno::ENOENT, "Theme #{theme} not found"
-      end
-
       def org_theme_config(theme)
-        { 'base-directory' => theme_directory(theme),
+        { 'base-directory' => Lisp.theme_directory(theme),
           # rubocop:disable Layout/LineLength
           'base-extension' => %w[css js gif jpg png svg otf ttf woff2?].join('\\\\|'),
           'publishing-directory' => "#{get('html_public_folder')}/assets/#{theme}",

data/lib/fronde/index/atom_generator.rb

@@ -34,21 +34,16 @@ module Fronde
     # @param entries [Array] the article to list in this file
     # @return [String] the Atom feed as a String
     def atom_file(tag_name, entries)
-      domain = Fronde::CONFIG.get('domain')
       slug = Slug.slug(tag_name)
-      tagurl = "#{domain}#{@project.public_absolute_path}tags/#{slug}.html"
-      Config::Helpers.render_liquid_template(
-        File.read(File.expand_path('./data/template.xml', __dir__)),
+      variables = atom_templating_basics.merge(
         'title' => @tags_names[tag_name],
-        'lang' => Fronde::CONFIG.get('lang'),
-        'domain' => domain,
         'slug' => slug,
-        'tagurl' => tagurl,
-        'upddate' => @date.xmlschema,
-        'author' => Fronde::CONFIG.get('author'),
-        'publication_format' => @project['mime_type'],
         'entries' => entries
       )
+      Config::Helpers.render_liquid_template(
+        File.read(File.expand_path('./data/template.xml', __dir__)),
+        variables
+      )
     end
 
     # Render the main/index Atom feed.
@@ -56,19 +51,26 @@ module Fronde
     # @param entries [Array] the article to list in this file
     # @return [String] the Atom feed as a String
     def atom_index(entries)
-      domain = Fronde::CONFIG.get('domain')
+      variables = atom_templating_basics.merge(
+        'title' => @project['title'],
+        'slug' => '__HOME_PAGE__',
+        'entries' => entries
+      )
       Config::Helpers.render_liquid_template(
         File.read(File.expand_path('./data/template.xml', __dir__)),
-        'title' => @project['title'],
+        variables
+      )
+    end
+
+    def atom_templating_basics
+      {
         'lang' => Fronde::CONFIG.get('lang'),
-        'domain' => domain,
-        'slug' => 'index',
-        'tagurl' => domain,
-        'upddate' => @date.xmlschema,
         'author' => Fronde::CONFIG.get('author'),
-        'publication_format' => @project['mime_type'],
-        'entries' => entries
-      )
+        'domain' => Fronde::CONFIG.get('domain'),
+        'project_path' => @project.public_absolute_path,
+        'upddate' => @date.xmlschema,
+        'publication_format' => @project['mime_type']
+      }
     end
   end
 end

data/lib/fronde/index/data/template.xml

@@ -4,12 +4,17 @@
       xml:lang="{{ lang }}">
 
   <title>{{ title | escape }}</title>
-  <link href="{{ domain }}/feeds/{{ slug }}.xml" rel="self" type="application/atom+xml"/>
-  <link href="{{ tagurl }}" rel="alternate" type="text/html" title="{{ title }}"/>
+{%- if slug == "__HOME_PAGE__" %}
+  <link href="{{ domain }}{{ project_path }}feeds/index.xml" rel="self" type="application/atom+xml"/>
+  <link href="{{ domain }}" rel="alternate" type="text/html" title="{{ title | escape }}"/>
+{%- else %}
+  <link href="{{ domain }}{{ project_path }}feeds/{{ slug }}.xml" rel="self" type="application/atom+xml"/>
+  <link href="{{ domain }}{{ project_path }}tags/{{ slug }}.html" rel="alternate" type="text/html" title="{{ title | escape }}"/>
+{%- endif %}
   <updated>{{ upddate }}</updated>
   <author><name>{{ author }}</name></author>
   <id>urn:md5:{{ domain | md5 }}</id>
-  <generator uri="https://git.umaneti.net/fronde/about/">Fronde</generator>
+  <generator uri="https://git.umaneti.net/fronde">Fronde</generator>
 
   {%- for article in entries %}
 
@@ -17,7 +22,7 @@
     <title>{{ article.title | escape }}</title>
     <link href="{{ article.url }}" rel="alternate"
           type="{{ publication_format }}"
-          title="{{ article.title }}"/>
+          title="{{ article.title | escape }}"/>
     <id>urn:md5:{{ article.timekey | md5 }}</id>
     <published>{{ article.published_xml }}</published>
     <updated>{{ article.updated_xml }}</updated>

data/lib/fronde/org/file.rb

@@ -193,7 +193,7 @@ module Fronde
               .gsub('%l', @data[:lang])
               .gsub('%L', Fronde::CONFIG.get('license', '').gsub(/\s+/, ' ').strip)
               .gsub('%n', "Fronde #{Fronde::VERSION}")
-              .gsub('%N', "<a href=\"https://git.umaneti.net/fronde/about/\">Fronde</a> #{Fronde::VERSION}")
+              .gsub('%N', "<a href=\"https://git.umaneti.net/fronde\">Fronde</a> #{Fronde::VERSION}")
               .gsub('%o', project_data['theme'] || '')
               .gsub('%s', @data[:subtitle])
               .gsub('%t', @data[:title])

data/lib/fronde/org.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'net/http'
+require_relative 'version'
+
 module Fronde
   # Everything related to Org mode
   #
@@ -7,6 +10,8 @@ module Fronde
   # of the Emacs package. It also serves as a namespace for the class
   # responsible for handling Org files: {Fronde::Org::File}.
   module Org
+    CGIT_BASE_URL = 'https://cgit.git.savannah.gnu.org/cgit/emacs/org-mode.git/'
+
     class << self
       def current_version
         # Do not crash if Org is not yet installed (and thus return nil)
@@ -36,18 +41,26 @@ module Fronde
         org_version
       end
 
+      def http_get_client(uri)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+          request['User-Agent'] = Fronde::USER_AGENT
+          yield http, request
+        end
+      end
+
       def fetch_version_number
         # Retrieve last org version from git repository tags page.
         tag_rx = Regexp.new(
           '<a href=\'/cgit/emacs/org-mode.git/tag/\?h=' \
           '(?<tag>release_(?<number>[^\']+))\'>\k<tag></a>'
         )
-        versions = URI(
-          'https://git.savannah.gnu.org/cgit/emacs/org-mode.git/refs/'
-        ).open.readlines.map do |line|
+        uri = URI(CGIT_BASE_URL)
+        response = http_get_client(uri) { |http, req| http.request req }
+        versions = response.body.each_line(chomp: true).filter_map do |line|
           line.match(tag_rx) { |matchdata| matchdata[:number] }
         end
-        versions.compact.first
+        versions.compact.max_by { Gem::Version.new _1 }
       end
 
       # Download latest org-mode tarball.
@@ -57,10 +70,10 @@ module Fronde
       def download(destination = 'var/tmp')
         org_last_version = last_version(force: false, cookie_dir: destination)
         tarball = "org-mode-release_#{org_last_version}.tar.gz"
-        uri = URI("https://git.savannah.gnu.org/cgit/emacs/org-mode.git/snapshot/#{tarball}")
+        uri = URI("#{CGIT_BASE_URL}snapshot/#{tarball}")
         # Will crash on purpose if anything goes wrong
-        Net::HTTP.start(uri.host) do |http|
-          fetch_org_tarball http, Net::HTTP::Get.new(uri), destination
+        http_get_client(uri) do |http, request|
+          fetch_org_tarball http, request, destination
         end
         org_last_version
       end

data/lib/fronde/version.rb

@@ -2,5 +2,9 @@
 
 module Fronde
   # @return [String] the version number of the current Fronde release.
-  VERSION = '0.6.1'
+  VERSION = '0.6.3'
+
+  USER_AGENT = ["Fronde/#{Fronde::VERSION}",
+                "(#{RUBY_ENGINE} #{RUBY_VERSION} #{RUBY_PLATFORM})",
+                '(+https://etienne.pflieger.bzh/fronde/)'].join(' ').freeze
 end

data/lib/tasks/org.rake

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'open-uri'
-
 require_relative '../fronde/config'
 require_relative '../fronde/cli/throbber'
 
@@ -12,7 +10,6 @@ CLOBBER.push(
 )
 
 HTMLIZE_TAG = 'release/1.58'
-OX_GMI_TAG = 'v0.2'
 
 namespace :org do
   directory 'var/tmp'
@@ -57,20 +54,18 @@ namespace :org do
   directory 'lib'
 
   file 'lib/htmlize.el' => 'lib' do
-    htmlize = URI(
+    uri = URI(
       "https://raw.githubusercontent.com/hniksic/emacs-htmlize/refs/tags/#{HTMLIZE_TAG}/htmlize.el"
-    ).open.read
-    File.write 'lib/htmlize.el', htmlize
-  end
-
-  file 'lib/ox-gmi.el' => 'lib' do
-    ox_gmi = URI(
-      "https://git.umaneti.net/ox-gmi/plain/ox-gmi.el?h=#{OX_GMI_TAG}"
-    ).open.read
-    File.write 'lib/ox-gmi.el', ox_gmi
+    )
+    response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+      request = Net::HTTP::Get.new(uri)
+      request['User-Agent'] = Fronde::USER_AGENT
+      http.request request
+    end
+    File.write 'lib/htmlize.el', response.body
   end
 
-  file 'var/lib/org-config.el' => ['lib/htmlize.el', 'lib/ox-gmi.el'] do
+  file 'var/lib/org-config.el' => ['lib/htmlize.el'] do
     Fronde::CONFIG.write_org_lisp_config
   end
 
@@ -85,9 +80,9 @@ namespace :org do
 
   desc 'Install Org'
   multitask install: ['org:compile', '.gitignore'] do
-    # lib/htmlize.el and lib/ox-gmi.el cannot be generated in parallel
-    # of org:compilation, as it will leads to a weird SSL error. Thus
-    # finishing file generation "manually" here.
+    # lib/htmlize.el cannot be generated in parallel of org:compilation,
+    # as it will leads to a weird SSL error. Thus finishing file generation
+    # "manually" here.
     Rake::Task['var/lib/org-config.el'].invoke
     sources = Fronde::CONFIG.sources
     sources.each { mkdir_p _1['path'] }

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: fronde
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.6.3
 platform: ruby
 authors:
-- Étienne Deparis
-autorequire:
+- Étienne Pflieger
 bindir: bin
 cert_chain: []
-date: 2024-11-05 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -58,28 +57,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.5'
+        version: '5.8'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '1.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '1.18'
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -100,28 +99,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.1'
+        version: '13.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.1'
+        version: '13.2'
 - !ruby/object:Gem::Dependency
   name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.9'
 description: |
   Fronde helps you to convert Org mode files into websites, giving you
   full control over the publication process.
@@ -149,6 +148,7 @@ files:
 - lib/fronde/config.rb
 - lib/fronde/config/data/org-config.el
 - lib/fronde/config/data/ox-fronde.el
+- lib/fronde/config/data/ox-gmi.el
 - lib/fronde/config/data/themes/umaneti/css/htmlize.css
 - lib/fronde/config/data/themes/umaneti/css/style.css
 - lib/fronde/config/data/themes/umaneti/img/bottom.png
@@ -184,13 +184,13 @@ files:
 - lib/tasks/tags.rake
 - locales/en.yml
 - locales/fr.yml
-homepage: https://git.umaneti.net/fronde/about/
+homepage: https://etienne.pflieger.bzh/fronde/
 licenses:
 - WTFPL
 metadata:
   rubygems_mfa_required: 'true'
   source_code_uri: https://git.umaneti.net/fronde
-  homepage_uri: https://etienne.depar.is/fronde/
+  homepage_uri: https://etienne.pflieger.bzh/fronde/
   funding_uri: https://liberapay.com/milouse
 post_install_message: |+
   Start your first fronde project with:
@@ -217,8 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - emacs
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: An opinionated static website generator for Org
 test_files: []