fronde 0.3.0

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

@@ -0,0 +1,17 @@
+;; Add org-mode to load path
+(add-to-list 'load-path (expand-file-name "org-__ORG_VER__/lisp" "__WORK_DIR__/lib"))
+;; Load last version of htmlize.el
+(load-file (expand-file-name "htmlize.el" "__WORK_DIR__/lib"))
+
+;; Current project options
+(setq fronde/version "__VERSION__"
+      fronde/current-work-dir "__WORK_DIR__"
+      user-mail-address "__AUTHOR_EMAIL__"
+      user-full-name "__AUTHOR_NAME__"
+      org-html-metadata-timestamp-format "__LONG_DATE_FMT__"
+      org-publish-project-alist
+      `(__ALL_PROJECTS____THEME_CONFIG__
+        ("website" :components (__ALL_PROJECTS_NAMES__))))
+
+;; Load fronde lib
+(load-file (expand-file-name "ox-fronde.el" "__FRONDE_DIR__"))

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

@@ -0,0 +1,114 @@
+;;; ox-fronde.el --- Fronde Gem specific helpers for Org Export Engine -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2011-2019 Free Software Foundation, Inc.
+
+;; Author: Étienne Deparis <etienne at depar dot is>
+;; Keywords: org, export
+
+;; This file is not part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This library implements specific helpers function, needed by the Ruby
+;; Gem Fronde, which offers an easy way to publish a static website
+;; using Org files as sources.
+
+;;; Code:
+
+(require 'org)
+(require 'ox-html)
+
+;;; Function Declarations
+
+(defvar fronde/version ""
+  "Version of the current fronde installation")
+
+(defvar fronde/current-work-dir nil
+  "Location of the current fronde website base directory.")
+
+(defvar fronde/org-temp-dir nil
+  "Location of the local Org temporary directory (where to place
+org timestamps and id locations).")
+
+(defun fronde/org-html-format-spec (upstream info)
+  "Return format specification for preamble and postamble.
+INFO is a plist used as a communication channel."
+  (let ((output (funcall upstream info)))
+    (push `(?A . ,(format "<span class=\"author\">%s</span>"
+                    (org-export-data (plist-get info :author) info)))
+      output)
+    (push `(?k . ,(org-export-data (plist-get info :keywords) info)) output)
+    (push `(?K . ,(format "<ul class=\"keywords-list\">%s</ul>"
+                    (mapconcat
+	                    (lambda (k) (format "<li class=\"keyword\">%s</li>" k))
+	                    (split-string (or (plist-get info :keywords) "")  ",+ *")
+	                    "\n")))
+      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://git.umaneti.net/fronde/about/\">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)))
+      output)))
+
+(defun fronde/org-i18n-export (link description format)
+  "Export a i18n link"
+  (let* ((splitted-link (split-string link "|"))
+         (path (car splitted-link))
+         (desc (or description path))
+         (lang (cadr splitted-link)))
+    (pcase format
+      (`html (if lang
+                 (format "<a href=\"%s\" hreflang=\"%s\">%s</a>"
+                         path lang desc)
+               (format "<a href=\"%s\">%s</a>" path desc)))
+      (`latex (format "\\href{%s}{%s}" path desc))
+      (`ascii (format "%s (%s)" desc path))
+      (_ path))))
+
+(defun fronde/org-i18n-follow (link)
+  "Visit a i18n link"
+  (browse-url (car (split-string link "|"))))
+
+(org-link-set-parameters "i18n"
+  :export #'fronde/org-i18n-export
+  :follow #'fronde/org-i18n-follow)
+
+
+;;; Set configuration options
+
+(setq fronde/org-temp-dir (expand-file-name "var/tmp" fronde/current-work-dir)
+      org-publish-timestamp-directory (expand-file-name "timestamps/" fronde/org-temp-dir)
+      org-id-locations-file (expand-file-name "id-locations.el" fronde/org-temp-dir)
+      make-backup-files nil
+      enable-local-variables :all
+      org-confirm-babel-evaluate nil
+      org-export-with-broken-links t
+      org-html-doctype "html5"
+      org-html-html5-fancy t
+      org-html-htmlize-output-type 'css
+      org-html-text-markup-alist '((bold . "<strong>%s</strong>")
+                                    (code . "<code>%s</code>")
+                                    (italic . "<em>%s</em>")
+                                    (strike-through . "<del>%s</del>")
+                                    (underline . "<span class=\"underline\">%s</span>")
+                                    (verbatim . "<code>%s</code>")))
+(advice-add 'org-html-format-spec :around #'fronde/org-html-format-spec)
+
+(provide 'ox-fronde)
+
+;;; ox-fronde.el ends here

data/lib/fronde/emacs.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'fronde/config'
+
+module Fronde
+  # Wraps Gnu/Emacs calls
+  class Emacs
+    def initialize(file_path: nil, verbose: false)
+      @file = file_path
+      @verbose = verbose
+    end
+
+    def publish
+      command = emacs_command(
+        '-l ./var/lib/org-config.el', '--eval \'(org-publish "website")\''
+      )
+      if @verbose
+        warn command
+        return system(command, exception: true)
+      end
+      system command, out: '/dev/null', err: '/dev/null', exception: true
+    end
+
+    private
+
+    def emacs_command(*arguments)
+      default_emacs = Fronde::Config.settings['emacs']
+      emacs_cmd = [
+        default_emacs || 'emacs -Q --batch -nw',
+        '--eval \'(setq enable-dir-local-variables nil)\''
+      ]
+      emacs_cmd << '--eval \'(setq inhibit-message t)\'' unless @verbose
+      emacs_cmd.concat(arguments)
+      emacs_cmd.join(' ')
+    end
+  end
+end

data/lib/fronde/index.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'digest/md5'
+require 'fronde/config'
+require 'fronde/org_file'
+require 'fronde/index/atom_generator'
+require 'fronde/index/org_generator'
+
+module Fronde
+  # Generates website indexes and atom feeds for all the org documents
+  #   keywords.
+  class Index
+    attr_reader :date
+
+    include Fronde::IndexAtomGenerator
+    include Fronde::IndexOrgGenerator
+
+    def initialize
+      @pubdir = Fronde::Config.settings['public_folder']
+      @index = { 'index' => [] }
+      @projects = {}
+      @tags_names = {}
+      @date = DateTime.now
+      feed
+      sort!
+    end
+
+    def entries
+      @index.keys.reject { |k| k == 'index' }
+    end
+
+    def empty?
+      @index['index'].empty?
+    end
+
+    def write_all(verbose: true)
+      @index.each_key do |k|
+        write_org(k)
+        warn "Generated index file for #{k}" if verbose
+        write_atom(k)
+        warn "Generated atom feed for #{k}" if verbose
+      end
+      write_all_blog_home(verbose)
+    end
+
+    def sort_by(kind)
+      if [:name, :weight].include?(kind)
+        tags_sorted = sort_tags_by_name_and_weight["by_#{kind}".to_sym]
+        # Reverse in order to have most important or A near next prompt
+        # and avoid to scroll to find the beginning of the list.
+        return tags_sorted.map do |k|
+          @tags_names[k] + " (#{@index[k].length})"
+        end.reverse
+      end
+      raise ArgumentError, "#{kind} not in [:name, :weight]"
+    end
+
+    private
+
+    def feed
+      Fronde::Config.sources.each do |project|
+        next unless project['is_blog']
+        if project['recursive']
+          file_pattern = '**/*.org'
+        else
+          file_pattern = '*.org'
+        end
+        Dir.glob(file_pattern, base: project['path']).map do |s|
+          org_file = File.join(project['path'], s)
+          next if exclude_file?(org_file, project)
+          add_to_indexes(
+            Fronde::OrgFile.new(org_file, project: project)
+          )
+        end
+      end
+    end
+
+    def add_to_project_index(article)
+      project = article.project
+      @projects[project['name']] ||= []
+      @projects[project['name']] << article
+    end
+
+    def add_to_indexes(article)
+      @index['index'] << article
+      add_to_project_index article
+      article.keywords.each do |k|
+        slug = Fronde::OrgFile.slug k
+        @tags_names[slug] = k # Overwrite is permitted
+        @index[slug] ||= []
+        @index[slug] << article
+      end
+    end
+
+    def sort!
+      @index.each do |k, i|
+        @index[k] = i.sort { |a, b| b.timekey <=> a.timekey }
+      end
+      @projects.each do |k, i|
+        @projects[k] = i.sort { |a, b| b.timekey <=> a.timekey }
+      end
+    end
+
+    def sort_tags_by_name_and_weight
+      tags_sorted = {}
+      all_keys = entries
+      tags_sorted[:by_name] = all_keys.sort
+      tags_sorted[:by_weight] = all_keys.sort do |a, b|
+        @index[b].length <=> @index[a].length
+      end
+      tags_sorted
+    end
+
+    def exclude_file?(file_path, project)
+      # Obviously excluding index itself for blogs
+      return true if file_path == File.join(project['path'], 'index.org')
+      return false unless project['exclude']
+      file_path.match? project['exclude']
+    end
+
+    def save?
+      return true unless empty?
+      Fronde::Config.sources.each do |project|
+        return true if project['is_blog'] && Dir.exist?(project['path'])
+      end
+      false
+    end
+  end
+end

data/lib/fronde/index/atom_generator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'fronde/config'
+
+module Fronde
+  # Embeds Atom feeds sepecific methods
+  module IndexAtomGenerator
+    def to_atom(index_name = 'index')
+      content = [atom_header(index_name)]
+      @index[index_name][0...10].each do |article|
+        content << atom_entry(article)
+      end
+      format '%<content>s</feed>', content: content.join("\n")
+    end
+
+    def write_atom(index_name)
+      return unless save?
+      slug = Fronde::OrgFile.slug index_name
+      FileUtils.mkdir_p "#{@pubdir}/feeds"
+      atomdest = "#{@pubdir}/feeds/#{slug}.xml"
+      IO.write(atomdest, to_atom(index_name))
+    end
+
+    private
+
+    # Render the Atom feed header.
+    #
+    # @param title [String] the title of the current atom feed
+    # @return [String] the Atom header as a String
+    def atom_header(title)
+      domain = Fronde::Config.settings['domain']
+      upddate = @date.rfc3339
+      if title == 'index'
+        slug = 'index'
+        tagurl = domain
+        title = Fronde::Config.settings['title'] || \
+                R18n.t.fronde.index.all_tags
+      else
+        slug = Fronde::OrgFile.slug(title)
+        tagurl = "#{domain}/tags/#{slug}.html"
+        title = @tags_names[title]
+      end
+      title = CGI.escapeHTML(title)
+      <<~ENDATOM
+        <?xml version="1.0" encoding="utf-8"?>
+        <feed xmlns="http://www.w3.org/2005/Atom"
+              xmlns:dc="http://purl.org/dc/elements/1.1/"
+              xmlns:wfw="http://wellformedweb.org/CommentAPI/"
+              xml:lang="#{Fronde::Config.settings['lang']}">
+
+        <title>#{title}</title>
+        <link href="#{domain}/feeds/#{slug}.xml" rel="self" type="application/atom+xml"/>
+        <link href="#{tagurl}" rel="alternate" type="text/html" title="#{title}"/>
+        <updated>#{upddate}</updated>
+        <author><name>#{Fronde::Config.settings['author'] || ''}</name></author>
+        <id>urn:md5:#{Digest::MD5.hexdigest(domain)}</id>
+        <generator uri="https://git.umaneti.net/fronde/about/">Fronde</generator>
+      ENDATOM
+    end
+
+    # Render an Atom feed entry.
+    #
+    # @param article [Fronde::OrgFile] the related org document for this
+    #   entry
+    # @return [String] the Atom entry as a String
+    def atom_entry(article)
+      keywords = article.keywords.map do |k|
+        "<dc:subject>#{CGI.escapeHTML(k)}</dc:subject>"
+      end.join
+      keywords += "\n  " if keywords != ''
+      title = CGI.escapeHTML(article.title)
+      <<~ENDENTRY
+        <entry>
+          <title>#{title}</title>
+          <link href="#{article.url}" rel="alternate" type="text/html"
+                title="#{title}"/>
+          <id>urn:md5:#{Digest::MD5.hexdigest(article.timekey)}</id>
+          <published>#{article.datestring(:rfc3339)}</published>
+          <author><name>#{CGI.escapeHTML(article.author)}</name></author>
+          #{keywords}<content type="html">#{CGI.escapeHTML(article.excerpt)}</content>
+        </entry>
+      ENDENTRY
+    end
+  end
+end

data/lib/fronde/index/org_generator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Fronde
+  # Embeds methods responsible for generating an org file for a given
+  #   index.
+  module IndexOrgGenerator
+    def to_org(index_name = 'index', is_project: false)
+      return project_home_page(index_name) if is_project
+      return all_tags_index if index_name == 'index'
+      [org_header(index_name),
+       org_articles(@index[index_name])].join("\n")
+    end
+    alias_method :to_s, :to_org
+
+    def write_org(index_name)
+      return unless save?
+      slug = Fronde::OrgFile.slug index_name
+      FileUtils.mkdir 'tags' unless Dir.exist? 'tags'
+      content = to_org index_name
+      orgdest = "tags/#{slug}.org"
+      IO.write(orgdest, content)
+    end
+
+    private
+
+    def project_home_page(project_name)
+      content = [org_header(project_name, is_tag: false)]
+      if @projects[project_name]&.any?
+        content += org_articles(@projects[project_name])
+      end
+      content.join("\n")
+    end
+
+    def write_all_blog_home(verbose)
+      Fronde::Config.sources.each do |project|
+        next unless project['is_blog']
+        next unless Dir.exist?(project['path'])
+        warn "Generated blog home for #{project['name']}" if verbose
+        orgdest = format('%<root>s/index.org', root: project['path'])
+        IO.write(orgdest, to_org(project['name'], is_project: true))
+      end
+    end
+
+    def all_tags_index
+      content = [
+        org_header(R18n.t.fronde.index.all_tags, is_tag: false)
+      ]
+      sort_tags_by_name_and_weight.each do |t, tags|
+        content << ''
+        content << org_title(R18n.t.fronde.index.send(t), 'index-tags')
+        next if tags.empty?
+        tags.each do |k|
+          content << "- #{tag_published_url(k)} (#{@index[k].length})"
+        end
+      end
+      content.join("\n")
+    end
+
+    def tag_published_url(tag_name)
+      domain = Fronde::Config.settings['domain']
+      title = @tags_names[tag_name]
+      tag_link = "#{domain}/tags/#{tag_name}.html"
+      "[[#{tag_link}][#{title}]]"
+    end
+
+    def org_header(title = nil, is_tag: true)
+      if is_tag
+        title = @tags_names[title]
+      elsif title.nil? || title == 'index'
+        title = Fronde::Config.settings['title']
+      end
+      <<~HEADER.strip
+        #+title: #{title}
+        #+author: #{Fronde::Config.settings['author']}
+        #+language: #{Fronde::Config.settings['lang']}
+      HEADER
+    end
+
+    def org_articles(articles_list)
+      last_year = nil
+      articles_list.map do |article|
+        year_title = ''
+        year = article.timekey.slice(0, 4)
+        if year != last_year
+          year_title = format("\n%<title>s\n", title: org_title(year))
+          last_year = year
+        end
+        year_title + org_entry(article)
+      end
+    end
+
+    def org_entry(article)
+      line = "- *[[#{article.url}][#{article.title}]]*"
+      if article.date
+        art_date = article.datestring(:full, year: false)
+        published = R18n.t.fronde.index.published_on art_date
+        line += " / #{published}"
+      end
+      line += " \\\\\n  #{article.excerpt}" if article.excerpt != ''
+      line
+    end
+
+    def org_title(year, html_class = 'index-year')
+      year = R18n.t.fronde.index.unsorted if year == '0000'
+      <<~ENDPROP
+        * #{year}
+        :PROPERTIES:
+        :HTML_CONTAINER_CLASS: #{html_class}
+        :UNNUMBERED: notoc
+        :END:
+      ENDPROP
+    end
+  end
+end