fronde 0.3.4 → 0.5.0

data/lib/fronde/cli/opt_parse.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Fronde
+  module CLI
+    # Helper code to help build the fronde option parser
+    module OptParse
+      # @return [Hash] the possible ~fronde~ options and their
+      #   configuration
+      FRONDE_OPTIONS = {
+        '-a' => { long: 'author' },
+        '-f' => { long: 'force', boolean: true },
+        '-h' => { long: 'help', boolean: true, method: :on_tail,
+                  help: R18n.t.fronde.bin.options.help },
+        '-l' => { long: 'lang', keyword: 'LOCALE' },
+        '-o' => { long: 'output', keyword: 'FORMAT', choices: %w[gemini html] },
+        '-t' => { long: 'title' },
+        '-v' => { long: 'verbose', boolean: true, method: :on_tail },
+        '-V' => { long: 'version', boolean: true, method: :on_tail,
+                  help: R18n.t.fronde.bin.options.version }
+      }.freeze
+
+      # TODO: jekyll new [path] / jekyll build / jekyll clean / jekyll serve
+      # TODO: hugo new site [path] / hugo / hugo new content / hugo server
+      # TODO: zola init [path] / zola build --root path_to_project / zola serve
+
+      # @return [Hash] the possible ~fronde~ subcommands and their
+      #   configuration
+      FRONDE_COMMANDS = {
+        'new' => { opts: ['-a', '-l', '-o', '-t', '-v'], label: 'new <path>' },
+        'init' => { alias: 'new' },
+        'update' => {},
+        'config' => { alias: 'update' },
+        'preview' => {},
+        'open' => { opts: ['-a', '-l', '-t', '-v'], label: 'open <path>' },
+        'edit' => { alias: 'open' },
+        'build' => { opts: ['-f'] },
+        'publish' => {},
+        'help' => {},
+        'basic' => { opts: ['-h', '-V'], label: '<command>' }
+      }.freeze
+
+      class << self
+        # Returns the short and long options specification for a given
+        #   short option.
+        #
+        # This method use the {Fronde::CLI::OptParse::FRONDE_OPTIONS}
+        # Hash to retrieve corresponding values.
+        #
+        # @example
+        #     spec = Fronde::CLI::OptParse.decorate_option('-a')
+        #     => ['-a AUTHOR', '--author AUTHOR']
+        #
+        # @param short [String] the short option to decorate
+        # @return [Array] the short and long specification for an option
+        def decorate_option(short)
+          opt = FRONDE_OPTIONS[short]
+          long = "--#{opt[:long]}"
+          if opt[:boolean]
+            config = [short, long]
+          else
+            key = opt[:keyword] || opt[:long].upcase
+            config = [short, format('%<long>s %<key>s', long: long, key: key)]
+          end
+          config.push opt[:choices], opt[:help]
+          config.compact
+        end
+
+        # Returns the ~fronde~ help summary for a given command.
+        #
+        # @param command [String] the command for which a summary
+        #   should be given
+        # @return [String]
+        def summarize_command(command)
+          (FRONDE_COMMANDS[command][:opts] || []).map do |k|
+            short, long = decorate_option(k)
+            opt = FRONDE_OPTIONS[k]
+            label = [short, long].join(', ')
+            line = [format('    %<opt>s', opt: label).ljust(30), opt[:help]]
+            choices = opt[:choices]
+            line << "(#{choices.join(', ')})" if choices
+            line.compact.join(' ')
+          end.join("\n")
+        end
+
+        def help_command_body(command)
+          command_opts_doc = summarize_command(command)
+          return '' if command_opts_doc == ''
+
+          body = [R18n.t.fronde.bin.options.cmd_title, command_opts_doc]
+          if command == 'basic'
+            body += ['', R18n.t.fronde.bin.commands.cmd_title, list_commands]
+          end
+          body.join("\n")
+        end
+
+        # Returns a formatted list of available commands for ~fronde~.
+        #
+        # @return [String]
+        def list_commands
+          FRONDE_COMMANDS.filter_map do |cmd, opt|
+            next if cmd == 'basic'
+
+            line = ['   ', cmd.ljust(10)]
+            if opt.has_key? :alias
+              line << R18n.t.fronde.bin.commands.alias(opt[:alias])
+            else
+              line << R18n.t.fronde.bin.commands[cmd]
+            end
+            line.join(' ')
+          end.join("\n")
+        end
+
+        # Returns the real command name for a given command, which may be
+        #   an alias.
+        #
+        # @param command [String] the command to resolve
+        # @return [String]
+        def resolve_possible_alias(command)
+          return 'basic' unless FRONDE_COMMANDS.include?(command)
+
+          cmd_opt = FRONDE_COMMANDS[command]
+          return cmd_opt[:alias] if cmd_opt.has_key?(:alias)
+
+          command
+        end
+
+        # Returns the given command options.
+        #
+        # This method will first try to resolve command alias, if any.
+        #
+        # @param command [String] the command, which options should be returned
+        # @return [Hash] the command options
+        def command_options(command)
+          cmd = resolve_possible_alias command
+          FRONDE_COMMANDS[cmd].merge(name: cmd)
+        end
+      end
+    end
+  end
+end

data/lib/fronde/cli/throbber.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'rainbow'
+
+module Fronde
+  module CLI
+    # Decorations for the command line
+    class Throbber
+      # @return [Hash] the possible throbber themes
+      THROBBER_FRAMES = {
+        'basic' => '-\|/',
+        'basicdots' => '⋯⋱⋮⋰',
+        'moon' => '🌑🌒🌓🌔🌕🌖🌗🌘',
+        'clock' => '🕛🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚',
+        'bricks' => '⣷⣯⣟⡿⢿⣻⣽⣾',
+        'points' => '·⁘⁛⁘',
+        'quadrant' => '▙▛▜▟',
+        'default' => ['⠁ ⠂ ⠄ ⡀ ⠄ ⠂ ⠁', '⠂ ⠁ ⠂ ⠄ ⡀ ⠄ ⠂', '⠄ ⠂ ⠁ ⠂ ⠄ ⡀ ⠄',
+                      '⡀ ⠄ ⠂ ⠁ ⠂ ⠄ ⡀', '⠄ ⡀ ⠄ ⠂ ⠁ ⠂ ⠄', '⠂ ⠄ ⡀ ⠄ ⠂ ⠁ ⠂']
+      }.freeze
+
+      def initialize(thread, message)
+        @frames = select_frames
+        @term_width = terminal_width
+        @thread = thread
+        @thread.abort_on_exception = false
+        @thread.report_on_exception = false
+        @message = message
+      end
+
+      def run
+        thread_loop
+      rescue RuntimeError => e
+        show_error
+        raise e
+        # :nocov: not sure how to emulate a Ctrl+c in rspec
+      rescue Interrupt => e
+        show_message Rainbow(R18n.t.fronde.bin.interrupted).red, "\n"
+        raise e
+        # :nocov:
+      else
+        show_message Rainbow(R18n.t.fronde.bin.done).green, "\n"
+      end
+
+      class << self
+        # Animates strings in the user console to alert him that something
+        #   is running in the background.
+        #
+        # The animation is chosen among a bunch of themes, with the
+        # configuration option ~throbber~ (retrieved via
+        # {Fronde::Config::Store#get}).
+        #
+        # @example
+        #     long_stuff = Thread.new { very_long_operation }
+        #     Fronde::CLI::Throbber.run(long_stuff, 'Computing hard stuff:')
+        #
+        # @param thread [Thread] the long-running operation to decorate
+        # @param message [String] the message to display before the throbber
+        # @return [void]
+        def run(thread, message)
+          throbber = new(thread, message)
+          throbber.run
+        end
+      end
+
+      private
+
+      def thread_loop
+        frames_len = @frames.length
+        current = 0
+        while @thread.alive?
+          sleep 0.1
+          show_message @frames[current % frames_len]
+          current += 1
+        end
+        @thread.join # Ensure any inner exception is re-raised
+      end
+
+      def terminal_width
+        # Not a tty. Docker?
+        return 0 unless system('test -t 0')
+
+        `stty size`.strip.split[1].to_i - 1
+      end
+
+      def show_message(suffix, end_of_line = "\r")
+        message = "#{@message} #{suffix}".ljust(@term_width)
+        print "#{message}#{end_of_line}"
+      end
+
+      def show_error
+        warn(
+          format(
+            "%<message>s %<label>s\n%<explanation>s",
+            message: @message,
+            label: Rainbow(R18n.t.fronde.error.bin.label).bold.red,
+            explanation: Rainbow(R18n.t.fronde.error.bin.explanation).bold
+          )
+        )
+      end
+
+      def select_frames
+        model = Fronde::CONFIG.get 'throbber', 'default'
+        model = 'default' unless THROBBER_FRAMES.has_key?(model)
+
+        THROBBER_FRAMES[model]
+      end
+    end
+  end
+end

data/lib/fronde/cli.rb

@@ -1,60 +1,60 @@
 # frozen_string_literal: true
 
 require 'rake'
-require 'fronde/cli/commands'
+require_relative 'cli/commands'
 
 module Fronde
-  # Fronde CLI app
-  class CLI
-    def initialize(opts = {})
-      @options = { verbose: false }.merge(opts)
-      init_required_files
-      init_rake
-    end
+  module CLI
+    # Fronde CLI app
+    class App
+      def initialize(opts = {})
+        @options = { verbose: false }.merge(opts)
+        @command = @rake = nil
+        @argv = []
+      end
 
-    include Fronde::CLICommands
+      include Commands
 
-    private
+      def run(argv)
+        @argv = argv
+        @command = OptParse.resolve_possible_alias(@argv.shift || 'basic')
 
-    def init_required_files
-      init_rakefile unless File.exist?('Rakefile')
-      init_gitignore unless File.exist?('.gitignore')
-    end
+        if help_param_given?
+          return 2 if @options[:recover_from_error]
 
-    def init_rake
-      @rake = Rake.application
-      Rake.verbose(false) unless @options[:verbose]
-      @rake.raw_load_rakefile
-    end
+          return true
+        end
 
-    def init_rakefile
-      rakefile = <<~RAKE
-        # frozen_string_literal: true
+        init_rake if %w[build preview publish].include?(@command)
 
-        require 'fronde/config'
-        require 'r18n-core'
+        method = :"fronde_#{@command}"
+        return 2 if method_unknown?(method)
 
-        fronde_spec = Gem::Specification.find_by_name 'fronde'
-        R18n.default_places = "\#{fronde_spec.gem_dir}/locales"
-        R18n.set(Fronde::Config.get('lang', 'en'))
-        R18n::Filters.on(:named_variables)
+        send method
+      end
 
-        Dir.glob("\#{fronde_spec.gem_dir}/lib/tasks/*.rake").each { |r| import r }
+      private
 
-        task default: 'site:build'
-      RAKE
-      File.write 'Rakefile', rakefile
-    end
+      def init_rake
+        @rake = Rake.application
+        Rake.verbose(false) unless @options[:verbose]
+        @rake.load_rakefile
+      end
+
+      def help_param_given?
+        return false unless @options[:help]
+
+        fronde_help
+        true
+      end
+
+      def method_unknown?(method)
+        return false if respond_to?(method)
 
-    def init_gitignore
-      gitignore = <<~GITIGNORE
-        .dir-locals.el
-        Rakefile
-        lib
-        public_html
-        var
-      GITIGNORE
-      File.write '.gitignore', gitignore
+        warn R18n.t.fronde.error.bin.no_command
+        fronde_help
+        true
+      end
     end
   end
 end

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

@@ -0,0 +1,25 @@
+;; Add org-mode to load path
+(add-to-list 'load-path (expand-file-name "org-{{ org_version }}/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 }}"
+      fronde-domain "{{ domain }}"
+      user-mail-address "{{ author.email }}"
+      user-full-name "{{ author.name }}"
+      org-html-metadata-timestamp-format "{{ long_date_fmt }}"
+      org-gmi-timestamp-format "{{ long_date_fmt }}"
+      org-publish-project-alist
+      `({% for project in all_projects -%}
+        ("{{ project.name }}"
+         {%- for attribute in project.attributes %}
+         :{{ attribute[0] }} {{ attribute[1] | cast_lisp_value: attribute[0] }}
+         {%- endfor %})
+        {% endfor -%}
+        ("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-fronde.el" "{{ fronde_data_dir }}"))

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

@@ -0,0 +1,158 @@
+;;; 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)
+(require 'ox-gmi)
+
+;;; 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-domain ""
+  "Target domain with scheme of the current fronde installation.")
+
+(defvar fronde-org-temp-dir nil
+  "Location of the local Org temporary directory.
+This is where to place org timestamps and id locations.")
+
+(defun fronde--format-rich-keywords (info function)
+  "Extract keywords from INFO and apply FUNCTION on them.
+FUNCTION is expected to format each keyword for a rich display for the
+current export backend.  FUNCTION must receive 3 arguments: the current
+KEYWORD, its related SLUG and the current project BASE-URI."
+  (let ((base-uri (plist-get info :fronde-base-uri))
+        (current-path (symbol-file 'fronde--format-rich-keywords))
+        sluglib)
+    (when current-path
+      (setq sluglib
+        (expand-file-name
+          (format "%s../../slug" (file-name-directory current-path)))))
+    (mapcar
+      (lambda (k)
+        (let ((slug (if sluglib
+                      (string-trim-right
+                        (shell-command-to-string
+                          (format "ruby -r %s -e \"puts Fronde::Slug.slug '%s'\""
+                            (shell-quote-argument sluglib)
+                            (shell-quote-argument k))))
+                      k)))
+          (funcall function k slug base-uri)))
+      (split-string
+        (org-export-data (plist-get info :keywords) info)
+        ",+ *"))))
+
+(defun fronde--org-html-format-spec (upstream info)
+  "Advise UPSTREAM to 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\">\n%s</ul>"
+                    (apply #'concat
+                      (fronde--format-rich-keywords
+                        info
+	                      (lambda (k slug base-uri)
+                          (format "<li class=\"keyword\"><a href=\"%stags/%s.html\">%s</a></li>\n"
+                            base-uri slug k))))))
+      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 `(?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-gmi-format-spec (upstream info)
+  "Advise UPSTREAM to return format specification for gemini postamble.
+INFO is a plist used as a communication channel."
+  (let ((output (funcall upstream info)))
+    (push `(?K . ,(org-gmi--build-links-list
+                    (fronde--format-rich-keywords
+                      info
+                      (lambda (k slug base-uri)
+                        (list (format "%stags/%s.gmi" base-uri slug)
+                          (format "🏷️ %s" k))))))
+      output)
+    (push `(?n . ,(format "Fronde %s" fronde-version)) output)))
+
+(defun fronde--org-i18n-export (link description backend)
+  "Export the given i18n LINK with its DESCRIPTION for the current BACKEND."
+  (let* ((splitted-link (split-string link "::"))
+         (path (car splitted-link))
+         (desc (or description path))
+         (lang (cadr splitted-link)))
+    (pcase backend
+      (`html (if lang
+                 (format "<a href=\"%s\" hreflang=\"%s\">%s</a>"
+                         path lang desc)
+               (format "<a href=\"%s\">%s</a>" path desc)))
+      (_ nil))))
+
+(defun fronde--org-i18n-follow (link)
+  "Visit the given 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)
+(advice-add 'org-gmi--format-spec :around #'fronde--org-gmi-format-spec)
+
+(provide 'ox-fronde)
+
+;;; ox-fronde.el ends here