doing 2.1.12 → 2.1.13

data/lib/doing/item.rb

@@ -197,6 +197,29 @@ module Doing
       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
+
     def ignore_case(search, case_type)
       (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
     end
@@ -385,6 +408,102 @@ module Doing
       false
     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 if queries.nil? || queries.empty?
+
+      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 if queries.nil? || queries.empty?
+
+      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 if queries.nil? || queries.empty?
+
+      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 tag_value_matches?(tag, comp, value, negate)
+      if all_tags?([tag])
+        tag_val = tag_value(tag)
+
+        if (value.chronify.nil? && value =~ /[a-z]/i && comp =~ /^!?==?$/) || comp =~ /[$*^]=/
+          is_match = 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
+
+          comp =~ /!/ || negate ? !is_match : is_match
+        else
+          tag_val = number_or_date(tag_val)
+          val = number_or_date(value)
+
+          return false if val.nil? || tag_val.nil?
+
+          return false unless val.class == tag_val.class
+
+          matches = case comp
+                    when /^<$/
+                      tag_val < val
+                    when /^<=$/
+                      tag_val <= val
+                    when /^>$/
+                      tag_val > val
+                    when /^>=$/
+                      tag_val >= val
+                    when /^!=/
+                      tag_val != val
+                    when /^=/
+                      tag_val == val
+                    end
+          negate.nil? ? matches : !matches
+        end
+      else
+        false
+      end
+    end
+
     def to_query(query)
       parser = BooleanTermParser::QueryParser.new
       transformer = BooleanTermParser::QueryTransformer.new

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.12'
+  VERSION = '2.1.13'
 end

data/lib/doing/wwid.rb

@@ -640,6 +640,7 @@ module Doing
     ## @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: {})
       time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
@@ -701,6 +702,16 @@ module Doing
           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
+
+          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[:tag]
           opt[:tag_bool] = opt[:bool].normalize_bool if opt[:bool]
           opt[:tag_bool] ||= :and
@@ -887,7 +898,7 @@ module Doing
       opt[:query] = "!#{opt[:query]}" if opt[:not]
       opt[:multiple] = true
       opt[:show_if_single] = true
-      filter_options = %i[after before case date_filter from fuzzy not search section].each_with_object({}) {
+      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)
@@ -1221,14 +1232,17 @@ module Doing
             end
 
             tag = tag.strip
-            if opt[:remove] || opt[:rename]
+            if opt[:remove] || opt[:rename] || opt[:value]
               rename_to = nil
-              if opt[:rename]
+              if opt[:value]
+                rename_to = tag
+              elsif opt[:rename]
                 rename_to = tag
                 tag = opt[:rename]
               end
               old_title = item.title.dup
-              item.title.tag!(tag, remove: opt[:remove], rename_to: rename_to, regex: opt[:regex])
+              force = opt[:value].nil? ? false : true
+              item.title.tag!(tag, remove: opt[:remove], rename_to: rename_to, regex: opt[:regex], value: opt[:value], force: force)
               if old_title != item.title
                 removed << tag
                 added << rename_to if rename_to
@@ -1823,7 +1837,8 @@ module Doing
         case: options[:case],
         not: options[:negate],
         config_template: 'last',
-        delete: options[:delete]
+        delete: options[:delete],
+        val: options[:val]
       }
 
       if options[:tag]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: doing
 version: !ruby/object:Gem::Version
-  version: 2.1.12
+  version: 2.1.13
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-12 00:00:00.000000000 Z
+date: 2022-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: safe_yaml