doing 2.1.2pre → 2.1.6pre

data/lib/doing/configuration.rb

@@ -7,7 +7,11 @@ module Doing
   class Configuration
     attr_reader :settings
 
-    attr_writer :ignore_local
+    attr_writer :ignore_local, :config_file, :force_answer
+
+    def force_answer
+      @force_answer ||= false
+    end
 
     MissingConfigFile = Class.new(RuntimeError)
 
@@ -25,11 +29,13 @@ module Doing
         'plugin_path' => File.join(Util.user_home, '.config', 'doing', 'plugins'),
         'command_path' => File.join(Util.user_home, '.config', 'doing', 'commands')
       },
-      'doing_file' => '~/what_was_i_doing.md',
+      'doing_file' => '~/.local/share/doing/what_was_i_doing.md',
+      'backup_dir' => '~/.local/share/doing/doing_backup',
       'current_section' => 'Currently',
       'paginate' => false,
       'never_time' => [],
       'never_finish' => [],
+      'date_tags' => ['done', 'defer(?:red)?', 'waiting'],
 
       'timer_format' => 'text',
       'interval_format' => 'text',
@@ -37,7 +43,8 @@ module Doing
       'templates' => {
         'default' => {
           'date_format' => '%Y-%m-%d %H:%M',
-          'template' => '%date | %title %interval%duration%note',
+          'template' => '%reset%cyan%shortdate %boldwhite%80║ title %dark%boldmagenta[%boldwhite%-10section%boldmagenta]%reset
+            %yellow%interval%boldred%duration%dark%white%80_14┃ note',
           'wrap_width' => 0,
           'order' => 'asc'
         },
@@ -54,7 +61,8 @@ module Doing
         },
         'recent' => {
           'date_format' => '%_I:%M%P',
-          'template' => '%shortdate: %title (%section) %interval%duration%note',
+          'template' => '%reset%cyan%shortdate %boldwhite%80║ title %dark%boldmagenta[%boldwhite%-10section%boldmagenta]%reset
+            %yellow%interval%boldred%duration%dark%white%80_14┃ note',
           'wrap_width' => 88,
           'count' => 10,
           'order' => 'asc'
@@ -66,7 +74,7 @@ module Doing
       'views' => {
         'done' => {
           'date_format' => '%_I:%M%P',
-          'template' => '%date | %title%note',
+          'template' => '%date | %title (%section)% 18: note',
           'wrap_width' => 0,
           'section' => 'All',
           'count' => 0,
@@ -87,6 +95,11 @@ module Doing
       'marker_color' => 'red',
       'default_tags' => [],
       'tag_sort' => 'name',
+      'search' => {
+        'matching' => 'pattern', # fuzzy, pattern, exact
+        'distance' => 3,
+        'case' => 'smart' # sensitive, ignore, smart
+      },
       'include_notes' => true
     }
 
@@ -100,24 +113,32 @@ module Doing
       @config_file ||= default_config_file
     end
 
-    def config_file=(file)
-      @config_file = file
-    end
-
     def config_dir
       @config_dir ||= File.join(Util.user_home, '.config', 'doing')
-      # @config_dir ||= Util.user_home
+    end
+
+    ##
+    ## Check if configuration enforces exact string matching
+    ##
+    ## @return     [Boolean] exact matching enabled
+    ##
+    def exact_match?
+      search_settings = @settings['search']
+      matching = search_settings.fetch('matching', 'pattern').normalize_matching
+      matching == :exact
     end
 
     def default_config_file
-      raise DoingRuntimeError, "#{config_dir} exists but is not a directory" if File.exist?(config_dir) && !File.directory?(config_dir)
+      if File.exist?(config_dir) && !File.directory?(config_dir)
+        raise DoingRuntimeError, "#{config_dir} exists but is not a directory"
+
+      end
 
       unless File.exist?(config_dir)
         FileUtils.mkdir_p(config_dir)
         Doing.logger.log_now(:warn, "Config directory created at #{config_dir}")
       end
 
-      # File.join(config_dir, 'config.yml')
       File.join(config_dir, 'config.yml')
     end
 
@@ -131,10 +152,13 @@ module Doing
     ## @return     [String] file path
     ##
     def choose_config
+      return @config_file if @force_answer
+
       if @additional_configs.count.positive?
-        choices = [@config_file]
-        choices.concat(@additional_configs)
-        res = Doing::Prompt.choose_from(choices.uniq.sort.reverse, sorted: false, prompt: 'Local configs found, select which to update > ')
+        choices = [@config_file].concat(@additional_configs)
+        res = Doing::Prompt.choose_from(choices.uniq.sort.reverse,
+                                        sorted: false,
+                                        prompt: 'Local configs found, select which to update > ')
 
         raise UserCancelled, 'Cancelled' unless res
 
@@ -214,11 +238,15 @@ module Doing
       cfg.nil? ? nil : { real_path[-1] => cfg }
     end
 
-    # It takes the input, fills in the defaults where values do not exist.
+    # It takes the input, fills in the defaults where values
+    # do not exist.
+    #
+    # @param      user_config  a Hash or Configuration of
+    #                          overrides.
     #
-    # user_config - a Hash or Configuration of overrides.
+    # @return     [Hash] a Configuration filled with
+    #             defaults.
     #
-    # Returns a Configuration filled with defaults.
     def from(user_config)
       Util.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
     end
@@ -233,14 +261,13 @@ module Doing
       old_file = File.join(Util.user_home, '.doingrc')
       return unless File.exist?(old_file)
 
-      wwid = Doing::WWID.new
       Doing.logger.log_now(:warn, 'Deprecated:', "main config file location has changed to #{config_file}")
-      res = wwid.yn("Move #{old_file} to new location, preserving settings?", default_response: true)
+      res = Prompt.yn("Move #{old_file} to new location, preserving settings?", default_response: true)
 
       return unless res
 
       if File.exist?(default_config_file)
-        res = wwid.yn("#{default_config_file} already exists, overwrite it?", default_response: false)
+        res = Prompt.yn("#{default_config_file} already exists, overwrite it?", default_response: false)
 
         unless res
           @config_file = old_file

data/lib/doing/item.rb

@@ -7,7 +7,7 @@ module Doing
   class Item
     attr_accessor :date, :title, :section, :note
 
-    attr_reader :id
+    # attr_reader :id
 
     ##
     ## Initialize an item with date, title, section, and
@@ -116,7 +116,7 @@ module Doing
     ## Add (or remove) tags from the title of the item
     ##
     ## @param      tags    [Array] The tags to apply
-    ## @param      **options Additional options
+    ## @param      options Additional options
     ##
     ## @option options :date       [Boolean] Include timestamp?
     ## @option options :single     [Boolean] Log as a single change?
@@ -162,6 +162,10 @@ module Doing
       @title.scan(/(?<= |\A)@([^\s(]+)/).map { |tag| tag[0] }.sort.uniq
     end
 
+    def tag_array
+      tags.tags_to_array
+    end
+
     ##
     ## Test if item contains tag(s)
     ##
@@ -172,6 +176,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 +197,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 +212,30 @@ 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: 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
+
+      if search.is_rx? || matching == :fuzzy
+        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 +322,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/log_adapter.rb

@@ -38,6 +38,7 @@ module Doing
       rotated
       skipped
       updated
+      exported
     ].freeze
 
     #
@@ -265,6 +266,31 @@ module Doing
       end
     end
 
+    def benchmark(key, state)
+      return unless ENV['DOING_BENCHMARK']
+
+      @benchmarks ||= {}
+      @benchmarks[key] ||= { start: nil, finish: nil }
+      @benchmarks[key][state] = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def log_benchmarks
+      if ENV['DOING_BENCHMARK']
+        output = []
+        @benchmarks.each do |k, timers|
+          if timers[:finish] && timers[:start]
+            output << "#{k}: #{timers[:finish] - timers[:start]}"
+          else
+            output << "#{k}: error"
+          end
+        end
+        output.each do |msg|
+          $stdout.puts color_message(:debug, 'Benchmark:', msg)
+        end
+      end
+    end
+
+
     def log_change(tags_added: [], tags_removed: [], count: 1, item: nil, single: false)
       if tags_added.empty? && tags_removed.empty?
         count(:skipped, level: :debug, message: '%count %items with no change', count: count)
@@ -319,6 +345,8 @@ module Doing
         ['Archived:',  data[:message] || 'completed and archived %count %items']
       when :skipped
         ['Skipped:', data[:message] || '%count %items were unchanged']
+      when :exported
+        ['Exported:', data[:message] || '%count %items were exported']
       end
     end
 

data/lib/doing/note.rb

@@ -22,7 +22,7 @@ module Doing
     ## Add note contents, optionally replacing existing note
     ##
     ## @param      note     [Array] The note to add, can be
-    ##                      string or array (Note)
+    ##                      String, Array, or Note
     ## @param      replace  [Boolean] replace existing
     ##                      content
     ##
@@ -36,32 +36,7 @@ module Doing
     end
 
     ##
-    ## Append an array of strings to note
-    ##
-    ## @param      lines  [Array] Array of strings
-    ##
-    def append(lines)
-      concat(lines)
-      replace compress
-    end
-
-    ##
-    ## Append a string to the note content
-    ##
-    ## @param      input  [String] The input string,
-    ##                    newlines will be split
-    ##
-    def append_string(input)
-      concat(input.split(/\n/).map(&:strip))
-      replace compress
-    end
-
-    def compress!
-      replace compress
-    end
-
-    ##
-    ## Remove blank lines and comment lines (#)
+    ## Remove blank lines and comments (#)
     ##
     ## @return     [Array] compressed array
     ##
@@ -69,8 +44,8 @@ module Doing
       delete_if { |l| l =~ /^\s*$/ || l =~ /^#/ }
     end
 
-    def strip_lines!
-      replace strip_lines
+    def compress!
+      replace compress
     end
 
     ##
@@ -83,6 +58,10 @@ module Doing
       map(&:strip)
     end
 
+    def strip_lines!
+      replace strip_lines
+    end
+
     ##
     ## Note as multi-line string
     def to_s
@@ -101,11 +80,33 @@ module Doing
     ## @param      other  [Note] The other Note
     ##
     ## @return     [Boolean] true if equal
-    ##
     def equal?(other)
       return false unless other.is_a?(Note)
 
       to_s == other.to_s
     end
+
+    private
+
+    ##
+    ## Append an array of strings to note
+    ##
+    ## @param      lines  [Array] Array of strings
+    ##
+    def append(lines)
+      concat(lines)
+      replace compress
+    end
+
+    ##
+    ## Append a string to the note content
+    ##
+    ## @param      input  [String] The input string,
+    ##                    newlines will be split
+    ##
+    def append_string(input)
+      concat(input.split(/\n/).map(&:strip))
+      replace compress
+    end
   end
 end

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