fronde 0.3.0

data/lib/fronde/preview.rb

@@ -0,0 +1,55 @@
+# 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
+
+    private
+
+    def local_path(requested_path)
+      routes = Fronde::Config.settings.dig('preview', 'routes') || {}
+      return routes[requested_path] if routes.has_key? requested_path
+      local_path = Fronde::Config.settings['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 = IO.read local_path
+      return body unless local_path.match?(/\.(?:ht|x)ml\z/)
+      domain = Fronde::Config.settings['domain']
+      return body if domain == ''
+      body.gsub(/"file:\/\//, format('"%<host>s', host: local_host))
+          .gsub(/"#{domain}/, format('"%<host>s', host: local_host))
+    end
+  end
+
+  class << self
+    def start_preview
+      # 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.settings.dig('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.start
+    end
+  end
+end

data/lib/fronde/templater.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'digest/md5'
+require 'fronde/org_file'
+
+module Fronde
+  # Insert custom part inside generated HTML files.
+  class Templater
+    def initialize(source, dom, opts = {})
+      @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} "
+    end
+
+    def apply
+      flag_head
+      content = @org_file.format(@content)
+      @element.each do |e|
+        insert_new_node_at e, content
+      end
+    end
+
+    def in_head?
+      @dom.xpath('//head').children.to_a.filter(&:comment?).each do |c|
+        return true if c.text == @check_line
+      end
+      false
+    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
+        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)
+      end
+
+      private
+
+      def filter_templates(file_name)
+        templates = Fronde::Config.settings['templates']
+        return [] if templates.nil? || templates.empty?
+        templates.filter { |t| check_required_keys(t, file_name) }
+      end
+
+      def open_dom(file_name)
+        file = File.new file_name, 'r'
+        dom = Nokogiri::HTML file
+        file.close
+        dom
+      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.settings['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
+        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
+      when 'before'
+        elem.add_previous_sibling content
+      when 'replace'
+        elem.replace content
+      else
+        elem.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
+    end
+  end
+end

data/lib/fronde/utils.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'rainbow'
+require 'net/http'
+require 'r18n-core'
+require 'fronde/config'
+
+module Fronde
+  # Embeds usefull methods, mainly used in rake tasks.
+  module Utils
+    # @return [Hash] the possible throbber themes
+    THROBBER_FRAMES = {
+      'basic' => '-\|/',
+      'basicdots' => '⋯⋱⋮⋰',
+      'moon' => '🌑🌒🌓🌔🌕🌖🌗🌘',
+      'clock' => '🕛🕐🕑🕒🕓🕔🕕🕖🕗🕘🕙🕚',
+      'bricks' => '⣷⣯⣟⡿⢿⣻⣽⣾',
+      'points' => '·⁘∷⁛∷⁘',
+      'quadrant2' => '▙▛▜▟',
+      'default' => ['⠁ ⠂ ⠄ ⡀ ⠄ ⠂ ⠁', '⠂ ⠁ ⠂ ⠄ ⡀ ⠄ ⠂', '⠄ ⠂ ⠁ ⠂ ⠄ ⡀ ⠄',
+                    '⡀ ⠄ ⠂ ⠁ ⠂ ⠄ ⡀', '⠄ ⡀ ⠄ ⠂ ⠁ ⠂ ⠄', '⠂ ⠄ ⡀ ⠄ ⠂ ⠁ ⠂']
+    }.freeze
+
+    # @return [Hash] the possible ~fronde~ options and their
+    #   configuration
+    FRONDE_OPTIONS = {
+      '-a' => { long: 'author' },
+      '-f' => { long: 'force', boolean: true },
+      '-h' => { long: 'help', boolean: true, meth: :on_tail },
+      '-l' => { long: 'lang', keyword: 'LOCALE' },
+      '-t' => { long: 'title' },
+      '-v' => { long: 'verbose', boolean: true, meth: :on_tail },
+      '-V' => { long: 'version', boolean: true, meth: :on_tail }
+    }.freeze
+
+    # @return [Hash] the possible ~fronde~ subcommands and their
+    #   configuration
+    FRONDE_COMMANDS = {
+      'init' => { opts: ['-a', '-h', '-l', '-t', '-v'] },
+      'config' => { alias: 'init' },
+      'preview' => { opts: ['-h'] },
+      'open' => { opts: ['-a', '-h', '-l', '-t', '-v'] },
+      'edit' => { alias: 'open' },
+      'build' => { opts: ['-f', '-h'] },
+      'publish' => { opts: ['-h'] },
+      'help' => { opts: ['-h'] },
+      'basic' => { opts: ['-h', '-V'], label: '<command>' }
+    }.freeze
+
+    class << self
+      # Animates strings in the user console to alert him that something
+      #   is running in the background.
+      #
+      # The animation is chosen among a bunch of themes, with the
+      # configuration option ~throbber~ (retrieved via
+      # {Fronde::Config#settings}).
+      #
+      # @example
+      #     long_stuff = Thread.new { very_long_operation }
+      #     Fronde::Utils.throbber(long_stuff, 'Computing hard stuff:')
+      #
+      # @param thread [Thread] the long-running operation to decorate
+      # @param message [String] the message to display before the throbber
+      # @return [void]
+      def throbber(thread, message)
+        frames = select_throbber_frames
+        begin
+          run_and_decorate_thread thread, message, frames
+        rescue RuntimeError => e
+          throbber_error message
+          raise e
+        else
+          done = Rainbow('done'.ljust(frames[0].length)).green
+          puts "#{message} #{done}"
+        end
+      end
+
+      # Returns the short and long options specification for a given
+      #   short option.
+      #
+      # This method use the {Fronde::Utils::FRONDE_OPTIONS} Hash to
+      # retrieve corresponding values.
+      #
+      # @example
+      #     spec = Fronde::Utils.decorate_option('-a')
+      #     => ['-a AUTHOR', '--author AUTHOR']
+      #
+      # @param short [String] the short option to decorate
+      # @return [Array] the short and long specification for an option
+      def decorate_option(short)
+        opt = Fronde::Utils::FRONDE_OPTIONS[short]
+        long = "--#{opt[:long]}"
+        return [short, long] if opt[:boolean]
+        key = opt[:keyword] || opt[:long].upcase
+        [short + key, format('%<long>s %<key>s', long: long, key: key)]
+      end
+
+      # Returns the ~fronde~ help summary for a given command.
+      #
+      # @param command [String] the command for which a summary
+      #   should be given
+      # @return [String]
+      def summarize_command(command)
+        Fronde::Utils::FRONDE_COMMANDS[command][:opts].map do |k|
+          short, long = Fronde::Utils.decorate_option(k)
+          opt = Fronde::Utils::FRONDE_OPTIONS[k]
+          label = [short, long].join(', ')
+          line = [format('    %<opt>s', opt: label).ljust(30)]
+          if R18n.t.fronde.bin.options[opt[:long]].translated?
+            line << R18n.t.fronde.bin.options[opt[:long]]
+          end
+          line.join(' ')
+        end.join("\n")
+      end
+
+      # Returns a formatted list of available commands for ~fronde~.
+      #
+      # @return [String]
+      def list_commands
+        lines = []
+        Fronde::Utils::FRONDE_COMMANDS.each do |cmd, opt|
+          next if cmd == 'basic'
+          line = ['   ', cmd.ljust(10)]
+          if opt.has_key? :alias
+            line << R18n.t.fronde.bin.commands.alias(opt[:alias])
+          else
+            line << R18n.t.fronde.bin.commands[cmd]
+          end
+          lines << line.join(' ')
+        end
+        lines.join("\n")
+      end
+
+      # Returns the real command name for a given command, which may be
+      #   an alias.
+      #
+      # @param command [String] the command to resolve
+      # @return [String]
+      def resolve_possible_alias(command)
+        return 'basic' unless Fronde::Utils::FRONDE_COMMANDS.include?(command)
+        cmd_opt = Fronde::Utils::FRONDE_COMMANDS[command]
+        return cmd_opt[:alias] if cmd_opt.has_key?(:alias)
+        command
+      end
+
+      # Try to discover the current host operating system.
+      #
+      # @return [String] either apple, windows or linux (default)
+      # :nocov:
+      def current_os
+        if ENV['OS'] == 'Windows_NT' || RUBY_PLATFORM.include?('cygwin')
+          return 'windows'
+        end
+        return 'apple' if RUBY_PLATFORM.include?('darwin')
+        'linux'
+      end
+      # :nocov:
+
+      # Download latest org-mode tarball.
+      #
+      # @param destination [String] where to save the org-mode tarball
+      # @return [String] the downloaded org-mode version
+      def download_org(destination = 'var/tmp')
+        # :nocov:
+        return if Fronde::Config.org_last_version.nil?
+        # :nocov:
+        tarball = "org-#{Fronde::Config.org_last_version}.tar.gz"
+        # Remove version number in dest file to allow easy rake file
+        # task naming
+        dest_file = File.expand_path('org.tar.gz', destination)
+        return if File.exist?(dest_file)
+        uri = URI("https://orgmode.org/#{tarball}")
+        # Will crash on purpose if anything goes wrong
+        Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
+          http.request(Net::HTTP::Get.new(uri)) do |response|
+            File.open(dest_file, 'w') do |io|
+              response.read_body { |chunk| io.write chunk }
+            end
+          end
+        end
+      end
+
+      private
+
+      def throbber_error(message)
+        warn(
+          format(
+            "%<message>s %<label>s\n%<explanation>s",
+            message: message,
+            label: Rainbow(R18n.t.fronde.error.label).bold.red,
+            explanation: Rainbow(R18n.t.fronde.error.explanation).bold
+          )
+        )
+      end
+
+      def select_throbber_frames
+        model = Fronde::Config.settings['throbber'] || 'default'
+        model = 'default' unless Fronde::Utils::THROBBER_FRAMES.has_key?(model)
+        Fronde::Utils::THROBBER_FRAMES[model]
+      end
+
+      def run_and_decorate_thread(thread, message, frames)
+        thread.abort_on_exception = true
+        current = 0
+        while thread.alive?
+          sleep 0.1
+          print "#{message} #{frames[current % frames.length]}\r"
+          current += 1
+        end
+      end
+    end
+  end
+end

data/lib/fronde/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Fronde
+  # @return [String] the version number of the current Fronde release.
+  VERSION = '0.3.0'
+end

data/lib/tasks/org.rake

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+
+# Fronde::Config is required by Fronde::Utils
+require 'fronde/utils'
+
+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'
+)
+
+namespace :org do
+  directory 'var/tmp'
+
+  desc 'Download last version of Org'
+  file 'var/tmp/org.tar.gz' => 'var/tmp' do
+    verbose = Rake::FileUtilsExt.verbose_flag
+    download = Thread.new do
+      Thread.current[:org_version] = Fronde::Config.org_last_version
+      Fronde::Utils.download_org
+    end
+    if verbose
+      download.join
+      warn "Org version #{download[:org_version]} has been downloaded"
+    else
+      Fronde::Utils.throbber(download, 'Downloading Org:')
+    end
+  end
+
+  desc 'Compile Org'
+  task compile: 'var/tmp/org.tar.gz' do |task|
+    verbose = Rake::FileUtilsExt.verbose_flag
+    org_version = Fronde::Config.org_last_version
+    org_dir = "lib/org-#{org_version}"
+    next if Dir.exist?("#{org_dir}/lisp")
+    make = ['make', '-C', org_dir]
+    unless verbose
+      make << '-s'
+      make << 'EMACSQ="emacs -Q --eval \'(setq inhibit-message t)\'"'
+    end
+    build = Thread.new do
+      sh "tar -C lib -xzf #{task.prerequisites[0]}"
+      sh((make + ['compile']).join(' '))
+      sh((make + ['autoloads']).join(' '))
+      Dir.glob('lib/org-[0-9.]*').each do |ov|
+        next if ov == org_dir
+        rm_r ov
+      end
+    end
+    if verbose
+      build.join
+      warn "#{org_version} has been locally installed"
+    else
+      Fronde::Utils.throbber(build, 'Installing Org:')
+    end
+  end
+
+  directory 'lib'
+
+  file 'lib/htmlize.el' => 'lib' do
+    htmlize = URI(
+      'https://raw.githubusercontent.com/hniksic/emacs-htmlize/master/htmlize.el'
+    ).open.read
+    IO.write 'lib/htmlize.el', htmlize
+  end
+
+  file 'var/lib/org-config.el' => 'lib/htmlize.el' do
+    Fronde::Config.write_org_lisp_config
+  end
+
+  file '.dir-locals.el' => 'var/lib/org-config.el' do
+    Fronde::Config.write_dir_locals
+  end
+
+  desc 'Install Org'
+  multitask install: ['org:compile', '.dir-locals.el'] do
+    mkdir_p "#{Fronde::Config.settings['public_folder']}/assets"
+    Fronde::Config.sources.each do |s|
+      mkdir_p s['path'] unless Dir.exist? s['path']
+    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
+    Rake::Task['org:install'].invoke
+  end
+  # :nocov:
+end