doing 2.1.14 → 2.1.18

data/lib/doing/string.rb

@@ -101,6 +101,46 @@ module Doing
       gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{last_color}")
     end
 
+    def to_phrase_query(query)
+      parser = PhraseParser::QueryParser.new
+      transformer = PhraseParser::QueryTransformer.new
+      parse_tree = parser.parse(query)
+      transformer.apply(parse_tree).to_elasticsearch
+    end
+
+    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)
+      replace highlight_search(search, distance: distance, negate: negate, case_type: case_type)
+    end
+
+    def highlight_search(search, distance: nil, negate: false, case_type: nil)
+      out = dup
+      prefs = Doing.config.settings['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.is_rx? || matching == :fuzzy
+        rx = search.to_rx(distance: distance, case_type: case_type)
+        out.gsub!(rx) { |m| m.bgyellow.black }
+      else
+        query = to_phrase_query(search.strip)
+
+        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))
+          out.gsub!(rx) { |m| m.bgyellow.black }
+        end
+      end
+      out
+    end
+
     ##
     ## Test if line should be ignored
     ##
@@ -259,7 +299,13 @@ module Doing
       end
     end
 
-    def pluralize(number)
+    ##
+    ## Pluralize a string based on quantity
+    ##
+    ## @param      number  [Integer] the quantity of the
+    ##                     object the string represents
+    ##
+    def to_p(number)
       number == 1 ? self : "#{self}s"
     end
 
@@ -268,10 +314,6 @@ module Doing
     ##
     ## @return     [Symbol] :oldest or :newest
     ##
-    def normalize_age!(default = :newest)
-      replace normalize_age(default)
-    end
-
     def normalize_age(default = :newest)
       case self
       when /^o/i
@@ -283,6 +325,11 @@ module Doing
       end
     end
 
+    ## @see #normalize_age
+    def normalize_age!(default = :newest)
+      replace normalize_age(default)
+    end
+
     ##
     ## Convert a sort order string to a qualified type
     ##
@@ -308,10 +355,6 @@ module Doing
     ##
     ## @return     Symbol :smart, :sensitive, :ignore
     ##
-    def normalize_case!
-      replace normalize_case
-    end
-
     def normalize_case(default = :smart)
       case self
       when /^(c|sens)/i
@@ -325,15 +368,16 @@ module Doing
       end
     end
 
+    ## @see #normalize_case
+    def normalize_case!
+      replace normalize_case
+    end
+
     ##
     ## Convert a boolean string to a symbol
     ##
     ## @return     Symbol :and, :or, or :not
     ##
-    def normalize_bool!(default = :and)
-      replace normalize_bool(default)
-    end
-
     def normalize_bool(default = :and)
       case self
       when /(and|all)/i
@@ -349,15 +393,19 @@ module Doing
       end
     end
 
+    ## @see #normalize_bool
+    def normalize_bool!(default = :and)
+      replace normalize_bool(default)
+    end
+
     ##
     ## Convert a matching configuration string to a symbol
     ##
+    ## @param      default  [Symbol] the default matching
+    ##                      type to return if the string
+    ##                      doesn't match a known symbol
     ## @return     Symbol :fuzzy, :pattern, :exact
     ##
-    def normalize_matching!(default = :pattern)
-      replace normalize_bool(default)
-    end
-
     def normalize_matching(default = :pattern)
       case self
       when /^f/i
@@ -371,30 +419,64 @@ module Doing
       end
     end
 
-    def normalize_trigger!
-      replace normalize_trigger
+    ## @see #normalize_matching
+    def normalize_matching!(default = :pattern)
+      replace normalize_bool(default)
     end
 
+    ##
+    ## Adds ?: to any parentheticals in a regular expression
+    ## to avoid match groups
+    ##
+    ## @return     [String] modified regular expression
+    ##
     def normalize_trigger
       gsub(/\((?!\?:)/, '(?:').downcase
     end
 
+    ## @see #normalize_trigger
+    def normalize_trigger!
+      replace normalize_trigger
+    end
+
+    ##
+    ## Convert ? and * wildcards to regular expressions.
+    ## Uses \S (non-whitespace) instead of . (any character)
+    ##
+    ## @return     [String] Regular expression string
+    ##
     def wildcard_to_rx
       gsub(/\?/, '\S').gsub(/\*/, '\S*?')
     end
 
+    ##
+    ## Add @ prefix to string if needed, maintains +/- prefix
+    ##
+    ## @return     [String] @string
+    ##
     def add_at
       strip.sub(/^([+-]*)@/, '\1')
     end
 
+    ##
+    ## Convert a list of tags to an array. Tags can be with
+    ## or without @ symbols, separated by any character, and
+    ## can include parenthetical values (with spaces)
+    ##
+    ## @return     [Array] array of tags including @ symbols
+    ##
     def to_tags
-      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map(&:add_at)
-    end
-
-    def add_tags!(tags, remove: false)
-      replace add_tags(tags, remove: remove)
+      gsub(/ *, */, ' ').scan(/(@?(?:\S+(?:\(.+\)))|@?(?:\S+))/).map(&:first).sort.uniq.map(&:add_at)
     end
 
+    ##
+    ## @brief      Adds tags to a string
+    ##
+    ## @param      tags    [String or Array] List of tags to add. @ symbol optional
+    ## @param      remove  [Boolean] remove tags instead of adding
+    ##
+    ## @return     [String] the tagged string
+    ##
     def add_tags(tags, remove: false)
       title = self.dup
       tags = tags.to_tags
@@ -402,6 +484,11 @@ module Doing
       title
     end
 
+    ## @see #add_tags
+    def add_tags!(tags, remove: false)
+      replace add_tags(tags, remove: remove)
+    end
+
     ##
     ## Add, rename, or remove a tag in place
     ##
@@ -484,10 +571,6 @@ module Doing
     ##
     ## @return     Deduplicated string
     ##
-    def dedup_tags!
-      replace dedup_tags
-    end
-
     def dedup_tags
       title = dup
       tags = title.scan(/(?<=\A| )(@(\S+?)(\([^)]+\))?)(?= |\Z)/).uniq
@@ -505,6 +588,11 @@ module Doing
       title
     end
 
+    ## @see #dedup_tags
+    def dedup_tags!
+      replace dedup_tags
+    end
+
     # Returns the last escape sequence from a string.
     #
     # Actually returns all escape codes, with the assumption
@@ -525,11 +613,9 @@ module Doing
     ##
     ## @param      opt   [Hash] Additional Options
     ##
-    def link_urls!(**opt)
-      fmt = opt.fetch(:format, :html)
-      replace link_urls(format: fmt)
-    end
-
+    ## @option opt [Symbol] :format can be :markdown or
+    ## :html (default)
+    ##
     def link_urls(**opt)
       fmt = opt.fetch(:format, :html)
       return self unless fmt
@@ -541,6 +627,12 @@ module Doing
       str.replace_qualified_urls(format: fmt).clean_unlinked_urls
     end
 
+    ## @see #link_urls
+    def link_urls!(**opt)
+      fmt = opt.fetch(:format, :html)
+      replace link_urls(format: fmt)
+    end
+
     # Remove <self-linked> formatting
     def remove_self_links
       gsub(/<(.*?)>/) do |match|
@@ -590,6 +682,18 @@ module Doing
       end
     end
 
+    ##
+    ## Convert a string value to an appropriate type. If
+    ## kind is not specified, '[one, two]' becomes an Array,
+    ## '1' becomes Integer, '1.5' becomes Float, 'true' or
+    ## 'yes' becomes TrueClass, 'false' or 'no' becomes
+    ## FalseClass.
+    ##
+    ## @param      kind  [String] specify string, array,
+    ##                   integer, float, symbol, or boolean
+    ##                   (falls back to string if value is
+    ##                   not recognized)
+    ## @return Converted object type
     def set_type(kind = nil)
       if kind
         case kind.to_s

data/lib/doing/string_chronify.rb

@@ -64,22 +64,120 @@ module Doing
       when /^(\d+):(\d\d)$/
         minutes += Regexp.last_match(1).to_i * 60
         minutes += Regexp.last_match(2).to_i
-      when /^(\d+(?:\.\d+)?)([hmd])?$/
-        amt = Regexp.last_match(1)
-        type = Regexp.last_match(2).nil? ? 'm' : Regexp.last_match(2)
-
-        minutes = case type.downcase
-                  when 'm'
-                    amt.to_i
-                  when 'h'
-                    (amt.to_f * 60).round
-                  when 'd'
-                    (amt.to_f * 60 * 24).round
-                  else
-                    minutes
-                  end
+      when /^(\d+(?:\.\d+)?)([hmd])?/
+        scan(/(\d+(?:\.\d+)?)([hmd])?/).each do |m|
+          amt = m[0]
+          type = m[1].nil? ? 'm' : m[1]
+
+          minutes += case type.downcase
+                     when 'm'
+                       amt.to_i
+                     when 'h'
+                       (amt.to_f * 60).round
+                     when 'd'
+                       (amt.to_f * 60 * 24).round
+                     else
+                       0
+                     end
+        end
       end
       minutes * 60
     end
+
+    ##
+    ## Convert DD:HH:MM to seconds
+    ##
+    ## @return     [Integer] rounded number of seconds
+    ##
+    def to_seconds
+      mtch = match(/(\d+):(\d+):(\d+)/)
+
+      raise Errors::DoingRuntimeError, "Invalid time string: #{self}" unless mtch
+
+      h = mtch[1]
+      m = mtch[2]
+      s = mtch[3]
+      (h.to_i * 60 * 60) + (m.to_i * 60) + s.to_i
+    end
+
+    ##
+    ## Convert DD:HH:MM to a natural language string
+    ##
+    ## @param      format  [Symbol] The format to output (:dhm, :hm, :m, :clock, :natural)
+    ##
+    def time_string(format: :dhm)
+      to_seconds.time_string(format: format)
+    end
+
+    ##
+    ## Convert (chronify) natural language dates
+    ## within configured date tags (tags whose value is
+    ## expected to be a date). Modifies string in place.
+    ##
+    ## @param      additional_tags  [Array] An array of
+    ##                              additional tags to
+    ##                              consider date_tags
+    ##
+    def expand_date_tags(additional_tags = nil)
+      iso_rx = /\d{4}-\d\d-\d\d \d\d:\d\d/
+
+      watch_tags = [
+        'start(?:ed)?',
+        'beg[ia]n',
+        'done',
+        'finished',
+        'completed?',
+        'waiting',
+        'defer(?:red)?'
+      ]
+
+      if additional_tags
+        date_tags = additional_tags
+        date_tags = date_tags.split(/ *, */) if date_tags.is_a?(String)
+        date_tags.map! do |tag|
+          tag.sub(/^@/, '').gsub(/\((?!\?:)(.*?)\)/, '(?:\1)').strip
+        end
+        watch_tags.concat(date_tags).uniq!
+      end
+
+      done_rx = /(?<=^| )@(?<tag>#{watch_tags.join('|')})\((?<date>.*?)\)/i
+
+      gsub!(done_rx) do
+        m = Regexp.last_match
+        t = m['tag']
+        d = m['date']
+        future = t =~ /^(done|complete)/ ? false : true
+        parsed_date = d =~ iso_rx ? Time.parse(d) : d.chronify(guess: :begin, future: future)
+        parsed_date.nil? ? m[0] : "@#{t}(#{parsed_date.strftime('%F %R')})"
+      end
+    end
+
+    ##
+    ## Splits a range string and returns an array of
+    ## DateTime objects as [start, end]. If only one date is
+    ## given, end time is nil.
+    ##
+    ## @return     [Array<DateTime>] Start and end dates as
+    ##             array
+    ## @example    Process a natural language date range
+    ## "mon 3pm to mon 5pm".split_date_range
+    ##
+    def split_date_range
+      date_string = dup
+      case date_string
+      when / (to|through|thru|(un)?til|-+) /
+        dates = date_string.split(/ (?:to|through|thru|(?:un)?til|-+) /)
+        start = dates[0].chronify(guess: :begin)
+        finish = dates[-1].chronify(guess: :end)
+      else
+        start = date_string.chronify(guess: :begin)
+        finish = nil
+      end
+
+      raise InvalidTimeExpression, 'Unrecognized date string' unless start
+
+      Doing.logger.debug('Parser:', "date range interpreted as #{start.strftime('%F %R')} -- #{finish ? finish.strftime('%F %R') : 'now'}")
+      [start, finish]
+    end
   end
 end

data/lib/doing/template_string.rb

@@ -176,7 +176,7 @@ module Doing
                   '  '
                 else
                   line = l.gsub(/%/, '\%').strip.wrap(width, pad: pad, indent: indent, offset: 0, prefix: prefix, color: last_color, after: after, reset: reset, pad_first: true)
-                  line.highlight_tags!(tags_color, last_color: last_color) unless tags_color.nil? || tags_color.empty?
+                  line.highlight_tags!(tags_color, last_color: last_color) unless !tags_color || tags_color.nil? || tags_color.empty?
                   "#{line}  "
                 end
               end.join("\n")

data/lib/doing/time.rb

@@ -25,10 +25,10 @@ module Doing
       h = h % 24
 
       output = []
-      output.push("#{d} #{'day'.pluralize(d)}") if d.positive?
-      output.push("#{h} #{'hour'.pluralize(h)}") if h.positive?
-      output.push("#{m} #{'minute'.pluralize(m)}") if m.positive?
-      output.push("#{s} #{'second'.pluralize(s)}") if s.positive?
+      output.push("#{d} #{'day'.to_p(d)}") if d.positive?
+      output.push("#{h} #{'hour'.to_p(h)}") if h.positive?
+      output.push("#{m} #{'minute'.to_p(m)}") if m.positive?
+      output.push("#{s} #{'second'.to_p(s)}") if s.positive?
       output.join(', ')
     end
 

data/lib/doing/util_backup.rb

@@ -79,7 +79,7 @@ module Doing
       def redo_backup(filename = nil, count: 1)
         filename ||= Doing.config.settings['doing_file']
         # redo_file = File.join(backup_dir, "undone___#{File.basename(filename)}")
-        undones = Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).sort
+        undones = Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).sort.reverse
         total = undones.count
         count = total if count > total
 

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.14'
+  VERSION = '2.1.18'
 end