doing 2.1.39 → 2.1.40

data/lib/doing/wwid/interactive.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Interactive methods for WWID class
+    module Interactive
+      ##
+      ## 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,
+                                      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/)
+          to_do.each do |action|
+            case action
+            when /resume/
+              opt[:resume] = true
+            when /reset/
+              opt[:reset] = true
+            when /autotag/
+              opt[:autotag] = 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)
+
+              puts "#{yellow}Separate multiple tags with spaces, hit tab to complete known tags#{type == 'add' ? ', include values with tag(value)' : ''}"
+              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 /archive/
+              opt[:archive] = true
+            when /delete/
+              opt[:delete] = true
+            when /edit/
+              opt[:editor] = true
+            when /finish/
+              opt[:finish] = true
+            when /cancel/
+              opt[:cancel] = true
+            when /move/
+              section = choose_section.strip
+              opt[:move] = section.strip unless section =~ /^ *$/
+            when /flag/
+              opt[:flag] = true
+            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: '')
+            if res =~ /^ *$/
+              date = Time.now
+            else
+              date = 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|
+            if 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
+        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]
+          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
+end