doing 2.1.26 → 2.1.30

data/lib/doing/normalize.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## String to symbol conversion
+  ##
+  class ::String
+    ##
+    ## Convert tag sort string to a qualified type
+    ##
+    ## @return     [Symbol] :name or :time
+    ##
+    def normalize_tag_sort(default = :name)
+      case self
+      when /^n/i
+        :name
+      when /^t/i
+        :time
+      else
+        default
+      end
+    end
+
+    ## @see #normalize_tag_sort
+    def normalize_tag_sort!(default = :name)
+      replace normalize_tag_sort(default)
+    end
+
+    ##
+    ## Convert an age string to a qualified type
+    ##
+    ## @return     [Symbol] :oldest or :newest
+    ##
+    def normalize_age(default = :newest)
+      case self
+      when /^o/i
+        :oldest
+      when /^n/i
+        :newest
+      else
+        default
+      end
+    end
+
+    ## @see #normalize_age
+    def normalize_age!(default = :newest)
+      replace normalize_age(default)
+    end
+
+    ##
+    ## Convert a sort order string to a qualified type
+    ##
+    ## @return     [Symbol] :asc or :desc
+    ##
+    def normalize_order!(default = :asc)
+      replace normalize_order(default)
+    end
+
+    def normalize_order(default = :asc)
+      case self
+      when /^a/i
+        :asc
+      when /^d/i
+        :desc
+      else
+        default
+      end
+    end
+
+    ##
+    ## Convert a case sensitivity string to a symbol
+    ##
+    ## @return     Symbol :smart, :sensitive, :ignore
+    ##
+    def normalize_case(default = :smart)
+      case self
+      when /^(c|sens)/i
+        :sensitive
+      when /^i/i
+        :ignore
+      when /^s/i
+        :smart
+      else
+        default.is_a?(Symbol) ? default : default.normalize_case
+      end
+    end
+
+    ## @see #normalize_case
+    def normalize_case!(default = :smart)
+      replace normalize_case(default)
+    end
+
+    ##
+    ## Convert a boolean string to a symbol
+    ##
+    ## @return     Symbol :and, :or, or :not
+    ##
+    def normalize_bool(default = :and)
+      case self
+      when /(and|all)/i
+        :and
+      when /(any|or)/i
+        :or
+      when /(not|none)/i
+        :not
+      when /^p/i
+        :pattern
+      else
+        default.is_a?(Symbol) ? default : default.normalize_bool
+      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)
+      case self
+      when /^f/i
+        :fuzzy
+      when /^p/i
+        :pattern
+      when /^e/i
+        :exact
+      else
+        default.is_a?(Symbol) ? default : default.normalize_matching
+      end
+    end
+
+    ## @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
+  end
+
+  ##
+  ## Symbol helpers
+  ##
+  class ::Symbol
+    def normalize_tag_sort(default = :name)
+      to_s.normalize_tag_sort
+    end
+
+    def normalize_bool(default = :and)
+      to_s.normalize_bool(default)
+    end
+
+    def normalize_age(default = :newest)
+      to_s.normalize_age(default)
+    end
+
+    def normalize_order(default = :asc)
+      to_s.normalize_order(default)
+    end
+
+    def normalize_case(default = :smart)
+      to_s.normalize_case(default)
+    end
+
+    def normalize_matching(default = :pattern)
+      to_s.normalize_matching(default)
+    end
+  end
+end

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

@@ -129,7 +129,7 @@ module Doing
                    self.template('dayone')
                  end
 
-      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
 
       case digest
       when :day

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

@@ -70,7 +70,7 @@ module Doing
                 self.template('css')
               end
 
-      totals = opt[:totals] ? wwid.tag_times(format: :html, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      totals = opt[:totals] ? wwid.tag_times(format: :html, sort_by: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
       engine = Haml::Engine.new(template)
       Doing.logger.debug('HTML Export:', "#{items_out.count} items output to HTML")
       @out = engine.render(Object.new,

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

@@ -91,7 +91,7 @@ module Doing
         JSON.pretty_generate({
           'section' => variables[:page_title],
           'items' => items_out,
-          'timers' => wwid.tag_times(format: :json, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order])
+          'timers' => wwid.tag_times(format: :json, sort_by: opt[:sort_tags], sort_order: opt[:tag_order])
         })
       elsif opt[:output] == 'timeline'
         template = <<~EOTEMPLATE

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

@@ -72,7 +72,7 @@ module Doing
                    self.template(nil)
                  end
 
-      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
 
       mdx = MarkdownRenderer.new(variables[:page_title], all_items, totals)
       Doing.logger.debug('Markdown Export:', "#{all_items.count} items output to Markdown")

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

@@ -17,6 +17,7 @@ module Doing
     end
 
     def self.render(wwid, items, variables: {})
+      # Doing.logger.benchmark(:template_render, :start)
       return if items.nil?
 
       opt = variables[:options]
@@ -133,9 +134,10 @@ module Doing
       # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:template]}")
       if opt[:totals]
         out += wwid.tag_times(format: wwid.config['timer_format'].to_sym,
-                              sort_by_name: opt[:sort_tags],
+                              sort_by: opt[:sort_tags],
                               sort_order: opt[:tag_order])
       end
+      # Doing.logger.benchmark(:template_render, :finish)
       out
     end
 

data/lib/doing/prompt.rb

@@ -107,9 +107,7 @@ module Doing
       ## @return     (Bool) yes or no
       ##
       def yn(question, default_response: false)
-        unless @force_answer.nil?
-          return @force_answer
-        end
+        return @force_answer == :yes ? true : false unless @force_answer.nil?
 
         $stdin.reopen('/dev/tty')
 

data/lib/doing/section.rb

@@ -13,7 +13,7 @@ module Doing
       @original = if original.nil?
                     "#{title}:"
                   else
-                    original =~ /:(\s+@\S+(\(.*?\))?)*$/ ? original : "#{original}:"
+                    original =~ /:(\s+@[^ (]+(\([^)]*\))?)*?$/ ? original : "#{original}:"
                   end
     end
 

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