fronde 0.3.4 → 0.5.0

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,98 @@
 # 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,
+        'project_type' => @project.type,
+        '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,
+        'project_type' => @project.type,
+        '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,92 @@ 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
+    def sort_by(kind)
+      accepted_values = %i[name weight]
+      unless accepted_values.include?(kind)
+        error_msg = R18n.t.fronde.error.index.wrong_sort_kind(
+          kind: kind, accepted_values: accepted_values.inspect
+        )
+        raise ArgumentError, error_msg
       end
-      write_all_blog_home(verbose)
+      sort_tags_by_name_and_weight[:"by_#{kind}"].map do |tag|
+        @tags_names[tag] + " (#{@index[tag].length})"
+      end.reverse
+      # Reverse in order to have most important or A near next prompt
+      # and avoid to scroll to find the beginning of the list.
     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
+    class << self
+      def all_blog_index(&block)
+        all_blogs = CONFIG.sources.filter_map do |project|
+          Index.new(project) if project.blog?
+        end
+        return all_blogs unless block
+
+        all_blogs.each(&block)
       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 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
 
-    def add_to_project_index(article)
-      project = article.project
-      @projects[project['name']] ||= []
-      @projects[project['name']] << article
+        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'