doing 1.0.52 → 1.0.53

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab98c4f6aa3c2c5d3ccdb29a7b5f78a5f8adc67d12e9628e81b53316a10bc66c
-  data.tar.gz: dbe47b1b6b15d3d067a34f77b51b5f44b6137bd6f3cd89eccf4dd1909681ad32
+  metadata.gz: f55781d1fff1b59e4f2b495bc93235006e9b72aaa5ad51b0faeb55e332006570
+  data.tar.gz: b113d0e0ddf72bd2b56de7121414ec4cdc2ad5dfc9ced9f45d3f1ccb82381639
 SHA512:
-  metadata.gz: 31b94d0107fae62ca3f8b791173d3ea36be2ba8a09f6a4c27f1c75ac9f75a3840f83d0ce13eb11ddcaee05d305e35d5f15acd4d285936cf673e34d320b0db8d5
-  data.tar.gz: 48e17f344c27e38c82272906f082ee78dbb7be36fcc66b76de1c784ad2ab845ff54398c73624a83eaa883f5780264eb026c4a9b6443f60af7bbb55e06d5e1bb7
+  metadata.gz: cf665e041da4ac7ef3d6ce676620db8e055df2d72e963e84635b8af28267c36e90882409df824aa041df11177ff96b67f721512b0ce32931bcef6c36b54dc7e7
+  data.tar.gz: 4450964dfdda9b69d1a0f41429e7780a6726bb81875773b090a2de346fd751e777a52f890228ac100e9d0d82354b682f74c391971f3e6785386e80d911d18759

data/README.md

@@ -17,6 +17,7 @@ _If you're one of the rare people like me who find this useful, feel free to [bu
 - [Changelog](#changelog)
 
 <!-- end toc -->
+<!--README-->
 
 ## What and why
 
@@ -413,6 +414,8 @@ When used with `doing done`, `--back` and `--took` allow time intervals to be ac
 
 All of these commands accept a `-e` argument. This opens your command line editor (as defined in the environment variable `$EDITOR`). Add your entry, save the temp file, and close it. The new entry is added. Anything after the first line is included as a note on the entry.
 
+`doing again` (or `doing resume`) will duplicate the last @done entry (most recently completed) with a new start date (and without the @done tag). To resume the last entry matching specific tags, use `--tag=TAG`. You can specify multiple tags by separating with a comma. Multiple tags are combined with 'AND' by default (all tags must exist on the entry to match), but you can use `--bool=` to set it to 'OR' or 'NOT'. By default the new entry will be added to the same section as the matching entry, but you can specify a section with `--in=SECTION`.
+
 `doing meanwhile` is a special command for creating and finishing tasks that may have other entries come before they're complete. When you create an entry with `doing meanwhile [entry text]`, it will automatically complete the last _@meanwhile_ item (dated _@done_ tag) and add the _@meanwhile_ tag to the new item. This allows time tracking on a more general basis, and still lets you keep track of the smaller things you do while working on an overarching project. The `meanwhile` command accepts `--back [time]` and will backdate the _@done_ tag and start date of the new task at the same time. Running `meanwhile` with no arguments will simply complete the last _@meanwhile_ task. 
 
 See `doing help meanwhile` for more options.
@@ -438,9 +441,9 @@ You can finish the last entry containing a specific tag or combination of tags u
 
     doing finish --tag=work,project1
 
-You can change the boolean using `--tag_bool=OR` (last entry containing any of the specified tags) or `--tag_bool=NOT` (last entry containing none of the tags).
+You can change the boolean using `--bool=OR` (last entry containing any of the specified tags) or `--bool=NOT` (last entry containing none of the tags).
 
-You can also include a `--no-date` switch to add `@done` without a finish date, meaning no time is tracked for the task. `doing cancel` is an alias for this. Like `finish`, `cancel` accepts a count to act on the last X entries, as well as `--archive` and `--section` options.
+You can also include a `--no-date` switch to add `@done` without a finish date, meaning no time is tracked for the task. `doing cancel` is an alias for this. Like `finish`, `cancel` accepts a count to act on the last X entries, as well as `--archive` and `--section` options. `cancel` also accepts the `--tag` and `--bool` flags for tag filtering.
 
 
 ##### Tagging and Autotagging
@@ -621,7 +624,9 @@ Please try not to email me directly about GitHub projects.
 
 Feel free to [poke around](http://github.com/ttscoff/doing/), I'll try to add more comments in the future (and retroactively).
 
-{% donate doing now sending coffee money to Brett. %}
+<!--END README-->
+
+PayPal link: [paypal.me/ttscoff](https://paypal.me/ttscoff)
 
 ## Changelog
 

data/bin/doing

@@ -36,23 +36,20 @@ default_command :recent
 # sort_help :manually
 
 desc 'Output notes if included in the template'
-default_value true
-switch [:notes], :default_value => true, :negatable => true
+switch [:notes], default_value: true, negatable: true
 
 desc 'Send results report to STDOUT instead of STDERR'
-default_value false
-switch [:stdout], :default_value => false, :negatable => false
+switch [:stdout], default_value: false, negatable: false
 
 desc 'Exclude auto tags and default tags'
-switch [:x, :noauto], :default_value => false
+switch [:x, :noauto], default_value: false
 
 desc 'Use a specific configuration file'
-default_value false
 flag [:config_file]
 
 
 # desc 'Wrap notes at X chars (0 for no wrap)'
-# flag [:w, :wrapwidth], :must_match => /^\d+$/, :type => Integer
+# flag [:w, :wrapwidth], must_match: /^\d+$/, type: Integer
 
 desc 'Specify a different doing_file'
 flag [:f, :doing_file]
@@ -62,7 +59,7 @@ 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.flag [:s, :section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
   c.switch [:e, :editor]
@@ -71,7 +68,7 @@ command [:now, :next] do |c|
   c.flag [: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 [:f, :finish_last], negatable: false, default_value: false
 
   c.desc 'Note'
   c.arg_name 'note_text'
@@ -100,7 +97,7 @@ command [:now, :next] do |c|
       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.add_item(title.cap_first, section, {note: note, back: date, timed: options[:f]})
         wwid.write(wwid.doing_file)
       else
         raise "No content"
@@ -109,12 +106,12 @@ command [:now, :next] do |c|
       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.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.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"
@@ -133,13 +130,13 @@ arg_name 'note_text'
 command :note do |c|
   c.desc 'Section'
   c.arg_name 'section_name'
-  c.flag [:s, :section], :default_value => "All"
+  c.flag [:s, :section], default_value: "All"
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
-  c.switch [:e, :editor], :negatable => false, :default_value => false
+  c.switch [: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 [:r, :remove], negatable: false, default_value: false
 
   c.action do |global_options,options,args|
     section = wwid.guess_section(options[:s]) || options[:s].cap_first
@@ -192,13 +189,13 @@ 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.flag [:s, :section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
   c.switch [:e, :editor]
 
   c.desc "Archive previous @meanwhile entry"
-  c.switch [:a, :archive], :default_value => false
+  c.switch [: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]
@@ -233,7 +230,7 @@ command :meanwhile do |c|
     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})
+    wwid.stop_start('meanwhile', {new_item: input, back: date, section: section, archive: options[:a], note: note})
     wwid.write(wwid.doing_file)
   end
 end
@@ -296,7 +293,7 @@ command :later do |c|
       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.add_item(title.cap_first, "Later", {note: note, back: date})
         wwid.write(wwid.doing_file)
       else
         raise "No content"
@@ -305,12 +302,12 @@ command :later do |c|
       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.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.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"
@@ -323,13 +320,13 @@ desc 'Add a completed item with @done(date). No argument finishes last 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 [:r, :remove], negatable: false, default_value: false
 
   c.desc 'Include date'
-  c.switch [:date], :negatable => true, :default_value => true
+  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 [: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.flag [:at]
@@ -341,7 +338,7 @@ command [:done, :did] do |c|
   c.flag [:t, :took]
 
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => wwid.current_section
+  c.flag [:s, :section], default_value: wwid.current_section
 
   c.desc "Edit entry with #{ENV['EDITOR']}"
   c.switch [:e, :editor]
@@ -390,16 +387,16 @@ command [:done, :did] do |c|
         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.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
       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
     else
       if args.length > 0
@@ -407,13 +404,13 @@ command [:done, :did] do |c|
         title.chomp!
         title += " @done#{donedate}"
         section = "Archive" if options[:a]
-        wwid.add_item(title.cap_first, section.cap_first, {:note => note, :back => date})
+        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.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"
@@ -427,20 +424,34 @@ long_desc 'Adds @done tag without datestamp so no elapsed time is recorded. Alia
 arg_name 'count'
 command :cancel do |c|
   c.desc 'Archive entries'
-  c.switch [:a, :archive], :negatable => false, :default_value => false
+  c.switch [:a, :archive], negatable: false, default_value: false
 
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => wwid.current_section
+  c.flag [: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.flag [:tag]
+
+  c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
+  c.flag [:bool], must_match: /^(and|or|not)$/i, default_value: 'AND'
+
 
   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(/^@/, '') }
+      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 })
+      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
@@ -452,7 +463,7 @@ long_desc 'Marks the last X entries with a @done tag and current date. Does not
 arg_name 'count'
 command :finish do |c|
   c.desc 'Include date'
-  c.switch [:date], :negatable => true, :default_value => true
+  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]
@@ -464,16 +475,16 @@ command :finish do |c|
   c.flag [:tag]
 
   c.desc 'Boolean (AND|OR|NOT) with which to combine multiple tag filters'
-  c.flag [:tag_bool], default_value: 'AND'
+  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.switch [:auto], :negatable => false, :default_value => false
+  c.switch [:auto], negatable: false, default_value: false
 
   c.desc 'Archive entries'
-  c.switch [:a, :archive], :negatable => false, :default_value => false
+  c.switch [:a, :archive], negatable: false, default_value: false
 
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => wwid.current_section
+  c.flag [:s, :section], default_value: wwid.current_section
 
   c.action do |global_options,options,args|
 
@@ -494,21 +505,17 @@ command :finish do |c|
     end
 
     if options[:tag].nil?
-      options[:tag] = []
+      tags = []
     else
-      options[:tag] = options[:tag].split(/,/).map {|tag| tag.strip.sub(/^@/, '') }
-      if options[:tag_bool] =~ /^(and|or|not)$/i
-        options[:tag_bool] = options[:tag_bool].upcase
-      else
-        options[:tag_bool] = 'AND'
-      end
+      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[:tag_bool] })
+      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
@@ -519,14 +526,24 @@ 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.flag [:s, :section], default_value: "All"
+
+  c.desc 'Add new entry to section (default: same section as repeated entry)'
+  c.flag [:in]
+
+  c.desc 'Repeat last entry matching tags. Combine multiple tags with a comma.'
+  c.flag [:tag]
+
+  c.desc 'Boolean used to combine multiple tags'
+  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|
-    wwid.restart_last({ section: options[:s], note: options[:n] })
+    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] })
   end
 end
 
@@ -534,19 +551,19 @@ desc 'Tag last entry'
 arg_name 'tag1 [tag2...]'
 command :tag do |c|
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => "All"
+  c.flag [:s, :section], default_value: 'All'
 
   c.desc 'How many recent entries to tag (0 for all)'
-  c.flag [:c, :count], :default_value => 1
+  c.flag [:c, :count], default_value: 1
 
   c.desc 'Include current date/time with tag'
-  c.switch [:d, :date], :negatable => false, :default_value => false
+  c.switch [:d, :date], negatable: false, default_value: false
 
   c.desc 'Remove given tag(s)'
-  c.switch [:r, :remove], :negatable => false, :default_value => false
+  c.switch [: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 [:a, :autotag], negatable: false, default_value: false
 
   c.action do |global_options,options,args|
     if args.length == 0 && !options[:a]
@@ -587,7 +604,7 @@ command :tag do |c|
         end
       end
 
-      wwid.tag_last({:tags => tags, :count => count, :section => section, :date => options[:date], :remove => options[:r], :autotag => options[:a]})
+      wwid.tag_last({tags: tags, count: count, section: section, date: options[:date], remove: options[:r], autotag: options[:a]})
     end
   end
 end
@@ -595,15 +612,15 @@ 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.flag [:s, :section], default_value: wwid.current_section
 
   c.desc 'Remove mark'
-  c.switch [:r, :remove], :negatable => false, :default_value => false
+  c.switch [: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]})
+    wwid.tag_last({tags: [mark], section: options[:s], remove: options[:r]})
   end
 end
 
@@ -611,17 +628,20 @@ 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]'
 command :show do |c|
+  c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.flag [:tag]
+
   c.desc 'Tag boolean (AND,OR,NONE)'
-  c.flag [:b, :bool], :default_value => "OR"
+  c.flag [: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.flag [:c, :count], default_value: 0
 
   c.desc 'Age (oldest/newest)'
-  c.flag [:a, :age], :default_value => 'newest'
+  c.flag [:a, :age], default_value: 'newest'
 
   c.desc 'Sort order (asc/desc)'
-  c.flag [:s, :sort], :default_value => 'asc'
+  c.flag [:s, :sort], default_value: 'asc'
 
   c.desc %{
     Date range to show, or a single day to filter date on.
@@ -631,20 +651,20 @@ command :show do |c|
   c.flag [:f, :from]
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [: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.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.flag [:tag_sort], default_value: default
 
   c.desc 'Only show items with recorded time intervals'
-  c.switch [:only_timed], :default_value => false, :negatable => false
+  c.switch [:only_timed], default_value: false, negatable: false
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
@@ -681,6 +701,8 @@ command :show do |c|
       section = wwid.current_section
     end
 
+    tags.concat(options[:tag].split(/ *, */).map {|t| t.sub(/^@/, '').strip }) if options[:tag]
+
     unless tags.empty?
       tag_filter = {
         'tags' => tags,
@@ -699,14 +721,14 @@ command :show do |c|
         finish = false
       end
       exit_now! "Unrecognized date string" unless start
-      dates = [start,finish]
+      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]})
+    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]})
 
   end
 end
@@ -721,26 +743,26 @@ EODESC
 arg_name 'search_pattern'
 command [:grep, :search] do |c|
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => "All"
+  c.flag [:s, :section], default_value: "All"
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [: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.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.flag [:tag_sort], default_value: default
 
   c.desc 'Only show items with recorded time intervals'
-  c.switch [:only_timed], :default_value => false, :negatable => false
+  c.switch [:only_timed], default_value: false, negatable: false
 
   c.action do |global_options,options,args|
 
@@ -749,7 +771,7 @@ command [:grep, :search] do |c|
     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]})
+    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]})
 
   end
 end
@@ -759,20 +781,20 @@ default_value 10
 arg_name 'count'
 command :recent do |c|
   c.desc 'Section'
-  c.flag [:s, :section], :default_value => "All"
+  c.flag [:s, :section], default_value: "All"
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [: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.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.flag [:tag_sort], default_value: default
 
   c.action do |global_options,options,args|
 
@@ -787,7 +809,7 @@ command :recent do |c|
       options[:t] = true if options[:totals]
       options[:sort_tags] = options[:tag_sort] =~ /^n/i
 
-      puts wwid.recent(count,section.cap_first,{ :times => options[:t], :totals => options[:totals], :sort_tags => options[:sort_tags] })
+      puts wwid.recent(count,section.cap_first,{ times: options[:t], totals: options[:totals], sort_tags: options[:sort_tags] })
 
     end
   end
@@ -797,20 +819,20 @@ 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.flag [:s, :section], default_value: 'All'
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [:t, :times], default_value: true
 
   c.desc 'Show time totals at the end of output'
-  c.switch [:totals], :default_value => false, :negatable => true
+  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.flag [:tag_sort], default_value: default
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
@@ -820,7 +842,7 @@ command :today do |c|
     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
@@ -831,25 +853,26 @@ arg_name 'date_string'
 command :on do |c|
   c.desc 'Section'
   c.arg_name 'section_name'
-  c.flag [:s, :section], :default_value => 'All'
+  c.flag [:s, :section], default_value: 'All'
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [:t, :times], default_value: true
 
   c.desc 'Show time totals at the end of output'
-  c.switch [:totals], :default_value => false, :negatable => true
+  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.flag [:tag_sort], default_value: default
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
 
   c.action do |global_options,options,args|
+    exit_now! "Missing date argument" if args.empty?
 
     date_string = args.join(" ")
 
@@ -871,7 +894,7 @@ 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
@@ -880,27 +903,27 @@ 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.flag [:s, :section], default_value: 'All'
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [:t, :times], default_value: true
 
   c.desc 'Show time totals at the end of output'
-  c.switch [:totals], :default_value => false, :negatable => true
+  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.flag [:tag_sort], default_value: default
 
   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
@@ -918,7 +941,7 @@ end
 desc 'List sections'
 command :sections do |c|
   c.desc 'List in single column'
-  c.switch [:c, :column], :default_value => false
+  c.switch [:c, :column], default_value: false
 
   c.action do |global_options,options,args|
     joiner = options[:c] ? "\n" : "\t"
@@ -930,7 +953,7 @@ desc 'Select a section to display from a menu'
 command :choose do |c|
   c.action do |global_options,options,args|
     section = wwid.choose_section
-    puts wwid.list_section({:section => section.cap_first, :count => 0})
+    puts wwid.list_section({ section: section.cap_first, count: 0 })
   end
 end
 
@@ -972,26 +995,29 @@ command :view do |c|
   c.flag [:s, :section]
 
   c.desc 'Count to display (override view settings)'
-  c.flag [:c, :count], :must_match => /^\d+$/, :type => Integer
+  c.flag [:c, :count], must_match: /^\d+$/, type: Integer
 
   c.desc 'Output to export format (csv|html|json)'
   c.flag [:o, :output]
 
   c.desc 'Show time intervals on @done tasks'
-  c.switch [:t, :times], :default_value => true
+  c.switch [: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.switch [:totals], default_value: false, negatable: true
+
+  c.desc 'Include colors in output'
+  c.switch [:color], default_value: true, 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.flag [:tag_sort], default_value: default
 
   c.desc 'Only show items with recorded time intervals'
-  c.switch [:only_timed], :default_value => false, :negatable => true
+  c.switch [:only_timed], default_value: false, negatable: true
 
   c.action do |global_options,options,args|
     if args.empty?
@@ -1018,7 +1044,7 @@ command :view do |c|
       tag_filter = false
       if view.has_key?('tags')
         unless view['tags'].nil? || view['tags'].empty?
-          tag_filter = {'tags' => [], 'bool' => "OR"}
+          tag_filter = {'tags' => [], 'bool' => 'OR'}
           if view['tags'].class == Array
             tag_filter['tags'] = view['tags'].map{|tag| tag.strip }
           else
@@ -1039,7 +1065,7 @@ command :view do |c|
       options[:output].downcase! if options[:output]
       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 => true, :totals => options[:totals], :only_timed => only_timed, :sort_tags => options[:sort_tags] })
+      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] })
     else
       if title.class == FalseClass
         exit_now! "Cancelled"
@@ -1053,7 +1079,7 @@ 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 [:c, :column], default_value: false
 
   c.action do |global_options,options,args|
     joiner = options[:c] ? "\n" : "\t"
@@ -1061,18 +1087,21 @@ command :views do |c|
   end
 end
 
-desc 'Move entries in between sections'
+desc 'Move entries between sections'
 arg_name 'section'
 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.flag [:k, :keep], default_value: 5, must_match: /^\d+$/, type: Integer
 
   c.desc 'Move entries to'
-  c.flag [:t, :to], :default_value => "Archive"
+  c.flag [:t, :to], default_value: 'Archive'
+
+  c.desc 'Tag filter, combine multiple tags with a comma. Added for compatibility with other commands.'
+  c.flag [:tag]
 
   c.desc 'Tag boolean'
-  c.flag [:b, :bool], :default_value => "AND"
+  c.flag [:b, :bool], must_match: /(and|or|not)/i, default_value: 'AND'
 
   c.action do |global_options,options,args|
     if args.length > 0
@@ -1081,13 +1110,16 @@ command :archive do |c|
         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
+        tags = args.length > 1 ? args[1..-1].map {|t| t.sub(/^@/, '').strip } : nil
       end
     else
       section = wwid.current_section
-      tags = nil
+      tags = []
     end
-    wwid.archive(section,options[:k],options[:t],tags,options[:b])
+
+    tags.concat(options[:tag].split(/ *, */).map {|t| t.sub(/^@/, '').strip }) if options[:tag]
+
+    wwid.archive(section, options[:k], options[:t], tags, options[:b])
   end
 end
 
@@ -1103,7 +1135,7 @@ if `uname` =~ /Darwin/
   c.flag [:b]
 end
   c.desc 'open with $EDITOR'
-  c.switch [:e], :negatable => false
+  c.switch [:e], negatable: false
 
   c.action do |global_options,options,args|
     params = options.dup
@@ -1140,7 +1172,7 @@ end
 desc 'Edit the configuration file'
 command :config do |c|
   c.desc 'Editor to use'
-  c.flag [:e, :editor], :default_value => nil
+  c.flag [:e, :editor], default_value: nil
 
   if `uname` =~ /Darwins/
     c.desc 'Application to use'
@@ -1178,7 +1210,7 @@ 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.flag [:f, :file], default_value: wwid.doing_file
 
   c.action do |global_options,options,args|
     file = options[:f] || wwid.doing_file
@@ -1190,7 +1222,7 @@ end
 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
 

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '1.0.52'
+  VERSION = '1.0.53'
 end

data/lib/doing/wwid.rb

@@ -3,6 +3,44 @@
 require 'deep_merge'
 require 'open3'
 
+##
+## @brief      Hash helpers
+##
+class Hash
+  def has_tags?(tags, bool = 'AND')
+    item = self
+    case bool
+    when 'AND'
+      result = true
+      tags.each do |tag|
+        unless item['title'] =~ /@#{tag}/
+          result = false
+          break
+        end
+      end
+      result
+    when 'NOT'
+      result = true
+      tags.each do |tag|
+        if item['title'] =~ /@#{tag}/
+          result = false
+          break
+        end
+      end
+      result
+    else
+      result = false
+      tags.each do |tag|
+        if item['title'] =~ /@#{tag}/
+          result = true
+          break
+        end
+      end
+      result
+    end
+  end
+end
+
 ##
 ## @brief      String helpers
 ##
@@ -637,6 +675,8 @@ class WWID
   def restart_last(opt = {})
     opt[:section] ||= 'all'
     opt[:note] ||= []
+    opt[:tag] ||= []
+    opt[:tag_bool] ||= 'AND'
 
     last = last_entry(opt)
     if last.nil?
@@ -645,8 +685,9 @@ class WWID
     end
     # Remove @done tag
     title = last['title'].sub(/\s*@done(\(.*?\))?/, '').chomp
+    section = opt[:in].nil? ? last['section'] : guess_section(opt[:in])
     @auto_tag = false
-    add_item(title, last['section'], { note: opt[:note], back: opt[:date], timed: true })
+    add_item(title, section, { note: opt[:note], back: opt[:date], timed: true })
     write(@doing_file)
   end
 
@@ -656,6 +697,8 @@ class WWID
   ## @param      opt   (Hash) Additional Options
   ##
   def last_entry(opt = {})
+    opt[:tag] ||= []
+    opt[:tag_bool] ||= 'AND'
     opt[:section] ||= @current_section
 
     sec_arr = []
@@ -682,6 +725,8 @@ class WWID
       all_items.concat(@content[section]['items'].dup) if @content.key?(section)
     end
 
+    all_items.select! { |item| item.has_tags?(opt[:tag], opt[:tag_bool]) } if !opt[:tag].nil? && opt[:tag].length.positive?
+
     all_items.max_by { |item| item['date'] }
   end
 
@@ -735,39 +780,7 @@ class WWID
         items.map! do |item|
           break if index == count
 
-          tag_match = if opt[:tag].length.positive?
-                        case opt[:tag_bool]
-                        when 'AND'
-                          result = true
-                          opt[:tag].each do |tag|
-                            unless item['title'] =~ /@#{tag}/
-                              result = false
-                              break
-                            end
-                          end
-                          result
-                        when 'NOT'
-                          result = true
-                          opt[:tag].each do |tag|
-                            if item['title'] =~ /@#{tag}/
-                              result = false
-                              break
-                            end
-                          end
-                          result
-                        else
-                          result = false
-                          opt[:tag].each do |tag|
-                            if item['title'] =~ /@#{tag}/
-                              result = true
-                              break
-                            end
-                          end
-                          result
-                        end
-                      else
-                        true
-                      end
+          tag_match = !opt[:tag].nil? && opt[:tag].length.positive? ? item.has_tags?(opt[:tag], opt[:tag_bool]) : true
 
           if tag_match
             if opt[:autotag]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: doing
 version: !ruby/object:Gem::Version
-  version: 1.0.52
+  version: 1.0.53
 platform: ruby
 authors:
 - Brett Terpstra