fronde 0.3.4 → 0.5.0

data/lib/fronde/config/lisp.rb

@@ -0,0 +1,80 @@
+# 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)
+      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') },
+          'domain' => get('domain'),
+          'all_projects' => all_projects + all_themes
+        )
+        File.write("#{workdir}/var/lib/org-config.el", content)
+      end
+
+      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),
+          # 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
+        # Do not load sources now to avoid dependency loop on config
+        @sources = nil
+        @config = load_settings
+      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
+        @sources = nil
+        @sources = load_sources
       end
 
       # Load the given settings as if they comes from the ~config.yml~ file.
@@ -111,68 +106,123 @@ 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
+        @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 check_duplicate_and_warn(collection, source, type)
+        path = source['path']
+        return path unless collection[type].has_key?(path)
+
+        warn(
+          R18n.t.fronde.error.source.duplicate(
+            source: source['name'], type: type
+          )
+        )
+      end
+
+      def remove_duplicate(sources)
+        check_paths = {}
+        sources.each do |source|
+          type = source.type
+          check_paths[type] ||= {}
+          path = check_duplicate_and_warn check_paths, source, type
+          # Avoid duplicate
+          next unless path
+
+          check_paths[type][path] = source
+        end
+        check_paths
+      end
+
+      def filter_possible_matchs(path, other_paths_list)
+        other_paths_list.select do |other_path|
+          path != other_path && other_path.start_with?(path)
+        end
       end
 
-      def build_source(seed)
-        opts = { 'recursive' => true, 'is_blog' => false }
-        case seed
-        when String
-          opts['path'] = seed
-        when Hash
-          opts.merge! seed
+      def warn_on_existing_inclusion(type, other, possible_matchs, sources)
+        possible_matchs.each do |match|
+          warn(
+            R18n.t.fronde.error.source.inclusion(
+              source: sources[match]['title'],
+              other_source: other, type: type
+            )
+          )
         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
+      end
+
+      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 = filter_possible_matchs path, sorted_paths
+            next source if possible_matchs.empty?
+
+            skip_paths += possible_matchs
+            warn_on_existing_inclusion(
+              type, source['title'], possible_matchs, sources_by_path
+            )
+          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

data/lib/fronde/emacs.rb

@@ -1,37 +1,40 @@
 # frozen_string_literal: true
 
-require 'fronde/config'
+require_relative 'config'
 
 module Fronde
   # Wraps Gnu/Emacs calls
   class Emacs
-    def initialize(file_path: nil, verbose: false)
-      @file = file_path
+    def initialize(verbose: false)
       @verbose = verbose
+      @command = nil
     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
+    def publish(project = 'website')
+      build_command("(org-publish \"#{project}\")")
+      run_command
     end
 
     private
 
-    def emacs_command(*arguments)
-      default_emacs = Fronde::Config.get('emacs')
-      emacs_cmd = [
-        default_emacs || 'emacs -Q --batch -nw',
-        '--eval \'(setq enable-dir-local-variables nil)\''
+    def run_command
+      cmd = @command.join(' ')
+      if @verbose
+        warn cmd
+        return system(cmd, exception: true)
+      end
+      system cmd, out: File::NULL, err: File::NULL, exception: true
+    end
+
+    def build_command(org_action)
+      default_emacs = Fronde::CONFIG.get('emacs')
+      @command = [default_emacs || 'emacs -Q --batch -nw']
+      @command << '--eval \'(setq inhibit-message t)\'' unless @verbose
+      @command += [
+        '--eval \'(setq enable-dir-local-variables nil)\'',
+        '-l ./var/lib/org-config.el',
+        "--eval '#{org_action}'"
       ]
-      emacs_cmd << '--eval \'(setq inhibit-message t)\'' unless @verbose
-      emacs_cmd.concat(arguments)
-      emacs_cmd.join(' ')
     end
   end
 end

data/lib/fronde/index/atom_generator.rb

@@ -1,85 +1,74 @@
 # frozen_string_literal: true
 
-require 'cgi'
-require 'fronde/config'
+require_relative '../config'
 
 module Fronde
-  # Embeds Atom feeds sepecific methods
-  module IndexAtomGenerator
+  # Reopen Index class to embed Atom feeds sepecific methods
+  class Index
     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")
+      entries = @index[index_name][0...10].map(&:to_h)
+      return atom_index(entries) if index_name == 'index'
+
+      atom_file(index_name, entries)
     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"
-      File.write(atomdest, to_atom(index_name))
+      slug = Slug.slug index_name
+      atomdest = "#{@project.publication_path}/feeds/#{slug}.xml"
+      File.write atomdest, to_atom(index_name)
+    end
+
+    def write_all_feeds(verbose: true)
+      FileUtils.mkdir_p "#{@project.publication_path}/feeds"
+      @index.each_key do |tag|
+        write_atom(tag)
+        warn R18n.t.fronde.index.atom_generated(tag: tag) if verbose
+      end
     end
 
     private
 
-    # Render the Atom feed header.
+    # Render an Atom feed file.
     #
-    # @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.get('domain')
-      upddate = @date.rfc3339
-      if title == 'index'
-        slug = 'index'
-        tagurl = domain
-        title = Fronde::Config.get('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.get('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.get('author', '')}</name></author>
-        <id>urn:md5:#{Digest::MD5.hexdigest(domain)}</id>
-        <generator uri="https://git.umaneti.net/fronde/about/">Fronde</generator>
-      ENDATOM
+    # @param tag_name [String] the tag name of the current atom feed
+    # @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__)),
+        '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
+      )
     end
 
-    # Render an Atom feed entry.
+    # Render the main/index Atom feed.
     #
-    # @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
+    # @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')
+      Config::Helpers.render_liquid_template(
+        File.read(File.expand_path('./data/template.xml', __dir__)),
+        'title' => @project['title'],
+        '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
+      )
     end
   end
 end

data/lib/fronde/index/data/all_tags.org

@@ -0,0 +1,19 @@
+#+title: {{ title }}
+#+author: {{ author }}
+#+language: {{ lang }}
+{% for index in indexes %}
+* {{ index.title }}
+:PROPERTIES:
+{%- if project_type == 'html' %}
+:HTML_CONTAINER_CLASS: index-tags{% endif %}
+:UNNUMBERED: notoc
+:END:
+
+{% for tag in index.tags -%}
+{%- if project_type == 'gemini' -%}
+[[{{ domain }}{{ project_path }}tags/{{ tag.slug }}.gmi][{{ tag.title }} ({{ tag.weight }})]]
+{%- else -%}
+- [[{{ domain }}{{ project_path }}tags/{{ tag.slug }}.html][{{ tag.title }}]] ({{ tag.weight }})
+{%- endif %}
+{% endfor %}
+{%- endfor -%}

data/lib/fronde/index/data/template.org

@@ -0,0 +1,26 @@
+#+title: {{ title }}
+#+author: {{ author }}
+#+language: {{ lang }}
+{%- if project_type == 'html' and slug != '__HOME_PAGE__' %}
+#+html_head_extra: <link rel="alternate" type="application/atom+xml" title="{{ title }}" href="{{ domain }}{{ project_path }}feeds/{{ slug }}.xml" />
+{% endif -%}
+{%- assign last_year = 0 -%}
+{% for article in entries %}
+{% assign cur_year = article.timekey | slice: 0, 4 %}
+{%- unless cur_year == last_year %}
+* {% if cur_year == "0000" %}{{ unsorted }}{% else %}{{ cur_year }}{% endif %}
+:PROPERTIES:
+{%- if project_type == 'html' %}
+:HTML_CONTAINER_CLASS: index-year{% endif %}
+:UNNUMBERED: notoc
+:END:
+{% assign last_year = cur_year %}
+{% endunless -%}
+{%- if project_type == 'gemini' -%}
+[[{{ article.url }}][{% if article.published != '' %}{{ article.published_gemini_index }} {% endif %}{{ article.title }}]]
+{%- else -%}
+- *[[{{ article.url }}][{{ article.title }}]]*
+{%- if article.published != '' %} / {{ article.published }}{% endif -%}
+{%- if article.excerpt != '' %} \\
+  {{ article.excerpt }}{% endif %}{% endif %}
+{%- endfor %}