doing 2.1.11 → 2.1.15

data/lib/doing/plugins/export/template_export.rb

@@ -5,6 +5,7 @@
 # author: Brett Terpstra
 # url: https://brettterpstra.com
 module Doing
+  # Template Export
   class TemplateExport
     include Doing::Color
     include Doing::Util
@@ -32,7 +33,7 @@ module Doing
 
         placeholders = {}
 
-        if (!item.note.empty?) && wwid.config['include_notes']
+        if !item.note.empty? && wwid.config['include_notes']
           note = item.note.map(&:strip).delete_if(&:empty?)
           note.map! { |line| "#{line.sub(/^\t*/, '')}  " }
 
@@ -42,122 +43,74 @@ module Doing
               line.simple_wrap(width)
               # line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
             end
-            note = note.delete_if(&:empty?)
+            note.delete_if(&:empty?)
           end
         else
           note = []
         end
 
-        # output.sub!(/%(\d+)?date/) do
-        #   pad = Regexp.last_match(1).to_i
-        #   format("%#{pad}s", item.date.strftime(opt[:format]))
-        # end
         placeholders['date'] = item.date.strftime(opt[:format])
 
         interval = wwid.get_interval(item, record: true, formatted: false) if opt[:times]
         if interval
-          case opt[:interval_format].to_sym
-          when :human
-            _d, h, m = wwid.format_time(interval, human: true)
-            interval = format('%<h> 4dh %<m>02dm', h: h, m: m)
-          else
-            d, h, m = wwid.format_time(interval)
-            interval = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
-          end
+          interval = case opt[:interval_format].to_sym
+                     when :human
+                       interval.time_string(format: :hm)
+                     else
+                       interval.time_string(format: :clock)
+                     end
         end
 
         interval ||= ''
-        # output.sub!(/%interval/, interval)
         placeholders['interval'] = interval
 
         duration = item.duration if opt[:duration]
         if duration
-          case opt[:interval_format].to_sym
-          when :human
-            _d, h, m = wwid.format_time(duration, human: true)
-            duration = format('%<h> 4dh %<m>02dm', h: h, m: m)
-          else
-            d, h, m = wwid.format_time(duration)
-            duration = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
-          end
+          duration = case opt[:interval_format].to_sym
+                     when :human
+                       duration.time_string(format: :hm)
+                     else
+                       duration.time_string(format: :clock)
+                     end
         end
         duration ||= ''
-        # output.sub!(/%duration/, duration)
         placeholders['duration'] = duration
 
-        # output.sub!(/%(\d+)?shortdate/) do
-        #   pad = Regexp.last_match(1) || 13
-        #   format("%#{pad}s", item.date.relative_date)
-        # end
-        placeholders['shortdate'] = format("%13s", item.date.relative_date)
-        # output.sub!(/%section/, item.section) if item.section
+        placeholders['shortdate'] = format('%13s', item.date.relative_date)
         placeholders['section'] = item.section || ''
         placeholders['title'] = item.title
-
-        # title_rx = /(?mi)%(?<width>-?\d+)?(?:(?<ichar>[ _t])(?<icount>\d+))?(?<prefix>.[ _t]?)?title(?<after>.*?)$/
-        # title_color = Doing::Color.reset + output.match(/(?mi)^(.*?)(%.*?title)/)[1].last_color
-
-        # title_offset = Doing::Color.uncolor(output).match(title_rx).begin(0)
-
-        # output.sub!(title_rx) do
-        #   m = Regexp.last_match
-
-        #   after = m['after']
-        #   pad = m['width'].to_i
-        #   indent = ''
-        #   if m['ichar']
-        #     char = m['ichar'] =~ /t/ ? "\t" : ' '
-        #     indent = char * m['icount'].to_i
-        #   end
-        #   prefix = m['prefix']
-        #   if opt[:wrap_width]&.positive? || pad.positive?
-        #     width = pad.positive? ? pad : opt[:wrap_width]
-        #     item.title.wrap(width, pad: pad, indent: indent, offset: title_offset, prefix: prefix, color: title_color, after: after, reset: reset)
-        #     # flag + item.title.gsub(/(.{#{opt[:wrap_width]}})(?=\s+|\Z)/, "\\1\n ").sub(/\s*$/, '') + reset
-        #   else
-        #     format("%s%#{pad}s%s", prefix, item.title.sub(/\s*$/, ''), after)
-        #   end
-        # end
-
-
-
         placeholders['note'] = note
         placeholders['idnote'] = note.empty? ? '' : "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}"
         placeholders['odnote'] = note.empty? ? '' : "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}"
-        placeholders['chompnote'] = note.empty? ? '' : note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
-
-        # if note.empty?
-        #   output.gsub!(/%(chomp|[io]d|(\^.)?(([ _t]|[^a-z0-9])?\d+)?(.[ _t]?)?)?note/, '')
-        # else
-        #   output.sub!(/%note/, "\n#{note.map { |l| "\t#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/%idnote/, "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/%odnote/, "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/(?mi)%(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])?(?<icount>\d+))?(?<prefix>.[ _t]?)?note/) do
-        #     m = Regexp.last_match
-        #     mark = m['mchar'] || ''
-        #     indent = if m['ichar']
-        #                char = m['ichar'] =~ /t/ ? "\t" : ' '
-        #                char * m['icount'].to_i
-        #              else
-        #                ''
-        #              end
-        #     prefix = m['prefix'] || ''
-        #     "\n#{note.map { |l| "#{mark}#{indent}#{prefix}#{l.strip}  " }.join("\n")}"
-        #   end
-
-        #   output.sub!(/%chompnote/) do
-        #     note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
-        #   end
-        # end
 
-        template = opt[:template].dup
-        template.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
-        output = Doing::TemplateString.new(template, placeholders: placeholders, wrap_width: opt[:wrap_width], color: flag, tags_color: opt[:tags_color], reset: reset).colored
+        chompnote = []
+        unless note.empty?
+          chompnote = note.map do |l|
+            l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ')
+          end
+        end
+        placeholders['chompnote'] = chompnote.join(' ')
 
-        output.gsub!(/(?<!\\)%hr(_under)?/) do
+        template = opt[:template].dup
+        note_rx = /(?i-m)(?x:^([\s\S]*?)
+                    (%(?:[io]d|(?:\^[\s\S])?
+                    (?:(?:[ _t]|[^a-z0-9])?\d+)?
+                    (?:[\s\S][ _t]?)?)?note)
+                    ([\s\S]*?)$)/
+        template.sub!(note_rx, '\1\3\2')
+        output = Doing::TemplateString.new(template,
+                                           color: flag,
+                                           placeholders: placeholders,
+                                           reset: reset,
+                                           tags_color: opt[:tags_color],
+                                           wrap_width: opt[:wrap_width]).colored
+
+        output.gsub!(/(?<!\\)%(\S)?hr(_under)?/) do
           o = ''
-          `tput cols`.to_i.times do
-            o += Regexp.last_match(1).nil? ? '-' : '_'
+          TTY::Screen.columns.to_i.times do
+            char = Regexp.last_match(2).nil? ? '-' : '_'
+            char = Regexp.last_match(1).nil? ? char : Regexp.last_match(1)
+            o += char
           end
           o
         end
@@ -170,7 +123,11 @@ module Doing
       end
 
       # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:template]}")
-      out += wwid.tag_times(format: wwid.config['timer_format'].to_sym, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) if opt[:totals]
+      if opt[:totals]
+        out += wwid.tag_times(format: wwid.config['timer_format'].to_sym,
+                              sort_by_name: opt[:sort_tags],
+                              sort_order: opt[:tag_order])
+      end
       out
     end
 

data/lib/doing/plugins/import/calendar_import.rb

@@ -61,7 +61,19 @@ module Doing
         title.strip!
         new_entry = Item.new(start_time, title, section)
         new_entry.note = entry['notes'].split(/\n/).map(&:chomp) if entry.key?('notes')
-        new_items.push(new_entry)
+
+        is_match = true
+
+        if options[:search]
+          is_match = new_entry.search(options[:search], case_type: options[:date], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = start_time > options[:date_filter][0] && start_time < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        new_items.push(new_entry) if is_match
       end
       total = new_items.count
 

data/lib/doing/plugins/import/doing_import.rb

@@ -68,7 +68,18 @@ module Doing
         new_item = Item.new(item.date, title, section)
         new_item.note = item.note
 
-        imported.push(new_item)
+        is_match = true
+
+        if options[:search]
+          is_match = new_item.search(options[:search], case_type: options[:case], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = new_item.date > options[:date_filter][0] && new_item.date < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        imported.push(new_item) if is_match
       end
 
       dups = new_items.count - imported.count

data/lib/doing/plugins/import/timing_import.rb

@@ -63,7 +63,19 @@ module Doing
         title.strip!
         new_item = Item.new(start_time, title, section)
         new_item.note.add(entry['notes']) if entry.key?('notes')
-        new_items.push(new_item)
+
+        is_match = true
+
+        if options[:search]
+          is_match = new_item.search(options[:search], case_type: options[:case], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = start_time > options[:date_filter][0] && start_time < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        new_items.push(new_item) if is_match
       end
       total = new_items.count
       skipped = data.count - total

data/lib/doing/prompt.rb

@@ -23,6 +23,18 @@ module Doing
         $stdin.gets.strip
       end
 
+      def request_lines(prompt: 'Enter text')
+        ask_note = []
+        reader = TTY::Reader.new(interrupt: -> { raise Errors::UserCancelled }, track_history: false)
+        puts "#{boldgreen(prompt.sub(/:?$/, ':'))} #{yellow('Hit return for a new line, ')}#{boldwhite('enter a blank line (')}#{boldyellow('return twice')}#{boldwhite(') to end editing')}"
+        loop do
+          res = reader.read_line(green('> '))
+          break if res.strip.empty?
+
+          ask_note.push(res)
+        end
+        ask_note.join("\n").strip
+      end
 
       ##
       ## Ask a yes or no question in the terminal
@@ -205,7 +217,7 @@ module Doing
           out = [
             format("%#{pad}d", i),
             ') ',
-            format('%13s', item.date.relative_date),
+            format('%16s', item.date.strftime('%Y-%m-%d %H:%M')),
             ' | ',
             item.title
           ]

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

@@ -8,10 +8,10 @@ module Doing
         strftime('%_I:%M%P')
       elsif self > (Date.today - 6).to_time
         strftime('%a %_I:%M%P')
-      elsif self.year == Date.today.year
+      elsif self.year == Date.today.year || (self.year + 1 == Date.today.year && self.month > Date.today.month)
         strftime('%m/%d %_I:%M%P')
       else
-        strftime('%m/%d/%Y %_I:%M%P')
+        strftime('%m/%d/%y %_I:%M%P')
       end
     end
 
@@ -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.11'
+  VERSION = '2.1.15'
 end