fronde 0.3.4 → 0.4.0

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: '/dev/null', err: '/dev/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,14 @@
+#+title: {{ title }}
+#+author: {{ author }}
+#+language: {{ lang }}
+{% for index in indexes %}
+* {{ index.title }}
+:PROPERTIES:
+:HTML_CONTAINER_CLASS: index-tags
+:UNNUMBERED: notoc
+:END:
+
+{% for tag in index.tags -%}
+- [[{{ domain }}{{ project_path }}tags/{{ tag.slug }}.html][{{ tag.title }}]] ({{ tag.weight }})
+{% endfor %}
+{%- endfor -%}

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

@@ -0,0 +1,22 @@
+#+title: {{ title }}
+#+author: {{ author }}
+#+language: {{ lang }}
+{%- unless slug == '__HOME_PAGE__' %}
+#+html_head_extra: <link rel="alternate" type="application/atom+xml" title="{{ title }}" href="{{ domain }}{{ project_path }}feeds/{{ slug }}.xml" />
+{% endunless -%}
+{%- 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:
+:HTML_CONTAINER_CLASS: index-year
+:UNNUMBERED: notoc
+:END:
+{% assign last_year = cur_year %}
+{% endunless -%}
+- *[[{{ article.url }}][{{ article.title }}]]*
+{%- if article.published != '' %} / {{ article.published }}{% endif -%}
+{%- if article.excerpt != '' %} \\
+  {{ article.excerpt }}{% endif %}
+{%- endfor %}

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

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom"
+      xmlns:dc="http://purl.org/dc/elements/1.1/"
+      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 }}"/>
+  <updated>{{ upddate }}</updated>
+  <author><name>{{ author }}</name></author>
+  <id>urn:md5:{{ domain | md5 }}</id>
+  <generator uri="https://git.umaneti.net/fronde/about/">Fronde</generator>
+
+  {%- for article in entries %}
+
+  <entry>
+    <title>{{ article.title | escape }}</title>
+    <link href="{{ article.url }}" rel="alternate"
+          type="{{ publication_format }}"
+          title="{{ article.title }}"/>
+    <id>urn:md5:{{ article.timekey | md5 }}</id>
+    <published>{{ article.published_xml }}</published>
+    <updated>{{ article.updated_xml }}</updated>
+    <author><name>{{ article.author | escape }}</name></author>
+    {%- for keyword in article.keywords %}
+    <dc:subject>{{ keyword | escape }}</dc:subject>
+    {%- endfor %}
+    {%- if publication_format == 'text/html' %}
+    <content type="html">
+    {%- else %}
+    <content>
+    {%- endif %}
+      {{- article.published_body | escape -}}
+    </content>
+  </entry>
+  {%- endfor %}
+</feed>

data/lib/fronde/index/org_generator.rb

@@ -1,114 +1,96 @@
 # frozen_string_literal: true
 
+using TimePatch
+
 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
+  # Reopen Index class to embed methods responsible for generating an
+  #   org file for a given index.
+  class Index
+    def blog_home_page
+      org_index @project['title'], '__HOME_PAGE__', @entries.map(&:to_h)
+    end
+
+    def to_org(index_name = 'index')
       return all_tags_index if index_name == 'index'
-      [org_header(index_name),
-       org_articles(@index[index_name])].join("\n")
+
+      org_index(
+        @tags_names[index_name], index_name,
+        (@index[index_name] || []).map(&:to_h)
+      )
     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"
-      File.write(orgdest, content)
+      slug = Slug.slug index_name
+      orgdest = "#{@project['path']}/tags/#{slug}.org"
+      File.write orgdest, to_org(index_name)
     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])
+    def write_all_org(verbose: true)
+      FileUtils.mkdir_p "#{@project['path']}/tags"
+      @index.each_key do |tag|
+        write_org(tag)
+        warn R18n.t.fronde.index.index_generated(tag: tag) if verbose
       end
-      content.join("\n")
+      write_blog_home_page(verbose)
     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'])
-        File.write(orgdest, to_org(project['name'], is_project: true))
-      end
-    end
+    private
 
-    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})"
+    # Render an Org index file.
+    #
+    # @param title [String] the title of the current org index
+    # @param slug [String] the slug of the current org index
+    # @param entries [Array] the article to list in this file
+    # @return [String] the org file content as a String
+    def org_index(title, slug, entries)
+      entries.map! do |article|
+        published = article['published']
+        unless published == ''
+          article['published'] = R18n.t.fronde.index.published_on published
         end
+        article
       end
-      content.join("\n")
-    end
-
-    def tag_published_url(tag_name)
-      domain = Fronde::Config.get('domain')
-      title = @tags_names[tag_name]
-      tag_link = "#{domain}/tags/#{tag_name}.html"
-      "[[#{tag_link}][#{title}]]"
+      Config::Helpers.render_liquid_template(
+        File.read(File.expand_path('./data/template.org', __dir__)),
+        'title' => title,
+        'slug' => slug,
+        'project_path' => @project.public_absolute_path,
+        'domain' => Fronde::CONFIG.get('domain'),
+        'lang' => Fronde::CONFIG.get('lang'),
+        'author' => Fronde::CONFIG.get('author'),
+        'unsorted' => R18n.t.fronde.index.unsorted,
+        'entries' => entries
+      )
     end
 
-    def org_header(title = nil, is_tag: true)
-      if is_tag
-        title = @tags_names[title]
-      elsif title.nil? || title == 'index'
-        title = Fronde::Config.get('title')
-      end
-      <<~HEADER.strip
-        #+title: #{title}
-        #+author: #{Fronde::Config.get('author')}
-        #+language: #{Fronde::Config.get('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
+    def all_tags_index
+      indexes = sort_tags_by_name_and_weight.map do |title, tags|
+        all_tags = tags.map do |tag|
+          {
+            'slug' => tag, 'title' => @tags_names[tag],
+            'weight' => @index[tag].length
+          }
         end
-        year_title + org_entry(article)
+        { 'title' => R18n.t.fronde.index.send(title), 'tags' => all_tags }
       end
+      Config::Helpers.render_liquid_template(
+        File.read(File.expand_path('./data/all_tags.org', __dir__)),
+        'title' => R18n.t.fronde.index.all_tags,
+        'lang' => Fronde::CONFIG.get('lang'),
+        'author' => Fronde::CONFIG.get('author'),
+        'domain' => Fronde::CONFIG.get('domain'),
+        'project_path' => @project.public_absolute_path,
+        'indexes' => indexes
+      )
     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}"
+    def write_blog_home_page(verbose)
+      orgdest = format('%<root>s/index.org', root: @project['path'])
+      if verbose
+        warn R18n.t.fronde.org.generate_blog_index(name: @project['name'])
       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
+      File.write(orgdest, blog_home_page)
     end
   end
 end

data/lib/fronde/index.rb

@@ -1,11 +1,8 @@
 # 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'
+require_relative 'slug'
+require_relative 'config'
+require_relative 'org/file'
 
 module Fronde
   # Generates website indexes and atom feeds for all the org documents
@@ -13,118 +10,95 @@ module Fronde
   class Index
     attr_reader :date
 
-    include Fronde::IndexAtomGenerator
-    include Fronde::IndexOrgGenerator
-
-    def initialize
-      @pubdir = Fronde::Config.get('public_folder')
+    def initialize(project)
+      @project = project
       @index = { 'index' => [] }
-      @projects = {}
+      @entries = []
       @tags_names = {}
-      @date = DateTime.now
-      feed
-      sort!
+      @date = Time.now
+      generate_feeds if @project.blog?
+      sort_feeds!
     end
 
-    def entries
-      @index.keys.reject { |k| k == 'index' }
+    def all_tags
+      @index.keys.reject { |tag| tag == '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)
+      accepted_values = %i[name weight]
+      if accepted_values.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})"
+        return tags_sorted.map do |tag|
+          @tags_names[tag] + " (#{@index[tag].length})"
         end.reverse
       end
-      raise ArgumentError, "#{kind} not in [:name, :weight]"
+      error_msg = R18n.t.fronde.error.index.wrong_sort_kind(
+        kind: kind, accepted_values: accepted_values.inspect
+      )
+      raise ArgumentError, error_msg
     end
 
-    private
+    class << self
+      def all_html_blog_index(&block)
+        all_blogs = CONFIG.sources.filter_map do |project|
+          next unless project['type'] == 'html' && project.blog?
 
-    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)
-          )
+          Index.new(project)
         end
+        return all_blogs unless block
+
+        all_blogs.each(&block)
       end
     end
 
-    def add_to_project_index(article)
-      project = article.project
-      @projects[project['name']] ||= []
-      @projects[project['name']] << article
+    private
+
+    def generate_feeds
+      file_pattern = '**/*.org'
+      Dir.glob(file_pattern, base: @project['path']).map do |index_file|
+        # Obviously don't parse tags
+        next if index_file.start_with?('tags/')
+
+        org_file = File.join(@project['path'], index_file)
+        next if @project.exclude_file? org_file
+
+        add_to_indexes(Org::File.new(org_file))
+      end
     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
+      @entries << article
+      article.keywords.each do |tag|
+        slug = Slug.slug tag
+        @tags_names[slug] = tag # 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 }
+    def sort_feeds!
+      @index.transform_values! do |articles|
+        articles.sort_by(&:timekey).reverse
       end
+      @entries = @entries.sort_by(&:timekey).reverse
     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
+      all_keys = all_tags
+      {
+        by_name: all_keys.sort,
+        by_weight: all_keys.sort_by { @index[_1].length }.reverse
+      }
     end
   end
 end
+
+require_relative 'index/org_generator'
+require_relative 'index/atom_generator'