doing 2.1.24 → 2.1.28

data/lib/doing/string/tags.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Doing
+  # Handling of @tags in strings
+  class ::String
+    ##
+    ## Add @ prefix to string if needed, maintains +/- prefix
+    ##
+    ## @return     [String] @string
+    ##
+    def add_at
+      strip.sub(/^([+-]*)@?/, '\1@')
+    end
+
+    ##
+    ## Removes @ prefix if needed, maintains +/- prefix
+    ##
+    ## @return     [String] string without @ prefix
+    ##
+    def remove_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
+      arr = gsub(/ *, */, ' ').scan(/(@?(?:\S+(?:\(.+\)))|@?(?:\S+))/).map(&:first).sort.uniq.map(&:add_at)
+      if block_given?
+        yield arr
+      else
+        arr
+      end
+    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 = dup
+      tags = tags.to_tags
+      tags.each { |tag| title.tag!(tag, remove: remove) }
+      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
+    ##
+    ## @see #tag
+    ##
+    def tag!(tag, **options)
+      replace tag(tag, **options)
+    end
+
+    ##
+    ## Add, rename, or remove a tag
+    ##
+    ## @param      tag        The tag
+    ## @param      value      [String] Value for tag (@tag(value))
+    ## @param      remove     [Boolean] Remove the tag instead of adding
+    ## @param      rename_to  [String] Replace tag with this tag
+    ## @param      regex      [Boolean] Tag is regular expression
+    ## @param      single     [Boolean] Operating on a single item (for logging)
+    ## @param      force      [Boolean] With rename_to, add tag if it doesn't exist
+    ##
+    ## @return     [String] The string with modified tags
+    ##
+    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false, force: false)
+      log_level = single ? :info : :debug
+      title = dup
+      title.chomp!
+      tag = tag.sub(/^@?/, '')
+      case_sensitive = tag !~ /[A-Z]/
+
+      rx_tag = if regex
+                 tag.gsub(/\./, '\S')
+               else
+                 tag.gsub(/\?/, '.').gsub(/\*/, '\S*?')
+               end
+
+      if remove || rename_to
+        rx = Regexp.new("(?<=^| )@#{rx_tag}(?<parens>\\((?<value>[^)]*)\\))?(?= |$)", case_sensitive)
+        m = title.match(rx)
+
+        if m.nil? && rename_to && force
+          title.tag!(rename_to, value: value, single: single)
+        elsif m
+          title.gsub!(rx) do
+            rename_to ? "@#{rename_to}#{value.nil? ? m['parens'] : "(#{value})"}" : ''
+          end
+
+          title.dedup_tags!
+          title.chomp!
+
+          if rename_to
+            f = "@#{tag}".cyan
+            t = "@#{rename_to}".cyan
+            Doing.logger.write(log_level, 'Tag:', %(renamed #{f} to #{t} in "#{title}"))
+          else
+            f = "@#{tag}".cyan
+            Doing.logger.write(log_level, 'Tag:', %(removed #{f} from "#{title}"))
+          end
+        else
+          Doing.logger.debug('Skipped:', "not tagged #{"@#{tag}".cyan}")
+        end
+      elsif title =~ /@#{tag}(?=[ (]|$)/
+        Doing.logger.debug('Skipped:', "already tagged #{"@#{tag}".cyan}")
+        return title
+      else
+        add = tag
+        add += "(#{value})" unless value.nil?
+        title.chomp!
+        title += " @#{add}"
+
+        title.dedup_tags!
+        title.chomp!
+        Doing.logger.write(log_level, 'Tag:', %(added #{('@' + tag).cyan} to "#{title}"))
+      end
+
+      title.gsub(/ +/, ' ')
+    end
+
+    ##
+    ## Remove duplicate tags, leaving only first occurrence
+    ##
+    ## @return     Deduplicated string
+    ##
+    def dedup_tags
+      title = dup
+      tags = title.scan(/(?<=\A| )(@(\S+?)(\([^)]+\))?)(?= |\Z)/).uniq
+      tags.each do |tag|
+        found = false
+        title.gsub!(/( |^)#{tag[1]}(\([^)]+\))?(?= |$)/) do |m|
+          if found
+            ''
+          else
+            found = true
+            m
+          end
+        end
+      end
+      title
+    end
+
+    ## @see #dedup_tags
+    def dedup_tags!
+      replace dedup_tags
+    end
+  end
+end

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
@@ -131,7 +109,7 @@ module Doing
 
         after = m['after']
 
-        if value.nil? || value.empty?
+        if !value.good?
           after
         else
           pad = m['width'].to_i
@@ -183,7 +161,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 || tags_color.nil? || tags_color.empty?
+                  line.highlight_tags!(tags_color, last_color: last_color) unless !tags_color || !tags_color.good?
                   "#{line}  "
                 end
               end.join("\n")

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
@@ -20,6 +22,13 @@ module Doing
     DateBeginString = Class.new(DateTime)
     DateEndString = Class.new(DateTime)
     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

@@ -19,7 +19,7 @@ module Doing
     ## @param      cli   [String] The name or path of the cli
     ##
     def exec_available(cli)
-      return false if cli.nil?
+      return false unless cli.good?
 
       !TTY::Which.which(cli).nil?
     end
@@ -32,7 +32,7 @@ module Doing
     ##
     def first_available_exec(*commands)
       commands.compact.map(&:strip).reject(&:empty?).uniq
-      .find { |cmd| exec_available(cmd.split.first) }
+              .find { |cmd| exec_available(cmd.split.first) }
     end
 
     def merge_default_proc(target, overwrite)
@@ -56,7 +56,7 @@ module Doing
     # @param      [Hash] other_hash   The other hash
     #
     def deep_merge_hashes(master_hash, other_hash)
-      deep_merge_hashes!(master_hash.dup, other_hash)
+      deep_merge_hashes!(master_hash.clone, other_hash)
     end
 
     # Merges a master hash with another hash, recursively.
@@ -157,42 +157,46 @@ module Doing
     def find_default_editor(editor_for = 'default')
       # return nil unless $stdout.isatty || ENV['DOING_EDITOR_TEST']
 
-      if ENV['DOING_EDITOR_TEST']
-        return ENV['EDITOR']
-      end
+      return ENV['EDITOR'] if ENV['DOING_EDITOR_TEST']
 
       editor_config = Doing.config.settings['editors']
 
       if editor_config.is_a?(String)
-        Doing.logger.warn('Deprecated:', "Please update your configuration, 'editors' should be a mapping. Delete the key and run `doing config --update`.")
+        msg = "Please update your configuration, 'editors' should be a mapping."
+        msg << ' Delete the key and run `doing config --update`.'
+        Doing.logger.warn('Deprecated:', msg)
         return editor_config
       end
 
       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.nil? || editor.empty?
+        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.nil? || editor.empty?
+        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.nil? || editor.empty?
-        # 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.24'
+  VERSION = '2.1.28'
 end