doing 2.0.22 → 2.1.0pre

data/lib/doing/configuration.rb

@@ -90,21 +90,70 @@ module Doing
     }
 
     def initialize(file = nil, options: {})
-      if file
-        cf = File.expand_path(file)
-        # raise MissingConfigFile, "Config not found (#{cf})" unless File.exist?(cf)
+      @config_file = file.nil? ? default_config_file : File.expand_path(file)
 
-        @config_file = cf
+      @settings = configure(options)
+    end
+
+    def config_file
+      @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
+
+    def default_config_file
+      raise DoingRuntimeError, "#{config_dir} exists but is not a directory" if File.exist?(config_dir) && !File.directory?(config_dir)
+
+      unless File.exist?(config_dir)
+        FileUtils.mkdir_p(config_dir)
+        Doing.logger.log_now(:warn, "Config directory created at #{config_dir}")
       end
 
-      @settings = configure(options)
+      # File.join(config_dir, 'config.yml')
+      File.join(config_dir, 'config.yml')
     end
 
     def additional_configs
       @additional_configs ||= find_local_config
     end
 
-    def value_for_key(keypath = '')
+    ##
+    ## Present a menu if there are multiple configs found
+    ##
+    ## @return     [String] file path
+    ##
+    def choose_config
+      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 > ')
+
+        raise UserCancelled, 'Cancelled' unless res
+
+        res.strip || @config_file
+      else
+        @config_file
+      end
+    end
+
+    ##
+    ## Resolve a fuzzy-matched key path
+    ##
+    ## @param      keypath  [String] A dot-separated key
+    ##                      path, e.g.
+    ##                      "plugins.plugin_path". Will also
+    ##                      work with "plug.path" (fuzzy
+    ##                      matched, first match wins)
+    ## @return     [Array] ordered array of resolved keys
+    ##
+    def resolve_key_path(keypath)
       cfg = @settings
       real_path = []
       unless keypath =~ /^[.*]?$/
@@ -113,7 +162,8 @@ module Doing
           path = paths.shift
           new_cfg = nil
           cfg.each do |key, val|
-            next unless key =~ path.to_rx(distance: 2)
+            next unless key =~ path.to_rx(distance: 4)
+
             real_path << key
             new_cfg = val
             break
@@ -127,9 +177,30 @@ module Doing
         end
       end
       Doing.logger.debug('Config:', "translated key path #{keypath} to #{real_path.join('.')}")
-      result = {}
-      result[real_path[-1]] = cfg
-      result
+      real_path
+    end
+
+    ##
+    ## Get the value for a fuzzy-matched key path
+    ##
+    ## @param      keypath  [String] A dot-separated key
+    ##                      path, e.g.
+    ##                      "plugins.plugin_path". Will also
+    ##                      work with "plug.path" (fuzzy
+    ##                      matched, first match wins)
+    ## @return     [Hash] Config value
+    ##
+    def value_for_key(keypath = '')
+      cfg = @settings
+      real_path = ['config']
+      unless keypath =~ /^[.*]?$/
+        real_path = resolve_key_path(keypath)
+        return nil unless real_path&.count&.positive?
+
+        cfg = cfg.dig(*real_path)
+      end
+
+      cfg.nil? ? nil : { real_path[-1] => cfg }
     end
 
     # It takes the input, fills in the defaults where values do not exist.
@@ -141,12 +212,37 @@ module Doing
       Util.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
     end
 
-    def config_file
-      @config_file ||= File.join(Util.user_home, '.doingrc')
-    end
+    ##
+    ## Method for transitioning from ~/.doingrc to ~/.config/doing/config.yml
+    ##
+    def update_deprecated_config
+      # return # Until further notice
+      return if File.exist?(default_config_file)
 
-    def config_file=(file)
-      @config_file = file
+      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)
+
+      return unless res
+
+      if File.exist?(default_config_file)
+        res = wwid.yn("#{default_config_file} already exists, overwrite it?", default_response: false)
+
+        unless res
+          @config_file = old_file
+          return
+        end
+      end
+
+      FileUtils.mv old_file, default_config_file, force: true
+      Doing.logger.log_now(:warn, 'Config:', "Config file moved to #{default_config_file}")
+      Doing.logger.log_now(:warn, 'Config:', %(If ~/.doingrc exists in the future,
+                           it will be considered a local config and its values will override the
+                           default configuration.))
+      Process.exit 0
     end
 
     ##
@@ -155,6 +251,8 @@ module Doing
     ## @param      opt   [Hash] Additional Options
     ##
     def configure(opt = {})
+      update_deprecated_config if config_file == default_config_file
+
       @ignore_local = opt[:ignore_local] if opt[:ignore_local]
 
       config = read_config.dup
@@ -191,8 +289,23 @@ module Doing
       config
     end
 
+    # @private
+    def inspect
+      %(<Doing::Configuration #{@settings.hash}>)
+    end
+
+    # @private
+    def to_s
+      YAML.dump(@settings)
+    end
+
     private
 
+    ##
+    ## Test for deprecated config keys
+    ##
+    ## @param      config  The configuration
+    ##
     def find_deprecations(config)
       deprecated = false
       if config.key?('editor')
@@ -206,14 +319,16 @@ module Doing
         deprecated = true
         config['editors']['config'] = config['config_editor_app']
         config.delete('config_editor_app')
-        Doing.logger.debug('Deprecated:', "config key 'config_editor_app' is now 'editors->config', please update your config.")
+        Doing.logger.debug('Deprecated:',
+                           "config key 'config_editor_app' is now 'editors->config', please update your config.")
       end
 
       if config.key?('editor_app') && !config['editors']['doing_file']
         deprecated = true
         config['editors']['doing_file'] = config['editor_app']
         config.delete('editor_app')
-        Doing.logger.debug('Deprecated:', "config key 'editor_app' is now 'editors->doing_file', please update your config.")
+        Doing.logger.debug('Deprecated:',
+                           "config key 'editor_app' is now 'editors->doing_file', please update your config.")
       end
 
       Doing.logger.warn('Deprecated:', 'outdated keys found, please run `doing config --update`.') if deprecated
@@ -257,7 +372,7 @@ module Doing
     ##
     def read_config
       unless File.exist?(config_file)
-        Doing.logger.info('Config:', 'Config file doesn\'t exist, using default configuration' )
+        Doing.logger.info('Config:', 'Config file doesn\'t exist, using default configuration')
         return {}.deep_merge(DEFAULTS)
       end
 
@@ -302,11 +417,7 @@ module Doing
     end
 
     def load_plugins(add_dir = nil)
-      begin
-        FileUtils.mkdir_p(add_dir) if add_dir && !File.exist?(add_dir)
-      rescue
-        nil
-      end
+      FileUtils.mkdir_p(add_dir) if add_dir && !File.exist?(add_dir)
 
       Plugins.load_plugins(add_dir)
     end

data/lib/doing/hash.rb

@@ -27,5 +27,42 @@ module Doing
     def symbolize_keys
       each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v }
     end
+
+    # Set a nested hash value using an array
+    #
+    # @example `{}.deep_set(['one', 'two'], 'value')`
+    # @example `=> { 'one' => { 'two' => 'value' } }
+    #
+    # @param      path   [Array] key path
+    # @param      value  The value
+    #
+    def deep_set(path, value)
+      if path.count == 1
+        if value
+          self[path[0]] = value
+        else
+          delete(path[0])
+        end
+      else
+        if value
+          self.default_proc = ->(h, k) { h[k] = Hash.new(&h.default_proc) }
+          dig(*path[0..-2])[path.fetch(-1)] = value
+        else
+          return self unless dig(*path)
+
+          dig(*path[0..-2]).delete(path.fetch(-1))
+          path.pop
+          cleaned = self
+          path.each do |key|
+            if cleaned[key].empty?
+              cleaned.delete(key)
+              break
+            end
+            cleaned = cleaned[key]
+          end
+          empty? ? nil : self
+        end
+      end
+    end
   end
 end

data/lib/doing/item.rb

@@ -5,10 +5,10 @@ module Doing
   ## This class describes a single WWID item
   ##
   class Item
-    # include Amatch
-
     attr_accessor :date, :title, :section, :note
 
+    attr_reader :id
+
     ##
     ## Initialize an item with date, title, section, and
     ## optional note
@@ -50,8 +50,11 @@ 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 hash_id
-      (@date.to_s + @title + @section + @note.join(' ')).hash
+    # Generate a hash that represents the entry
+    #
+    # @return [String] entry hash
+    def id
+      @id ||= (@date.to_s + @title + @section).hash
     end
 
     ##
@@ -105,14 +108,42 @@ module Doing
     ##
     ## Add (or remove) tags from the title of the item
     ##
-    ## @param      tag        [String] The tag to add
-    ## @param      value      [String] A value to include as @tag(value)
-    ## @param      remove     [Boolean] if true remove instead of adding
-    ## @param      rename_to  [String] if not nil, rename target tag to this tag name
-    ## @param      regex      [Boolean] treat target tag string as regex pattern
+    ## @param      tags    [Array] The tags to apply
+    ## @param      **options Additional options
+    ##
+    ## @option options :date       [Boolean] Include timestamp?
+    ## @option options :single     [Boolean] Log as a single change?
+    ## @option options :value      [String] A value to include as @tag(value)
+    ## @option options :remove     [Boolean] if true remove instead of adding
+    ## @option options :rename_to  [String] if not nil, rename target tag to this tag name
+    ## @option options :regex      [Boolean] treat target tag string as regex pattern
+    ## @option options :force      [Boolean] with rename_to, add tag if it doesn't exist
     ##
-    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false)
-      @title.tag!(tag, value: value, remove: remove, rename_to: rename_to, regex: regex).strip!
+    def tag(tags, **options)
+      added = []
+      removed = []
+
+      date = options.fetch(:date, false)
+      options[:value] ||= date ? Time.now.strftime('%F %R') : nil
+      options.delete(:date)
+
+      single = options.fetch(:single, false)
+      options.delete(:single)
+
+      tags = tags.to_tags if tags.is_a? ::String
+
+      remove = options.fetch(:remove, false)
+      tags.each do |tag|
+        bool = remove ? :and : :not
+        if tags?(tag, bool)
+          @title.tag!(tag, **options).strip!
+          remove ? removed.push(tag) : added.push(tag)
+        end
+      end
+
+      Doing.logger.log_change(tags_added: added, tags_removed: removed, count: 1, item: self, single: single)
+
+      self
     end
 
     ##
@@ -121,7 +152,7 @@ module Doing
     ## @return     [Array] array of tags (no values)
     ##
     def tags
-      @title.scan(/(?<= |\A)@([^\s(]+)/).map {|tag| tag[0]}.sort.uniq
+      @title.scan(/(?<= |\A)@([^\s(]+)/).map { |tag| tag[0] }.sort.uniq
     end
 
     ##
@@ -190,6 +221,40 @@ module Doing
       should?('never_time')
     end
 
+    ##
+    ## Move item from current section to destination section
+    ##
+    ## @param      new_section  [String] The destination
+    ##                          section
+    ## @param      label        [Boolean] add @from(original
+    ##                          section) tag
+    ## @param      log          [Boolean] log this action
+    ##
+    ## @return     nothing
+    ##
+    def move_to(new_section, label: true, log: true)
+      from = @section
+
+      tag('from', rename_to: 'from', value: from, force: true) if label
+      @section = new_section
+
+      Doing.logger.count(@section == 'Archive' ? :archived : :moved) if log
+      Doing.logger.debug("#{@section == 'Archive' ? 'Archived' : 'Moved'}:",
+                         "#{@title.truncate(60)} from #{from} to #{@section}")
+      self
+    end
+
+    # outputs item in Doing file format, including leading tab
+    def to_s
+      "\t- #{@date.strftime('%Y-%m-%d %H:%M')} | #{@title}#{@note.empty? ? '' : "\n#{@note}"}"
+    end
+
+    # @private
+    def inspect
+      # %(<Doing::Item @date=#{@date} @title="#{@title}" @section:"#{@section}" @note:#{@note.to_s}>)
+      %(<Doing::Item @date=#{@date}>)
+    end
+
     private
 
     def should?(key)

data/lib/doing/items.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Doing
+  # Items Array
+  class Items < Array
+    attr_accessor :sections
+
+    def initialize
+      super
+      @sections = []
+    end
+
+    # List sections, title only
+    #
+    # @return     [Array] section titles
+    #
+    def section_titles
+      @sections.map(&:title)
+    end
+
+    # Test if section already exists
+    #
+    # @param      section  [String] section title
+    #
+    # @return     [Boolean] true if section exists
+    #
+    def section?(section)
+      has_section = false
+      section = section.is_a?(Section) ? section.title.downcase : section.downcase
+      @sections.each do |s|
+        if s.title.downcase == section
+          has_section = true
+          break
+        end
+      end
+      has_section
+    end
+
+    # Add a new section to the sections array. Accepts
+    # either a Section object, or a title string that will
+    # be converted into a Section.
+    #
+    # @param      section  [Section] The section to add. A
+    #                      String value will be converted to
+    #                      Section automatically.
+    # @param      log      [Boolean] Add a log message
+    #                      notifying the user about the
+    #                      creation of the section.
+    #
+    # @return     nothing
+    #
+    def add_section(section, log: false)
+      section = section.is_a?(Section) ? section : Section.new(section.cap_first)
+
+      return if section?(section)
+
+      @sections.push(section)
+      Doing.logger.info('New section:', %("#{section}" added)) if log
+    end
+
+    # Get a new Items object containing only items in a
+    # specified section
+    #
+    # @param      section  [String] section title
+    #
+    # @return     [Items] Array of items
+    #
+    def in_section(section)
+      if section =~ /^all$/i
+        dup
+      else
+        items = Items.new.concat(select { |item| item.section == section })
+        items.add_section(section, log: false)
+        items
+      end
+    end
+
+    ##
+    ## Delete an item from the index
+    ##
+    ## @param      item  The item
+    ##
+    def delete_item(item, single: false)
+      deleted = delete(item)
+      Doing.logger.count(:deleted)
+      Doing.logger.info('Entry deleted:', deleted.title) if single
+    end
+
+    ##
+    ## Update an item in the index with a modified item
+    ##
+    ## @param      old_item  The old item
+    ## @param      new_item  The new item
+    ##
+    def update_item(old_item, new_item)
+      s_idx = index { |item| item.equal?(old_item) }
+
+      raise ItemNotFound, 'Unable to find item in index, did it mutate?' unless s_idx
+
+      return if fetch(s_idx).equal?(new_item)
+
+      self[s_idx] = new_item
+      Doing.logger.count(:updated)
+      Doing.logger.info('Entry updated:', self[s_idx].title.truncate(60))
+      new_item
+    end
+
+    # Output sections and items in Doing file format
+    def to_s
+      out = []
+      @sections.each do |section|
+        out.push(section.original)
+        in_section(section.title).each { |item| out.push(item.to_s)}
+      end
+
+      out.join("\n")
+    end
+
+    # @private
+    def inspect
+      "#<Doing::Items #{count} items, #{@sections.count} sections: #{@sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')}>"
+    end
+
+  end
+end

data/lib/doing/log_adapter.rb

@@ -5,9 +5,16 @@ module Doing
   ## Log adapter
   ##
   class LogAdapter
-    attr_writer :logdev, :max_length
+    # Sets the log device
+    attr_writer :logdev
 
-    attr_reader :messages, :level, :results
+    # Max length of log messages (truncate in middle)
+    attr_writer :max_length
+
+    # Returns the current log level (debug, info, warn, error)
+    attr_reader :level
+
+    attr_reader :messages, :results
 
     TOPIC_WIDTH = 12
 
@@ -28,6 +35,7 @@ module Doing
       deleted
       moved
       removed_tags
+      rotated
       skipped
       updated
     ].freeze
@@ -45,6 +53,7 @@ module Doing
       @logdev = $stderr
       @max_length = `tput cols`.strip.to_i - 5 || 85
       self.log_level = level
+      @prev_level = level
     end
 
     #
@@ -71,8 +80,26 @@ module Doing
       @level = level
     end
 
+    # Set log level temporarily
+    def temp_level(level)
+      return if level.nil? || level.to_sym == @log_level
+
+      @prev_level = log_level.dup
+      @log_level = level.to_sym
+    end
+
+    # Restore temporary level
+    def restore_level
+      return if @prev_level.nil? || @prev_level == @log_level
+
+      self.log_level = @prev_level
+      @prev_level = nil
+    end
+
     def adjust_verbosity(options = {})
-      if options[:quiet]
+      if options[:log_level]
+        self.log_level = options[:log_level].to_sym
+      elsif options[:quiet]
         self.log_level = :error
       elsif options[:verbose] || options[:debug]
         self.log_level = :debug
@@ -227,7 +254,6 @@ module Doing
     ##
     def output_results
       total_counters
-
       results = @results.select { |msg| write_message?(msg[:level]) }.uniq
 
       if @logdev == $stdout
@@ -239,10 +265,38 @@ module Doing
       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)
+      else
+        if tags_added.empty?
+          count(:skipped, level: :debug, message: 'no tags added to %count %items')
+        elsif single && item
+          added = tags_added.log_tags
+          info('Tagged:',
+               %(added #{tags_added.count == 1 ? 'tag' : 'tags'} #{added} to #{item.title}))
+        else
+          count(:added_tags, level: :info, tag: tags_added, message: '%tags added to %count %items')
+        end
+
+        if tags_removed.empty?
+          count(:skipped, level: :debug, message: 'no tags removed from %count %items')
+        elsif single && item
+          added = tags_added.log_tags
+          info('Untagged:',
+               %(removed #{tags_removed.count == 1 ? 'tag' : 'tags'} #{added} from #{item.title}))
+        else
+          count(:removed_tags, level: :info, tag: tags_removed, message: '%tags removed from %count %items')
+        end
+      end
+    end
+
     private
 
     def format_counter(key, data)
       case key
+      when :rotated
+        ['Rotated:', data[:message] || 'rotated %count %items']
       when :autotag
         ['Autotag:', data[:message] || 'autotagged %count %items']
       when :added_tags