fronde 0.3.4 → 0.4.0

data/lib/fronde/source/html.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Fronde
+  class Source
+    # Specific settings for HTML {Fronde::Source}
+    class Html < Source
+      def org_config
+        config = super
+        config[0]['theme'] = @config['theme']
+        config
+      end
+
+      class << self
+        def org_default_postamble
+          <<~POSTAMBLE
+            <p><span class="author">#{R18n.t.fronde.org.postamble.written_by}</span>
+            #{R18n.t.fronde.org.postamble.with_emacs_html}</p>
+            <p class="date">#{R18n.t.fronde.org.postamble.last_modification}</p>
+            <p class="validation">%v</p>
+          POSTAMBLE
+        end
+      end
+
+      private
+
+      def fill_in_specific_config
+        @config.merge!(
+          'type' => 'html', 'ext' => '.html', 'mime_type' => 'text/html',
+          'folder' => CONFIG.get('html_public_folder')
+        )
+      end
+
+      def org_publish_options
+        if @config['is_blog']
+          @config['atom_feed'] = <<~ATOMFEED
+            <link rel="alternate" type="application/atom+xml" title="#{@config['title']}"
+                  href="#{@config['domain']}#{public_absolute_path}feeds/index.xml" />
+          ATOMFEED
+        end
+        super
+      end
+
+      def org_default_options # rubocop:disable Metrics/MethodLength
+        defaults = {
+          'publishing-function' => 'org-html-publish-to-html',
+          'html-head-include-default-style' => 't',
+          'html-head-include-scripts' => 't',
+          'html-head' => '{{ atom_feed }}',
+          'html-postamble' => Html.org_default_postamble
+        }
+        return defaults if @config['theme'] == 'default'
+
+        defaults.merge(
+          'html-head-include-default-style' => 'nil',
+          'html-head-include-scripts' => 'nil',
+          'html-head' => <<~HTMLHEAD
+            <link rel="stylesheet" type="text/css" media="screen"
+                  href="{{ domain }}/assets/{{ theme }}/css/style.css">
+            <link rel="stylesheet" type="text/css" media="screen"
+                  href="{{ domain }}/assets/{{ theme }}/css/htmlize.css">
+            {{ atom_feed }}
+          HTMLHEAD
+        )
+      end
+    end
+  end
+end

data/lib/fronde/source.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Fronde
+  # Wrapper for each possible project source.
+  # Must be subclassed by specific source type (like Gemini or HTML)
+  class Source
+    def initialize(source_config)
+      @config = {
+        'recursive' => true, 'is_blog' => false,
+        'domain' => CONFIG.get('domain'), 'atom_feed' => '',
+        'org-options' => {
+          'section-numbers' => 'nil', 'with-toc' => 'nil'
+        }
+      }.merge(source_config)
+      clean_config
+      org_publish_options
+      render_heading
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def []=(key, value)
+      @config[key] = value
+    end
+
+    def type
+      @config['type']
+    end
+
+    def recursive?
+      !!@config['recursive']
+    end
+
+    def blog?
+      !!@config['is_blog']
+    end
+
+    def to_h
+      @config
+    end
+
+    def source_for?(file_name)
+      relative_file_path = file_name.delete_prefix "#{@config['path']}/"
+      # file_name does not begin with source path.
+      return false if relative_file_path == file_name
+
+      # Looks like a file at a deeper level, but current source is not
+      # recursive.
+      return false if relative_file_path.include?('/') && !recursive?
+
+      # We don’t check file if the file really exist as the current
+      # check may be done before the file is actually written.
+      true
+    end
+
+    def source_for(file_name)
+      relative_file_path = file_name.delete_prefix "#{publication_path}/"
+      # file_name does not begin with source path.
+      return nil if relative_file_path == file_name
+
+      # Looks like a file at a deeper level, but current source is not
+      # recursive.
+      return nil if relative_file_path.include?('/') && !recursive?
+
+      # Looks like a match. But does a source file for this one actually
+      # exists?
+      relative_source_path = relative_file_path.sub(
+        /#{@config['ext']}\z/, '.org'
+      )
+      source_path = File.join(@config['path'], relative_source_path)
+      return nil unless File.file?(source_path)
+
+      source_path
+    end
+
+    def target_for(file_name)
+      target = File.expand_path file_name
+      target.delete_prefix! "#{Dir.pwd}/"
+      target.sub!(/\.org\z/, @config['ext'])
+      project_relative_path = @config['path'].delete_prefix("#{Dir.pwd}/")
+      target.delete_prefix! "#{project_relative_path}/"
+      public_absolute_path + target
+    end
+
+    def exclude_file?(file_name)
+      # Obviously excluding index itself for blogs
+      return true if file_name == File.join(@config['path'], 'index.org')
+
+      exclusion_rules = @config['exclude']
+      return false unless exclusion_rules
+
+      file_name.match? exclusion_rules
+    end
+
+    def org_config
+      name = @config['name']
+      [{ 'name' => name, 'attributes' => org_project_config },
+       { 'name' => "#{name}-assets", 'attributes' => org_assets_config }]
+    end
+
+    # Return the publication absolute path on file system.
+    #
+    # The returned string never end with a slash (/).
+    #
+    # Use {Fronde::Source#public_absolute_path} to get the absolute path
+    # of this project, as seen from a web browser.
+    #
+    # @return [String] the absolute path to the target dir of this project
+    def publication_path
+      return @config['publication_path'] if @config['publication_path']
+
+      publish_in = [File.expand_path(@config['folder']), @config['target']]
+      @config['publication_path'] = publish_in.join('/').delete_suffix('/')
+    end
+
+    # Return the absolute path as seen in User Agent.
+    #
+    # The returned string always end with a slash (/).
+    #
+    # Use {Fronde::Source#publication_path} to locate published file on
+    # the file system.
+    #
+    # @return [String] the absolute path to this project
+    def public_absolute_path
+      return @config['public_absolute_path'] if @config['public_absolute_path']
+
+      @config['public_absolute_path'] = "/#{@config['target']}/".squeeze('/')
+    end
+
+    class << self
+      def canonical_config(config)
+        config = { 'path' => config } if config.is_a?(String)
+        config['type'] ||= 'html'
+        config
+      end
+
+      def new_from_config(config)
+        klass_name = config['type'].capitalize
+        klass = Kernel.const_get("::Fronde::Source::#{klass_name}")
+        klass.new(config)
+      end
+    end
+
+    private
+
+    def clean_config
+      fill_in_specific_config
+      @config['name'] ||= @config['path'].sub(/^[.~]*\//, '').tr('/.', '-')
+      @config['title'] ||= @config['path']
+      @config['target'] ||= File.basename(@config['path']).delete_prefix '.'
+      @config['target'] = '' if @config['target'] == '.'
+      @config['path'] = File.expand_path(@config['path'])
+      @config['theme'] ||= CONFIG.get('theme', 'default')
+      # Blog are necessarily recursive to allow publication of tags and feeds
+      @config['recursive'] = true if @config['is_blog']
+    end
+
+    def org_publish_options
+      type = @config['type']
+      options = org_default_options.merge(
+        @config['org-options'],
+        CONFIG.get("org-#{type}", {}),
+        @config["org-#{type}"] || {}
+      )
+      @config['org-options'] = options
+    end
+
+    def render_heading
+      heading_key = "#{@config['type']}-head"
+      heading = @config.dig 'org-options', heading_key
+      @config['org-options'][heading_key] = \
+        Config::Helpers.render_liquid_template(
+          heading, to_h
+        )
+    end
+
+    def org_project_config
+      attributes = {
+        'base-directory' => @config['path'],
+        'base-extension' => 'org',
+        'publishing-directory' => publication_path,
+        'recursive' => @config['recursive']
+      }.merge(@config['org-options'])
+      exclude = @config['exclude']
+      attributes['exclude'] = exclude if exclude
+      attributes.sort.to_h # Have lisp config sorted
+    end
+
+    def org_assets_config
+      {
+        'base-directory' => @config['path'],
+        'base-extension' => %w[gif jpg png svg pdf].join('\\\\|'),
+        'publishing-directory' => publication_path,
+        'publishing-function' => 'org-publish-attachment',
+        'recursive' => @config['recursive']
+      }
+    end
+  end
+end
+
+require_relative 'source/gemini'
+require_relative 'source/html'

data/lib/fronde/templater.rb

@@ -2,117 +2,140 @@
 
 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
+      # 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)
+      # Do nothing if we don’t have a reliable content to work with
+      unless node.any?
+        warn(
+          R18n.t.fronde.error.templater.no_element_found(
+            source: source,
+            file: Fronde::CONFIG.get('html_public_folder') + @org_file.pub_file
+          )
+        )
+        return ''
       end
+
+      @config['source'] = node
+      node.to_s
     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 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.4.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,61 +2,57 @@
 
 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', '.dir-locals.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
+    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|
+    begin
+      # No need to force fetch last version as it is only interesting as
+      # part of the upgrade task
+      org_version = Fronde::Org.last_version
+    rescue RuntimeError
+      next
+    end
     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
   end
 
@@ -77,29 +73,53 @@ 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
+    Fronde::Config::Helpers.write_dir_locals
+  end
+
+  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
+    # I need a fully installed org mode to correctly generate the lisp
+    # config
+    Rake::Task['.dir-locals.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