fronde 0.3.4 → 0.5.0

data/lib/fronde/templater.rb

@@ -2,117 +2,147 @@
 
 require 'nokogiri'
 require 'digest/md5'
-require 'fronde/org_file'
+require_relative 'org/file'
 
 module Fronde
+  class NoHeadError < ::StandardError; end
+
   # Insert custom part inside generated HTML files.
   class Templater
-    def initialize(source, dom, opts = {})
+    def initialize(source, dom, config = {})
       @dom = dom
       @org_file = source
-      @position = opts['type'] || 'after'
-      @content = extract_content opts
-      @element = @dom.css(opts['selector'])
-      digest = Digest::MD5.hexdigest(@content)
-      @check_line = " Fronde Template: #{digest} "
+      @config = { 'type' => 'after' }.merge(config)
+      digest = Digest::MD5.hexdigest(config.to_s)
+      @config['check_line'] = " Fronde Template: #{digest} "
     end
 
     def apply
-      flag_head
-      content = @org_file.format(@content)
-      @element.each do |e|
-        insert_new_node_at e, content
+      # Flag the file for this template
+      head = @dom.xpath('//head').first
+      raise NoHeadError, self unless head
+
+      head.prepend_child("<!--#{@config['check_line']}-->")
+      content = @org_file.format extract_content
+      # Remove source element if necessary to avoid doubling it during
+      # the insert action
+      @config['source'].unlink if @config.has_key? 'source'
+      # Insert new content
+      @dom.css(@config['selector']).each do |element|
+        insert_new_node_at element, content
       end
     end
 
     def in_head?
-      @dom.xpath('//head').children.to_a.filter(&:comment?).each do |c|
-        return true if c.text == @check_line
+      @dom.xpath('//head').children.any? do |child|
+        next false unless child.comment?
+
+        child.text == @config['check_line']
+      end
+    end
+
+    def valid?(file_name)
+      return false unless @config.has_key?('selector')
+
+      unless @config.has_key?('content') || @config.has_key?('source')
+        return false
       end
-      false
+
+      check_path(file_name)
     end
 
     class << self
-      def customize_output(file_name, source = nil)
-        templates_to_apply = filter_templates(file_name)
-        return if templates_to_apply.empty?
-        if source.nil?
-          sourcepath = Fronde::OrgFile.source_for_target(file_name)
-          source = Fronde::OrgFile.new(sourcepath)
-        end
+      def customize_output(file_name)
+        source = Fronde::Org::File.new(file_name)
+        # Return if no org file found for this published file
+        return if source.file.end_with?(file_name)
+
         dom = open_dom(file_name)
-        templates_to_apply.each do |t|
-          tpl = Fronde::Templater.new(source, dom, t)
-          next if tpl.in_head?
-          tpl.apply
-        end
-        write_dom(file_name, dom)
+        updated = apply_templates(source, dom, file_name)
+        write_dom(file_name, dom) if updated
       end
 
       private
 
-      def filter_templates(file_name)
-        templates = Fronde::Config.get('templates')
-        return [] if templates.nil? || templates.empty?
-        templates.filter { |t| check_required_keys(t, file_name) }
+      def apply_templates(source, dom, file_name)
+        Fronde::CONFIG.get('templates', []).map do |config|
+          template = Fronde::Templater.new(source, dom, config)
+          next if !template.valid?(file_name) || template.in_head?
+
+          template.apply
+          true
+        rescue NoHeadError
+          warn R18n.t.fronde.error.templater.no_head_element(file: file_name)
+          next
+        end.any?
       end
 
       def open_dom(file_name)
-        file = File.new file_name, 'r'
-        dom = Nokogiri::HTML file
-        file.close
-        dom
+        File.open(file_name, 'r') do |file|
+          Nokogiri::HTML file
+        end
       end
 
       def write_dom(file_name, dom)
-        file = File.new file_name, 'w'
-        dom.write_to file
-        file.close
-      end
-
-      def check_path(file_name, pathes)
-        pub_folder = Fronde::Config.get('public_folder')
-        if pathes.is_a?(Array)
-          pathes.each do |tp|
-            return true if File.fnmatch?("#{pub_folder}#{tp}",
-                                         file_name, File::FNM_DOTMATCH)
-          end
-          return false
+        File.open(file_name, 'w') do |file|
+          dom.write_to file
         end
-        File.fnmatch?("#{pub_folder}#{pathes}",
-                      file_name, File::FNM_DOTMATCH)
-      end
-
-      def check_required_keys(opts, file_name)
-        return false unless opts.has_key?('selector')
-        return false unless opts.has_key?('content') || opts.has_key?('source')
-        return check_path(file_name, opts['path']) if opts.has_key?('path')
-        true
       end
     end
 
     private
 
-    def flag_head
-      @dom.xpath('//head').first.prepend_child("<!--#{@check_line}-->\n")
-    end
-
-    def insert_new_node_at(elem, content)
-      case @position
+    def insert_new_node_at(element, content)
+      case @config['type']
       when 'before'
-        elem.add_previous_sibling content
+        element.add_previous_sibling content
       when 'replace'
-        elem.replace content
+        element.replace content
       else
-        elem.add_next_sibling content
+        element.add_next_sibling content
       end
     end
 
-    def extract_content(opts)
-      return opts['content'] if opts['content']
-      # If we don't have a content option, then we must have a source
-      # one.
-      @dom.css(opts['source']).unlink.to_s
+    def warn_no_element(source)
+      pub_folder = Fronde::CONFIG.get('html_public_folder').sub(
+        /^#{Dir.pwd}/, '.'
+      )
+      warn(
+        R18n.t.fronde.error.templater.no_element_found(
+          source: source, file: "#{pub_folder}#{@org_file.pub_file}"
+        )
+      )
+      '' # Return empty string
+    end
+
+    def extract_content
+      # We must either have a source or a content key
+      source = @config.delete 'source'
+      unless source.is_a?(String) && source != ''
+        return @config['content'] || ''
+      end
+
+      node = @dom.css(source)
+      if node.any?
+        # Put it back in config
+        @config['source'] = node
+        return node.to_s
+      end
+
+      # Do nothing if we don’t have a reliable content to work with
+      warn_no_element source
+    end
+
+    def check_path(file_name)
+      paths = @config['path']
+      return true unless paths
+
+      paths = [paths] unless paths.is_a? Array
+
+      pub_folder = Fronde::CONFIG.get('html_public_folder')
+      paths.any? do |template_path|
+        File.fnmatch?("#{pub_folder}#{template_path}", file_name)
+      end
     end
   end
 end

data/lib/fronde/version.rb

@@ -2,5 +2,5 @@
 
 module Fronde
   # @return [String] the version number of the current Fronde release.
-  VERSION = '0.3.4'
+  VERSION = '0.5.0'
 end

data/lib/tasks/cli.rake

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../fronde/cli/opt_parse'
+
+namespace :cli do
+  desc 'Generate an autocomplete file for zsh'
+  task :zsh_complete do
+    data = {}
+    all_commands = Fronde::CLI::OptParse::FRONDE_COMMANDS
+    data['commands'] = all_commands.filter_map do |command, options|
+      next if options[:alias] || command == 'basic'
+
+      opts = (options[:opts] || []).map do |opt|
+        opt_config = Fronde::CLI::OptParse::FRONDE_OPTIONS[opt]
+        keyword = nil
+        unless opt_config[:boolean]
+          keyword = opt_config[:keyword] || opt_config[:long].upcase
+        end
+        { 'short' => opt,
+          'long' => "--#{opt_config[:long]}",
+          'keyword' => keyword }
+      end
+
+      translation = R18n.t.fronde.bin.commands[command].tr("'", '’')
+      { 'name' => command,
+        'translation' => translation,
+        'options' => opts }
+    end
+    source = File.expand_path '../fronde/cli/data/zsh_completion', __dir__
+    template = Liquid::Template.parse(File.read(source))
+    puts template.render(data)
+  end
+end

data/lib/tasks/org.rake

@@ -2,62 +2,56 @@
 
 require 'open-uri'
 
-# Fronde::Config is required by Fronde::Utils
-require 'fronde/utils'
+require_relative '../fronde/config'
+require_relative '../fronde/cli/throbber'
 
 require 'rake/clean'
 
 CLOBBER.push(
-  'var/tmp/org.tar.gz', 'var/tmp/last_org_version',
-  'var/lib/org-config.el', '.dir-locals.el', 'lib/htmlize.el'
+  'var/lib/org-config.el', 'lib/htmlize.el'
 )
 
-def make_org_cmd(org_dir, target)
-  make = ['make', '-C', org_dir, target]
-  return make.join(' ') if verbose
-  make.insert(3, '-s')
-  make << 'EMACSQ="emacs -Q --eval \'(setq inhibit-message t)\'"'
-  make.join(' ')
-end
-
 namespace :org do
   directory 'var/tmp'
 
   desc 'Download last version of Org'
   file 'var/tmp/org.tar.gz' => 'var/tmp' do
-    download = Thread.new do
-      Thread.current[:org_version] = Fronde::Config.org_last_version
-      Fronde::Utils.download_org
-    end
+    # Weird Rake issue, still executing the task even if the file exists
+    next if File.exist? 'var/tmp/org.tar.gz'
+
+    download = Thread.new { Fronde::Org.download }
     if verbose
-      download.join
-      warn "Org version #{download[:org_version]} has been downloaded"
+      warn R18n.t.fronde.tasks.org.downloaded(version: download.value)
     else
-      Fronde::Utils.throbber(download, 'Downloading Org:')
+      Fronde::CLI::Throbber.run(download, R18n.t.fronde.tasks.org.downloading)
     end
+  rescue RuntimeError, Interrupt
+    warn R18n.t.fronde.tasks.org.no_download if verbose
   end
 
   desc 'Compile Org'
-  task compile: 'var/tmp/org.tar.gz' do |task|
-    org_version = Fronde::Config.org_last_version
+  multitask compile: ['var/tmp/org.tar.gz', 'lib'] do |task|
+    # No need to force fetch last version as it is only interesting as
+    # part of the upgrade task
+    org_version = Fronde::Org.last_version
+
     org_dir = "lib/org-#{org_version}"
     next if Dir.exist?("#{org_dir}/lisp")
+
     build = Thread.new do
-      sh "tar -C lib -xzf #{task.prerequisites[0]}"
-      mv "lib/org-mode-release_#{org_version}", org_dir
-      sh make_org_cmd(org_dir, 'compile')
-      sh make_org_cmd(org_dir, 'autoloads')
-      Dir.glob('lib/org-[0-9.]*').each do |ov|
-        next if ov == org_dir
-        rm_r ov
-      end
+      Fronde::Org.compile(
+        task.prerequisites[0], org_version, org_dir, verbose: verbose
+      )
+      Dir.glob('lib/org-[0-9.]*').each { rm_r _1 unless _1 == org_dir }
     end
     if verbose
       build.join
-      warn "#{org_version} has been locally installed"
+      warn R18n.t.fronde.tasks.org.installed(version: org_version)
     else
-      Fronde::Utils.throbber(build, 'Installing Org:')
+      Fronde::CLI::Throbber.run(build, R18n.t.fronde.tasks.org.installing)
     end
+  rescue RuntimeError, Interrupt
+    next
   end
 
   directory 'lib'
@@ -77,29 +71,50 @@ namespace :org do
   end
 
   file 'var/lib/org-config.el' => ['lib/htmlize.el', 'lib/ox-gmi.el'] do
-    Fronde::Config.write_org_lisp_config
+    Fronde::CONFIG.write_org_lisp_config
   end
 
-  file '.dir-locals.el' => 'var/lib/org-config.el' do
-    Fronde::Config.write_dir_locals
+  file '.gitignore' do
+    next if File.exist? '.gitignore'
+
+    upstream = File.expand_path(
+      '../fronde/cli/data/gitignore', __dir__
+    )
+    cp upstream, '.gitignore'
   end
 
   desc 'Install Org'
-  multitask install: ['org:compile', '.dir-locals.el'] do
-    mkdir_p "#{Fronde::Config.get('public_folder')}/assets"
-    Fronde::Config.sources.each do |s|
-      mkdir_p s['path'] unless Dir.exist? s['path']
+  multitask install: ['org:compile', '.gitignore'] do
+    # lib/htmlize.el and lib/ox-gmi.el cannot be generated in parallel
+    # of org:compilation, as it will leads to a weird SSL error. Thus
+    # finishing file generation "manually" here.
+    Rake::Task['var/lib/org-config.el'].invoke
+    sources = Fronde::CONFIG.sources
+    sources.each { mkdir_p _1['path'] }
+
+    outputs = sources.map { _1['type'] }.uniq
+    if outputs.include?('html')
+      mkdir_p "#{Fronde::CONFIG.get('html_public_folder')}/assets"
+    end
+    if outputs.include?('gemini')
+      mkdir_p Fronde::CONFIG.get('gemini_public_folder')
     end
   end
 
-  # The following task only run the clobber task (not provided by us)
-  # and the org:install one, which is already tested. Thus, we can
-  # safely remove it from coverage.
-  # :nocov:
   desc 'Upgrade Org'
   task :upgrade do
     Rake::Task['clobber'].execute
+    if File.exist? 'var/tmp/org.tar.gz'
+      # Cleanup cached tarball only if a new version is available.
+      # Also cached the new remote org version in the same time.
+      org_version = Fronde::Org.current_version
+      begin
+        last_version = Fronde::Org.last_version(force: true)
+      rescue RuntimeError
+        last_version = org_version
+      end
+      File.unlink 'var/tmp/org.tar.gz' unless org_version == last_version
+    end
     Rake::Task['org:install'].invoke
   end
-  # :nocov:
 end

data/lib/tasks/site.rake

@@ -1,54 +1,89 @@
 # frozen_string_literal: true
 
-require 'fronde/emacs'
-require 'fronde/index'
-require 'fronde/utils'
-require 'fronde/org_file'
-require 'fronde/templater'
+require_relative '../fronde/emacs'
+require_relative '../fronde/index'
+require_relative '../fronde/templater'
+require_relative '../fronde/cli/throbber'
 
 namespace :site do
-  desc 'Generates all index files'
-  task :index do
-    index = Fronde::Index.new
-    if verbose
-      index.write_all
-      next
+  desc 'Build all your projects'
+  task :build, [:force?] => ['var/lib/org-config.el'] do |_, args|
+    args.with_defaults(force?: false)
+    build_index = Thread.new do
+      all_index = Fronde::Index.all_blog_index
+      all_index.each do |index|
+        index.write_all_org(verbose: verbose)
+      end
+      Thread.current[:all_indexes] = all_index
     end
-    build = Thread.new do
-      index.write_all(verbose: false)
+    if verbose
+      build_index.join
+    else
+      Fronde::CLI::Throbber.run(
+        build_index, R18n.t.fronde.tasks.site.generating_indexes
+      )
     end
-    Fronde::Utils.throbber(build, 'Generating indexes:')
-    next if index.empty?
-    Fronde::Config.write_org_lisp_config(with_tags: true)
-  end
+    all_indexes = build_index[:all_indexes]
 
-  desc 'Convert and customize all org files'
-  task :build, [:force?] => ['var/lib/org-config.el', :index] do |_, args|
-    args.with_defaults(:force? => false)
     build_html = Thread.new do
       rm_r 'var/tmp/timestamps', force: true if args[:force?]
       Fronde::Emacs.new(verbose: verbose).publish
     end
-    begin
-      Fronde::Utils.throbber(build_html, 'Building:')
-    # :nocov:
-    rescue RuntimeError
-      warn 'Aborting'
-      next
+    Fronde::CLI::Throbber.run(build_html, R18n.t.fronde.tasks.site.building)
+
+    if all_indexes.any?
+      if verbose
+        all_indexes.each(&:write_all_feeds)
+      else
+        publish_feed = Thread.new do
+          all_indexes.each do |index|
+            index.write_all_feeds(verbose: false)
+          end
+        end
+        Fronde::CLI::Throbber.run(
+          publish_feed, R18n.t.fronde.tasks.site.publishing_feeds
+        )
+      end
     end
-    # :nocov:
+
+    next unless Fronde::CONFIG.sources.any? { |source| source.type == 'html' }
+
     customize_html = Thread.new do
-      pubfolder = Fronde::Config.get('public_folder')
+      pubfolder = Fronde::CONFIG.get('html_public_folder')
       Dir["#{pubfolder}/**/*.html"].each do |f|
         Fronde::Templater.customize_output(f)
       end
     end
-    Fronde::Utils.throbber(customize_html, 'Customizing:')
+    Fronde::CLI::Throbber.run(
+      customize_html, R18n.t.fronde.tasks.site.customizing
+    )
+    # :nocov:
+  rescue RuntimeError, Interrupt
+    warn R18n.t.fronde.tasks.site.aborting
+    next
+    # :nocov:
+  end
+
+  desc 'Cleanup orphaned published files'
+  task :clean do
+    pubfolder = Fronde::CONFIG.get('html_public_folder')
+    Dir["#{pubfolder}/**/*.html"].each do |file_name|
+      source = Fronde::Org::File.new(file_name)
+
+      # Return if an org file has been found for this published file
+      next unless source.file == file_name
+
+      print R18n.t.fronde.tasks.site.remove_orphan_file
+      action = $stdin.gets.strip.downcase
+      next unless action == 'y'
+
+      rm file_name
+    end
   end
 
   desc 'Start a test server'
   task :preview do
-    require 'fronde/preview'
-    Fronde.start_preview
+    require_relative '../fronde/preview'
+    Fronde::Preview.start
   end
 end

data/lib/tasks/sync.rake

@@ -1,56 +1,53 @@
 # frozen_string_literal: true
 
-require 'fronde/config'
-require 'fronde/utils'
+require_relative '../fronde/config'
+require_relative '../fronde/sync'
+require_relative '../fronde/cli/throbber'
 
-module Fronde
-  class SyncError < Error; end
-end
-
-def rsync_command(test = nil)
-  rsync_command = Fronde::Config.get('rsync')
-  return rsync_command unless rsync_command.nil?
-  optstring = []
-  optstring << 'n' if test
-  if verbose
-    optstring << 'v'
-  else
-    optstring << 'q'
-  end
-  "rsync -#{optstring.join}rlt --delete"
-end
-
-def pull_or_push(direction, label, test)
-  unless [:pull, :push].include? direction
-    raise Fronde::SyncError, 'Not a valid direction'
-  end
-  remote_path = Fronde::Config.get('remote')
-  raise Fronde::SyncError, 'No remote path set' if remote_path.nil?
-  public_folder = Fronde::Config.get('public_folder')
-  # Default is to push
-  cmd = ["#{public_folder}/", remote_path]
-  cmd.reverse! if direction == :pull
-  rsync = rsync_command(test)
-  publish_thread = Thread.new do
-    sh "#{rsync} #{cmd.join(' ')}"
-  end
-  Fronde::Utils.throbber(publish_thread, label)
+def source_types
+  Fronde::CONFIG.sources.map(&:type).uniq
 end
 
 namespace :sync do
   desc 'Push changes to server'
   task :push, :test? do |_, args|
-    pull_or_push(:push, 'Publishing:', args[:test?])
-  rescue Fronde::SyncError => e
-    warn e
+    source_types.each do |type|
+      publish_thread = Fronde::Sync.pull_or_push(
+        :push, type, test: args[:test?], verbose: verbose
+      )
+      if verbose
+        publish_thread.join
+      else
+        Fronde::CLI::Throbber.run(
+          publish_thread, format('Publishing %<fmt>s:', fmt: type)
+        )
+      end
+    rescue Fronde::Sync::Error => e
+      warn e
+      next
+    end
+  rescue RuntimeError, Interrupt
     next
   end
 
   desc 'Pull changes from server'
   task :pull, :test? do |_, args|
-    pull_or_push(:pull, 'Pulling:', args[:test?])
-  rescue Fronde::SyncError => e
-    warn e
+    source_types.each do |type|
+      pull_thread = Fronde::Sync.pull_or_push(
+        :pull, type, test: args[:test?], verbose: verbose
+      )
+      if verbose
+        pull_thread.join
+      else
+        Fronde::CLI::Throbber.run(
+          pull_thread, format('Pulling %<fmt>s:', fmt: type)
+        )
+      end
+    rescue Fronde::Sync::Error => e
+      warn e
+      next
+    end
+  rescue RuntimeError, Interrupt
     next
   end
 end

data/lib/tasks/tags.rake

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
-require 'fronde/index'
+require_relative '../fronde/index'
 
 namespace :tags do
   desc 'List all tags by name'
   task :name do
-    index = Fronde::Index.new
-    next if index.empty?
-    puts index.sort_by(:name).join("\n")
+    Fronde::Index.all_blog_index do |index|
+      next if index.empty?
+
+      puts index.sort_by(:name).join("\n")
+    end
   end
 
   desc 'List all tags by weight'
   task :weight do
-    index = Fronde::Index.new
-    next if index.empty?
-    puts index.sort_by(:weight).join("\n")
+    Fronde::Index.all_blog_index do |index|
+      next if index.empty?
+
+      puts index.sort_by(:weight).join("\n")
+    end
   end
 end