doing 2.1.3 → 2.1.4pre

data/lib/doing/item.rb

@@ -172,6 +172,13 @@ module Doing
     ## @return     [Boolean] true if tag/bool combination passes
     ##
     def tags?(tags, bool = :and, negate: false)
+      if bool == :pattern
+        tags = tags.join(' ') if tags.is_a?(Array)
+        matches = tag_pattern?(tags.gsub(/ *, */, ' '))
+
+        return negate ? !matches : matches
+      end
+
       tags = split_tags(tags)
       bool = bool.normalize_bool
 
@@ -186,6 +193,10 @@ module Doing
       negate ? !matches : matches
     end
 
+    def ignore_case(search, case_type)
+      (case_type == :smart && search !~ /[A-Z]/) || case_type == :ignore
+    end
+
     ##
     ## Test if item matches search string
     ##
@@ -197,9 +208,25 @@ module Doing
     ##
     ## @return     [Boolean] matches search criteria
     ##
-    def search(search, distance: 3, negate: false, case_type: :smart, fuzzy: false)
-      text = @title + @note.to_s
-      matches = text =~ search.to_rx(distance: distance, case_type: case_type)
+    def search(search, distance: 3, negate: false, case_type: :smart)
+      if search.is_rx?
+        matches = @title + @note.to_s =~ search.to_rx(distance: distance, case_type: case_type)
+      else
+        query = to_phrase_query(search.strip)
+
+        if query[:must].nil? && query[:must_not].nil?
+          query[:must] = query[:should]
+          query[:should] = []
+        end
+        matches = no_searches?(query[:must_not], case_type: case_type)
+        matches &&= all_searches?(query[:must], case_type: case_type)
+        matches &&= any_searches?(query[:should], case_type: case_type)
+      end
+      # if search =~ /(?<=\A| )[+-]\S/
+      # else
+      #   text = @title + @note.to_s
+      #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
+      # end
 
       # if search.is_rx? || !fuzzy
       #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
@@ -286,33 +313,92 @@ module Doing
       start = @date
 
       t = (done - start).to_i
-      t > 0 ? t : nil
+      t.positive? ? t : nil
+    end
+
+    def all_searches?(searches, case_type: :smart)
+      return true if searches.nil? || searches.empty?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return false unless text =~ rx
+      end
+      true
+    end
+
+    def no_searches?(searches, case_type: :smart)
+      return true if searches.nil? || searches.empty?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return false if text =~ rx
+      end
+      true
+    end
+
+    def any_searches?(searches, case_type: :smart)
+      return true if searches.nil? || searches.empty?
+
+      text = @title + @note.to_s
+      searches.each do |s|
+        rx = Regexp.new(s.wildcard_to_rx, ignore_case(s, case_type))
+        return true if text =~ rx
+      end
+      false
     end
 
     def all_tags?(tags)
+      return true if tags.nil? || tags.empty?
+
       tags.each do |tag|
-        return false unless @title =~ /@#{tag}/
+        return false unless @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
       end
       true
     end
 
     def no_tags?(tags)
+      return true if tags.nil? || tags.empty?
+
       tags.each do |tag|
-        return false if @title =~ /@#{tag}/
+        return false if @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
       end
       true
     end
 
     def any_tags?(tags)
+      return true if tags.nil? || tags.empty?
+
       tags.each do |tag|
-        return true if @title =~ /@#{tag}/
+        return true if @title =~ /@#{tag.wildcard_to_rx}(?= |\(|\Z)/i
       end
       false
     end
 
+    def to_query(query)
+      parser = BooleanTermParser::QueryParser.new
+      transformer = BooleanTermParser::QueryTransformer.new
+      parse_tree = parser.parse(query)
+      transformer.apply(parse_tree).to_elasticsearch
+    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 tag_pattern?(tags)
+      query = to_query(tags)
+
+      no_tags?(query[:must_not]) && all_tags?(query[:must]) && any_tags?(query[:should])
+    end
+
     def split_tags(tags)
       tags = tags.split(/ *, */) if tags.is_a? String
-      tags.map { |t| t.strip.sub(/^@/, '') }
+      tags.map { |t| t.strip.add_at }
     end
   end
 end

data/lib/doing/items.rb

@@ -105,6 +105,12 @@ module Doing
       new_item
     end
 
+    def all_tags
+      each_with_object([]) do |entry, tags|
+        tags.concat(entry.tags).sort!.uniq!
+      end
+    end
+
     # Output sections and items in Doing file format
     def to_s
       out = []

data/lib/doing/phrase_parser.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'parslet'
+
+module PhraseParser
+  # This parser adds quoted phrases (using matched double quotes) in addition to
+  # terms. This is done creating multiple types of clauses instead of just one.
+  # A phrase clause generates an Elasticsearch match_phrase query.
+  class QueryParser < Parslet::Parser
+    rule(:term) { match('[^\s"]').repeat(1).as(:term) }
+    rule(:quote) { str('"') }
+    rule(:operator) { (str('+') | str('-')).as(:operator) }
+    rule(:phrase) do
+      (quote >> (term >> space.maybe).repeat >> quote).as(:phrase)
+    end
+    rule(:clause) { (operator.maybe >> (phrase | term)).as(:clause) }
+    rule(:space)  { match('\s').repeat(1) }
+    rule(:query) { (clause >> space.maybe).repeat.as(:query) }
+    root(:query)
+  end
+
+  class QueryTransformer < Parslet::Transform
+    rule(:clause => subtree(:clause)) do
+      if clause[:term]
+        TermClause.new(clause[:operator]&.to_s, clause[:term].to_s)
+      elsif clause[:phrase]
+        phrase = clause[:phrase].map { |p| p[:term].to_s }.join(' ')
+        PhraseClause.new(clause[:operator]&.to_s, phrase)
+      else
+        raise "Unexpected clause type: '#{clause}'"
+      end
+    end
+    rule(query: sequence(:clauses)) { Query.new(clauses) }
+  end
+
+  class Operator
+    def self.symbol(str)
+      case str
+      when '+'
+        :must
+      when '-'
+        :must_not
+      when nil
+        :should
+      else
+        raise "Unknown operator: #{str}"
+      end
+    end
+  end
+
+  class TermClause
+    attr_accessor :operator, :term
+
+    def initialize(operator, term)
+      self.operator = Operator.symbol(operator)
+      self.term = term
+    end
+  end
+
+  # Phrase
+  class PhraseClause
+    attr_accessor :operator, :phrase
+
+    def initialize(operator, phrase)
+      self.operator = Operator.symbol(operator)
+      self.phrase = phrase
+    end
+  end
+
+  ## Query object
+  class Query
+    attr_accessor :should_clauses, :must_not_clauses, :must_clauses
+
+    def initialize(clauses)
+      grouped = clauses.chunk(&:operator).to_h
+      self.should_clauses = grouped.fetch(:should, [])
+      self.must_not_clauses = grouped.fetch(:must_not, [])
+      self.must_clauses = grouped.fetch(:must, [])
+    end
+
+    def to_elasticsearch
+      query = {}
+
+      if should_clauses.any?
+        query[:should] = should_clauses.map do |clause|
+          clause_to_query(clause)
+        end
+      end
+
+      if must_clauses.any?
+        query[:must] = must_clauses.map do |clause|
+          clause_to_query(clause)
+        end
+      end
+
+      if must_not_clauses.any?
+        query[:must_not] = must_not_clauses.map do |clause|
+          clause_to_query(clause)
+        end
+      end
+
+      query
+    end
+
+    def clause_to_query(clause)
+      case clause
+      when TermClause
+        match(clause.term)
+      when PhraseClause
+        match_phrase(clause.phrase)
+      else
+        raise "Unknown clause type: #{clause}"
+      end
+    end
+
+    def match(term)
+      term
+    end
+
+    def match_phrase(phrase)
+      phrase
+    end
+  end
+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
       ##

data/lib/doing/string.rb

@@ -240,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
     ##
@@ -299,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
@@ -312,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)
@@ -533,7 +547,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/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.3'
+  VERSION = '2.1.4pre'
 end