doing 2.1.26 → 2.1.30

data/lib/doing/string/transform.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## String helpers
+  ##
+  class ::String
+    # Compress multiple spaces to single space
+    def compress
+      gsub(/ +/, ' ').strip
+    end
+
+    def compress!
+      replace compress
+    end
+
+    def simple_wrap(width)
+      str = gsub(/@\S+\(.*?\)/) { |tag| tag.gsub(/\s/, '%%%%') }
+      words = str.split(/ /).map { |word| word.gsub(/%%%%/, ' ') }
+      out = []
+      line = []
+
+      words.each do |word|
+        if word.uncolor.length >= width
+          chars = word.uncolor.split('')
+          out << chars.slice!(0, width - 1).join('') while chars.count >= width
+          line << chars.join('')
+          next
+        elsif line.join(' ').uncolor.length + word.uncolor.length + 1 > width
+          out.push(line.join(' '))
+          line.clear
+        end
+
+        line << word.uncolor
+      end
+      out.push(line.join(' '))
+      out.join("\n")
+    end
+
+    ##
+    ## Wrap string at word breaks, respecting tags
+    ##
+    ## @param      len     [Integer] The length
+    ## @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: '', pad_first: false)
+      last_color = color.empty? ? '' : after.last_color
+      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/, '%%%%') }.gsub(/\n/, ' ')
+
+      words = str.split(/ /).map { |word| word.gsub(/%%%%/, ' ') }
+      out = []
+      line = []
+
+      words.each do |word|
+        if word.uncolor.length >= len
+          chars = word.uncolor.split('')
+          out << chars.slice!(0, len - 1).join('') while chars.count >= len
+          line << chars.join('')
+          next
+        elsif line.join(' ').uncolor.length + word.uncolor.length + 1 > len
+          out.push(line.join(' '))
+          line.clear
+        end
+
+        line << word.uncolor
+      end
+      out.push(line.join(' '))
+
+      last_color = ''
+      out[0] = format("%-#{pad}s%s%s", out[0], last_color, after)
+
+      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
+
+    ##
+    ## Capitalize on the first character on string
+    ##
+    ## @return     Capitalized string
+    ##
+    def cap_first
+      sub(/^\w/) do |m|
+        m.upcase
+      end
+    end
+
+    ##
+    ## 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
+
+    ##
+    ## 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
+        when /^a/i
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^i/i
+          to_i
+        when /^(fa|tr)/i
+          to_bool
+        when /^f/i
+          to_f
+        when /^sy/i
+          sub(/^:/, '').to_sym
+        when /^b/i
+          self =~ /^(true|yes)$/ ? true : false
+        else
+          to_s
+        end
+      else
+        case self
+        when /(^\[.*?\]$| *, *)/
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^[0-9]+$/
+          to_i
+        when /^[0-9]+\.[0-9]+$/
+          to_f
+        when /^:\w+/
+          sub(/^:/, '').to_sym
+        when /^(true|yes)$/i
+          true
+        when /^(false|no)$/i
+          false
+        else
+          to_s
+        end
+      end
+    end
+  end
+end

data/lib/doing/string/truncate.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## String truncation
+  ##
+  class ::String
+    ##
+    ## Truncate to nearest word
+    ##
+    ## @param      len   The length
+    ##
+    def trunc(len, ellipsis: '...')
+      return self if length <= len
+
+      total = 0
+      res = []
+
+      split(/ /).each do |word|
+        break if total + 1 + word.length > len
+
+        total += 1 + word.length
+        res.push(word)
+      end
+      res.join(' ') + ellipsis
+    end
+
+    def trunc!(len, ellipsis: '...')
+      replace trunc(len, ellipsis: ellipsis)
+    end
+
+    ##
+    ## Truncate from middle to end at nearest word
+    ##
+    ## @param      len   The length
+    ##
+    def truncend(len, ellipsis: '...')
+      return self if length <= len
+
+      total = 0
+      res = []
+
+      split(/ /).reverse.each do |word|
+        break if total + 1 + word.length > len
+
+        total += 1 + word.length
+        res.unshift(word)
+      end
+      ellipsis + res.join(' ')
+    end
+
+    def truncend!(len, ellipsis: '...')
+      replace truncend(len, ellipsis: ellipsis)
+    end
+
+    ##
+    ## Truncate string in the middle, separating at nearest word
+    ##
+    ## @param      len       The length
+    ## @param      ellipsis  The ellipsis
+    ##
+    def truncmiddle(len, ellipsis: '...')
+      return self if length <= len
+      len -= (ellipsis.length / 2).to_i
+      half = (len / 2).to_i
+      start = trunc(half, ellipsis: ellipsis)
+      finish = truncend(half, ellipsis: '')
+      start + finish
+    end
+
+    def truncmiddle!(len, ellipsis: '...')
+      replace truncmiddle(len, ellipsis: ellipsis)
+    end
+  end
+end

data/lib/doing/string/url.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## URL linking and formatting
+  ##
+  class ::String
+    ##
+    ## Turn raw urls into HTML links
+    ##
+    ## @param      opt   [Hash] Additional Options
+    ##
+    ## @option opt [Symbol] :format can be :markdown or
+    ## :html (default)
+    ##
+    def link_urls(**opt)
+      fmt = opt.fetch(:format, :html)
+      return self unless fmt
+
+      str = dup
+
+      str = str.remove_self_links if fmt == :markdown
+
+      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|
+        m = Regexp.last_match
+        if m[1] =~ /^https?:/
+          m[1]
+        else
+          match
+        end
+      end
+    end
+
+    # Replace qualified urls
+    def replace_qualified_urls(**options)
+      fmt = options.fetch(:format, :html)
+      gsub(%r{(?mi)(?x:
+      (?<!["'\[(\\])
+      (?<protocol>(?:http|https)://)
+      (?<domain>[\w\-]+(?:\.[\w\-]+)+)
+      (?<path>[\w\-.,@?^=%&;:/~+#]*[\w\-@^=%&;/~+#])?
+      )}) do |_match|
+        m = Regexp.last_match
+        url = "#{m['domain']}#{m['path']}"
+        proto = m['protocol'].nil? ? 'http://' : m['protocol']
+        case fmt
+        when :terminal
+          TTY::Link.link_to("#{proto}#{url}", "#{proto}#{url}")
+        when :html
+          %(<a href="#{proto}#{url}" title="Link to #{m['domain']}">[#{url}]</a>)
+        when :markdown
+          "[#{url}](#{proto}#{url})"
+        else
+          m[0]
+        end
+      end
+    end
+
+    # Clean up unlinked <urls>
+    def clean_unlinked_urls
+      gsub(/<(\w+:.*?)>/) do |match|
+        m = Regexp.last_match
+        if m[1] =~ /<a href/
+          match
+        else
+          %(<a href="#{m[1]}" title="Link to #{m[1]}">[link]</a>)
+        end
+      end
+    end
+  end
+end

data/lib/doing/template_string.rb

@@ -5,28 +5,6 @@ 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

data/lib/doing/types.rb

@@ -2,6 +2,8 @@
 
 module Doing
   module Types
+    REGEX_CASE = /^[cis].*?$/i.freeze
+    REGEX_TAG_SORT = /^(?:n(?:ame)?|t(?:ime)?)$/i.freeze
     REGEX_BOOL = /^(?:and|all|any|or|not|none|p(?:at(?:tern)?)?)$/i.freeze
     REGEX_SORT_ORDER = /^(?:a(?:sc)?|d(?:esc)?)$/i.freeze
     REGEX_VALUE_QUERY = /^(?:!)?@?(?:\S+) +(?:!?[<>=][=*]?|[$*^]=) +(?:.*?)$/.freeze
@@ -22,5 +24,11 @@ module Doing
     DateRangeString = Class.new(Array)
     DateRangeOptionalString = Class.new(Array)
     DateIntervalString = Class.new(DateTime)
+    BooleanSymbol = Class.new(Symbol)
+    CaseSymbol = Class.new(Symbol)
+    AgeSymbol = Class.new(String)
+    OrderSymbol = Class.new(Symbol)
+    TagSortSymbol = Class.new(Symbol)
+    MatchingSymbol = Class.new(Symbol)
   end
 end

data/lib/doing/util.rb

@@ -170,29 +170,33 @@ module Doing
 
       if editor_config[editor_for]
         editor = editor_config[editor_for]
-        # Doing.logger.debug('Editor:', "Using #{editor} from config 'editors->#{editor_for}'")
-        return editor unless editor.good?
+        Doing.logger.debug('Editor:', "Using #{editor} from config 'editors.#{editor_for}' for #{editor_for}")
+        return editor if editor.good?
       end
 
       if editor_for != 'editor' && editor_config['default']
         editor = editor_config['default']
-        # Doing.logger.debug('Editor:', "Using #{editor} from config: 'editors->default'")
-        return editor unless editor.good?
+        Doing.logger.debug('Editor:', "Using #{editor} from config: 'editors.default' for #{editor_for}")
+        return editor if editor.good?
       end
 
       editor ||= ENV['DOING_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
 
-      unless editor.good?
-        # Doing.logger.debug('Editor:', "Found editor in environment variables: #{editor}")
+      if editor.good?
+        Doing.logger.debug('Editor:', "Found editor in environment variables: #{editor} for #{editor_for}")
         return editor
       end
 
-      Doing.logger.debug('ENV:', 'No EDITOR environment variable, testing available editors')
+      Doing.logger.debug('Editor:', 'No EDITOR environment variable, testing available editors')
       editors = %w[vim vi code subl mate mvim nano emacs]
       editors.each do |ed|
-        return TTY::Which.which(ed) if TTY::Which.which(ed)
+        try = TTY::Which.which(ed)
+        if try
+          Doing.logger.debug('Editor:', "Using editor #{try} for #{editor_for}")
+          return try
+        end
 
-        Doing.logger.debug('ENV:', "#{ed} not available")
+        Doing.logger.debug('Editor:', "#{ed} not available")
       end
 
       nil

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.26'
+  VERSION = '2.1.30'
 end

data/lib/doing/wwid.rb

@@ -77,7 +77,7 @@ module Doing
       lines.each do |line|
         next if line =~ /^\s*$/
 
-        if line =~ /^(\S[\S ]+):\s*(@\S+\s*)*$/
+        if line =~ /^(\S[\S ]+):( .*)?$/
           section = Regexp.last_match(1)
           @content.add_section(Section.new(section, original: line), log: false)
         elsif line =~ /^\s*- (\d{4}-\d\d-\d\d \d\d:\d\d) \| (.*)/
@@ -659,6 +659,7 @@ module Doing
     ## @option opt [Array] :val (nil) Array of tag value queries
     ##
     def filter_items(items = Items.new, opt: {})
+      logger.benchmark(:filter_items, :start)
       time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
 
       if items.nil? || items.empty?
@@ -810,6 +811,8 @@ module Doing
         output.concat(filtered_items.reverse.slice(0, count))
       end
 
+      logger.benchmark(:filter_items, :finish)
+
       output
     end
 
@@ -1211,6 +1214,7 @@ module Doing
       opt[:sequential] ||= false
       opt[:date] ||= false
       opt[:remove] ||= false
+      opt[:update] ||= false
       opt[:autotag] ||= false
       opt[:back] ||= false
       opt[:unfinished] ||= false
@@ -1323,7 +1327,7 @@ module Doing
             else
               old_title = item.title.dup
               should_date = opt[:date] && item.should_time?
-              item.title.tag!('done', remove: true) if tag =~ /done/ && !should_date
+              item.title.tag!('done', remove: true) if tag =~ /done/ && (!should_date || opt[:update])
               item.title.tag!(tag, value: should_date ? done_date.strftime('%F %R') : nil)
               added << tag if old_title != item.title
             end
@@ -1619,6 +1623,7 @@ module Doing
     ## @param      opt   [Hash] Additional Options
     ##
     def list_section(opt, items: Items.new)
+      logger.benchmark(:list_section, :start)
       opt[:config_template] ||= 'default'
 
       tpl_cfg = @config.dig('templates', opt[:config_template])
@@ -1632,7 +1637,7 @@ module Doing
       cfg.deep_merge({
                        'wrap_width' => @config['wrap_width'] || 0,
                        'date_format' => @config['default_date_format'],
-                       'order' => @config['order'] || 'asc',
+                       'order' => @config['order'] || :asc,
                        'tags_color' => @config['tags_color'],
                        'duration' => @config['duration'],
                        'interval_format' => @config['interval_format']
@@ -1644,8 +1649,8 @@ module Doing
       opt[:age] ||= :newest
       opt[:age] = opt[:age].normalize_age
       opt[:format] ||= cfg['date_format']
-      opt[:order] ||= cfg['order'] || 'asc'
-      opt[:tag_order] ||= 'asc'
+      opt[:order] ||= cfg['order'] || :asc
+      opt[:tag_order] ||= :asc
       opt[:tags_color] = cfg['tags_color'] || false if opt[:tags_color].nil?
       opt[:template] ||= cfg['template']
 
@@ -1671,7 +1676,7 @@ module Doing
 
       items = filter_items(items, opt: opt)
 
-      items.reverse! unless opt[:order] =~ /^d/i
+      items.reverse! unless opt[:order].normalize_order == :desc
 
       if opt[:delete]
         delete_items(items, force: opt[:force])
@@ -1694,6 +1699,7 @@ module Doing
       opt[:output] ||= 'template'
       opt[:wrap_width] ||= @config['templates']['default']['wrap_width'] || 0
 
+      logger.benchmark(:list_section, :finish)
       output(items, title, is_single, opt)
     end
 
@@ -1721,7 +1727,7 @@ module Doing
       destination = guess_section(destination)
 
       if @content.section?(destination) && (@content.section?(section) || archive_all)
-        do_archive(section, destination, { count: count, tags: tags, bool: bool, search: options[:search], label: options[:label], before: options[:before] })
+        do_archive(section, destination, { count: count, tags: tags, bool: bool, search: options[:search], label: options[:label], before: options[:before], after: options[:after], from: options[:from] })
         write(doing_file)
       else
         raise InvalidArgument, 'Either source or destination does not exist'
@@ -1743,7 +1749,7 @@ module Doing
       cfg = @config['templates'][opt[:config_template]].deep_merge(@config['templates']['default'], { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
         'wrap_width' => @config['wrap_width'] || 0,
         'date_format' => @config['default_date_format'],
-        'order' => @config['order'] || 'asc',
+        'order' => @config['order'] || :asc,
         'tags_color' => @config['tags_color'],
         'duration' => @config['duration'],
         'interval_format' => @config['interval_format']
@@ -1762,7 +1768,7 @@ module Doing
         from: opt[:from],
         format: cfg['date_format'],
         interval_format: opt[:interval_format],
-        order: cfg['order'] || 'asc',
+        order: cfg['order'] || :asc,
         output: output,
         section: opt[:section],
         sort_tags: opt[:sort_tags],
@@ -1797,7 +1803,7 @@ module Doing
       list_section({
                      section: section,
                      count: 0,
-                     order: 'asc',
+                     order: :asc,
                      date_filter: dates,
                      times: times,
                      output: output,
@@ -1863,7 +1869,7 @@ module Doing
       cfg = @config['templates'][opt[:config_template]].deep_merge(@config['templates']['default'], { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
         'wrap_width' => @config['wrap_width'] || 0,
         'date_format' => @config['default_date_format'],
-        'order' => @config['order'] || 'asc',
+        'order' => @config['order'] || :asc,
         'tags_color' => @config['tags_color'],
         'duration' => @config['duration'],
         'interval_format' => @config['interval_format']
@@ -1879,7 +1885,7 @@ module Doing
       opt[:count] = count
       opt[:format] = cfg['date_format']
       opt[:template] = opt[:template] || cfg['template']
-      opt[:order] = 'asc'
+      opt[:order] = :asc
       opt[:times] = times
 
       list_section(opt)
@@ -1896,7 +1902,7 @@ module Doing
       cfg = @config['templates'][options[:config_template]].deep_merge(@config['templates']['default'], { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
         'wrap_width' => @config['wrap_width'] || 0,
         'date_format' => @config['default_date_format'],
-        'order' => @config['order'] || 'asc',
+        'order' => @config['order'] || :asc,
         'tags_color' => @config['tags_color'],
         'duration' => @config['duration'],
         'interval_format' => @config['interval_format']
@@ -2043,10 +2049,10 @@ module Doing
     ##
     ## @param      format        [String] return format (html,
     ##                           json, or text)
-    ## @param      sort_by_name  [Boolean] Sort by name if true, otherwise by time
-    ## @param      sort_order    [String] The sort order (asc or desc)
+    ## @param      sort_by       [Symbol] Sort by :name or :time
+    ## @param      sort_order    [Symbol] The sort order (:asc or :desc)
     ##
-    def tag_times(format: :text, sort_by_name: false, sort_order: 'asc')
+    def tag_times(format: :text, sort_by: :time, sort_order: :asc)
       return '' if @timers.empty?
 
       max = @timers.keys.sort_by { |k| k.length }.reverse[0].length + 1
@@ -2054,13 +2060,13 @@ module Doing
       total = @timers.delete('All')
 
       tags_data = @timers.delete_if { |_k, v| v == 0 }
-      sorted_tags_data = if sort_by_name
+      sorted_tags_data = if sort_by.normalize_tag_sort == :name
                            tags_data.sort_by { |k, _v| k }
                          else
                            tags_data.sort_by { |_k, v| v }
                          end
 
-      sorted_tags_data.reverse! if sort_order =~ /^asc/i
+      sorted_tags_data.reverse! if sort_order.normalize_order == :asc
       case format
       when :html
 
@@ -2210,9 +2216,9 @@ EOS
         Doing.config_with(ENV['DOING_CONFIG'], { ignore_local: true })
       end
 
-      Doing.logger.benchmark(:configure, :start)
+      logger.benchmark(:configure, :start)
       config = Doing.config
-      Doing.logger.benchmark(:configure, :finish)
+      logger.benchmark(:configure, :finish)
 
       config.settings['backup_dir'] = ENV['DOING_BACKUP_DIR'] if ENV['DOING_BACKUP_DIR']
       @config = config.settings
@@ -2266,6 +2272,7 @@ EOS
     ##             template trigger
     ##
     def output(items, title, is_single, opt)
+      logger.benchmark(:output, :start)
       opt ||= {}
       out = nil
 
@@ -2283,7 +2290,7 @@ EOS
       end
 
       logger.debug('Output:', "#{items.count} #{items.count == 1 ? 'item' : 'items'} shown")
-
+      logger.benchmark(:output, :finish)
       out
     end
 
@@ -2327,26 +2334,37 @@ EOS
       section_items = @content.in_section(section)
       max = section_items.count - count.to_i
 
+      opt[:after] = opt[:from][0] if opt[:from]
+      opt[:before] = opt[:from][1] if opt[:from]
+
+      time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
+
+      if opt[:before].is_a?(String) && opt[:before] =~ time_rx
+        opt[:before] = opt[:before].chronify(guess: :end, future: false)
+      end
+
+      if opt[:after].is_a?(String) && opt[:after] =~ time_rx
+        opt[:after] = opt[:after].chronify(guess: :begin, future: false)
+      end
+
       counter = 0
 
       @content.map do |item|
         break if counter >= max
-        if opt[:before]
-          time_string = opt[:before]
-          cutoff = time_string.chronify(guess: :begin)
-        end
 
-        if (item.section.downcase != section.downcase && section != /^all$/i) || item.section.downcase == destination.downcase
-          item
-        elsif ((!tags.empty? && !item.tags?(tags, bool)) || (opt[:search] && !item.search(opt[:search].to_s)) || (opt[:before] && item.date >= cutoff))
-          item
-        else
-          counter += 1
-          old_item = item.clone
-          item.move_to(destination, label: label, log: false)
-          Hooks.trigger :post_entry_updated, self, item, old_item
-          item
-        end
+        next if item.section.downcase == destination.downcase
+
+        next if item.section.downcase != section.downcase && section != /^all$/i
+
+        next if (opt[:before] && item.date > opt[:before]) || (opt[:after] && item.date < opt[:after])
+
+        next if (!tags.empty? && !item.tags?(tags, bool)) || (opt[:search] && !item.search(opt[:search].to_s))
+
+        counter += 1
+        old_item = item.clone
+        item.move_to(destination, label: label, log: false)
+        Hooks.trigger :post_entry_updated, self, item, old_item
+        item
       end
 
       if counter.positive?