doing 2.1.13 → 2.1.17

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

@@ -5,6 +5,7 @@
 # author: Brett Terpstra
 # url: https://brettterpstra.com
 module Doing
+  # Template Export
   class TemplateExport
     include Doing::Color
     include Doing::Util
@@ -32,7 +33,7 @@ module Doing
 
         placeholders = {}
 
-        if (!item.note.empty?) && wwid.config['include_notes']
+        if !item.note.empty? && wwid.config['include_notes']
           note = item.note.map(&:strip).delete_if(&:empty?)
           note.map! { |line| "#{line.sub(/^\t*/, '')}  " }
 
@@ -42,122 +43,74 @@ module Doing
               line.simple_wrap(width)
               # line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
             end
-            note = note.delete_if(&:empty?)
+            note.delete_if(&:empty?)
           end
         else
           note = []
         end
 
-        # output.sub!(/%(\d+)?date/) do
-        #   pad = Regexp.last_match(1).to_i
-        #   format("%#{pad}s", item.date.strftime(opt[:format]))
-        # end
         placeholders['date'] = item.date.strftime(opt[:format])
 
         interval = wwid.get_interval(item, record: true, formatted: false) if opt[:times]
         if interval
-          case opt[:interval_format].to_sym
-          when :human
-            _d, h, m = wwid.format_time(interval, human: true)
-            interval = format('%<h> 4dh %<m>02dm', h: h, m: m)
-          else
-            d, h, m = wwid.format_time(interval)
-            interval = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
-          end
+          interval = case opt[:interval_format].to_sym
+                     when :human
+                       interval.time_string(format: :hm)
+                     else
+                       interval.time_string(format: :clock)
+                     end
         end
 
         interval ||= ''
-        # output.sub!(/%interval/, interval)
         placeholders['interval'] = interval
 
         duration = item.duration if opt[:duration]
         if duration
-          case opt[:interval_format].to_sym
-          when :human
-            _d, h, m = wwid.format_time(duration, human: true)
-            duration = format('%<h> 4dh %<m>02dm', h: h, m: m)
-          else
-            d, h, m = wwid.format_time(duration)
-            duration = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
-          end
+          duration = case opt[:interval_format].to_sym
+                     when :human
+                       duration.time_string(format: :hm)
+                     else
+                       duration.time_string(format: :clock)
+                     end
         end
         duration ||= ''
-        # output.sub!(/%duration/, duration)
         placeholders['duration'] = duration
 
-        # output.sub!(/%(\d+)?shortdate/) do
-        #   pad = Regexp.last_match(1) || 13
-        #   format("%#{pad}s", item.date.relative_date)
-        # end
-        placeholders['shortdate'] = format("%13s", item.date.relative_date)
-        # output.sub!(/%section/, item.section) if item.section
+        placeholders['shortdate'] = format('%13s', item.date.relative_date)
         placeholders['section'] = item.section || ''
         placeholders['title'] = item.title
-
-        # title_rx = /(?mi)%(?<width>-?\d+)?(?:(?<ichar>[ _t])(?<icount>\d+))?(?<prefix>.[ _t]?)?title(?<after>.*?)$/
-        # title_color = Doing::Color.reset + output.match(/(?mi)^(.*?)(%.*?title)/)[1].last_color
-
-        # title_offset = Doing::Color.uncolor(output).match(title_rx).begin(0)
-
-        # output.sub!(title_rx) do
-        #   m = Regexp.last_match
-
-        #   after = m['after']
-        #   pad = m['width'].to_i
-        #   indent = ''
-        #   if m['ichar']
-        #     char = m['ichar'] =~ /t/ ? "\t" : ' '
-        #     indent = char * m['icount'].to_i
-        #   end
-        #   prefix = m['prefix']
-        #   if opt[:wrap_width]&.positive? || pad.positive?
-        #     width = pad.positive? ? pad : opt[:wrap_width]
-        #     item.title.wrap(width, pad: pad, indent: indent, offset: title_offset, prefix: prefix, color: title_color, after: after, reset: reset)
-        #     # flag + item.title.gsub(/(.{#{opt[:wrap_width]}})(?=\s+|\Z)/, "\\1\n ").sub(/\s*$/, '') + reset
-        #   else
-        #     format("%s%#{pad}s%s", prefix, item.title.sub(/\s*$/, ''), after)
-        #   end
-        # end
-
-
-
         placeholders['note'] = note
         placeholders['idnote'] = note.empty? ? '' : "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}"
         placeholders['odnote'] = note.empty? ? '' : "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}"
-        placeholders['chompnote'] = note.empty? ? '' : note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
-
-        # if note.empty?
-        #   output.gsub!(/%(chomp|[io]d|(\^.)?(([ _t]|[^a-z0-9])?\d+)?(.[ _t]?)?)?note/, '')
-        # else
-        #   output.sub!(/%note/, "\n#{note.map { |l| "\t#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/%idnote/, "\n#{note.map { |l| "\t\t#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/%odnote/, "\n#{note.map { |l| "#{l.strip}  " }.join("\n")}")
-        #   output.sub!(/(?mi)%(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])?(?<icount>\d+))?(?<prefix>.[ _t]?)?note/) do
-        #     m = Regexp.last_match
-        #     mark = m['mchar'] || ''
-        #     indent = if m['ichar']
-        #                char = m['ichar'] =~ /t/ ? "\t" : ' '
-        #                char * m['icount'].to_i
-        #              else
-        #                ''
-        #              end
-        #     prefix = m['prefix'] || ''
-        #     "\n#{note.map { |l| "#{mark}#{indent}#{prefix}#{l.strip}  " }.join("\n")}"
-        #   end
-
-        #   output.sub!(/%chompnote/) do
-        #     note.map { |l| l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ') }.join(' ')
-        #   end
-        # end
 
-        template = opt[:template].dup
-        template.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
-        output = Doing::TemplateString.new(template, placeholders: placeholders, wrap_width: opt[:wrap_width], color: flag, tags_color: opt[:tags_color], reset: reset).colored
+        chompnote = []
+        unless note.empty?
+          chompnote = note.map do |l|
+            l.gsub(/\n+/, ' ').gsub(/(^\s*|\s*$)/, '').gsub(/\s+/, ' ')
+          end
+        end
+        placeholders['chompnote'] = chompnote.join(' ')
 
-        output.gsub!(/(?<!\\)%hr(_under)?/) do
+        template = opt[:template].dup
+        note_rx = /(?i-m)(?x:^([\s\S]*?)
+                    (%(?:[io]d|(?:\^[\s\S])?
+                    (?:(?:[ _t]|[^a-z0-9])?\d+)?
+                    (?:[\s\S][ _t]?)?)?note)
+                    ([\s\S]*?)$)/
+        template.sub!(note_rx, '\1\3\2')
+        output = Doing::TemplateString.new(template,
+                                           color: flag,
+                                           placeholders: placeholders,
+                                           reset: reset,
+                                           tags_color: opt[:tags_color],
+                                           wrap_width: opt[:wrap_width]).colored
+
+        output.gsub!(/(?<!\\)%(\S)?hr(_under)?/) do
           o = ''
-          `tput cols`.to_i.times do
-            o += Regexp.last_match(1).nil? ? '-' : '_'
+          TTY::Screen.columns.to_i.times do
+            char = Regexp.last_match(2).nil? ? '-' : '_'
+            char = Regexp.last_match(1).nil? ? char : Regexp.last_match(1)
+            o += char
           end
           o
         end
@@ -166,11 +119,17 @@ module Doing
 
         output.gsub!(/\\%/, '%')
 
+        output.highlight_search!(opt[:search]) if opt[:search] && !opt[:not] && opt[:hilite]
+
         out += "#{output}\n"
       end
 
       # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:template]}")
-      out += wwid.tag_times(format: wwid.config['timer_format'].to_sym, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) if opt[:totals]
+      if opt[:totals]
+        out += wwid.tag_times(format: wwid.config['timer_format'].to_sym,
+                              sort_by_name: opt[:sort_tags],
+                              sort_order: opt[:tag_order])
+      end
       out
     end
 

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

@@ -61,7 +61,19 @@ module Doing
         title.strip!
         new_entry = Item.new(start_time, title, section)
         new_entry.note = entry['notes'].split(/\n/).map(&:chomp) if entry.key?('notes')
-        new_items.push(new_entry)
+
+        is_match = true
+
+        if options[:search]
+          is_match = new_entry.search(options[:search], case_type: options[:date], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = start_time > options[:date_filter][0] && start_time < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        new_items.push(new_entry) if is_match
       end
       total = new_items.count
 

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

@@ -68,7 +68,18 @@ module Doing
         new_item = Item.new(item.date, title, section)
         new_item.note = item.note
 
-        imported.push(new_item)
+        is_match = true
+
+        if options[:search]
+          is_match = new_item.search(options[:search], case_type: options[:case], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = new_item.date > options[:date_filter][0] && new_item.date < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        imported.push(new_item) if is_match
       end
 
       dups = new_items.count - imported.count

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

@@ -63,7 +63,19 @@ module Doing
         title.strip!
         new_item = Item.new(start_time, title, section)
         new_item.note.add(entry['notes']) if entry.key?('notes')
-        new_items.push(new_item)
+
+        is_match = true
+
+        if options[:search]
+          is_match = new_item.search(options[:search], case_type: options[:case], negate: options[:not])
+        end
+
+        if is_match && options[:date_filter]
+          is_match = start_time > options[:date_filter][0] && start_time < options[:date_filter][1]
+          is_match = options[:not] ? !is_match : is_match
+        end
+
+        new_items.push(new_item) if is_match
       end
       total = new_items.count
       skipped = data.count - total

data/lib/doing/prompt.rb

@@ -17,12 +17,74 @@ module Doing
       end
 
       def enter_text(prompt, default_response: '')
+        $stdin.reopen('/dev/tty')
         return default_response if @default_answer
 
         print "#{yellow(prompt).sub(/:?$/, ':')} #{reset}"
         $stdin.gets.strip
       end
 
+      def read_line(prompt: 'Enter text', completions: [], default_response: '')
+        $stdin.reopen('/dev/tty')
+        return default_response if @default_answer
+
+        unless completions.empty?
+          completions.sort!
+          comp = proc { |s| completions.grep(/^#{Regexp.escape(s)}/) }
+          Readline.completion_append_character = ' '
+          Readline.completion_proc = comp
+        end
+
+        begin
+          Readline.readline("#{yellow(prompt).sub(/:?$/, ':')} #{reset}", true).strip
+        rescue Interrupt
+          raise UserCancelled
+        end
+      end
+
+      def read_lines(prompt: 'Enter text', completions: [])
+        $stdin.reopen('/dev/tty')
+        return default_response if @default_answer
+
+        completions.sort!
+        comp = proc { |s| completions.grep(/^#{Regexp.escape(s)}/) }
+        Readline.completion_append_character = ' '
+        Readline.completion_proc = comp
+        prompt_text = []
+        prompt_text << boldgreen(prompt.sub(/:?$/, ':'))
+        prompt_text << yellow(' Enter a blank line (')
+        prompt_text << boldwhite('return twice')
+        prompt_text << yellow(') to end editing')
+        puts prompt_text.join('')
+
+        res = []
+
+        begin
+          while (line = Readline.readline('> ', true))
+            break if line.strip.empty?
+
+            res << line.chomp
+          end
+        rescue Interrupt
+          raise UserCancelled
+        end
+
+        res.join("\n").strip
+      end
+
+      def request_lines(prompt: 'Enter text')
+        $stdin.reopen('/dev/tty')
+        ask_note = []
+        reader = TTY::Reader.new(interrupt: -> { raise Errors::UserCancelled }, track_history: false)
+        puts "#{boldgreen(prompt.sub(/:?$/, ':'))} #{yellow('Hit return for a new line, ')}#{boldwhite('enter a blank line (')}#{boldyellow('return twice')}#{boldwhite(') to end editing')}"
+        loop do
+          res = reader.read_line(green('> '))
+          break if res.strip.empty?
+
+          ask_note.push(res)
+        end
+        ask_note.join("\n").strip
+      end
 
       ##
       ## Ask a yes or no question in the terminal
@@ -39,6 +101,8 @@ module Doing
           return @force_answer
         end
 
+        $stdin.reopen('/dev/tty')
+
         default = if default_response.is_a?(String)
                     default_response =~ /y/i ? true : false
                   else
@@ -205,7 +269,7 @@ module Doing
           out = [
             format("%#{pad}d", i),
             ') ',
-            format('%13s', item.date.relative_date),
+            format('%16s', item.date.strftime('%Y-%m-%d %H:%M')),
             ' | ',
             item.title
           ]

data/lib/doing/string.rb

@@ -101,6 +101,46 @@ module Doing
       gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{last_color}")
     end
 
+    def to_phrase_query(query)
+      parser = PhraseParser::QueryParser.new
+      transformer = PhraseParser::QueryTransformer.new
+      parse_tree = parser.parse(query)
+      transformer.apply(parse_tree).to_elasticsearch
+    end
+
+    def ignore_case(search, case_type)
+      (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
+    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.is_rx? || matching == :fuzzy
+        rx = search.to_rx(distance: distance, case_type: case_type)
+        out.gsub!(rx) { |m| m.bgyellow.black }
+      else
+        query = to_phrase_query(search.strip)
+
+        if query[:must].nil? && query[:must_not].nil?
+          query[:must] = query[:should]
+          query[:should] = []
+        end
+        query[:must].concat(query[:should]).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
+
     ##
     ## Test if line should be ignored
     ##
@@ -259,7 +299,13 @@ module Doing
       end
     end
 
-    def pluralize(number)
+    ##
+    ## 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
 
@@ -268,10 +314,6 @@ module Doing
     ##
     ## @return     [Symbol] :oldest or :newest
     ##
-    def normalize_age!(default = :newest)
-      replace normalize_age(default)
-    end
-
     def normalize_age(default = :newest)
       case self
       when /^o/i
@@ -283,6 +325,11 @@ module Doing
       end
     end
 
+    ## @see #normalize_age
+    def normalize_age!(default = :newest)
+      replace normalize_age(default)
+    end
+
     ##
     ## Convert a sort order string to a qualified type
     ##
@@ -308,10 +355,6 @@ module Doing
     ##
     ## @return     Symbol :smart, :sensitive, :ignore
     ##
-    def normalize_case!
-      replace normalize_case
-    end
-
     def normalize_case(default = :smart)
       case self
       when /^(c|sens)/i
@@ -325,15 +368,16 @@ module Doing
       end
     end
 
+    ## @see #normalize_case
+    def normalize_case!
+      replace normalize_case
+    end
+
     ##
     ## Convert a boolean string to a symbol
     ##
     ## @return     Symbol :and, :or, or :not
     ##
-    def normalize_bool!(default = :and)
-      replace normalize_bool(default)
-    end
-
     def normalize_bool(default = :and)
       case self
       when /(and|all)/i
@@ -349,15 +393,19 @@ module Doing
       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)
-      replace normalize_bool(default)
-    end
-
     def normalize_matching(default = :pattern)
       case self
       when /^f/i
@@ -371,30 +419,64 @@ module Doing
       end
     end
 
-    def normalize_trigger!
-      replace normalize_trigger
+    ## @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
+
+    ##
+    ## 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*?')
     end
 
+    ##
+    ## Add @ prefix to string if needed, maintains +/- prefix
+    ##
+    ## @return     [String] @string
+    ##
     def add_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
-      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map(&:add_at)
-    end
-
-    def add_tags!(tags, remove: false)
-      replace add_tags(tags, remove: remove)
+      gsub(/ *, */, ' ').scan(/(@?(?:\S+(?:\(.+\)))|@?(?:\S+))/).map(&:first).sort.uniq.map(&:add_at)
     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 = self.dup
       tags = tags.to_tags
@@ -402,6 +484,11 @@ module Doing
       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
     ##
@@ -484,10 +571,6 @@ module Doing
     ##
     ## @return     Deduplicated string
     ##
-    def dedup_tags!
-      replace dedup_tags
-    end
-
     def dedup_tags
       title = dup
       tags = title.scan(/(?<=\A| )(@(\S+?)(\([^)]+\))?)(?= |\Z)/).uniq
@@ -505,6 +588,11 @@ module Doing
       title
     end
 
+    ## @see #dedup_tags
+    def dedup_tags!
+      replace dedup_tags
+    end
+
     # Returns the last escape sequence from a string.
     #
     # Actually returns all escape codes, with the assumption
@@ -525,11 +613,9 @@ module Doing
     ##
     ## @param      opt   [Hash] Additional Options
     ##
-    def link_urls!(**opt)
-      fmt = opt.fetch(:format, :html)
-      replace link_urls(format: fmt)
-    end
-
+    ## @option opt [Symbol] :format can be :markdown or
+    ## :html (default)
+    ##
     def link_urls(**opt)
       fmt = opt.fetch(:format, :html)
       return self unless fmt
@@ -541,6 +627,12 @@ module Doing
       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|
@@ -590,6 +682,18 @@ module Doing
       end
     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