doing 2.1.39 → 2.1.42

data/bin/commands/config.rb

@@ -29,7 +29,7 @@ command :config do |c|
   c.long_desc 'Config files are listed in order of precedence (if there are multiple configs detected).
   Values defined in the top item in the list will override values in configutations below it.'
   c.command :list do |list|
-    list.action do |global, options, args|
+    list.action do
       puts Doing.config.additional_configs.join("\n")
       puts Doing.config.config_file
     end
@@ -54,7 +54,8 @@ command :config do |c|
       edit.arg_name 'BUNDLE_ID'
       edit.flag %i[b bundle_id]
 
-      edit.desc "Use the config editor defined in ~/.config/doing/config.yml (#{Doing.setting('editors.config', 'editors.config not set')})"
+      default_editor = Doing.setting('editors.config', 'editors.config not set')
+      edit.desc "Use the config editor defined in ~/.config/doing/config.yml (#{default_editor})"
       edit.switch %i[x default], negatable: false
     end
 
@@ -68,10 +69,11 @@ command :config do |c|
         end
         action = cmd.send(:get_action, nil)
         action.call(global, options, args)
-        Doing.logger.warn('Deprecated:', '--dump and --update are deprecated,
-                             use `doing config get` and `doing config update`')
-        Doing.logger.output_results
-        return
+
+        raise DoingNoTraceError.new('--dump and --update are deprecated,
+                                    use `doing config get` and `doing config update`',
+                                    level: :warn,
+                                    topic: 'Deprecated:')
       end
 
       config_file = Doing.config.choose_config
@@ -79,14 +81,12 @@ command :config do |c|
       if `uname` =~ /Darwin/
         if options[:default]
           editor = Doing::Util.find_default_editor('config')
-          if editor
-            if Doing::Util.exec_available(editor.split(/ /).first)
-              system %(#{editor} "#{config_file}")
-            else
-              `open -a "#{editor}" "#{config_file}"`
-            end
+          raise InvalidArgument, 'No viable editor found in config or environment.' unless editor
+
+          if Doing::Util.exec_available(editor.split(/ /).first)
+            system %(#{editor} "#{config_file}")
           else
-            raise InvalidArgument, 'No viable editor found in config or environment.'
+            `open -a "#{editor}" "#{config_file}"`
           end
         elsif options[:app] || options[:bundle_id]
           if options[:app]
@@ -107,7 +107,10 @@ command :config do |c|
         end
       else
         editor = options[:editor] || Doing::Util.default_editor
-        raise MissingEditor, 'No EDITOR variable defined in environment' unless editor && Doing::Util.exec_available(editor.split(/ /).first)
+        unless editor && Doing::Util.exec_available(editor.split(/ /).first)
+          raise MissingEditor, 'No EDITOR variable defined in environment'
+
+        end
 
         system %(#{editor} "#{config_file}")
       end
@@ -117,8 +120,8 @@ command :config do |c|
   # @@config.update @@config.refresh
   c.desc 'Update default config file, adding any missing keys'
   c.command %i[update refresh] do |update|
-    update.action do |_global, options, args|
-      Doing.config.configure({rewrite: true, ignore_local: true})
+    update.action do
+      Doing.config.configure({ rewrite: true, ignore_local: true })
       Doing.logger.warn('Config:', 'config refreshed')
     end
   end
@@ -126,7 +129,7 @@ command :config do |c|
   # @@config.undo
   c.desc 'Undo the last change to a config file'
   c.command :undo do |undo|
-    undo.action do |_global, options, args|
+    undo.action do
       config_file = Doing.config.choose_config
       Doing::Util::Backup.restore_last_backup(config_file, count: 1)
     end
@@ -137,22 +140,24 @@ command :config do |c|
   c.arg 'KEY_PATH'
   c.command %i[get dump] do |dump|
     dump.example 'doing config get', desc: 'Output the entire configuration'
-    dump.example 'doing config get timer_format --output raw', desc: 'Output the value of timer_format as a plain string'
-    dump.example 'doing config get doing_file', desc: 'Output the value of the doing_file setting, respecting local configurations'
-    dump.example 'doing config get -o json plug.plugpath', desc: 'Key path is fuzzy matched: output the value of plugins.plugin_path as JSON'
+    dump.example 'doing config get timer_format --output raw',
+                 desc: 'Output the value of timer_format as a plain string'
+    dump.example 'doing config get doing_file',
+                 desc: 'Output the value of the doing_file setting, respecting local configurations'
+    dump.example 'doing config get -o json plug.plugpath',
+                 desc: 'Key path is fuzzy matched: output the value of plugins.plugin_path as JSON'
 
     dump.desc 'Format for output (json|yaml|raw)'
     dump.arg_name 'FORMAT'
     dump.flag %i[o output], default_value: 'yaml', must_match: /^(?:y(?:aml)?|j(?:son)?|r(?:aw)?)$/
 
     dump.action do |_global, options, args|
-
       keypath = args.join('.')
       cfg = Doing.config.value_for_key(keypath)
       real_path = Doing.config.resolve_key_path(keypath)
 
       if cfg
-        val = cfg.map {|k, v| v }[0]
+        val = cfg.map { |_, v| v }[0]
         if real_path.count.positive?
           nested_cfg = {}
           nested_cfg.deep_set(real_path, val)
@@ -161,13 +166,15 @@ command :config do |c|
         end
 
         if options[:output] =~ /^r/
-          if val.is_a?(Hash)
-            $stdout.puts YAML.dump(val)
-          elsif val.is_a?(Array)
-            $stdout.puts val.join(', ')
-          else
-            $stdout.puts val.to_s
-          end
+
+          $stdout.puts case val
+                       when Hash
+                         YAML.dump(val)
+                       when Array
+                         val.join(', ')
+                       else
+                         val.to_s
+                       end
         else
           $stdout.puts case options[:output]
                        when /^j/
@@ -188,13 +195,14 @@ command :config do |c|
   c.arg 'KEY VALUE'
   c.command :set do |set|
     set.example 'doing config set timer_format human', desc: 'Set the value of timer_format to "human"'
-    set.example 'doing config set plug.plugpath ~/my_plugins', desc: 'Key path is fuzzy matched: set the value of plugins.plugin_path'
+    set.example 'doing config set plug.plugpath ~/my_plugins',
+                desc: 'Key path is fuzzy matched: set the value of plugins.plugin_path'
 
     set.desc 'Delete specified key'
     set.switch %i[r remove], negatable: false
 
     set.desc 'Force update to .doingrc in the current directory'
-    set.switch %[local], negatable: false
+    set.switch %i[local], negatable: false
 
     set.action do |_global, options, args|
       if args.count < 2 && !options[:remove]
@@ -206,13 +214,14 @@ command :config do |c|
       keypath = args.join('.')
       real_path = Doing.config.resolve_key_path(keypath, create: true)
       old_value = Doing.config.settings.dig(*real_path)
-      old_type = old_value&.class.to_s || nil
+      old_type = old_value.good? ? old_value&.class.to_s : nil
 
       if old_value.is_a?(Hash) && !options[:remove]
-        Doing.logger.log_now(:warn, 'Config:', "Config key must point to a single value, #{real_path.join('.').boldwhite} is a mapping")
+        Doing.logger.log_now(:warn, 'Config:', ['Config key must point to a single value, ',
+                                                "#{real_path.join('.').boldwhite} is a mapping"].join(' '))
         didyou = 'Did you mean:'
-        old_value.keys.each do |k|
-          Doing.logger.log_now(:warn, "#{didyou}", "#{keypath}.#{k}?")
+        old_value.each_key do |k|
+          Doing.logger.log_now(:warn, didyou, "#{keypath}.#{k}?")
           didyou = '..........or:'
         end
         raise InvalidArgument, 'Config value is a mapping, can not be set to a single value'
@@ -226,8 +235,8 @@ command :config do |c|
       $stderr.puts ">      Config: Updating #{config_file}".yellow
 
       if options[:remove]
-        cfg.deep_set(real_path, nil)
         $stderr.puts "#{'Deleting key:'.yellow} #{real_path.join('.').boldwhite}"
+        cfg.deep_set(real_path, nil)
       else
         current_value = cfg.dig(*real_path)
         cfg.deep_set(real_path, value.set_type(old_type))

data/bin/commands/done.rb

@@ -19,24 +19,6 @@ command %i[done did] do |c|
   c.desc 'Immediately archive the entry'
   c.switch %i[a archive], negatable: false, default_value: false
 
-  c.desc %(Set finish date to specific date/time (natural langauge parsed, e.g. --at=1:30pm).
-  Used with --took, backdates start date)
-  c.arg_name 'DATE_STRING'
-  c.flag %i[at finished], type: DateEndString
-
-  c.desc %(
-        Start and end times as a date/time range `doing done --from "1am to 8am"`.
-        Overrides other date flags.
-      )
-  c.arg_name 'TIME_RANGE'
-  c.flag [:from], must_match: REGEX_RANGE
-
-  c.desc %(Set completion date to start date plus interval (XX[mhd] or HH:MM).
-  If used without the --back option, the start date will be moved back to allow
-  the completion date to be the current time.)
-  c.arg_name 'INTERVAL'
-  c.flag %i[t took for], type: DateIntervalString
-
   c.desc 'Section'
   c.arg_name 'NAME'
   c.flag %i[s section]
@@ -45,6 +27,7 @@ command %i[done did] do |c|
   c.switch %i[u unfinished], negatable: false, default_value: false
 
   add_options(:add_entry, c)
+  add_options(:finish_entry, c)
 
   c.action do |global_options, options, args|
     Doing.auto_tag = !options[:noauto]

data/bin/commands/finish.rb

@@ -1,97 +1,126 @@
-# @@finish
-desc 'Mark last X entries as @done'
-long_desc 'Marks the last X entries with a @done tag and current date. Does not alter already completed entries.'
-arg_name 'COUNT', optional: true
-command :finish do |c|
-  c.example 'doing finish', desc: 'Mark the last entry @done'
-  c.example 'doing finish --auto --section Later 10', desc: 'Add @done to any unfinished entries in the last 10 in Later, setting the finish time based on the start time of the task after it'
-  c.example 'doing finish --search "a specific entry" --at "yesterday 3pm"', desc: 'Search for an entry containing string and set its @done time to yesterday at 3pm'
+# frozen_string_literal: true
 
-  c.desc 'Include date'
-  c.switch [:date], negatable: true, default_value: true
+# @@finish
+module Doing
+  # finish command methods
+  class FinishCommand
+    def initialize(wwid)
+      @wwid = wwid
+    end
 
-  c.desc 'Backdate completed date to date string [4pm|20m|2h|yesterday noon]'
-  c.arg_name 'DATE_STRING'
-  c.flag %i[b back started], type: DateBeginString
+    def add_examples(cmd)
+      cmd.example 'doing finish', desc: 'Mark the last entry @done'
+      cmd.example 'doing finish --auto --section Later 10', desc: 'Add @done to any unfinished entries in the last 10 in Later, setting the finish time based on the start time of the task after it'
+      cmd.example 'doing finish --search "a specific entry" --at "yesterday 3pm"', desc: 'Search for an entry containing string and set its @done time to yesterday at 3pm'
+    end
 
-  c.desc 'Set the completed date to the start date plus XX[hmd]'
-  c.arg_name 'INTERVAL'
-  c.flag %i[t took for], type: DateIntervalString
+    def add_options(cmd)
+      cmd.desc 'Include date'
+      cmd.switch [:date], negatable: true, default_value: true
 
-  c.desc %(Set finish date to specific date/time (natural langauge parsed, e.g. --at=1:30pm). If used, ignores --back.)
-  c.arg_name 'DATE_STRING'
-  c.flag %i[at finished], type: DateEndString
+      cmd.desc 'Backdate completed date to date string [4pm|20m|2h|yesterday noon]'
+      cmd.arg_name 'DATE_STRING'
+      cmd.flag %i[b back started], type: DateBeginString
 
-  c.desc 'Overwrite existing @done tag with new date'
-  c.switch %i[update], negatable: false, default_value: false
+      cmd.desc 'Overwrite existing @done tag with new date'
+      cmd.switch %i[update], negatable: false, default_value: false
 
-  c.desc 'Remove @done tag'
-  c.switch %i[r remove], negatable: false, default_value: false
+      cmd.desc 'Remove @done tag'
+      cmd.switch %i[r remove], negatable: false, default_value: false
 
-  c.desc 'Finish last entry (or entries) not already marked @done'
-  c.switch %i[u unfinished], negatable: false, default_value: false
+      cmd.desc 'Finish last entry (or entries) not already marked @done'
+      cmd.switch %i[u unfinished], negatable: false, default_value: false
 
-  c.desc %(Auto-generate finish dates from next entry's start time.
-  Automatically generate completion dates 1 minute before next item (in any section) began.
-  --auto overrides the --date and --back parameters.)
-  c.switch [:auto], negatable: false, default_value: false
+      cmd.desc %(Auto-generate finish dates from next entry's start time.
+      Automatically generate completion dates 1 minute before next item (in any section) began.
+      --auto overrides the --date and --back parameters.)
+      cmd.switch [:auto], negatable: false, default_value: false
 
-  c.desc 'Archive entries'
-  c.switch %i[a archive], negatable: false, default_value: false
+      cmd.desc 'Archive entries'
+      cmd.switch %i[a archive], negatable: false, default_value: false
 
-  c.desc 'Section'
-  c.arg_name 'NAME'
-  c.flag %i[s section]
+      cmd.desc 'Section'
+      cmd.arg_name 'NAME'
+      cmd.flag %i[s section]
 
-  c.desc 'Select item(s) to finish from a menu of matching entries'
-  c.switch %i[i interactive], negatable: false, default_value: false
+      cmd.desc 'Select item(s) to finish from a menu of matching entries'
+      cmd.switch %i[i interactive], negatable: false, default_value: false
+    end
 
-  add_options(:search, c)
-  add_options(:tag_filter, c)
+    def handle_from(options)
+      options[:from] = options[:from].split(/#{REGEX_RANGE_INDICATOR}/).map do |time|
+        time =~ REGEX_TIME ? "today #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}" : time
+      end.join(' to ').split_date_range
+      start_date, finish_date = options[:from]
+      finish_date ||= Time.now
+      [start_date, finish_date]
+    end
 
-  c.action do |_global_options, options, args|
-    options[:fuzzy] = false
-    unless options[:auto]
+    def handle_date_options(options)
       if options[:took]
         took = options[:took]
         raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
-      end
 
-      raise InvalidArgument, '--back and --took can not be used together' if options[:back] && options[:took]
-
-      raise InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
+      end
 
       if options[:at]
         finish_date = options[:at]
         finish_date = finish_date.chronify(guess: :begin) if finish_date.is_a? String
         raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
-        date = options[:took] ? finish_date - took : finish_date
+        start_date = options[:took] ? finish_date - took : nil
       elsif options[:back]
-        date = options[:back]
+        start_date = options[:back]
+        finish_date = options[:took] ? start_date + took : Time.now
+
+        raise InvalidTimeExpression, 'Unable to parse date string' if start_date.nil?
 
-        raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
       else
-        date = Time.now
+        start_date = options[:took] ? Time.now - took : nil
+        finish_date = Time.now
       end
+
+      [start_date, finish_date]
     end
+  end
+end
+
+desc 'Mark last X entries as @done'
+long_desc 'Marks the last X entries with a @done tag and current date. Does not alter already completed entries.'
+arg_name 'COUNT', optional: true
+command :finish do |c|
+  cmd = Doing::FinishCommand.new(@wwid)
+  cmd.add_examples(c)
+  cmd.add_options(c)
+  add_options(:search, c)
+  add_options(:tag_filter, c)
+  add_options(:finish_entry, c)
 
-    if options[:tag].nil?
-      tags = []
-    else
-      tags = options[:tag]
+  c.action do |_global_options, options, args|
+    options[:fuzzy] = false
+    unless options[:auto]
+      if options[:from]
+        start_date, finish_date = cmd.handle_from(options)
+      else
+        start_date, finish_date = cmd.handle_date_options(options)
+      end
     end
 
+    tags = options[:tag] || []
+
     raise InvalidArgument, 'Only one argument allowed' if args.length > 1
 
-    raise InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)' unless args.length == 0 || args[0] =~ /\d+/
+    unless args.empty? || args[0] =~ /\d+/
+      raise InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)'
 
-    if options[:interactive]
-      count = 0
-    else
-      count = args[0] ? args[0].to_i : 1
     end
 
+    count = if options[:interactive]
+              0
+            else
+              args[0] ? args[0].to_i : 1
+            end
+
     search = nil
 
     if options[:search]
@@ -101,10 +130,11 @@ command :finish do |c|
 
     opts = {
       archive: options[:archive],
-      back: date,
+      back: start_date,
       case: options[:case].normalize_case,
       count: count,
       date: options[:date],
+      done_date: finish_date,
       fuzzy: options[:fuzzy],
       interactive: options[:interactive],
       not: options[:not],
@@ -112,6 +142,7 @@ command :finish do |c|
       search: search,
       section: options[:section],
       sequential: options[:auto],
+      start_date: start_date,
       tag: tags,
       tag_bool: options[:bool].normalize_bool,
       tags: ['done'],

data/bin/commands/flag.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 # @@mark @@flag
 desc 'Mark last entry as flagged'
 command %i[mark flag] do |c|
   c.example 'doing flag', desc: 'Add @flagged to the last entry created'
   c.example 'doing mark', desc: 'mark is an alias for flag'
   c.example 'doing flag --tag project1 --count 2', desc: 'Add @flagged to the last 2 entries tagged @project1'
-  c.example 'doing flag --interactive --search "/(develop|cod)ing/"', desc: 'Find entries matching regular expression and create a menu allowing multiple selections, selected items will be @flagged'
+  c.example 'doing flag --interactive --search "/(develop|cod)ing/"',
+            desc: 'Find entries matching regular expression and create a menu allowing multiple selections,
+                   selected items will be @flagged'
 
   c.desc 'Section'
   c.arg_name 'SECTION_NAME'

data/bin/commands/grep.rb

@@ -16,25 +16,12 @@ command %i[grep search] do |c|
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
-  c.arg_name 'FORMAT'
-  c.flag %i[o output]
-
-  c.desc "Output using a template from configuration"
-  c.arg_name 'TEMPLATE_KEY'
-  c.flag [:config_template], type: TemplateName, default_value: 'default'
-
-  c.desc 'Override output format with a template string containing %placeholders'
-  c.arg_name 'TEMPLATE_STRING'
-  c.flag [:template]
-
   # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
   # c.switch [:fuzzy], default_value: false, negatable: false
 
   c.desc 'Force exact string matching (case sensitive)'
   c.switch %i[x exact], default_value: Doing.config.exact_match?, negatable: Doing.config.exact_match?
 
-
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
   c.flag [:case], must_match: REGEX_CASE,
@@ -53,13 +40,15 @@ command %i[grep search] do |c|
   c.desc 'Display an interactive menu of results to perform further operations'
   c.switch %i[i interactive], default_value: false, negatable: false
 
+  add_options(:output_template, c)
   add_options(:tag_filter, c)
   add_options(:date_filter, c)
   add_options(:time_display, c)
 
   c.action do |_global_options, options, args|
     options[:fuzzy] = false
-    raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise InvalidPlugin.new('output', options[:output]) if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
 
     template = Doing.setting(['templates', options[:config_template]]).deep_merge(Doing.settings)
     tags_color = template.key?('tags_color') ? template['tags_color'] : nil

data/bin/commands/last.rb

@@ -21,20 +21,13 @@ command :last do |c|
   c.desc "Delete the last entry"
   c.switch %i[d delete], negatable: false, default_value: false
 
-  c.desc "Output using a template from configuration"
-  c.arg_name 'TEMPLATE_KEY'
-  c.flag [:config_template], type: TemplateName, default_value: 'last'
-
-  c.desc 'Override output format with a template string containing %placeholders'
-  c.arg_name 'TEMPLATE_STRING'
-  c.flag [:template]
-
   c.desc "Highlight search matches in output. Only affects command line output"
   c.switch %i[h hilite], default_value: Doing.settings.dig('search', 'highlight')
 
   c.desc 'Show elapsed time if entry is not tagged @done'
   c.switch [:duration]
 
+  add_options(:output_template, c, default_template: 'last')
   add_options(:search, c)
   add_options(:tag_filter, c)
 
@@ -69,6 +62,7 @@ command :last do |c|
                         case: options[:case],
                         hilite: options[:hilite],
                         negate: options[:not],
+                        output: options[:output],
                         tag: options[:tag],
                         tag_bool: options[:bool],
                         delete: options[:delete],

data/bin/commands/meanwhile.rb

@@ -19,6 +19,8 @@ command :meanwhile do |c|
   c.switch %i[a archive], negatable: false, default_value: false
 
   add_options(:add_entry, c)
+  # TODO: Add took and from handling for post-dating meanwhile entries
+  # add_options(:add_dated, c)
 
   c.action do |global_options, options, args|
     Doing.auto_tag = !options[:noauto]
@@ -31,17 +33,18 @@ command :meanwhile do |c|
       date = Time.now
     end
 
-    if options[:section]
-      section = @wwid.guess_section(options[:section]) || options[:section].cap_first
-    else
-      section = Doing.setting('current_section')
-    end
+    section = if options[:section]
+                @wwid.guess_section(options[:section]) || options[:section].cap_first
+              else
+                Doing.setting('current_section')
+              end
     input = ''
 
     ask_note = options[:ask] ? Doing::Prompt.read_lines(prompt: 'Add a note') : []
 
     if options[:editor]
       raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+
       input += date.strftime('%F %R | ')
       input += args.join(' ') unless args.empty?
       input += "\n#{options[:note]}" if options[:note]
@@ -70,7 +73,11 @@ command :meanwhile do |c|
       note.add(ask_note) if ask_note.good?
     end
 
-    @wwid.stop_start('meanwhile', { new_item: input, back: date, section: section, archive: options[:archive], note: note })
+    @wwid.stop_start('meanwhile', { new_item: input,
+                                    back: date,
+                                    section: section,
+                                    archive: options[:archive],
+                                    note: note })
     @wwid.write(@wwid.doing_file)
   end
 end