neruda 0.1.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 819cab1f549a9991714bac07e34be41187f667b67200996e2ef78a6a8c555ef5
-  data.tar.gz: 4cc683d19f3bfdf060ce56c720251f1db58ac88df3a44c55ada1298155e76f77
+  metadata.gz: f704b888004971a0ee3c321f41874132283f7f42a3c6b57f267356b7723b2260
+  data.tar.gz: 54c3738824f1b80b46b00654aedd805ef0a999a096f1ff320c42001027419147
 SHA512:
-  metadata.gz: 4d15fb6bcd865e0493b5f08e6209d7ce6a4e1764b88e2eff9cf9d05b20d832f83d1da81e9d7c9d381c4fd128c1f1ff0ff45524ba2e9412c56c3b17247c89a516
-  data.tar.gz: 05e47deafd1cf2366748100699dcbb8677802be4423191d16ed3f352ba52038665c524aafcf5b205cacbda2b8dad582ad13c161ed3110c5503d18a958aaa2b24
+  metadata.gz: ba08196581125aa378a938cb34413d856d7126800cbe692b9237f6e3ffb7bf45743d7dd6fa0ab77c9adb13000dd266085a7ebb4fe556b3d223f620596b237074
+  data.tar.gz: efc4308eb4c1d43091f6134fbdee4054feb80535e01fa1cff7f79656f22540bd55011c66c6ac7ca33fb01c0b6c4dbcab6012db44f1726285dc6be85fb8236953

data/bin/pablo

@@ -7,42 +7,41 @@ require 'r18n-core'
 require 'neruda/utils'
 require 'neruda/version'
 
-R18n.set(Neruda::Config.settings['lang'],
-         File.expand_path('../locales', __dir__))
+R18n.default_places = File.expand_path('../locales', __dir__)
+R18n.set Neruda::Config.settings['lang']
 
 # Pablo commands
 module PabloCommands
   def pablo_init
     cnf = @options.merge
     cnf.delete(:verbose)
-    cnf.delete(:directory)
     cnf.transform_keys!(&:to_s)
     Neruda::Config.save(Neruda::Config.settings.merge(cnf))
     @rake.options.build_all = true
     @rake.invoke_task('org:install')
-    o = Neruda::OrgFile.new('src/index.org', @options)
-    o.write unless File.exist? 'src/index.org'
+    return if File.exist? 'src/index.org'
+    Neruda::OrgFile.new('src/index.org', @options).write
+    pablo_open 'src/index.org'
   end
   alias_method :pablo_config, :pablo_init
 
-  def pablo_build(file = ARGV[0])
+  def pablo_build
     @rake.options.build_all = true
-    if file.nil?
-      @rake.invoke_task('site:build')
-    else
-      @rake.invoke_task("site:build:one[#{file}]")
-    end
+    task = 'site:build'
+    task = "#{task}[true]" if @options[:force]
+    @rake.invoke_task task
   end
 
   def pablo_preview
     Thread.new do
       sleep 1
-      port = Neruda::Config.settings['server_port'] || 5000
+      port = Neruda::Config.settings.dig('preview', 'server_port') || 5000
       uri = "http://127.0.0.1:#{port}/"
       current_os = Neruda::Utils.current_os
-      if current_os == 'windows'
+      case current_os
+      when 'windows'
         system 'start', uri
-      elsif current_os == 'apple'
+      when 'apple'
         system 'open', uri
       else
         system 'gio', 'open', uri
@@ -51,14 +50,17 @@ module PabloCommands
     @rake.invoke_task('site:preview')
   end
 
-  def pablo_open
-    filename = new_file_name(ARGV[0])
-    FileUtils.mkdir_p File.dirname(filename)
-    o = Neruda::OrgFile.new(filename, @options)
-    o.write unless File.exist? filename
+  def pablo_open(file_path = ARGV[0])
     editor = ENV['EDITOR'] || ENV['VISUAL'] || 'emacs'
-    cmd = [editor, filename]
-    cmd.insert(1, '+6') if editor.match?(/^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 :pablo_edit, :pablo_open
@@ -67,27 +69,56 @@ module PabloCommands
     @rake.invoke_task('sync:push')
   end
 
-  def pablo_help(command = 'basic', error = false)
+  def pablo_help(command = 'basic', error: false)
     warn R18n.t.pablo.error.no_command if error
     cmd = Neruda::Utils.resolve_possible_alias(command)
     cmd_opt = Neruda::Utils::PABLO_COMMANDS[cmd]
     label = cmd_opt[:label] || command
-    warn "Usage: pablo #{label} [options]\n\n"
-    warn cmd_opt[:desc] + "\n\n" if cmd_opt.has_key?(:desc)
-    warn "Options\n#{Neruda::Utils.summarize_command(cmd)}\n"
-    warn "Commands\n#{Neruda::Utils.list_commands}\n" if cmd == 'basic'
+    warn format("%<label>s\n\n", label: R18n.t.pablo.usage(label))
+    if R18n.t.pablo.commands[cmd].translated?
+      warn format("%<label>s\n\n", label: R18n.t.pablo.commands[cmd])
+    end
+    warn help_command_body(cmd).join("\n")
     exit 1 if error
     exit
   end
 
   private
 
-  def new_file_name(title)
-    title ||= @options[:title]
-    title = 'new' if title.nil? || title == ''
-    filename = Neruda::OrgFile.slug title
-    return "#{filename}.org" unless @options[:directory]
-    "#{filename}/index.org"
+  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 = "#{Neruda::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.pablo.error.no_file
+      exit 1
+    end
+    FileUtils.mkdir_p File.dirname(filename)
+    Neruda::OrgFile.new(filename, @options).write
+    filename
+  end
+
+  def help_command_body(command)
+    body = [
+      R18n.t.pablo.options.cmd_title,
+      Neruda::Utils.summarize_command(command)
+    ]
+    return body unless command == 'basic'
+    body + [
+      '',
+      R18n.t.pablo.commands.cmd_title,
+      Neruda::Utils.list_commands
+    ]
   end
 end
 
@@ -117,8 +148,8 @@ class Pablo
       require 'r18n-core'
 
       neruda_spec = Gem::Specification.find_by_name 'neruda'
-      R18n.set(Neruda::Config.settings['lang'] || 'en',
-               "\#{neruda_spec.gem_dir}/locales")
+      R18n.default_places = "\#{neruda_spec.gem_dir}/locales"
+      R18n.set(Neruda::Config.settings['lang'] || 'en')
       R18n::Filters.on(:named_variables)
 
       Dir.glob("\#{neruda_spec.gem_dir}/lib/tasks/*.rake").each { |r| import r }
@@ -153,10 +184,10 @@ command = "pablo_#{ARGV[0]}".to_sym
 cmd_err = !pablo.respond_to?(command)
 if params[:help] || cmd_err
   cmd_err = false if params[:help] && !ARGV[0]
-  pablo.pablo_help(ARGV[0], cmd_err)
+  pablo.pablo_help(ARGV[0], error: cmd_err)
 end
 ARGV.shift
 
-init_cmds = ['pablo_init', 'pablo_config']
+init_cmds = [:pablo_init, :pablo_config]
 pablo.pablo_init unless File.exist?('config.yml') || init_cmds.include?(command)
 pablo.send command

data/lib/neruda/config.rb

@@ -53,8 +53,17 @@ module Neruda
       # @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 neruda 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
-        @config = new_config.freeze
+        load_settings # Reload config, taking default settings into account
       end
 
       # Load the given settings as if they comes from the ~config.yml~ file.
@@ -66,28 +75,62 @@ module Neruda
       # @param config [Hash] the settings to artificially load
       # @return [Hash] the new settings
       def load_test(config)
-        @config = config
-        add_default_settings
+        @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
-        @config = {}
-        conf = 'config.yml'
-        @config = YAML.load_file(conf) if File.exist? conf
-        add_default_settings
-        @config.freeze
+        @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 add_default_settings
-        @config['lang'] ||= 'en'
-        @config['author'] ||= (ENV['USER'] || '')
-        @config['domain'] ||= ''
-        @config['public_folder'] ||= 'public_html'
-        @config['templates'] ||= []
-        return if @config['blog_path'].nil?
-        @config['blog_pattern'] ||= '**/*.org'
+      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

data/lib/neruda/config/lisp_config.rb

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'open-uri'
+require 'neruda/version'
 
 module Neruda
   # This module contains utilitary methods to ease ~org-config.el~
   # file generation
   module LispConfig
-    # Fetch and return the last published version of org mode.
+    # Fetch and return the last published version of Org.
     #
-    # @return [String] the new x.x.x version string of org mode
+    # @return [String] the new x.x.x version string of Org
     def org_last_version
       return @org_version if @org_version
-      index = open('https://orgmode.org/index.html', 'r').read
-      last_ver = index.match(/https:\/\/orgmode\.org\/org-([0-9.]+)\.tar\.gz/)
-      # :nocov:
-      if last_ver.nil?
-        warn 'Org last version not found'
-        return nil
+      if File.exist?('tmp/__last_org_version__')
+        @org_version = IO.read('tmp/__last_org_version__')
+        return @org_version
       end
-      # :nocov:
-      @org_version = last_ver[1]
+      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 'tmp'
+      IO.write('tmp/__last_org_version__', @org_version)
+      @org_version
     end
 
-    # Generate emacs lisp configuration file for org mode and write it.
+    # 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
@@ -30,15 +34,16 @@ module Neruda
     #
     # @return [Integer] the length written (as returned by the
     #   underlying ~IO.write~ method call)
-    def write_org_lisp_config
-      projects = org_generate_projects
+    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__', Neruda::VERSION)
                   .gsub('__WORK_DIR__', workdir)
                   .gsub('__NERUDA_DIR__', __dir__)
                   .gsub('__ORG_VER__', org_last_version)
-                  .gsub('__ALL_PROJECTS__', all_projects(projects).strip)
-                  .gsub('__THEME_CONFIG__', org_theme_config.strip)
+                  .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'] || '')
@@ -49,8 +54,8 @@ module Neruda
     # Generate emacs directory variables file.
     #
     # This method generate the file ~.dir-locals.el~, which is
-    # responsible to load neruda org mode settings when visiting an
-    # org file of this neruda instance.
+    # responsible to load neruda Org settings when visiting an Org file
+    # of this neruda instance.
     #
     # @return [Integer] the length written (as returned by the
     #   underlying ~IO.write~ method call)
@@ -76,69 +81,137 @@ module Neruda
       )
     end
 
+    def ruby_to_lisp_boolean(value)
+      return 't' if value == true
+      'nil'
+    end
+
     def project_names(projects)
-      projects.keys.map { |p| ["\"#{p}\"", "\"#{p}-assets\""] }
-              .flatten.join(' ')
+      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\n/, "\n")
+              .gsub(/\n\s*\n/, "\n")
               .gsub(/\n/, "\n        ")
     end
 
-    def org_project(project_name, opts)
-      orgtpl = opts['org_headers']
-      base_directory = File.expand_path(opts['path'])
+    # 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_name unless project_name == 'neruda'
-      publish_in = publish_in.join('/')
-      recline = [opts['recursive'] || 't']
-      default_ex_ptrn = settings['exclude_pattern']
+      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']
-        recline << ":exclude \"#{opts['exclude']}\""
-      elsif project_name == 'neruda' && default_ex_ptrn
-        recline << ":exclude \"#{default_ex_ptrn}\""
+        other_lines << format(':exclude "%<value>s"',
+                              value: opts['exclude'])
       end
+      themeconf = org_theme_config(opts['theme'])
       <<~ORGPROJECT
         ("#{project_name}"
-         :base-directory "#{base_directory}"
+         :base-directory "#{opts['path']}"
          :base-extension "org"
-         :recursive #{recline.join("\n ")}
+         #{other_lines.join("\n ")}
          :publishing-directory "#{publish_in}"
          :publishing-function org-html-publish-to-html
-         :section-numbers nil
-         :with-toc nil
-         #{orgtpl})
+         #{opts['org_headers']})
         ("#{project_name}-assets"
-         :base-directory "#{base_directory}"
+         :base-directory "#{opts['path']}"
          :base-extension "jpg\\\\\\|gif\\\\\\|png\\\\\\|svg\\\\\\|pdf"
-         :recursive #{recline[0]}
+         #{other_lines[0]}
          :publishing-directory "#{publish_in}"
          :publishing-function org-publish-attachment)
+        #{themeconf}
       ORGPROJECT
     end
 
-    def org_default_theme_options
-      postamble = <<~POSTAMBLE
+    def org_default_postamble
+      <<~POSTAMBLE
         <p><span class="author">#{R18n.t.neruda.org.postamble.written_by}</span>
         #{R18n.t.neruda.org.postamble.with_emacs}</p>
         <p class="date">#{R18n.t.neruda.org.postamble.last_modification}</p>
         <p class="validation">%v</p>
       POSTAMBLE
-      { 'html-head' => build_html_head.strip,
-        'html-postamble' => postamble.strip,
+    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' => 'nil' }
+        '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 org_templates
-      orgtplopts = org_default_theme_options.merge
-      orgtplopts.merge!(settings['org-html'] || {})
+    def build_project_org_headers(project)
+      orgtplopts = org_default_html_options(project).merge(
+        settings['org-html'] || {}, project['org-html'] || {}
+      )
       orgtpl = []
+      truthy_val = ['t', 'nil', '1'].freeze
       orgtplopts.each do |k, v|
+        v = expand_vars_in_html_head(v, project) if k == 'html-head'
         val = v.strip.gsub(/"/, '\"')
-        if ['t', 'nil', '1'].include? val
+        if truthy_val.include? val
           orgtpl << ":#{k} #{val}"
         else
           orgtpl << ":#{k} \"#{val}\""
@@ -147,62 +220,41 @@ module Neruda
       orgtpl.join("\n ")
     end
 
-    def org_external_projects_opts(seed, orgtpl)
-      opts = { 'org_headers' => orgtpl }
-      if seed.is_a? String
-        opts['path'] = seed
-      elsif seed.is_a? Hash
-        opts.merge! seed
+    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
-      opts
+      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_generate_projects
-      orgtpl = org_templates
-      default_project = org_project(
-        'neruda', 'org_headers' => orgtpl, 'path' => './src'
-      )
-      projects = { 'neruda' => default_project }
-      settings['external_sources']&.each do |s|
-        opts = org_external_projects_opts(s, orgtpl)
-        next unless opts.has_key?('path')
-        pname = File.basename(opts['path']).sub(/^\./, '')
-        projects[pname] = org_project(pname, opts)
+    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
-      projects
+      format("\n%<conf>s", conf: output.join("\n"))
     end
 
-    def org_theme_config
-      curtheme = settings['theme'] || 'default'
+    def org_theme_config(theme)
+      return '' if theme.nil? || theme == 'default'
       workdir = Dir.pwd
-      if curtheme == 'default'
-        sourcedir = File.expand_path('../../../', __dir__)
-      else
-        sourcedir = workdir
-      end
       <<~THEMECONFIG
-        ("theme"
-                 :base-directory "#{sourcedir}/themes/#{curtheme}"
-                 :base-extension "jpg\\\\\\|gif\\\\\\|png\\\\\\|js\\\\\\|css\\\\\\|otf\\\\\\|ttf\\\\\\|woff2?"
-                 :recursive t
-                 :publishing-directory "#{workdir}/#{settings['public_folder']}/assets"
-                 :publishing-function org-publish-attachment)
+        ("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
-
-    def build_html_head
-      stylesheet = <<~CSS
-        <link rel="stylesheet" type="text/css" media="screen"
-              href="#{settings['domain']}/assets/css/style.css">
-        <link rel="stylesheet" type="text/css" media="screen"
-              href="#{settings['domain']}/assets/css/htmlize.css">
-      CSS
-      return stylesheet if settings['blog_path'].nil?
-      <<~ATOM
-        #{stylesheet.strip}
-        <link rel="alternate" type="application/atom+xml" title="Atom 1.0"
-              href="#{settings['domain']}/feeds/index.xml" />
-      ATOM
-    end
   end
 end