doing 2.1.24 → 2.1.28

data/bin/commands/grep.rb

@@ -0,0 +1,108 @@
+# @@grep @@search
+desc 'Search for entries'
+long_desc %(
+Search all sections (or limit to a single section) for entries matching text or regular expression. Normal strings are fuzzy matched.
+
+To search with regular expressions, single quote the string and surround with slashes: `doing search '/\bm.*?x\b/'`
+)
+arg_name 'SEARCH_PATTERN'
+command %i[grep search] do |c|
+  c.example 'doing grep "doing wiki"', desc: 'Find entries containing "doing wiki" using fuzzy matching'
+  c.example 'doing search "\'search command"', desc: 'Find entries containing "search command" using exact matching (search is an alias for grep)'
+  c.example 'doing grep "/do.*?wiki.*?@done/"', desc: 'Find entries matching regular expression'
+  c.example 'doing search --before 12/21 "doing wiki"', desc: 'Find entries containing "doing wiki" with entry dates before 12/21 of the current year'
+
+  c.desc 'Section'
+  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 'Show time intervals on @done tasks'
+  c.switch %i[t times], default_value: true, negatable: true
+
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
+  c.desc 'Show intervals with totals at the end of output'
+  c.switch [:totals], default_value: false, negatable: false
+
+  c.desc 'Sort tags by (name|time)'
+  default = @settings['tag_sort'].normalize_tag_sort || :name
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: REGEX_TAG_SORT, default_value: default, type: TagSortSymbol
+
+  c.desc 'Only show items with recorded time intervals'
+  c.switch [:only_timed], default_value: false, negatable: false
+
+  # 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: @config.exact_match?, negatable: @config.exact_match?
+
+  c.desc 'Show items that *don\'t* match search string'
+  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: REGEX_CASE,
+                  default_value: @settings.dig('search', 'case').normalize_case,
+                  type: CaseSymbol
+
+  c.desc "Highlight search matches in output. Only affects command line output"
+  c.switch %i[h hilite], default_value: @settings.dig('search', 'highlight')
+
+  c.desc "Edit matching entries with #{Doing::Util.default_editor}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc "Delete matching entries"
+  c.switch %i[d delete], negatable: false, default_value: false
+
+  c.desc 'Display an interactive menu of results to perform further operations'
+  c.switch %i[i interactive], default_value: false, negatable: false
+
+  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 'Combine multiple tags or value queries using AND, OR, or NOT'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: REGEX_BOOL,
+                  default_value: :pattern,
+                  type: BooleanSymbol
+
+  add_options(:date_filter, 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)
+
+    template = @settings['templates'][options[:config_template]].deep_merge(@settings)
+    tags_color = template.key?('tags_color') ? template['tags_color'] : nil
+
+    section = @wwid.guess_section(options[:section]) if options[:section]
+
+    search = args.join(' ')
+    search.sub!(/^'?/, "'") if options[:exact]
+
+    options[:times] = true if options[:totals]
+    options[:sort_tags] = options[:tag_sort]
+    options[:highlight] = true
+    options[:search] = search
+    options[:section] = section
+    options[:tags_color] = tags_color
+
+    Doing::Pager.page @wwid.list_section(options)
+  end
+end

data/bin/commands/import.rb

@@ -0,0 +1,71 @@
+# @@import
+desc 'Import entries from an external source'
+long_desc "Imports entries from other sources. Available plugins: #{Doing::Plugins.plugin_names(type: :import, separator: ', ')}"
+arg_name 'PATH'
+command :import do |c|
+  c.example 'doing import --type timing "~/Desktop/All Activities.json"', desc: 'Import a Timing.app JSON report'
+  c.example 'doing import --type doing --tag imported --no-autotag ~/doing_backup.md', desc: 'Import an Doing archive, tag all entries with @imported, skip autotagging'
+  c.example 'doing import --type doing --from "10/1 to 10/15" ~/doing_backup.md', desc: 'Import a Doing archive, only importing entries between two dates'
+
+  c.desc "Import type (#{Doing::Plugins.plugin_names(type: :import)})"
+  c.arg_name 'TYPE'
+  c.flag :type, default_value: 'doing'
+
+  c.desc 'Import items that *don\'t* match search/tag/date filters'
+  c.switch [:not], default_value: false, negatable: false
+
+  c.desc 'Only import items with recorded time intervals'
+  c.switch [:only_timed], default_value: false, negatable: false
+
+  c.desc 'Target section'
+  c.arg_name 'NAME'
+  c.flag %i[s section]
+
+  c.desc 'Tag all imported entries'
+  c.arg_name 'TAGS'
+  c.flag %i[t tag]
+
+  c.desc 'Autotag entries'
+  c.switch :autotag, negatable: true, default_value: true
+
+  c.desc 'Prefix entries with'
+  c.arg_name 'PREFIX'
+  c.flag :prefix
+
+  c.desc 'Allow entries that overlap existing times'
+  c.switch [:overlap], negatable: true
+
+  add_options(:search, c)
+  add_options(:date_filter, c)
+
+  c.action do |_global_options, options, args|
+    options[:fuzzy] = false
+    if options[:section]
+      options[:section] = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    end
+
+    if options[:search]
+      search = options[:search]
+      search.sub!(/^'?/, "'") if options[:exact]
+      options[:search] = search
+    end
+
+    if options[:from]
+      options[:date_filter] = options[:from]
+
+      raise InvalidTimeExpression, 'Unrecognized date string' unless options[:date_filter][0]
+    elsif options[:before] || options[:after]
+      options[:date_filter] = [nil, nil]
+      options[:date_filter][1] = options[:before] || Time.now + (1 << 64)
+      options[:date_filter][0] = options[:after] || Time.now - (1 << 64)
+    end
+
+    if options[:type] =~ Doing::Plugins.plugin_regex(type: :import)
+      options[:no_overlap] = !options[:overlap]
+      @wwid.import(args, options)
+      @wwid.write(@wwid.doing_file)
+    else
+      raise InvalidPluginType, "Invalid import type: #{options[:type]}"
+    end
+  end
+end

data/bin/commands/install_fzf.rb

@@ -0,0 +1,17 @@
+# @@install_fzf
+command :install_fzf do |c|
+  c.desc 'Force reinstall'
+  c.switch %i[r reinstall], default_value: false
+
+  c.desc 'Uninstall'
+  c.switch %i[u uninstall], default_value: false, negatable: false
+
+  c.action do |g, o, a|
+    if o[:uninstall]
+      Doing::Prompt.uninstall_fzf
+    else
+      Doing.logger.warn('fzf:', 'force reinstall') if o[:reinstall]
+      res = Doing::Prompt.install_fzf(force: o[:reinstall])
+    end
+  end
+end

data/bin/commands/last.rb

@@ -0,0 +1,81 @@
+# @@last
+desc 'Show the last entry, optionally edit'
+long_desc 'Shows the last entry. Using --search and --tag filters, you can view/edit the last entry matching a filter,
+allowing `doing last` to target historical entries.'
+command :last do |c|
+  c.example 'doing last', desc: 'Show the most recent entry in all sections'
+  c.example 'doing last -s Later', desc: 'Show the most recent entry in the Later section'
+  c.example 'doing last --tag project1,work --bool AND', desc: 'Show most recent entry tagged @project1 and @work'
+  c.example 'doing last --search "side hustle"', desc: 'Show most recent entry containing "side hustle" (fuzzy matching)'
+  c.example 'doing last --search "\'side hustle"', desc: 'Show most recent entry containing "side hustle" (exact match)'
+  c.example 'doing last --edit', desc: 'Open the most recent entry in an editor for modifications'
+  c.example 'doing last --search "\'side hustle" --edit', desc: 'Open most recent entry containing "side hustle" (exact match) in editor'
+
+  c.desc 'Specify a section'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  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: @settings.dig('search', 'highlight')
+
+  c.desc 'Show elapsed time if entry is not tagged @done'
+  c.switch [:duration]
+
+  add_options(:search, c)
+  add_options(:tag_filter, c)
+
+  c.action do |global_options, options, _args|
+    options[:fuzzy] = false
+    raise InvalidArgument, '--tag and --search can not be used together' if options[:tag] && options[:search]
+
+    options[:tag] ||= []
+
+    options[:search] = options[:search].sub(/^'?/, "'") if options[:search] && options[:exact]
+
+    if options[:editor]
+      @wwid.edit_last(section: options[:section],
+                     options: {
+                       search: options[:search],
+                       fuzzy: options[:fuzzy],
+                       case: options[:case],
+                       tag: options[:tag],
+                       tag_bool: options[:bool],
+                       not: options[:not],
+                       val: options[:val],
+                       bool: options[:bool]
+                     })
+    else
+      last = @wwid.last(times: true, section: options[:section],
+                     options: {
+                        config_template: options[:config_template],
+                        template: options[:template],
+                        duration: options[:duration],
+                        search: options[:search],
+                        fuzzy: options[:fuzzy],
+                        case: options[:case],
+                        hilite: options[:hilite],
+                        negate: options[:not],
+                        tag: options[:tag],
+                        tag_bool: options[:bool],
+                        delete: options[:delete],
+                        bool: options[:bool],
+                        val: options[:val]
+                      })
+      Doing::Pager::page last.strip if last
+    end
+  end
+end

data/bin/commands/meanwhile.rb

@@ -0,0 +1,76 @@
+# @@meanwhile
+desc 'Finish any running @meanwhile tasks and optionally create a new one'
+long_desc 'The @meanwhile tag allows you to have long-running entries that encompass smaller entries.
+This command makes it easy to start and stop these overarching entries. Just run `doing meanwhile Starting work on this
+big project` to start a @meanwhile entry, add other entries as you work on the project, then use `doing meanwhile` by
+itself to mark the entry as @done.'
+arg_name 'ENTRY', optional: true
+command :meanwhile do |c|
+  c.example 'doing meanwhile "Long task that will have others after it before it\'s done"', desc: 'Add a new long-running entry, completing any current @meanwhile entry'
+  c.example 'doing meanwhile', desc: 'Finish any open @meanwhile entry'
+  c.example 'doing meanwhile --archive', desc: 'Finish any open @meanwhile entry and archive it'
+  c.example 'doing meanwhile --back 2h "Something I\'ve been working on for a while', desc: 'Add a @meanwhile entry with a start date 2 hours ago'
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.flag %i[s section]
+
+  c.desc 'Archive previous @meanwhile entry'
+  c.switch %i[a archive], negatable: false, default_value: false
+
+  add_options(:add_entry, c)
+
+  c.action do |_global_options, options, args|
+    @wwid.auto_tag = !options[:noauto]
+
+    if options[:back]
+      date = options[:back]
+
+      raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
+    else
+      date = Time.now
+    end
+
+    if options[:section]
+      section = @wwid.guess_section(options[:section]) || options[:section].cap_first
+    else
+      section = @settings['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]
+      input += "\n#{ask_note}" unless ask_note.good?
+
+      input = @wwid.fork_editor(input).strip
+    elsif !args.empty?
+      input = args.join(' ')
+    elsif $stdin.stat.size.positive?
+      input = $stdin.read.strip
+    end
+
+    if input.good?
+      d, input, note = @wwid.format_input(input)
+      unless d.nil?
+        Doing.logger.debug('Parser:', 'Date detected in input, overriding command line values')
+        date = d
+      end
+    else
+      input = nil
+      note = []
+    end
+
+    unless options[:editor]
+      note.add(options[:note]) if options[:note]
+      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.write(@wwid.doing_file)
+  end
+end

data/bin/commands/note.rb

@@ -0,0 +1,91 @@
+# @@note
+desc 'Add a note to the last entry'
+long_desc %(
+  If -r is provided with no other arguments, the last note is removed.
+  If new content is specified through arguments or STDIN, any previous
+  note will be replaced with the new one.
+
+  Use -e to load the last entry in a text editor where you can append a note.
+)
+arg_name 'NOTE_TEXT', optional: true
+command :note do |c|
+  c.example 'doing note', desc: 'Open the last entry in $EDITOR to append a note'
+  c.example 'doing note "Just a quick annotation"', desc: 'Add a quick note to the last entry'
+  c.example 'doing note --tag done "Keeping it real or something"', desc: 'Add a note to the last item tagged @done'
+  c.example 'doing note --search "late night" -e', desc: 'Open $EDITOR to add a note to the last item containing "late night" (fuzzy matched)'
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc "Edit entry with #{Doing::Util.default_editor}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc "Replace/Remove last entry's note (default append)"
+  c.switch %i[r remove], negatable: false, default_value: false
+
+  c.desc 'Select item for new note from a menu of matching entries'
+  c.switch %i[i interactive], negatable: false, default_value: false
+
+  c.desc 'Prompt for note via multi-line input'
+  c.switch %i[ask], negatable: false, default_value: false
+
+  add_options(:search, c)
+  add_options(:tag_filter, c)
+
+  c.action do |_global_options, options, args|
+    options[:fuzzy] = false
+    options[:section] = @wwid.guess_section(options[:section]) || options[:section].cap_first if options[:section]
+    options[:tag_bool] = options[:bool]
+
+    if options[:search]
+      search = options[:search]
+      search.sub!(/^'?/, "'") if options[:exact]
+      options[:search] = search
+    end
+
+    last_entry = @wwid.last_entry(options)
+    old_entry = last_entry.clone
+
+    raise NoResults, 'No entry matching parameters was found.' unless last_entry
+
+    last_note = last_entry.note || Doing::Note.new
+    new_note = Doing::Note.new
+
+    new_note.add($stdin.read.strip) if $stdin.stat.size.positive?
+    new_note.add(args.join(' ')) unless args.empty?
+
+    if options[:editor]
+      raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
+
+      input = if options[:remove]
+                Doing::Note.new
+              else
+                last_entry.note || Doing::Note.new
+              end
+
+      input.add(new_note)
+
+      new_note = Doing::Note.new(@wwid.fork_editor(input.strip_lines.join("\n"), message: nil).strip)
+      options[:remove] = true
+    end
+
+    if (new_note.empty? && !options[:remove]) || options[:ask]
+      $stderr.puts last_note if last_note.good?
+      $stderr.puts new_note if new_note.good?
+      new_note.add(Doing::Prompt.read_lines(prompt: 'Add a note'))
+    end
+
+    raise EmptyInput, 'You must provide content when adding a note' unless options[:remove] || new_note.good?
+
+    if last_note.equal?(new_note)
+      Doing.logger.debug('Skipped:', 'No note change')
+    else
+      last_note.add(new_note, replace: options[:remove])
+      Doing.logger.info('Entry updated:', last_entry.title)
+      Doing::Hooks.trigger :post_entry_updated, @wwid, last_entry, old_entry
+    end
+    # new_entry = Doing::Item.new(last_entry.date, last_entry.title, last_entry.section, new_note)
+    @wwid.write(@wwid.doing_file)
+  end
+end

data/bin/commands/now.rb

@@ -0,0 +1,145 @@
+# @@now @@next
+desc 'Add an entry'
+long_desc %(Record what you're starting now, or backdate the start time using natural language.
+
+A parenthetical at the end of the entry will be converted to a note.
+
+Run without arguments to create a new entry interactively.
+
+Run with --editor to create a new entry using #{Doing::Util.default_editor}.)
+arg_name 'ENTRY'
+command %i[now next] do |c|
+  c.example 'doing now', desc: 'Create a new entry with interactive prompts'
+  c.example 'doing now -e', desc: "Open #{Doing::Util.default_editor} to input an entry and optional note"
+  c.example 'doing now working on a new project', desc: 'Add a new entry at the current time'
+  c.example 'doing now debugging @project2', desc: 'Add an entry with a tag'
+  c.example 'doing now adding an entry (with a note)', desc: 'Parenthetical at end is converted to note'
+  c.example 'doing now --back 2pm A thing I started at 2:00 and am still doing...', desc: 'Backdate an entry'
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.flag %i[s section]
+
+  c.desc %(
+        Set a start and optionally end time as a date range ("from 1pm to 2:30pm").
+        If an end time is provided, a dated @done tag will be added
+      )
+  c.arg_name 'TIME_RANGE'
+  c.flag [:from], type: DateRangeString
+
+  c.desc 'Timed entry, marks last entry in section as @done'
+  c.switch %i[f finish_last], negatable: false, default_value: false
+
+  add_options(:add_entry, c)
+
+  # c.desc "Edit entry with specified app"
+  # c.arg_name 'editor_app'
+  # # c.flag [:a, :app]
+
+  c.action do |_global_options, options, args|
+    @wwid.auto_tag = !options[:noauto]
+
+    raise InvalidArgument, '--back and --from cannot be used together' if options[:back] && options[:from]
+
+    if options[:back]
+      date = options[:back]
+    elsif options[:from]
+      date, finish_date = options[:from]
+      options[:done] = finish_date
+    else
+      date = Time.now
+    end
+    raise InvalidTimeExpression.new('unable to parse date string', topic: 'Parser:') if date.nil?
+
+    section = if options[:section]
+                @wwid.guess_section(options[:section]) || options[:section].cap_first
+              else
+                @settings['current_section']
+              end
+
+    ask_note = if options[:ask] && !options[:editor] && args.count.positive?
+                 Doing::Prompt.read_lines(prompt: 'Add a note')
+               else
+                 ''
+               end
+
+    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 += " @done(#{options[:done].strftime('%F %R')})" if options[:done]
+      input += "\n#{options[:note]}" if options[:note]
+      input += "\n#{ask_note}" if ask_note.good?
+      input = @wwid.fork_editor(input).strip
+
+      d, title, note = @wwid.format_input(input)
+      raise EmptyInput, 'No content' unless title.good?
+
+      if ask_note.empty? && 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
+      @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      @wwid.write(@wwid.doing_file)
+    elsif args.length.positive?
+      d, title, note = @wwid.format_input(args.join(' '))
+      date = d.nil? ? date : d
+      note.add(options[:note]) if options[:note]
+      note.add(ask_note) if ask_note.good?
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    elsif $stdin.stat.size.positive?
+      input = $stdin.read.strip
+      d, title, note = @wwid.format_input(input)
+      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]
+      if ask_note.empty? && options[:ask]
+        ask_note = Doing::Prompt.read_lines(prompt: 'Add a note')
+        note.add(ask_note) if ask_note.good?
+      end
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    else
+      tags = @wwid.all_tags(@wwid.content)
+      $stderr.puts Doing::Color.boldgreen("Add a new entry. Tab will autocomplete known tags. Ctrl-c to cancel.")
+      title = Doing::Prompt.read_line(prompt: 'Entry content', completions: tags)
+      raise EmptyInput, 'You must provide content when creating a new entry' unless title.good?
+
+      note = Doing::Note.new
+      note.add(options[:note]) if options[:note]
+      res = Doing::Prompt.yn('Add a note', default_response: false)
+      ask_note = res ? Doing::Prompt.read_lines(prompt: 'Enter note') : []
+      note.add(ask_note)
+
+      entry = @wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
+      if options[:done] && entry.should_finish?
+        if entry.should_time?
+          entry.tag('done', value: options[:done])
+        else
+          entry.tag('done')
+        end
+      end
+      @wwid.write(@wwid.doing_file)
+    end
+  end
+end

data/bin/commands/on.rb

@@ -0,0 +1,65 @@
+# @@on
+desc 'List entries for a date'
+long_desc %(Date argument can be natural language. "thursday" would be interpreted as "last thursday,"
+and "2d" would be interpreted as "two days ago." If you use "to" or "through" between two dates,
+it will create a range.)
+arg_name 'DATE_STRING'
+command :on do |c|
+  c.example 'doing on friday', desc: 'List entries between 12am and 11:59PM last Friday'
+  c.example 'doing on 12/21/2020', desc: 'List entries from Dec 21, 2020'
+  c.example 'doing on "3d to 1d"', desc: 'List entries added between 3 days ago and 1 day ago'
+
+  c.desc 'Section'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
+
+  c.desc 'Show time intervals on @done tasks'
+  c.switch %i[t times], default_value: true, negatable: true
+
+  c.desc 'Show elapsed time on entries without @done tag'
+  c.switch [:duration]
+
+  c.desc 'Show time totals at the end of output'
+  c.switch [:totals], default_value: false, negatable: false
+
+  c.desc 'Sort tags by (name|time)'
+  default = @settings['tag_sort'].normalize_tag_sort || :name
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: REGEX_TAG_SORT, default_value: default, type: TagSortSymbol
+
+  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.action do |_global_options, options, args|
+    raise DoingRuntimeError, %(Invalid output type "#{options[:output]}") if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+
+    raise MissingArgument, 'Missing date argument' if args.empty?
+
+    date_string = args.join(' ').strip
+    if date_string =~ /^tod(?:ay)?/i
+      date_string = 'today to tomorrow 12am'
+    end
+    start, finish = date_string.split_date_range
+
+    raise InvalidTimeExpression, 'Unrecognized date string' unless start
+
+    message = "date interpreted as #{start}"
+    message += " to #{finish}" if finish
+    Doing.logger.debug('Interpreter:', message)
+
+    options[:times] = true if options[:totals]
+    options[:sort_tags] = options[:tag_sort]
+
+    Doing::Pager.page @wwid.list_date([start, finish], options[:section], options[:times], options[:output],
+                        { template: options[:template], config_template: options[:config_template], duration: options[:duration], totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
+  end
+end