doing 2.1.22 → 2.1.26

data/bin/commands/config.rb

@@ -0,0 +1,245 @@
+# @@config
+desc 'Edit the configuration file or output a value from it'
+long_desc %(Run without arguments, `doing config` opens your `config.yml` in an editor.
+If local configurations are found in the path between the current directory
+and the root (/), a menu will allow you to select which to open in the editor.
+
+It will use the editor defined in `config_editor_app`, or one specified with `--editor`.
+
+Use `doing config get` to output the configuration to the terminal, and
+provide a dot-separated key path to get a specific value. Shows the current value
+including keys/overrides set by local configs.)
+command :config do |c|
+  c.example 'doing config', desc: "Open an active configuration in #{Doing::Util.find_default_editor('config')}"
+  c.example 'doing config get doing_file', desc: 'Output the value of a config key as YAML'
+  c.example 'doing config get plugins.plugin_path -o json', desc: 'Output the value of a key path as JSON'
+  c.example 'doing config set plugins.say.say_voice Alex', desc: 'Set the value of a key path and update config file'
+  c.example 'doing config set plug.say.voice Zarvox', desc: 'Key paths for get and set are fuzzy matched'
+
+  c.default_command :edit
+
+  c.desc 'DEPRECATED'
+  c.switch %i[d dump]
+
+  c.desc 'DEPRECATED'
+  c.switch %i[u update]
+
+  # @@config.list
+  c.desc 'List configuration paths, including .doingrc files in the current and parent directories'
+  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|
+      puts @config.additional_configs.join("\n")
+      puts @config.config_file
+    end
+  end
+
+  # @@config.edit
+  c.desc 'Open config file in editor'
+  c.command :edit do |edit|
+    edit.example 'doing config edit', desc: 'Open a config file in the default editor'
+    edit.example 'doing config edit --editor vim', desc: 'Open config in specific editor'
+
+    edit.desc 'Editor to use'
+    edit.arg_name 'EDITOR'
+    edit.flag %i[e editor], default_value: nil
+
+    if `uname` =~ /Darwin/
+      edit.desc 'Application to use'
+      edit.arg_name 'APP_NAME'
+      edit.flag %i[a app]
+
+      edit.desc 'Application bundle id to use'
+      edit.arg_name 'BUNDLE_ID'
+      edit.flag %i[b bundle_id]
+
+      edit.desc "Use the config_editor_app defined in ~/.config/doing/config.yml (#{@settings.key?('config_editor_app') ? @settings['config_editor_app'] : 'config_editor_app not set'})"
+      edit.switch %i[x default]
+    end
+
+    edit.action do |global, options, args|
+      if options[:update] || options[:dump]
+        cmd = commands[:config]
+        if options[:update]
+          cmd = cmd.commands[:update]
+        elsif options[:dump]
+          cmd = cmd.commands[:get]
+        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
+      end
+
+      config_file = @config.choose_config
+
+      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
+          else
+            raise InvalidArgument, 'No viable editor found in config or environment.'
+          end
+        elsif options[:app] || options[:bundle_id]
+          if options[:app]
+            `open -a "#{options[:app]}" "#{config_file}"`
+          elsif options[:bundle_id]
+            `open -b #{options[:bundle_id]} "#{config_file}"`
+          end
+        else
+          editor = options[:editor] || Doing::Util.find_default_editor('config')
+
+          raise MissingEditor, 'No viable editor defined in config or environment' unless editor
+
+          if Doing::Util.exec_available(editor.split(/ /).first)
+            system %(#{editor} "#{config_file}")
+          else
+            `open -a "#{editor}" "#{config_file}"`
+          end
+        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)
+
+        system %(#{editor} "#{config_file}")
+      end
+    end
+  end
+
+  # @@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|
+      @config.configure({rewrite: true, ignore_local: true})
+      Doing.logger.warn('Config:', 'config refreshed')
+    end
+  end
+
+  # @@config.undo
+  c.desc 'Undo the last change to a config file'
+  c.command :undo do |undo|
+    undo.action do |_global, options, args|
+      config_file = @config.choose_config
+      Doing::Util::Backup.restore_last_backup(config_file, count: 1)
+    end
+  end
+
+  # @@config.get @@config.dump
+  c.desc 'Output a key\'s value'
+  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.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 = @config.value_for_key(keypath)
+      real_path = @config.resolve_key_path(keypath)
+
+      if cfg
+        val = cfg.map {|k, v| v }[0]
+        if real_path.count.positive?
+          nested_cfg = {}
+          nested_cfg.deep_set(real_path, val)
+        else
+          nested_cfg = val
+        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
+        else
+          $stdout.puts case options[:output]
+                       when /^j/
+                         JSON.pretty_generate(val)
+                       else
+                         YAML.dump(nested_cfg)
+                       end
+        end
+      else
+        Doing.logger.log_now(:error, 'Config:', "Key #{keypath} not found")
+      end
+      Doing.logger.output_results
+    end
+  end
+
+  # @@config.set
+  c.desc 'Set a key\'s value in the config file'
+  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.desc 'Delete specified key'
+    set.switch %i[r remove], default_value: false, negatable: false
+
+    set.action do |_global, options, args|
+      if args.count < 2 && !options[:remove]
+        raise InvalidArgument, 'config set requires at least two arguments, key path and value'
+
+      end
+
+      value = options[:remove] ? nil : args.pop
+      keypath = args.join('.')
+      real_path = @config.resolve_key_path(keypath, create: true)
+      old_value = @settings.dig(*real_path)
+      old_type = 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")
+        didyou = 'Did you mean:'
+        old_value.keys.each 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'
+
+      end
+
+      config_file = @config.choose_config(create: true)
+
+      cfg = YAML.safe_load_file(config_file) || {}
+
+      $stderr.puts "Updating #{config_file}".yellow
+
+      if options[:remove]
+        cfg.deep_set(real_path, nil)
+        $stderr.puts "#{'Deleting key:'.yellow} #{real_path.join('->').boldwhite}"
+      else
+        current_value = cfg.dig(*real_path)
+        cfg.deep_set(real_path, value.set_type(old_type))
+        $stderr.puts "#{' Key path:'.yellow} #{real_path.join('->').boldwhite}"
+        $stderr.puts "#{'Inherited:'.yellow} #{(old_value ? old_value.to_s : 'empty').boldwhite}"
+        $stderr.puts "#{'  Current:'.yellow} #{ (current_value ? current_value.to_s : 'empty').boldwhite }"
+        $stderr.puts "#{'      New:'.yellow} #{value.set_type(old_type).to_s.boldwhite}"
+      end
+
+      res = Doing::Prompt.yn('Update selected config', default_response: true)
+
+      raise UserCancelled, 'Cancelled' unless res
+
+      Doing::Util.write_to_file(config_file, YAML.dump(cfg), backup: true)
+      Doing.logger.warn('Config:', "#{config_file} updated")
+    end
+  end
+end

data/bin/commands/done.rb

@@ -0,0 +1,249 @@
+# @@done @@did
+desc 'Add a completed item with @done(date). No argument finishes last entry'
+long_desc 'Use this command to add an entry after you\'ve already finished it. It will be immediately marked as @done.
+You can modify the start and end times of the entry using the --back, --took, and --at flags, making it an easy
+way to add entries in post and maintain accurate (albeit manual) time tracking.'
+arg_name 'ENTRY', optional: true
+command %i[done did] do |c|
+  c.example 'doing done', desc: 'Tag the last entry @done'
+  c.example 'doing done I already finished this', desc: 'Add a new entry and immediately mark it @done'
+  c.example 'doing done --back 30m This took me half an hour', desc: 'Add an entry with a start date 30 minutes ago and a @done date of right now'
+  c.example 'doing done --at 3pm --took 1h Started and finished this afternoon', desc: 'Add an entry with a @done date of 3pm and a start date of 2pm (3pm - 1h)'
+
+  c.desc 'Remove @done tag'
+  c.switch %i[r remove], negatable: false, default_value: false
+
+  c.desc 'Include date'
+  c.switch [:date], negatable: true, default_value: true
+
+  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 'Backdate start date by interval or set to time [4pm|20m|2h|"yesterday noon"]'
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back started], type: DateBeginString
+
+  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]
+
+  c.desc "Edit entry with #{Doing::Util.default_editor} (with no arguments, edits the last entry)"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc 'Include a note'
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
+
+  c.desc 'Prompt for note via multi-line input'
+  c.switch %i[ask], negatable: false, default_value: false
+
+  c.desc 'Finish last entry not already marked @done'
+  c.switch %i[u unfinished], negatable: false, default_value: false
+
+  # c.desc "Edit entry with specified app"
+  # c.arg_name 'editor_app'
+  # # c.flag [:a, :app]
+
+  c.action do |_global_options, options, args|
+    took = 0
+    donedate = nil
+
+    if options[:from]
+      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
+      date, finish_date = options[:from]
+      finish_date ||= Time.now
+    else
+      if options[:took]
+        took = options[:took]
+        raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
+      end
+
+      if options[:back]
+        date = options[:back]
+        raise InvalidTimeExpression, 'Unable to parse date string for --back' if date.nil?
+      else
+        date = options[:took] ? Time.now - took : Time.now
+      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?
+
+        if options[:took]
+          date = finish_date - took
+        else
+          date ||= finish_date
+        end
+      elsif options[:took]
+        finish_date = date + took
+      else
+        finish_date = Time.now
+      end
+    end
+
+    if options[:date]
+      date = date.chronify(guess: :begin, context: :today) if date =~ REGEX_TIME
+      finish_date = @wwid.verify_duration(date, finish_date) unless options[:took] || options[:from]
+
+      donedate = finish_date.strftime('%F %R')
+    end
+
+    if options[:section]
+      section = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    else
+      section = @settings['current_section']
+    end
+
+
+    note = Doing::Note.new
+    note.add(options[:note]) if options[:note]
+
+    if options[:ask] && !options[:editor]
+      note.add(Doing::Prompt.read_lines(prompt: 'Add a note'))
+    end
+
+    if options[:editor]
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+      is_new = false
+
+      if args.empty?
+        last_entry = @wwid.filter_items([], opt: { unfinished: options[:unfinished], section: section, count: 1, age: :newest }).max_by { |item| item.date }
+
+        unless last_entry
+          Doing.logger.debug('Skipped:', options[:unfinished] ? 'No unfinished entry' : 'Last entry already @done')
+          raise NoResults, 'No results'
+        end
+
+        old_entry = last_entry.clone
+        last_entry.note.add(note)
+        input = ["#{last_entry.date.strftime('%F %R | ')}#{last_entry.title}", last_entry.note.strip_lines.join("\n")].join("\n")
+      else
+        is_new = true
+        input = ["#{date.strftime('%F %R | ')}#{args.join(' ')}", note.strip_lines.join("\n")].join("\n")
+      end
+
+      input = @wwid.fork_editor(input).strip
+      raise EmptyInput, 'No content' unless input.good?
+
+      d, title, note = @wwid.format_input(input)
+
+      if options[:ask]
+        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
+        note.add(ask_note) if ask_note.good?
+      end
+
+      date = d.nil? ? date : d
+      new_entry = Doing::Item.new(date, title, section, note)
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+
+      if (is_new)
+        Doing::Hooks.trigger :pre_entry_add, @wwid, new_entry
+        @wwid.content.push(new_entry)
+        Doing::Hooks.trigger :post_entry_added, @wwid, new_entry
+      else
+        old = old_entry.clone
+        @wwid.content.update_item(old_entry, new_entry)
+        Doing::Hooks.trigger :post_entry_updated, @wwid, new_entry, old unless options[:archive]
+      end
+
+      if options[:archive]
+        @wwid.move_item(new_entry, 'Archive', label: true)
+        Doing::Hooks.trigger :post_entry_updated, @wwid, new_entry, old_entry
+      end
+
+      @wwid.write(@wwid.doing_file)
+    elsif args.empty? && $stdin.stat.size.zero?
+      if options[:remove]
+        @wwid.tag_last({ tags: ['done'], count: 1, section: section, remove: true })
+      else
+        opt = {
+          archive: options[:archive],
+          back: finish_date,
+          count: 1,
+          date: options[:date],
+          note: note,
+          section: section,
+          tags: ['done'],
+          took: took == 0 ? nil : took,
+          unfinished: options[:unfinished]
+        }
+        @wwid.tag_last(opt)
+      end
+    elsif !args.empty?
+      d, title, new_note = @wwid.format_input([args.join(' '), note.strip_lines.join("\n")].join("\n"))
+      date = d.nil? ? date : d
+      new_note.add(options[:note])
+      title.chomp!
+      section = 'Archive' if options[:archive]
+      new_entry = Doing::Item.new(date, title, section, new_note)
+
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+
+      Doing::Hooks.trigger :pre_entry_add, @wwid, new_entry
+      @wwid.content.push(new_entry)
+      Doing::Hooks.trigger :post_entry_added, @wwid, new_entry
+      @wwid.write(@wwid.doing_file)
+      Doing.logger.info('New entry:', %(added "#{new_entry.date.relative_date}: #{new_entry.title}" to #{section}))
+    elsif $stdin.stat.size.positive?
+      note = Doing::Note.new(options[:note])
+      d, title, note = @wwid.format_input($stdin.read.strip)
+      unless d.nil?
+        Doing.logger.debug('Parser:', 'Date detected in input, overriding command line values')
+        date = d
+      end
+      note.add(options[:note]) if options[:note]
+      section = options[:archive] ? 'Archive' : section
+      new_entry = Doing::Item.new(date, title, section, note)
+
+      if new_entry.should_finish?
+        if new_entry.should_time?
+          new_entry.tag('done', value: donedate)
+        else
+          new_entry.tag('done')
+        end
+      end
+
+      Doing::Hooks.trigger :pre_entry_add, @wwid, new_entry
+      @wwid.content.push(new_entry)
+      Doing::Hooks.trigger :post_entry_added, @wwid, new_entry
+
+      @wwid.write(@wwid.doing_file)
+      Doing.logger.info('New entry:', %(added "#{new_entry.date.relative_date}: #{new_entry.title}" to #{section}))
+    else
+      raise EmptyInput, 'You must provide content when creating a new entry'
+    end
+  end
+end

data/bin/commands/finish.rb

@@ -0,0 +1,149 @@
+# @@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'
+
+  c.desc 'Include date'
+  c.switch [:date], negatable: true, default_value: true
+
+  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
+
+  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
+
+  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
+
+  c.desc 'Finish the last X entries containing TAG.
+  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool. Wildcards allowed (*, ?).'
+  c.arg_name 'TAG'
+  c.flag [:tag], type: TagArray
+
+  c.desc 'Finish the last X entries matching search filter, surround with slashes for regex (e.g. "/query.*/"), start with single quote for exact match ("\'query")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  c.desc 'Perform a tag value query ("@done > two hours ago" or "@progress < 50"). May be used multiple times, combined with --bool'
+  c.arg_name 'QUERY'
+  c.flag [:val], multiple: true, must_match: REGEX_VALUE_QUERY
+
+  # c.desc '[DEPRECATED] Use alternative fuzzy matching for search string'
+  # c.switch [:fuzzy], default_value: false, negatable: false
+
+  c.desc 'Force exact search string matching (case sensitive)'
+  c.switch %i[x exact], default_value: @config.exact_match?, negatable: @config.exact_match?
+
+  c.desc 'Finish items that *don\'t* match search/tag filters'
+  c.switch [:not], default_value: false, negatable: false
+
+  c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
+  c.arg_name 'TYPE'
+  c.flag [:case], must_match: /^[csi]/, default_value: @settings.dig('search', 'case')
+
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters. Use PATTERN to parse + and - as booleans'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: REGEX_BOOL, default_value: 'PATTERN'
+
+  c.desc 'Remove done tag'
+  c.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
+
+  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
+
+  c.desc 'Archive entries'
+  c.switch %i[a archive], negatable: false, default_value: false
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.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
+
+  c.action do |_global_options, options, args|
+    options[:fuzzy] = false
+    unless options[:auto]
+      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]
+
+      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
+      elsif options[:back]
+        date = options[:back]
+
+        raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
+      else
+        date = Time.now
+      end
+    end
+
+    if options[:tag].nil?
+      tags = []
+    else
+      tags = options[:tag]
+    end
+
+    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+/
+
+    if options[:interactive]
+      count = 0
+    else
+      count = args[0] ? args[0].to_i : 1
+    end
+
+    search = nil
+
+    if options[:search]
+      search = options[:search]
+      search.sub!(/^'?/, "'") if options[:exact]
+    end
+
+    opts = {
+      archive: options[:archive],
+      back: date,
+      case: options[:case].normalize_case,
+      count: count,
+      date: options[:date],
+      fuzzy: options[:fuzzy],
+      interactive: options[:interactive],
+      not: options[:not],
+      remove: options[:remove],
+      search: search,
+      section: options[:section],
+      sequential: options[:auto],
+      tag: tags,
+      tag_bool: options[:bool].normalize_bool,
+      tags: ['done'],
+      took: options[:took],
+      unfinished: options[:unfinished],
+      val: options[:val]
+    }
+
+    @wwid.tag_last(opts)
+  end
+end