doing 2.1.39 → 2.1.42

data/lib/doing/wwid/interactive.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    ##
+    ## Display an interactive menu of entries
+    ##
+    ## @param      opt   [Hash] Additional options
+    ##
+    ## Options hash is shared with #filter_items and #act_on
+    ##
+    def interactive(opt)
+      opt ||= {}
+      opt[:section] = opt[:section] ? guess_section(opt[:section]) : 'All'
+
+      search = nil
+
+      if opt[:search]
+        search = opt[:search]
+        search.sub!(/^'?/, "'") if opt[:exact]
+        opt[:search] = search
+      end
+
+      # opt[:query] = opt[:search] if opt[:search] && !opt[:query]
+      opt[:query] = "!#{opt[:query]}" if opt[:query] && opt[:not]
+      opt[:multiple] = true
+      opt[:show_if_single] = true
+      filter_options = %i[after before case date_filter from fuzzy not search section val].each_with_object({}) {
+        |k, hsh| hsh[k] = opt[k]
+      }
+      items = filter_items(Items.new, opt: filter_options)
+
+      menu_options = %i[search query exact multiple show_if_single menu sort case].each_with_object({}) {
+        |k, hsh| hsh[k] = opt[k]
+      }
+
+      selection = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i, **menu_options)
+
+      raise NoResults, 'no items selected' if selection.nil? || selection.empty?
+
+      act_on(selection, opt)
+    end
+
+    ##
+    ## Perform actions on a set of entries. If
+    ##             no valid action is included in the opt
+    ##             hash and the terminal is a TTY, a menu
+    ##             will be presented
+    ##
+    ## @param      items  [Array] Array of Items to affect
+    ## @param      opt    [Hash] Options and actions to perform
+    ##
+    ## @option opt [Boolean] :editor
+    ## @option opt [Boolean] :delete
+    ## @option opt [String] :tag
+    ## @option opt [Boolean] :flag
+    ## @option opt [Boolean] :finish
+    ## @option opt [Boolean] :cancel
+    ## @option opt [Boolean] :archive
+    ## @option opt [String] :output
+    ## @option opt [String] :save_to
+    ## @option opt [Boolean] :again
+    ## @option opt [Boolean] :resume
+    ##
+    def act_on(items, opt)
+      opt ||= {}
+      actions = %i[editor delete tag flag finish cancel archive output save_to again resume]
+      has_action = false
+      single = items.count == 1
+
+      actions.each do |a|
+        if opt[a]
+          has_action = true
+          break
+        end
+      end
+
+      unless has_action
+        actions = [
+          'add tag',
+          'remove tag',
+          'autotag',
+          'cancel',
+          'delete',
+          'finish',
+          'flag',
+          'archive',
+          'move',
+          'edit',
+          'output formatted'
+        ]
+
+        actions.concat(['resume/repeat', 'begin/reset']) if items.count == 1
+
+        choice = Prompt.choose_from(actions.map(&:titlecase),
+                                    prompt: 'What do you want to do with the selected items? > ',
+                                    multiple: true,
+                                    sorted: false,
+                                    fzf_args: ["--height=#{actions.count + 3}", '--tac', '--no-sort', '--info=hidden'])
+        return unless choice
+
+        to_do = choice.strip.split(/\n/).map(&:downcase)
+
+        to_do.each do |action|
+          case action
+          when /(resume|reset|autotag|archive|delete|finish|cancel|flag)/
+            opt[action.to_sym] = true
+          when /edit/
+            opt[:editor] = true
+          when /(add|remove) tag/
+            type = action =~ /^add/ ? 'add' : 'remove'
+            raise InvalidArgument, "'add tag' and 'remove tag' can not be used together" if opt[:tag]
+
+            tags = type == 'add' ? all_tags(@content) : all_tags(items)
+
+            add_msg = type == 'add' ? ', include values with tag(value)' : ''
+            puts "#{yellow}Separate multiple tags with spaces, hit tab to complete known tags#{add_msg}"
+            puts "#{boldgreen}Available tags: #{boldwhite}#{tags.sort.map(&:add_at).join(', ')}" if type == 'remove'
+            tag = Prompt.read_line(prompt: "Tags to #{type}", completions: tags)
+
+            # print "#{yellow("Tag to #{type}: ")}#{reset}"
+            # tag = $stdin.gets
+            next if tag =~ /^ *$/
+
+            opt[:tag] = tag.strip.sub(/^@/, '')
+            opt[:remove] = true if type == 'remove'
+          when /output formatted/
+            plugins = Plugins.available_plugins(type: :export).sort
+            output_format = Prompt.choose_from(plugins,
+                                               prompt: 'Which output format? > ',
+                                               fzf_args: [
+                                                 "--height=#{plugins.count + 3}",
+                                                 '--tac',
+                                                 '--no-sort',
+                                                 '--info=hidden'
+                                               ])
+            next if output_format =~ /^ *$/
+
+            raise UserCancelled unless output_format
+
+            opt[:output] = output_format.strip
+            res = opt[:force] ? false : Prompt.yn('Save to file?', default_response: 'n')
+            if res
+              # print "#{yellow('File path/name: ')}#{reset}"
+              # filename = $stdin.gets.strip
+              filename = Prompt.read_line(prompt: 'File path/name')
+              next if filename.empty?
+
+              opt[:save_to] = filename
+            end
+          when /move/
+            section = choose_section.strip
+            opt[:move] = section.strip unless section =~ /^ *$/
+          end
+        end
+      end
+
+      if opt[:resume] || opt[:reset]
+        raise InvalidArgument, 'resume and restart can only be used on a single entry' if items.count > 1
+
+        item = items[0]
+        if opt[:resume] && !opt[:reset]
+          repeat_item(item, { editor: opt[:editor] }) # hooked
+        elsif opt[:reset]
+          res = Prompt.enter_text('Start date (blank for current time)', default_response: '')
+          date = if res =~ /^ *$/
+                   Time.now
+                 else
+                   res.chronify(guess: :begin)
+                 end
+
+          res = if item.tags?('done', :and) && !opt[:resume]
+                  opt[:force] ? true : Prompt.yn('Remove @done tag?', default_response: 'y')
+                else
+                  opt[:resume]
+                end
+          old_item = item.clone
+          new_entry = reset_item(item, date: date, resume: res)
+          @content.update_item(item, new_entry)
+          Hooks.trigger :post_entry_updated, self, new_entry, old_item
+        end
+        write(@doing_file)
+
+        return
+      end
+
+      if opt[:delete]
+        delete_items(items, force: opt[:force]) # hooked
+        write(@doing_file)
+
+        return
+      end
+
+      if opt[:flag]
+        tag = Doing.setting('marker_tag', 'flagged')
+        items.map! do |i|
+          old_item = i.clone
+          i.tag(tag, date: false, remove: opt[:remove], single: single)
+          Hooks.trigger :post_entry_updated, self, i, old_item
+        end
+      end
+
+      if opt[:finish] || opt[:cancel]
+        tag = 'done'
+        items.map! do |i|
+          next unless i.should_finish?
+
+          old_item = i.clone
+          should_date = !opt[:cancel] && i.should_time?
+          i.tag(tag, date: should_date, remove: opt[:remove], single: single)
+          Hooks.trigger :post_entry_updated, self, i, old_item
+        end
+      end
+
+      if opt[:autotag]
+        items.map! do |i|
+          new_title = autotag(i.title)
+          if new_title == i.title
+            logger.count(:skipped, level: :debug, message: '%count unchaged %items')
+            # logger.debug('Autotag:', 'No changes')
+          else
+            logger.count(:added_tags)
+            logger.write(items.count == 1 ? :info : :debug, 'Tagged:', new_title)
+            old_item = i.clone
+            i.title = new_title
+            Hooks.trigger :post_entry_updated, self, i, old_item
+          end
+        end
+      end
+
+      if opt[:tag]
+        tag = opt[:tag]
+        items.map! do |i|
+          old_item = i.clone
+          i.tag(tag, date: false, remove: opt[:remove], single: single)
+          i.expand_date_tags(Doing.setting('date_tags'))
+          Hooks.trigger :post_entry_updated, self, i, old_item
+        end
+      end
+
+      if opt[:archive] || opt[:move]
+        section = opt[:archive] ? 'Archive' : guess_section(opt[:move])
+        items.map! do |i|
+          old_item = i.clone
+          i.move_to(section, label: true)
+          Hooks.trigger :post_entry_updated, self, i, old_item
+        end
+      end
+
+      write(@doing_file)
+
+      if opt[:editor]
+        sleep 2 # This seems to be necessary between running fzf
+                # and forking the editor, otherwise vim gets all
+                # screwy and I can't figure out why
+        edit_items(items) # hooked
+
+        write(@doing_file)
+      end
+
+      return unless opt[:output]
+
+      items.each { |i| i.title = "#{i.title} @section(#{i.section})" }
+
+      export_items = Items.new
+      export_items.concat(items)
+      export_items.add_section(Section.new('Export'), log: false)
+      options = { section: 'All' }
+
+      if opt[:output] =~ /doing/
+        options[:output] = 'template'
+        options[:template] = '- %date | %title%note'
+      else
+        options[:output] = opt[:output]
+        options[:template] = opt[:template] || nil
+      end
+
+      output = list_section(options, items: export_items) # hooked
+
+      if opt[:save_to]
+        file = File.expand_path(opt[:save_to])
+        if File.exist?(file)
+          # Create a backup copy for the undo command
+          FileUtils.cp(file, "#{file}~")
+        end
+
+        File.open(file, 'w+') do |f|
+          f.puts output
+        end
+
+        logger.warn('File written:', file)
+      else
+        Doing::Pager.page output
+      end
+    end
+
+    ##
+    ## Generate a menu of sections and allow user selection
+    ##
+    ## @return     [String] The selected section name
+    ##
+    def choose_section(include_all: false)
+      options = @content.section_titles.sort
+      options.unshift('All') if include_all
+      choice = Prompt.choose_from(options, prompt: 'Choose a section > ', fzf_args: ['--height=60%'])
+      choice ? choice.strip : choice
+    end
+
+    ##
+    ## Generate a menu of tags and allow user selection
+    ##
+    ## @return     [String] The selected tag name
+    ##
+    def choose_tag(section = 'All', items: nil, include_all: false)
+      items ||= @content.in_section(section)
+      tags = all_tags(items, counts: true).map { |t, c| "@#{t} (#{c})" }
+      tags.unshift('No tag filter') if include_all
+      choice = Prompt.choose_from(tags,
+                                  sorted: false,
+                                  multiple: true,
+                                  prompt: 'Choose tag(s) > ',
+                                  fzf_args: ['--height=60%'])
+      choice ? choice.split(/\n/).map { |t| t.strip.sub(/ \(.*?\)$/, '') }.join(' ') : choice
+    end
+
+    ##
+    ## Generate a menu of sections and tags and allow user selection
+    ##
+    ## @return     [String] The selected section or tag name
+    ##
+    def choose_section_tag
+      options = @content.section_titles.sort
+      options.concat(@content.all_tags.sort.map { |t| "@#{t}" })
+      choice = Prompt.choose_from(options, prompt: 'Choose a section or tag > ', fzf_args: ['--height=60%'])
+      choice ? choice.strip : choice
+    end
+
+    ##
+    ## Generate a menu of views and allow user selection
+    ##
+    ## @return     [String] The selected view name
+    ##
+    def choose_view
+      choice = Prompt.choose_from(views.sort, prompt: 'Choose a view > ', fzf_args: ['--height=60%'])
+      choice ? choice.strip : choice
+    end
+
+    ##
+    ## Interactively verify an item modification if elapsed time is greater than configured threshold
+    ##
+    ## @param      date         [String] Item date
+    ## @param      finish_date  [String] The finish date
+    ## @param      title        [String] The Item title
+    ##
+    def verify_duration(date, finish_date, title: nil)
+      max_elapsed = Doing.setting('interaction.confirm_longer_than', 0)
+      max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
+      date = date.chronify(guess: :end, context: :today) if finish_date.is_a?(String)
+
+      elapsed = finish_date - date
+
+      if max_elapsed.positive? && (elapsed > max_elapsed)
+        puts boldwhite(title) if title
+        human = elapsed.time_string(format: :natural)
+        res = Prompt.yn(yellow("Did this entry actually take #{human}"), default_response: true)
+        unless res
+          new_elapsed = Prompt.enter_text('How long did it take?').chronify_qty
+          raise InvalidTimeExpression, 'Unrecognized time span entry' unless new_elapsed.positive?
+
+          finish_date = date + new_elapsed if new_elapsed
+        end
+      end
+
+      finish_date
+    end
+  end
+end