doing 2.1.41 → 2.1.44

data/bin/commands/finish.rb

@@ -1,43 +1,97 @@
+# frozen_string_literal: true
+
 # @@finish
-desc 'Mark last X entries as @done'
-long_desc 'Marks the last X entries with a @done tag and current date. Does not alter already completed entries.'
-arg_name 'COUNT', optional: true
-command :finish do |c|
-  c.example 'doing finish', desc: 'Mark the last entry @done'
-  c.example 'doing finish --auto --section Later 10', desc: 'Add @done to any unfinished entries in the last 10 in Later, setting the finish time based on the start time of the task after it'
-  c.example 'doing finish --search "a specific entry" --at "yesterday 3pm"', desc: 'Search for an entry containing string and set its @done time to yesterday at 3pm'
+module Doing
+  # finish command methods
+  class FinishCommand
+    def initialize(wwid)
+      @wwid = wwid
+    end
 
-  c.desc 'Include date'
-  c.switch [:date], negatable: true, default_value: true
+    def add_examples(cmd)
+      cmd.example 'doing finish', desc: 'Mark the last entry @done'
+      cmd.example 'doing finish --auto --section Later 10', desc: 'Add @done to any unfinished entries in the last 10 in Later, setting the finish time based on the start time of the task after it'
+      cmd.example 'doing finish --search "a specific entry" --at "yesterday 3pm"', desc: 'Search for an entry containing string and set its @done time to yesterday at 3pm'
+    end
 
-  c.desc 'Backdate completed date to date string [4pm|20m|2h|yesterday noon]'
-  c.arg_name 'DATE_STRING'
-  c.flag %i[b back started], type: DateBeginString
+    def add_options(cmd)
+      cmd.desc 'Include date'
+      cmd.switch [:date], negatable: true, default_value: true
 
-  c.desc 'Overwrite existing @done tag with new date'
-  c.switch %i[update], negatable: false, default_value: false
+      cmd.desc 'Backdate completed date to date string [4pm|20m|2h|yesterday noon]'
+      cmd.arg_name 'DATE_STRING'
+      cmd.flag %i[b back started], type: DateBeginString
 
-  c.desc 'Remove @done tag'
-  c.switch %i[r remove], negatable: false, default_value: false
+      cmd.desc 'Overwrite existing @done tag with new date'
+      cmd.switch %i[update], negatable: false, default_value: false
 
-  c.desc 'Finish last entry (or entries) not already marked @done'
-  c.switch %i[u unfinished], negatable: false, default_value: false
+      cmd.desc 'Remove @done tag'
+      cmd.switch %i[r remove], negatable: false, default_value: false
 
-  c.desc %(Auto-generate finish dates from next entry's start time.
-  Automatically generate completion dates 1 minute before next item (in any section) began.
-  --auto overrides the --date and --back parameters.)
-  c.switch [:auto], negatable: false, default_value: false
+      cmd.desc 'Finish last entry (or entries) not already marked @done'
+      cmd.switch %i[u unfinished], negatable: false, default_value: false
 
-  c.desc 'Archive entries'
-  c.switch %i[a archive], negatable: false, default_value: false
+      cmd.desc %(Auto-generate finish dates from next entry's start time.
+      Automatically generate completion dates 1 minute before next item (in any section) began.
+      --auto overrides the --date and --back parameters.)
+      cmd.switch [:auto], negatable: false, default_value: false
 
-  c.desc 'Section'
-  c.arg_name 'NAME'
-  c.flag %i[s section]
+      cmd.desc 'Archive entries'
+      cmd.switch %i[a archive], negatable: false, default_value: false
 
-  c.desc 'Select item(s) to finish from a menu of matching entries'
-  c.switch %i[i interactive], negatable: false, default_value: false
+      cmd.desc 'Section'
+      cmd.arg_name 'NAME'
+      cmd.flag %i[s section]
 
+      cmd.desc 'Select item(s) to finish from a menu of matching entries'
+      cmd.switch %i[i interactive], negatable: false, default_value: false
+    end
+
+    def handle_from(options)
+      options[:from] = options[:from].split(/#{REGEX_RANGE_INDICATOR}/).map do |time|
+        time =~ REGEX_TIME ? "today #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}" : time
+      end.join(' to ').split_date_range
+      start_date, finish_date = options[:from]
+      finish_date ||= Time.now
+      [start_date, finish_date]
+    end
+
+    def handle_date_options(options)
+      if options[:took]
+        took = options[:took]
+        raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
+
+      end
+
+      if options[:at]
+        finish_date = options[:at]
+        finish_date = finish_date.chronify(guess: :begin) if finish_date.is_a? String
+        raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
+
+        start_date = options[:took] ? finish_date - took : nil
+      elsif options[:back]
+        start_date = options[:back]
+        finish_date = options[:took] ? start_date + took : Time.now
+
+        raise InvalidTimeExpression, 'Unable to parse date string' if start_date.nil?
+
+      else
+        start_date = options[:took] ? Time.now - took : nil
+        finish_date = Time.now
+      end
+
+      [start_date, finish_date]
+    end
+  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', optional: true
+command :finish do |c|
+  cmd = Doing::FinishCommand.new(@wwid)
+  cmd.add_examples(c)
+  cmd.add_options(c)
   add_options(:search, c)
   add_options(:tag_filter, c)
   add_options(:finish_entry, c)
@@ -46,55 +100,27 @@ command :finish do |c|
     options[:fuzzy] = false
     unless options[:auto]
       if options[:from]
-        options[:from] = options[:from].split(/#{REGEX_RANGE_INDICATOR}/).map do |time|
-          time =~ REGEX_TIME ? "today #{time.sub(/(?mi)(^.*?(?=\d+)|(?<=[ap]m).*?$)/, '')}" : time
-        end.join(' to ').split_date_range
-        start_date, finish_date = options[:from]
-        finish_date ||= Time.now
+        start_date, finish_date = cmd.handle_from(options)
       else
-        if options[:took]
-          took = options[:took]
-          raise InvalidTimeExpression, 'Unable to parse date string for --took' if took.nil?
-
-        end
-
-        if options[:at]
-          finish_date = options[:at]
-          finish_date = finish_date.chronify(guess: :begin) if finish_date.is_a? String
-          raise InvalidTimeExpression, 'Unable to parse date string for --at' if finish_date.nil?
-
-          start_date = options[:took] ? finish_date - took : nil
-        elsif options[:back]
-          start_date = options[:back]
-          finish_date = options[:took] ? start_date + took : Time.now
-
-          raise InvalidTimeExpression, 'Unable to parse date string' if start_date.nil?
-
-        else
-          start_date = options[:took] ? Time.now - took : nil
-          finish_date = Time.now
-        end
+        start_date, finish_date = cmd.handle_date_options(options)
       end
-
-
     end
 
-    if options[:tag].nil?
-      tags = []
-    else
-      tags = options[:tag]
-    end
+    tags = options[:tag] || []
 
     raise InvalidArgument, 'Only one argument allowed' if args.length > 1
 
-    raise InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)' unless args.length == 0 || args[0] =~ /\d+/
+    unless args.empty? || args[0] =~ /\d+/
+      raise InvalidArgument, 'Invalid argument (specify number of recent items to mark @done)'
 
-    if options[:interactive]
-      count = 0
-    else
-      count = args[0] ? args[0].to_i : 1
     end
 
+    count = if options[:interactive]
+              0
+            else
+              args[0] ? args[0].to_i : 1
+            end
+
     search = nil
 
     if options[:search]

data/bin/commands/flag.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 # @@mark @@flag
 desc 'Mark last entry as flagged'
 command %i[mark flag] do |c|
   c.example 'doing flag', desc: 'Add @flagged to the last entry created'
   c.example 'doing mark', desc: 'mark is an alias for flag'
   c.example 'doing flag --tag project1 --count 2', desc: 'Add @flagged to the last 2 entries tagged @project1'
-  c.example 'doing flag --interactive --search "/(develop|cod)ing/"', desc: 'Find entries matching regular expression and create a menu allowing multiple selections, selected items will be @flagged'
+  c.example 'doing flag --interactive --search "/(develop|cod)ing/"',
+            desc: 'Find entries matching regular expression and create a menu allowing multiple selections,
+                  selected items will be @flagged'
 
   c.desc 'Section'
   c.arg_name 'SECTION_NAME'

data/bin/commands/grep.rb

@@ -25,7 +25,7 @@ command %i[grep search] do |c|
   c.desc 'Case sensitivity for search string matching [(c)ase-sensitive, (i)gnore, (s)mart]'
   c.arg_name 'TYPE'
   c.flag [:case], must_match: REGEX_CASE,
-                  default_value: Doing.settings.dig('search', 'case').normalize_case,
+                  default_value: Doing.setting('search.case', :smart).normalize_case,
                   type: CaseSymbol
 
   c.desc "Highlight search matches in output. Only affects command line output"
@@ -44,11 +44,15 @@ command %i[grep search] do |c|
   add_options(:tag_filter, c)
   add_options(:date_filter, c)
   add_options(:time_display, c)
+  add_options(:save, c)
 
   c.action do |_global_options, options, args|
     options[:fuzzy] = false
 
-    raise InvalidPlugin.new('output', options[:output]) if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+    if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+      raise InvalidPlugin.new('output', options[:output])
+
+    end
 
     template = Doing.setting(['templates', options[:config_template]]).deep_merge(Doing.settings)
     tags_color = template.key?('tags_color') ? template['tags_color'] : nil
@@ -66,5 +70,11 @@ command %i[grep search] do |c|
     options[:tags_color] = tags_color
 
     Doing::Pager.page @wwid.list_section(options)
+    if options[:save]
+      options[:before] = Doing.original_options[:date_begin] if Doing.original_options[:date_begin].good?
+      options[:after] = Doing.original_options[:date_end] if Doing.original_options[:date_end].good?
+      options[:from] = Doing.original_options[:date_range] if Doing.original_options[:date_range].good?
+      Doing.config.save_view(options.to_view, options[:save].downcase)
+   end
   end
 end

data/bin/commands/last.rb

@@ -30,6 +30,7 @@ command :last do |c|
   add_options(:output_template, c, default_template: 'last')
   add_options(:search, c)
   add_options(:tag_filter, c)
+  add_options(:save, c)
 
   c.action do |global_options, options, _args|
     options[:fuzzy] = false
@@ -70,6 +71,7 @@ command :last do |c|
                         val: options[:val]
                       })
       Doing::Pager::page last.strip if last
+      Doing.config.save_view(options.to_view, options[:save].downcase) if options[:save]
     end
   end
 end

data/bin/commands/now.rb

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

data/bin/commands/on.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # @@on
 desc 'List entries for a date'
 long_desc %(Date argument can be natural language. "thursday" would be interpreted as "last thursday,"
@@ -18,16 +20,18 @@ command :on do |c|
   add_options(:search, c)
   add_options(:tag_filter, c)
   add_options(:time_filter, c)
+  add_options(:save, c)
 
   c.action do |_global_options, options, args|
-    raise InvalidPlugin.new('output', options[:output]) if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+    if options[:output] && options[:output] !~ Doing::Plugins.plugin_regex(type: :export)
+      raise InvalidPlugin.new('output', options[:output])
+
+    end
 
     raise MissingArgument, 'Missing date argument' if args.empty?
 
     date_string = args.join(' ').strip
-    if date_string =~ /^tod(?:ay)?/i
-      date_string = 'midnight to today 23:59'
-    end
+    date_string = 'midnight to today 23:59' if date_string =~ /^tod(?:ay)?/i
 
     start, finish = date_string.split_date_range
 
@@ -40,6 +44,17 @@ command :on do |c|
     options[:times] = true if options[:totals]
     options[:sort_tags] = options[:tag_sort]
 
-    Doing::Pager.page @wwid.list_date([start, finish], options[:section], options[:times], options[:output], options).chomp
+    Doing::Pager.page @wwid.list_date([start, finish],
+                                      options[:section],
+                                      options[:times],
+                                      options[:output],
+                                      options).chomp
+
+    if options[:save]
+      options[:before] = Doing.original_options[:date_end] if Doing.original_options[:date_end].good?
+      options[:after] = Doing.original_options[:date_begin] if Doing.original_options[:date_begin].good?
+      options[:from] = Doing.original_options[:date_range] if Doing.original_options[:date_range].good?
+      Doing.config.save_view(options.to_view, options[:save].downcase)
+    end
   end
 end

data/bin/commands/recent.rb

@@ -17,6 +17,7 @@ command :recent do |c|
 
   add_options(:output_template, c, default_template: 'recent')
   add_options(:time_display, c)
+  add_options(:save, c)
 
   c.action do |global_options, options, args|
     section = @wwid.guess_section(options[:section]) || options[:section].cap_first
@@ -53,7 +54,9 @@ command :recent do |c|
       }
 
       Doing::Pager::page @wwid.recent(count, section.cap_first, opts)
-
+      opts[:count] = count
+      opts[:title] = options[:title]
+      Doing.config.save_view(opts.to_view, options[:save].downcase) if options[:save]
     end
   end
 end

data/bin/commands/show.rb

@@ -47,6 +47,7 @@ command :show do |c|
   add_options(:search, c)
   add_options(:tag_filter, c)
   add_options(:date_filter, c)
+  add_options(:save, c)
 
   c.action do |global_options, options, args|
     options[:fuzzy] = false
@@ -153,5 +154,12 @@ command :show do |c|
     opt[:tags_color] = template['tags_color']
 
     Doing::Pager.page @wwid.list_section(opt, items: items)
+
+    if options[:save]
+      opt[:before] = Doing.original_options[:date_begin] if Doing.original_options[:date_begin].good?
+      opt[:after] = Doing.original_options[:date_end] if Doing.original_options[:date_end].good?
+      opt[:from] = Doing.original_options[:date_range] if Doing.original_options[:date_range].good?
+      Doing.config.save_view(opt.to_view, options[:save].downcase)
+    end
   end
 end