neruda 0.1.0 → 0.2.2

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

@@ -1,17 +1,17 @@
-;; Add custom org mode to load path
+;; Add org-mode to load path
 (add-to-list 'load-path (expand-file-name "org-__ORG_VER__/lisp" "__WORK_DIR__"))
-;; Load modern version of htmlize.el
+;; Load last version of htmlize.el
 (load-file (expand-file-name "htmlize.el" "__WORK_DIR__"))
 
 ;; Current project options
-(setq neruda/current-work-dir "__WORK_DIR__"
+(setq neruda/version "__VERSION__"
+      neruda/current-work-dir "__WORK_DIR__"
       user-mail-address "__AUTHOR_EMAIL__"
       user-full-name "__AUTHOR_NAME__"
       org-html-metadata-timestamp-format "__LONG_DATE_FMT__"
       org-publish-project-alist
-      `(__ALL_PROJECTS__
-        __THEME_CONFIG__
-        ("website" :components (__ALL_PROJECTS_NAMES__ "theme"))))
+      `(__ALL_PROJECTS____THEME_CONFIG__
+        ("website" :components (__ALL_PROJECTS_NAMES__))))
 
 ;; Load neruda lib
 (load-file (expand-file-name "ox-neruda.el" "__NERUDA_DIR__"))

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

@@ -33,13 +33,38 @@
 
 ;;; Function Declarations
 
+(defvar neruda/version ""
+  "Version of the current neruda installation")
+
 (defvar neruda/current-work-dir nil
   "Location of the current neruda website base directory.")
 
 (defvar neruda/org-temp-dir nil
-  "Location of the local org-mode temporary directory (where to place
+  "Location of the local Org temporary directory (where to place
 org timestamps and id locations).")
 
+(defun neruda/org-html-format-spec (upstream info)
+  "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\">%s</ul>"
+                    (mapconcat
+	                    (lambda (k) (format "<li class=\"keyword\">%s</li>" k))
+	                    (split-string (or (plist-get info :keywords) "")  ",+ *")
+	                    "\n")))
+      output)
+    (push `(?l . ,(org-export-data (plist-get info :language) info)) output)
+    (push `(?n . ,(format "Neruda %s" neruda/version)) output)
+    (push `(?N . ,(format "<a href=\"https://git.umaneti.net/neruda/about/\">Neruda</a> %s" neruda/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 neruda/org-i18n-export (link description format)
   "Export a i18n link"
   (let* ((splitted-link (split-string link "|"))
@@ -72,6 +97,7 @@ org timestamps and id locations).")
       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
@@ -81,7 +107,7 @@ org timestamps and id locations).")
                                     (strike-through . "<del>%s</del>")
                                     (underline . "<span class=\"underline\">%s</span>")
                                     (verbatim . "<code>%s</code>")))
-
+(advice-add 'org-html-format-spec :around #'neruda/org-html-format-spec)
 
 (provide 'ox-neruda)
 

data/lib/neruda/emacs.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'neruda/config'
+
+module Neruda
+  # Wraps Gnu/Emacs calls
+  class Emacs
+    def initialize(file_path: nil, verbose: false)
+      @file = file_path
+      @verbose = verbose
+    end
+
+    def publish
+      if @file.nil?
+        emacs_args = ['--eval \'(org-publish "website")\'']
+      else
+        emacs_args = ['-f org-publish-current-file']
+      end
+      call_emacs emacs_args
+    end
+
+    private
+
+    def emacs_command(arguments = [])
+      default_emacs = Neruda::Config.settings['emacs']
+      emacs_cmd = [default_emacs || 'emacs -Q --batch -nw']
+      emacs_cmd << '--eval \'(setq enable-dir-local-variables nil)\''
+      emacs_cmd << '--eval \'(setq inhibit-message t)\'' unless @verbose
+      emacs_cmd << '-l ./org-config.el'
+      emacs_cmd << "--eval '(find-file \"#{@file}\")'" unless @file.nil?
+      emacs_cmd.concat(arguments)
+      emacs_cmd.join(' ')
+    end
+
+    def call_emacs(arguments = [])
+      command = emacs_command arguments
+      if @verbose
+        warn command
+        return system(command, exception: true)
+      end
+      system command, out: '/dev/null', err: '/dev/null', exception: true
+    end
+  end
+end

data/lib/neruda/index.rb

@@ -16,75 +16,78 @@ module Neruda
     include Neruda::IndexAtomGenerator
     include Neruda::IndexOrgGenerator
 
-    def initialize(file_list = nil)
-      @blog_path = Neruda::Config.settings['blog_path']
+    def initialize
       @pubdir = Neruda::Config.settings['public_folder']
       @index = { 'index' => [] }
+      @projects = {}
       @tags_names = {}
       @date = DateTime.now
-      if @blog_path.nil?
-        @sources = []
-      else
-        @sources = sources_list(file_list)
-        filter_and_prefix_sources!
-        @sources.each { |f| add_to_indexes(Neruda::OrgFile.new(f)) }
-        sort!
-      end
+      feed
+      sort!
     end
 
     def entries
-      @index.keys
+      @index.keys.reject { |k| k == 'index' }
+    end
+
+    def empty?
+      @index['index'].empty?
     end
 
-    def write_all(verbose = true)
-      @index.keys.each do |k|
+    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_org_lists
-      warn 'Generated all tags index' if verbose
+      write_all_blog_home(verbose)
     end
 
     def sort_by(kind)
       if [:name, :weight].include?(kind)
-        return sort_tags_by_name_and_weight["by_#{kind}".to_sym]
+        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
       end
       raise ArgumentError, "#{kind} not in [:name, :weight]"
     end
 
     private
 
-    def sources_list(file_list)
-      return file_list unless file_list.nil?
-      Dir.glob(Neruda::Config.settings['blog_pattern'],
-               base: "src/#{@blog_path}")
-    end
-
-    def filter_and_prefix_sources!
-      exclude = Neruda::Config.settings['exclude_pattern']
-      sources = []
-      @sources.each do |f|
-        next if f == 'index.org'
-        if File.exist?(f)
-          file_path = f
+    def feed
+      Neruda::Config.sources.each do |project|
+        next unless project['is_blog']
+        if project['recursive']
+          file_pattern = '**/*.org'
         else
-          file_path = "src/#{@blog_path}/#{f}"
-          next unless File.exist?(file_path)
+          file_pattern = '*.org'
+        end
+        Dir.glob(file_pattern, base: project['path']).map do |s|
+          org_file = File.join(project['path'], s)
+          add_to_indexes(
+            Neruda::OrgFile.new(org_file, project: project)
+          )
         end
-        next if exclude && file_path.match(exclude)
-        sources << file_path
       end
-      @sources = sources
+    end
+
+    def add_to_project_index(article)
+      project = article.project
+      @projects[project['name']] ||= []
+      @projects[project['name']] << article
     end
 
     def add_to_indexes(article)
       @index['index'] << article
+      add_to_project_index article
       article.keywords.each do |k|
         slug = Neruda::OrgFile.slug k
         @tags_names[slug] = k # Overwrite is permitted
-        @index[slug] = [] unless @index.has_key?(slug)
+        @index[slug] ||= []
         @index[slug] << article
       end
     end
@@ -93,16 +96,27 @@ module Neruda
       @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 }
+      end
     end
 
     def sort_tags_by_name_and_weight
       tags_sorted = {}
-      all_keys = @index.keys.reject { |k| k == 'index' }
+      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 save?
+      return true unless empty?
+      Neruda::Config.sources.each do |project|
+        return true if project['is_blog'] && Dir.exist?(project['path'])
+      end
+      false
+    end
   end
 end

data/lib/neruda/index/atom_generator.rb

@@ -11,11 +11,11 @@ module Neruda
       @index[index_name][0...10].each do |article|
         content << atom_entry(article)
       end
-      content.join("\n") + '</feed>'
+      format '%<content>s</feed>', content: content.join("\n")
     end
 
     def write_atom(index_name)
-      return 0 if @blog_path.nil?
+      return unless save?
       slug = Neruda::OrgFile.slug index_name
       FileUtils.mkdir_p "#{@pubdir}/feeds"
       atomdest = "#{@pubdir}/feeds/#{slug}.xml"
@@ -31,17 +31,17 @@ module Neruda
     def atom_header(title)
       domain = Neruda::Config.settings['domain']
       upddate = @date.rfc3339
-      slug = Neruda::OrgFile.slug(title)
-      tagurl = "#{domain}/tags/#{slug}.html"
       if title == 'index'
-        if Neruda::Config.settings['title']
-          title = Neruda::Config.settings['title']
-        end
-        tagurl = "#{domain}/#{@blog_path}"
-      elsif @tags_names.has_key?(title)
+        slug = 'index'
+        tagurl = domain
+        title = Neruda::Config.settings['title'] || \
+                R18n.t.neruda.index.all_tags
+      else
+        slug = Neruda::OrgFile.slug(title)
+        tagurl = "#{domain}/tags/#{slug}.html"
         title = @tags_names[title]
       end
-      title_esc = CGI.escapeHTML(title)
+      title = CGI.escapeHTML(title)
       <<~ENDATOM
         <?xml version="1.0" encoding="utf-8"?>
         <feed xmlns="http://www.w3.org/2005/Atom"
@@ -49,13 +49,13 @@ module Neruda
               xmlns:wfw="http://wellformedweb.org/CommentAPI/"
               xml:lang="#{Neruda::Config.settings['lang']}">
 
-        <title>#{title_esc}</title>
+        <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_esc}"/>
+        <link href="#{tagurl}" rel="alternate" type="text/html" title="#{title}"/>
         <updated>#{upddate}</updated>
         <author><name>#{Neruda::Config.settings['author'] || ''}</name></author>
         <id>urn:md5:#{Digest::MD5.hexdigest(domain)}</id>
-        <generator uri="https://fossil.deparis.io/neruda">Neruda</generator>
+        <generator uri="https://git.umaneti.net/neruda/about/">Neruda</generator>
       ENDATOM
     end
 
@@ -69,12 +69,12 @@ module Neruda
         "<dc:subject>#{CGI.escapeHTML(k)}</dc:subject>"
       end.join
       keywords += "\n  " if keywords != ''
-      title_esc = CGI.escapeHTML(article.title)
+      title = CGI.escapeHTML(article.title)
       <<~ENDENTRY
         <entry>
-          <title>#{title_esc}</title>
+          <title>#{title}</title>
           <link href="#{article.url}" rel="alternate" type="text/html"
-                title="#{title_esc}"/>
+                title="#{title}"/>
           <id>urn:md5:#{Digest::MD5.hexdigest(article.timekey)}</id>
           <published>#{article.datestring(:rfc3339)}</published>
           <author><name>#{CGI.escapeHTML(article.author)}</name></author>

data/lib/neruda/index/org_generator.rb

@@ -4,73 +4,95 @@ module Neruda
   # Embeds methods responsible for generating an org file for a given
   #   index.
   module IndexOrgGenerator
-    def to_org(index_name = 'index')
-      content = [org_header(index_name).strip]
-      last_year = nil
-      @index[index_name].each do |article|
-        year = article.timekey.slice(0, 4)
-        if year != last_year
-          content << ''
-          content << org_title(year)
-          last_year = year
-        end
-        content << org_entry(article)
-      end
-      content.join("\n")
+    def to_org(index_name = 'index', is_project: false)
+      return project_home_page(index_name) if is_project
+      return all_tags_index if index_name == 'index'
+      [org_header(index_name),
+       org_articles(@index[index_name])].join("\n")
     end
     alias_method :to_s, :to_org
 
     def write_org(index_name)
-      return 0 if @blog_path.nil?
-      FileUtils.mkdir_p 'src/tags' unless index_name == 'index'
-      src = index_source_path(index_name)
-      IO.write(src, to_org(index_name))
+      return unless save?
+      slug = Neruda::OrgFile.slug index_name
+      FileUtils.mkdir 'tags' unless Dir.exist? 'tags'
+      content = to_org index_name
+      orgdest = "tags/#{slug}.org"
+      IO.write(orgdest, content)
     end
 
-    def write_org_lists
-      return 0 if @blog_path.nil?
-      domain = Neruda::Config.settings['domain']
-      content = [org_header(R18n.t.neruda.index.all_tags)]
+    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])
+      end
+      content.join("\n")
+    end
+
+    def write_all_blog_home(verbose)
+      Neruda::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'])
+        IO.write(orgdest, to_org(project['name'], is_project: true))
+      end
+    end
+
+    def all_tags_index
+      content = [
+        org_header(R18n.t.neruda.index.all_tags, is_tag: false)
+      ]
       sort_tags_by_name_and_weight.each do |t, tags|
         content << ''
         content << org_title(R18n.t.neruda.index.send(t), 'index-tags')
+        next if tags.empty?
         tags.each do |k|
-          title = @tags_names[k] || k
-          link = "[[#{domain}/tags/#{k}.html][#{title}]]"
-          content << "- #{link} (#{@index[k].length})"
+          content << "- #{tag_published_url(k)} (#{@index[k].length})"
         end
       end
-      FileUtils.mkdir_p 'src/tags'
-      src = 'src/tags/index.org'
-      IO.write(src, content.join("\n"))
+      content.join("\n")
     end
 
-    private
-
-    def index_source_path(index_name)
-      slug = Neruda::OrgFile.slug index_name
-      src = ['src', 'tags', "#{slug}.org"]
-      src[1] = @blog_path if slug == 'index'
-      src.join('/')
+    def tag_published_url(tag_name)
+      domain = Neruda::Config.settings['domain']
+      title = @tags_names[tag_name]
+      tag_link = "#{domain}/tags/#{tag_name}.html"
+      "[[#{tag_link}][#{title}]]"
     end
 
-    def org_header(title = nil)
-      if title.nil? || title == 'index'
-        title = Neruda::Config.settings['title']
-      elsif @tags_names.has_key?(title)
+    def org_header(title = nil, is_tag: true)
+      if is_tag
         title = @tags_names[title]
+      elsif title.nil? || title == 'index'
+        title = Neruda::Config.settings['title']
       end
-      <<~HEADER
+      <<~HEADER.strip
         #+title: #{title}
         #+author: #{Neruda::Config.settings['author']}
         #+language: #{Neruda::Config.settings['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
+        end
+        year_title + org_entry(article)
+      end
+    end
+
     def org_entry(article)
-      line = "- *[[..#{article.html_file}][#{article.title}]]*"
+      line = "- *[[#{article.url}][#{article.title}]]*"
       if article.date
-        art_date = article.datestring(:full, false)
+        art_date = article.datestring(:full, year: false)
         published = R18n.t.neruda.index.published_on art_date
         line += " / #{published}"
       end