neruda 0.0.9 → 0.2.0

data/lib/neruda/org_file/class_methods.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Neruda
+  # This module holds class methods for the {Neruda::OrgFile} class.
+  module OrgFileClassMethods
+    def source_for_target(file_name)
+      # file_name may be frozen...
+      src = file_name.sub(/\.html$/, '.org')
+      pubfolder = Neruda::Config.settings['public_folder']
+      src.sub!(/^#{pubfolder}\//, '')
+      # Look for match in each possible sources. The first found wins.
+      Neruda::Config.sources.each do |project|
+        if project['target'] == '.'
+          origin = File.join(project['path'], src)
+        else
+          origin = File.join(
+            project['path'], src.sub(/^#{project['target']}\//, '')
+          )
+        end
+        return origin if File.exist?(origin)
+      end
+      nil
+    end
+
+    def target_for_source(file_name, project, with_public_folder: true)
+      return nil if file_name.nil?
+      # file_name may be frozen...
+      target = file_name.sub(/\.org$/, '.html').sub(/^#{Dir.pwd}\//, '')
+      if project.nil?
+        subfolder = File.basename(File.dirname(target))
+        target = File.basename(target)
+        target = "#{subfolder}/#{target}" if subfolder != '.'
+      else
+        project_relative_path = project['path'].sub(/^#{Dir.pwd}\//, '')
+        target.sub!(/^#{project_relative_path}\//, '')
+        target = "#{project['target']}/#{target}" if project['target'] != '.'
+      end
+      return target unless with_public_folder
+      pubfolder = Neruda::Config.settings['public_folder']
+      "#{pubfolder}/#{target}"
+    end
+
+    def project_for_source(file_name)
+      # Look for match in each possible sources. The first found wins.
+      Neruda::Config.sources.each do |project|
+        project_relative_path = project['path'].sub(/^#{Dir.pwd}\//, '')
+        return project if file_name =~ /^#{project_relative_path}\//
+      end
+      nil
+    end
+
+    def slug(title)
+      title.downcase.gsub(' ', '-')
+           .encode('ascii', fallback: ->(k) { translit(k) })
+           .gsub(/[^\w-]/, '').gsub(/-$/, '')
+    end
+
+    private
+
+    def translit(char)
+      return 'a' if ['á', 'à', 'â', 'ä', 'ǎ', 'ã', 'å'].include?(char)
+      return 'e' if ['é', 'è', 'ê', 'ë', 'ě', 'ẽ'].include?(char)
+      return 'i' if ['í', 'ì', 'î', 'ï', 'ǐ', 'ĩ'].include?(char)
+      return 'o' if ['ó', 'ò', 'ô', 'ö', 'ǒ', 'õ'].include?(char)
+      return 'u' if ['ú', 'ù', 'û', 'ü', 'ǔ', 'ũ'].include?(char)
+      return 'y' if ['ý', 'ỳ', 'ŷ', 'ÿ', 'ỹ'].include?(char)
+      return 'c' if char == 'ç'
+      return 'n' if char == 'ñ'
+      '-'
+    end
+  end
+end

data/lib/neruda/org_file/extracter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Neruda
+  # This module holds extracter methods for the {Neruda::OrgFile} class.
+  module OrgFileExtracter
+    private
+
+    # Main method, which will call the other to initialize an
+    #   {Neruda::OrgFile} instance.
+    def extract_data
+      @content = IO.read @file
+      @title = extract_title
+      @subtitle = extract_subtitle
+      @date = extract_date
+      @author = extract_author
+      @keywords = extract_keywords
+      @lang = extract_lang
+      @excerpt = extract_excerpt
+    end
+
+    def extract_date
+      timerx = '([0-9:]{5})(?::([0-9]{2}))?'
+      m = /^#\+date: *<([0-9-]{10}) [\w.]+(?: #{timerx})?> *$/i.match(@content)
+      return nil if m.nil?
+      @notime = m[2].nil?
+      if @notime
+        time = '00:00:00'
+      else
+        time = "#{m[2]}:#{m[3] || '00'}"
+      end
+      DateTime.strptime("#{m[1]} #{time}", '%Y-%m-%d %H:%M:%S')
+    end
+
+    def extract_title
+      m = /^#\+title:(.+)$/i.match(@content)
+      if m.nil?
+        # Avoid to leak absolute path
+        project_relative_path = @file.sub(/^#{Dir.pwd}\//, '')
+        return project_relative_path
+      end
+      m[1].strip
+    end
+
+    def extract_subtitle
+      m = /^#\+subtitle:(.+)$/i.match(@content)
+      return '' if m.nil?
+      m[1].strip
+    end
+
+    def extract_author
+      m = /^#\+author:(.+)$/i.match(@content)
+      return Neruda::Config.settings['author'] if m.nil?
+      m[1].strip
+    end
+
+    def extract_keywords
+      m = /^#\+keywords:(.+)$/i.match(@content)
+      return [] if m.nil?
+      m[1].split(',').map(&:strip)
+    end
+
+    def extract_lang
+      m = /^#\+language:(.+)$/i.match(@content)
+      return Neruda::Config.settings['lang'] if m.nil?
+      m[1].strip
+    end
+
+    def extract_excerpt
+      @content.scan(/^#\+description:(.+)$/i).map { |l| l[0].strip }.join(' ')
+    end
+  end
+end

data/lib/neruda/org_file/htmlizer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'neruda/config'
+require 'neruda/emacs'
+
+module Neruda
+  # This module holds HTML formatter methods for the {Neruda::OrgFile}
+  # class.
+  module OrgFileHtmlizer
+    # Publish the current file or the entire project if
+    #   {Neruda::OrgFile#file @file} is ~nil~.
+    #
+    # @return [Boolean, nil] the underlying ~system~ method return value
+    def publish
+      Neruda::Emacs.new(
+        file_path: @file, verbose: @options[:verbose]
+      ).publish
+    end
+
+    private
+
+    # Format {Neruda::OrgFile#keywords} list in an HTML listing.
+    #
+    # @return [String] the HTML keywords list
+    def keywords_to_html
+      domain = Neruda::Config.settings['domain']
+      klist = @keywords.map do |k|
+        <<~KEYWORDLINK
+          <li class="keyword">
+            <a href="#{domain}/tags/#{Neruda::OrgFile.slug(k)}.html">#{k}</a>
+          </li>
+        KEYWORDLINK
+      end.join
+      "<ul class=\"keywords-list\">#{klist}</ul>"
+    end
+
+    # Format {Neruda::OrgFile#date} as a HTML `time` tag.
+    #
+    # @return [String] the HTML `time` tag
+    def date_to_html(dateformat = :full)
+      return '<time></time>' if @date.nil?
+      "<time datetime=\"#{@date.rfc3339}\">#{datestring(dateformat)}</time>"
+    end
+
+    # Format {Neruda::OrgFile#author} in a HTML `span` tag with a
+    #   specific class.
+    #
+    # @return [String] the author HTML `span`
+    def author_to_html
+      "<span class=\"author\">#{@author}</span>"
+    end
+  end
+end

data/lib/neruda/preview.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'webrick'
+require 'neruda/config'
+
+module Neruda # 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 = Neruda::Config.settings.dig('preview', 'routes') || {}
+      return routes[requested_path] if routes.keys.include? requested_path
+      local_path = Neruda::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$/)
+      domain = Neruda::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 = Neruda::Config.settings.dig('preview', 'server_port') || 5000
+      s = WEBrick::HTTPServer.new(Port: port)
+      s.mount '/', Neruda::PreviewServlet
+      ['TERM', 'QUIT', 'INT'].each { |sig| trap(sig, proc { s.shutdown }) }
+      s.start
+    end
+  end
+end

data/lib/neruda/templater.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'digest/md5'
+require 'neruda/org_file'
+
+module Neruda
+  # Insert custom part inside generated HTML files.
+  class Templater
+    def initialize(source, dom, opts = {})
+      @dom = dom
+      @org_file = source
+      @position = opts['type'] || 'after'
+      @content = opts['content']
+      @element = @dom.css(opts['selector'])
+      digest = Digest::MD5.hexdigest(@content)
+      @check_line = " Neruda 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 = Neruda::OrgFile.source_for_target(file_name)
+          source = Neruda::OrgFile.new(sourcepath)
+        end
+        dom = open_dom(file_name)
+        templates_to_apply.each do |t|
+          tpl = Neruda::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 = Neruda::Config.settings['templates']
+        return [] if templates.nil? || templates.empty?
+        templates.filter do |t|
+          if !t.has_key?('selector') || !t.has_key?('content')
+            false
+          elsif t.has_key?('path') && !check_path(file_name, t['path'])
+            false
+          else
+            true
+          end
+        end
+      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 = Neruda::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
+    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
+  end
+end

data/lib/neruda/utils.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'rainbow'
+require 'net/http'
+require 'r18n-core'
+require 'neruda/config'
+
+module Neruda
+  # 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 ~pablo~ options and their
+    #   configuration
+    PABLO_OPTIONS = {
+      '-a' => { long: 'author' },
+      '-l' => { long: 'lang', keyword: 'LOCALE' },
+      '-t' => { long: 'title' },
+      '-p' => { long: 'path' },
+      '-d' => { long: 'directory', boolean: true },
+      '-v' => { long: 'verbose', boolean: true, meth: :on_tail },
+      '-h' => { long: 'help', boolean: true, meth: :on_tail },
+      '-V' => { long: 'version', boolean: true, meth: :on_tail }
+    }.freeze
+
+    # @return [Hash] the possible ~pablo~ subcommands and their
+    #   configuration
+    PABLO_COMMANDS = {
+      'init' => { opts: ['-a', '-l', '-t', '-v', '-h'] },
+      'config' => { alias: 'init' },
+      'preview' => { opts: ['-h'] },
+      'open' => { opts: ['-a', '-l', '-t', '-d', '-p', '-v', '-h'] },
+      'edit' => { alias: 'open' },
+      'build' => { opts: ['-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
+      # {Neruda::Config#settings}).
+      #
+      # @example
+      #     long_stuff = Thread.new { very_long_operation }
+      #     Neruda::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 {Neruda::Utils::PABLO_OPTIONS} Hash to
+      # retrieve corresponding values.
+      #
+      # @example
+      #     spec = Neruda::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 = Neruda::Utils::PABLO_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 ~pablo~ help summary for a given command.
+      #
+      # @param command [String] the command for which a summary
+      #   should be given
+      # @return [String]
+      def summarize_command(command)
+        Neruda::Utils::PABLO_COMMANDS[command][:opts].map do |k|
+          short, long = Neruda::Utils.decorate_option(k)
+          opt = Neruda::Utils::PABLO_OPTIONS[k]
+          label = [short, long].join(', ')
+          line = [format('    %<opt>s', opt: label).ljust(30)]
+          if R18n.t.pablo.options[opt[:long]].translated?
+            line << R18n.t.pablo.options[opt[:long]]
+          end
+          line.join(' ')
+        end.join("\n")
+      end
+
+      # Returns a formatted list of available commands for ~pablo~.
+      #
+      # @return [String]
+      def list_commands
+        lines = []
+        Neruda::Utils::PABLO_COMMANDS.each do |cmd, opt|
+          next if cmd == 'basic'
+          line = ['   ', cmd.ljust(10)]
+          if opt.has_key? :alias
+            line << R18n.t.pablo.commands.alias(opt[:alias])
+          else
+            line << R18n.t.pablo.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 Neruda::Utils::PABLO_COMMANDS.include?(command)
+        cmd_opt = Neruda::Utils::PABLO_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 =~ /cygwin/
+          return 'windows'
+        end
+        return 'apple' if RUBY_PLATFORM =~ /darwin/
+        'linux'
+      end
+      # :nocov:
+
+      # Download latest org-mode tarball.
+      #
+      # @return [String] the downloaded org-mode version
+      def download_org
+        # :nocov:
+        return if Neruda::Config.org_last_version.nil?
+        # :nocov:
+        tarball = "org-#{Neruda::Config.org_last_version}.tar.gz"
+        dest_file = "tmp/#{tarball}"
+        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.neruda.error.label).bold.red,
+            explanation: Rainbow(R18n.t.neruda.error.explanation).bold
+          )
+        )
+      end
+
+      def select_throbber_frames
+        model = Neruda::Config.settings['throbber'] || 'default'
+        model = 'default' unless Neruda::Utils::THROBBER_FRAMES.has_key?(model)
+        Neruda::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