fronde 0.3.4 → 0.4.0

data/lib/fronde/org/file.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'time'
+require_relative '../../ext/nil_time'
+require_relative '../../ext/time'
+using TimePatch
+
+require 'nokogiri'
+require 'fileutils'
+
+require_relative '../config'
+require_relative '../version'
+require_relative '../slug'
+require_relative 'file_extracter'
+
+module Fronde
+  module Org
+    # Handles org files.
+    #
+    # This class is responsible for reading or writing existing or new
+    # org files, and formating their content to be used on the generated
+    # website.
+    class File
+      # @return [String] the relative path to the source of this
+      #   document.
+      attr_reader :file
+
+      # @return [Hash] the project owning this document.
+      attr_reader :project
+
+      include FileExtracter
+
+      # Prepares the file named by ~file_name~ for read and write
+      #   operations.
+      #
+      # If the file ~file_name~ does not exist, the new instance may be
+      # populated by data given in the ~opts~ parameter.
+      #
+      # @example
+      #     File.exist? './test.org'
+      #     => true
+      #     o = Fronde::Org::File.new('./test.org')
+      #     => #<Fronde::Org::File @file='./test.org'...>
+      #     o.title
+      #     => "This is an existing test file"
+      #     File.exist? '/tmp/does_not_exist.org'
+      #     => false
+      #     o = Fronde::Org::File.new('/tmp/does_not_exist.org')
+      #     => #<Fronde::Org::File @file='/tmp/does_not_exist.org'...>
+      #     o.title
+      #     => ""
+      #     File.exist? '/tmp/other.org'
+      #     => false
+      #     o = Fronde::Org::File.new('/tmp/other.org', title: 'New file')
+      #     => #<Fronde::Org::File @file='/tmp/other.org'...>
+      #     o.title
+      #     => "New file"
+      #
+      # @param file_name [String] path to the corresponding Org file
+      # @param opts [Hash] optional data to initialize new Org file
+      # @option opts [String] title ('') the title of the new Org file
+      # @option opts [String] author (system user or '') the author of
+      #   the document
+      # @return [Fronde::Org::File] the new instance of
+      #   Fronde::Org::File
+      def initialize(file_name, opts = {})
+        file_name ||= ''
+        @file = ::File.expand_path file_name
+        @options = opts
+        @project = find_source
+        @data = {}
+        if ::File.file?(@file)
+          extract_data
+        else
+          init_empty_file
+        end
+      end
+
+      # Returns a String representation of the document date, which aims
+      #   to be used to sort several Org::Files.
+      #
+      # The format used for the key is ~%Y%m%d%H%M%S~. If the current
+      # Org::File instance does not have a date, this mehod return
+      # ~00000000000000~. If the current Org::File instance does not
+      # have time information, the date is padded with zeros.
+      #
+      # @example with the org header ~#+date: <2019-07-03 Wed 20:52:49>~
+      #     org_file.date
+      #     => #<Time: 2019-07-03T20:52:49+02:00...>
+      #     org_file.timekey
+      #     => "20190703205349"
+      #
+      # @example with the org header ~#+date: <2019-07-03 Wed>~
+      #     org_file.date
+      #     => #<Time: 2019-07-03T00:00:00+02:00...>
+      #     org_file.timekey
+      #     => "20190703000000"
+      #
+      # @example with no date header in the org file
+      #     org_file.date
+      #     => nil
+      #     org_file.timekey
+      #     => "00000000000000"
+      #
+      # @return [String] the document key
+      def timekey
+        return '00000000000000' if @data[:date].is_a? NilTime
+
+        @data[:date].strftime('%Y%m%d%H%M%S')
+      end
+
+      # Formats given ~string~ with values of the current Org::File.
+      #
+      # This method expects to find percent-tags in the given ~string~
+      # and replace them by their corresponding value.
+      #
+      # It reuses the same tags than the ~org-html-format-spec~ method.
+      #
+      # *** Format:
+      #
+      # - %a :: the raw author name
+      # - %A :: the HTML rendering of the author name, equivalent to
+      #         ~<span class="author">%a</span>~
+      # - %d :: the ~:short~ date HTML representation, equivalent
+      #         to ~<time datetime="%I">%i</time>~
+      # - %D :: the ~:full~ date and time HTML representation
+      # - %i :: the raw ~:short~ date and time
+      # - %I :: the raw ~:iso8601~ date and time
+      # - %k :: the keywords separated by a comma
+      # - %K :: the HTML list rendering of the keywords
+      # - %l :: the lang of the document
+      # - %L :: the license information, taken from the
+      #         {Fronde::Config#settings}
+      # - %n :: the Fronde name and version
+      # - %N :: the Fronde name and version with a link to the project
+      #         home on the name
+      # - %s :: the subtitle of the document
+      # - %t :: the title of the document
+      # - %u :: the URL to the related published HTML document
+      # - %x :: the raw description (eXcerpt)
+      # - %X :: the description, enclosed in an HTML ~p~ tag, equivalent
+      #         to ~<p>%x</p>~
+      #
+      # @example
+      #     org_file.format("Article written by %a the %d")
+      #     => "Article written by Alice Smith the Wednesday 3rd July"
+      #
+      # @return [String] the given ~string~ after replacement occurs
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Layout/LineLength
+      def format(string)
+        string.gsub('%a', @data[:author])
+              .gsub('%A', "<span class=\"author\">#{@data[:author]}</span>")
+              .gsub('%d', @data[:date].l18n_short_date_html)
+              .gsub('%D', @data[:date].l18n_long_date_html)
+              .gsub('%i', @data[:date].l18n_short_date_string)
+              .gsub('%I', @data[:date].xmlschema)
+              .gsub('%k', @data[:keywords].join(', '))
+              .gsub('%K', keywords_to_html)
+              .gsub('%l', @data[:lang])
+              .gsub('%L', Fronde::CONFIG.get('license', '').gsub(/\s+/, ' ').strip)
+              .gsub('%n', "Fronde #{Fronde::VERSION}")
+              .gsub('%N', "<a href=\"https://git.umaneti.net/fronde/about/\">Fronde</a> #{Fronde::VERSION}")
+              .gsub('%s', @data[:subtitle])
+              .gsub('%t', @data[:title])
+              .gsub('%u', @data[:url] || '')
+              .gsub('%x', @data[:excerpt])
+              .gsub('%X', "<p>#{@data[:excerpt]}</p>")
+      end
+      # rubocop:enable Layout/LineLength
+      # rubocop:enable Metrics/MethodLength
+
+      # Writes the current Org::File content to the underlying file.
+      #
+      # The intermediate parent folders are created if necessary.
+      #
+      # @return [Integer] the length written (as returned by the
+      #   underlying ~File.write~ method call)
+      def write
+        if ::File.directory? @file
+          if @data[:title] == ''
+            raise R18n.t.fronde.error.org_file.no_file_or_title
+          end
+
+          @file = ::File.join @file, "#{Slug.slug(@data[:title])}.org"
+        else
+          file_dir = ::File.dirname @file
+          FileUtils.mkdir_p file_dir
+        end
+        ::File.write @file, @data[:content]
+      end
+
+      def method_missing(method_name, *args, &block)
+        reader_method = method_name.to_s.delete_suffix('=').to_sym
+        if @data.has_key? reader_method
+          return @data[reader_method] if reader_method == method_name
+
+          return @data[reader_method] = args.first
+        end
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        return true if @data.has_key? method_name
+
+        reader_method = method_name.to_s.delete_suffix('=').to_sym
+        return true if @data.has_key? reader_method
+
+        super
+      end
+
+      def to_h
+        fields = %w[author excerpt keywords timekey title url]
+        data = fields.to_h { |key| [key, send(key)] }
+        data['published_body'] = extract_published_body
+        pub_date = @data[:date]
+        data['published'] = pub_date.l18n_long_date_string(with_year: false)
+        data['published_xml'] = pub_date.xmlschema
+        data['updated_xml'] = @data[:updated]&.xmlschema
+        data
+      end
+
+      private
+
+      def find_source
+        if ::File.extname(@file) == '.org'
+          source = find_source_for_org_file
+        else
+          source = find_source_for_publication_file
+        end
+        warn R18n.t.fronde.error.org_file.no_project(file: @file) unless source
+        source
+      end
+
+      def find_source_for_org_file
+        Fronde::CONFIG.sources.find do |project|
+          project.source_for? @file
+        end
+      end
+
+      def find_source_for_publication_file
+        Fronde::CONFIG.sources.find do |project|
+          org_file = project.source_for @file
+          next unless org_file
+
+          @file = org_file
+        end
+      end
+
+      def init_empty_file
+        @data = {
+          title: @options[:title] || '', subtitle: '', excerpt: '',
+          date: Time.now,
+          author: @options[:author] || Fronde::CONFIG.get('author'),
+          keywords: [],
+          lang: @options[:lang] || Fronde::CONFIG.get('lang'),
+          pub_file: nil, url: nil
+        }
+        body = @options[:content] || ''
+        @data[:content] = @options[:raw_content] || <<~ORG
+          #+title: #{@data[:title]}
+          #+date: <#{@data[:date].strftime('%Y-%m-%d %a. %H:%M:%S')}>
+          #+author: #{@data[:author]}
+          #+language: #{@data[:lang]}
+
+          #{body}
+        ORG
+      end
+
+      # Format {Fronde::Org::File#keywords} list in an HTML listing.
+      #
+      # @return [String] the HTML keywords list
+      def keywords_to_html
+        domain = Fronde::CONFIG.get('domain')
+        # Allow a nil project, mainly for tests purpose. Should never
+        # happen in reality
+        pub_path = @project&.public_absolute_path || '/'
+        klist = @data[:keywords].map do |k|
+          %(<li class="keyword">
+            <a href="#{domain}#{pub_path}tags/#{Slug.slug(k)}.html">#{k}</a>
+              </li>)
+        end.join
+        %(<ul class="keywords-list">#{klist}</ul>)
+      end
+    end
+  end
+end

data/lib/fronde/org/file_extracter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+using TimePatch
+
+module Fronde
+  module Org
+    # This module holds extracter methods for the {Fronde::Org::File}
+    #   class.
+    module FileExtracter
+      private
+
+      # Main method, which will call the other to initialize an
+      #   {Fronde::Org::File} instance.
+      def extract_data
+        @data = { content: ::File.read(@file), pub_file: nil, url: nil }
+        %i[title subtitle date author keywords lang excerpt].each do |param|
+          @data[param] = send("extract_#{param}".to_sym)
+        end
+        return unless @project
+
+        @data[:updated] = ::File.mtime(@file)
+        @data[:pub_file] = @project.target_for @file
+        @data[:url] = Fronde::CONFIG.get('domain') + @data[:pub_file]
+      end
+
+      def extract_date
+        timerx = '([0-9:]{5})(?::([0-9]{2}))?'
+        daterx = /^#\+date: *<([0-9-]{10}) [\w.]+(?: #{timerx})?> *$/i
+        match = daterx.match(@data[:content])
+        return NilTime.new if match.nil?
+
+        notime = match[2].nil?
+        if notime
+          time = '00:00:00'
+        else
+          time = "#{match[2]}:#{match[3] || '00'}"
+        end
+        date = Time.strptime("#{match[1]} #{time}", '%Y-%m-%d %H:%M:%S')
+        date.no_time = notime
+        date
+      end
+
+      def extract_title
+        match = /^#\+title:(.+)$/i.match(@data[:content])
+        if match.nil?
+          # Avoid to leak absolute path
+          project_relative_path = @file.sub(/^#{Dir.pwd}\//, '')
+          return project_relative_path
+        end
+        match[1].strip
+      end
+
+      def extract_subtitle
+        match = /^#\+subtitle:(.+)$/i.match(@data[:content])
+        (match && match[1].strip) || ''
+      end
+
+      def extract_author
+        match = /^#\+author:(.+)$/i.match(@data[:content])
+        (match && match[1].strip) || Fronde::CONFIG.get('author')
+      end
+
+      def extract_keywords
+        match = /^#\+keywords:(.+)$/i.match(@data[:content])
+        (match && match[1].split(',').map(&:strip)) || []
+      end
+
+      def extract_lang
+        match = /^#\+language:(.+)$/i.match(@data[:content])
+        (match && match[1].strip) || Fronde::CONFIG.get('lang')
+      end
+
+      def extract_excerpt
+        @data[:content].scan(/^#\+description:(.+)$/i).map do |line|
+          line.first.strip
+        end.join(' ')
+      end
+
+      def extract_published_body
+        pub_file = @data[:pub_file]
+        # Always return something, even when not published yet
+        return @data[:excerpt] unless pub_file && @project
+
+        project_type = @project['type']
+        pub_folder = Fronde::CONFIG.get("#{project_type}_public_folder")
+        file_name = pub_folder + pub_file
+        return @data[:excerpt] unless ::File.exist? file_name
+
+        return ::File.read(file_name) if project_type == 'gemini'
+
+        dom = ::File.open(file_name, 'r') { |file| Nokogiri::HTML file }
+        body = dom.css('div#content')
+        body.css('header').unlink # Remove the main title
+        body.to_s
+      end
+    end
+  end
+end

data/lib/fronde/org.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Fronde
+  # Everything related to Org mode
+  #
+  # The module itself wraps code necessary to download the last version
+  # of the Emacs package. It also serves as a namespace for the class
+  # responsible for handling Org files: {Fronde::Org::File}.
+  module Org
+    class << self
+      def current_version
+        # Do not crash if Org is not yet installed (and thus return nil)
+        Dir['lib/org-*'].first&.delete_prefix('lib/org-')
+      end
+
+      # Fetch and return the last published version of Org.
+      #
+      # To be nice with Org servers, this method will keep the fetched
+      # version number in a cache file. You can bypass it by using the
+      # force parameter.
+      #
+      # @param force [Boolean] Whether we should first remove the guard
+      #   file if it exists
+      # @param destination [String] Where to store the cookie file to
+      #   remember the last version number
+      # @return [String] the new x.x.x version string of Org
+      def last_version(force: false, cookie_dir: 'var/tmp')
+        cookie = "#{cookie_dir}/last_org_version"
+        return ::File.read cookie if !force && ::File.exist?(cookie)
+
+        org_version = fetch_version_number
+        raise 'No remote Org version found' unless org_version
+
+        FileUtils.mkdir_p cookie_dir
+        ::File.write cookie, org_version
+        org_version
+      end
+
+      def fetch_version_number
+        # Retrieve last org version from git repository tags page.
+        tag_rx = Regexp.new(
+          '<a href=\'/cgit/emacs/org-mode.git/tag/\?h=' \
+          '(?<tag>release_(?<number>[^\']+))\'>\k<tag></a>'
+        )
+        versions = URI(
+          'https://git.savannah.gnu.org/cgit/emacs/org-mode.git/refs/'
+        ).open.readlines.map do |line|
+          line.match(tag_rx) { |matchdata| matchdata[:number] }
+        end
+        versions.compact.first
+      end
+
+      # Download latest org-mode tarball.
+      #
+      # @param destination [String] where to save the org-mode tarball
+      # @return [String] the downloaded org-mode version
+      def download(destination = 'var/tmp')
+        # Remove version number in dest file to allow easy rake file
+        # task naming
+        dest_file = ::File.expand_path('org.tar.gz', destination)
+        org_last_version = last_version(force: false, cookie_dir: destination)
+        tarball = "org-mode-release_#{org_last_version}.tar.gz"
+        uri = URI("https://git.savannah.gnu.org/cgit/emacs/org-mode.git/snapshot/#{tarball}")
+        # Will crash on purpose if anything goes wrong
+        Net::HTTP.start(uri.host) do |http|
+          request = Net::HTTP::Get.new uri
+
+          http.request request do |response|
+            ::File.open(dest_file, 'w') do |io|
+              response.read_body { |chunk| io.write chunk }
+            end
+          end
+        end
+        org_last_version
+      end
+
+      def make_org_cmd(org_dir, target, verbose: false)
+        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
+
+      # Compile downloaded Org package
+      #
+      # @param source [String] path to the org-mode tarball to install
+      # @param version [String] version of the org package to install
+      # @param target [String] path to the final install directory
+      # @param verbose [Boolean] whether the process should be verbose
+      def compile(source, version, target, verbose: false)
+        untar_cmd = ['tar', '-xzf', source]
+        system(*untar_cmd)
+        FileUtils.mv "org-mode-release_#{version}", target
+        # Fix a weird unknown package version
+        ::File.write("#{target}/mk/version.mk", "ORGVERSION ?= #{version}")
+        system(*make_org_cmd(target, 'compile', verbose: verbose))
+        system(*make_org_cmd(target, 'autoloads', verbose: verbose))
+      end
+    end
+  end
+end

data/lib/fronde/preview.rb

@@ -1,54 +1,58 @@
 # frozen_string_literal: true
 
 require 'webrick'
-require 'fronde/config'
-
-module Fronde # rubocop:disable Style/Documentation
-  # A tiny preview server, which main goal is to replace references to
-  # the target domain by localhost.
-  class PreviewServlet < WEBrick::HTTPServlet::AbstractServlet
-    include WEBrick::HTTPUtils
-
-    def do_GET(request, response) # rubocop:disable Naming/MethodName
-      file = local_path(request.path)
-      response.body = parse_body(file, "http://#{request.host}:#{request.port}")
-      response.status = 200
-      response.content_type = mime_type(file, DefaultMimeTypes)
-    end
+require_relative 'config'
 
-    private
+module Fronde
+  module Preview # rubocop:disable Style/Documentation
+    # A tiny preview server, which main goal is to replace references to
+    #   the target domain by localhost.
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      include WEBrick::HTTPUtils
 
-    def local_path(requested_path)
-      routes = Fronde::Config.get(['preview', 'routes'], {})
-      return routes[requested_path] if routes.has_key? requested_path
-      local_path = Fronde::Config.get('public_folder') + requested_path
-      if File.directory? local_path
-        local_path = format(
-          '%<path>s/index.html', path: local_path.delete_suffix('/')
-        )
+      def do_GET(request, response) # rubocop:disable Naming/MethodName
+        file = local_path(request.path)
+        response.body = parse_body(file, "http://#{request.host}:#{request.port}")
+        response.status = 200
+        response.content_type = mime_type(file, DefaultMimeTypes)
       end
-      return local_path if File.exist? local_path
-      raise WEBrick::HTTPStatus::NotFound, 'Not found.'
-    end
 
-    def parse_body(local_path, local_host)
-      body = File.read local_path
-      return body unless local_path.match?(/\.(?:ht|x)ml\z/)
-      domain = Fronde::Config.get('domain')
-      return body if domain == ''
-      body.gsub(/"file:\/\//, format('"%<host>s', host: local_host))
-          .gsub(/"#{domain}/, format('"%<host>s', host: local_host))
+      private
+
+      def local_path(requested_path)
+        routes = Fronde::CONFIG.get(%w[preview routes], {})
+        return routes[requested_path] if routes.has_key? requested_path
+
+        local_path = Fronde::CONFIG.get('html_public_folder') + requested_path
+        if File.directory? local_path
+          local_path = format(
+            '%<path>s/index.html', path: local_path.delete_suffix('/')
+          )
+        end
+        return local_path if File.exist? local_path
+
+        raise WEBrick::HTTPStatus::NotFound, 'Not found.'
+      end
+
+      def parse_body(local_path, local_host)
+        body = File.read local_path
+        return body unless local_path.match?(/\.(?:ht|x)ml\z/)
+
+        domain = Fronde::CONFIG.get('domain')
+        return body if domain == ''
+
+        host_repl = %("#{local_host})
+        body.gsub('"file://', host_repl).gsub(%("#{domain}), host_repl)
+      end
     end
-  end
 
-  class << self
-    def start_preview
+    def self.start
       # Inspired by ruby un.rb library, which allows normally to start a
       # webrick server in one line: ruby -run -e httpd public_html -p 5000
-      port = Fronde::Config.get(['preview', 'server_port'], 5000)
+      port = Fronde::CONFIG.get(%w[preview server_port], 5000)
       s = WEBrick::HTTPServer.new(Port: port)
-      s.mount '/', Fronde::PreviewServlet
-      ['TERM', 'QUIT', 'INT'].each { |sig| trap(sig, proc { s.shutdown }) }
+      s.mount '/', Servlet
+      %w[TERM QUIT INT].each { |sig| trap(sig, proc { s.shutdown }) }
       s.start
     end
   end

data/lib/fronde/slug.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fronde
+  # Contains method to generate URL compatible strings
+  module Slug
+    class << self
+      def slug(title)
+        title.downcase.tr(' ', '-')
+             .encode('ascii', fallback: ->(k) { translit(k) })
+             .gsub(/[^\w-]/, '').delete_suffix('-')
+      end
+
+      def translit(char)
+        return 'a' if %w[á à â ä ǎ ã å].include?(char)
+        return 'e' if %w[é è ê ë ě ẽ].include?(char)
+        return 'i' if %w[í ì î ï ǐ ĩ].include?(char)
+        return 'o' if %w[ó ò ô ö ǒ õ].include?(char)
+        return 'u' if %w[ú ù û ü ǔ ũ].include?(char)
+        return 'y' if %w[ý ỳ ŷ ÿ ỹ].include?(char)
+        return 'c' if char == 'ç'
+        return 'n' if char == 'ñ'
+
+        '-'
+      end
+    end
+  end
+end

data/lib/fronde/source/gemini.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Fronde
+  class Source
+    # Specific settings for Gemini {Fronde::Source}
+    class Gemini < Source
+      def blog?
+        # TODO: See how to support blog/indexes with gemini
+        false
+      end
+
+      class << self
+        def org_default_postamble
+          format(
+            "📅 %<date>s\n📝 %<author>s %<creator>s",
+            author: R18n.t.fronde.org.postamble.written_by,
+            creator: R18n.t.fronde.org.postamble.with_emacs,
+            date: R18n.t.fronde.org.postamble.last_modification
+          )
+        end
+      end
+
+      private
+
+      def fill_in_specific_config
+        @config.merge!(
+          'type' => 'gemini', 'ext' => '.gmi', 'mime_type' => 'text/gemini',
+          'folder' => CONFIG.get('gemini_public_folder')
+        )
+      end
+
+      def org_default_options
+        { 'publishing-function' => 'org-gmi-publish-to-gemini',
+          'gemini-head' => '',
+          'gemini-postamble' => Gemini.org_default_postamble }
+      end
+    end
+  end
+end