doing 2.1.14 → 2.1.18

data/lib/doing/item.rb

@@ -9,6 +9,8 @@ module Doing
 
     # attr_reader :id
 
+    include Color
+
     ##
     ## Initialize an item with date, title, section, and
     ## optional note
@@ -57,6 +59,25 @@ module Doing
       @end_date ||= Time.parse(Regexp.last_match(1)) if @title =~ /@done\((\d{4}-\d\d-\d\d \d\d:\d\d.*?)\)/
     end
 
+    def calculate_end_date(opt)
+      if opt[:took]
+        if @date + opt[:took] > Time.now
+          @date = Time.now - opt[:took]
+          Time.now
+        else
+          @date + opt[:took]
+        end
+      elsif opt[:back]
+        if opt[:back].is_a? Integer
+          @date + opt[:back]
+        else
+          @date + (opt[:back] - @date)
+        end
+      else
+        Time.now
+      end
+    end
+
     # Generate a hash that represents the entry
     #
     # @return [String] entry hash
@@ -112,6 +133,19 @@ module Doing
       (start_a >= start_b && start_a <= end_b) || (end_a >= start_b && end_a <= end_b) || (start_a < start_b && end_a > end_b)
     end
 
+    ##
+    ## Updates the title of the Item by expanding natural
+    ## language dates within configured date tags (tags
+    ## whose value is expected to be a date)
+    ##
+    ## @param      additional_tags  An array of additional
+    ##                              tag names to consider
+    ##                              dates
+    ##
+    def expand_date_tags(additional_tags = nil)
+      @title.expand_date_tags(additional_tags)
+    end
+
     ##
     ## Add (or remove) tags from the title of the item
     ##
@@ -237,6 +271,34 @@ module Doing
       (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
     end
 
+    def highlight_search(search, distance: nil, negate: false, case_type: nil)
+      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
+      new_note = Note.new
+
+      if search.is_rx? || matching == :fuzzy
+        rx = search.to_rx(distance: distance, case_type: case_type)
+        new_title = @title.gsub(rx) { |m| yellow(m) }
+        new_note.add(@note.to_s.gsub(rx) { |m| yellow(m) })
+      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))
+          new_title = @title.gsub(rx) { |m| yellow(m) }
+          new_note.add(@note.to_s.gsub(rx) { |m| yellow(m) })
+        end
+      end
+
+      Item.new(@date, new_title, @section, new_note)
+    end
+
     ##
     ## Test if item matches search string
     ##
@@ -340,6 +402,27 @@ module Doing
       "\t- #{@date.strftime('%Y-%m-%d %H:%M')} | #{@title}#{@note.empty? ? '' : "\n#{@note}"}"
     end
 
+    ##
+    ## outputs a colored string with relative date and highlighted tags
+    ##
+    ## @return     Pretty representation of the object.
+    ##
+    def to_pretty(elements: %i[date title section])
+      output = []
+      elements.each do |e|
+        case e
+        when :date
+          output << format('%13s |', @date.relative_date).cyan
+        when :section
+          output << "#{magenta}(#{white(@section)}#{magenta})"
+        when :title
+          output << @title.white.highlight_tags('cyan')
+        end
+      end
+
+      output.join(' ')
+    end
+
     # @private
     def inspect
       # %(<Doing::Item @date=#{@date} @title="#{@title}" @section:"#{@section}" @note:#{@note.to_s}>)

data/lib/doing/log_adapter.rb

@@ -52,7 +52,7 @@ module Doing
       COUNT_KEYS.each { |key| @counters[key] = { tag: [], count: 0 } }
       @results = []
       @logdev = $stderr
-      @max_length = `tput cols`.strip.to_i - 5 || 85
+      @max_length = TTY::Screen.columns - 5 || 85
       self.log_level = level
       @prev_level = level
     end
@@ -398,9 +398,9 @@ module Doing
       return topic.ljust(TOPIC_WIDTH) if topic && message.strip.empty?
 
       topic = formatted_topic(topic, colon: block_given?)
-      message.truncmiddle!(@max_length - TOPIC_WIDTH - 5)
+      # message.truncmiddle!(@max_length - TOPIC_WIDTH - 5)
       out = topic + message
-      out.truncate!(@max_length) if @max_length.positive?
+      # out.truncate!(@max_length) if @max_length.positive?
       messages << out
       out
     end

data/lib/doing/numeric_chronify.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## Number helpers
+  ##
+  class ::Numeric
+    ##
+    ## Format human readable time from seconds
+    ##
+    ## @param      seconds  [Integer] Seconds
+    ##
+    def format_time(human: false)
+      return [0, 0, 0] if nil?
+
+      seconds = dup.to_i
+      minutes = (seconds / 60).to_i
+      hours = (minutes / 60).to_i
+      if human
+        minutes = (minutes % 60).to_i
+        [0, hours, minutes]
+      else
+        days = (hours / 24).to_i
+        hours = (hours % 24).to_i
+        minutes = (minutes % 60).to_i
+        [days, hours, minutes]
+      end
+    end
+
+    ##
+    ## Format seconds as natural language time string
+    ##
+    ## @param      format  [Symbol] The format to output
+    ##                     (:dhm, :hm, :m, :clock, :natural)
+    ##
+    def time_string(format: :dhm)
+      format_time(human: true).time_string(format: format)
+    end
+  end
+end

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

@@ -84,7 +84,7 @@ module Doing
         interval ||= false
         human_time = false
         if interval
-          d, h, m = wwid.format_time(wwid.get_interval(i, formatted: false))
+          d, h, m = wwid.get_interval(i, formatted: false).format_time
           human_times = []
           human_times << format('%<d>d day%<p>s', d: d, p: d == 1 ? '' : 's') if d > 0
           human_times << format('%<h>d hour%<p>s', h: h, p: h == 1 ? '' : 's') if h > 0

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

@@ -56,7 +56,7 @@ module Doing
             end_date: end_date,
             title: title.strip, #+ " #{note}"
             note: note.instance_of?(Array) ? note.to_s : note,
-            time: '%02d:%02d:%02d' % wwid.format_time(interval),
+            time: interval.time_string(format: :clock),
             tags: tags
           }
 
@@ -68,7 +68,7 @@ module Doing
           new_item = {
             'id' => index + 1,
             'content' => title.strip, #+ " #{note}"
-            'title' => title.strip + " (#{'%02d:%02d:%02d' % wwid.format_time(interval)})",
+            'title' => title.strip + " (#{interval.time_string(format: :clock)})",
             'start' => i.date.strftime('%F %T'),
             'type' => 'box',
             'style' => 'color:#4c566b;background-color:#d8dee9;'

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

@@ -17,13 +17,63 @@ 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')}"
@@ -51,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