doing 1.0.54 → 1.0.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f1fda3219bcf3e27c6816ff77efe53b168d4c2ecf5d8c17653fd4dc6f95a1dd
-  data.tar.gz: 17a4dc1ea548c201e22335d0055fd383f6ceac611c2f0d71f1ae5900e7cd1087
+  metadata.gz: 01becc9c5c9439e6c529fb4cc55cdd4487ed1d620f3bf110bee361205a8fa0fb
+  data.tar.gz: 98cf7dd0cf85aedaa9ee269420db1550d9cbfe784ba84685e27c60e7c16193c1
 SHA512:
-  metadata.gz: b2fb4ddc3f092a01134e157e84ea86ce44b5be6714c074b17bed647b8b1341fa43a5514311cfd387e662a744d307a624a57ec242caa3e651d57dc6875e572b08
-  data.tar.gz: f7e2eb609ce0eda0e2ca51205609b77cc44bf7c3d6dc12f25eb5bb8f06c50322d8d89d789998509d542dd7a90b3b29e1d3c82f5e021cf501850666ccc45243d0
+  metadata.gz: 98cfd2b536bccbc584556e00fc4757598f5043acadbec75d5d047428c88830da024e6d48c2672d571cc7028a373782cc6947ac61e9dc2362065e86732deafc63
+  data.tar.gz: 4306e5526d3ba9049006b7ded95cd84dc7168a282f6da177753b5ca6c77b1716f9d4551c6142edf9166b5d37833ad225c864faec80a1c27ecb4979f16c78e928

data/README.md

@@ -4,7 +4,6 @@
 
 _If you're one of the rare people like me who find this useful, feel free to [buy me some coffee](http://brettterpstra.com/donate/)._
 
-
 ## Contents
 
 - [What and why](#what-and-why)
@@ -31,6 +30,8 @@ _Side note:_ I actually use the library behind this utility as part of another s
 
 ## Installation
 
+The current version of `doing` is <!--VER-->1.0.54<!--END VER-->.
+
     $ [sudo] gem install doing
 
 To install the _latest_ version, use `--pre`:
@@ -68,8 +69,10 @@ A basic configuration looks like this:
     default_date_format: '%Y-%m-%d %H:%M'
     marker_tag: flagged
     marker_color: yellow
+    tags_color: boldcyan
     default_tags: []
-    editor_app: TextEdit
+    editor_app: TaskPaper
+    config_editor_app: Sublime Text
     :include_notes: true
     views:
       color:
@@ -138,7 +141,9 @@ You can rename the section that holds your current tasks. By default, this is `C
 
 ### Default editors
 
-The setting `editor_app` only applies to Mac OS X users. It's the default application that the command `doing open` will open your WWID file in. If this is blank, it will be opened by whatever the system default is, or you can use `-a app_name` or `-b bundle_id` to override.
+The setting `editor_app` only applies to Mac OS X users. It's the default application that the command `doing open` will open your WWID file in. Personally, I use `editor_app: TaskPaper`. If this is blank, it will be opened by whatever the system default is for the doing file extension (default is `.md`), or you can use `-a app_name` or `-b bundle_id` to override.
+
+You can define a separate app to open the config file in when running `doing config`. The key for this is `config_editor_app`.
 
 In the case of the `doing now -e` command, your `$EDITOR` environment variable will be used to complete the entry text and notes. Set it in your `~/.bash_profile` or whatever is appropriate for your system:
 
@@ -146,6 +151,8 @@ In the case of the `doing now -e` command, your `$EDITOR` environment variable w
 
 The only requirements are that your editor be launchable from the command line and able to "wait." In the case of Sublime Text and TextMate, just use `-w` like this: `export EDITOR="subl -w"`.
 
+You can set a 
+
 ### Templates
 
 The config also contains templates for various command outputs. Include placeholders by placing a % before the keyword. The available tokens are:
@@ -495,6 +502,8 @@ This creates a search pattern looking for a string of word characters followed b
 
 You can also add notes at the time of entry by using the `-n` or `--note` flag with `doing now`, `doing later`, or `doing done`. If you pass text to any of the creation commands which has multiple lines, everything after the first line break will become the note.
 
+If a string passed to `now`, `later`, or `done` has a parenthetical at the end, the parenthetical will be removed from the title and its contents added as a note. So `doing now Working on @project1 (Adding some unit tests)` would create an entry titled "Working on @project1" with a note "Adding some unit tests." This is the equivalent of `doing now Working on @project1 -n "Adding some unit tests"`.
+
 #### Displaying entries:
 
     show      - List all entries
@@ -520,6 +529,18 @@ If you have a use for it, you can use `-o csv` on the show or view commands to o
 
 You can also show entries matching a search string with `doing grep` (synonym `doing search`). If you want to search with regular expressions or for an exact match, surround your search query with forward slashes, e.g. `doing search /project name/`. If you pass a search string without slashes, it's treated as a fuzzy search string, meaning matches can be found as long as the characters in the search string are in order and with no more than three other characters between each. By default searches are across all sections, but you can limit it to one with the `-s SECTION_NAME` flag. Searches can be displayed with the default template, or output as HTML, CSV, or JSON.
 
+##### Modifying the last entry
+
+If you want to make a change to the last entry added, use `doing last -e`. The `-e` flag opens the last entry (including note) in your editor, and when you close your editor, your doing file will be updated with any changes you made to the entry.
+
+You can choose the last entry in a specific section by including the `-s` flag, so `doing last -s Later -e` would edit the most recent entry in the Later section.
+
+You can also use text search or a tag filter to get an entry earlier than the most recent one. A tag search with `doing last --tag=project1 -e` will edit the last entry tagged `@project1`. Multiple tags can be combined with commas, and you can use `--bool` to specify whether the search is `AND` (matches all tags given), `OR` (matches any tag given), or `NOT` (matches none of the tags).
+
+You can edit the last entry that matches a search string with `--search=QUERY`. `QUERY` can either be a raw string, or you can surround it with slashes to search by regex (`doing last --search="/project./" -e`). If the string is raw text, fuzzy matching will be used, so the characters must be in order but can be separated by up to three other characters.
+
+Both `--tag` and `--search` can be constrained to a single section with `-s SECTION`.
+
 #### Views
 
     view     - Display a user-created view
@@ -583,12 +604,10 @@ Pressing Spacebar and typing allows you to add a new entry to currently. You an
 
 Point of interest, the LaunchBar Action makes use of the `-o json` flag for outputting JSON to the action's script for parsing.
 
-<!--GITHUB-->
-See <https://brettterpstra.com/projects/doing/> for the download.
+<!--GITHUB-->See <https://brettterpstra.com/projects/doing/> for the download.<!--END GITHUB-->
 <!--JEKYLL
 {% download 117 %} 
 -->
-<!--END GITHUB-->
 
 Evan Lovely has [created an Alfred workflow as well](http://www.evanlovely.com/blog/technology/alfred-for-terpstras-doing/).
 

data/bin/doing

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
 require 'gli'
 require 'doing'
@@ -7,9 +9,9 @@ require 'pp'
 
 def class_exists?(class_name)
   klass = Module.const_get(class_name)
-  return klass.is_a?(Class)
+  klass.is_a?(Class)
 rescue NameError
-  return false
+  false
 end
 
 if class_exists? 'Encoding'
@@ -17,19 +19,17 @@ if class_exists? 'Encoding'
   Encoding.default_internal = Encoding::UTF_8 if Encoding.respond_to?('default_internal')
 end
 
-
 include GLI::App
 version Doing::VERSION
 
 wwid = WWID.new
-if Dir.respond_to?('home')
-  wwid.user_home = Dir.home
-else
-  wwid.user_home = File.expand_path("~")
-end
+wwid.user_home = if Dir.respond_to?('home')
+                   Dir.home
+                 else
+                   File.expand_path('~')
+                 end
 wwid.configure
 
-
 program_desc 'A CLI for a What Was I Doing system'
 
 default_command :recent
@@ -42,330 +42,329 @@ desc 'Send results report to STDOUT instead of STDERR'
 switch [:stdout], default_value: false, negatable: false
 
 desc 'Exclude auto tags and default tags'
-switch [:x, :noauto], default_value: false
+switch %i[x noauto], default_value: false
 
 desc 'Use a specific configuration file'
-flag [:config_file]
-
-
-# desc 'Wrap notes at X chars (0 for no wrap)'
-# flag [:w, :wrapwidth], must_match: /^\d+$/, type: Integer
+flag [:config_file], default_value: wwid.config_file
 
 desc 'Specify a different doing_file'
-flag [:f, :doing_file]
+flag %i[f doing_file]
 
 desc 'Add an entry'
-arg_name 'entry'
+arg_name 'ENTRY'
 command [:now, :next] do |c|
   c.desc 'Section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: wwid.current_section
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor]
+  c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc 'Backdate start time [4pm|20m|2h|yesterday noon]'
-  c.flag [:b, :back]
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back]
 
   c.desc 'Timed entry, marks last entry in section as @done'
-  c.switch [:f, :finish_last], negatable: false, default_value: false
+  c.switch %i[f finish_last], negatable: false, default_value: false
 
   c.desc 'Note'
-  c.arg_name 'note_text'
-  c.flag [:n, :note]
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
 
   # c.desc "Edit entry with specified app"
   # c.arg_name 'editor_app'
   # # c.flag [:a, :app]
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, args|
     if options[:back]
       date = wwid.chronify(options[:back])
 
-      raise "Unable to parse date string" if date.nil?
+      raise 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
 
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
-    if options[:e] || (args.length == 0 && STDIN.stat.size == 0)
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-      input = ""
-      input += args.join(" ") if args.length > 0
-      input = wwid.fork_editor(input)
-      if input
-        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]})
-        wwid.write(wwid.doing_file)
-      else
-        raise "No content"
-      end
+    if options[:e] || (args.empty? && $stdin.stat.size.zero?)
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      input = ''
+      input += args.join(' ') unless args.empty?
+      input = wwid.fork_editor(input).strip
+
+      raise '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] })
+      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] })
+      wwid.write(wwid.doing_file)
+    elsif $stdin.stat.size.positive?
+      title, note = wwid.format_input($stdin.read)
+      note.push(options[:n]) if options[:n]
+      wwid.add_item(title.cap_first, section, { note: note, back: date, timed: options[:f] })
+      wwid.write(wwid.doing_file)
     else
-      if args.length > 0
-        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]})
-        wwid.write(wwid.doing_file)
-      elsif STDIN.stat.size > 0
-        title, note = wwid.format_input(STDIN.read)
-        note.push(options[:n]) if options[:n]
-        wwid.add_item(title.cap_first, section, {note: note, back: date, timed: options[:f]})
-        wwid.write(wwid.doing_file)
-      else
-        raise "You must provide content when creating a new entry"
-      end
+      raise 'You must provide content when creating a new entry'
     end
   end
 end
 
 desc 'Add a note to the last entry'
-long_desc %{
+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'
+)
+arg_name 'NOTE_TEXT'
 command :note do |c|
   c.desc 'Section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: "All"
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor], negatable: false, default_value: false
+  c.switch %i[e editor], negatable: false, default_value: false
 
   c.desc "Replace/Remove last entry's note (default append)"
-  c.switch [:r, :remove], negatable: false, default_value: false
+  c.switch %i[r remove], negatable: false, default_value: false
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
-    if options[:e] || (args.length == 0 && STDIN.stat.size == 0 && !options[:r])
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
+    if options[:e] || (args.empty? && $stdin.stat.size.zero? && !options[:r])
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
 
-      input = args.length > 0 ? args.join(" ") : ""
+      input = !args.empty? ? args.join(' ') : ''
 
-      prev_input = wwid.last_note(section) || ""
-      if prev_input.class == Array
-        prev_input = prev_input.join("\n")
-      end
+      prev_input = wwid.last_note(section) || ''
+      prev_input = prev_input.join("\n") if prev_input.instance_of?(Array)
       input = prev_input + input
 
-      input = wwid.fork_editor(input)
-      if input
-        title, note = wwid.format_input(input)
-        if note
-          wwid.note_last(section, note, replace: true)
-        else
-          raise "No note content"
-        end
-      else
-        raise "No content, cancelled"
-      end
+      input = wwid.fork_editor(input).strip
+      raise 'No content, cancelled' unless input
+
+      _title, note = wwid.format_input(input)
+
+      raise 'No note content' unless note
+
+      wwid.note_last(section, note, replace: true)
+    elsif !args.empty?
+      title, note = wwid.format_input(args.join(' '))
+      note.insert(0, title)
+      wwid.note_last(section, note, replace: options[:r])
+    elsif $stdin.stat.size.positive?
+      title, note = wwid.format_input($stdin.read)
+      note.insert(0, title)
+      wwid.note_last(section, note, replace: options[:r])
+    elsif options[:r]
+      wwid.note_last(section, [], replace: true)
     else
-      if args.length > 0
-        title, note = wwid.format_input(args.join(" "))
-        note.insert(0, title)
-        wwid.note_last(section, note, replace: options[:r])
-      elsif STDIN.stat.size > 0
-        title, note = wwid.format_input(STDIN.read)
-        note.insert(0, title)
-        wwid.note_last(section, note, replace: options[:r])
-      else
-        if options[:r]
-          wwid.note_last(section, [], replace: true)
-        else
-          raise "You must provide content when adding a note"
-        end
-      end
+      raise 'You must provide content when adding a note'
     end
     wwid.write(wwid.doing_file)
   end
 end
 
 desc 'Finish any running @meanwhile tasks and optionally create a new one'
-arg_name 'entry'
+arg_name 'ENTRY'
 command :meanwhile do |c|
   c.desc 'Section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: wwid.current_section
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor]
+  c.switch %i[e editor], negatable: false, default_value: false
 
-  c.desc "Archive previous @meanwhile entry"
-  c.switch [:a, :archive], default_value: false
+  c.desc 'Archive previous @meanwhile entry'
+  c.switch %i[a archive], default_value: false
 
   c.desc 'Backdate start date for new entry to date string [4pm|20m|2h|yesterday noon]'
-  c.flag [:b, :back]
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back]
 
   c.desc 'Note'
-  c.arg_name 'note_text'
-  c.flag [:n, :note]
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, args|
     if options[:back]
       date = wwid.chronify(options[:back])
 
-      raise "Unable to parse date string" if date.nil?
+      raise 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
 
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
-    input = ""
+    input = ''
 
     if options[:e]
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-      input += args.join(" ") if args.length > 0
-      input = wwid.fork_editor(input)
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      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
+    end
+
+    if input && !input.empty?
+      input, note = wwid.format_input(input)
     else
-      if args.length > 0
-        input = args.join(" ")
-      elsif STDIN.stat.size > 0
-        input = STDIN.read
-      end
+      input = nil
+      note = []
     end
-    input = false unless input && input.length > 0
 
-    note = options[:n] ? options[:n] : false
-    wwid.stop_start('meanwhile', {new_item: input, back: date, section: section, archive: options[:a], note: note})
+    if options[:n]
+      note.push(options[:n])
+    elsif note.empty?
+      note = nil
+    end
+
+    wwid.stop_start('meanwhile', { new_item: input, back: date, section: section, archive: options[:a], note: note })
     wwid.write(wwid.doing_file)
   end
 end
 
-desc 'Output HTML templates for customization'
-long_desc %{
-  Templates are printed to STDOUT for piping to a file. Save them and use them in the configuration file under html_template. Example `doing templates --type=HAML > ~/styles/my_doing.haml`
-}
-command :templates do |c|
-  c.desc "Type of template to output (HAML|CSS)"
-  c.arg_name 'template_type'
-  c.flag [:t, :type]
-
-  c.action do |global_options,options,args|
-    unless options[:type]
-      raise "No type specified, use --type=[HAML|CSS]"
+desc 'Output HTML and CSS templates for customization'
+long_desc %(
+  Templates are printed to STDOUT for piping to a file.
+  Save them and use them in the configuration file under html_template.
+
+  Example `doing template HAML > ~/styles/my_doing.haml`
+)
+arg_name 'TYPE', must_match: /^(html|haml|css)/i
+command :template do |c|
+  c.action do |_global_options, options, args|
+    raise 'No type specified, use `doing template [HAML|CSS]`' if args.empty?
+
+    case options[:t]
+    when /html|haml/i
+      $stdout.puts wwid.haml_template
+    when /css/i
+      $stdout.puts wwid.css_template
     else
-      if options[:t] =~ /html|haml/i
-        $stdout.puts wwid.haml_template
-      elsif options[:t] =~ /css/i
-        $stdout.puts wwid.css_template
-      else
-        raise "Invalid type specified, use --type=[HAML|CSS]"
-      end
+      raise 'Invalid type specified, must be HAML or CSS'
     end
   end
 end
 
-
 desc 'Add an item to the Later section'
-arg_name 'entry'
+arg_name 'ENTRY'
 command :later do |c|
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor]
+  c.switch %i[e editor], negatable: false, default_value: false
 
-  c.desc "Edit entry with specified app"
-  c.arg_name 'editor_app'
-  c.flag [:a, :app]
+  c.desc 'Edit entry with specified app'
+  c.arg_name 'APP'
+  c.flag %i[a app]
 
   c.desc 'Backdate start time to date string [4pm|20m|2h|yesterday noon]'
-  c.flag [:b, :back]
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back]
 
   c.desc 'Note'
-  c.arg_name 'note_text'
-  c.flag [:n, :note]
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, args|
     if options[:back]
       date = wwid.chronify(options[:back])
-      raise "Unable to parse date string" if date.nil?
+      raise 'Unable to parse date string' if date.nil?
     else
       date = Time.now
     end
 
-    if options[:e] || (args.length == 0 && STDIN.stat.size == 0)
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-      input = ""
-      input += args.join(" ") if args.length > 0
-      input = wwid.fork_editor(input)
-      if input
-        title, note = wwid.format_input(input)
-        note.push(options[:n]) if options[:n]
-        wwid.add_item(title.cap_first, "Later", {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      else
-        raise "No content"
-      end
+    if options[:e] || (args.empty? && $stdin.stat.size.zero?)
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      input = args.empty? ? '' : args.join(' ')
+      input = wwid.fork_editor(input).strip
+      raise 'No content' unless input && !input.empty?
+
+      title, note = wwid.format_input(input)
+      note.push(options[:n]) if options[:n]
+      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]
+      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]
+      wwid.add_item(title.cap_first, 'Later', { note: note, back: date })
+      wwid.write(wwid.doing_file)
     else
-      if args.length > 0
-        title, note = wwid.format_input(args.join(" "))
-        note.push(options[:n]) if options[:n]
-        wwid.add_item(title.cap_first, "Later", {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      elsif STDIN.stat.size > 0
-        title, note = wwid.format_input(STDIN.read)
-        note.push(options[:n]) if options[:n]
-        wwid.add_item(title.cap_first, "Later", {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      else
-        raise "You must provide content when creating a new entry"
-      end
+      raise 'You must provide content when creating a new entry'
     end
   end
 end
 
 desc 'Add a completed item with @done(date). No argument finishes last entry.'
-arg_name 'entry'
+arg_name 'ENTRY'
 command [:done, :did] do |c|
   c.desc 'Remove @done tag'
-  c.switch [:r, :remove], negatable: false, default_value: false
+  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 [:a, :archive], negatable: false, default_value: false
+  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). If used, ignores --back. Used with --took, backdates start date'
+  c.desc %(Set finish date to specific date/time (natural langauge parsed, e.g. --at=1:30pm).
+  If used, ignores --back. Used with --took, backdates start date)
+  c.arg_name 'DATE_STRING'
   c.flag [:at]
 
   c.desc 'Backdate start date by interval [4pm|20m|2h|yesterday noon]'
-  c.flag [:b, :back]
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back]
 
-  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.flag [:t, :took]
+  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]
 
   c.desc 'Section'
-  c.flag [:s, :section], default_value: wwid.current_section
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor]
+  c.switch %i[e editor], 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|
+  c.action do |_global_options, options, args|
     took = 0
 
-
     if options[:took]
       took = wwid.chronify_qty(options[:took])
-      raise "Unable to parse date string for --took" if took.nil?
+      raise 'Unable to parse date string for --took' if took.nil?
     end
 
     if options[:back]
       date = wwid.chronify(options[:back])
-      raise "Unable to parse date string for --back" if date.nil?
+      raise '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])
-      raise "Unable to parse date string for --at" if finish_date.nil?
+      raise '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
@@ -376,127 +375,147 @@ command [:done, :did] do |c|
     end
 
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
-    donedate = options[:date] ? "(#{finish_date.strftime('%F %R')})" : ""
+    donedate = options[:date] ? "(#{finish_date.strftime('%F %R')})" : ''
 
     if options[:e]
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-      input = ""
-      input += args.join(" ") if args.length > 0
-      input = wwid.fork_editor(input)
-      if input
-        title, note = wwid.format_input(input)
-        title += " @done#{donedate}"
-        section = "Archive" if options[:a]
-        wwid.add_item(title.cap_first, section.cap_first, {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      else
-        raise "No content"
-      end
-    elsif args.length == 0 && STDIN.stat.size == 0
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      input = ''
+      input += args.join(' ') unless args.empty?
+      input = wwid.fork_editor(input).strip
+      raise 'No content' unless input && !input.empty?
+
+      title, note = wwid.format_input(input)
+      title += " @done#{donedate}"
+      section = 'Archive' if options[:a]
+      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      wwid.write(wwid.doing_file)
+    elsif args.empty? && $stdin.stat.size.zero?
       if options[:r]
-        wwid.tag_last({tags: ["done"], count: 1, section: section, remove: true })
+        wwid.tag_last({ tags: ['done'], count: 1, section: section, remove: true })
       else
-        wwid.tag_last({tags: ["done"], count: 1, section: section, archive: options[:a], back: finish_date, date: options[:date]})
+        wwid.tag_last({ tags: ['done'], count: 1, section: section, archive: options[:a], back: finish_date,
+                        date: options[:date] })
       end
+    elsif !args.empty?
+      title, note = wwid.format_input(args.join(' '))
+      title.chomp!
+      title += " @done#{donedate}"
+      section = 'Archive' if options[:a]
+      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      wwid.write(wwid.doing_file)
+    elsif $stdin.stat.size.positive?
+      title, note = wwid.format_input($stdin.read)
+      title += " @done#{donedate}"
+      section = options[:a] ? 'Archive' : section
+      wwid.add_item(title.cap_first, section.cap_first, { note: note, back: date })
+      wwid.write(wwid.doing_file)
     else
-      if args.length > 0
-        title, note = wwid.format_input(args.join(" "))
-        title.chomp!
-        title += " @done#{donedate}"
-        section = "Archive" if options[:a]
-        wwid.add_item(title.cap_first, section.cap_first, {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      elsif STDIN.stat.size > 0
-        title, note = wwid.format_input(STDIN.read)
-        title += " @done#{donedate}"
-        section = options[:a] ? "Archive" : section
-        wwid.add_item(title.cap_first, section.cap_first, {note: note, back: date})
-        wwid.write(wwid.doing_file)
-      else
-        raise "You must provide content when creating a new entry"
-      end
+      raise 'You must provide content when creating a new entry'
     end
   end
 end
 
 desc 'End last X entries with no time tracked'
 long_desc 'Adds @done tag without datestamp so no elapsed time is recorded. Alias for `doing finish --no-date`.'
-arg_name 'count'
+arg_name 'COUNT'
 command :cancel do |c|
   c.desc 'Archive entries'
-  c.switch [:a, :archive], negatable: false, default_value: false
+  c.switch %i[a archive], negatable: false, default_value: false
 
   c.desc 'Section'
-  c.flag [:s, :section], default_value: wwid.current_section
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
-  c.desc 'Cancel the last X entries containing TAG. Separate multiple tags with comma (--tag=tag2,tag2)'
+  c.desc 'Cancel the last X entries containing TAG. Separate multiple tags with comma (--tag=tag1,tag2)'
+  c.arg_name 'TAG'
   c.flag [:tag]
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.arg_name 'BOOLEAN'
   c.flag [:bool], must_match: /^(and|or|not)$/i, default_value: 'AND'
 
-
-  c.action do |global_options,options,args|
-
+  c.action do |_global_options, options, args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
     if options[:tag].nil?
       tags = []
     else
-      tags = options[:tag].split(/ *, */).map {|t| t.strip.sub(/^@/, '') }
+      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
       options[:bool] = options[:bool] =~ /^(and|or|not)$/i ? options[:bool].upcase : 'AND'
     end
 
-    if args.length > 1
-      raise "Only one argument allowed"
-    elsif args.length == 0 || args[0] =~ /\d+/
-      count = args[0] ? args[0].to_i : 1
-      wwid.tag_last({tags: ["done"], count: count, section: section, archive: options[:a], sequential: false, date: false, tag: tags, tag_bool: options[:bool] })
-    else
-      raise "Invalid argument (specify number of recent items to mark @done)"
-    end
+    raise 'Only one argument allowed' if args.length > 1
+
+    raise 'Invalid argument (specify number of recent items to mark @done)' unless args.empty? || args[0] =~ /\d+/
+
+    count = args[0] ? args[0].to_i : 1
+    opts = {
+      archive: options[:a],
+      count: count,
+      date: false,
+      section: section,
+      sequential: false,
+      tag: tags,
+      tag_bool: options[:bool],
+      tags: ['done']
+    }
+    wwid.tag_last(opts)
   end
 end
 
 desc 'Mark last X entries as @done'
 long_desc 'Marks the last X entries with a @done tag and current date. Does not alter already completed entries.'
-arg_name 'count'
+arg_name 'COUNT'
 command :finish do |c|
   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.flag [:b, :back]
+  c.arg_name 'DATE_STRING'
+  c.flag %i[b back]
 
   c.desc 'Set the completed date to the start date plus XX[hmd]'
-  c.flag [:t, :took]
+  c.arg_name 'INTERVAL'
+  c.flag %i[t took]
 
-  c.desc 'Finish the last X entries containing TAG. Separate multiple tags with comma (--tag=tag2,tag2)'
+  c.desc 'Finish the last X entries containing TAG.
+  Separate multiple tags with comma (--tag=tag1,tag2), combine with --bool'
+  c.arg_name 'TAG'
   c.flag [:tag]
 
+  c.desc 'Finish the last X entries matching search filter, surround with slashes for regex (e.g. "/query.*/")'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.arg_name 'BOOLEAN'
   c.flag [:bool], must_match: /^(and|or|not)$/i, default_value: 'AND'
 
-  c.desc 'Auto-generate finish dates from next entry\'s start time. Automatically generate completion dates 1 minute before next start date. --auto overrides the --date and --back parameters.'
+  c.desc %(Auto-generate finish dates from next entry's start time.
+  Automatically generate completion dates 1 minute before next start date.
+  --auto overrides the --date and --back parameters.)
   c.switch [:auto], negatable: false, default_value: false
 
   c.desc 'Archive entries'
-  c.switch [:a, :archive], negatable: false, default_value: false
+  c.switch %i[a archive], negatable: false, default_value: false
 
   c.desc 'Section'
-  c.flag [:s, :section], default_value: wwid.current_section
-
-  c.action do |global_options,options,args|
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
+  c.action do |_global_options, options, args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
     unless options[:auto]
-      raise "--back and --took cannot be used together" if options[:back] and options[:took]
+      raise '--back and --took cannot be used together' if options[:back] && options[:took]
+
+      raise '--search and --tag cannot be used together' if options[:search] && options[:tag]
 
       if options[:back]
         date = wwid.chronify(options[:back])
 
-        raise "Unable to parse date string" if date.nil?
+        raise 'Unable to parse date string' if date.nil?
       elsif options[:took]
         date = wwid.chronify_qty(options[:took])
       else
@@ -507,201 +526,241 @@ command :finish do |c|
     if options[:tag].nil?
       tags = []
     else
-      tags = options[:tag].split(/ *, */).map {|t| t.strip.sub(/^@/, '') }
+      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
       options[:bool] = options[:bool] =~ /^(and|or|not)$/i ? options[:bool].upcase : 'AND'
     end
 
-    if args.length > 1
-      raise "Only one argument allowed"
-    elsif args.length == 0 || args[0] =~ /\d+/
-      count = args[0] ? args[0].to_i : 1
-      wwid.tag_last({ tags: ["done"],count: count,section: section,archive: options[:a],sequential: options[:auto],date: options[:date], back: date, tag: options[:tag], tag_bool: options[:bool] })
-    else
-      raise "Invalid argument (specify number of recent items to mark @done)"
-    end
+    raise 'Only one argument allowed' if args.length > 1
+
+    raise 'Invalid argument (specify number of recent items to mark @done)' unless args.length == 0 || args[0] =~ /\d+/
+
+    count = args[0] ? args[0].to_i : 1
+    opts = {
+      archive: options[:a],
+      back: date,
+      count: count,
+      date: options[:date],
+      search: options[:search],
+      section: section,
+      sequential: options[:auto],
+      tag: tags,
+      tag_bool: options[:bool],
+      tags: ['done']
+    }
+    wwid.tag_last(opts)
   end
 end
 
 desc 'Repeat last entry as new entry'
-arg_name 'section'
 command [:again, :resume] do |c|
   c.desc 'Section'
-  c.flag [:s, :section], default_value: "All"
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc 'Add new entry to section (default: same section as repeated entry)'
+  c.arg_name 'SECTION_NAME'
   c.flag [:in]
 
   c.desc 'Repeat last entry matching tags. Combine multiple tags with a comma.'
+  c.arg_name 'TAG'
   c.flag [:tag]
 
+  c.desc 'Repeat last entry matching search. Surround with
+  slashes for regex (e.g. "/query/").'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
   c.desc 'Boolean used to combine multiple tags'
+  c.arg_name 'BOOLEAN'
   c.flag [:bool], must_match: /^(and|or|not)$/i, default_value: 'ALL'
 
   c.desc 'Note'
-  c.arg_name 'note_text'
-  c.flag [:n, :note]
-
-  c.action do |global_options, options, args|
-    tags = options[:tag].nil? ? [] : options[:tag].split(/ *, */).map {|t| t.sub(/^@/, '').strip }
-    wwid.restart_last({ section: options[:s], note: options[:n], tag: tags, tag_bool: options[:bool], in: options[:in] })
+  c.arg_name 'TEXT'
+  c.flag %i[n note]
+
+  c.action do |_global_options, options, _args|
+    tags = options[:tag].nil? ? [] : options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }
+    opts = {
+      in: options[:in],
+      note: options[:n],
+      search: options[:search],
+      section: options[:s],
+      tag: tags,
+      tag_bool: options[:bool]
+    }
+    wwid.restart_last(opts)
   end
 end
 
-desc 'Tag last entry'
-arg_name 'tag1 [tag2...]'
+desc 'Add tag(s) to last entry'
+arg_name 'TAG', :multiple
 command :tag do |c|
   c.desc 'Section'
-  c.flag [:s, :section], default_value: 'All'
+  c.arg_name 'SECTION_NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc 'How many recent entries to tag (0 for all)'
-  c.flag [:c, :count], default_value: 1
+  c.arg_name 'COUNT'
+  c.flag %i[c count], default_value: 1
 
   c.desc 'Include current date/time with tag'
-  c.switch [:d, :date], negatable: false, default_value: false
+  c.switch %i[d date], negatable: false, default_value: false
 
   c.desc 'Remove given tag(s)'
-  c.switch [:r, :remove], negatable: false, default_value: false
+  c.switch %i[r remove], negatable: false, default_value: false
 
   c.desc 'Autotag entries based on autotag configuration in ~/.doingrc'
-  c.switch [:a, :autotag], negatable: false, default_value: false
+  c.switch %i[a autotag], negatable: false, default_value: false
 
-  c.action do |global_options,options,args|
-    if args.length == 0 && !options[:a]
-      raise "You must specify at least one tag"
-    else
-
-      section = wwid.guess_section(options[:s]) || options[:s].cap_first
+  c.action do |_global_options, options, args|
+    raise 'You must specify at least one tag' if args.empty? && !options[:a]
 
-      unless options[:a]
-        if args.join("") =~ /,/
-          tags = args.join("").split(/,/)
-        else
-          tags = args.join(" ").split(" ") # in case tags are quoted as one arg
-        end
+    section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
-        tags.map!{|tag| tag.sub(/^@/,'').strip }
-      else
-        tags = []
-      end
+    if options[:a]
+      tags = []
+    else
+      tags = if args.join('') =~ /,/
+               args.join('').split(/,/)
+             else
+               args.join(' ').split(' ') # in case tags are quoted as one arg
+             end
 
-      count = options[:c].to_i
+      tags.map! { |tag| tag.sub(/^@/, '').strip }
+    end
 
-      if count == 0
-        section_q = section == 'All' ? "" : " in section #{section}"
+    count = options[:c].to_i
 
-        if options[:a]
-          question = "Are you sure you want to autotag all records#{section_q}"
-        elsif options[:r]
-          question = "Are you sure you want to remove #{tags.join(" and ")} from all records#{section_q}"
-        else
-          question = "Are you sure you want to add #{tags.join(" and ")} to all records#{section_q}"
-        end
+    if count.zero?
+      section_q = section == 'All' ? '' : " in section #{section}"
 
-        res = wwid.yn(question, default_response: false)
+      question = if options[:a]
+                   "Are you sure you want to autotag all records#{section_q}"
+                 elsif options[:r]
+                   "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
 
-        unless res
-          raise "Cancelled"
-        end
-      end
+      res = wwid.yn(question, default_response: false)
 
-      wwid.tag_last({tags: tags, count: count, section: section, date: options[:date], remove: options[:r], autotag: options[:a]})
+      raise 'Cancelled' unless res
     end
+    opts = {
+      autotag: options[:a],
+      count: count,
+      date: options[:date],
+      remove: options[:r],
+      section: section,
+      tags: tags
+    }
+    wwid.tag_last(opts)
   end
 end
 
 desc 'Mark last entry as highlighted'
 command [:mark, :flag] do |c|
   c.desc 'Section'
-  c.flag [:s, :section], default_value: wwid.current_section
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: wwid.current_section
 
   c.desc 'Remove mark'
-  c.switch [:r, :remove], negatable: false, default_value: false
+  c.switch %i[r remove], negatable: false, default_value: false
 
-
-  c.action do |global_options,options,args|
-    mark = wwid.config['marker_tag'] || "flagged"
-    wwid.tag_last({tags: [mark], section: options[:s], remove: options[:r]})
+  c.action do |_global_options, options, _args|
+    mark = wwid.config['marker_tag'] || 'flagged'
+    wwid.tag_last({ tags: [mark], section: options[:s], remove: options[:r] })
   end
 end
 
 desc 'List all entries'
-long_desc 'The argument can be a section name, @tag(s) or both. "pick" or "choose" as an argument will offer a section menu.'
-arg_name '[section|@tags]'
+long_desc %(
+  The argument can be a section name, @tag(s) or both.
+  "pick" or "choose" as an argument will offer a section menu.
+)
+arg_name '[SECTION|@TAGS]'
 command :show do |c|
   c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.arg_name 'TAG'
   c.flag [:tag]
 
   c.desc 'Tag boolean (AND,OR,NONE)'
-  c.flag [:b, :bool], must_match: /^(and|or|not)$/i, default_value: 'OR'
+  c.arg_name 'BOOLEAN'
+  c.flag %i[b bool], must_match: /^(and|or|not)$/i, default_value: 'OR'
 
   c.desc 'Max count to show'
-  c.flag [:c, :count], default_value: 0
+  c.arg_name 'MAX'
+  c.flag %i[c count], default_value: 0
 
   c.desc 'Age (oldest/newest)'
-  c.flag [:a, :age], default_value: 'newest'
+  c.arg_name 'AGE'
+  c.flag %i[a age], default_value: 'newest'
 
   c.desc 'Sort order (asc/desc)'
-  c.flag [:s, :sort], default_value: 'asc'
+  c.arg_name 'ORDER'
+  c.flag %i[s sort], must_match: /^(a|d)/i, default_value: 'ASC'
 
-  c.desc %{
+  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.flag [:f, :from]
+  )
+  c.arg_name 'DATE_OR_RANGE'
+  c.flag %i[f from]
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)/i, default_value: default
 
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
-  c.action do |global_options,options,args|
-
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
+  c.action do |_global_options, options, args|
     tag_filter = false
     tags = []
-    if args.length > 0
-      if args[0] =~ /^all$/i
-        section = "All"
+    if args.length.positive?
+      case args[0]
+      when /^all$/i
+        section = 'All'
         args.shift
-      elsif args[0] =~ /^(choose|pick)$/i
+      when /^(choose|pick)$/i
         section = wwid.choose_section
         args.shift
-      elsif args[0] =~ /^@/
-        section = "All"
+      when /^@/
+        section = 'All'
       else
         section = wwid.guess_section(args[0])
         raise "No such section: #{args[0]}" unless section
+
         args.shift
       end
-      if args.length > 0
-        args.each {|arg|
+      if args.length.positive?
+        args.each do |arg|
           if arg =~ /,/
-            arg.split(/,/).each {|tag|
-              tags.push(tag.strip.sub(/^@/,''))
-            }
+            arg.split(/,/).each do |tag|
+              tags.push(tag.strip.sub(/^@/, ''))
+            end
           else
-            tags.push(arg.strip.sub(/^@/,''))
+            tags.push(arg.strip.sub(/^@/, ''))
           end
-        }
+        end
       end
     else
       section = wwid.current_section
     end
 
-    tags.concat(options[:tag].split(/ *, */).map {|t| t.sub(/^@/, '').strip }) if options[:tag]
+    tags.concat(options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if options[:tag]
 
     unless tags.empty?
       tag_filter = {
@@ -720,96 +779,127 @@ command :show do |c|
         start = wwid.chronify(date_string)
         finish = false
       end
-      exit_now! "Unrecognized date string" unless start
+      exit_now! 'Unrecognized date string' unless start
       dates = [start, finish]
     end
 
     options[:t] = true if options[:totals]
 
-    options[:sort_tags] = options[:tag_sort] =~ /^n/i
-
-    puts wwid.list_section({section: section, date_filter: dates, count: options[:c].to_i, tag_filter: tag_filter, age: options[:a], order: options[:s], output: options[:output], times: options[:t], totals: options[:totals], sort_tags: options[:sort_tags], highlight: true, only_timed: options[:only_timed]})
+    tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
 
+    options[:sort_tags] = options[:tag_sort] =~ /^n/i
+    opts = {
+      age: options[:a],
+      count: options[:c].to_i,
+      date_filter: dates,
+      highlight: true,
+      only_timed: options[:only_timed],
+      order: options[:s],
+      output: options[:output],
+      section: section,
+      sort_tags: options[:sort_tags],
+      tag_filter: tag_filter,
+      tags_color: tags_color,
+      times: options[:t],
+      totals: options[:totals]
+    }
+    puts wwid.list_section(opts)
   end
 end
 
 desc 'Search for entries'
-long_desc <<-'EODESC'
-Search all sections (or limit to a single section) for entries matching text or regular expression. Normal strings are fuzzy matched.
+long_desc <<~'EODESC'
+  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/'`
+  To search with regular expressions, single quote the string and surround with slashes: `doing search '/\bm.*?x\b/'`
 EODESC
 
-arg_name 'search_pattern'
+arg_name 'SEARCH_PATTERN'
 command [:grep, :search] do |c|
   c.desc 'Section'
-  c.flag [:s, :section], default_value: "All"
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: false
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, args|
+    tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
 
     section = wwid.guess_section(options[:s]) if options[:s]
 
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    puts wwid.list_section({search: args.join(' '), section: section, output: options[:output], times: options[:t], highlight: true, totals: options[:totals], only_timed: options[:only_timed], sort_tags: options[:sort_tags]})
+    opts = {
+      highlight: true,
+      only_timed: options[:only_timed],
+      output: options[:output],
+      search: args.join(' '),
+      section: section,
+      sort_tags: options[:sort_tags],
+      tags_color: tags_color,
+      times: options[:t],
+      totals: options[:totals]
+    }
 
+    puts wwid.list_section(opts)
   end
 end
 
 desc 'List recent entries'
 default_value 10
-arg_name 'count'
+arg_name 'COUNT'
 command :recent do |c|
   c.desc 'Section'
-  c.flag [:s, :section], default_value: "All"
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
-
-  c.action do |global_options,options,args|
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
+  c.action do |global_options, options, args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
 
     unless global_options[:version]
-      if args.length > 0
-        count = args[0].to_i
-      else
-        count = 10
-      end
+      count = args.empty? ? 10 : args[0].to_i
       options[:t] = true if options[:totals]
       options[:sort_tags] = options[:tag_sort] =~ /^n/i
+      tags_color = wwid.config.key?('tags_color') ? wwid.config['tags_color'] : nil
 
-      puts wwid.recent(count,section.cap_first,{ times: options[:t], totals: options[:totals], sort_tags: options[:sort_tags] })
+      opts = {
+        sort_tags: options[:sort_tags],
+        tags_color: tags_color,
+        times: options[:t],
+        totals: options[:totals]
+      }
+
+      puts wwid.recent(count, section.cap_first, opts)
 
     end
   end
@@ -818,63 +908,64 @@ end
 desc 'List entries from today'
 command :today do |c|
   c.desc 'Specify a section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: 'All'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
-
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
-  c.action do |global_options,options,args|
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
 
+  c.action do |_global_options, options, _args|
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    puts wwid.today(options[:t], options[:output], {totals: options[:totals], section: options[:s], sort_tags: options[:sort_tags]}).chomp
-
+    puts wwid.today(options[:t], options[:output],
+                    { totals: options[:totals], section: options[:s], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
 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'
+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.desc 'Section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: 'All'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
 
-  c.action do |global_options,options,args|
-    exit_now! "Missing date argument" if args.empty?
+  c.action do |_global_options, options, args|
+    exit_now! 'Missing date argument' if args.empty?
 
-    date_string = args.join(" ")
+    date_string = args.join(' ')
 
     if date_string =~ / (to|through|thru) /
       dates = date_string.split(/ (to|through|thru) /)
@@ -885,7 +976,7 @@ command :on do |c|
       finish = false
     end
 
-    exit_now! "Unrecognized date string" unless start
+    exit_now! 'Unrecognized date string' unless start
 
     message = "Date interpreted as #{start}"
     message += " to #{finish}" if finish
@@ -894,56 +985,86 @@ command :on do |c|
     options[:t] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-    puts wwid.list_date([start, finish], options[:s], options[:t], options[:output], {totals: options[:totals], sort_tags: options[:sort_tags]}).chomp
-
+    puts wwid.list_date([start, finish], options[:s], options[:t], options[:output],
+                        { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
 desc 'List entries from yesterday'
 command :yesterday do |c|
   c.desc 'Specify a section'
-  c.arg_name 'section_name'
-  c.flag [:s, :section], default_value: 'All'
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show time totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
-  c.action do |global_options, options,args|
+  c.action do |_global_options, options, _args|
     options[:sort_tags] = options[:tag_sort] =~ /^n/i
-    puts wwid.yesterday(options[:s], options[:t], options[:o],{ totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
-
+    puts wwid.yesterday(options[:s], options[:t], options[:o],
+                        { totals: options[:totals], sort_tags: options[:sort_tags] }).chomp
   end
 end
 
-desc 'Show the last entry'
+desc 'Show the last entry, optionally edit'
 command :last do |c|
   c.desc 'Specify a section'
-  c.flag [:s, :section]
+  c.arg_name 'NAME'
+  c.flag %i[s section], default_value: 'All'
 
-  c.action do |global_options,options,args|
-    puts wwid.last(true,options[:s]).strip
+  c.desc "Edit entry with #{ENV['EDITOR']}"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.desc 'Tag filter, combine multiple tags with a comma.'
+  c.arg_name 'TAG'
+  c.flag [:tag]
+
+  c.desc 'Tag boolean'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: /(and|or|not)/i, default_value: 'AND'
+
+  c.desc 'Search filter, surround with slashes for regex (/query/)'
+  c.arg_name 'QUERY'
+  c.flag [:search]
+
+  c.action do |_global_options, options, _args|
+    raise '--tag and --search cannot be used together' if options[:tag] && options[:search]
+
+    if options[:tag].nil?
+      tags = []
+    else
+      tags = options[:tag].split(/ *, */).map { |t| t.strip.sub(/^@/, '') }
+      options[:bool] = options[:bool] =~ /^(and|or|not)$/i ? options[:bool].upcase : 'AND'
+    end
+
+    if options[:e]
+      wwid.edit_last(section: options[:s], options: { search: options[:search], tag: tags, tag_bool: options[:bool] })
+    else
+      puts wwid.last(times: true, section: options[:s],
+                     options: { search: options[:search], tag: tags, tag_bool: options[:bool] }).strip
+    end
   end
 end
 
 desc 'List sections'
 command :sections do |c|
   c.desc 'List in single column'
-  c.switch [:c, :column], default_value: false
+  c.switch %i[c column], default_value: false
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, _args|
     joiner = options[:c] ? "\n" : "\t"
     print wwid.sections.join(joiner)
   end
@@ -951,57 +1072,58 @@ end
 
 desc 'Select a section to display from a menu'
 command :choose do |c|
-  c.action do |global_options,options,args|
+  c.action do |_global_options, _options, _args|
     section = wwid.choose_section
     puts wwid.list_section({ section: section.cap_first, count: 0 })
   end
 end
 
 desc 'Add a new section to the "doing" file'
-arg_name 'section_name'
+arg_name 'SECTION_NAME'
 command :add_section do |c|
-  c.action do |global_options,options,args|
-    unless wwid.sections.include?(args[0])
-      wwid.add_section(args[0].cap_first)
-      wwid.write(wwid.doing_file)
-    else
-      raise "Section #{args[0]} already exists"
-    end
+  c.action do |_global_options, _options, args|
+    raise "Section #{args[0]} already exists" if wwid.sections.include?(args[0])
+
+    wwid.add_section(args[0].cap_first)
+    wwid.write(wwid.doing_file)
   end
 end
 
 desc 'List available color variables for configuration templates and views'
 command :colors do |c|
-  c.action do |global_options,options,args|
+  c.action do |_global_options, _options, _args|
     clrs = wwid.colors
     bgs = []
     fgs = []
-    clrs.each {|k,v|
+    clrs.each do |k, v|
       if k =~ /bg/
         bgs.push("#{v}    #{clrs['default']} <-- #{k}")
       else
         fgs.push("#{v}XXXX#{clrs['default']} <-- #{k}")
       end
-    }
+    end
     puts fgs.join("\n")
     puts bgs.join("\n")
   end
 end
 
 desc 'Display a user-created view'
-arg_name 'view_name'
+arg_name 'VIEW_NAME'
 command :view do |c|
   c.desc 'Section (override view settings)'
-  c.flag [:s, :section]
+  c.arg_name 'NAME'
+  c.flag %i[s section]
 
   c.desc 'Count to display (override view settings)'
-  c.flag [:c, :count], must_match: /^\d+$/, type: Integer
+  c.arg_name 'COUNT'
+  c.flag %i[c count], must_match: /^\d+$/, type: Integer
 
-  c.desc 'Output to export format (csv|html|json)'
-  c.flag [:o, :output]
+  c.desc 'Output to export format (csv|html|json|template|timeline)'
+  c.arg_name 'FORMAT'
+  c.flag %i[o output], must_match: /^(template|html|csv|json|timeline)$/i
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], default_value: true
+  c.switch %i[t times], default_value: true
 
   c.desc 'Show intervals with totals at the end of output'
   c.switch [:totals], default_value: false, negatable: true
@@ -1011,67 +1133,84 @@ command :view do |c|
 
   c.desc 'Sort tags by (name|time)'
   default = 'time'
-  if wwid.config.has_key?('tag_sort')
-    default = wwid.config['tag_sort']
-  end
-  c.flag [:tag_sort], default_value: default
+  default = wwid.config['tag_sort'] if wwid.config.key?('tag_sort')
+  c.arg_name 'KEY'
+  c.flag [:tag_sort], must_match: /^(name|time)$/i, default_value: default
 
   c.desc 'Only show items with recorded time intervals'
   c.switch [:only_timed], default_value: false, negatable: true
 
-  c.action do |global_options,options,args|
-    if args.empty?
-      title = wwid.choose_view
-    else
-      title = wwid.guess_view(args[0])
-    end
+  c.action do |_global_options, options, args|
+    title = if args.empty?
+              wwid.choose_view
+            else
+              wwid.guess_view(args[0])
+            end
 
-    if options[:s]
-      section = wwid.guess_section(options[:s]) || options[:s].cap_first
-    end
+    section = wwid.guess_section(options[:s]) || options[:s].cap_first if options[:s]
 
     view = wwid.get_view(title)
     if view
-      if (view.has_key?('only_timed') && view['only_timed']) || options[:only_timed]
-        only_timed = true
-      else
-        only_timed = false
-      end
-
-      template = view.has_key?('template') ? view['template'] : nil
-      format = view.has_key?('date_format') ? view['date_format'] : nil
-      tags_color = view.has_key?('tags_color') ? view['tags_color'] : nil
+      only_timed = if (view.key?('only_timed') && view['only_timed']) || options[:only_timed]
+                     true
+                   else
+                     false
+                   end
+
+      template = view.key?('template') ? view['template'] : nil
+      format = view.key?('date_format') ? view['date_format'] : nil
+      tags_color = view.key?('tags_color') ? view['tags_color'] : nil
       tag_filter = false
-      if view.has_key?('tags')
-        unless view['tags'].nil? || view['tags'].empty?
-          tag_filter = {'tags' => [], 'bool' => 'OR'}
-          if view['tags'].class == Array
-            tag_filter['tags'] = view['tags'].map{|tag| tag.strip }
-          else
-            tag_filter['tags'] = view['tags'].gsub(/[, ]+/," ").split(" ").map{|tag| tag.strip }
-          end
-          tag_filter['bool'] = view.has_key?('tags_bool') && !view['tags_bool'].nil? ? view['tags_bool'].upcase : "OR"
-        end
+      if view.key?('tags') && !(view['tags'].nil? || view['tags'].empty?)
+        tag_filter = { 'tags' => [], 'bool' => 'OR' }
+        tag_filter['tags'] = if view['tags'].instance_of?(Array)
+                               view['tags'].map(&:strip)
+                             else
+                               view['tags'].gsub(/[, ]+/, ' ').split(' ').map(&:strip)
+                             end
+        tag_filter['bool'] = view.key?('tags_bool') && !view['tags_bool'].nil? ? view['tags_bool'].upcase : 'OR'
       end
 
       # If the -o/--output flag was specified, override any default in the view template
-      options[:o] ||= view.has_key?('output_format') ? view['output_format'] : "template"
-
-      count = options[:c] ? options[:c] : view.has_key?('count') ? view['count'] : 10
-      section = options[:s] ? section : view.has_key?('section') ? view['section'] : wwid.current_section
-      order = view.has_key?('order') ? view['order'] : "asc"
+      options[:o] ||= 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]
+                  section
+                else
+                  view.key?('section') ? view['section'] : wwid.current_section
+                end
+      order = view.key?('order') ? view['order'] : 'asc'
 
       options[:t] = true if options[:totals]
-      options[:output].downcase! if options[:output]
+      options[:output]&.downcase!
       options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-      puts wwid.list_section({section: section, count: count, template: template, format: format, order: order, tag_filter: tag_filter, output: options[:o], tags_color: tags_color, times: options[:t], highlight: options[:color], totals: options[:totals], only_timed: only_timed, sort_tags: options[:sort_tags] })
+      opts = {
+        count: count,
+        format: format,
+        highlight: options[:color],
+        only_timed: only_timed,
+        order: order,
+        output: options[:o],
+        section: section,
+        sort_tags: options[:sort_tags],
+        tag_filter: tag_filter,
+        tags_color: tags_color,
+        template: template,
+        times: options[:t],
+        totals: options[:totals]
+      }
+
+      puts wwid.list_section(opts)
+    elsif title.instance_of?(FalseClass)
+      exit_now! 'Cancelled'
     else
-      if title.class == FalseClass
-        exit_now! "Cancelled"
-      else
-        raise "View #{title} not found in config"
-      end
+      raise "View #{title} not found in config"
     end
   end
 end
@@ -1079,130 +1218,135 @@ end
 desc 'List available custom views'
 command :views do |c|
   c.desc 'List in single column'
-  c.switch [:c, :column], default_value: false
+  c.switch %i[c column], default_value: false
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, _args|
     joiner = options[:c] ? "\n" : "\t"
     print wwid.views.join(joiner)
   end
 end
 
 desc 'Move entries between sections'
-arg_name 'section'
+arg_name 'SECTION_NAME'
 default_value wwid.current_section
 command :archive do |c|
   c.desc 'Count to keep (ignored if archiving by tag)'
-  c.flag [:k, :keep], default_value: 5, must_match: /^\d+$/, type: Integer
+  c.arg_name 'COUNT'
+  c.flag %i[k keep], default_value: 5, must_match: /^\d+$/, type: Integer
 
   c.desc 'Move entries to'
-  c.flag [:t, :to], default_value: 'Archive'
+  c.arg_name 'SECTION_NAME'
+  c.flag %i[t to], default_value: 'Archive'
 
   c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.arg_name 'TAG'
   c.flag [:tag]
 
-  c.desc 'Tag boolean'
-  c.flag [:b, :bool], must_match: /(and|or|not)/i, default_value: 'AND'
+  c.desc 'Tag boolean (AND|OR|NOT)'
+  c.arg_name 'BOOLEAN'
+  c.flag [:bool], must_match: /(and|or|not)/i, default_value: 'AND'
 
-  c.action do |global_options,options,args|
-    if args.length > 0
-      if args[0] =~ /^@\S+/
-        section = "all"
-        tags = args.map {|t| t.sub(/^@/,'').strip }
-      else
-        section = args[0].cap_first
-        tags = args.length > 1 ? args[1..-1].map {|t| t.sub(/^@/, '').strip } : nil
-      end
-    else
+  c.action do |_global_options, options, args|
+    if args.empty?
       section = wwid.current_section
       tags = []
+    elsif args[0] =~ /^@\S+/
+      section = 'all'
+      tags = args.map { |t| t.sub(/^@/, '').strip }
+    else
+      section = args[0].cap_first
+      tags = args.length > 1 ? args[1..].map { |t| t.sub(/^@/, '').strip } : nil
     end
 
-    tags.concat(options[:tag].split(/ *, */).map {|t| t.sub(/^@/, '').strip }) if options[:tag]
+    tags.concat(options[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if options[:tag]
 
-    wwid.archive(section, options[:k], options[:t], tags, options[:b])
+    wwid.archive(section, options[:keep], options[:to], tags, options[:bool])
   end
 end
 
 desc 'Open the "doing" file in an editor'
+long_desc "`doing open` defaults to using the editor_app setting in #{wwid.config_file} (#{wwid.config.key?('editor_app') ? wwid.config['editor_app'] : 'not set'})"
 command :open do |c|
-if `uname` =~ /Darwin/
-  c.desc 'open with app name'
-  c.arg_name 'app_name'
-  c.flag [:a]
-
-  c.desc 'open with app bundle id'
-  c.arg_name 'bundle_id'
-  c.flag [:b]
-end
-  c.desc 'open with $EDITOR'
-  c.switch [:e], negatable: false
+  if `uname` =~ /Darwin/
+    c.desc 'Open with app name'
+    c.arg_name 'APP_NAME'
+    c.flag [:a]
 
-  c.action do |global_options,options,args|
+    c.desc 'Open with app bundle id'
+    c.arg_name 'BUNDLE_ID'
+    c.flag [:b]
+  end
+  c.desc "Open with $EDITOR (#{ENV['EDITOR']})"
+  c.switch %i[e editor], negatable: false, default_value: false
+
+  c.action do |_global_options, options, _args|
     params = options.dup
-    params.delete_if { |k,v|
-      k.class == String || v.nil? || v == false
-    }
+    params.delete_if do |k, v|
+      k.instance_of?(String) || v.nil? || v == false
+    end
     if `uname` =~ /Darwin/
-    if params.length < 2
       if options[:a]
-        system %Q{open -a "#{options[:a]}" "#{File.expand_path(wwid.doing_file)}"}
+        system %(open -a "#{options[:a]}" "#{File.expand_path(wwid.doing_file)}")
       elsif options[:b]
-        system %Q{open -b "#{options[:b]}" "#{File.expand_path(wwid.doing_file)}"}
+        system %(open -b "#{options[:b]}" "#{File.expand_path(wwid.doing_file)}")
       elsif options[:e]
-        raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-        system %Q{$EDITOR "#{File.expand_path(wwid.doing_file)}"}
+        raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+        system %($EDITOR "#{File.expand_path(wwid.doing_file)}")
+      elsif wwid.config.key?('editor_app') && !wwid.config['editor_app'].nil?
+        system %(open -a "#{wwid.config['editor_app']}" "#{File.expand_path(wwid.doing_file)}")
       else
-        if wwid.config.has_key?('editor_app') && !wwid.config['editor_app'].nil?
-          system %Q{open -a "#{wwid.config['editor_app']}" "#{File.expand_path(wwid.doing_file)}"}
-        else
-          system %Q{open "#{File.expand_path(wwid.doing_file)}"}
-        end
+        system %(open "#{File.expand_path(wwid.doing_file)}")
       end
+
     else
-      raise "The open command takes a single parameter. #{params.length} specified."
-    end
-    else
-      raise "No EDITOR variable defined in environment" if ENV['EDITOR'].nil?
-      system %Q{$EDITOR "#{File.expand_path(wwid.doing_file)}"}
+      raise 'No EDITOR variable defined in environment' if ENV['EDITOR'].nil?
+
+      system %($EDITOR "#{File.expand_path(wwid.doing_file)}")
     end
   end
 end
 
-
 desc 'Edit the configuration file'
 command :config do |c|
   c.desc 'Editor to use'
-  c.flag [:e, :editor], default_value: nil
+  c.arg_name 'EDITOR'
+  c.flag %i[e editor], default_value: nil
 
-  if `uname` =~ /Darwins/
+  if `uname` =~ /Darwin/
     c.desc 'Application to use'
+    c.arg_name 'APP_NAME'
     c.flag [:a]
 
-    c.desc "Use the editor_app defined in ~/.doingrc (#{wwid.config['editor_app']})"
-    c.switch [:x]
-
     c.desc 'Application bundle id to use'
+    c.arg_name 'BUNDLE_ID'
     c.flag [:b]
+
+    c.desc "Use the config_editor_app defined in ~/.doingrc (#{wwid.config.key?('config_editor_app') ? wwid.config['config_editor_app'] : 'config_editor_app not set'})"
+    c.switch [:x]
   end
-  c.action do |global_options,options,args|
-    if `uname` =~ /Darwins/
+
+  c.action do |_global_options, options, _args|
+    if `uname` =~ /Darwin/
       if options[:x]
-        %x{open -a "#{wwid.config['editor_app']}" "#{wwid.config_file}"}
+        `open -a "#{wwid.config['config_editor_app']}" "#{wwid.config_file}"`
       elsif options[:a] || options[:b]
         if options[:a]
-          %x{open -a "#{options[:a]}" "#{wwid.config_file}"}
+          `open -a "#{options[:a]}" "#{wwid.config_file}"`
         elsif options[:b]
-          %x{open -b #{options[:b]} "#{wwid.config_file}"}
+          `open -b #{options[:b]} "#{wwid.config_file}"`
         end
       else
-        raise "No EDITOR variable defined in environment" if options[:e].nil? && ENV['EDITOR'].nil?
+        raise 'No EDITOR variable defined in environment' if options[:e].nil? && ENV['EDITOR'].nil?
+
         editor = options[:e].nil? ? ENV['EDITOR'] : options[:e]
-        system %Q{#{editor} "#{wwid.config_file}"}
+        system %(#{editor} "#{wwid.config_file}")
       end
     else
-      raise "No EDITOR variable defined in environment" if options[:e].nil? && ENV['EDITOR'].nil?
+      raise 'No EDITOR variable defined in environment' if options[:e].nil? && ENV['EDITOR'].nil?
+
       editor = options[:e].nil? ? ENV['EDITOR'] : options[:e]
-      system %Q{#{editor} "#{wwid.config_file}"}
+      system %(#{editor} "#{wwid.config_file}")
     end
   end
 end
@@ -1210,19 +1354,19 @@ end
 desc 'Undo the last change to the doing_file'
 command :undo do |c|
   c.desc 'Specify alternate doing file'
-  c.flag [:f, :file], default_value: wwid.doing_file
+  c.arg_name 'PATH'
+  c.flag %i[f file], default_value: wwid.doing_file
 
-  c.action do |global_options,options,args|
+  c.action do |_global_options, options, _args|
     file = options[:f] || wwid.doing_file
     wwid.restore_backup(file)
   end
 end
 
-
-pre do |global,command,options,args|
+pre do |global, _command, _options, _args|
   if global[:config_file]
     wwid.config_file = global[:config_file]
-    wwid.configure({ignore_local: true})
+    wwid.configure({ ignore_local: true })
     # wwid.results.push("Override config file #{wwid.config_file}")
   end
 
@@ -1236,9 +1380,7 @@ pre do |global,command,options,args|
 
   wwid.config[:include_notes] = false unless global[:notes]
 
-  if global[:version]
-    $stdout.puts "doing v" + Doing::VERSION
-  end
+  $stdout.puts "doing v#{Doing::VERSION}" if global[:version]
 
   # Return true to proceed; false to abort and not call the
   # chosen command
@@ -1247,7 +1389,7 @@ pre do |global,command,options,args|
   true
 end
 
-post do |global,command,options,args|
+post do |global, _command, _options, _args|
   # Use skips_post before a command to skip this
   # block on that command only
   if global[:stdout]
@@ -1257,7 +1399,7 @@ post do |global,command,options,args|
   end
 end
 
-on_error do |exception|
+on_error do |_exception|
   # puts exception.message
   true
 end