doing 2.1.1pre → 2.1.5pre

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

@@ -23,116 +23,148 @@ module Doing
       out = ''
       items.each do |item|
         if opt[:highlight] && item.title =~ /@#{wwid.config['marker_tag']}\b/i
-          # flag = Doing::Color.send(wwid.config['marker_color'])
-          reset = Doing::Color.default
+          flag = Doing::Color.send(wwid.config['marker_color'])
+          reset = Doing::Color.reset + Doing::Color.default
         else
-          # flag = ''
+          flag = ''
           reset = ''
         end
 
+        placeholders = {}
+
         if (!item.note.empty?) && wwid.config['include_notes']
           note = item.note.map(&:strip).delete_if(&:empty?)
           note.map! { |line| "#{line.sub(/^\t*/, '')}  " }
 
           if opt[:wrap_width]&.positive?
             width = opt[:wrap_width]
-            note.map! { |line| line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n") }
-            note = note.join("\n").split(/\n/).delete_if(&:empty?)
+            note.map! do |line|
+              line.simple_wrap(width)
+              # line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
+            end
+            note = note.delete_if(&:empty?)
           end
         else
           note = []
         end
 
-        output = opt[:template].dup
-
-        output.gsub!(/%[a-z]+/) do |m|
-          if Doing::Color.respond_to?(m.sub(/^%/, ''))
-            Doing::Color.send(m.sub(/^%/, ''))
+        # 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
-            m
+            d, h, m = wwid.format_time(interval)
+            interval = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
           end
         end
 
-        output.sub!(/%(\d+)?date/) do
-          pad = Regexp.last_match(1).to_i
-          format("%#{pad}s", item.date.strftime(opt[:format]))
-        end
-
-        interval = wwid.get_interval(item, record: true) if opt[:times]
-
         interval ||= ''
-        output.sub!(/%interval/, interval)
-
-        output.sub!(/%(\d+)?shortdate/) do
-          pad = Regexp.last_match(1) || 13
-          format("%#{pad}s", item.date.relative_date)
-        end
-
-        output.sub!(/%section/, item.section) if item.section
-
-        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
+        # 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
-            format("%s%#{pad}s%s", prefix, item.title.sub(/\s*$/, ''), after)
+            d, h, m = wwid.format_time(duration)
+            duration = format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
           end
         end
-
-        # output.sub!(/(?i-m)^([\s\S]*?)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)([\s\S]*?)$/, '\1\3\2')
-        if opt[:tags_color]
-          output.highlight_tags!(opt[:tags_color])
-        end
-
-        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
-
-        output.gsub!(/%hr(_under)?/) do
+        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['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
+
+        output.gsub!(/(?<!\\)%hr(_under)?/) do
           o = ''
           `tput cols`.to_i.times do
             o += Regexp.last_match(1).nil? ? '-' : '_'
           end
           o
         end
-        output.gsub!(/%n/, "\n")
-        output.gsub!(/%t/, "\t")
+        output.gsub!(/(?<!\\)%n/, "\n")
+        output.gsub!(/(?<!\\)%t/, "\t")
+
+        output.gsub!(/\\%/, '%')
 
         out += "#{output}\n"
       end

data/lib/doing/prompt.rb

@@ -16,6 +16,14 @@ module Doing
         @default_answer ||= false
       end
 
+      def enter_text(prompt, default_response: '')
+        return default_response if @default_answer
+
+        print "#{yellow(prompt).sub(/:?$/, ':')} #{reset}"
+        $stdin.gets.strip
+      end
+
+
       ##
       ## Ask a yes or no question in the terminal
       ##
@@ -110,12 +118,17 @@ module Doing
         return nil unless $stdout.isatty
 
         # fzf_args << '-1' # User is expecting a menu, and even if only one it seves as confirmation
-        fzf_args << %(--prompt "#{prompt}")
-        fzf_args << '--multi' if multiple
+        default_args = []
+        default_args << %(--prompt="#{prompt}")
+        default_args << "--height=#{options.count + 2}"
+        default_args << '--info=inline'
+        default_args << '--multi' if multiple
         header = "esc: cancel,#{multiple ? ' tab: multi-select, ctrl-a: select all,' : ''} return: confirm"
-        fzf_args << %(--header "#{header}")
+        default_args << %(--header="#{header}")
+        default_args.concat(fzf_args)
         options.sort! if sorted
-        res = `echo #{Shellwords.escape(options.join("\n"))}|#{fzf} #{fzf_args.join(' ')}`
+
+        res = `echo #{Shellwords.escape(options.join("\n"))}|#{fzf} #{default_args.join(' ')}`
         return false if res.strip.size.zero?
 
         res
@@ -125,16 +138,16 @@ module Doing
       ## Create an interactive menu to select from a set of Items
       ##
       ## @param      items            [Array] list of items
-      ## @param      opt              [Hash] options
-      ## @param      include_section  [Boolean] include section
+      ## @param      opt              Additional options
       ##
-      ## @option opt [String] :header
-      ## @option opt [String] :prompt
-      ## @option opt [String] :query
-      ## @option opt [Boolean] :show_if_single
-      ## @option opt [Boolean] :menu
-      ## @option opt [Boolean] :sort
-      ## @option opt [Boolean] :multiple
+      ## @option opt [Boolean] :include_section Include section name for each item in menu
+      ## @option opt [String] :header A custom header string
+      ## @option opt [String] :prompt A custom prompt string
+      ## @option opt [String] :query Initial query
+      ## @option opt [Boolean] :show_if_single Show menu even if there's only one option
+      ## @option opt [Boolean] :menu Show menu
+      ## @option opt [Boolean] :sort Sort options
+      ## @option opt [Boolean] :multiple Allow multiple selections
       ## @option opt [Symbol] :case (:sensitive, :ignore, :smart)
       ##
       def choose_from_items(items, **opt)

data/lib/doing/string.rb

@@ -28,7 +28,9 @@ module Doing
     ##
     ## @return     [Regexp] Regex pattern
     ##
-    def to_rx(distance: 3, case_type: :smart)
+    def to_rx(distance: nil, case_type: nil)
+      distance ||= Doing.config.settings.dig('search', 'distance').to_i || 3
+      case_type ||= Doing.config.settings.dig('search', 'case')&.normalize_case || :smart
       case_sensitive = case case_type
                        when :smart
                          self =~ /[A-Z]/ ? true : false
@@ -44,7 +46,9 @@ module Doing
                 when /^'/
                   sub(/^'(.*?)'?$/, '\1')
                 else
-                  split(/ +/).map { |w| w.split('').join(".{0,#{distance}}") }.join('.*?')
+                  split(/ +/).map do |w|
+                    w.split('').join(".{0,#{distance}}").gsub(/\+/, '\+').wildcard_to_rx
+                  end.join('.*?')
                 end
       Regexp.new(pattern, !case_sensitive)
     end
@@ -72,7 +76,7 @@ module Doing
     end
 
     ## @param (see #highlight_tags)
-    def highlight_tags!(color = 'yellow')
+    def highlight_tags!(color = 'yellow', last_color: nil)
       replace highlight_tags(color)
     end
 
@@ -83,17 +87,18 @@ module Doing
     ##
     ## @return     [String] string with @tags highlighted
     ##
-    def highlight_tags(color = 'yellow')
-      escapes = scan(/(\e\[[\d;]+m)[^\e]+@/)
-      color = color.split(' ') unless color.is_a?(Array)
-      tag_color = ''
-      color.each { |c| tag_color += Doing::Color.send(c) }
-      last_color = if !escapes.empty?
-                     escapes[-1][0]
-                   else
-                     Doing::Color.default
-                   end
-      gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{Doing::Color.reset}#{last_color}")
+    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.empty?
+                       (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
 
     ##
@@ -162,6 +167,29 @@ module Doing
       replace uncolor
     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
     ##
@@ -169,16 +197,36 @@ module Doing
     ## @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: '')
+    def wrap(len, pad: 0, indent: '  ', offset: 0, prefix: '', color: '', after: '', reset: '', pad_first: false)
       last_color = color.empty? ? '' : after.last_color
-      note_rx = /(?i-m)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)/
+      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/, '%%%%') }
+      str = gsub(/@\S+\(.*?\)/) { |tag| tag.gsub(/\s/, '%%%%') }.gsub(/\n/, ' ')
+
       words = str.split(/ /).map { |word| word.gsub(/%%%%/, ' ') }
       out = []
       line = []
+
       words.each do |word|
-        if line.join(' ').uncolor.length + word.uncolor.length + 1 > len
+        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
@@ -186,17 +234,18 @@ module Doing
         line << word.uncolor
       end
       out.push(line.join(' '))
-      note = ''
-      after.sub!(note_rx) do
-        note = Regexp.last_match(0)
-        ''
-      end
 
+      last_color = ''
       out[0] = format("%-#{pad}s%s%s", out[0], last_color, after)
 
-      left_pad = ' ' * offset
-      left_pad += indent
-      out.map { |l| "#{left_pad}#{color}#{l}#{last_color}" }.join("\n").strip + last_color + " #{note}".chomp
+      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
 
     ##
@@ -210,6 +259,10 @@ module Doing
       end
     end
 
+    def pluralize(number)
+      number == 1 ? self : "#{self}s"
+    end
+
     ##
     ## Convert a sort order string to a qualified type
     ##
@@ -241,7 +294,7 @@ module Doing
 
     def normalize_case(default = :smart)
       case self
-      when /^c/i
+      when /^(c|sens)/i
         :sensitive
       when /^i/i
         :ignore
@@ -269,11 +322,35 @@ module Doing
         :or
       when /(not|none)/i
         :not
+      when /^p/i
+        :pattern
       else
         default.is_a?(Symbol) ? default : default.normalize_bool
       end
     end
 
+    ##
+    ## Convert a matching configuration string to a 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
+        :fuzzy
+      when /^p/i
+        :pattern
+      when /^e/i
+        :exact
+      else
+        default.is_a?(Symbol) ? default : default.normalize_matching
+      end
+    end
+
     def normalize_trigger!
       replace normalize_trigger
     end
@@ -282,8 +359,16 @@ module Doing
       gsub(/\((?!\?:)/, '(?:').downcase
     end
 
+    def wildcard_to_rx
+      gsub(/\?/, '\S').gsub(/\*/, '\S*?')
+    end
+
+    def add_at
+      strip.sub(/^([+-]*)@/, '\1')
+    end
+
     def to_tags
-      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map { |t| t.strip.sub(/^@/, '') }
+      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map(&:add_at)
     end
 
     def add_tags!(tags, remove: false)
@@ -503,7 +588,7 @@ module Doing
         end
       else
         case self
-        when / *, */
+        when /(^\[.*?\]$| *, *)/
           gsub(/^\[ *| *\]$/, '').split(/ *, */)
         when /^[0-9]+$/
           to_i

data/lib/doing/string_chronify.rb

@@ -41,7 +41,11 @@ module Doing
       if secs_ago
         now - secs_ago
       else
-        Chronic.parse(self, { guess: options.fetch(:guess, :begin), context: options.fetch(:future, false) ? :future : :past, ambiguous_time_range: 8 })
+        Chronic.parse(self, {
+                        guess: options.fetch(:guess, :begin),
+                        context: options.fetch(:future, false) ? :future : :past,
+                        ambiguous_time_range: 8
+                      })
       end
     end
 

data/lib/doing/symbol.rb

@@ -16,5 +16,9 @@ module Doing
     def normalize_case
       self
     end
+
+    def normalize_matching(default = :pattern)
+      to_s.normalize_matching(default)
+    end
   end
 end