doing 2.1.1pre → 2.1.5pre

data/lib/doing/template_string.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## Template string formatting
+  ##
+  class TemplateString < String
+    class ::String
+      ##
+      ## Extract the longest valid color from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ## @api private
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym)
+        end
+
+        valid_color
+      end
+    end
+
+    attr_reader :original
+
+    include Color
+    def initialize(string, placeholders: {}, force_color: false, wrap_width: 0, color: '', tags_color: '', reset: '')
+      Color.coloring = true if force_color
+      @colors = nil
+      @original = string
+      super(Color.reset + string)
+
+      placeholders.each { |k, v| fill(k, v, wrap_width: wrap_width, color: color, tags_color: tags_color) }
+    end
+
+    ##
+    ## Test if string contains any valid %colors
+    ##
+    ## @return     [Boolean] True if colors, False otherwise.
+    ##
+    def colors?
+      scan(/%([a-z]+)/).each do
+        return true if Regexp.last_match(1).validate_color
+      end
+      false
+    end
+
+    def reparse
+      @parsed_colors = nil
+    end
+
+    ##
+    ## Return string with %colors replaced with escape codes
+    ##
+    ## @return     [String] colorized string
+    ##
+    def colored
+      reparse
+      parsed_colors[:string].apply_colors(parsed_colors[:colors])
+    end
+
+    ##
+    ## Remove all valid %colors from string
+    ##
+    ## @return     [String] cleaned string
+    ##
+    def raw
+      parsed_colors[:string].uncolor
+    end
+
+    def parsed_colors
+      @parsed_colors ||= parse_colors
+    end
+
+    ##
+    ## Parse a template string for %colors and return a hash
+    ## of colors and string locations
+    ##
+    ## @return     [Hash] Uncolored string and array of colors and locations
+    def parse_colors
+      working = dup
+      color_array = []
+
+      scan(/(?<!\\)(%([a-z]+))/).each do |color|
+        valid_color = color[1].validate_color
+        next unless valid_color
+
+        idx = working.match(/(?<!\\)%#{valid_color}/).begin(0)
+        color_array.push({ name: valid_color, color: Color.send(valid_color), index: idx })
+        working.sub!(/(?<!\\)%#{valid_color}/, '')
+      end
+
+      { string: working, colors: color_array }
+    end
+
+    ##
+    ## Apply a color array to a string
+    ##
+    ## @param      color_array  [Array] Array of hashes
+    ##                          containing :name, :color,
+    ##                          :index
+    ##
+    def apply_colors(color_array)
+      str = dup
+      color_array.reverse.each do |color|
+        c = color[:color].empty? ? Color.send(color[:name]) : color[:color]
+        str.insert(color[:index], c)
+      end
+      str
+    end
+
+    def fill(placeholder, value, wrap_width: 0, color: '', tags_color: '', reset: '')
+      reparse
+      rx = /(?mi)(?<!\\)%(?<width>-?\d+)?(?:\^(?<mchar>.))?(?:(?<ichar>[ _t]|[^a-z0-9])(?<icount>\d+))?(?<prefix>.[ _t]?)?#{placeholder.sub(/^%/, '')}(?<after>.*?)$/
+      ph = raw.match(rx)
+
+      return unless ph
+      placeholder_offset = ph.begin(0)
+      last_colors = parsed_colors[:colors].select { |v| v[:index] <= placeholder_offset + 4 }
+
+      last_color = last_colors.map { |v| v[:color] }.pop(3).join('')
+
+      sub!(rx) do
+        m = Regexp.last_match
+
+        after = m['after']
+
+        if value.nil? || value.empty?
+          after
+        else
+          pad = m['width'].to_i
+          mark = m['mchar'] || ''
+          if placeholder == 'shortdate' && m['width'].nil?
+            pad = 13
+          end
+          indent = nil
+          if m['ichar']
+            char = m['ichar'] =~ /t/ ? "\t" : ' '
+            indent = char * m['icount'].to_i
+          end
+          indent ||= placeholder =~ /^title/ ? '' : "\t"
+          prefix = m['prefix']
+          if placeholder =~ /^title/
+            color = last_color + color
+
+            if wrap_width.positive? || pad.positive?
+              width = pad.positive? ? pad : wrap_width
+
+              out = value.gsub(/%/, '\%').strip.wrap(width,
+                                                     pad: pad,
+                                                     indent: indent,
+                                                     offset: placeholder_offset,
+                                                     prefix: prefix,
+                                                     color: color,
+                                                     after: after,
+                                                     reset: reset,
+                                                     pad_first: false)
+              out.highlight_tags!(tags_color, last_color: color) if tags_color && !tags_color.empty?
+              out
+            else
+              out = format("%s%s%#{pad}s%s", prefix, color, value.gsub(/%/, '\%').sub(/\s*$/, ''), after)
+              out.highlight_tags!(tags_color, last_color: color) if tags_color && !tags_color.empty?
+              out
+            end
+          elsif placeholder =~ /^note/
+            if wrap_width.positive? || pad.positive?
+              width = pad.positive? ? pad : wrap_width
+              outstring = value.map do |l|
+                if l.empty?
+                  '  '
+                else
+                  line = l.gsub(/%/, '\%').strip.wrap(width, pad: pad, indent: indent, offset: 0, prefix: prefix, color: last_color, after: after, reset: reset, pad_first: true)
+                  line.highlight_tags!(tags_color, last_color: last_color) unless tags_color.nil? || tags_color.empty?
+                  "#{line}  "
+                end
+              end.join("\n")
+              "\n#{last_color}#{mark}#{outstring}  "
+            else
+              out = format("\n%s%s%s%#{pad}s%s", indent, prefix, last_color, value.join("\n#{indent}#{prefix}").gsub(/%/, '\%').sub(/\s*$/, ''), after)
+              out.highlight_tags!(tags_color, last_color: last_color) if tags_color && !tags_color.empty?
+              out
+            end
+          else
+            format("%s%#{pad}s%s", prefix, value.gsub(/%/, '\%').sub(/\s*$/, ''), after)
+          end
+        end
+      end
+      @parsed_colors = parse_colors
+    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

@@ -112,20 +112,19 @@ module Doing
         puts content
         return
       end
-
+      Doing.logger.benchmark(:write_file, :start)
       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
         Doing.logger.debug('Write:', "File written: #{file}")
       end
-
+      Doing.logger.benchmark(:_post_write_hook, :start)
       Hooks.trigger :post_write, file
+      Doing.logger.benchmark(:_post_write_hook, :finish)
+      Doing.logger.benchmark(:write_file, :finish)
     end
 
     def safe_load_file(filename)
@@ -133,7 +132,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,287 @@
+# frozen_string_literal: true
+require 'zlib'
+
+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)
+        Doing.logger.benchmark(:restore_backup, :start)
+        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}")
+        Doing.logger.benchmark(:restore_backup, :finish)
+      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 undos. If a filename is
+      ## provided, only backups of that filename will be used.
+      ##
+      ## @param      filename  The filename to restore
+      ##
+      def select_redo(filename = nil)
+        filename ||= Doing.config.settings['doing_file']
+
+        undones = Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).sort
+
+        raise DoingRuntimeError, 'End of redo history' if undones.empty?
+
+        total = undones.count
+        options = undones.each_with_object([]) do |file, arr|
+          d, _base = date_of_backup(file)
+          next if d.nil?
+
+          arr.push("#{d.time_ago}\t#{File.join(backup_dir, file)}")
+        end
+
+        backup_file = show_menu(options, filename)
+        idx = undones.index(File.basename(backup_file))
+        skipped = undones.slice!(idx, undones.count - idx)
+        undone = skipped.shift
+
+        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 #{idx}/#{total}")
+        Doing.logger.debug('Backup:', "#{total - skipped.count - 1} redos remaining")
+      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)
+          next if d.nil?
+          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,
+                                           prompt: 'Select a backup to restore',
+                                           sorted: false,
+                                           fzf_args: [
+                                             '--delimiter="\t"',
+                                             '--with-nth=1',
+                                             %(--preview='#{preview} "#{filename}" {2} #{pipe}'),
+                                             '--disabled',
+                                             '--height=10',
+                                             '--preview-window="right,70%,nowrap,follow"',
+                                             '--header="Select a revision to restore"'
+                                           ])
+        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)
+        Doing.logger.benchmark(:_write_backup, :start)
+        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)
+        # Zlib::GzipWriter.open(backup_file + '.gz') do |gz|
+        #   gz.write(IO.read(filename))
+        # end
+
+        FileUtils.cp(filename, backup_file)
+
+        prune_backups(filename, 15)
+        clear_undone(filename)
+        Doing.logger.benchmark(:_write_backup, :finish)
+      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(/^(?:undone)?(?<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)
+        return if target_date.nil?
+
+        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.1pre'
+  VERSION = '2.1.5pre'
 end