doing 2.0.23 → 2.1.1pre

data/bin/doing

@@ -35,8 +35,10 @@ colors = Doing::Color
 wwid = Doing::WWID.new
 
 Doing.logger.log_level = :info
+env_log_level = nil
 
 if ENV['DOING_LOG_LEVEL'] || ENV['DOING_DEBUG'] || ENV['DOING_QUIET'] || ENV['DOING_VERBOSE'] || ENV['DOING_PLUGIN_DEBUG']
+  env_log_level = true
   # Quiet always wins
   if ENV['DOING_QUIET'] && ENV['DOING_QUIET'].truthy?
     Doing.logger.log_level = :error
@@ -82,6 +84,12 @@ switch %i[p pager], default_value: settings['paginate']
 desc 'Answer yes/no menus with default option'
 switch [:default], default_value: false
 
+desc 'Answer all yes/no menus with yes'
+switch [:yes], negatable: false
+
+desc 'Answer all yes/no menus with no'
+switch [:no], negatable: false
+
 desc 'Exclude auto tags and default tags'
 switch %i[x noauto], default_value: false, negatable: false
 
@@ -121,9 +129,9 @@ command %i[now next] do |c|
   c.desc "Edit entry with #{Doing::Util.default_editor}"
   c.switch %i[e editor], negatable: false, default_value: false
 
-  c.desc 'Backdate start time [4pm|20m|2h|yesterday noon]'
+  c.desc 'Backdate start time [4pm|20m|2h|"yesterday noon"]'
   c.arg_name 'DATE_STRING'
-  c.flag %i[b back]
+  c.flag %i[b back started]
 
   c.desc 'Timed entry, marks last entry in section as @done'
   c.switch %i[f finish_last], negatable: false, default_value: false
@@ -138,9 +146,9 @@ command %i[now next] do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
 
-      raise InvalidTimeExpression.new('unable to parse date string', topic: 'Date parser:') if date.nil?
+      raise InvalidTimeExpression.new('unable to parse date string', topic: 'Parser:') if date.nil?
     else
       date = Time.now
     end
@@ -151,29 +159,34 @@ command %i[now next] do |c|
       options[:section] = settings['current_section']
     end
 
-    if options[:e] || (args.empty? && $stdin.stat.size.zero?)
+    if options[:editor] || (args.empty? && $stdin.stat.size.zero?)
       raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
-      input = ''
+      input = date.strftime('%F %R | ')
       input += args.join(' ') unless args.empty?
       input = wwid.fork_editor(input).strip
 
       raise EmptyInput, 'No content' if input.empty?
 
-      title, note = wwid.format_input(input)
-      note.push(options[:n]) if options[:n]
-      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:f] })
+      date, title, note = wwid.format_input(input)
+      note.add(options[:note]) if options[:note]
+      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
       wwid.write(wwid.doing_file)
     elsif args.length.positive?
-      title, note = wwid.format_input(args.join(' '))
-      note.push(options[:n]) if options[:n]
-      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:f] })
+      d, title, note = wwid.format_input(args.join(' '))
+      date = d.nil? ? date : d
+      note.add(options[:note]) if options[:note]
+      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
       wwid.write(wwid.doing_file)
     elsif $stdin.stat.size.positive?
-      input = $stdin.read
-      title, note = wwid.format_input(input)
-      note.push(options[:n]) if options[:n]
-      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:f] })
+      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]
+      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:finish_last] })
       wwid.write(wwid.doing_file)
     else
       raise EmptyInput, 'You must provide content when creating a new entry'
@@ -238,14 +251,13 @@ command %i[reset begin] do |c|
     items = wwid.filter_items([], opt: options)
 
     if options[:interactive]
-      last_entry = wwid.choose_from_items(items, {
+      last_entry = Doing::Prompt.choose_from_items(items, include_section: options[:section].nil?,
         menu: true,
         header: '',
         prompt: 'Select an entry to start/reset > ',
         multiple: false,
         sort: false,
-        show_if_single: true
-      }, include_section: options[:section].nil? )
+        show_if_single: true)
     else
       last_entry = items.last
     end
@@ -344,7 +356,7 @@ command :note do |c|
     last_note = last_entry.note || Doing::Note.new
     new_note = Doing::Note.new
 
-    if options[:e] || (args.empty? && $stdin.stat.size.zero? && !options[:r])
+    if options[:editor] || (args.empty? && $stdin.stat.size.zero? && !options[:remove])
       raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
       input = !args.empty? ? args.join(' ') : ''
@@ -357,14 +369,14 @@ command :note do |c|
 
       input = prev_input.add(input)
 
-      input = wwid.fork_editor([last_entry.title, '### Edit below this line', input.to_s].join("\n")).strip
-      _title, note = wwid.format_input(input)
+      input = wwid.fork_editor(prev_input.strip_lines.join("\n"), message: nil).strip
+      note = input
       options[:remove] = true
       new_note.add(note)
     elsif !args.empty?
       new_note.add(args.join(' '))
     elsif $stdin.stat.size.positive?
-      new_note.add($stdin.read)
+      new_note.add($stdin.read.strip)
     else
       raise EmptyInput, 'You must provide content when adding a note' unless options[:remove]
     end
@@ -409,7 +421,7 @@ command :meanwhile do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
 
       raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
@@ -423,31 +435,35 @@ command :meanwhile do |c|
     end
     input = ''
 
-    if options[:e]
+    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 = wwid.fork_editor(input).strip
     elsif !args.empty?
       input = args.join(' ')
     elsif $stdin.stat.size.positive?
-      input = $stdin.read
+      input = $stdin.read.strip
     end
 
     if input && !input.empty?
-      input, note = wwid.format_input(input)
+      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
 
-    if options[:n]
-      note.push(options[:n])
+    if options[:note]
+      note.push(options[:note])
     elsif note.empty?
       note = nil
     end
 
-    wwid.stop_start('meanwhile', { new_item: input, back: date, section: section, archive: options[:a], 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
@@ -465,11 +481,11 @@ command :template do |c|
   c.switch %i[l list], negatable: false
 
   c.desc 'List in single column for completion'
-  c.switch %i[c]
+  c.switch %i[c column]
 
   c.action do |_global_options, options, args|
-    if options[:list] || options[:c]
-      if options[:c]
+    if options[:list] || options[:column]
+      if options[:column]
         $stdout.print Doing::Plugins.plugin_templates.join("\n")
       else
         $stdout.puts "Available templates: #{Doing::Plugins.plugin_templates.join(', ')}"
@@ -478,7 +494,7 @@ command :template do |c|
     end
 
     if args.empty?
-      type = wwid.choose_from(Doing::Plugins.plugin_templates, sorted: false, prompt: 'Select template type > ')
+      type = Doing::Prompt.choose_from(Doing::Plugins.plugin_templates, sorted: false, prompt: 'Select template type > ')
     else
       type = args[0]
     end
@@ -532,6 +548,25 @@ command :select do |c|
   c.arg_name 'QUERY'
   c.flag %i[q query search]
 
+  c.desc 'Select from entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
+  c.arg_name 'DATE_STRING'
+  c.flag [:before]
+
+  c.desc 'Select from entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
+  c.arg_name 'DATE_STRING'
+  c.flag [:after]
+
+  c.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing select --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Force exact search string matching (case sensitive)'
   c.switch %i[x exact], default_value: false, negatable: false
 
@@ -604,7 +639,7 @@ command :later do |c|
 
   c.action do |_global_options, options, args|
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
       raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
     else
       date = Time.now
@@ -613,22 +648,29 @@ command :later do |c|
     if options[:editor] || (args.empty? && $stdin.stat.size.zero?)
       raise MissingEditor, 'No EDITOR variable defined in environment' if Doing::Util.default_editor.nil?
 
-      input = args.empty? ? '' : args.join(' ')
+      input += date.strftime('%F %R | ')
+      input += args.empty? ? '' : args.join(' ')
       input = wwid.fork_editor(input).strip
       raise EmptyInput, 'No content' unless input && !input.empty?
 
-      title, note = wwid.format_input(input)
-      note.push(options[:n]) if options[:n]
+      d, title, note = wwid.format_input(input)
+      date = d.nil? ? date : d
+      note.add(options[:note]) if options[:note]
       wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
       wwid.write(wwid.doing_file)
     elsif !args.empty?
-      title, note = wwid.format_input(args.join(' '))
-      note.push(options[:n]) if options[:n]
+      d, title, note = wwid.format_input(args.join(' '))
+      date = d.nil? ? date : d
+      note.add(options[:note]) if options[:note]
       wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
       wwid.write(wwid.doing_file)
     elsif $stdin.stat.size.positive?
-      title, note = wwid.format_input($stdin.read)
-      note.push(options[:n]) if options[:n]
+      d, title, note = wwid.format_input($stdin.read)
+      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]
       wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
       wwid.write(wwid.doing_file)
     else
@@ -659,9 +701,9 @@ command %i[done did] do |c|
   c.arg_name 'DATE_STRING'
   c.flag [:at]
 
-  c.desc 'Backdate start date by interval [4pm|20m|2h|yesterday noon]'
+  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]
+  c.flag %i[b back started]
 
   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
@@ -692,26 +734,24 @@ command %i[done did] do |c|
     donedate = nil
 
     if options[:took]
-      took = wwid.chronify_qty(options[:took])
+      took = options[:took].chronify_qty
       raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
     end
 
     if options[:back]
-      date = wwid.chronify(options[:back], guess: :begin)
+      date = options[:back].chronify(guess: :begin)
       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 = wwid.chronify(options[:at], guess: :begin)
+      finish_date = options[:at].chronify(guess: :begin)
       raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
 
       date = options[:took] ? finish_date - took : finish_date
     elsif options[:took]
       finish_date = date + took
-    elsif options[:back]
-      finish_date = date
     else
       finish_date = Time.now
     end
@@ -743,16 +783,17 @@ command %i[done did] do |c|
 
         old_entry = last_entry.dup
         last_entry.note.add(note)
-        input = [last_entry.title, last_entry.note.to_s].join("\n")
+        input = ["#{last_entry.date.strftime('%F %R | ')}#{last_entry.title}", last_entry.note.strip_lines.join("\n")].join("\n")
       else
         is_new = true
-        input = [args.join(' '), note.to_s].join("\n")
+        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 && !input.empty?
 
-      title, note = wwid.format_input(input)
+      d, title, note = wwid.format_input(input)
+      date = d.nil? ? date : d
       new_entry = Doing::Item.new(date, title, section, note)
       if new_entry.should_finish?
         if new_entry.should_time?
@@ -763,23 +804,23 @@ command %i[done did] do |c|
       end
 
       if (is_new)
-        wwid.content[section][:items].push(new_entry)
+        wwid.content.push(new_entry)
       else
-        wwid.update_item(old_entry, new_entry)
+        wwid.content.update_item(old_entry, new_entry)
       end
 
-      if options[:a]
+      if options[:archive]
         wwid.move_item(new_entry, 'Archive', label: true)
       end
 
       wwid.write(wwid.doing_file)
     elsif args.empty? && $stdin.stat.size.zero?
-      if options[:r]
+      if options[:remove]
         wwid.tag_last({ tags: ['done'], count: 1, section: section, remove: true })
       else
         note = options[:note] ? Doing::Note.new(options[:note]) : nil
         opt = {
-          archive: options[:a],
+          archive: options[:archive],
           back: finish_date,
           count: 1,
           date: options[:date],
@@ -793,9 +834,10 @@ command %i[done did] do |c|
       end
     elsif !args.empty?
       note = Doing::Note.new(options[:note])
-      title, new_note = wwid.format_input([args.join(' '), note.to_s].join("\n"))
+      d, title, new_note = wwid.format_input([args.join(' '), note.strip_lines.join("\n")].join("\n"))
+      date = d.nil? ? date : d
       title.chomp!
-      section = 'Archive' if options[:a]
+      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?
@@ -804,13 +846,17 @@ command %i[done did] do |c|
           new_entry.tag('done')
         end
       end
-      wwid.content[section][:items].push(new_entry)
+      wwid.content.push(new_entry)
       wwid.write(wwid.doing_file)
       Doing.logger.info('Entry Added:', new_entry.title)
     elsif $stdin.stat.size.positive?
-      title, note = wwid.format_input($stdin.read)
+      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[:a] ? 'Archive' : section
+      section = options[:archive] ? 'Archive' : section
       new_entry = Doing::Item.new(date, title, section, note)
 
       if new_entry.should_finish?
@@ -821,7 +867,7 @@ command %i[done did] do |c|
         end
       end
 
-      wwid.content[section][:items].push(new_entry)
+      wwid.content.push(new_entry)
       wwid.write(wwid.doing_file)
       Doing.logger.info('Entry Added:', new_entry.title)
     else
@@ -907,7 +953,7 @@ command :cancel do |c|
     end
 
     opts = {
-      archive: options[:a],
+      archive: options[:archive],
       case: options[:case].normalize_case,
       count: count,
       date: false,
@@ -1001,7 +1047,7 @@ command :finish do |c|
     options[:fuzzy] = false
     unless options[:auto]
       if options[:took]
-        took = wwid.chronify_qty(options[:took])
+        took = options[:took].chronify_qty
         raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
       end
 
@@ -1010,21 +1056,21 @@ command :finish do |c|
       raise InvalidArgument, '--search and --tag can not be used together' if options[:search] && options[:tag]
 
       if options[:at]
-        finish_date = wwid.chronify(options[:at], guess: :begin)
+        finish_date = options[:at].chronify(guess: :begin)
         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 = wwid.chronify(options[:back])
+        date = options[:back].chronify()
 
         raise InvalidTimeExpression, 'Unable to parse date string' if date.nil?
-      elsif options[:took]
-        date = wwid.chronify_qty(options[:took])
       else
         date = Time.now
       end
     end
 
+    options[:took] = options[:took].chronify_qty if options[:took]
+
     if options[:tag].nil?
       tags = []
     else
@@ -1064,6 +1110,7 @@ command :finish do |c|
       tag: tags,
       tag_bool: options[:bool].normalize_bool,
       tags: ['done'],
+      took: options[:took],
       unfinished: options[:unfinished]
     }
 
@@ -1188,7 +1235,7 @@ command :tag do |c|
   c.desc 'Tag last entry (or entries) not marked @done'
   c.switch %i[u unfinished], negatable: false, default_value: false
 
-  c.desc 'Autotag entries based on autotag configuration in ~/.doingrc'
+  c.desc 'Autotag entries based on autotag configuration in ~/.config/doing/config.yml'
   c.switch %i[a autotag], negatable: false, default_value: false
 
   c.desc 'Tag the last X entries containing TAG.
@@ -1279,15 +1326,15 @@ command :tag do |c|
       end
 
 
-      question = if options[:a]
+      question = if options[:aarchive]
                    "Are you sure you want to autotag all records#{section_q}"
-                 elsif options[:r]
+                 elsif options[:remove]
                    "Are you sure you want to remove #{tags.join(' and ')} from all records#{section_q}"
                  else
                    "Are you sure you want to add #{tags.join(' and ')} to all records#{section_q}"
                  end
 
-      res = wwid.yn(question, default_response: false)
+      res = Doing::Prompt.yn(question, default_response: false)
 
       raise UserCancelled unless res
     end
@@ -1408,7 +1455,7 @@ command [:mark, :flag] do |c|
                    "Are you sure you want to flag all records#{section_q}"
                  end
 
-      res = wwid.yn(question, default_response: false)
+      res = Doing::Prompt.yn(question, default_response: false)
 
       exit_now! 'Cancelled' unless res
     end
@@ -1454,14 +1501,26 @@ command :show do |c|
   c.arg_name 'AGE'
   c.flag %i[a age], default_value: 'newest'
 
-  c.desc 'View entries older than date'
+  c.desc 'Show entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:before]
 
-  c.desc 'View entries newer than date'
+  c.desc 'Show entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:after]
 
+  c.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing show --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Search filter, surround with slashes for regex (/query/), start with single quote for exact match ("\'query")'
   c.arg_name 'QUERY'
   c.flag [:search]
@@ -1483,14 +1542,6 @@ command :show do |c|
   c.arg_name 'ORDER'
   c.flag %i[s sort], must_match: REGEX_SORT_ORDER, default_value: 'asc'
 
-  c.desc %(
-    Date range to show, or a single day to filter date on.
-    Date range argument should be quoted. Date specifications can be natural language.
-    To specify a range, use "to" or "through": `doing show --from "monday to friday"`
-  )
-  c.arg_name 'DATE_OR_RANGE'
-  c.flag %i[f from]
-
   c.desc 'Show time intervals on @done tasks'
   c.switch %i[t times], default_value: true, negatable: true
 
@@ -1565,21 +1616,6 @@ command :show do |c|
       }
     end
 
-    if options[:from]
-
-      date_string = options[:from]
-      if date_string =~ / (to|through|thru|(un)?til|-+) /
-        dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-        start = wwid.chronify(dates[0], guess: :begin)
-        finish = wwid.chronify(dates[2], guess: :end)
-      else
-        start = wwid.chronify(date_string, guess: :begin)
-        finish = false
-      end
-      raise InvalidTimeExpression, 'Unrecognized date string' unless start
-      dates = [start, finish]
-    end
-
     options[:times] = true if options[:totals]
 
     template = settings['templates']['default'].deep_merge({
@@ -1598,10 +1634,8 @@ command :show do |c|
     end
 
     opt = options.dup
-
     opt[:sort_tags] = options[:tag_sort] =~ /^n/i
     opt[:count] = options[:count].to_i
-    opt[:date_filter] = dates
     opt[:highlight] = true
     opt[:order] = options[:sort].normalize_order
     opt[:section] = section
@@ -1632,14 +1666,25 @@ command %i[grep search] do |c|
   c.arg_name 'NAME'
   c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Constrain search to entries older than date'
+  c.desc 'Search entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:before]
 
-  c.desc 'Constrain search to entries newer than date'
+  c.desc 'Search entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:after]
 
+  c.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing search --from "monday 8am to friday 5pm"`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc "Output to export format (#{Doing::Plugins.plugin_names(type: :export)})"
   c.arg_name 'FORMAT'
   c.flag %i[o output]
@@ -1729,7 +1774,7 @@ command :recent do |c|
   c.switch %i[i interactive], negatable: false, default_value: false
 
   c.action do |global_options, options, args|
-    section = wwid.guess_section(options[:s]) || options[:s].cap_first
+    section = wwid.guess_section(options[:section]) || options[:section].cap_first
 
     unless global_options[:version]
       if settings['templates']['recent'].key?('count')
@@ -1744,7 +1789,7 @@ command :recent do |c|
         count = args.empty? ? config_count : args[0].to_i
       end
 
-      options[:t] = true if options[:totals]
+      options[:times] = true if options[:totals]
       options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
       template = settings['templates']['recent'].deep_merge(settings['templates']['default'])
@@ -1753,7 +1798,7 @@ command :recent do |c|
       opts = {
         sort_tags: options[:sort_tags],
         tags_color: tags_color,
-        times: options[:t],
+        times: options[:times],
         totals: options[:totals],
         interactive: options[:interactive]
       }
@@ -1799,19 +1844,20 @@ command :today do |c|
   c.arg_name 'TIME_STRING'
   c.flag [:after]
 
+  c.desc %(
+    Time range to show `doing today --from "12pm to 4pm"`
+  )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   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)
 
-    options[:t] = true if options[:totals]
+    options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
-    opt = {
-      after: options[:after],
-      before: options[:before],
-      section: options[:section],
-      sort_tags: options[:sort_tags],
-      totals: options[:totals]
-    }
-    Doing::Pager.page wwid.today(options[:times], options[:output], opt).chomp
+    filter_options = %i[after before from section sort_tags totals].each_with_object({}) { |k, hsh| hsh[k] = options[k] }
+
+    Doing::Pager.page wwid.today(options[:times], options[:output], filter_options).chomp
   end
 end
 
@@ -1854,23 +1900,23 @@ command :on do |c|
 
     if date_string =~ / (to|through|thru) /
       dates = date_string.split(/ (to|through|thru) /)
-      start = wwid.chronify(dates[0], guess: :begin)
-      finish = wwid.chronify(dates[2], guess: :end)
+      start = dates[0].chronify(guess: :begin)
+      finish = dates[2].chronify(guess: :end)
     else
-      start = wwid.chronify(date_string, guess: :begin)
+      start = date_string.chronify(guess: :begin)
       finish = false
     end
 
     raise InvalidTimeExpression, 'Unrecognized date string' unless start
 
-    message = "Date interpreted as #{start}"
+    message = "date interpreted as #{start}"
     message += " to #{finish}" if finish
-    Doing.logger.debug(message)
+    Doing.logger.debug('Interpreter:', message)
 
-    options[:t] = true if options[:totals]
+    options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    Doing::Pager.page wwid.list_date([start, finish], options[:s], options[:t], options[:output],
+    Doing::Pager.page wwid.list_date([start, finish], options[:section], options[:times], options[:output],
                         { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
@@ -1913,17 +1959,17 @@ command :since do |c|
     date_string.sub!(/(day) (\d)/, '\1 at \2')
     date_string.sub!(/(\d+)d( ago)?/, '\1 days ago')
 
-    start = wwid.chronify(date_string, guess: :begin)
+    start = date_string.chronify(guess: :begin)
     finish = Time.now
 
     raise InvalidTimeExpression, 'Unrecognized date string' unless start
 
-    Doing.logger.debug("Date interpreted as #{start} through the current time")
+    Doing.logger.debug('Interpreter:', "date interpreted as #{start} through the current time")
 
-    options[:t] = true if options[:totals]
+    options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    Doing::Pager.page wwid.list_date([start, finish], options[:s], options[:t], options[:output],
+    Doing::Pager.page wwid.list_date([start, finish], options[:section], options[:times], options[:output],
                         { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
@@ -1961,6 +2007,12 @@ command :yesterday do |c|
   c.arg_name 'TIME_STRING'
   c.flag [:after]
 
+  c.desc %(
+      Time range to show, e.g. `doing yesterday --from "1am to 8am"`
+    )
+  c.arg_name 'TIME_RANGE'
+  c.flag [:from]
+
   c.desc 'Tag sort direction (asc|desc)'
   c.arg_name 'DIRECTION'
   c.flag [:tag_order], must_match: REGEX_SORT_ORDER, default_value: 'asc'
@@ -1970,9 +2022,16 @@ command :yesterday do |c|
 
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
+    if options[:from]
+      options[:from] = options[:from].split(/ (?:to|through|thru|(?:un)?til|-+) /).map do |time|
+        "yesterday #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}"
+      end.join(' to ')
+    end
+
     opt = {
       after: options[:after],
       before: options[:before],
+      from: options[:from],
       sort_tags: options[:sort_tags],
       tag_order: options[:tag_order].normalize_order,
       totals: options[:totals],
@@ -2053,9 +2112,9 @@ command :last do |c|
     end
 
     if options[:editor]
-      wwid.edit_last(section: options[:s], options: { search: search, fuzzy: options[:fuzzy], case: options[:case], tag: tags, tag_bool: options[:bool], not: options[:not] })
+      wwid.edit_last(section: options[:section], options: { search: search, fuzzy: options[:fuzzy], case: options[:case], tag: tags, tag_bool: options[:bool], not: options[:not] })
     else
-      Doing::Pager::page wwid.last(times: true, section: options[:s],
+      Doing::Pager::page wwid.last(times: true, section: options[:section],
                      options: { search: search, fuzzy: options[:fuzzy], case: options[:case], negate: options[:not], tag: tags, tag_bool: options[:bool] }).strip
     end
   end
@@ -2067,8 +2126,8 @@ command :sections do |c|
   c.switch %i[c column], negatable: false, default_value: false
 
   c.action do |_global_options, options, _args|
-    joiner = options[:c] ? "\n" : "\t"
-    print wwid.sections.join(joiner)
+    joiner = options[:column] ? "\n" : "\t"
+    print wwid.content.section_titles.join(joiner)
   end
 end
 
@@ -2089,7 +2148,7 @@ command :add_section do |c|
   c.action do |_global_options, _options, args|
     raise InvalidArgument, "Section #{args[0]} already exists" if wwid.sections.include?(args[0])
 
-    wwid.add_section(args.join(' ').cap_first)
+    wwid.content.add_section(args.join(' ').cap_first, log: true)
     wwid.write(wwid.doing_file)
   end
 end
@@ -2219,14 +2278,25 @@ command :view do |c|
   c.arg_name 'DIRECTION'
   c.flag [:tag_order], must_match: REGEX_SORT_ORDER
 
-  c.desc 'View entries older than date'
+  c.desc 'View entries older than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:before]
 
-  c.desc 'View entries newer than date'
+  c.desc 'View entries newer than date. If this is only a time (8am, 1:30pm, 15:00), all dates will be included, but entries will be filtered by time of day.'
   c.arg_name 'DATE_STRING'
   c.flag [:after]
 
+  c.desc %(
+      Date range to show, or a single day to filter date on.
+      Date range argument should be quoted. Date specifications can be natural language.
+      To specify a range, use "to" or "through": `doing view --from "monday 8am to friday 5pm" view_name`.
+
+      If values are only time(s) (6am to noon) all dates will be included, but entries will be filtered
+      by time of day.
+    )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag [:from]
+
   c.desc 'Only show items with recorded time intervals (override view settings)'
   c.switch [:only_timed], default_value: false, negatable: false
 
@@ -2247,6 +2317,7 @@ command :view do |c|
               rescue WrongCommand => exception
                 cmd = commands[:show]
                 options[:sort] = 'asc'
+                options[:tag_order] = 'asc'
                 action = cmd.send(:get_action, nil)
                 return action.call(global_options, options, args)
               end
@@ -2289,12 +2360,9 @@ command :view do |c|
       # If the -o/--output flag was specified, override any default in the view template
       options[:output] ||= view.key?('output_format') ? view['output_format'] : 'template'
 
-      count = if options[:c]
-                options[:c]
-              else
-                view.key?('count') ? view['count'] : 10
-              end
-      section = if options[:s]
+      count = options[:count] ? options[:count] : view.key?('count') ? view['count'] : 10
+
+      section = if options[:section]
                   section
                 else
                   view.key?('section') ? view['section'] : settings['current_section']
@@ -2312,7 +2380,7 @@ command :view do |c|
                     view.key?('tag_order') ? view['tag_order'].normalize_order : 'asc'
                   end
 
-      options[:t] = true if totals
+      options[:times] = true if totals
       output_format = options[:output]&.downcase || 'template'
 
       options[:sort_tags] = if options[:tag_sort]
@@ -2322,27 +2390,8 @@ command :view do |c|
                             else
                               false
                             end
-      if view.key?('after') && !options[:after]
-        options[:after] = view['after']
-      end
 
-      if view.key?('before') && !options[:before]
-        options[:before] = view['before']
-      end
-
-      if view.key?('from')
-        date_string = view['from']
-        if date_string =~ / (to|through|thru|(un)?til|-+) /
-          dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-          start = wwid.chronify(dates[0], guess: :begin)
-          finish = wwid.chronify(dates[2], guess: :end)
-        else
-          start = wwid.chronify(date_string, guess: :begin)
-          finish = false
-        end
-        raise InvalidTimeExpression, 'Unrecognized date string' unless start
-        dates = [start, finish]
-      end
+      %w[before after from].each { |k| options[k.to_sym] = view[k] if view.key?(k) && !options[k.to_sym] }
 
       options[:case] = options[:case].normalize_case
 
@@ -2354,22 +2403,21 @@ command :view do |c|
       end
 
       opts = options.dup
-      opts[:search] = search
-      opts[:output] = output_format
       opts[:count] = count
       opts[:format] = date_format
       opts[:highlight] = options[:color]
       opts[:only_timed] = only_timed
       opts[:order] = order
+      opts[:output] = options[:interactive] ? nil : options[:output]
+      opts[:output] = output_format
+      opts[:page_title] = page_title
+      opts[:search] = search
       opts[:section] = section
       opts[:tag_filter] = tag_filter
       opts[:tag_order] = tag_order
       opts[:tags_color] = tags_color
       opts[:template] = template
       opts[:totals] = totals
-      opts[:page_title] = page_title
-      opts[:date_filter] = dates
-      opts[:output] = options[:interactive] ? nil : options[:output]
 
       Doing::Pager.page wwid.list_section(opts)
     elsif title.instance_of?(FalseClass)
@@ -2386,7 +2434,7 @@ command :views do |c|
   c.switch %i[c column], default_value: false
 
   c.action do |_global_options, options, _args|
-    joiner = options[:c] ? "\n" : "\t"
+    joiner = options[:column] ? "\n" : "\t"
     print wwid.views.join(joiner)
   end
 end
@@ -2552,6 +2600,10 @@ end
 desc 'Open the "doing" file in an editor'
 long_desc "`doing open` defaults to using the editor_app setting in #{config.config_file} (#{settings.key?('editor_app') ? settings['editor_app'] : 'not set'})."
 command :open do |c|
+  c.desc 'Open with editor command (e.g. vim, mate)'
+  c.arg_name 'COMMAND'
+  c.flag %i[e editor]
+
   if `uname` =~ /Darwin/
     c.desc 'Open with app name'
     c.arg_name 'APP_NAME'
@@ -2567,14 +2619,20 @@ command :open do |c|
     params.delete_if do |k, v|
       k.instance_of?(String) || v.nil? || v == false
     end
-    if `uname` =~ /Darwin/
+
+    if options[:editor]
+      raise MissingEditor, "Editor #{options[:editor]} not found" unless Doing::Util.exec_available(options[:editor].split(/ /).first)
+
+      editor = TTY::Which.which(options[:editor])
+      system %(#{editor} "#{File.expand_path(wwid.doing_file)}")
+    elsif `uname` =~ /Darwin/
       if options[:app]
-        system %(open -a "#{options[:a]}" "#{File.expand_path(wwid.doing_file)}")
+        system %(open -a "#{options[:app]}" "#{File.expand_path(wwid.doing_file)}")
       elsif options[:bundle_id]
-        system %(open -b "#{options[:b]}" "#{File.expand_path(wwid.doing_file)}")
+        system %(open -b "#{options[:bundle_id]}" "#{File.expand_path(wwid.doing_file)}")
       elsif Doing::Util.find_default_editor('doing_file')
         editor = Doing::Util.find_default_editor('doing_file')
-        if Doing::Util.exec_available(editor)
+        if Doing::Util.exec_available(editor.split(/ /).first)
           system %(#{editor} "#{File.expand_path(wwid.doing_file)}")
         else
           system %(open -a "#{editor}" "#{File.expand_path(wwid.doing_file)}")
@@ -2591,132 +2649,240 @@ command :open do |c|
 end
 
 desc 'Edit the configuration file or output a value from it'
-long_desc %(Run without arguments, `doing config` opens your `.doingrc` in an editor.
+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 `~/.doingrc`, a menu will allow you to select which to open in the editor.
+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 -d` to output the configuration to the terminal, and
+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.)
-arg_name 'KEY_PATH'
 command :config do |c|
   c.example 'doing config', desc: "Open an active configuration in #{Doing::Util.find_default_editor('config')}"
-  c.example 'doing config -d doing_file', desc: 'Output the value of a config key as YAML'
-  c.example 'doing config -d plugins.say.say_voice -o json', desc: 'Output the value of a key path as JSON'
+  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.desc 'Editor to use'
-  c.arg_name 'EDITOR'
-  c.flag %i[e editor], default_value: nil
+  c.default_command :edit
 
-  c.desc 'Show a config key value based on arguments. Separate key paths with colons or dots, e.g. "export_templates.html". Empty arguments outputs the entire config.'
-  c.switch %i[d dump], negatable: false
+  c.desc 'DEPRECATED'
+  c.switch %i[d dump]
 
-  c.desc 'Format for --dump (json|yaml|raw)'
-  c.arg_name 'FORMAT'
-  c.flag %i[o output], default_value: 'yaml', must_match: /^(?:y(?:aml)?|j(?:son)?|r(?:aw)?)$/
+  c.desc 'DEPRECATED'
+  c.switch %i[u update]
 
-  c.desc 'Update config file with missing configuration options'
-  c.switch %i[u update], default_value: false, negatable: false
+  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
 
-  if `uname` =~ /Darwin/
-    c.desc 'Application to use'
-    c.arg_name 'APP_NAME'
-    c.flag [:a]
+  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'
 
-    c.desc 'Application bundle id to use'
-    c.arg_name 'BUNDLE_ID'
-    c.flag [:b]
+    edit.desc 'Editor to use'
+    edit.arg_name 'EDITOR'
+    edit.flag %i[e editor], default_value: nil
 
-    c.desc "Use the config_editor_app defined in ~/.doingrc (#{settings.key?('config_editor_app') ? settings['config_editor_app'] : 'config_editor_app not set'})"
-    c.switch [:x]
+    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
 
-  c.action do |_global_options, options, args|
-    if options[:update]
+  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})
-      return
+      Doing.logger.warn('Config:', 'config refreshed')
     end
+  end
+
+  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
+      wwid.restore_backup(config_file)
+    end
+  end
+
+  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|
 
-    if options[:dump]
       keypath = args.join('.')
       cfg = config.value_for_key(keypath)
+      real_path = config.resolve_key_path(keypath)
 
       if cfg
-        $stdout.puts case options[:output]
-                     when /^j/
-                       JSON.pretty_generate(cfg)
-                     when /^r/
-                       cfg.map {|k, v| v.to_s }
-                     else
-                       YAML.dump(cfg)
-                     end
+        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
       return
     end
+  end
 
-    if config.additional_configs.count.positive?
-      choices = [config.config_file]
-      choices.concat(config.additional_configs)
-      res = wwid.choose_from(choices.uniq.sort.reverse, sorted: false, prompt: 'Local configs found, select which to edit > ')
+  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'
 
-      raise UserCancelled, 'Cancelled' unless res
+    set.desc 'Delete specified key'
+    set.switch %i[r remove], default_value: false, negatable: false
 
-      config_file = res.strip || config.config_file
-    else
-      config_file = config.config_file
-    end
+    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'
 
-    if `uname` =~ /Darwin/
-      if options[:x]
-        editor = Doing::Util.find_default_editor('config')
-        if editor
-          if Doing::Util.exec_available(editor)
-            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[:a] || options[:b]
-        if options[:a]
-          `open -a "#{options[:a]}" "#{config_file}"`
-        elsif options[:b]
-          `open -b #{options[:b]} "#{config_file}"`
-        end
-      else
-        editor = options[:e] || Doing::Util.find_default_editor('config')
+      end
 
-        raise MissingEditor, 'No viable editor defined in config or environment' unless editor
+      value = options[:remove] ? nil : args.pop
+      keypath = args.join('.')
+      old_value = config.value_for_key(keypath).map { |k, v| v.to_s }
+      real_path = config.resolve_key_path(keypath)
+      raise InvalidArgument, 'Invalid key path' if real_path.empty?
 
-        if Doing::Util.exec_available(editor)
-          system %(#{editor} "#{config_file}")
-        else
-          `open -a "#{editor}" "#{config_file}"`
-        end
+      config_file = config.choose_config
+      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
+        old_value = cfg.dig(*real_path) || 'empty'
+        cfg.deep_set(real_path, value.set_type)
+        $stderr.puts "#{'Key path:'.yellow} #{real_path.join('->').boldwhite}"
+        $stderr.puts "#{'Previous:'.yellow} #{old_value.to_s.boldwhite}"
+        $stderr.puts "#{'     New:'.yellow} #{value.set_type.to_s.boldwhite}"
       end
-    else
-      editor = options[:e] || Doing::Util.default_editor
-      raise MissingEditor, 'No EDITOR variable defined in environment' unless editor && Doing::Util.exec_available(editor)
 
-      system %(#{editor} "#{config_file}")
+      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
 
-desc 'Undo the last change to the doing_file'
+desc 'Undo the last change to the Doing file'
 command :undo do |c|
   c.desc 'Specify alternate doing file'
   c.arg_name 'PATH'
   c.flag %i[f file], default_value: wwid.doing_file
 
   c.action do |_global_options, options, _args|
-    file = options[:f] || wwid.doing_file
+    file = options[:file] || wwid.doing_file
     wwid.restore_backup(file)
   end
 end
@@ -2764,6 +2930,7 @@ command :import do |c|
   c.arg_name 'PREFIX'
   c.flag :prefix
 
+  # TODO: Allow time range filtering
   c.desc 'Import entries older than date'
   c.arg_name 'DATE_STRING'
   c.flag [:before]
@@ -2793,10 +2960,10 @@ command :import do |c|
       date_string = options[:from]
       if date_string =~ / (to|through|thru|(un)?til|-+) /
         dates = date_string.split(/ (to|through|thru|(un)?til|-+) /)
-        start = wwid.chronify(dates[0], guess: :begin)
-        finish = wwid.chronify(dates[2], guess: :end)
+        start = dates[0].chronify(guess: :begin)
+        finish = dates[2].chronify(guess: :end)
       else
-        start = wwid.chronify(date_string, guess: :begin)
+        start = date_string.chronify(guess: :begin)
         finish = false
       end
       raise InvalidTimeExpression, 'Unrecognized date string' unless start
@@ -2823,9 +2990,9 @@ pre do |global, _command, _options, _args|
 
   $stdout.puts "doing v#{Doing::VERSION}" if global[:version]
   unless STDOUT.isatty
-    Doing::Color::coloring = global[:pager] ? global[:color] : false
+    Doing::Color.coloring = global[:pager] ? global[:color] : false
   else
-    Doing::Color::coloring = global[:color]
+    Doing::Color.coloring = global[:color]
   end
 
   # Return true to proceed; false to abort and not call the
@@ -2853,13 +3020,21 @@ end
 
 around do |global, command, options, arguments, code|
   # Doing.logger.debug('Pager:', "Global: #{global[:pager]}, Config: #{settings['paginate']}, Pager: #{Doing::Pager.paginate}")
-  Doing.logger.adjust_verbosity(global)
+  if env_log_level.nil?
+    Doing.logger.adjust_verbosity(global)
+  end
 
   if global[:stdout]
     Doing.logger.logdev = $stdout
   end
 
-  wwid.default_option = global[:default]
+  if global[:yes]
+    Doing::Prompt.force_answer = true
+  elsif global[:no]
+    Doing::Prompt.force_answer = false
+  else
+    Doing::Prompt.default_answer = global[:default]
+  end
 
   if global[:config_file] && global[:config_file] != config.config_file
     Doing.logger.warn(format('%sWARNING:%s %sThe use of --config_file is deprecated, please set the environment variable DOING_CONFIG instead.', colors.flamingo, colors.default, colors.boldred))