doing 2.1.26 → 2.1.27

data/lib/doing/string/highlight.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Doing
+  ## Tag and search highlighting
+  class ::String
+    ## @param (see #highlight_tags)
+    def highlight_tags!(color = 'yellow', last_color: nil)
+      replace highlight_tags(color)
+    end
+
+    ##
+    ## Colorize @tags with ANSI escapes
+    ##
+    ## @param      color  [String] color (see #Color)
+    ##
+    ## @return     [String] string with @tags highlighted
+    ##
+    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.good?
+                       (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
+
+    def highlight_search!(search, distance: nil, negate: false, case_type: nil)
+      replace highlight_search(search, distance: distance, negate: negate, case_type: case_type)
+    end
+
+    def highlight_search(search, distance: nil, negate: false, case_type: nil)
+      out = dup
+      prefs = Doing.config.settings['search'] || {}
+      matching = prefs.fetch('matching', 'pattern').normalize_matching
+      distance ||= prefs.fetch('distance', 3).to_i
+      case_type ||= prefs.fetch('case', 'smart').normalize_case
+
+      if search.rx? || matching == :fuzzy
+        rx = search.to_rx(distance: distance, case_type: case_type)
+        out.gsub!(rx) { |m| m.bgyellow.black }
+      else
+        query = search.strip.to_phrase_query
+
+        if query[:must].nil? && query[:must_not].nil?
+          query[:must] = query[:should]
+          query[:should] = []
+        end
+        qs = []
+        qs.concat(query[:must]) if query[:must]
+        qs.concat(query[:should]) if query[:should]
+        qs.each do |s|
+          rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+          out.gsub!(rx) { |m| m.bgyellow.black }
+        end
+      end
+      out
+    end
+
+    # Returns the last escape sequence from a string.
+    #
+    # Actually returns all escape codes, with the assumption
+    # that the result of inserting them will generate the
+    # same color as was set at the end of the string.
+    # Because you can send modifiers like dark and bold
+    # separate from color codes, only using the last code
+    # may not render the same style.
+    #
+    # @return     [String]  All escape codes in string
+    #
+    def last_color
+      scan(/\e\[[\d;]+m/).join('')
+    end
+
+    ##
+    ## Remove color escape codes
+    ##
+    ## @return     clean string
+    ##
+    def uncolor
+      gsub(/\e\[[\d;]+m/, '')
+    end
+
+    ##
+    ## @see        #uncolor
+    ##
+    def uncolor!
+      replace uncolor
+    end
+  end
+end

data/lib/doing/string/query.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Doing
+  ## Handling of search and regex strings
+  class ::String
+    ##
+    ## Determine whether case should be ignored for string
+    ##
+    ## @param      search     The search string
+    ## @param      case_type  The case type, :smart,
+    ##                        :sensitive, :ignore
+    ##
+    ## @return     [Boolean] true if case should be ignored
+    ##
+    def ignore_case(search, case_type)
+      (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
+    end
+
+    ##
+    ## Test if line should be ignored
+    ##
+    ## @return     [Boolean] line is empty or comment
+    ##
+    def ignore?
+      line = self
+      line =~ /^#/ || line =~ /^\s*$/
+    end
+
+    ##
+    ## Determines if receiver is surrounded by slashes or starts with single quote
+    ##
+    ## @return     [Boolean] True if regex, False otherwise.
+    ##
+    def rx?
+      self =~ %r{(^/.*?/$|^')}
+    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*?').gsub(/\]\]/, '--')
+    end
+
+    ##
+    ## Convert string to fuzzy regex. Characters in words
+    ## can be separated by up to *distance* characters in
+    ## haystack, spaces indicate unlimited distance.
+    ##
+    ## @example
+    ##   "this word".to_rx(3)
+    ##   # => /t.{0,3}h.{0,3}i.{0,3}s.{0,3}.*?w.{0,3}o.{0,3}r.{0,3}d/
+    ##
+    ## @param      distance   [Integer] Allowed distance
+    ##                        between characters
+    ## @param      case_type  The case type
+    ##
+    ## @return     [Regexp] Regex pattern
+    ##
+    def to_rx(distance: nil, case_type: nil)
+      distance ||= Doing.config.fetch('search', 'distance', 3).to_i
+      case_type ||= Doing.config.fetch('search', 'case', 'smart')&.normalize_case
+      case_sensitive = case case_type
+                       when :smart
+                         self =~ /[A-Z]/ ? true : false
+                       when :sensitive
+                         true
+                       else
+                         false
+                       end
+
+      pattern = case dup.strip
+                when %r{^/.*?/$}
+                  sub(%r{/(.*?)/}, '\1')
+                when /^'/
+                  sub(/^'(.*?)'?$/, '\1')
+                else
+                  split(/ +/).map do |w|
+                    w.split('').join(".{0,#{distance}}").gsub(/\+/, '\+').wildcard_to_rx
+                  end.join('.*?')
+                end
+      Regexp.new(pattern, !case_sensitive)
+    end
+
+    def to_phrase_query
+      parser = PhraseParser::QueryParser.new
+      transformer = PhraseParser::QueryTransformer.new
+      parse_tree = parser.parse(self)
+      transformer.apply(parse_tree).to_elasticsearch
+    end
+
+    def to_query
+      parser = BooleanTermParser::QueryParser.new
+      transformer = BooleanTermParser::QueryTransformer.new
+      parse_tree = parser.parse(self)
+      transformer.apply(parse_tree).to_elasticsearch
+    end
+
+    ##
+    ## Test string for truthiness (0, "f", "false", "n", "no" all return false, case insensitive, otherwise true)
+    ##
+    ## @return     [Boolean] String is truthy
+    ##
+    def truthy?
+      if self =~ /^(0|f(alse)?|n(o)?)$/i
+        false
+      else
+        true
+      end
+    end
+
+    ##
+    ## Returns a bool representation of the string.
+    ##
+    ## @return     [Boolean] Bool representation of the object.
+    ##
+    def to_bool
+      case self
+      when /^[yt1]/i
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/doing/string/string.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ::String
+  include Doing::Color
+end
+
+require_relative 'highlight'
+require_relative 'query'
+require_relative 'tags'
+require_relative 'transform'
+require_relative 'truncate'
+require_relative 'url'

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