doing 2.1.40 → 2.1.41

data/lib/doing/wwid/filter.rb

@@ -2,217 +2,225 @@
 
 module Doing
   class WWID
-    # Filter methods for WWID class
-    module Filter
-      def fuzzy_filter_items(items, opt: {})
-        scannable = items.map.with_index { |item, idx| "#{item.title} #{item.note.join(' ')}".gsub(/[|*?!]/, '') + "|#{idx}"  }.join("\n")
-
-        fzf_args = [
-          '--multi',
-          %(--filter="#{opt[:search].sub(/^'?/, "'")}"),
-          '--no-sort',
-          '-d "\|"',
-          '--nth=1'
-        ]
-        if opt[:case]
-          fzf_args << case opt[:case].normalize_case
-                      when :sensitive
-                        '+i'
-                      when :ignore
-                        '-i'
-                      end
-        end
-        # fzf_args << '-e' if opt[:exact]
-        # puts fzf_args.join(' ')
-        res = `echo #{Shellwords.escape(scannable)}|#{Prompt.fzf} #{fzf_args.join(' ')}`
-        selected = Items.new
-        res.split(/\n/).each do |item|
-          idx = item.match(/\|(\d+)$/)[1].to_i
-          selected.push(items[idx])
-        end
-        selected
+    # Use fzf to filter an Items object with a search query.
+    # Faster than {#filter_items} when all you need is a
+    # text search of the title and note
+    #
+    # @param      items      [Items] an Items object
+    # @param      query      [String] The search query
+    # @param      case_type  [Symbol] The case type (:smart, :sensitive, :ignore)
+    #
+    # @return     [Items] Filtered Items array
+    #
+    def fuzzy_filter_items(items, query, case_type: :smart)
+      scannable = items.map.with_index { |item, idx| "#{item.title} #{item.note.join(' ')}".gsub(/[|*?!]/, '') + "|#{idx}"  }.join("\n")
+
+      fzf_args = [
+        '--multi',
+        %(--filter="#{query.sub(/^'?/, "'")}"),
+        '--no-sort',
+        '-d "\|"',
+        '--nth=1'
+      ]
+      fzf_args << case case_type.normalize_case
+                  when :smart
+                    query =~ /[A-Z]/ ? '+i' : '-i'
+                  when :sensitive
+                    '+i'
+                  when :ignore
+                    '-i'
+                  end
+
+      # fzf_args << '-e' if opt[:exact]
+      # puts fzf_args.join(' ')
+      res = `echo #{Shellwords.escape(scannable)}|#{Prompt.fzf} #{fzf_args.join(' ')}`
+      selected = Items.new
+      res.split(/\n/).each do |item|
+        idx = item.match(/\|(\d+)$/)[1].to_i
+        selected.push(items[idx])
       end
+      selected
+    end
 
-      ##
-      ## Filter items based on search criteria
-      ##
-      ## @param      items  [Array] The items to filter (if empty, filters all items)
-      ## @param      opt    [Hash] The filter parameters
-      ##
-      ## @option opt [String] :section ('all')
-      ## @option opt [Boolean] :unfinished (false)
-      ## @option opt [Array or String] :tag ([]) Array or comma-separated string
-      ## @option opt [Symbol] :tag_bool (:and) :and, :or, :not
-      ## @option opt [String] :search ('') string, optional regex with `/string/`
-      ## @option opt [Array] :date_filter (nil) [[Time]start, [Time]end]
-      ## @option opt [Boolean] :only_timed (false)
-      ## @option opt [String] :before (nil) Date/Time string, unparsed
-      ## @option opt [String] :after  (nil) Date/Time string, unparsed
-      ## @option opt [Boolean] :today (false) limit to entries from today
-      ## @option opt [Boolean] :yesterday (false) limit to entries from yesterday
-      ## @option opt [Number] :count (0) max entries to return
-      ## @option opt [String] :age (new) 'old' or 'new'
-      ## @option opt [Array] :val (nil) Array of tag value queries
-      ##
-      def filter_items(items = Items.new, opt: {})
-        logger.benchmark(:filter_items, :start)
-        time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/i
-
-        if items.nil? || items.empty?
-          section = opt[:section] ? guess_section(opt[:section]) : 'All'
-          items = section =~ /^all$/i ? @content.clone : @content.in_section(section)
-        end
+    ##
+    ## Filter items based on search criteria
+    ##
+    ## @param      items  [Array] The items to filter (if empty, filters all items)
+    ## @param      opt    [Hash] The filter parameters
+    ##
+    ## @option opt [String] :section ('all')
+    ## @option opt [Boolean] :unfinished (false)
+    ## @option opt [Array or String] :tag ([]) Array or comma-separated string
+    ## @option opt [Symbol] :tag_bool (:and) :and, :or, :not
+    ## @option opt [String] :search ('') string, optional regex with `/string/`
+    ## @option opt [Array] :date_filter (nil) [[Time]start, [Time]end]
+    ## @option opt [Boolean] :only_timed (false)
+    ## @option opt [String] :before (nil) Date/Time string, unparsed
+    ## @option opt [String] :after  (nil) Date/Time string, unparsed
+    ## @option opt [Boolean] :today (false) limit to entries from today
+    ## @option opt [Boolean] :yesterday (false) limit to entries from yesterday
+    ## @option opt [Number] :count (0) max entries to return
+    ## @option opt [String] :age (new) 'old' or 'new'
+    ## @option opt [Array] :val (nil) Array of tag value queries
+    ##
+    def filter_items(items = Items.new, opt: {})
+      logger.benchmark(:filter_items, :start)
+      time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/i
+
+      if items.nil? || items.empty?
+        section = opt[:section] ? guess_section(opt[:section]) : 'All'
+        items = section =~ /^all$/i ? @content.clone : @content.in_section(section)
+      end
 
-        if !opt[:time_filter]
-          opt[:time_filter] = [nil, nil]
-          if opt[:from] && !opt[:date_filter]
-            if opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
-              opt[:time_filter] = opt[:from]
-            elsif opt[:from][0].is_a?(Time)
-              opt[:date_filter] = opt[:from]
-            end
+      unless opt[:time_filter]
+        opt[:time_filter] = [nil, nil]
+        if opt[:from] && !opt[:date_filter]
+          if opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
+            opt[:time_filter] = opt[:from]
+          elsif opt[:from][0].is_a?(Time)
+            opt[:date_filter] = opt[:from]
           end
         end
+      end
 
-        if opt[:before].is_a?(String) && opt[:before] =~ time_rx
-          opt[:time_filter][1] = opt[:before]
-          opt[:before] = nil
-        end
-
-        if opt[:after].is_a?(String) && opt[:after] =~ time_rx
-          opt[:time_filter][0] = opt[:after]
-          opt[:after] = nil
-        end
-
-        items.sort_by! { |item| [item.date, item.title.downcase] }.reverse
-
-        filtered_items = items.select do |item|
-          keep = true
-          if opt[:unfinished]
-            finished = item.tags?('done', :and)
-            finished = opt[:not] ? !finished : finished
-            keep = false if finished
-          end
-
-          if keep && opt[:val]&.count&.positive?
-            bool = opt[:bool].normalize_bool if opt[:bool]
-            bool ||= :and
-            bool = :and if bool == :pattern
+      if opt[:before].is_a?(String) && opt[:before] =~ time_rx
+        opt[:time_filter][1] = opt[:before]
+        opt[:before] = nil
+      end
 
-            val_match = opt[:val].nil? || opt[:val].empty? ? true : item.tag_values?(opt[:val], bool)
-            keep = false unless val_match
-            keep = opt[:not] ? !keep : keep
-          end
+      if opt[:after].is_a?(String) && opt[:after] =~ time_rx
+        opt[:time_filter][0] = opt[:after]
+        opt[:after] = nil
+      end
 
-          if keep && opt[:tag]
-            opt[:tag_bool] = opt[:bool].normalize_bool if opt[:bool]
-            opt[:tag_bool] ||= :and
-            tag_match = opt[:tag].nil? || opt[:tag].empty? ? true : item.tags?(opt[:tag], opt[:tag_bool])
-            keep = false unless tag_match
-            keep = opt[:not] ? !keep : keep
-          end
+      items.sort_by! { |item| [item.date, item.title.downcase] }.reverse
 
-          if keep && opt[:search]
-            search_match = if opt[:search].nil? || opt[:search].empty?
-                             true
-                           else
-                             item.search(opt[:search], case_type: opt[:case].normalize_case)
-                           end
+      filtered_items = items.select do |item|
+        keep = true
+        if opt[:unfinished]
+          finished = item.tags?('done', :and)
+          finished = opt[:not] ? !finished : finished
+          keep = false if finished
+        end
 
-            keep = false unless search_match
-            keep = opt[:not] ? !keep : keep
-          end
+        if keep && opt[:val]&.count&.positive?
+          bool = opt[:bool].normalize_bool if opt[:bool]
+          bool ||= :and
+          bool = :and if bool == :pattern
 
-          if keep && opt[:date_filter]&.length == 2
-            start_date = opt[:date_filter][0]
-            end_date = opt[:date_filter][1]
-
-            in_date_range = if end_date
-                              item.date >= start_date && item.date <= end_date
-                            else
-                              item.date.strftime('%F') == start_date.strftime('%F')
-                            end
-            keep = false unless in_date_range
-            keep = opt[:not] ? !keep : keep
-          end
+          val_match = opt[:val].nil? || opt[:val].empty? ? true : item.tag_values?(opt[:val], bool)
+          keep = false unless val_match
+          keep = opt[:not] ? !keep : keep
+        end
 
-          if keep && opt[:time_filter][0] || opt[:time_filter][1]
-            start_string = if opt[:time_filter][0].nil?
-                             "#{item.date.strftime('%Y-%m-%d')} 12am"
-                           else
-                             "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][0]}"
-                           end
-            start_time = start_string.chronify(guess: :begin)
+        if keep && opt[:tag]
+          opt[:tag_bool] = opt[:bool].normalize_bool if opt[:bool]
+          opt[:tag_bool] ||= :and
+          tag_match = opt[:tag].nil? || opt[:tag].empty? ? true : item.tags?(opt[:tag], opt[:tag_bool])
+          keep = false unless tag_match
+          keep = opt[:not] ? !keep : keep
+        end
 
-            end_string = if opt[:time_filter][1].nil?
-                           "#{item.date.to_datetime.next_day.strftime('%Y-%m-%d')} 12am"
+        if keep && opt[:search]
+          search_match = if opt[:search].nil? || opt[:search].empty?
+                           true
                          else
-                           "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][1]}"
+                           item.search(opt[:search], case_type: opt[:case].normalize_case)
                          end
-            end_time = end_string.chronify(guess: :end)
 
-            in_time_range = item.date >= start_time && item.date <= end_time
-            keep = false unless in_time_range
-            keep = opt[:not] ? !keep : keep
-          end
-
-          keep = false if keep && opt[:only_timed] && !item.interval
+          keep = false unless search_match
+          keep = opt[:not] ? !keep : keep
+        end
 
-          if keep && opt[:tag_filter]
-            keep = item.tags?(opt[:tag_filter]['tags'], opt[:tag_filter]['bool'])
-            keep = opt[:not] ? !keep : keep
-          end
+        if keep && opt[:date_filter]&.length == 2
+          start_date = opt[:date_filter][0]
+          end_date = opt[:date_filter][1]
+
+          in_date_range = if end_date
+                            item.date >= start_date && item.date <= end_date
+                          else
+                            item.date.strftime('%F') == start_date.strftime('%F')
+                          end
+          keep = false unless in_date_range
+          keep = opt[:not] ? !keep : keep
+        end
 
-          if keep && opt[:before]
-            before = opt[:before]
-            cutoff = if before =~ time_rx
-                       "#{item.date.strftime('%Y-%m-%d')} #{before}".chronify(guess: :begin)
-                     elsif before.is_a?(String)
-                       before.chronify(guess: :begin)
-                     else
-                       before
-                     end
-            keep = cutoff && item.date <= cutoff
-            keep = opt[:not] ? !keep : keep
-          end
+        if keep && opt[:time_filter][0] || opt[:time_filter][1]
+          start_string = if opt[:time_filter][0].nil?
+                           "#{item.date.strftime('%Y-%m-%d')} 12am"
+                         else
+                           "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][0]}"
+                         end
+          start_time = start_string.chronify(guess: :begin)
+
+          end_string = if opt[:time_filter][1].nil?
+                         "#{item.date.to_datetime.next_day.strftime('%Y-%m-%d')} 12am"
+                       else
+                         "#{item.date.strftime('%Y-%m-%d')} #{opt[:time_filter][1]}"
+                       end
+          end_time = end_string.chronify(guess: :end)
+
+          in_time_range = item.date >= start_time && item.date <= end_time
+          keep = false unless in_time_range
+          keep = opt[:not] ? !keep : keep
+        end
 
-          if keep && opt[:after]
-            after = opt[:after]
-            cutoff = if after =~ time_rx
-                       "#{item.date.strftime('%Y-%m-%d')} #{after}".chronify(guess: :end)
-                     elsif after.is_a?(String)
-                       after.chronify(guess: :end)
-                     else
-                       after
-                     end
-            keep = cutoff && item.date >= cutoff
-            keep = opt[:not] ? !keep : keep
-          end
+        keep = false if keep && opt[:only_timed] && !item.interval
 
-          if keep && opt[:today]
-            keep = item.date >= Date.today.to_time && item.date < Date.today.next_day.to_time
-            keep = opt[:not] ? !keep : keep
-          elsif keep && opt[:yesterday]
-            keep = item.date >= Date.today.prev_day.to_time && item.date < Date.today.to_time
-            keep = opt[:not] ? !keep : keep
-          end
+        if keep && opt[:tag_filter]
+          keep = item.tags?(opt[:tag_filter]['tags'], opt[:tag_filter]['bool'])
+          keep = opt[:not] ? !keep : keep
+        end
 
-          keep
+        if keep && opt[:before]
+          before = opt[:before]
+          cutoff = if before =~ time_rx
+                     "#{item.date.strftime('%Y-%m-%d')} #{before}".chronify(guess: :begin)
+                   elsif before.is_a?(String)
+                     before.chronify(guess: :begin)
+                   else
+                     before
+                   end
+          keep = cutoff && item.date <= cutoff
+          keep = opt[:not] ? !keep : keep
         end
-        count = opt[:count].to_i&.positive? ? opt[:count].to_i : filtered_items.count
 
-        output = Items.new
+        if keep && opt[:after]
+          after = opt[:after]
+          cutoff = if after =~ time_rx
+                     "#{item.date.strftime('%Y-%m-%d')} #{after}".chronify(guess: :end)
+                   elsif after.is_a?(String)
+                     after.chronify(guess: :end)
+                   else
+                     after
+                   end
+          keep = cutoff && item.date >= cutoff
+          keep = opt[:not] ? !keep : keep
+        end
 
-        if opt[:age] && opt[:age].normalize_age == :oldest
-          output.concat(filtered_items.slice(0, count).reverse)
-        else
-          output.concat(filtered_items.reverse.slice(0, count))
+        if keep && opt[:today]
+          keep = item.date >= Date.today.to_time && item.date < Date.today.next_day.to_time
+          keep = opt[:not] ? !keep : keep
+        elsif keep && opt[:yesterday]
+          keep = item.date >= Date.today.prev_day.to_time && item.date < Date.today.to_time
+          keep = opt[:not] ? !keep : keep
         end
 
-        logger.benchmark(:filter_items, :finish)
+        keep
+      end
+      count = opt[:count].to_i&.positive? ? opt[:count].to_i : filtered_items.count
+
+      output = Items.new
 
-        output
+      if opt[:age] && opt[:age].normalize_age == :oldest
+        output.concat(filtered_items.slice(0, count).reverse)
+      else
+        output.concat(filtered_items.reverse.slice(0, count))
       end
+
+      logger.benchmark(:filter_items, :finish)
+
+      output
     end
   end
 end

data/lib/doing/wwid/guess.rb

@@ -2,86 +2,84 @@
 
 module Doing
   class WWID
-    # Section and view guessing methods for WWID class
-    module Guess
-      ##
-      ## Attempt to match a string with an existing section
-      ##
-      ## @param      frag     [String] The user-provided string
-      ## @param      guessed  [Boolean] already guessed and failed
-      ##
-      def guess_section(frag, guessed: false, suggest: false)
-        return 'All' if frag =~ /^all$/i
-        frag ||= Doing.setting('current_section')
+    ##
+    ## Attempt to match a string with an existing section
+    ##
+    ## @param      frag     [String] The user-provided string
+    ## @param      guessed  [Boolean] already guessed and failed
+    ##
+    def guess_section(frag, guessed: false, suggest: false)
+      return 'All' if frag =~ /^all$/i
 
-        return frag.cap_first if @content.section?(frag)
+      frag ||= Doing.setting('current_section')
 
-        found = @content.guess_section(frag, distance: 2)
+      return frag.cap_first if @content.section?(frag)
 
-        section = found ? found.title : nil
+      found = @content.guess_section(frag, distance: 2)
 
-        return section if suggest
+      section = found ? found.title : nil
 
-        unless section || guessed
-          alt = guess_view(frag, guessed: true, suggest: true)
-          if alt
-            prompt = Color.template("{bw}Did you mean `{xy}doing {by}view {xy}#{alt}`{bw}?{x}")
-            meant_view = Prompt.yn(prompt, default_response: 'n')
+      return section if suggest
 
-            msg = format('%<y>srun with `%<w>sdoing view %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
-            raise Errors::WrongCommand.new(msg, topic: 'Try again:') if meant_view
+      unless section || guessed
+        alt = guess_view(frag, guessed: true, suggest: true)
+        if alt
+          prompt = Color.template("{bw}Did you mean `{xy}doing {by}view {xy}#{alt}`{bw}?{x}")
+          meant_view = Prompt.yn(prompt, default_response: 'n')
 
-          end
+          msg = format('%<y>srun with `%<w>sdoing view %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
+          raise Errors::WrongCommand.new(msg, topic: 'Try again:') if meant_view
 
-          res = Prompt.yn("#{boldwhite}Section #{frag.yellow}#{boldwhite} not found, create it", default_response: 'n')
+        end
 
-          if res
-            @content.add_section(frag.cap_first, log: true)
-            write(@doing_file)
-            return frag.cap_first
-          end
+        res = Prompt.yn("#{boldwhite}Section #{frag.yellow}#{boldwhite} not found, create it", default_response: 'n')
 
-          raise Errors::InvalidSection.new("unknown section #{frag.bold.white}", topic: 'Missing:')
+        if res
+          @content.add_section(frag.cap_first, log: true)
+          write(@doing_file)
+          return frag.cap_first
         end
-        section ? section.cap_first : guessed
+
+        raise Errors::InvalidSection.new("unknown section #{frag.bold.white}", topic: 'Missing:')
       end
+      section ? section.cap_first : guessed
+    end
 
-      ##
-      ## Attempt to match a string with an existing view
-      ##
-      ## @param      frag     [String] The user-provided string
-      ## @param      guessed  [Boolean] already guessed
-      ##
-      def guess_view(frag, guessed: false, suggest: false)
-        views.each { |view| return view if frag.downcase == view.downcase }
-        view = false
-        re = frag.to_rx(distance: 2, case_type: :ignore)
-        views.each do |v|
-          next unless v =~ /#{re}/i
-
-          logger.debug('Match:', %(Assuming "#{v}" from "#{frag}"))
-          view = v
-          break
-        end
-        unless view || guessed
-          alt = guess_section(frag, guessed: true, suggest: true)
+    ##
+    ## Attempt to match a string with an existing view
+    ##
+    ## @param      frag     [String] The user-provided string
+    ## @param      guessed  [Boolean] already guessed
+    ##
+    def guess_view(frag, guessed: false, suggest: false)
+      views.each { |view| return view if frag.downcase == view.downcase }
+      view = nil
+      re = frag.to_rx(distance: 2, case_type: :ignore)
+      views.each do |v|
+        next unless v =~ /#{re}/i
+
+        logger.debug('Match:', %(Assuming "#{v}" from "#{frag}"))
+        view = v
+        break
+      end
+      unless view || guessed
+        alt = guess_section(frag, guessed: true, suggest: true)
 
-          raise Errors::InvalidView.new(%(unknown view #{frag.bold.white}), topic: 'Missing:') unless alt
+        raise Errors::InvalidView.new(%(unknown view #{frag.bold.white}), topic: 'Missing:') unless alt
 
-          prompt = Color.template("{bw}Did you mean `{xy}doing {by}show {xy}#{alt}`{bw}?{x}")
-          meant_view = Prompt.yn(prompt, default_response: 'n')
+        prompt = Color.template("{bw}Did you mean `{xy}doing {by}show {xy}#{alt}`{bw}?{x}")
+        meant_view = Prompt.yn(prompt, default_response: 'n')
 
-          if meant_view
-            msg = format('%<y>srun with `%<w>sdoing show %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
-            raise Errors::WrongCommand.new(msg, topic: 'Try again:')
+        if meant_view
+          msg = format('%<y>srun with `%<w>sdoing show %<alt>s%<y>s`', w: boldwhite, y: yellow, alt: alt)
+          raise Errors::WrongCommand.new(msg, topic: 'Try again:')
 
-          end
+        end
 
-          raise Errors::InvalidView.new(%(unknown view #{alt.bold.white}), topic: 'Missing:')
+        raise Errors::InvalidView.new(%(unknown view #{alt.bold.white}), topic: 'Missing:')
 
-        end
-        view
       end
+      view
     end
   end
 end