fronde 0.3.4 → 0.4.0

data/lib/fronde/cli/throbber.rb

@@ -0,0 +1,99 @@
+# 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
+        @thread = thread
+        @thread.abort_on_exception = false
+        @thread.report_on_exception = false
+        @message = message
+      end
+
+      def run
+        term_width = terminal_width
+        frames_len = @frames.length
+        current = 0
+        while @thread.alive?
+          sleep 0.1
+          frame = @frames[current % frames_len]
+          message = "#{@message} #{frame}"
+          print "#{message.ljust(term_width)}\r"
+          current += 1
+        end
+        @thread.join # Ensure any inner exception is re-raised
+      rescue RuntimeError => e
+        show_error
+        raise e
+      else
+        done = Rainbow(R18n.t.fronde.bin.done).green
+        puts "#{@message} #{done}".ljust(term_width)
+      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 terminal_width
+        # Not a tty. Docker?
+        return 0 unless system('test -t 0')
+
+        `stty size`.strip.split[1].to_i - 1
+      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,59 @@
 # 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]
+          return 0
+        end
 
-    def init_rake
-      @rake = Rake.application
-      Rake.verbose(false) unless @options[:verbose]
-      @rake.raw_load_rakefile
-    end
+        init_rake if %w[build preview publish].include?(@command)
 
-    def init_rakefile
-      rakefile = <<~RAKE
-        # frozen_string_literal: true
+        method = "fronde_#{@command}".to_sym
+        return 2 if method_unknown?(method)
 
-        require 'fronde/config'
-        require 'r18n-core'
+        send method
+      end
 
-        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)
+      private
 
-        Dir.glob("\#{fronde_spec.gem_dir}/lib/tasks/*.rake").each { |r| import r }
+      def init_rake
+        @rake = Rake.application
+        Rake.verbose(false) unless @options[:verbose]
+        @rake.load_rakefile
+      end
 
-        task default: 'site:build'
-      RAKE
-      File.write 'Rakefile', 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,24 @@
+;; 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 }}"
+      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/{ox-fronde.el → data/ox-fronde.el}

@@ -60,7 +60,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://git.umaneti.net/fronde/about/\">Fronde</a> %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)))

data/lib/fronde/config/helpers.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'liquid'
+require 'digest/md5'
+
+module Fronde
+  module Config
+    # Various utilitaries methods
+    module Helpers
+      def self.extract_lang_from_env(default)
+        (ENV['LANG'] || default).split('_', 2).first
+      end
+
+      def self.migrate(config)
+        return config unless config.has_key?('public_folder')
+
+        warn R18n.t.fronde.error.config.deprecated_public_folder
+        old_pub_folder = config.delete('public_folder')
+        return config if config.has_key?('html_public_folder')
+
+        config['html_public_folder'] = old_pub_folder
+        config
+      end
+
+      def self.ensure_expanded_paths(config)
+        %w[html gemini].each do |what|
+          key = "#{what}_public_folder"
+          config[key] = File.expand_path config[key]
+        end
+        config
+      end
+
+      # Generate emacs directory variables file.
+      #
+      # This method generate the file ~.dir-locals.el~, which is
+      # responsible to load fronde Org settings when visiting an Org file
+      # of this fronde instance.
+      #
+      # @return [Integer] the length written (as returned by the
+      #   underlying ~File.write~ method call)
+      def self.write_dir_locals
+        workdir = Dir.pwd
+        # rubocop:disable Layout/LineLength
+        File.write(
+          "#{workdir}/.dir-locals.el",
+          "((org-mode . ((eval . (load-file \"#{workdir}/var/lib/org-config.el\")))))"
+        )
+        # rubocop:enable Layout/LineLength
+      end
+
+      def self.render_liquid_template(content, data)
+        template = Liquid::Template.parse(content)
+        template.render(data)
+      end
+    end
+
+    # Filter for liquid templates
+    module Filters
+      def cast_lisp_value(value, key)
+        return 't' if value.is_a?(TrueClass)
+        return 'nil' if value.nil? || value.is_a?(FalseClass)
+
+        value = value.strip
+        lisp_keywords = ['t', 'nil', '1', '-1', '0']
+        if key.end_with?('-function') || lisp_keywords.include?(value)
+          return value
+        end
+
+        value.gsub!('"', '\"')
+        %("#{value}")
+      end
+
+      def md5(value)
+        Digest::MD5.hexdigest(value)
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Fronde::Config::Filters)

data/lib/fronde/config/lisp.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open-uri'
+require_relative '../version'
+require_relative '../org'
+require_relative 'helpers'
+
+require_relative '../../ext/r18n'
+using R18nPatch
+
+module Fronde
+  module Config
+    # This module contains utilitary methods to ease ~org-config.el~
+    # file generation
+    module Lisp
+      # Generate emacs lisp configuration file for Org and write it.
+      #
+      # This method saves the generated configuration in the file
+      # ~org-config.el~ at the root of your project, overwriting it if it
+      # existed already.
+      #
+      # @return [Integer] the length written (as returned by the
+      #   underlying ~File.write~ method call)
+      # rubocop:disable Metrics/MethodLength
+      def write_org_lisp_config
+        workdir = Dir.pwd
+        all_projects = sources.map(&:org_config).flatten
+        all_themes = org_generate_themes(all_projects)
+        FileUtils.mkdir_p "#{workdir}/var/lib"
+        content = Helpers.render_liquid_template(
+          File.read(File.expand_path('./data/org-config.el', __dir__)),
+          'version' => Fronde::VERSION,
+          'work_dir' => workdir,
+          'fronde_data_dir' => File.expand_path('data', __dir__),
+          'org_version' => Fronde::Org.current_version,
+          'long_date_fmt' => R18n.t.full_datetime_format.to_s,
+          'author' => { 'email' => get('author_email', ''),
+                        'name' => get('author') },
+          'all_projects' => all_projects + all_themes
+        )
+        File.write("#{workdir}/var/lib/org-config.el", content)
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def org_theme_config(theme)
+        { 'base-directory' => File.expand_path("themes/#{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}",
+          # rubocop:enable Layout/LineLength
+          'publishing-function' => 'org-publish-attachment',
+          'recursive' => true }
+      end
+
+      def org_generate_themes(projects)
+        all_themes = projects.filter_map { |project| project['theme'] }
+        all_themes << get('theme')
+        all_themes.uniq.compact.filter_map do |theme|
+          next if theme == 'default'
+
+          { 'name' => "theme-#{theme}",
+            'attributes' => org_theme_config(theme) }
+        end
+      end
+    end
+  end
+end

data/lib/fronde/config.rb

@@ -1,44 +1,62 @@
 # frozen_string_literal: true
 
 require 'yaml'
-require 'fronde/config/lisp_config'
+require 'r18n-core'
+require 'singleton'
+
+require_relative 'config/lisp'
+require_relative 'source'
 
 module Fronde
-  # Wrapper for configuration
-  #
-  # This class is a singleton interface, which share the static website
-  # being build settings among different steps or tasks.
-  #
-  # It expects the website author to holds their custom settings in a
-  # YAML file named ~config.yml~ available at the root of their
-  # project.
-  #
-  # For example, with the given config file:
-  #
-  # #+begin_src
-  # ---
-  # title: My website
-  # author: Alice Doe
-  # #+end_src
-  #
-  # Settings will be available like this:
-  #
-  # #+begin_src
-  # Fronde::Config.get('author')
-  # => "Alice Doe"
-  # #+end_src
-  class Config
-    extend Fronde::LispConfig
-
-    class << self
+  module Config
+    # Wrapper for configuration
+    #
+    # This class is a singleton interface, which share the static website
+    # being build settings among different steps or tasks.
+    #
+    # It expects the website author to holds their custom settings in a
+    # YAML file named ~config.yml~ available at the root of their
+    # project.
+    #
+    # For example, with the given config file:
+    #
+    # #+begin_src
+    # ---
+    # title: My website
+    # author: Alice Doe
+    # #+end_src
+    #
+    # Settings will be available like this:
+    #
+    # #+begin_src
+    # Fronde::CONFIG.get('author')
+    # => "Alice Doe"
+    # #+end_src
+    class Store
+      include Singleton
+
+      attr_reader :sources
+
+      def initialize
+        @default_settings = {
+          'author' => (ENV['USER'] || ''),
+          'domain' => '',
+          'lang' => Fronde::Config::Helpers.extract_lang_from_env('en'),
+          'html_public_folder' => 'public_html',
+          'gemini_public_folder' => 'public_gmi',
+          'templates' => [], 'theme' => 'default'
+        }.freeze
+        @org_version = @sources = nil
+        @config = load_settings
+        # Do not load sources now to avoid dependency loop on config
+      end
+
+      include Fronde::Config::Lisp
+
       # Access the current website settings
       #
-      # If necessary, this method will load settings from a config
-      # file.
-      #
       # @return [Hash] the website settings
       def settings
-        load_settings
         @config
       end
 
@@ -56,7 +74,6 @@ module Fronde
       # @param default the default value to use if ~setting~ is absent
       # @return the setting value or nil
       def get(setting, default = nil)
-        load_settings
         if setting.is_a? Array
           value = @config.dig(*setting)
         else
@@ -65,31 +82,6 @@ module Fronde
         value || default
       end
 
-      # Save the settings given as a parameter to the ~config.yml~ file.
-      #
-      # Not only this method overwrite the old settings, but it replace
-      # the current shared settings with the ones given in
-      # parameter. Later call to
-      # {file:Fronde/Config.html#settings-class_method settings}
-      # will, obviously, use these new settings.
-      #
-      # @param new_config [Hash] the settings to save
-      # @return [Hash] the new settings after save
-      def save(new_config)
-        # Do not save obvious default config values. We'll always try to
-        # save author and lang as they default on system variables,
-        # which may be different from a system to another. Thus it may
-        # be confusing if one use fronde on two different computer and
-        # these params always change.
-        default_keys = default_settings.keys
-        new_config.delete_if do |k, v|
-          default_keys.include?(k) && v == default_settings[k]
-        end
-        File.write 'config.yml', new_config.to_yaml
-        @config = @sources = nil
-        load_settings # Reload config, taking default settings into account
-      end
-
       # Reset settings
       #
       # This method is handy for testing purpose. Next call to
@@ -99,7 +91,10 @@ module Fronde
       #
       # @return nil
       def reset
-        @sources = @config = nil
+        # Reload config, taking default settings into account
+        @config = load_settings
+        @org_version = @sources = nil
+        @sources = load_sources
       end
 
       # Load the given settings as if they comes from the ~config.yml~ file.
@@ -111,68 +106,109 @@ module Fronde
       # use these new settings.
       #
       # @param config [Hash] the settings to artificially load
-      # @return [Hash] the new settings
+      # @return [Fronde::Config::Store] self
       def load_test(config)
-        reset
-        @config = default_settings.merge config
-        sources
-        @config
+        @config = @default_settings.merge config
+        @org_version = @sources = nil
+        @sources = load_sources
+        self
       end
 
       # Return the qualified projects sources list.
       #
       # @return [Array] the fully qualified projects sources list
-      def sources
+      def load_sources
         return @sources if @sources
-        load_settings
-        default_sources = [{ 'path' => 'src', 'target' => '.' }]
-        @sources = get('sources', default_sources).map do |s|
-          build_source(s)
-        end.compact
+
+        @sources = remove_inclusion(remove_duplicate(build_sources))
       end
 
       private
 
       def load_settings
-        return @config if @config
         conf_file = 'config.yml'
+        user_conf = {}
         if File.exist? conf_file
-          @config = default_settings.merge(YAML.load_file(conf_file)).freeze
-        else
-          @config = default_settings
+          user_conf = YAML.load_file(conf_file)
+          user_conf = Fronde::Config::Helpers.migrate(user_conf)
         end
+        user_conf = @default_settings.merge(user_conf)
+        Fronde::Config::Helpers.ensure_expanded_paths(user_conf).freeze
       end
 
-      def extract_lang_from_env(default)
-        (ENV['LANG'] || default).split('_', 2).first
+      def build_sources
+        default_sources = [{ 'path' => 'src', 'target' => '.' }]
+        get('sources', default_sources).filter_map do |source_conf|
+          config = Source.canonical_config source_conf.dup
+          unless config['path']
+            warn R18n.t.fronde.error.source.no_path(source: config.inspect)
+            next
+          end
+          Source.new_from_config config
+        end
       end
 
-      def default_settings
-        return @default_settings if @default_settings
-        @default_settings = {
-          'author' => (ENV['USER'] || ''),
-          'domain' => '',
-          'lang' => extract_lang_from_env('en'),
-          'public_folder' => 'public_html',
-          'templates' => [],
-          'theme' => 'default'
-        }.freeze
+      def remove_duplicate(sources)
+        check_paths = {}
+        sources.each do |source|
+          type = source.type
+          check_paths[type] ||= {}
+          path = source['path']
+          # Avoid duplicate
+          if check_paths[type].has_key?(path)
+            warn(
+              R18n.t.fronde.error.source.duplicate(
+                source: source['name'], type: type
+              )
+            )
+            next
+          end
+          check_paths[type][path] = source
+        end
+        check_paths
       end
 
-      def build_source(seed)
-        opts = { 'recursive' => true, 'is_blog' => false }
-        case seed
-        when String
-          opts['path'] = seed
-        when Hash
-          opts.merge! seed
-        end
-        return nil unless opts.has_key?('path')
-        opts['path'] = File.expand_path(opts['path'])
-        opts['name'] ||= File.basename(opts['path']).sub(/^\./, '')
-        opts['target'] ||= opts['name']
-        opts
+      def remove_inclusion(check_paths)
+        check_paths.map do |type, sources_by_path|
+          skip_paths = []
+
+          # Check paths in the right order
+          sorted_paths = sources_by_path.keys.sort_by(&:length)
+          sorted_paths.filter_map do |path|
+            next if skip_paths.include?(path)
+
+            source = sources_by_path[path]
+            # If current source is not recursive, there is no possible
+            # issue
+            next source unless source.recursive?
+
+            # Ensure that the current source does not embed another one
+            possible_matchs = sorted_paths.select do |other_path|
+              path != other_path && other_path.start_with?(path)
+            end
+            next source if possible_matchs.empty?
+
+            skip_paths += possible_matchs
+            possible_matchs.each do |match|
+              other_source = sources_by_path[match]
+              warn(
+                R18n.t.fronde.error.source.inclusion(
+                  source: other_source['title'], type: type,
+                  other_source: source['title']
+                )
+              )
+            end
+          end
+        end.flatten
       end
     end
   end
+
+  CONFIG = Config::Store.instance
 end
+
+R18n.default_places = File.expand_path('../../locales', __dir__)
+R18n::Filters.on(:named_variables)
+R18n.set Fronde::CONFIG.get('lang')
+
+Fronde::CONFIG.load_sources