doing 2.0.18 → 2.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbd007c83df322397ff7da7025dfbc0e31fd0b54b3247bfffb2e7a61134366a5
-  data.tar.gz: 78e741e12e3f28771d68bc7028caf2ed03edb677be1cfe8f975f32406d3d4f01
+  metadata.gz: 36dd66af3e00464697ab6eb89101e501e0b50ee6b21bc8629a13e21b3906c18a
+  data.tar.gz: 758903fc78fd9a812ab723a5af00cdec0c6cd13c1316dc638e9ca10f24bf939a
 SHA512:
-  metadata.gz: 1a7262555d07ecea5e0e504df1edaacd48654156a50dff44f1d5ee365c04b6c5ae5f4785d9a97f7b6363c450d8184f186aff21ac47653684494e5aec3d1e5f8a
-  data.tar.gz: 1b2e38445ffbe3a6a9687bdd8607f5b41591a4370e4ac68f4036155baceac97e98a50c58cb31e1948f6bdbfd6419fa419e9e1db75170e339227e09361f0b601b
+  metadata.gz: e755266bcfedb72b69f966a2621af76b5014168cd44898c2ba24b0dfc711482aef6a3694afd8010abbeb3bdeb88749532b15f1699ab6926227679ffb7308758d
+  data.tar.gz: f892efc03f34754866f436603e49c3e3f9b9ec52496ecdcddb1c5783abc485b7996bb5385d531a5814a4ee9b52d262f754545ee4a0a0559e49ccfff56de38bdb

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+### 2.0.22
+
+#### IMPROVED
+
+- include fzf source directly, in case git isn't installed
+
+### 2.0.20
+
+#### IMPROVED
+
+- completion script generator refactor and progress bars
+
+#### FIXED
+
+- compile fzf for current operating system
+
+### 2.0.19
+
+#### FIXED
+
+- Remove any coloring before writing to doing file
+
 ### 2.0.18
 
 #### FIXED

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    doing (2.0.18)
+    doing (2.0.22)
       chronic (~> 0.10, >= 0.10.2)
       deep_merge (~> 1.2, >= 1.2.1)
       gli (~> 2.19, >= 2.19.2)
       haml (~> 5.0.0, >= 5.0.0)
       safe_yaml (~> 1.0)
+      tty-progressbar (~> 0.18, >= 0.18.2)
 
 GEM
   remote: http://rubygems.org/
@@ -89,6 +90,7 @@ GEM
       rspec-support (~> 3.10.0)
     rspec-support (3.10.3)
     safe_yaml (1.0.5)
+    strings-ansi (0.2.0)
     sys-uname (1.2.2)
       ffi (~> 1.1)
     temple (0.8.2)
@@ -97,8 +99,16 @@ GEM
     thor (1.1.0)
     thread_safe (0.3.6)
     tilt (2.0.10)
+    tty-cursor (0.7.1)
+    tty-progressbar (0.18.2)
+      strings-ansi (~> 0.2)
+      tty-cursor (~> 0.7)
+      tty-screen (~> 0.8)
+      unicode-display_width (>= 1.6, < 3.0)
+    tty-screen (0.8.1)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
     yard (0.9.26)
     zeitwerk (2.5.1)
 
@@ -108,13 +118,13 @@ PLATFORMS
 DEPENDENCIES
   aruba (~> 1.0.2)
   doing!
-  github-markup
-  parallel_tests
+  github-markup (~> 4.0, >= 4.0.0)
+  parallel_tests (~> 3.7, >= 3.7.3)
   rake (~> 13.0, >= 13.0.1)
   rdoc (~> 6.3.1)
-  redcarpet
+  redcarpet (~> 3.5, >= 3.5.1)
   test-unit (~> 3.4.4)
-  yard
+  yard (~> 0.9, >= 0.9.26)
 
 BUNDLED WITH
    2.2.17

data/README.md

@@ -6,7 +6,7 @@ _If you're one of the rare people like me who find this useful, feel free to [bu
 
 <!--README-->
 
-The current version of `doing` is <!--VER-->2.0.17<!--END VER-->.
+The current version of `doing` is <!--VER-->2.0.21<!--END VER-->.
 
 Find all of the documentation in the [doing wiki](https://github.com/ttscoff/doing/wiki).
 

data/bin/doing

@@ -2149,28 +2149,12 @@ command :completion do |c|
 
   c.desc 'File to write output to'
   c.arg_name 'PATH'
-  c.flag %i[f file], default_value: 'stdout'
+  c.flag %i[f file], default_value: 'STDOUT'
 
   c.action do |_global_options, options, _args|
     script_dir = File.join(File.dirname(__FILE__), '..', 'scripts')
 
-    case options[:type]
-    when /^b/
-      result = `ruby #{File.join(script_dir, 'generate_bash_completions.rb')}`
-    when /^z/
-      result = `ruby #{File.join(script_dir, 'generate_zsh_completions.rb')}`
-    when /^f/
-      result = `ruby #{File.join(script_dir, 'generate_fish_completions.rb')}`
-    end
-
-    if options[:file] =~ /^stdout$/i
-      $stdout.puts result
-    else
-      File.open(File.expand_path(options[:file]), 'w') do |f|
-        f.puts result
-      end
-      Doing.logger.warn('File written:', "#{options[:type]} completions written to #{options[:file]}")
-    end
+    Doing::Completion.generate_completion(type: options[:type], file: options[:file])
   end
 end
 

data/doing.gemspec

@@ -27,10 +27,11 @@ spec = Gem::Specification.new do |s|
   s.add_development_dependency 'rdoc', '~> 6.3.1'
   s.add_development_dependency 'aruba', '~> 1.0.2'
   s.add_development_dependency 'test-unit', '~> 3.4.4'
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'redcarpet'
-  s.add_development_dependency 'github-markup'
-  s.add_development_dependency 'parallel_tests'
+  s.add_development_dependency 'yard', '~> 0.9', '>= 0.9.26'
+  s.add_development_dependency 'redcarpet', '~> 3.5', '>= 3.5.1'
+  s.add_development_dependency 'github-markup', '~> 4.0', '>= 4.0.0'
+  s.add_development_dependency 'parallel_tests', '~> 3.7', '>= 3.7.3'
+  s.add_runtime_dependency('tty-progressbar', '~> 0.18', '>= 0.18.2')
   s.add_runtime_dependency('gli', '~> 2.19', '>= 2.19.2')
   s.add_runtime_dependency('haml','~>5.0.0', '>= 5.0.0')
   s.add_runtime_dependency('chronic','~> 0.10', '>= 0.10.2')

data/doing.rdoc

@@ -5,7 +5,7 @@ record of what you've been doing, complete with tag-based time tracking. The
 command line tool allows you to add entries, annotate with tags and notes, and
 view your entries with myriad options, with a focus on a "natural" language syntax.
 
-v2.0.18
+v2.0.22
 
 === Global Options
 === --config_file arg
@@ -374,7 +374,7 @@ Generate shell completion scripts
 
 File to write output to
 
-[Default Value] stdout
+[Default Value] STDOUT
 
 
 ===== -t|--type SHELL

data/generate_completions.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
 
-scripts/generate_fish_completions.rb > lib/completion/doing.fish
-scripts/generate_bash_completions.rb > lib/completion/doing.bash
-scripts/generate_zsh_completions.rb > lib/completion/_doing.zsh
+bundle exec bin/doing completion --type fish --file lib/completion/doing.fish
+bundle exec bin/doing completion --type bash --file lib/completion/doing.bash
+bundle exec bin/doing completion --type zsh --file lib/completion/_doing.zsh

data/lib/doing/cli_status.rb

@@ -14,8 +14,12 @@ module Status
     $stderr.print format("#{esc['kill']}#{esc['boldyellow']}> #{esc['boldgreen']}%s #{esc['white']}[#{esc['boldwhite']}%#{@commands.count.to_s.length}d#{esc['boldblack']}/#{esc['boldyellow']}%d#{esc['white']}]: #{esc['boldcyan']}%s#{esc['default']}\r", msg, idx, total, tail)
   end
 
-  def status(msg, reset: true)
-    $stderr.print format("#{esc['kill']}#{esc['boldyellow']}> #{esc['whiteboard']}%s#{esc['default']}%s", msg, reset ? "\r" : "\n")
+  def status(msg, reset: true, end_char: "\n")
+    $stderr.print format("#{esc['kill']}#{esc['boldyellow']}> #{esc['whiteboard']}%s#{esc['default']}%s", msg, reset ? "\r" : end_char)
+  end
+
+  def msg(msg, reset: true, color: 'green', end_char: "\n")
+    $stderr.print format("#{esc['kill']}#{esc[color]}%s#{esc['default']}%s", msg, reset ? "\r" : end_char)
   end
 
   def clear

data/lib/doing/completion/bash_completion.rb

@@ -0,0 +1,185 @@
+module Doing
+  module Completion
+    class BashCompletions
+      attr_accessor :commands, :global_options
+
+      def main_function
+        first = true
+        out = []
+        logic = []
+        need_export = []
+
+        @commands.each_with_index do |cmd, i|
+          @bar.advance
+
+          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
+        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
+        data = get_help_sections
+        @global_options = parse_options(data[:global_options])
+        @commands = parse_commands(data[:commands])
+        @bar = TTY::ProgressBar.new("\033[0;0;33mGenerating Bash completions: \033[0;35;40m[:bar]\033[0m", total: @commands.count, bar_format: :blade)
+        @bar.resize(25)
+      end
+
+      def generate_completions
+        @bar.start
+        out = []
+        out << main_function
+        out << 'complete -F _doing doing'
+        @bar.finish
+        out.join("\n")
+      end
+    end
+  end
+end

data/lib/doing/completion/fish_completion.rb

@@ -0,0 +1,175 @@
+module Doing
+  module Completion
+    class FishCompletions
+
+      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 = []
+        @commands.each_with_index do |cmd, i|
+          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 = []
+
+        @commands.each_with_index do |cmd, i|
+          @bar.advance
+          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
+        data = get_help_sections
+        @global_options = parse_options(data[:global_options])
+        @commands = parse_commands(data[:commands])
+        @bar = TTY::ProgressBar.new("\033[0;0;33mGenerating Fish completions: \033[0;35;40m[:bar]\033[0m", total: @commands.count, bar_format: :blade)
+        @bar.resize(25)
+      end
+
+      def generate_completions
+        @bar.start
+        out = []
+        out << generate_helpers
+        out << generate_subcommand_completions
+        out << generate_subcommand_option_completions
+        @bar.finish
+        out.join("\n")
+      end
+    end
+  end
+end

data/lib/doing/completion/string.rb

@@ -0,0 +1,17 @@
+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