doing 2.1.24 → 2.1.28

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/pager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'pathname'
 
 module Doing

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/plugins/import/calendar_import.rb

@@ -89,7 +89,7 @@ module Doing
 
       wwid.content.concat(new_items)
 
-      new_items.map { |item| Hooks.trigger :post_entry_added, self, item.dup }
+      new_items.map { |item| Hooks.trigger :post_entry_added, self, item }
 
       Doing.logger.info(%(Imported #{new_items.count} items to #{section}))
     end

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

@@ -93,7 +93,7 @@ module Doing
         wwid.content.add_section(item.section) unless wwid.content.section?(item.section)
         Hooks.trigger :pre_entry_add, self, item
         wwid.content.push(item)
-        Hooks.trigger :post_entry_added, self, item.dup
+        Hooks.trigger :post_entry_added, self, item
       end
 
       Doing.logger.info('Imported:', "#{imported.count} items")

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

@@ -93,7 +93,7 @@ module Doing
 
       wwid.content.concat(new_items)
 
-      new_items.map { |item| Hooks.trigger :post_entry_added, self, item.dup }
+      new_items.map { |item| Hooks.trigger :post_entry_added, self, item }
 
       Doing.logger.info('Imported:', %(#{new_items.count} items to #{section}))
     end

data/lib/doing/prompt.rb

@@ -8,6 +8,14 @@ module Doing
 
       include Color
 
+      ##
+      ## Clear the terminal screen
+      ##
+      def clear_screen(msg = nil)
+        puts "\e[H\e[2J" if STDOUT.tty?
+        puts msg if msg.good?
+      end
+
       def force_answer
         @force_answer ||= nil
       end
@@ -99,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/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'