doing 2.1.30 → 2.1.34

data/lib/doing/completion/zsh_completion.rb

@@ -1,7 +1,15 @@
+# frozen_string_literal: true
+
 module Doing
   module Completion
-    class ZshCompletions
+    class ::String
+      def sanitize
+        gsub(/'/, '\\\'').gsub(/\[/, '(').gsub(/\]/, ')')
+      end
+    end
 
+    # Generate completions for zsh
+    class ZshCompletions
       attr_accessor :commands, :global_options
 
       def generate_helpers
@@ -34,58 +42,11 @@ module Doing
           }
 
         EOFUNCTIONS
+        @bar.advance(status: '✅')
         @bar.finish
         out
       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>.*?)$/)
-        if res.nil?
-          Doing.logger.error('Completion:', "Error parsing #{command}")
-          return nil
-
-        end
-        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|
@@ -103,19 +64,19 @@ module Doing
         @commands.each_with_index do |cmd, i|
           @bar.advance(status: cmd[:commands].first)
 
-          data = get_help_sections(cmd[:commands].first)
+          data = Completion.get_help_sections(cmd[:commands].first)
           option_arr = []
 
           if data[:command_options]
-            parse_options(data[:command_options]).each do |option|
+            Completion.parse_options(data[:command_options]).each do |option|
               next if option.nil?
 
-              arg = option[:arg] ? '=' : ''
+              arg = option[:arg] ? ":#{option[:arg]}:" : ''
 
               option_arr << if option[:short]
-                              %({-#{option[:short]},--#{option[:long]}#{arg}}"[#{option[:description].gsub(/'/, '\\\'')}]")
+                              %({'(--#{option[:long]})-#{option[:short]}','(-#{option[:short]})--#{option[:long]}'}"[#{option[:description].sanitize}]#{arg}")
                             else
-                              %("(--#{option[:long]}#{arg})--#{option[:long]}#{arg}}[#{option[:description].gsub(/'/, '\\\'')}]")
+                              %("--#{option[:long]}[#{option[:description].sanitize}]#{arg}")
                             end
             end
           end
@@ -129,11 +90,12 @@ module Doing
       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 Zsh completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count, bar_format: :blade, status: 'processing subcommands')
-        @bar.resize(25)
+        data = Completion.get_help_sections
+        @global_options = Completion.parse_options(data[:global_options])
+        @commands = Completion.parse_commands(data[:commands])
+        @bar = TTY::ProgressBar.new(" \033[0;0;33mGenerating Zsh completions: \033[0;35;40m[:bar] :status\033[0m", total: @commands.count + 1, bar_format: :square, hide_cursor: true, status: 'processing subcommands')
+        width = TTY::Screen.columns - 45
+        @bar.resize(width)
       end
 
       def generate_completions

data/lib/doing/completion.rb

@@ -11,25 +11,118 @@ require 'bash_completion'
 module Doing
   # Completion script generator
   module Completion
+    OPTIONS_RX = /(?:-(?<short>\w), )?(?:--(?:\[no-\])?(?<long>\w+)(?:=(?<arg>\w+))?)\s+- (?<desc>.*?)$/.freeze
+    SECTIONS_RX = /(?m-i)^([A-Z ]+)\n([\s\S]*?)(?=\n+[A-Z]+|\Z)/.freeze
+    COMMAND_RX = /^(?<cmd>[^, \t]+)(?<alias>(?:, [^, \t]+)*)?\s+- (?<desc>.*?)$/.freeze
+
     class << self
+      def get_help_sections(command = '')
+        res = `doing help #{command}`.strip
+        scanned = res.scan(SECTIONS_RX)
+        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(OPTIONS_RX)
+        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(COMMAND_RX)
+        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
+
       # Generate a completion script and output to file or
       # stdout
       #
       # @param      type  [String] shell to generate for (zsh|bash|fish)
       # @param      file  [String] Path to save to, or 'stdout'
       #
-      def generate_completion(type: 'zsh', file: 'stdout')
-        if type =~ /^all$/i
-          Doing.logger.log_now(:warn, 'Generating:', 'all completion types, will use default paths')
-          generate_completion(type: 'fish', file: 'lib/completion/doing.fish')
-          Doing.logger.warn('File written:', "fish completions written to lib/completion/doing.fish")
-          generate_completion(type: 'zsh', file: 'lib/completion/_doing.zsh')
-          Doing.logger.warn('File written:', "zsh completions written to lib/completion/_doing.zsh")
-          generate_completion(type: 'bash', file: 'lib/completion/doing.bash')
-          Doing.logger.warn('File written:', "bash completions written to lib/completion/doing.bash")
-          return
+      def generate_completion(type: 'zsh', file: :default, link: true)
+        return generate_all if type =~ /^all$/i
+
+        file = file == :default ? default_file(type) : file
+        file = validate_target(file)
+        result = generate_type(type)
+
+        if file =~ /^stdout$/i
+          $stdout.puts result
+        else
+          File.open(file, 'w') { |f| f.puts result }
+          Doing.logger.warn('File written:', "#{type} completions written to #{file}")
+
+          link_completion_type(type, file) if link
         end
+      end
+
+      def link_default(type)
+        type = normalize_type(type)
+        raise InvalidArgument, 'Unrecognized shell specified' if type == :invalid
+
+        return %i[zsh bash fish].each { |t| link_default(t) } if type == :all
 
+        install_builtin(type)
+
+        link_completion_type(type, File.join(default_dir, default_filenames[type]))
+      end
+
+      def install_builtin(type)
+        FileUtils.mkdir_p(default_dir)
+        src = File.expand_path(File.join(File.dirname(__FILE__), '..', 'completion', default_filenames[type]))
+
+        if File.exist?(File.join(default_dir, default_filenames[type]))
+          return unless Doing::Prompt.yn("Update #{type} completion script", default_response: 'n')
+        end
+
+        FileUtils.cp(src, default_dir)
+        Doing.logger.warn('File written:', "#{type} completions saved to #{default_file(type)}")
+      end
+
+      def normalize_type(type)
+        case type.to_s
+        when /^f/i
+          :fish
+        when /^b/i
+          :bash
+        when /^z/i
+          :zsh
+        when /^a/i
+          :all
+        else
+          :invalid
+        end
+      end
+
+      private
+
+      def generate_type(type)
         generator = case type.to_s
                     when /^f/i
                       FishCompletions.new
@@ -39,16 +132,109 @@ module Doing
                       ZshCompletions.new
                     end
 
-        result = generator.generate_completions
+        generator.generate_completions
+      end
 
-        if file =~ /^stdout$/i
-          $stdout.puts result
-        else
-          File.open(File.expand_path(file), 'w') do |f|
-            f.puts result
+      def validate_target(file)
+        unless file =~ /stdout/i
+          file = validate_file(file)
+
+          validate_dir(file)
+        end
+
+        file
+      end
+
+      def default_dir
+        File.expand_path('~/.local/share/doing/completion')
+      end
+
+      def default_filenames
+        { zsh: '_doing.zsh', bash: 'doing.bash', fish: 'doing.fish' }
+      end
+
+      def default_file(type)
+        type = normalize_type(type)
+
+        File.join(default_dir, default_filenames[type])
+      end
+
+      def validate_file(file)
+        file = File.expand_path(file)
+        if File.exist?(file)
+          res = Doing::Prompt.yn("Overwrite #{file}", default_response: 'y')
+          raise UserCancelled unless res
+
+          FileUtils.rm(file) if res
+        end
+        file
+      end
+
+      def validate_dir(file)
+        dir = File.dirname(file)
+        unless File.directory?(dir)
+          res = Doing::Prompt.yn("#{dir} doesn't exist, create it", default_response: 'y')
+          raise UserCancelled unless res
+
+          FileUtils.mkdir_p(dir)
+        end
+        dir
+      end
+
+      def generate_all
+        Doing.logger.log_now(:warn, 'Generating:', 'all completion types, will use default paths')
+        generate_completion(type: 'fish', file: 'lib/completion/doing.fish', link: false)
+        Doing.logger.warn('File written:', 'fish completions written to lib/completion/doing.fish')
+        generate_completion(type: 'zsh', file: 'lib/completion/_doing.zsh', link: false)
+        Doing.logger.warn('File written:', 'zsh completions written to lib/completion/_doing.zsh')
+        generate_completion(type: 'bash', file: 'lib/completion/doing.bash', link: false)
+        Doing.logger.warn('File written:', 'bash completions written to lib/completion/doing.bash')
+      end
+
+      def link_completion_type(type, file)
+        dir = File.dirname(file)
+        case type.to_s
+        when /^b/i
+          unless dir =~ %r{(\.bash_it/completion|bash_completion/completions)}
+            link_completion(file, ['~/.bash_it/completion/enabled', '/usr/share/bash_completion/completions'], 'doing.bash')
           end
-          Doing.logger.warn('File written:', "#{type} completions written to #{file}")
+        when /^f/i
+          link_completion(file, ['~/.config/fish/completions'], 'doing.fish') unless dir =~ %r{.config/fish/completions}
+        when /^z/i
+          unless dir =~ %r{(\.oh-my-zsh/completions|share/site-functions)}
+            link_completion(file, ['~/.oh-my-zsh/completions', '/usr/local/share/zsh/site-functions'], '_doing.zsh')
+          end
+        end
+      end
+
+      def link_completion(file, targets, filename)
+        return if targets.map { |t| File.expand_path(t) }.include?(File.dirname(file))
+
+        found = false
+        linked = false
+
+        targets.each do |target|
+          next unless File.directory?(File.expand_path(target))
+          found = true
+
+          target_file = File.join(File.expand_path(target), filename)
+          next unless Doing::Prompt.yn("Create link to #{target_file}", default_response: 'n')
+
+          FileUtils.ln_s(File.expand_path(file), target_file, force: true)
+          Doing.logger.warn('File linked:', "#{File.expand_path(file)} -> #{target_file}")
+          linked = true
+          break
+        end
+
+        return if linked
+
+        unless found
+          $stdout.puts 'No known auto-load directory found for specified shell'.red
+          $stdout.puts "Looked for #{targets.join(', ')}, found no existing directory".yellow
         end
+        $stdout.puts 'If you don\'t want to autoload completions'.yellow
+        $stdout.puts 'you can source the script directly in your shell\'s startup file:'.yellow
+        $stdout.puts %(source "#{file}").boldwhite
       end
     end
   end

data/lib/doing/configuration.rb

@@ -156,7 +156,13 @@ module Doing
     ##
     ## @return     [String] file path
     ##
-    def choose_config(create: false)
+    def choose_config(create: false, local: false)
+      if local && create
+        res = File.expand_path('.doingrc')
+        FileUtils.touch(res)
+        return res
+      end
+
       return @config_file if @force_answer
 
       if @additional_configs&.count&.positive? || create

data/lib/doing/item.rb

@@ -35,6 +35,8 @@ module Doing
 
     ## If the entry doesn't have a @done date, return the elapsed time
     def duration
+      return nil unless should_time? && should_finish?
+
       return nil if @title =~ /(?<=^| )@done\b/
 
       return Time.now - @date
@@ -88,17 +90,20 @@ module Doing
     ##
     ## Test for equality between items
     ##
-    ## @param      other [Item] The other item
+    ## @param      other          [Item] The other item
+    ## @param      match_section  [Boolean] If true, require item sections to match
     ##
     ## @return     [Boolean] is equal?
     ##
-    def equal?(other)
+    def equal?(other, match_section: false)
       return false if @title.strip != other.title.strip
 
       return false if @date != other.date
 
       return false unless @note.equal?(other.note)
 
+      return false if match_section && @section != other.section
+
       true
     end
 
@@ -272,7 +277,7 @@ module Doing
     end
 
     def highlight_search(search, distance: nil, negate: false, case_type: nil)
-      prefs = Doing.config.settings['search'] || {}
+      prefs = Doing.setting('search', {})
       matching = prefs.fetch('matching', 'pattern').normalize_matching
       distance ||= prefs.fetch('distance', 3).to_i
       case_type ||= prefs.fetch('case', 'smart').normalize_case
@@ -311,7 +316,7 @@ module Doing
     ## @return     [Boolean] matches search criteria
     ##
     def search(search, distance: nil, negate: false, case_type: nil)
-      prefs = Doing.config.settings['search'] || {}
+      prefs = Doing.setting('search', {})
       matching = prefs.fetch('matching', 'pattern').normalize_matching
       distance ||= prefs.fetch('distance', 3).to_i
       case_type ||= prefs.fetch('case', 'smart').normalize_case
@@ -354,6 +359,24 @@ module Doing
       negate ? !matches : matches
     end
 
+    ##
+    ## Test if item has a @done tag
+    ##
+    ## @return     [Boolean] true item has @done tag
+    ##
+    def finished?
+      tags?('done')
+    end
+
+    ##
+    ## Test if item does not contain @done tag
+    ##
+    ## @return     [Boolean] true if item is missing @done tag
+    ##
+    def unfinished?
+      tags?('done', negate: true)
+    end
+
     ##
     ## Test if item is included in never_finish config and
     ## thus should not receive a @done tag
@@ -436,7 +459,7 @@ module Doing
     private
 
     def should?(key)
-      config = Doing.config.settings
+      config = Doing.settings
       return true unless config[key].is_a?(Array)
 
       config[key].each do |tag|
@@ -451,6 +474,8 @@ module Doing
     end
 
     def calc_interval
+      return nil unless should_time? && should_finish?
+
       done = end_date
       return nil if done.nil?
 

data/lib/doing/items.rb

@@ -58,6 +58,24 @@ module Doing
       Doing.logger.info('New section:', %("#{section}" added)) if log
     end
 
+    def delete_section(section, log: false)
+      return unless section?(section)
+
+      raise DoingRuntimeError, 'Section not empty' if in_section(section).count > 0
+
+      deleted = false
+
+      @sections.each do |sect|
+        if sect.title == section && in_section(sect).count.zero?
+          @sections.delete(sect)
+          Doing.logger.info('Removed section:', %("#{section}" removed)) if log
+          return
+        end
+      end
+
+      Doing.logger.error('Not found:', %("#{section}" not found))
+    end
+
     # Get a new Items object containing only items in a
     # specified section
     #
@@ -126,14 +144,44 @@ module Doing
       diff
     end
 
+    ##
+    ## Remove duplicated entries. Duplicate entries must have matching start date, title, note, and section
+    ##
+    ## @return     [Items] Items array with duplicate entries removed
+    ##
+    def dedup(match_section: true)
+      unique = Items.new
+      each do |item|
+        unique.push(item) unless unique.include?(item, match_section: match_section)
+      end
+
+      unique
+    end
+
+    def dedup!(match_section: true)
+      replace dedup(match_section: match_section)
+    end
+
+    def include?(item, match_section: true)
+      includes = false
+      each do |other_item|
+        if other_item.equal?(item, match_section: match_section)
+          includes = true
+          break
+        end
+      end
+
+      includes
+    end
+
     # Output sections and items in Doing file format
     def to_s
       out = []
       @sections.each do |section|
         out.push(section.original)
-        items = in_section(section.title).sort_by { |i| i.date }
-        items.reverse! if Doing.config.settings['doing_file_sort'].normalize_order == :desc
-        items.each { |item| out.push(item.to_s)}
+        items = in_section(section.title).sort_by(&:date)
+        items.reverse! if Doing.setting('doing_file_sort').normalize_order == :desc
+        items.each { |item| out.push(item.to_s) }
       end
 
       out.join("\n")
@@ -141,8 +189,8 @@ module Doing
 
     # @private
     def inspect
-      "#<Doing::Items #{count} items, #{@sections.count} sections: #{@sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')}>"
+      sections = @sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')
+      "#<Doing::Items #{count} items, #{@sections.count} sections: #{sections}>"
     end
-
   end
 end

data/lib/doing/{log_adapter.rb → logger.rb}

@@ -4,7 +4,7 @@ module Doing
   ##
   ## Log adapter
   ##
-  class LogAdapter
+  class Logger
     # Sets the log device
     attr_writer :logdev
 
@@ -332,9 +332,15 @@ module Doing
         if tags_added.empty?
           count(:skipped, level: :debug, message: 'no tags added to %count %items')
         elsif single && item
+          elapsed = if item && tags_added.include?('done')
+                      item.interval ? " (#{item.interval&.time_string(format: :dhm)})" : ''
+                    else
+                      ''
+                    end
+
           added = tags_added.log_tags
           info('Tagged:',
-               %(added #{tags_added.count == 1 ? 'tag' : 'tags'} #{added} to #{item.title}))
+               %(added #{tags_added.count == 1 ? 'tag' : 'tags'} #{added}#{elapsed} to #{item.title}))
         else
           count(:added_tags, level: :info, tag: tags_added, message: '%tags added to %count %items')
         end

data/lib/doing/note.rb

@@ -5,7 +5,6 @@ module Doing
   ## This class describes an item note.
   ##
   class Note < Array
-
     ##
     ## Initializes a new note
     ##
@@ -28,9 +27,10 @@ module Doing
     ##
     def add(note, replace: false)
       clear if replace
-      if note.is_a?(String)
+      case note
+      when String
         append_string(note)
-      elsif note.is_a?(Array)
+      when Array
         append(note)
       end
     end
@@ -55,7 +55,7 @@ module Doing
     ## @return     [Array] Stripped note
     ##
     def strip_lines
-      map(&:strip)
+      Note.new(map(&:strip))
     end
 
     def strip_lines!
@@ -64,8 +64,24 @@ module Doing
 
     ##
     ## Note as multi-line string
-    def to_s
-      compress.strip_lines.map { |l| "\t\t#{l}" }.join("\n")
+    ##
+    ## @param      prefix  [String] prefix for each line (default two tabs, TaskPaper format)
+    ##
+    def to_s(prefix: "\t\t")
+      compress.strip_lines.map { |l| "#{prefix}#{l}" }.join("\n")
+    end
+
+    ##
+    ## Returns note as a single line, newlines separated by
+    ## space
+    ##
+    ## @return     [String] Line representation of the Note.
+    ##
+    ## @param      separator  The separator with which to
+    ##                        join multiple lines
+    ##
+    def to_line(separator: ' ')
+      compress.strip_lines.join(separator)
     end
 
     # @private
@@ -94,7 +110,7 @@ module Doing
     ## @param      lines  [Array] Array of strings
     ##
     def append(lines)
-      concat(lines)
+      concat(lines.utf8)
       replace compress
     end
 
@@ -105,7 +121,7 @@ module Doing
     ##                    newlines will be split
     ##
     def append_string(input)
-      concat(input.split(/\n/).map(&:strip))
+      concat(input.utf8.split(/\n/).map(&:strip))
       replace compress
     end
   end