fronde 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c646347a1cdbe6537384936ec392c1848617524fd7557f3c32566adb14e3c357
+  data.tar.gz: 41785e0d542baa6ac44c8e2f7b8d12d26db6ea5a5e10349ea4002d71b25f435d
+SHA512:
+  metadata.gz: ecac97edd7c48c3cd808c906195b11e941f84db6254f0548af1d951e8bba215a6545616cc8b425977b5453b158f5b3032e08d4cf702b1087f110054770e3c739
+  data.tar.gz: adb5628d1999d54284ad38c614ca29bd76b287124fb4ebc434a465225f3c1fb97acf1cce4e844de05aaf66b35c40be8216b9045535dfb05370c77eecb0cb4bde

data/LICENSE

@@ -0,0 +1,14 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.
+

data/bin/fronde

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'r18n-core'
+require 'fronde/utils'
+require 'fronde/version'
+require 'fronde/cli'
+
+R18n.default_places = File.expand_path('../locales', __dir__)
+R18n.set Fronde::Config.settings['lang']
+
+optparser = OptionParser.new
+optparser.version = Fronde::VERSION
+
+Fronde::Utils::FRONDE_OPTIONS.each do |k, opt|
+  optparser.send(opt[:meth] || :on, *Fronde::Utils.decorate_option(k))
+end
+
+params = {}
+optparser.parse!(into: params)
+
+if params[:version]
+  warn optparser.ver
+  exit
+end
+
+if ARGV[0] == 'help'
+  params[:help] = true
+  ARGV.shift
+end
+fronde = Fronde::CLI.new(params)
+command = "fronde_#{ARGV[0]}".to_sym
+cmd_err = !fronde.respond_to?(command)
+if params[:help] || cmd_err
+  cmd_err = false if params[:help] && !ARGV[0]
+  fronde.fronde_help(ARGV[0], error: cmd_err)
+end
+ARGV.shift
+
+init_cmds = [:fronde_init, :fronde_config]
+unless File.exist?('config.yml') || init_cmds.include?(command)
+  fronde.fronde_init
+end
+fronde.send command

data/lib/fronde/cli.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'fronde/cli/commands'
+
+module Fronde
+  # Fronde CLI app
+  class CLI
+    def initialize(opts = {})
+      @options = { verbose: false }.merge(opts)
+      init_required_files
+      init_rake
+    end
+
+    include Fronde::CLICommands
+
+    private
+
+    def init_required_files
+      init_rakefile unless File.exist?('Rakefile')
+      init_gitignore unless File.exist?('.gitignore')
+    end
+
+    def init_rake
+      @rake = Rake.application
+      Rake.verbose(false) unless @options[:verbose]
+      @rake.raw_load_rakefile
+    end
+
+    def init_rakefile
+      rakefile = <<~RAKE
+        # frozen_string_literal: true
+
+        require 'fronde/config'
+        require 'r18n-core'
+
+        fronde_spec = Gem::Specification.find_by_name 'fronde'
+        R18n.default_places = "\#{fronde_spec.gem_dir}/locales"
+        R18n.set(Fronde::Config.settings['lang'] || 'en')
+        R18n::Filters.on(:named_variables)
+
+        Dir.glob("\#{fronde_spec.gem_dir}/lib/tasks/*.rake").each { |r| import r }
+
+        task default: 'site:build'
+      RAKE
+      IO.write 'Rakefile', rakefile
+    end
+
+    def init_gitignore
+      gitignore = <<~GITIGNORE
+        .dir-locals.el
+        Rakefile
+        lib
+        public_html
+        var
+      GITIGNORE
+      IO.write '.gitignore', gitignore
+    end
+  end
+end

data/lib/fronde/cli/commands.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Fronde
+  # Fronde commands
+  module CLICommands
+    def fronde_init
+      cnf = @options.merge
+      cnf.delete(:verbose)
+      cnf.transform_keys!(&:to_s)
+      Fronde::Config.save(Fronde::Config.settings.merge(cnf))
+      @rake.options.build_all = true
+      @rake.invoke_task('org:install')
+      return if File.exist? 'src/index.org'
+      Fronde::OrgFile.new('src/index.org', @options).write
+      fronde_open 'src/index.org'
+    end
+    alias_method :fronde_config, :fronde_init
+
+    def fronde_build
+      @rake.options.build_all = true
+      task = 'site:build'
+      task = "#{task}[true]" if @options[:force]
+      @rake.invoke_task task
+    end
+
+    def fronde_preview
+      Thread.new do
+        sleep 1
+        port = Fronde::Config.settings.dig('preview', 'server_port') || 5000
+        uri = "http://127.0.0.1:#{port}/"
+        current_os = Fronde::Utils.current_os
+        case current_os
+        when 'windows'
+          system 'start', uri
+        when 'apple'
+          system 'open', uri
+        else
+          system 'gio', 'open', uri
+        end
+      end
+      @rake.invoke_task('site:preview')
+    end
+
+    def fronde_open(file_path = ARGV[0])
+      editor = ENV['EDITOR'] || ENV['VISUAL'] || 'emacs'
+      cmd = [editor]
+      if file_path.nil? || !File.file?(file_path)
+        # file_path may be updated with title given in options
+        file_path = create_new_file(file_path)
+        # Only move to the end of file for new file. Let the editor handle
+        # the best position for already existing files
+        cmd << '+6'
+      end
+      cmd << file_path
+      system(*cmd)
+    end
+    alias_method :fronde_edit, :fronde_open
+
+    def fronde_publish
+      @rake.invoke_task('sync:push')
+    end
+
+    def fronde_help(command = 'basic', error: false)
+      warn R18n.t.fronde.bin.error.no_command if error
+      cmd = Fronde::Utils.resolve_possible_alias(command)
+      cmd_opt = Fronde::Utils::FRONDE_COMMANDS[cmd]
+      label = cmd_opt[:label] || command
+      warn format("%<label>s\n\n", label: R18n.t.fronde.bin.usage(label))
+      if R18n.t.fronde.bin.commands[cmd].translated?
+        warn format("%<label>s\n\n", label: R18n.t.fronde.bin.commands[cmd])
+      end
+      warn help_command_body(cmd).join("\n")
+      exit 1 if error
+      exit
+    end
+
+    private
+
+    def new_file_name(file_path)
+      file_path = File.expand_path(file_path || '')
+      return file_path if file_path[-4..] == '.org'
+      # file_path seems to be a dir path. Thus we have to create the new
+      # filename from its title
+      title = @options[:title]
+      # No title, nor a reliable file_path? Better abort
+      return nil if title.nil? || title == ''
+      filename = "#{Fronde::OrgFile.slug(title)}.org"
+      File.join file_path, filename
+    end
+
+    def create_new_file(file_path)
+      filename = new_file_name(file_path)
+      if filename.nil?
+        warn R18n.t.fronde.bin.error.no_file
+        exit 1
+      end
+      FileUtils.mkdir_p File.dirname(filename)
+      Fronde::OrgFile.new(filename, @options).write
+      filename
+    end
+
+    def help_command_body(command)
+      body = [
+        R18n.t.fronde.bin.options.cmd_title,
+        Fronde::Utils.summarize_command(command)
+      ]
+      return body unless command == 'basic'
+      body + [
+        '',
+        R18n.t.fronde.bin.commands.cmd_title,
+        Fronde::Utils.list_commands
+      ]
+    end
+  end
+end

data/lib/fronde/config.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fronde/config/lisp_config'
+
+module Fronde
+  # Wrapper for configuration
+  #
+  # This class is a singleton interface, which share the static website
+  # being build settings among different steps or tasks.
+  #
+  # It expects the website author to holds their custom settings in a
+  # YAML file named ~config.yml~ available at the root of their
+  # project.
+  #
+  # For example, with the given config file:
+  #
+  # #+begin_src
+  # ---
+  # title: My website
+  # author: Alice Doe
+  # #+end_src
+  #
+  # Settings will be available like this:
+  #
+  # #+begin_src
+  # Fronde::Config.settings['author']
+  # => "Alice Doe"
+  # #+end_src
+  class Config
+    extend Fronde::LispConfig
+
+    class << self
+      # Access the current website settings
+      #
+      # If the settings have not been loaded yet, this method is
+      # responsible for calling the one, which actually loads them.
+      #
+      # @return [Hash] the website settings
+      def settings
+        return load_settings unless @config
+        @config
+      end
+
+      # Save the settings given as a parameter to the ~config.yml~ file.
+      #
+      # Not only this method overwrite the old settings, but it replace
+      # the current shared settings with the ones given in
+      # parameter. Later call to
+      # {file:Fronde/Config.html#settings-class_method settings}
+      # will, obviously, use these new settings.
+      #
+      # @param new_config [Hash] the settings to save
+      # @return [Hash] the new settings after save
+      def save(new_config)
+        # Do not save obvious default config values. We'll always try to
+        # save author and lang as they default on system variables,
+        # which may be different from a system to another. Thus it may
+        # be confusing if one use fronde on two different computer and
+        # these params always change.
+        new_config.delete_if do |k, v|
+          ['domain', 'public_folder', 'templates', 'theme'].include?(k) \
+          && v == default_settings[k]
+        end
+        IO.write 'config.yml', new_config.to_yaml
+        load_settings # Reload config, taking default settings into account
+      end
+
+      # Load the given settings as if they comes from the ~config.yml~ file.
+      #
+      # This method is handy for testing purpose. Later call to
+      # {file:Fronde/Config.html#settings-class_method settings} will
+      # use these new settings.
+      #
+      # @param config [Hash] the settings to artificially load
+      # @return [Hash] the new settings
+      def load_test(config)
+        @sources = nil # Reset sources
+        @config = default_settings.merge config
+      end
+
+      # Return the qualified projects sources list.
+      #
+      # @return [Array] the fully qualified projects sources list
+      def sources
+        return @sources if @sources
+        default_sources = [{ 'path' => 'src', 'target' => '.' }]
+        @sources = (settings['sources'] || default_sources).map do |s|
+          build_source(s)
+        end.compact
+      end
+
+      private
+
+      def load_settings
+        @sources = nil
+        conf_file = 'config.yml'
+        if File.exist? conf_file
+          @config = default_settings.merge(YAML.load_file(conf_file)).freeze
+        else
+          @config = default_settings
+        end
+      end
+
+      def extract_lang_from_env(default)
+        (ENV['LANG'] || default).split('_', 2).first
+      end
+
+      def default_settings
+        return @default_settings if @default_settings
+        @default_settings = {
+          'author' => (ENV['USER'] || ''),
+          'domain' => '',
+          'lang' => extract_lang_from_env('en'),
+          'public_folder' => 'public_html',
+          'templates' => [],
+          'theme' => 'default'
+        }.freeze
+      end
+
+      def build_source(seed)
+        opts = { 'recursive' => true, 'is_blog' => false }
+        case seed
+        when String
+          opts['path'] = seed
+        when Hash
+          opts.merge! seed
+        end
+        return nil unless opts.has_key?('path')
+        opts['path'] = File.expand_path(opts['path'])
+        opts['name'] ||= File.basename(opts['path']).sub(/^\./, '')
+        opts['target'] ||= opts['name']
+        opts
+      end
+    end
+  end
+end

data/lib/fronde/config/lisp_config.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open-uri'
+require 'fronde/version'
+
+module Fronde
+  # This module contains utilitary methods to ease ~org-config.el~
+  # file generation
+  module LispConfig
+    # Fetch and return the last published version of Org.
+    #
+    # @return [String] the new x.x.x version string of Org
+    def org_last_version
+      return @org_version if @org_version
+      if File.exist?('var/tmp/last_org_version')
+        @org_version = IO.read('var/tmp/last_org_version')
+        return @org_version
+      end
+      versions = JSON.parse(
+        URI('https://updates.orgmode.org/data/releases').open.read
+      ).sort { |a, b| b['date'] <=> a['date'] }
+      @org_version = versions.first['version']
+      FileUtils.mkdir_p 'var/tmp'
+      IO.write('var/tmp/last_org_version', @org_version)
+      @org_version
+    end
+
+    # Generate emacs lisp configuration file for Org and write it.
+    #
+    # This method saves the generated configuration in the file
+    # ~org-config.el~ at the root of your project, overwriting it if it
+    # existed already.
+    #
+    # @return [Integer] the length written (as returned by the
+    #   underlying ~IO.write~ method call)
+    def write_org_lisp_config(with_tags: false)
+      projects = org_generate_projects(with_tags: with_tags)
+      workdir = Dir.pwd
+      content = IO.read(File.expand_path('./org-config.el', __dir__))
+                  .gsub('__VERSION__', Fronde::VERSION)
+                  .gsub('__WORK_DIR__', workdir)
+                  .gsub('__FRONDE_DIR__', __dir__)
+                  .gsub('__ORG_VER__', org_last_version)
+                  .gsub('__ALL_PROJECTS__', all_projects(projects))
+                  .gsub('__THEME_CONFIG__', org_default_theme_config)
+                  .gsub('__ALL_PROJECTS_NAMES__', project_names(projects))
+                  .gsub('__LONG_DATE_FMT__', r18n_full_datetime_format)
+                  .gsub('__AUTHOR_EMAIL__', settings['author_email'] || '')
+                  .gsub('__AUTHOR_NAME__', settings['author'])
+      FileUtils.mkdir_p "#{workdir}/var/lib"
+      IO.write("#{workdir}/var/lib/org-config.el", content)
+    end
+
+    # Generate emacs directory variables file.
+    #
+    # This method generate the file ~.dir-locals.el~, which is
+    # responsible to load fronde Org settings when visiting an Org file
+    # of this fronde instance.
+    #
+    # @return [Integer] the length written (as returned by the
+    #   underlying ~IO.write~ method call)
+    def write_dir_locals
+      workdir = Dir.pwd
+      # rubocop:disable Layout/LineLength
+      IO.write(
+        "#{workdir}/.dir-locals.el",
+        "((org-mode . ((eval . (load-file \"#{workdir}/var/lib/org-config.el\")))))"
+      )
+      # rubocop:enable Layout/LineLength
+    end
+
+    private
+
+    def r18n_full_datetime_format
+      locale = R18n.get.locale
+      date_fmt = R18n.t.fronde.index.full_date_format(
+        date: locale.full_format
+      )
+      date_fmt = locale.year_format.sub('_', date_fmt)
+      time_fmt = locale.time_format.delete('_').strip
+      R18n.t.fronde.index.full_date_with_time_format(
+        date: date_fmt, time: time_fmt
+      )
+    end
+
+    def ruby_to_lisp_boolean(value)
+      return 't' if value == true
+      'nil'
+    end
+
+    def project_names(projects)
+      names = projects.keys.map do |p|
+        ["\"#{p}\"", "\"#{p}-assets\""]
+      end.flatten
+      unless settings['theme'] == 'default'
+        names << "\"theme-#{settings['theme']}\""
+      end
+      sources.each do |s|
+        # Default theme defined in settings is already included
+        next unless s['theme'] && s['theme'] != settings['theme']
+        # Never include theme named 'default' as it does not rely on any
+        # file to export.
+        next if s['theme'] == 'default'
+        theme = "\"theme-#{s['theme']}\""
+        next if names.include? theme
+        names << theme
+      end
+      names.join(' ')
+    end
+
+    def all_projects(projects)
+      projects.values.join("\n").strip
+              .gsub(/\n\s*\n/, "\n")
+              .gsub(/\n/, "\n        ")
+    end
+
+    # Return the full path to the publication path of a given project
+    #   configuration.
+    #
+    # @param project [Hash] a project configuration (as extracted from
+    #   the ~sources~ key)
+    # @return [String] the full path to the target dir of this project
+    def publication_path(project)
+      publish_in = [Dir.pwd, settings['public_folder']]
+      publish_in << project['target'] unless project['target'] == '.'
+      publish_in.join('/')
+    end
+
+    def org_project(project_name, opts)
+      publish_in = publication_path(opts)
+      other_lines = [
+        format(':recursive %<value>s',
+               value: ruby_to_lisp_boolean(opts['recursive']))
+      ]
+      if opts['exclude']
+        other_lines << format(':exclude "%<value>s"',
+                              value: opts['exclude'])
+      end
+      themeconf = org_theme_config(opts['theme'])
+      <<~ORGPROJECT
+        ("#{project_name}"
+         :base-directory "#{opts['path']}"
+         :base-extension "org"
+         #{other_lines.join("\n ")}
+         :publishing-directory "#{publish_in}"
+         :publishing-function org-html-publish-to-html
+         #{opts['org_headers']})
+        ("#{project_name}-assets"
+         :base-directory "#{opts['path']}"
+         :base-extension "jpg\\\\\\|gif\\\\\\|png\\\\\\|svg\\\\\\|pdf"
+         #{other_lines[0]}
+         :publishing-directory "#{publish_in}"
+         :publishing-function org-publish-attachment)
+        #{themeconf}
+      ORGPROJECT
+    end
+
+    def org_default_postamble
+      <<~POSTAMBLE
+        <p><span class="author">#{R18n.t.fronde.org.postamble.written_by}</span>
+        #{R18n.t.fronde.org.postamble.with_emacs}</p>
+        <p class="date">#{R18n.t.fronde.org.postamble.last_modification}</p>
+        <p class="validation">%v</p>
+      POSTAMBLE
+    end
+
+    def org_default_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
+
+    def org_default_html_options(project)
+      defaults = {
+        'section-numbers' => 'nil',
+        'with-toc' => 'nil',
+        'html-postamble' => org_default_postamble,
+        'html-head' => '__ATOM_FEED__',
+        'html-head-include-default-style' => 't',
+        'html-head-include-scripts' => 't'
+      }
+      curtheme = project['theme'] || settings['theme']
+      return defaults if curtheme.nil? || curtheme == 'default'
+      defaults['html-head'] = org_default_html_head
+      defaults['html-head-include-default-style'] = 'nil'
+      defaults['html-head-include-scripts'] = 'nil'
+      defaults
+    end
+
+    def expand_vars_in_html_head(head, project)
+      curtheme = project['theme'] || settings['theme']
+      # Head may be frozen when coming from settings
+      head = head.gsub('__THEME__', curtheme)
+                 .gsub('__DOMAIN__', settings['domain'])
+      return head.gsub('__ATOM_FEED__', '') unless project['is_blog']
+      atomfeed = <<~ATOMFEED
+        <link rel="alternate" type="application/atom+xml" title="Atom 1.0"
+              href="#{settings['domain']}/feeds/index.xml" />
+      ATOMFEED
+      head.gsub('__ATOM_FEED__', atomfeed)
+    end
+
+    def cast_lisp_value(value)
+      return 't' if value.is_a?(TrueClass)
+      return 'nil' if value.nil? || value.is_a?(FalseClass)
+      value.strip.gsub(/"/, '\"')
+    end
+
+    def build_project_org_headers(project)
+      orgtplopts = org_default_html_options(project).merge(
+        settings['org-html'] || {}, project['org-html'] || {}
+      )
+      orgtpl = []
+      lisp_keywords = ['t', 'nil', '1', '-1', '0'].freeze
+      orgtplopts.each do |k, v|
+        v = expand_vars_in_html_head(v, project) if k == 'html-head'
+        val = cast_lisp_value(v)
+        if lisp_keywords.include? val
+          orgtpl << ":#{k} #{val}"
+        else
+          orgtpl << ":#{k} \"#{val}\""
+        end
+      end
+      orgtpl.join("\n ")
+    end
+
+    def org_generate_projects(with_tags: false)
+      projects = {}
+      projects_sources = sources
+      if with_tags
+        tags_conf = build_source('tags')
+        tags_conf['recursive'] = false
+        projects_sources << tags_conf
+      end
+      projects_sources.each do |opts|
+        opts['org_headers'] = build_project_org_headers(opts)
+        projects[opts['name']] = org_project(opts['name'], opts)
+      end
+      projects
+    end
+
+    def org_default_theme_config
+      theme_config = org_theme_config(settings['theme'])
+      return theme_config if theme_config == ''
+      output = theme_config.split("\n").map do |line|
+        "        #{line}"
+      end
+      format("\n%<conf>s", conf: output.join("\n"))
+    end
+
+    def org_theme_config(theme)
+      return '' if theme.nil? || theme == 'default'
+      workdir = Dir.pwd
+      <<~THEMECONFIG
+        ("theme-#{theme}"
+         :base-directory "#{workdir}/themes/#{theme}"
+         :base-extension "jpg\\\\\\|gif\\\\\\|png\\\\\\|js\\\\\\|css\\\\\\|otf\\\\\\|ttf\\\\\\|woff2?"
+         :recursive t
+         :publishing-directory "#{workdir}/#{settings['public_folder']}/assets/#{theme}"
+         :publishing-function org-publish-attachment)
+      THEMECONFIG
+    end
+  end
+end