doing 2.1.0pre → 2.1.4pre

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

@@ -36,7 +36,10 @@ module Doing
 
           if opt[:wrap_width]&.positive?
             width = opt[:wrap_width]
-            note.map! { |line| line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n") }
+            note.map! do |line|
+              line.simple_wrap(width)
+              # line.chomp.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
+            end
             note = note.join("\n").split(/\n/).delete_if(&:empty?)
           end
         else
@@ -58,11 +61,35 @@ module Doing
           format("%#{pad}s", item.date.strftime(opt[:format]))
         end
 
-        interval = wwid.get_interval(item, record: true) if opt[:times]
+        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
+        end
 
         interval ||= ''
         output.sub!(/%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
+        end
+        duration ||= ''
+        output.sub!(/%duration/, duration)
+
         output.sub!(/%(\d+)?shortdate/) do
           pad = Regexp.last_match(1) || 13
           format("%#{pad}s", item.date.relative_date)

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,10 +118,12 @@ 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 << %(--prompt="#{prompt}")
+        fzf_args << "--height=#{options.count + 2}"
+        fzf_args << '--info=inline'
         fzf_args << '--multi' if multiple
         header = "esc: cancel,#{multiple ? ' tab: multi-select, ctrl-a: select all,' : ''} return: confirm"
-        fzf_args << %(--header "#{header}")
+        fzf_args << %(--header="#{header}")
         options.sort! if sorted
         res = `echo #{Shellwords.escape(options.join("\n"))}|#{fzf} #{fzf_args.join(' ')}`
         return false if res.strip.size.zero?
@@ -125,16 +135,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

@@ -162,6 +162,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
     ##
@@ -177,8 +200,14 @@ module Doing
       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
@@ -187,6 +216,7 @@ module Doing
       end
       out.push(line.join(' '))
       note = ''
+      after = after.dup if after.frozen?
       after.sub!(note_rx) do
         note = Regexp.last_match(0)
         ''
@@ -210,6 +240,10 @@ module Doing
       end
     end
 
+    def pluralize(number)
+      number == 1 ? self : "#{self}s"
+    end
+
     ##
     ## Convert a sort order string to a qualified type
     ##
@@ -269,6 +303,8 @@ module Doing
         :or
       when /(not|none)/i
         :not
+      when /^p/i
+        :pattern
       else
         default.is_a?(Symbol) ? default : default.normalize_bool
       end
@@ -282,8 +318,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 +547,7 @@ module Doing
         end
       else
         case self
-        when / *, */
+        when /(^\[.*?\]$| *, *)/
           gsub(/^\[ *| *\]$/, '').split(/ *, */)
         when /^[0-9]+$/
           to_i

data/lib/doing/string_chronify.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Doing
+  # Chronify methods for strings
+  class ::String
+    ##
+    ## Converts input string into a Time object when input
+    ## takes on the following formats:
+    ##             - interval format e.g. '1d2h30m', '45m'
+    ##               etc.
+    ##             - a semantic phrase e.g. 'yesterday
+    ##               5:30pm'
+    ##             - a strftime e.g. '2016-03-15 15:32:04
+    ##               PDT'
+    ##
+    ## @param      options  Additional options
+    ##
+    ## @option options :future [Boolean] assume future date
+    ##                                   (default: false)
+    ##
+    ## @option options :guess  [Symbol] :begin or :end to
+    ##                                   assume beginning or end of
+    ##                                   arbitrary time range
+    ##
+    ## @return     [DateTime] result
+    ##
+    def chronify(**options)
+      now = Time.now
+      raise InvalidTimeExpression, "Invalid time expression #{inspect}" if to_s.strip == ''
+
+      secs_ago = if match(/^(\d+)$/)
+                   # plain number, assume minutes
+                   Regexp.last_match(1).to_i * 60
+                 elsif (m = match(/^(?:(?<day>\d+)d)?(?:(?<hour>\d+)h)?(?:(?<min>\d+)m)?$/i))
+                   # day/hour/minute format e.g. 1d2h30m
+                   [[m['day'], 24 * 3600],
+                    [m['hour'], 3600],
+                    [m['min'], 60]].map { |qty, secs| qty ? (qty.to_i * secs) : 0 }.reduce(0, :+)
+                 end
+
+      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
+                      })
+      end
+    end
+
+    ##
+    ## Converts simple strings into seconds that can be
+    ## added to a Time object
+    ##
+    ## Input string can be HH:MM or XX[dhm][[XXhm][XXm]]
+    ## (1d2h30m, 45m, 1.5d, 1h20m, etc.)
+    ##
+    ## @return     [Integer] seconds
+    ##
+    def chronify_qty
+      minutes = 0
+      case self.strip
+      when /^(\d+):(\d\d)$/
+        minutes += Regexp.last_match(1).to_i * 60
+        minutes += Regexp.last_match(2).to_i
+      when /^(\d+(?:\.\d+)?)([hmd])?$/
+        amt = Regexp.last_match(1)
+        type = Regexp.last_match(2).nil? ? 'm' : Regexp.last_match(2)
+
+        minutes = case type.downcase
+                  when 'm'
+                    amt.to_i
+                  when 'h'
+                    (amt.to_f * 60).round
+                  when 'd'
+                    (amt.to_f * 60 * 24).round
+                  else
+                    minutes
+                  end
+      end
+      minutes * 60
+    end
+  end
+end

data/lib/doing/time.rb

@@ -14,5 +14,37 @@ module Doing
         strftime('%m/%d/%Y %_I:%M%P')
       end
     end
+
+    def humanize(seconds)
+      s = seconds
+      m = (s / 60).floor
+      s = (s % 60).floor
+      h = (m / 60).floor
+      m = (m % 60).floor
+      d = (h / 24).floor
+      h = h % 24
+
+      output = []
+      output.push("#{d} #{'day'.pluralize(d)}") if d.positive?
+      output.push("#{h} #{'hour'.pluralize(h)}") if h.positive?
+      output.push("#{m} #{'minute'.pluralize(m)}") if m.positive?
+      output.push("#{s} #{'second'.pluralize(s)}") if s.positive?
+      output.join(', ')
+    end
+
+    def time_ago
+      if self > Date.today.to_time
+        output = humanize(Time.now - self)
+        "#{output} ago"
+      elsif self > (Date.today - 1).to_time
+        "Yesterday at #{strftime('%_I:%M:%S%P')}"
+      elsif self > (Date.today - 6).to_time
+        strftime('%a %I:%M:%S%P')
+      elsif self.year == Date.today.year
+        strftime('%m/%d %I:%M:%S%P')
+      else
+        strftime('%m/%d/%Y %I:%M:%S%P')
+      end
+    end
   end
 end

data/lib/doing/util.rb

@@ -115,10 +115,7 @@ module Doing
 
       file = File.expand_path(file)
 
-      if File.exist?(file) && backup
-        # Create a backup copy for the undo command
-        FileUtils.cp(file, "#{file}~")
-      end
+      Backup.write_backup(file) if backup
 
       File.open(file, 'w+') do |f|
         f.puts content
@@ -133,7 +130,7 @@ module Doing
     end
 
     def default_editor
-      @default_editor = find_default_editor
+      @default_editor ||= find_default_editor
     end
 
     def editor_with_args

data/lib/doing/util_backup.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Doing
+  module Util
+    ## Backup utils
+    module Backup
+      extend self
+      include Util
+
+      ##
+      ## Delete all but most recent 5 backups
+      ##
+      ## @param      limit  Maximum number of backups to retain
+      ##
+      def prune_backups(filename, limit = 10)
+        backups = get_backups(filename)
+        return unless backups.count > limit
+
+        backups[limit..-1].each do |file|
+          FileUtils.rm(File.join(backup_dir, file))
+        end
+      end
+
+      ##
+      ## Restore the most recent backup. If a filename is
+      ## provided, only backups of that filename will be used.
+      ##
+      ## @param      filename  The filename to restore, if
+      ##                       different from default
+      ##
+      def restore_last_backup(filename = nil, count: 1)
+        filename ||= Doing.config.settings['doing_file']
+
+        result = get_backups(filename).slice(count - 1)
+        raise DoingRuntimeError, 'End of undo history' if result.nil?
+
+        backup_file = File.join(backup_dir, result)
+
+        save_undone(filename)
+        FileUtils.mv(backup_file, filename)
+        prune_backups_after(File.basename(backup_file))
+        Doing.logger.warn('File update:', "restored from #{result}")
+      end
+
+      ##
+      ## Undo last undo
+      ##
+      ## @param      filename  The filename
+      ##
+      def redo_backup(filename = nil, count: 1)
+        filename ||= Doing.config.settings['doing_file']
+        # redo_file = File.join(backup_dir, "undone___#{File.basename(filename)}")
+        undones = Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).sort
+        total = undones.count
+        count = total if count > total
+
+        skipped = undones.slice!(0, count)
+        undone = skipped.pop
+
+        raise DoingRuntimeError, 'End of redo history' if undone.nil?
+
+        redo_file = File.join(backup_dir, undone)
+
+        FileUtils.move(redo_file, filename)
+
+        skipped.each do |f|
+          FileUtils.mv(File.join(backup_dir, f), File.join(backup_dir, f.sub(/^undone/, '')))
+        end
+
+        Doing.logger.warn('File update:', "restored undo step #{count}/#{total}")
+        Doing.logger.debug('Backup:', "#{total - skipped.count - 1} redos remaining")
+      end
+
+      def clear_undone(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+        # redo_file = File.join(backup_dir, "undone___#{File.basename(filename)}")
+        Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).each do |f|
+          FileUtils.rm(File.join(backup_dir, f))
+        end
+      end
+
+      ##
+      ## Select from recent backups. If a filename is
+      ## provided, only backups of that filename will be used.
+      ##
+      ## @param      filename  The filename to restore
+      ##
+      def select_backup(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+
+        options = get_backups(filename).each_with_object([]) do |file, arr|
+          d, _base = date_of_backup(file)
+          arr.push("#{d.time_ago}\t#{File.join(backup_dir, file)}")
+        end
+
+        backup_file = show_menu(options, filename)
+        write_to_file(File.join(backup_dir, "undone___#{File.basename(filename)}"), IO.read(filename), backup: false)
+        FileUtils.mv(backup_file, filename)
+        prune_backups_after(File.basename(backup_file))
+        Doing.logger.warn('File update:', "restored from #{backup_file}")
+      end
+
+      def show_menu(options, filename)
+        if TTY::Which.which('colordiff')
+          preview = 'colordiff -U 1'
+          pipe = '| awk "(NR>2)"'
+        elsif TTY::Which.which('git')
+          preview = 'git --no-pager diff -U1 --color=always --minimal --word-diff'
+          pipe = ' | awk "(NR>4)"'
+        else
+          preview = 'diff -U 1'
+          pipe = if TTY::Which.which('delta')
+                   ' | delta --no-gitconfig --syntax-theme=1337'
+                 elsif TTY::Which.which('diff-so-fancy')
+                   ' | diff-so-fancy'
+                 elsif TTY::Which.which('ydiff')
+                   ' | ydiff -c always --wrap < /dev/tty'
+                 else
+                   cmd = 'sed -e "s/^-/`echo -e "\033[31m"`-/;s/^+/`echo -e "\033[32m"`+/;s/^@/`echo -e "\033[34m"`@/;s/\$/`echo -e "\033[0m"`/"'
+                   "| bash -c #{Shellwords.escape(cmd)}"
+                 end
+          pipe += ' | awk "(NR>2)"'
+        end
+
+        result = Doing::Prompt.choose_from(options,
+                                           sorted: false,
+                                           fzf_args: [
+                                             '--delimiter="\t"',
+                                             '--with-nth=1',
+                                             %(--preview='#{preview} "#{filename}" {2} #{pipe}'),
+                                             '--disabled',
+                                             '--preview-window="right,70%,nowrap,follow"'
+                                           ])
+        raise UserCancelled unless result
+
+        result.strip.split(/\t/).last
+      end
+
+      ##
+      ## Writes a copy of the content to a dated backup file
+      ## in a hidden directory
+      ##
+      ## @param      content  The data to back up
+      ##
+      def write_backup(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+
+        unless File.exist?(filename)
+          Doing.logger.debug('Backup:', "original file doesn't exist (#{filename})")
+          return
+        end
+
+        backup_file = File.join(backup_dir, "#{timestamp_filename}___#{File.basename(filename)}")
+        # compressed = Zlib::Deflate.deflate(content)
+
+        FileUtils.cp(filename, backup_file)
+
+        prune_backups(filename, 100)
+        clear_undone(filename)
+      end
+
+      private
+
+      def timestamp_filename
+        Time.now.strftime('%Y-%m-%d_%H.%M.%S')
+      end
+
+      def get_backups(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+        backups = Dir.glob("*___#{File.basename(filename)}", base: backup_dir).sort.reverse
+        backups.delete_if { |f| f =~ /^undone/ }
+      end
+
+      def save_undone(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+        undone_file = File.join(backup_dir, "undone#{timestamp_filename}___#{File.basename(filename)}")
+        FileUtils.cp(filename, undone_file)
+      end
+
+      ##
+      ## Retrieve date from backup filename
+      ##
+      ## @param      filename  The filename
+      ##
+      def date_of_backup(filename)
+        m = filename.match(/^(?<date>\d{4}-\d{2}-\d{2})_(?<time>\d{2}\.\d{2}\.\d{2})___(?<file>.*?)$/)
+        return nil if m.nil?
+
+        [Time.parse("#{m['date']} #{m['time'].gsub(/\./, ':')}"), m['file']]
+      end
+
+      ##
+      ## Return a location for storing backups, creating if needed
+      ##
+      ## @return     Path to backup directory
+      ##
+      def backup_dir
+        @backup_dir ||= create_backup_dir
+      end
+
+      def create_backup_dir
+        dir = File.expand_path(Doing.config.settings['backup_dir']) || File.join(user_home, '.doing_backup')
+        if File.exist?(dir) && !File.directory?(dir)
+          raise DoingRuntimeError, "Backup error: #{dir} is not a directory"
+
+        end
+
+        unless File.exist?(dir)
+          FileUtils.mkdir_p(dir)
+          Doing.logger.warn('Backup:', "backup directory created at #{dir}")
+        end
+
+        dir
+      end
+
+      ##
+      ## Delete backups newer than selected filename
+      ##
+      ## @param      filename  The filename
+      ##
+      def prune_backups_after(filename)
+        target_date, base = date_of_backup(filename)
+        counter = 0
+        get_backups(base).each do |file|
+          date, _base = date_of_backup(file)
+          if date && target_date < date
+            FileUtils.mv(File.join(backup_dir, file), File.join(backup_dir, "undone#{file}"))
+            counter += 1
+          end
+        end
+        Doing.logger.debug('Backup:', "deleted #{counter} files newer than restored backup")
+      end
+    end
+  end
+end

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.0pre'
+  VERSION = '2.1.4pre'
 end