fronde 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09c19f62dc0488af47253babe5508d3542a32641cd37ad4d48db18bcc9e99e41'
-  data.tar.gz: abed078181d7348c50706e6221e0820753a336d1ba23b0248e6ec588a8b43d07
+  metadata.gz: 31ed851cf895abccd33ec85ab91459e4310c9716631d096efd89d18fd16bf190
+  data.tar.gz: 901e11daea515cff4336f05a13a67604a5d73ca9fc020efb8250b34fbdb72450
 SHA512:
-  metadata.gz: 87d05d4afddff426c8093bfe210d4b33744493ebc4a095aef6c0127c072f013550d6169b8573b36916e3f2f286a023b47ee644ba8cc105ed25d73ee71bd7f1ed
-  data.tar.gz: f22641978e2b3b2416dfc36af56f914a345869b029e972ebc881dfa085ab9fe5bd8435174954fe5772d6a0e822ea51ec9a5f2c3759a27503f8fdb2730672eeed
+  metadata.gz: 1190105b49652d3bf177602a9ca37906f9a4659416f821734b17b5a49269825726019a6b69ad47b312937d75b362e658b93026003ffc42cd92859b601c9c8e96
+  data.tar.gz: 4e34d65345c82cc39237521c2e79365bbe4c23572fa4c4fa7d65e2d5aa7119d095a2956ec569e03c6cb459e7f1f37fe933aac3d2b0fdcefafb69f1cea8ef695b

data/bin/fronde

@@ -1,45 +1,30 @@
 #!/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.get('lang')
+require_relative '../lib/fronde/config'
+require_relative '../lib/fronde/version'
+require_relative '../lib/fronde/cli'
 
+require 'optparse'
 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))
+Fronde::CLI::OptParse::FRONDE_OPTIONS.each do |k, opt|
+  optparser.send(opt[:method] || :on, *Fronde::CLI::OptParse.decorate_option(k))
 end
 
-params = {}
-optparser.parse!(into: params)
+params = { verbose: false }
+begin
+  optparser.parse!(into: params)
+rescue OptionParser::InvalidArgument => e
+  warn e.message
+  params.merge!(help: true, recover_from_error: true)
+end
 
 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, :fronde_update]
-unless File.exist?('config.yml') || init_cmds.include?(command)
-  fronde.fronde_init
-end
-fronde.send command
+fronde = Fronde::CLI::App.new(params)
+exit fronde.run(ARGV)

data/lib/ext/nil_time.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# A time emulator to handle cases where no time is available
+class NilTime
+  def strftime(*)
+    ''
+  end
+
+  def xmlschema(_ = 0)
+    ''
+  end
+
+  def l18n_short_date_string
+    ''
+  end
+
+  def l18n_long_date_string(*)
+    ''
+  end
+
+  def l18n_short_date_html
+    '<time></time>'
+  end
+  alias_method :l18n_long_date_html, :l18n_long_date_string
+end

data/lib/ext/r18n.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Monkey patch to add a little helper
+module R18nPatch
+  refine R18n::Translation do
+    def full_datetime_format
+      date_fmt = fronde.index.full_date_format(
+        date: @locale.full_format
+      )
+      date_fmt = @locale.year_format.sub('_', date_fmt)
+      time_fmt = @locale.time_format.delete('_').strip
+      fronde.index.full_date_with_time_format(
+        date: date_fmt, time: time_fmt
+      )
+    end
+  end
+end

data/lib/ext/time.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Monkey patch to add some helpers
+module TimePatch
+  refine Time do
+    # Returns the current Time instance as a localized short string.
+    #
+    # @return [String] the localized Time string representation
+    def l18n_short_date_string
+      R18n.l to_date
+    end
+
+    # Format the current Time as a HTML `time` tag showing a short date.
+    #
+    # @return [String] the HTML `time` tag
+    def l18n_short_date_html
+      "<time datetime=\"#{xmlschema}\">#{l18n_short_date_string}</time>"
+    end
+
+    def no_time=(value)
+      @no_time = value
+    end
+
+    # Returns the current Time instance as a localized long string.
+    #
+    # @param with_year [Boolean] wether or not the string must contain the
+    #   year
+    # @return [String] the localized Time string representation
+    def l18n_long_date_string(with_year: true)
+      locale = R18n.get.locale
+      long_fmt = R18n.t.fronde.index.full_date_format(
+        date: locale.format_date_full(self, year: with_year)
+      )
+      unless @no_time
+        long_fmt = R18n.t.fronde.index.full_date_with_time_format(
+          date: long_fmt, time: locale.time_format.delete('_').strip
+        )
+      end
+      locale.strftime(self, long_fmt)
+    end
+
+    # Format the current Time as a HTML `time` tag showing a long date.
+    #
+    # @return [String] the HTML `time` tag
+    def l18n_long_date_html
+      "<time datetime=\"#{xmlschema}\">#{l18n_long_date_string}</time>"
+    end
+  end
+end

data/lib/fronde/cli/commands.rb

@@ -1,125 +1,114 @@
 # frozen_string_literal: true
 
+require_relative 'helpers'
+require_relative 'opt_parse'
+require_relative '../slug'
+require_relative '../org/file'
+
 module Fronde
-  # Fronde commands
-  module CLICommands
-    def fronde_update
-      update_config
-      @rake.options.build_all = true
-      @rake.invoke_task('org:upgrade')
-    end
-    alias_method :fronde_config, :fronde_update
+  module CLI
+    # Fronde commands
+    module Commands
+      def fronde_new
+        new_dir = @argv.first || 'my_fronde_website'
+        FileUtils.mkdir new_dir
+        Dir.chdir new_dir
+        Helpers.init_config_file @options
+        Fronde::CONFIG.reset # Correctly compute various path
+        Helpers.init_rakefile
+        init_rake
+        @rake['org:install'].invoke
+        @argv = ['src/index.org']
+        fronde_open
+      end
 
-    def fronde_init
-      update_config
-      @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
+      def fronde_update
+        Helpers.init_rakefile
+        init_rake
+        @rake.options.build_all = true
+        @rake['org:upgrade'].invoke
+        0
+      end
 
-    def fronde_build
-      @rake.options.build_all = true
-      task = 'site:build'
-      task = "#{task}[true]" if @options[:force]
-      @rake.invoke_task task
-    end
+      def fronde_build
+        @rake.options.build_all = true
+        @rake['site:build'].invoke @options[:force]
+        0
+      end
 
-    def fronde_preview
-      Thread.new do
-        sleep 1
-        port = Fronde::Config.get(['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
+      def fronde_preview
+        Thread.new do
+          sleep 1
+          port = Fronde::CONFIG.get(%w[preview server_port], 5000)
+          Helpers.launch_app_for_uri "http://127.0.0.1:#{port}/"
         end
+        @rake['site:preview'].invoke
+        0
       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'
+      def fronde_open
+        editor = ENV['EDITOR'] || ENV['VISUAL'] || 'emacs'
+        cmd = [editor]
+        file_path = @argv.first || Dir.pwd
+        unless 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) && 0) || 1
       end
-      cmd << file_path
-      system(*cmd)
-    end
-    alias_method :fronde_edit, :fronde_open
 
-    def fronde_publish
-      @rake.invoke_task('sync:push')
-    end
+      def fronde_publish
+        @rake['sync:push'].invoke
+        0
+      end
 
-    def fronde_help(command = 'basic', error: false)
-      warn R18n.t.fronde.bin.error.no_command if error
-      cmd_opt = Fronde::Utils.command_options(command)
-      label = cmd_opt[:label] || command
-      warn format("%<label>s\n\n", label: R18n.t.fronde.bin.usage(label))
-      cmd = cmd_opt[:name] || command
-      if R18n.t.fronde.bin.commands[cmd].translated?
-        warn format("%<label>s\n\n", label: R18n.t.fronde.bin.commands[cmd])
+      def fronde_help
+        # Try to find command in next argv, otherwise fallback again.
+        @command = @argv.shift || 'basic' if @command == 'help'
+        cmd_opt = OptParse.command_options(@command)
+        label = cmd_opt[:label] || @command
+        warn format("%<label>s\n\n", label: R18n.t.fronde.bin.usage(label))
+        cmd = cmd_opt[:name] || @command
+        if R18n.t.fronde.bin.commands[cmd].translated?
+          warn format("%<label>s\n\n", label: R18n.t.fronde.bin.commands[cmd])
+        end
+        body = OptParse.help_command_body(cmd)
+        warn body unless body == ''
+        0
       end
-      warn help_command_body(cmd).join("\n")
-      exit 1 if error
-      exit
-    end
 
-    private
+      private
 
-    def update_config
-      cnf = @options.merge
-      cnf.delete(:verbose)
-      cnf.transform_keys!(&:to_s)
-      Fronde::Config.save(Fronde::Config.settings.merge(cnf))
-    end
+      def file_name_from_title
+        title = @options[:title] || R18n.t.fronde.bin.options.default_title
+        # No title, nor a reliable file_path? Better abort
+        raise R18n.t.fronde.error.bin.no_file if title == ''
 
-    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
+        "#{Fronde::Slug.slug(title)}.org"
+      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
+      def new_file_name(file_path)
+        file_path = File.expand_path(file_path)
+
+        if file_path[-4..] == '.org' && !File.directory?(file_path)
+          return file_path
+        end
+
+        # file_path seems to be a dir path. Thus we have to create the new
+        # filename from its title
+        File.join file_path, file_name_from_title
       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
-      ]
+      def create_new_file(file_path)
+        filename = new_file_name(file_path)
+        FileUtils.mkdir_p File.dirname(filename)
+        Fronde::Org::File.new(filename, @options).write
+        filename
+      end
     end
   end
 end

data/lib/fronde/cli/data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'fronde/config'
+
+fronde_spec = Gem::Specification.find_by_name 'fronde'
+Dir.glob("#{fronde_spec.gem_dir}/lib/tasks/*.rake").each { |r| import r }
+
+task default: 'site:build'

data/lib/fronde/cli/data/config.yml

@@ -0,0 +1,13 @@
+---
+{%- if author %}
+author: {{ author }}
+{%- endif %}
+{%- if lang %}
+lang: {{ lang }}
+{%- endif %}
+sources:
+  - path: src
+    target: .
+{%- if output == 'gemini' %}
+    type: gemini
+{%- endif %}

data/lib/fronde/cli/data/gitignore

@@ -0,0 +1,7 @@
+.dir-locals.el
+.ruby-version
+Rakefile
+lib/
+public_gmi/
+public_html/
+var/

data/lib/fronde/cli/data/zsh_completion

@@ -0,0 +1,37 @@
+#compdef fronde
+#autoload
+
+{% for command in commands %}
+{%- for option in command.options %}
+{%- if forloop.first %}
+(( $+functions[__fronde_{{ command.name }}] )) ||
+__fronde_{{ command.name }}(){
+    _arguments \
+{%- endif %}
+        '({{ option.short }} {{ option.long }})'{{ '{' }}{{ option.short}},{{ option.long }}}
+        {%- if option.keyword %}':{{ option.keyword }}:'{% endif %}
+{%- if forloop.last %}
+{%- if command.name == 'open' %} \
+        '1:file:_files -g \*.org'
+{%- endif %}
+}
+{% else %} \{% endif %}
+{%- endfor %}{% endfor %}
+
+(( $+functions[__fronde_help] )) ||
+__fronde_help(){
+    _arguments \
+        "1:command:(({% for command in commands %}{{ command.name }}\:'{{ command.translation }}' {% endfor %}))"
+}
+
+local state
+
+_arguments -C \
+    '(-)-h[help]' \
+    '(-)-V[version]' \
+    "1:command:(({% for command in commands %}{{ command.name }}\:'{{ command.translation }}' {% endfor %}))" \
+    '*::arg:->args'
+
+if [ "$state" = args ]; then
+    _call_function ret __fronde_${words[1]}
+fi

data/lib/fronde/cli/helpers.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'fileutils'
+
+module Fronde
+  module CLI
+    # Various utilitaries methods
+    module Helpers
+      def self.init_config_file(config)
+        return if File.exist? 'config.yml'
+
+        output = config[:output] || 'html'
+        output = 'gemini' if output == 'gmi'
+        data = { 'author' => config[:author],
+                 'lang' => config[:lang],
+                 'output' => output }
+        source = File.expand_path './data/config.yml', __dir__
+        template = Liquid::Template.parse(File.read(source))
+        File.write('config.yml', template.render(data))
+      end
+
+      def self.init_rakefile
+        FileUtils.cp(
+          File.expand_path('./data/Rakefile', __dir__),
+          'Rakefile'
+        )
+      end
+
+      def self.launch_app_for_uri(uri)
+        case current_os
+        when 'windows'
+          system 'start', uri
+        when 'apple'
+          system 'open', uri
+        else
+          system 'gio', 'open', uri
+        end
+      end
+
+      # Try to discover the current host operating system.
+      #
+      # @return [String] either apple, windows or linux (default)
+      def self.current_os
+        if ENV['OS'] == 'Windows_NT' || RUBY_PLATFORM.include?('cygwin')
+          return 'windows'
+        end
+        return 'apple' if RUBY_PLATFORM.include?('darwin')
+
+        'linux'
+      end
+    end
+  end
+end

data/lib/fronde/cli/opt_parse.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Fronde
+  module CLI
+    # Helper code to help build the fronde option parser
+    module OptParse
+      # @return [Hash] the possible ~fronde~ options and their
+      #   configuration
+      FRONDE_OPTIONS = {
+        '-a' => { long: 'author' },
+        '-f' => { long: 'force', boolean: true },
+        '-h' => { long: 'help', boolean: true, method: :on_tail,
+                  help: R18n.t.fronde.bin.options.help },
+        '-l' => { long: 'lang', keyword: 'LOCALE' },
+        '-o' => { long: 'output', keyword: 'FORMAT', choices: %w[gemini html] },
+        '-t' => { long: 'title' },
+        '-v' => { long: 'verbose', boolean: true, method: :on_tail },
+        '-V' => { long: 'version', boolean: true, method: :on_tail,
+                  help: R18n.t.fronde.bin.options.version }
+      }.freeze
+
+      # TODO: jekyll new [path] / jekyll build / jekyll clean / jekyll serve
+      # TODO: hugo new site [path] / hugo / hugo new content / hugo server
+      # TODO: zola init [path] / zola build --root path_to_project / zola serve
+
+      # @return [Hash] the possible ~fronde~ subcommands and their
+      #   configuration
+      FRONDE_COMMANDS = {
+        'new' => { opts: ['-a', '-l', '-o', '-t', '-v'], label: 'new <path>' },
+        'init' => { alias: 'new' },
+        'update' => {},
+        'config' => { alias: 'update' },
+        'preview' => {},
+        'open' => { opts: ['-a', '-l', '-t', '-v'], label: 'open <path>' },
+        'edit' => { alias: 'open' },
+        'build' => { opts: ['-f'] },
+        'publish' => {},
+        'help' => {},
+        'basic' => { opts: ['-h', '-V'], label: '<command>' }
+      }.freeze
+
+      class << self
+        # Returns the short and long options specification for a given
+        #   short option.
+        #
+        # This method use the {Fronde::CLI::OptParse::FRONDE_OPTIONS}
+        # Hash to retrieve corresponding values.
+        #
+        # @example
+        #     spec = Fronde::CLI::OptParse.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_OPTIONS[short]
+          long = "--#{opt[:long]}"
+          if opt[:boolean]
+            config = [short, long]
+          else
+            key = opt[:keyword] || opt[:long].upcase
+            config = [short, format('%<long>s %<key>s', long: long, key: key)]
+          end
+          config << opt[:choices] if opt[:choices]
+          config << opt[:help] if opt[:help]
+          config
+        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_COMMANDS[command][:opts] || []).map do |k|
+            short, long = decorate_option(k)
+            opt = FRONDE_OPTIONS[k]
+            label = [short, long].join(', ')
+            line = [format('    %<opt>s', opt: label).ljust(30)]
+            help = opt[:help]
+            line << help if help
+            choices = opt[:choices]
+            line << "(#{choices.join(', ')})" if choices
+            line.join(' ')
+          end.join("\n")
+        end
+
+        def help_command_body(command)
+          command_opts_doc = summarize_command(command)
+          return '' if command_opts_doc == ''
+
+          body = [R18n.t.fronde.bin.options.cmd_title, command_opts_doc]
+          if command == 'basic'
+            body += ['', R18n.t.fronde.bin.commands.cmd_title, list_commands]
+          end
+          body.join("\n")
+        end
+
+        # Returns a formatted list of available commands for ~fronde~.
+        #
+        # @return [String]
+        def list_commands
+          FRONDE_COMMANDS.filter_map 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
+            line.join(' ')
+          end.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_COMMANDS.include?(command)
+
+          cmd_opt = FRONDE_COMMANDS[command]
+          return cmd_opt[:alias] if cmd_opt.has_key?(:alias)
+
+          command
+        end
+
+        # Returns the given command options.
+        #
+        # This method will first try to resolve command alias, if any.
+        #
+        # @param command [String] the command, which options should be returned
+        # @return [Hash] the command options
+        def command_options(command)
+          cmd = resolve_possible_alias command
+          FRONDE_COMMANDS[cmd].merge(name: cmd)
+        end
+      end
+    end
+  end
+end