doing 2.1.37 → 2.1.40

data/lib/doing/item/query.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+module Doing
+  # Tag and search filtering for a Doing entry
+  class Item
+    ##
+    ## Test if item contains tag(s)
+    ##
+    ## @param      tags    (Array or String) The tags to test. Can be an array or a comma-separated string.
+    ## @param      bool    (Symbol) The boolean to use for multiple tags (:and, :or, :not)
+    ## @param      negate  [Boolean] negate the result?
+    ##
+    ## @return     [Boolean] true if tag/bool combination passes
+    ##
+    def tags?(tags, bool = :and, negate: false)
+      if bool == :pattern
+        tags = tags.to_tags.tags_to_array.join(' ')
+        matches = tag_pattern?(tags)
+
+        return negate ? !matches : matches
+      end
+
+      tags = split_tags(tags)
+      bool = bool.normalize_bool
+
+      matches = case bool
+                when :and
+                  all_tags?(tags)
+                when :not
+                  no_tags?(tags)
+                else
+                  any_tags?(tags)
+                end
+      negate ? !matches : matches
+    end
+
+    ##
+    ## Test if item matches tag values
+    ##
+    ## @param      queries (Array) The tag value queries to test
+    ## @param      bool    (Symbol) The boolean to use for multiple tags (:and, :or, :not)
+    ## @param      negate  [Boolean] negate the result?
+    ##
+    ## @return     [Boolean] true if tag/bool combination passes
+    ##
+    def tag_values?(queries, bool = :and, negate: false)
+      bool = bool.normalize_bool
+
+      matches = case bool
+                when :and
+                  all_values?(queries)
+                when :not
+                  no_values?(queries)
+                else
+                  any_values?(queries)
+                end
+      negate ? !matches : matches
+    end
+
+    ##
+    ## Determine if case should be ignored for searches
+    ##
+    ## @param      search     [String] The search string
+    ## @param      case_type  [Symbol] The case type
+    ##
+    ## @return     [Boolean] case should be ignored
+    ##
+    def ignore_case(search, case_type)
+      (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
+    end
+
+    def highlight_search(search, distance: nil, negate: false, case_type: nil)
+      prefs = Doing.setting('search', {})
+      matching = prefs.fetch('matching', 'pattern').normalize_matching
+      distance ||= prefs.fetch('distance', 3).to_i
+      case_type ||= prefs.fetch('case', 'smart').normalize_case
+      new_note = Note.new
+
+      if search.rx? || matching == :fuzzy
+        rx = search.to_rx(distance: distance, case_type: case_type)
+        new_title = @title.gsub(rx) { |m| yellow(m) }
+        new_note.add(@note.to_s.gsub(rx) { |m| yellow(m) })
+      else
+        query = search.strip.to_phrase_query
+
+        if query[:must].nil? && query[:must_not].nil?
+          query[:must] = query[:should]
+          query[:should] = []
+        end
+        query[:must].concat(query[:should]).each do |s|
+          rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+          new_title = @title.gsub(rx) { |m| yellow(m) }
+          new_note.add(@note.to_s.gsub(rx) { |m| yellow(m) })
+        end
+      end
+
+      Item.new(@date, new_title, @section, new_note)
+    end
+
+    ##
+    ## Test if item matches search string
+    ##
+    ## @param      search     [String] The search string
+    ## @param      negate     [Boolean] negate results
+    ## @param      case_type  (Symbol) The case-sensitivity
+    ##                        type (:sensitive,
+    ##                        :ignore, :smart)
+    ##
+    ## @return     [Boolean] matches search criteria
+    ##
+    def search(search, distance: nil, negate: false, case_type: nil)
+      prefs = Doing.setting('search', {})
+      matching = prefs.fetch('matching', 'pattern').normalize_matching
+      distance ||= prefs.fetch('distance', 3).to_i
+      case_type ||= prefs.fetch('case', 'smart').normalize_case
+
+      if search.rx? || matching == :fuzzy
+        matches = @title + @note.to_s =~ search.to_rx(distance: distance, case_type: case_type)
+      else
+        query = search.strip.to_phrase_query
+
+        if query[:must].nil? && query[:must_not].nil?
+          query[:must] = query[:should]
+          query[:should] = []
+        end
+        matches = no_searches?(query[:must_not], case_type: case_type)
+        matches &&= all_searches?(query[:must], case_type: case_type)
+        matches &&= any_searches?(query[:should], case_type: case_type)
+      end
+      # if search =~ /(?<=\A| )[+-]\S/
+      # else
+      #   text = @title + @note.to_s
+      #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
+      # end
+
+      # if search.rx? || !fuzzy
+      #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
+      # else
+      #   distance = 0.25 if distance > 1
+      #   score = if (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
+      #             text.downcase.pair_distance_similar(search.downcase)
+      #           else
+      #             score = text.pair_distance_similar(search)
+      #           end
+
+      #   if score >= distance
+      #     matches = true
+      #     Doing.logger.debug('Fuzzy Match:', %(#{@title}, "#{search}" #{score}))
+      #   end
+      # end
+
+      negate ? !matches : matches
+    end
+
+    private
+
+    def all_searches?(searches, case_type: :smart)
+      return true unless searches.good?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return false unless text =~ rx
+      end
+      true
+    end
+
+    def no_searches?(searches, case_type: :smart)
+      return true unless searches.good?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return false if text =~ rx
+      end
+      true
+    end
+
+    def any_searches?(searches, case_type: :smart)
+      return true unless searches.good?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return true if text =~ rx
+      end
+      false
+    end
+
+    def all_tags?(tags)
+      return true unless tags.good?
+
+      tags.each do |tag|
+        if tag =~ /done/ && !should_finish?
+          next
+        else
+          return false unless @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
+        end
+      end
+      true
+    end
+
+    def no_tags?(tags)
+      return true unless tags.good?
+
+      tags.each do |tag|
+        if tag =~ /done/ && !should_finish?
+          return false
+        else
+          return false if @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
+        end
+      end
+      true
+    end
+
+    def any_tags?(tags)
+      return true unless tags.good?
+
+      tags.each do |tag|
+        if tag =~ /done/ && !should_finish?
+          return true
+        else
+          return true if @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
+        end
+      end
+      false
+    end
+
+    def tag_pattern?(tags)
+      query = tags.to_query
+
+      no_tags?(query[:must_not]) && all_tags?(query[:must]) && any_tags?(query[:should])
+    end
+
+    def tag_value(tag)
+      res = @title.match(/@#{tag.sub(/^@/, '').wildcard_to_rx}\((.*?)\)/)
+      res ? res[1] : nil
+    end
+
+    def number_or_date(value)
+      return nil unless value
+
+      if value.strip =~ /^[0-9.]+%?$/
+        value.strip.to_f
+      else
+        value.strip.chronify(guess: :end)
+      end
+    end
+
+    def split_value_query(query)
+      val_rx = /^(!)?@?(\S+) +(!?[<>=][=*]?|[$*^]=) +(.*?)$/
+      query.match(val_rx)
+    end
+
+    def any_values?(queries)
+      return true unless queries.good?
+
+      queries.each do |q|
+        parts = split_value_query(q)
+        return true if tag_value_matches?(parts[2], parts[3], parts[4], parts[1])
+      end
+      false
+    end
+
+    def all_values?(queries)
+      return true unless queries.good?
+
+      queries.each do |q|
+        parts = split_value_query(q)
+
+        return false unless tag_value_matches?(parts[2], parts[3], parts[4], parts[1])
+      end
+      true
+    end
+
+    def no_values?(queries)
+      return true unless queries.good?
+
+      queries.each do |q|
+        parts = split_value_query(q)
+        return false if tag_value_matches?(parts[2], parts[3], parts[4], parts[1])
+      end
+      true
+    end
+
+    def duration_matches?(value, comp)
+      return false if interval.nil?
+
+      val = value.chronify_qty
+      case comp
+      when /^<$/
+        interval < val
+      when /^<=$/
+        interval <= val
+      when /^>$/
+        interval > val
+      when /^>=$/
+        interval >= val
+      when /^!=/
+        interval != val
+      when /^=/
+        interval == val
+      end
+    end
+
+    def date_matches?(value, comp)
+      time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/i
+      value = "#{@date.strftime('%Y-%m-%d')} #{value}" if value =~ time_rx
+
+      val = value.chronify(guess: :begin)
+      raise InvalidTimeExpression, "Unrecognized date/time expression (#{value})" if val.nil?
+
+      case comp
+      when /^<$/
+        @date < val
+      when /^<=$/
+        @date <= val
+      when /^>$/
+        @date > val
+      when /^>=$/
+        @date >= val
+      when /^!=/
+        @date != val
+      when /^=/
+        @date == val
+      end
+    end
+
+    def value_string_matches?(tag_val, comp, value)
+      case comp
+      when /\^=/
+        tag_val =~ /^#{value.wildcard_to_rx}/i
+      when /\$=/
+        tag_val =~ /#{value.wildcard_to_rx}$/i
+      when %r{==}
+        tag_val =~ /^#{value.wildcard_to_rx}$/i
+      else
+        tag_val =~ /#{value.wildcard_to_rx}/i
+      end
+    end
+
+    def value_number_matches?(tag_val, comp, value)
+      case comp
+      when /^<$/
+        tag_val < value
+      when /^<=$/
+        tag_val <= value
+      when /^>$/
+        tag_val > value
+      when /^>=$/
+        tag_val >= value
+      when /^!=/
+        tag_val != value
+      when /^=/
+        tag_val == value
+      end
+    end
+
+    ##
+    ## Test if a tag's value matches a given value. Value
+    ## can be a date string, a text string, or a
+    ## number/percentage. Type of comparison is determined
+    ## by the comparitor and the objects being compared.
+    ##
+    ## @param      tag     [String] The tag name from which
+    ##                     to get the value
+    ## @param      comp    [String] The comparator (e.g. >=
+    ##                     or *=)
+    ## @param      value   [String] The value to test
+    ##                     against
+    ## @param      negate  [Boolean] Negate the response
+    ##
+    ## @return     True if tag value matches, False otherwise.
+    ##
+    def tag_value_matches?(tag, comp, value, negate)
+      # If tag matches existing tag
+      if tags?(tag, :and)
+        tag_val = tag_value(tag)
+
+        # If the tag value is not a date and contains alpha
+        # characters and comparison is ==, or comparison is
+        # a string comparitor (*= ^= $=)
+        if (value.chronify.nil? && value =~ /[a-z]/i && comp =~ /^!?==?$/) || comp =~ /[$*^]=/
+          is_match = value_string_matches?(tag_val, comp, value)
+
+          comp =~ /!/ || negate ? !is_match : is_match
+        else
+          # Convert values to either a number or a date
+          tag_val = number_or_date(tag_val)
+          val = number_or_date(value)
+
+          # Fail if either value is nil
+          return false if val.nil? || tag_val.nil?
+
+          # Fail unless both values are of the same class (float or date)
+          return false unless val.class == tag_val.class
+
+          is_match = value_number_matches?(tag_val, comp, val)
+
+          negate.nil? ? is_match : !is_match
+        end
+      # If tag name matches a trigger for elapsed time test
+      elsif tag =~ /^(elapsed|dur(ation)?|int(erval)?)$/i
+        is_match = duration_matches?(value, comp)
+
+        comp =~ /!/ || negate ? !is_match : is_match
+      # Else if tag name matches a trigger for start date
+      elsif tag =~ /^(d(ate)?|t(ime)?)$/i
+        is_match = date_matches?(value, comp)
+
+        comp =~ /!/ || negate ? !is_match : is_match
+      # Else if tag name matches a trigger for all text
+      elsif tag =~ /^text$/i
+        is_match = value_string_matches?([@title, @note.to_s(prefix: '')].join(' '), comp, value)
+
+        comp =~ /!/ || negate ? !is_match : is_match
+      # Else if tag name matches a trigger for title
+      elsif tag =~ /^title$/i
+        is_match = value_string_matches?(@title, comp, value)
+
+        comp =~ /!/ || negate ? !is_match : is_match
+      # Else if tag name matches a trigger for note
+      elsif tag =~ /^note$/i
+        is_match = value_string_matches?(@note.to_s(prefix: ''), comp, value)
+
+        comp =~ /!/ || negate ? !is_match : is_match
+      # Else if item contains tag being tested
+      else
+        false
+      end
+    end
+  end
+end

data/lib/doing/item/state.rb

@@ -0,0 +1,59 @@
+module Doing
+  # State queries for a Doing entry
+  class Item
+    ##
+    ## Test if item has a @done tag
+    ##
+    ## @return     [Boolean] true item has @done tag
+    ##
+    def finished?
+      tags?('done')
+    end
+
+    ##
+    ## Test if item does not contain @done tag
+    ##
+    ## @return     [Boolean] true if item is missing @done tag
+    ##
+    def unfinished?
+      tags?('done', negate: true)
+    end
+
+    ##
+    ## Test if item is included in never_finish config and
+    ## thus should not receive a @done tag
+    ##
+    ## @return     [Boolean] item should receive @done tag
+    ##
+    def should_finish?
+      should?('never_finish')
+    end
+
+    ##
+    ## Test if item is included in never_time config and
+    ## thus should not receive a date on the @done tag
+    ##
+    ## @return     [Boolean] item should receive @done date
+    ##
+    def should_time?
+      should?('never_time')
+    end
+
+    private
+
+    def should?(key)
+      config = Doing.settings
+      return true unless config[key].is_a?(Array)
+
+      config[key].each do |tag|
+        if tag =~ /^@/
+          return false if tags?(tag.sub(/^@/, '').downcase)
+        elsif section.downcase == tag.downcase
+          return false
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/doing/item/tags.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Doing
+  # A Doing entry
+  class Item
+    ##
+    ## Add (or remove) tags from the title of the item
+    ##
+    ## @param      tags    [Array] The tags to apply
+    ## @param      options Additional options
+    ##
+    ## @option options :date       [Boolean] Include timestamp?
+    ## @option options :single     [Boolean] Log as a single change?
+    ## @option options :value      [String] A value to include as @tag(value)
+    ## @option options :remove     [Boolean] if true remove instead of adding
+    ## @option options :rename_to  [String] if not nil, rename target tag to this tag name
+    ## @option options :regex      [Boolean] treat target tag string as regex pattern
+    ## @option options :force      [Boolean] with rename_to, add tag if it doesn't exist
+    ##
+    def tag(tags, **options)
+      added = []
+      removed = []
+
+      date = options.fetch(:date, false)
+      options[:value] ||= date ? Time.now.strftime('%F %R') : nil
+      options.delete(:date)
+
+      single = options.fetch(:single, false)
+      options.delete(:single)
+
+      tags = tags.to_tags if tags.is_a? ::String
+
+      remove = options.fetch(:remove, false)
+      tags.each do |tag|
+        if tag =~ /^(\S+)\((.*?)\)$/
+          m = Regexp.last_match
+          tag = m[1]
+          options[:value] ||= m[2]
+        end
+
+        bool = remove ? :and : :not
+        if tags?(tag, bool) || options[:value]
+          @title = @title.tag(tag, **options).strip
+          remove ? removed.push(tag) : added.push(tag)
+        end
+      end
+
+      Doing.logger.log_change(tags_added: added, tags_removed: removed, count: 1, item: self, single: single)
+
+      self
+    end
+
+    ##
+    ## Get a list of tags on the item
+    ##
+    ## @return     [Array] array of tags (no values)
+    ##
+    def tags
+      @title.scan(/(?<= |\A)@([^\s(]+)/).map { |tag| tag[0] }.sort.uniq
+    end
+
+    ##
+    ## Return all tags including parenthetical values
+    ##
+    ## @return     [Array<Array>] Array of array pairs,
+    ##             [[tag1, value], [tag2, value]]
+    ##
+    def tags_with_values
+      @title.scan(/(?<= |\A)@([^\s(]+)(?:\((.*?)\))?/).map { |tag| [tag[0], tag[1]] }.sort.uniq
+    end
+
+    ##
+    ## convert tags on item to an array with @ symbols removed
+    ##
+    ## @return     [Array] array of tags
+    ##
+    def tag_array
+      tags.tags_to_array
+    end
+
+    private
+
+    def split_tags(tags)
+      tags.to_tags.tags_to_array
+    end
+  end
+end