doing 2.1.3 → 2.1.6

data/lib/doing/string.rb

@@ -28,7 +28,9 @@ module Doing
     ##
     ## @return     [Regexp] Regex pattern
     ##
-    def to_rx(distance: 3, case_type: :smart)
+    def to_rx(distance: nil, case_type: nil)
+      distance ||= Doing.config.settings.dig('search', 'distance').to_i || 3
+      case_type ||= Doing.config.settings.dig('search', 'case')&.normalize_case || :smart
       case_sensitive = case case_type
                        when :smart
                          self =~ /[A-Z]/ ? true : false
@@ -44,7 +46,9 @@ module Doing
                 when /^'/
                   sub(/^'(.*?)'?$/, '\1')
                 else
-                  split(/ +/).map { |w| w.split('').join(".{0,#{distance}}") }.join('.*?')
+                  split(/ +/).map do |w|
+                    w.split('').join(".{0,#{distance}}").gsub(/\+/, '\+').wildcard_to_rx
+                  end.join('.*?')
                 end
       Regexp.new(pattern, !case_sensitive)
     end
@@ -72,7 +76,7 @@ module Doing
     end
 
     ## @param (see #highlight_tags)
-    def highlight_tags!(color = 'yellow')
+    def highlight_tags!(color = 'yellow', last_color: nil)
       replace highlight_tags(color)
     end
 
@@ -83,17 +87,18 @@ module Doing
     ##
     ## @return     [String] string with @tags highlighted
     ##
-    def highlight_tags(color = 'yellow')
-      escapes = scan(/(\e\[[\d;]+m)[^\e]+@/)
-      color = color.split(' ') unless color.is_a?(Array)
-      tag_color = ''
-      color.each { |c| tag_color += Doing::Color.send(c) }
-      last_color = if !escapes.empty?
-                     escapes[-1][0]
-                   else
-                     Doing::Color.default
-                   end
-      gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{Doing::Color.reset}#{last_color}")
+    def highlight_tags(color = 'yellow', last_color: nil)
+      unless last_color
+        escapes = scan(/(\e\[[\d;]+m)[^\e]+@/)
+        color = color.split(' ') unless color.is_a?(Array)
+        tag_color = color.each_with_object([]) { |c, arr| arr << Doing::Color.send(c) }.join('')
+        last_color = if !escapes.empty?
+                       (escapes.count > 1 ? escapes[-2..-1] : [escapes[-1]]).map { |v| v[0] }.join('')
+                     else
+                       Doing::Color.default
+                     end
+      end
+      gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{last_color}")
     end
 
     ##
@@ -192,11 +197,25 @@ module Doing
     ## @param      offset  [Integer] (Optional) The width to pad each subsequent line
     ## @param      prefix  [String] (Optional) A prefix to add to each line
     ##
-    def wrap(len, pad: 0, indent: '  ', offset: 0, prefix: '', color: '', after: '', reset: '')
+    def wrap(len, pad: 0, indent: '  ', offset: 0, prefix: '', color: '', after: '', reset: '', pad_first: false)
       last_color = color.empty? ? '' : after.last_color
-      note_rx = /(?i-m)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)/
+      note_rx = /(?mi)(?<!\\)%(?<width>-?\d+)?(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])(?<icount>\d+))?(?<prefix>.[ _t]?)?note/
+      note = ''
+      after = after.dup if after.frozen?
+      after.sub!(note_rx) do
+        note = Regexp.last_match(0)
+        ''
+      end
+
+      left_pad = ' ' * offset
+      left_pad += indent
+
+
+      # return "#{left_pad}#{prefix}#{color}#{self}#{last_color} #{note}" unless len.positive?
+
       # Don't break inside of tag values
-      str = gsub(/@\S+\(.*?\)/) { |tag| tag.gsub(/\s/, '%%%%') }
+      str = gsub(/@\S+\(.*?\)/) { |tag| tag.gsub(/\s/, '%%%%') }.gsub(/\n/, ' ')
+
       words = str.split(/ /).map { |word| word.gsub(/%%%%/, ' ') }
       out = []
       line = []
@@ -215,18 +234,18 @@ module Doing
         line << word.uncolor
       end
       out.push(line.join(' '))
-      note = ''
-      after = after.dup if after.frozen?
-      after.sub!(note_rx) do
-        note = Regexp.last_match(0)
-        ''
-      end
 
+      last_color = ''
       out[0] = format("%-#{pad}s%s%s", out[0], last_color, after)
 
-      left_pad = ' ' * offset
-      left_pad += indent
-      out.map { |l| "#{left_pad}#{color}#{l}#{last_color}" }.join("\n").strip + last_color + " #{note}".chomp
+      out.map.with_index { |l, idx|
+        if !pad_first && idx == 0
+          "#{color}#{prefix}#{l}#{last_color}"
+        else
+          "#{left_pad}#{color}#{prefix}#{l}#{last_color}"
+        end
+      }.join("\n") + " #{note}".chomp
+      # res.join("\n").strip + last_color + " #{note}".chomp
     end
 
     ##
@@ -240,6 +259,10 @@ module Doing
       end
     end
 
+    def pluralize(number)
+      number == 1 ? self : "#{self}s"
+    end
+
     ##
     ## Convert a sort order string to a qualified type
     ##
@@ -271,7 +294,7 @@ module Doing
 
     def normalize_case(default = :smart)
       case self
-      when /^c/i
+      when /^(c|sens)/i
         :sensitive
       when /^i/i
         :ignore
@@ -299,11 +322,35 @@ module Doing
         :or
       when /(not|none)/i
         :not
+      when /^p/i
+        :pattern
       else
         default.is_a?(Symbol) ? default : default.normalize_bool
       end
     end
 
+    ##
+    ## Convert a matching configuration string to a 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
+        :fuzzy
+      when /^p/i
+        :pattern
+      when /^e/i
+        :exact
+      else
+        default.is_a?(Symbol) ? default : default.normalize_matching
+      end
+    end
+
     def normalize_trigger!
       replace normalize_trigger
     end
@@ -312,8 +359,16 @@ module Doing
       gsub(/\((?!\?:)/, '(?:').downcase
     end
 
+    def wildcard_to_rx
+      gsub(/\?/, '\S').gsub(/\*/, '\S*?')
+    end
+
+    def add_at
+      strip.sub(/^([+-]*)@/, '\1')
+    end
+
     def to_tags
-      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map { |t| t.strip.sub(/^@/, '') }
+      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map(&:add_at)
     end
 
     def add_tags!(tags, remove: false)
@@ -533,7 +588,7 @@ module Doing
         end
       else
         case self
-        when / *, */
+        when /(^\[.*?\]$| *, *)/
           gsub(/^\[ *| *\]$/, '').split(/ *, */)
         when /^[0-9]+$/
           to_i

data/lib/doing/string_chronify.rb

@@ -41,7 +41,11 @@ module Doing
       if secs_ago
         now - secs_ago
       else
-        Chronic.parse(self, { guess: options.fetch(:guess, :begin), context: options.fetch(:future, false) ? :future : :past, ambiguous_time_range: 8 })
+        Chronic.parse(self, {
+                        guess: options.fetch(:guess, :begin),
+                        context: options.fetch(:future, false) ? :future : :past,
+                        ambiguous_time_range: 8
+                      })
       end
     end
 

data/lib/doing/symbol.rb

@@ -16,5 +16,9 @@ module Doing
     def normalize_case
       self
     end
+
+    def normalize_matching(default = :pattern)
+      to_s.normalize_matching(default)
+    end
   end
 end

data/lib/doing/template_string.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## Template string formatting
+  ##
+  class TemplateString < String
+    class ::String
+      ##
+      ## Extract the longest valid color from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ## @api private
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym)
+        end
+
+        valid_color
+      end
+    end
+
+    attr_reader :original
+
+    include Color
+    def initialize(string, placeholders: {}, force_color: false, wrap_width: 0, color: '', tags_color: '', reset: '')
+      Color.coloring = true if force_color
+      @colors = nil
+      @original = string
+      super(Color.reset + string)
+
+      placeholders.each { |k, v| fill(k, v, wrap_width: wrap_width, color: color, tags_color: tags_color) }
+    end
+
+    ##
+    ## Test if string contains any valid %colors
+    ##
+    ## @return     [Boolean] True if colors, False otherwise.
+    ##
+    def colors?
+      scan(/%([a-z]+)/).each do
+        return true if Regexp.last_match(1).validate_color
+      end
+      false
+    end
+
+    def reparse
+      @parsed_colors = nil
+    end
+
+    ##
+    ## Return string with %colors replaced with escape codes
+    ##
+    ## @return     [String] colorized string
+    ##
+    def colored
+      reparse
+      parsed_colors[:string].apply_colors(parsed_colors[:colors])
+    end
+
+    ##
+    ## Remove all valid %colors from string
+    ##
+    ## @return     [String] cleaned string
+    ##
+    def raw
+      parsed_colors[:string].uncolor
+    end
+
+    def parsed_colors
+      @parsed_colors ||= parse_colors
+    end
+
+    ##
+    ## Parse a template string for %colors and return a hash
+    ## of colors and string locations
+    ##
+    ## @return     [Hash] Uncolored string and array of colors and locations
+    def parse_colors
+      working = dup
+      color_array = []
+
+      scan(/(?<!\\)(%([a-z]+))/).each do |color|
+        valid_color = color[1].validate_color
+        next unless valid_color
+
+        idx = working.match(/(?<!\\)%#{valid_color}/).begin(0)
+        color_array.push({ name: valid_color, color: Color.send(valid_color), index: idx })
+        working.sub!(/(?<!\\)%#{valid_color}/, '')
+      end
+
+      { string: working, colors: color_array }
+    end
+
+    ##
+    ## Apply a color array to a string
+    ##
+    ## @param      color_array  [Array] Array of hashes
+    ##                          containing :name, :color,
+    ##                          :index
+    ##
+    def apply_colors(color_array)
+      str = dup
+      color_array.reverse.each do |color|
+        c = color[:color].empty? ? Color.send(color[:name]) : color[:color]
+        str.insert(color[:index], c)
+      end
+      str
+    end
+
+    def fill(placeholder, value, wrap_width: 0, color: '', tags_color: '', reset: '')
+      reparse
+      rx = /(?mi)(?<!\\)%(?<width>-?\d+)?(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])(?<icount>\d+))?(?<prefix>.[ _t]?)?#{placeholder.sub(/^%/, '')}(?<after>.*?)$/
+      ph = raw.match(rx)
+
+      return unless ph
+      placeholder_offset = ph.begin(0)
+      last_colors = parsed_colors[:colors].select { |v| v[:index] <= placeholder_offset + 4 }
+
+      last_color = last_colors.map { |v| v[:color] }.pop(3).join('')
+
+      sub!(rx) do
+        m = Regexp.last_match
+
+        after = m['after']
+
+        if value.nil? || value.empty?
+          after
+        else
+          pad = m['width'].to_i
+          mark = m['mchar'] || ''
+          if placeholder == 'shortdate' && m['width'].nil?
+            pad = 13
+          end
+          indent = nil
+          if m['ichar']
+            char = m['ichar'] =~ /t/ ? "\t" : ' '
+            indent = char * m['icount'].to_i
+          end
+          indent ||= placeholder =~ /^title/ ? '' : "\t"
+          prefix = m['prefix']
+          if placeholder =~ /^title/
+            color = last_color + color
+
+            if wrap_width.positive? || pad.positive?
+              width = pad.positive? ? pad : wrap_width
+
+              out = value.gsub(/%/, '\%').strip.wrap(width,
+                                                     pad: pad,
+                                                     indent: indent,
+                                                     offset: placeholder_offset,
+                                                     prefix: prefix,
+                                                     color: color,
+                                                     after: after,
+                                                     reset: reset,
+                                                     pad_first: false)
+              out.highlight_tags!(tags_color, last_color: color) if tags_color && !tags_color.empty?
+              out
+            else
+              out = format("%s%s%#{pad}s%s", prefix, color, value.gsub(/%/, '\%').sub(/\s*$/, ''), after)
+              out.highlight_tags!(tags_color, last_color: color) if tags_color && !tags_color.empty?
+              out
+            end
+          elsif placeholder =~ /^note/
+            if wrap_width.positive? || pad.positive?
+              width = pad.positive? ? pad : wrap_width
+              outstring = value.map do |l|
+                if l.empty?
+                  '  '
+                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}  "
+                end
+              end.join("\n")
+              "\n#{last_color}#{mark}#{outstring}  "
+            else
+              out = format("\n%s%s%s%#{pad}s%s", indent, prefix, last_color, value.join("\n#{indent}#{prefix}").gsub(/%/, '\%').sub(/\s*$/, ''), after)
+              out.highlight_tags!(tags_color, last_color: last_color) if tags_color && !tags_color.empty?
+              out
+            end
+          else
+            format("%s%#{pad}s%s", prefix, value.gsub(/%/, '\%').sub(/\s*$/, ''), after)
+          end
+        end
+      end
+      @parsed_colors = parse_colors
+    end
+  end
+end

data/lib/doing/time.rb

@@ -14,5 +14,37 @@ module Doing
         strftime('%m/%d/%Y %_I:%M%P')
       end
     end
+
+    def humanize(seconds)
+      s = seconds
+      m = (s / 60).floor
+      s = (s % 60).floor
+      h = (m / 60).floor
+      m = (m % 60).floor
+      d = (h / 24).floor
+      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.join(', ')
+    end
+
+    def time_ago
+      if self > Date.today.to_time
+        output = humanize(Time.now - self)
+        "#{output} ago"
+      elsif self > (Date.today - 1).to_time
+        "Yesterday at #{strftime('%_I:%M:%S%P')}"
+      elsif self > (Date.today - 6).to_time
+        strftime('%a %I:%M:%S%P')
+      elsif self.year == Date.today.year
+        strftime('%m/%d %I:%M:%S%P')
+      else
+        strftime('%m/%d/%Y %I:%M:%S%P')
+      end
+    end
   end
 end

data/lib/doing/util.rb

@@ -112,20 +112,19 @@ module Doing
         puts content
         return
       end
-
+      Doing.logger.benchmark(:write_file, :start)
       file = File.expand_path(file)
 
-      if File.exist?(file) && backup
-        # Create a backup copy for the undo command
-        FileUtils.cp(file, "#{file}~")
-      end
+      Backup.write_backup(file) if backup
 
       File.open(file, 'w+') do |f|
         f.puts content
         Doing.logger.debug('Write:', "File written: #{file}")
       end
-
+      Doing.logger.benchmark(:_post_write_hook, :start)
       Hooks.trigger :post_write, file
+      Doing.logger.benchmark(:_post_write_hook, :finish)
+      Doing.logger.benchmark(:write_file, :finish)
     end
 
     def safe_load_file(filename)
@@ -133,7 +132,7 @@ module Doing
     end
 
     def default_editor
-      @default_editor = find_default_editor
+      @default_editor ||= find_default_editor
     end
 
     def editor_with_args