doing 2.1.14 → 2.1.15

data/lib/doing/string.rb

@@ -259,7 +259,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 +274,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 +285,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 +315,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 +328,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 +353,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 +379,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 +444,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 +531,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 +548,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 +573,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 +587,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 +642,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,92 @@ 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)
+      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
-                    minutes
-                  end
+          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
   end
 end

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.15'
 end

data/lib/doing/wwid.rb

@@ -185,34 +185,9 @@ module Doing
 
       date = 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 @config['date_tags']
-        date_tags = @config['date_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
       date_rx = /^(?:\s*- )?(?<date>.*?) \| (?=\S)/
 
-      title.gsub!(done_rx) do
-        m = Regexp.last_match
-        t = m['tag']
-        d = m['date']
-        parsed_date = d =~ date_rx ? Time.parse(d) : d.chronify(guess: :begin)
-        parsed_date.nil? ? m[0] : "@#{t}(#{parsed_date.strftime('%F %R')})"
-      end
+      title.expand_date_tags(@config['date_tags'])
 
       if title =~ date_rx
         m = title.match(date_rx)
@@ -369,7 +344,8 @@ module Doing
         items.each_with_index do |i, x|
           next if i.title =~ / @done/
 
-          items[x].title = "#{i.title} @done(#{opt[:back].strftime('%F %R')})"
+          finish_date = verify_duration(i.date, opt[:back], title: i.title)
+          items[x].tag('done', value: finish_date.strftime('%F %R'))
           break
         end
       end
@@ -1001,7 +977,7 @@ module Doing
                                                  '--no-sort',
                                                  '--info=hidden'
                                                ])
-            next if tag =~ /^ *$/
+            next if output_format =~ /^ *$/
 
             raise UserCancelled unless output_format
 
@@ -1089,6 +1065,7 @@ module Doing
         tag = opt[:tag]
         items.map! do |i|
           i.tag(tag, date: false, remove: opt[:remove], single: single)
+          i.expand_date_tags(@config['date_tags'])
           Hooks.trigger :post_entry_updated, self, i
         end
       end
@@ -1148,6 +1125,26 @@ module Doing
       end
     end
 
+    def verify_duration(date, finish_date, title: nil)
+      max_elapsed = @config.dig('interaction', 'confirm_longer_than') || 0
+      max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
+      elapsed = finish_date - date
+
+      if max_elapsed.positive? && (elapsed > max_elapsed)
+        puts boldwhite(title) if title
+        human = elapsed.time_string(format: :natural)
+        res = Prompt.yn(yellow("Did this entry actually take #{human}"), default_response: true)
+        unless res
+          new_elapsed = Prompt.enter_text('How long did it take?').chronify_qty
+          raise InvalidTimeExpression, 'Unrecognized time span entry' unless new_elapsed.positive?
+
+          finish_date = date + new_elapsed if new_elapsed
+        end
+      end
+
+      finish_date
+    end
+
     ##
     ## Tag the last entry or X entries
     ##
@@ -1209,21 +1206,8 @@ module Doing
                         else
                           next_entry.date - 60
                         end
-          elsif opt[:took]
-            if item.date + opt[:took] > Time.now
-              item.date = Time.now - opt[:took]
-              done_date = Time.now
-            else
-              done_date = item.date + opt[:took]
-            end
-          elsif opt[:back]
-            done_date = if opt[:back].is_a? Integer
-                          item.date + opt[:back]
-                        else
-                          item.date + (opt[:back] - item.date)
-                        end
           else
-            done_date = Time.now
+            done_date = item.calculate_end_date(opt)
           end
 
           opt[:tags].each do |tag|
@@ -1234,7 +1218,28 @@ module Doing
               next
             end
 
+
             tag = tag.strip
+
+            if tag =~ /^done$/
+              max_elapsed = @config.dig('interaction', 'confirm_longer_than') || 0
+              max_elapsed = max_elapsed.chronify_qty if max_elapsed.is_a?(String)
+              elapsed = done_date - item.date
+
+              if max_elapsed.positive? && (elapsed > max_elapsed) && !opt[:took]
+                puts boldwhite(item.title)
+                human = elapsed.time_string(format: :natural)
+                res = Prompt.yn(yellow("Did this actually take #{human}"), default_response: true)
+                unless res
+                  new_elapsed = Prompt.enter_text('How long did it take?').chronify_qty
+                  raise InvalidTimeExpression, 'Unrecognized time span entry' unless new_elapsed > 0
+
+                  opt[:took] = new_elapsed
+                  done_date = item.calculate_end_date(opt) if opt[:took]
+                end
+              end
+            end
+
             if opt[:remove] || opt[:rename] || opt[:value]
               rename_to = nil
               if opt[:value]
@@ -1272,6 +1277,7 @@ module Doing
           logger.warn('Skipped:', 'Archiving is skipped when operating on all entries')
         end
 
+        item.expand_date_tags(@config['date_tags'])
         Hooks.trigger :post_entry_updated, self, item
       end
 
@@ -2005,7 +2011,7 @@ module Doing
 EOS
         sorted_tags_data.reverse.each do |k, v|
           if v > 0
-            output += "<tr><td style='text-align:left;'>#{k}</td><td style='text-align:left;'>#{'%02d:%02d:%02d' % format_time(v)}</td></tr>\n"
+            output += "<tr><td style='text-align:left;'>#{k}</td><td style='text-align:left;'>#{v.time_string(format: :clock)}</td></tr>\n"
           end
         end
         tail = <<EOS
@@ -2016,7 +2022,7 @@ EOS
         <tfoot>
         <tr>
           <td style="text-align:left;"><strong>Total</strong></td>
-          <td style="text-align:left;">#{'%02d:%02d:%02d' % format_time(total)}</td>
+          <td style="text-align:left;">#{total.time_string(format: :clock)}</td>
         </tr>
         </tfoot>
         </table>
@@ -2031,7 +2037,7 @@ EOS
         EOS
         sorted_tags_data.reverse.each do |k, v|
           if v > 0
-            output += "| #{' ' * (pad - k.length)}#{k} | #{'%02d:%02d:%02d' % format_time(v)} |\n"
+            output += "| #{' ' * (pad - k.length)}#{k} | #{v.time_string(format: :clock)} |\n"
           end
         end
         tail = "[Tag Totals]"
@@ -2039,11 +2045,10 @@ EOS
       when :json
         output = []
         sorted_tags_data.reverse.each do |k, v|
-          d, h, m = format_time(v)
           output << {
             'tag' => k,
             'seconds' => v,
-            'formatted' => format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
+            'formatted' => v.time_string(format: :clock)
           }
         end
         output
@@ -2054,8 +2059,7 @@ EOS
           (max - k.length).times do
             spacer += ' '
           end
-          _d, h, m = format_time(v, human: true)
-          output.push("┃ #{spacer}#{k}:#{format('%<h> 4dh %<m>02dm', h: h, m: m)} ┃")
+          output.push("┃ #{spacer}#{k}:#{v.time_string(format: :hm)} ┃")
         end
 
         header = '┏━━ Tag Totals '
@@ -2068,14 +2072,14 @@ EOS
         (max + 12).times { divider += '━' }
         divider += '┫'
         output = output.empty? ? '' : "\n#{header}\n#{output.join("\n")}"
-        d, h, m = format_time(total, human: true)
         output += "\n#{divider}"
         spacer = ''
         (max - 6).times do
           spacer += ' '
         end
+        total_time = total.time_string(format: :hm)
         total = "┃ #{spacer}total: "
-        total += format('%<h> 4dh %<m>02dm', h: h, m: m)
+        total += total_time
         total += ' ┃'
         output += "\n#{total}"
         output += "\n#{footer}"
@@ -2087,13 +2091,11 @@ EOS
           (max - k.length).times do
             spacer += ' '
           end
-          d, h, m = format_time(v)
-          output.push("#{k}:#{spacer}#{format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)}")
+          output.push("#{k}:#{spacer}#{v.time_string(format: :clock)}")
         end
 
         output = output.empty? ? '' : "\n--- Tag Totals ---\n#{output.join("\n")}"
-        d, h, m = format_time(total)
-        output += "\n\nTotal tracked: #{format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)}\n"
+        output += "\n\nTotal tracked: #{total.time_string(format: :clock)}\n"
         output
       end
     end
@@ -2118,39 +2120,12 @@ EOS
         record_tag_times(item, seconds) if record
         return seconds.positive? ? seconds : false unless formatted
 
-        return seconds.positive? ? format('%02d:%02d:%02d', *format_time(seconds)) : false
+        return seconds.positive? ? seconds.time_string(format: :clock) : false
       end
 
       false
     end
 
-    ##
-    ## Format human readable time from seconds
-    ##
-    ## @param      seconds  [Integer] Seconds
-    ##
-    def format_time(seconds, human: false)
-      return [0, 0, 0] if seconds.nil?
-
-      if seconds.instance_of?(String) && seconds =~ /(\d+):(\d+):(\d+)/
-        h = Regexp.last_match(1)
-        m = Regexp.last_match(2)
-        s = Regexp.last_match(3)
-        seconds = (h.to_i * 60 * 60) + (m.to_i * 60) + s.to_i
-      end
-      minutes = (seconds / 60).to_i
-      hours = (minutes / 60).to_i
-      if human
-        minutes = (minutes % 60).to_i
-        [0, hours, minutes]
-      else
-        days = (hours / 24).to_i
-        hours = (hours % 24).to_i
-        minutes = (minutes % 60).to_i
-        [days, hours, minutes]
-      end
-    end
-
     def configure(filename = nil)
       if filename
         Doing.config_with(filename, { ignore_local: true })