doing 1.0.93 → 2.0.6.pre

data/scripts/generate_bash_completions.rb

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+require 'doing/cli_status'
+
+require 'shellwords'
+
+class ::String
+  def short_desc
+    split(/[,.]/)[0].sub(/ \(.*?\)?$/, '').strip
+  end
+
+  def ltrunc(max)
+    if length > max
+      sub(/^.*?(.{#{max - 3}})$/, '...\1')
+    else
+      self
+    end
+  end
+
+  def ltrunc!(max)
+    replace ltrunc(max)
+  end
+end
+
+class BashCompletions
+  include Status
+
+  attr_accessor :commands, :global_options
+
+  def main_function
+    first = true
+    out = []
+    logic = []
+    need_export = []
+    # processing = []
+
+    @commands.each_with_index do |cmd, i|
+      # processing << cmd[:commands].first
+      processing = cmd[:commands]
+      progress('Processing subcommand options', i, @commands.count, processing)
+
+      data = get_help_sections(cmd[:commands].first)
+
+      arg = data[:synopsis].join(' ').strip.split(/ /).last
+      case arg
+      when /(path|file)/i
+        type = :file
+      when /sect/i
+        type = 'sections'
+      when /view/i
+        type = 'views'
+      else
+        type = nil
+      end
+
+      if data[:command_options]
+        options = parse_options(data[:command_options])
+        out << command_function(cmd[:commands].first, options, type)
+
+        if first
+          op = 'if'
+          first = false
+        else
+          op = 'elif'
+        end
+        logic << %(#{op} [[ $last =~ (#{cmd[:commands].join('|')}) ]]; then _doing_#{cmd[:commands].first})
+      end
+    end
+
+    out << <<~EOFUNC
+      _doing()
+      {
+        local last="${@: -1}"
+        local token=${COMP_WORDS[$COMP_CWORD]}
+
+        #{logic.join("\n    ")}
+        else
+          OLD_IFS="$IFS"
+          IFS=$'\n'
+          COMPREPLY=( $(compgen -W "$(doing help -c)" -- $token) )
+          IFS="$OLD_IFS"
+        fi
+      }
+    EOFUNC
+    clear
+    out.join("\n")
+  end
+
+  def command_function(command, options, type)
+    long_options = []
+    short_options = []
+    
+    options.each do |o|
+      next if o.nil?
+
+      long_options << o[:long] if o[:long]
+      short_options << o[:short] if o[:short]
+    end
+
+    long = long_options.map! {|o| "--#{o}"}.join(' ')
+    short = short_options.map! {|o| "-#{o}"}.join(' ')
+    words = ''
+    logic = ''
+    words, logic = get_words(type) if type && type.is_a?(String)
+
+    func = <<~ENDFUNC
+    _doing_#{command}() {
+      #{words}
+      if [[ "$token" == --* ]]; then
+        COMPREPLY=( $( compgen -W '#{long}' -- $token ) )
+      elif [[ "$token" == -* ]]; then
+        COMPREPLY=( $( compgen -W '#{short} #{long}' -- $token ) )
+      #{logic}
+      fi
+    }
+    ENDFUNC
+
+    func
+  end
+
+  def get_words(type)
+    func = <<~EOFUNC
+      OLD_IFS="$IFS"
+      local token=${COMP_WORDS[$COMP_CWORD]}
+      IFS=$'\t'
+      local words=$(doing #{type})
+      IFS="$OLD_IFS"
+    EOFUNC
+
+    logic = <<~EOLOGIC
+      else
+        local nocasematchWasOff=0
+        shopt nocasematch >/dev/null || nocasematchWasOff=1
+        (( nocasematchWasOff )) && shopt -s nocasematch
+        local w matches=()
+        OLD_IFS="$IFS"
+        IFS=$'\t'‰
+        for w in $words; do
+          if [[ "$w" == "$token"* ]]; then
+            matches+=("${w// /\ }")
+          fi
+        done
+        IFS="$OLD_IFS"
+        (( nocasematchWasOff )) && shopt -u nocasematch
+        COMPREPLY=("${matches[@]}")
+    EOLOGIC
+
+    [func, logic]
+  end
+
+
+
+  def get_help_sections(command = '')
+    res = `doing help #{command}`.strip
+    scanned = res.scan(/(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/)
+    sections = {}
+    scanned.each do |sect|
+      title = sect[0].downcase.strip.gsub(/ +/, '_').to_sym
+      content = sect[1].split(/\n/).map(&:strip).delete_if(&:empty?)
+      sections[title] = content
+    end
+    sections
+  end
+
+  def parse_option(option)
+    res = option.match(/(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>[\w_]+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/)
+    return nil unless res
+    {
+      short: res['short'],
+      long: res['long'],
+      arg: res[:arg],
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_options(options)
+    options.map { |opt| parse_option(opt) }
+  end
+
+  def parse_command(command)
+    res = command.match(/^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/)
+    commands = [res['cmd']]
+    commands.concat(res['alias'].split(/, /).delete_if(&:empty?)) if res['alias']
+
+    {
+      commands: commands,
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_commands(commands)
+    commands.map { |cmd| parse_command(cmd) }
+  end
+
+  def initialize
+    status('Generating Bash completions', reset: false)
+    data = get_help_sections
+    @global_options = parse_options(data[:global_options])
+    @commands = parse_commands(data[:commands])
+  end
+
+  def generate_completions
+    out = []
+    out << main_function
+    out << 'complete -F _doing doing'
+    status('Complete', reset: false)
+    out.join("\n")
+  end
+end
+
+puts BashCompletions.new.generate_completions

data/scripts/generate_fish_completions.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+require 'doing/cli_status'
+
+require 'shellwords'
+
+class ::String
+  def short_desc
+    split(/[,.]/)[0].sub(/ \(.*?\)?$/, '').strip
+  end
+
+  def ltrunc(max)
+    if length > max
+      sub(/^.*?(.{#{max - 3}})$/, '...\1')
+    else
+      self
+    end
+  end
+
+  def ltrunc!(max)
+    replace ltrunc(max)
+  end
+end
+
+class FishCompletions
+  include Status
+
+  attr_accessor :commands, :global_options
+
+  def generate_helpers
+    <<~EOFUNCTIONS
+      function __fish_doing_needs_command
+        # Figure out if the current invocation already has a command.
+
+        set -l opts h-help config_file= f-doing_file= n-notes v-version stdout d-debug default x-noauto
+        set cmd (commandline -opc)
+        set -e cmd[1]
+        argparse -s $opts -- $cmd 2>/dev/null
+        or return 0
+        # These flags function as commands, effectively.
+        if set -q argv[1]
+          # Also print the command, so this can be used to figure out what it is.
+          echo $argv[1]
+          return 1
+        end
+        return 0
+      end
+
+      function __fish_doing_using_command
+        set -l cmd (__fish_doing_needs_command)
+        test -z "$cmd"
+        and return 1
+        contains -- $cmd $argv
+        and return 0
+      end
+
+      function __fish_doing_complete_sections
+        doing sections -c
+      end
+
+      function __fish_doing_complete_views
+        doing views -c
+      end
+
+      function __fish_doing_subcommands
+        doing help -c
+      end
+
+      function __fish_doing_export_plugins
+        doing plugins --type export -c
+      end
+
+      function __fish_doing_import_plugins
+        doing plugins --type import -c
+      end
+
+      function __fish_doing_complete_templates
+        doing template -c
+      end
+
+      complete -c doing -f
+      complete -xc doing -n '__fish_doing_needs_command' -a '(__fish_doing_subcommands)'
+
+      complete -f -c doing -n '__fish_doing_using_command show' -a '(__fish_doing_complete_sections)'
+      complete -f -c doing -n '__fish_doing_using_command view' -a '(__fish_doing_complete_views)'
+      complete -f -c doing -n '__fish_doing_using_command template' -a '(__fish_doing_complete_templates)'
+      complete -f -c doing -s t -l type -x -n '__fish_doing_using_command import' -a '(__fish_doing_import_plugins)'
+
+      complete -xc doing -n '__fish_seen_subcommand_from help; and not __fish_seen_subcommand_from (doing help -c)' -a "(doing help -c)"
+    EOFUNCTIONS
+  end
+
+  def get_help_sections(command = '')
+    res = `doing help #{command}`.strip
+    scanned = res.scan(/(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/)
+    sections = {}
+    scanned.each do |sect|
+      title = sect[0].downcase.strip.gsub(/ +/, '_').to_sym
+      content = sect[1].split(/\n/).map(&:strip).delete_if(&:empty?)
+      sections[title] = content
+    end
+    sections
+  end
+
+  def parse_option(option)
+    res = option.match(/(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>[\w_]+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/)
+    return nil unless res
+    {
+      short: res['short'],
+      long: res['long'],
+      arg: res[:arg],
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_options(options)
+    options.map { |opt| parse_option(opt) }
+  end
+
+  def parse_command(command)
+    res = command.match(/^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/)
+    commands = [res['cmd']]
+    commands.concat(res['alias'].split(/, /).delete_if(&:empty?)) if res['alias']
+
+    {
+      commands: commands,
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_commands(commands)
+    commands.map { |cmd| parse_command(cmd) }
+  end
+
+  def generate_subcommand_completions
+    out = []
+    # processing = []
+    @commands.each_with_index do |cmd, i|
+      # processing << cmd[:commands].first
+      processing = cmd[:commands]
+      progress('Processing subcommands', i, @commands.count, processing)
+      out << "complete -xc doing -n '__fish_doing_needs_command' -a '#{cmd[:commands].join(' ')}' -d #{Shellwords.escape(cmd[:description])}"
+    end
+
+    out.join("\n")
+  end
+
+  def generate_subcommand_option_completions
+
+    out = []
+    need_export = []
+    # processing = []
+
+    @commands.each_with_index do |cmd, i|
+      # processing << cmd[:commands].first
+      processing = cmd[:commands]
+      progress('Processing subcommand options', i, @commands.count, processing)
+
+      data = get_help_sections(cmd[:commands].first)
+
+      if data[:synopsis].join(' ').strip.split(/ /).last =~ /(path|file)/i
+        out << "complete -c doing -F -n '__fish_doing_using_command #{cmd[:commands].join(" ")}'"
+      end
+
+      if data[:command_options]
+        parse_options(data[:command_options]).each do |option|
+          next if option.nil?
+
+          arg = option[:arg] ? '-r' : ''
+          short = option[:short] ? "-s #{option[:short]}" : ''
+          long = option[:long] ? "-l #{option[:long]}" : ''
+          out << "complete -c doing #{long} #{short} -f #{arg} -n '__fish_doing_using_command #{cmd[:commands].join(' ')}' -d #{Shellwords.escape(option[:description])}"
+
+          need_export.concat(cmd[:commands]) if option[:long] == 'output'
+        end
+      end
+    end
+
+    unless need_export.empty?
+      out << "complete -f -c doing -s o -l output -x -n '__fish_doing_using_command #{need_export.join(' ')}' -a '(__fish_doing_export_plugins)'"
+    end
+
+    clear
+    out.join("\n")
+  end
+
+  def initialize
+    status('Generating Fish completions', reset: false)
+    data = get_help_sections
+    @global_options = parse_options(data[:global_options])
+    @commands = parse_commands(data[:commands])
+  end
+
+  def generate_completions
+    out = []
+    out << generate_helpers
+    out << generate_subcommand_completions
+    out << generate_subcommand_option_completions
+    status('Complete', reset: false)
+    out.join("\n")
+  end
+end
+
+puts FishCompletions.new.generate_completions

data/scripts/generate_zsh_completions.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+require 'doing/cli_status'
+
+require 'shellwords'
+
+class ::String
+  def short_desc
+    split(/[,.]/)[0].sub(/ \(.*?\)?$/, '').strip
+  end
+
+  def ltrunc(max)
+    if length > max
+      sub(/^.*?(.{#{max - 3}})$/, '...\1')
+    else
+      self
+    end
+  end
+
+  def ltrunc!(max)
+    replace ltrunc(max)
+  end
+end
+
+class ZshCompletions
+  include Status
+
+  attr_accessor :commands, :global_options
+
+  def generate_helpers
+    <<~EOFUNCTIONS
+      compdef _doing doing
+
+      function _doing() {
+          local line state
+
+          function _commands {
+              local -a commands
+
+              commands=(
+                        #{generate_subcommand_completions.join("\n                  ")}
+              )
+              _describe 'command' commands
+          }
+
+          _arguments -C \
+                  "1: :_commands" \
+                  "*::arg:->args"
+
+
+
+          case $line[1] in
+              #{generate_subcommand_option_completions(indent: '            ').join("\n            ")}
+          esac
+
+          _arguments -s $args
+      }
+
+    EOFUNCTIONS
+  end
+
+  def get_help_sections(command = '')
+    res = `doing help #{command}`.strip
+    scanned = res.scan(/(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/)
+    sections = {}
+    scanned.each do |sect|
+      title = sect[0].downcase.strip.gsub(/ +/, '_').to_sym
+      content = sect[1].split(/\n/).map(&:strip).delete_if(&:empty?)
+      sections[title] = content
+    end
+    sections
+  end
+
+  def parse_option(option)
+    res = option.match(/(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>[\w_]+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/)
+    return nil unless res
+
+    {
+      short: res['short'],
+      long: res['long'],
+      arg: res[:arg],
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_options(options)
+    options.map { |opt| parse_option(opt) }
+  end
+
+  def parse_command(command)
+    res = command.match(/^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/)
+    commands = [res['cmd']]
+    commands.concat(res['alias'].split(/, /).delete_if(&:empty?)) if res['alias']
+
+    {
+      commands: commands,
+      description: res['desc'].short_desc
+    }
+  end
+
+  def parse_commands(commands)
+    commands.map { |cmd| parse_command(cmd) }
+  end
+
+  def generate_subcommand_completions
+    out = []
+    # processing = []
+    @commands.each_with_index do |cmd, i|
+      # processing << cmd[:commands].first
+      processing = cmd[:commands]
+      progress('Processing subcommands', i, @commands.count, processing)
+      cmd[:commands].each do |c|
+        out << "'#{c}:#{cmd[:description].gsub(/'/, '\\\'')}'"
+      end
+    end
+    clear
+    out
+  end
+
+  def generate_subcommand_option_completions(indent: '        ')
+
+    out = []
+    # processing = []
+
+    @commands.each_with_index do |cmd, i|
+      # processing << cmd[:commands].first
+      processing = cmd[:commands]
+      progress('Processing subcommand options', i, @commands.count, processing)
+
+      data = get_help_sections(cmd[:commands].first)
+      option_arr = []
+
+      if data[:command_options]
+        parse_options(data[:command_options]).each do |option|
+          next if option.nil?
+
+          arg = option[:arg] ? '=' : ''
+
+          option_arr << if option[:short]
+                          %({-#{option[:short]},--#{option[:long]}#{arg}}"[#{option[:description].gsub(/'/, '\\\'')}]")
+                        else
+                          %("(--#{option[:long]}#{arg})--#{option[:long]}#{arg}}[#{option[:description].gsub(/'/, '\\\'')}]")
+                        end
+        end
+      end
+
+      cmd[:commands].each do |c|
+        out << "#{c}) \n#{indent}    args=( #{option_arr.join(' ')} )\n#{indent};;"
+      end
+    end
+
+    out
+  end
+
+  def initialize
+    status('Generating Zsh completions', reset: false)
+    data = get_help_sections
+    @global_options = parse_options(data[:global_options])
+    @commands = parse_commands(data[:commands])
+  end
+
+  def generate_completions
+    generate_helpers
+    status('Complete', reset: false)
+  end
+end
+
+puts ZshCompletions.new.generate_completions

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: doing
 version: !ruby/object:Gem::Version
-  version: 1.0.93
+  version: 2.0.6.pre
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-16 00:00:00.000000000 Z
+date: 2021-11-18 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: safe_yaml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -162,16 +176,78 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- AUTHORS
+- CHANGELOG.md
+- COMMANDS.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
 - README.md
+- Rakefile
+- _config.yml
 - bin/doing
+- doing.gemspec
+- doing.rdoc
+- example_plugin.rb
+- generate_completions.sh
+- img/doing-colors.jpg
+- img/doing-printf-wrap-800.jpg
+- img/doing-show-note-formatting-800.jpg
+- lib/completion/_doing.zsh
+- lib/completion/doing.bash
+- lib/completion/doing.fish
 - lib/doing.rb
-- lib/doing/helpers.rb
-- lib/doing/markdown_export.rb
+- lib/doing/array.rb
+- lib/doing/cli_status.rb
+- lib/doing/colors.rb
+- lib/doing/configuration.rb
+- lib/doing/errors.rb
+- lib/doing/hash.rb
+- lib/doing/hooks.rb
+- lib/doing/item.rb
+- lib/doing/log_adapter.rb
+- lib/doing/markdown_document_listener.rb
+- lib/doing/note.rb
+- lib/doing/pager.rb
+- lib/doing/plugin_manager.rb
+- lib/doing/plugins/export/csv_export.rb
+- lib/doing/plugins/export/html_export.rb
+- lib/doing/plugins/export/json_export.rb
+- lib/doing/plugins/export/markdown_export.rb
+- lib/doing/plugins/export/taskpaper_export.rb
+- lib/doing/plugins/export/template_export.rb
+- lib/doing/plugins/import/cal_to_json.scpt
+- lib/doing/plugins/import/calendar_import.rb
+- lib/doing/plugins/import/doing_import.rb
+- lib/doing/plugins/import/timing_import.rb
+- lib/doing/string.rb
+- lib/doing/symbol.rb
+- lib/doing/time.rb
+- lib/doing/util.rb
 - lib/doing/version.rb
 - lib/doing/wwid.rb
+- lib/doing/wwidfile.rb
+- lib/examples/commands/autotag.rb
+- lib/examples/commands/wiki.rb
+- lib/examples/plugins/hooks.rb
+- lib/examples/plugins/say_export.rb
+- lib/examples/plugins/templates/wiki.css
+- lib/examples/plugins/templates/wiki.haml
+- lib/examples/plugins/templates/wiki_index.haml
+- lib/examples/plugins/wiki_export.rb
 - lib/helpers/fuzzyfilefinder
+- lib/templates/doing-markdown.erb
 - lib/templates/doing.css
 - lib/templates/doing.haml
+- man/doing.1
+- man/doing.1.html
+- man/doing.1.ronn
+- package-lock.json
+- rdoc_to_mmd.rb
+- rdocfixer.rb
+- scripts/generate_bash_completions.rb
+- scripts/generate_fish_completions.rb
+- scripts/generate_zsh_completions.rb
 homepage: http://brettterpstra.com/project/doing/
 licenses:
 - MIT
@@ -184,7 +260,6 @@ rdoc_options:
 - README.md
 - "--markup"
 - markdown
-- "-ri"
 require_paths:
 - lib
 - lib
@@ -195,9 +270,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.2.16
 signing_key: