doing 2.1.39 → 2.1.42

data/lib/doing/item/tags.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Doing
+  # A Doing entry
+  module ItemTags
+    ##
+    ## Add (or remove) tags from the title of the item
+    ##
+    ## @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(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|
+        if tag =~ /^(\S+)\((.*?)\)$/
+          m = Regexp.last_match
+          tag = m[1]
+          options[:value] ||= m[2]
+        end
+
+        bool = remove ? :and : :not
+        if tags?(tag, bool) || options[:value]
+          @title = @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
+
+    ##
+    ## Get a list of tags on the item
+    ##
+    ## @return     [Array] array of tags (no values)
+    ##
+    def tags
+      @title.scan(/(?<= |\A)@([^\s(]+)/).map { |tag| tag[0] }.sort.uniq
+    end
+
+    ##
+    ## Return all tags including parenthetical values
+    ##
+    ## @return     [Array<Array>] Array of array pairs,
+    ##             [[tag1, value], [tag2, value]]
+    ##
+    def tags_with_values
+      @title.scan(/(?<= |\A)@([^\s(]+)(?:\((.*?)\))?/).map { |tag| [tag[0], tag[1]] }.sort.uniq
+    end
+
+    ##
+    ## convert tags on item to an array with @ symbols removed
+    ##
+    ## @return     [Array] array of tags
+    ##
+    def tag_array
+      tags.tags_to_array
+    end
+
+    private
+
+    def split_tags(tags)
+      tags.to_tags.tags_to_array
+    end
+  end
+end

data/lib/doing/items/filter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Doing
+  class Items < Array
+    # 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.nil? && item.section == section })
+        items.add_section(section, log: false)
+        items
+      end
+    end
+
+    ##
+    ## Search Items for a string (title and note)
+    ##
+    ## @param      query      [String] The query
+    ## @param      case_type  [Symbol] The case type
+    ##                        (:smart, :sensitive, :ignore)
+    ##
+    ## @return     [Items] array of items matching search
+    ##
+    def search(query, case_type: :smart)
+      WWID.new.fuzzy_filter_items(self, query, case_type: case_type)
+    end
+
+    ##
+    ## Search items by tags
+    ##
+    ## @param      tags  [Array,String] The tags by which to
+    ##                   filter
+    ## @param      bool  [Symbol] The bool with which to
+    ##                   combine multiple tags
+    ##
+    ## @return     [Items] array of items matching tag filter
+    ##
+    def tagged(tags, bool: :and)
+      WWID.new.filter_items(self, opt: { tag: tags, bool: bool })
+    end
+
+    ##
+    ## Filter Items by date. String arguments will be
+    ## chronified
+    ##
+    ## @param      start   [Time,String] Filter items after
+    ##                     this date
+    ## @param      finish  [Time,String] Filter items before
+    ##                     this date
+    ##
+    ## @return     [Items] array of items with dates between
+    ##             targets
+    ##
+    def between_dates(start, finish)
+      start = start.chronify(guess: :begin, future: false) if start.is_a?(String)
+      finish = finish.chronify(guess: :end) if finish.is_a?(String)
+      WWID.new.filter_items(self, opt: { date_filter: [start, finish] })
+    end
+  end
+end

data/lib/doing/items/items.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'filter'
+require_relative 'modify'
+require_relative 'sections'
+require_relative 'util'
+
+module Doing
+  # A collection of Item objects
+  class Items < Array
+    attr_accessor :sections
+
+    def initialize
+      super
+      @sections = []
+    end
+
+    ##
+    ## Test if self includes Item
+    ##
+    ## @param      item           [Item] The item to search for
+    ## @param      match_section  [Boolean] Section must match
+    ##
+    ## @return     [Boolean] True if Item exists
+    ##
+    def include?(item, match_section: true)
+      includes = false
+      each do |other_item|
+        if other_item.equal?(item, match_section: match_section)
+          includes = true
+          break
+        end
+      end
+
+      includes
+    end
+
+    # Output sections and items in Doing file format
+    def to_s
+      out = []
+      @sections.each do |section|
+        out.push(section.original)
+        items = in_section(section.title).sort_by { |i| [i.date, i.title] }
+        items.reverse! if Doing.setting('doing_file_sort').normalize_order == :desc
+        items.each { |item| out.push(item.to_s) }
+      end
+
+      out.join("\n")
+    end
+
+    # @private
+    def inspect
+      sections = @sections.map { |s| "<Section:#{s.title} #{in_section(s.title).count} items>" }.join(', ')
+      "#<Doing::Items #{count} items, #{@sections.count} sections: #{sections}>"
+    end
+  end
+end

data/lib/doing/items/modify.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Doing
+  class Items < Array
+    ##
+    ## 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
+      deleted
+    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.trunc(60))
+      new_item
+    end
+  end
+end

data/lib/doing/items/sections.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Doing
+  class Items < Array
+    # 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)
+      section = section.is_a?(Section) ? section.title.downcase : section.downcase
+      @sections.map { |i| i.title.downcase }.include?(section)
+    end
+
+    ##
+    ## Return the best section match for a search query
+    ##
+    ## @param      frag      The search query
+    ## @param      distance  The distance apart characters can be (fuzziness)
+    ##
+    ## @return     [Section] (first) matching section object
+    ##
+    def guess_section(frag, distance: 2)
+      section = nil
+      re = frag.to_rx(distance: distance, case_type: :ignore)
+      @sections.each do |sect|
+        next unless sect.title =~ /#{re}/i
+
+        Doing.logger.debug('Match:', %(Assuming "#{sect.title}" from "#{frag}"))
+        section = sect
+        break
+      end
+
+      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
+
+    def delete_section(section, log: false)
+      return unless section?(section)
+
+      raise DoingRuntimeError, 'Section not empty' if in_section(section).count.positive?
+
+      @sections.each do |sect|
+        next unless sect.title == section && in_section(sect).count.zero?
+
+        @sections.delete(sect)
+        Doing.logger.info('Removed section:', %("#{section}" removed)) if log
+      end
+
+      Doing.logger.error('Not found:', %("#{section}" not found))
+    end
+  end
+end

data/lib/doing/items/util.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Doing
+  class Items < Array
+    # # Create a deep copy of Items
+    # def clone
+    #   Marshal.load(Marshal.dump(self))
+    # end
+
+    def delete(item)
+      deleted = nil
+      each_with_index do |i, idx|
+        if i.equal?(item, match_section: true)
+          deleted = delete_at(idx)
+          break
+        end
+      end
+      deleted
+    end
+
+    ##
+    ## Get all tags on Items in self
+    ##
+    ## @return     [Array] array of tags
+    ##
+    def all_tags
+      each_with_object([]) do |entry, tags|
+        tags.concat(entry.tags).sort!.uniq!
+      end
+    end
+
+    ##
+    ## Return Items containing items that don't exist in
+    ## receiver
+    ##
+    ## @param      items  [Items] Receiver
+    ##
+    ## @return     [Hash] Hash of added and deleted items
+    ##
+    def diff(items)
+      a = clone
+      b = items.clone
+
+      a.delete_if do |item|
+        if b.include?(item)
+          b.delete(item)
+          true
+        else
+          false
+        end
+      end
+      { added: b, deleted: a }
+    end
+
+    ##
+    ## Remove duplicated entries. Duplicate entries must have matching start date, title, note, and section
+    ##
+    ## @return     [Items] Items array with duplicate entries removed
+    ##
+    def dedup(match_section: true)
+      unique = Items.new
+      each do |item|
+        unique.push(item) unless unique.include?(item, match_section: match_section)
+      end
+
+      unique
+    end
+
+    # @see #dedup
+    def dedup!(match_section: true)
+      replace dedup(match_section: match_section)
+    end
+  end
+end

data/lib/doing/normalize.rb

@@ -4,7 +4,7 @@ module Doing
   ##
   ## String to symbol conversion
   ##
-  class ::String
+  module StringNormalize
     ##
     ## Convert tag sort string to a qualified type
     ##
@@ -160,7 +160,7 @@ module Doing
   ##
   ## Symbol helpers
   ##
-  class ::Symbol
+  module SymbolNormalize
     def normalize_tag_sort(default = :name)
       to_s.normalize_tag_sort
     end
@@ -186,3 +186,11 @@ module Doing
     end
   end
 end
+
+class ::String
+  include Doing::StringNormalize
+end
+
+class ::Symbol
+  include Doing::SymbolNormalize
+end

data/lib/doing/note.rb

@@ -20,7 +20,7 @@ module Doing
     ##
     ## Add note contents, optionally replacing existing note
     ##
-    ## @param      note     [Array] The note to add, can be
+    ## @param      note     [Array|String|Note] The note to add, can be
     ##                      String, Array, or Note
     ## @param      replace  [Boolean] replace existing
     ##                      content

data/lib/doing/pager.rb

@@ -70,14 +70,20 @@ module Doing
       end
 
       def pagers
-        [ENV['GIT_PAGER'], ENV['PAGER'], git_pager,
-         'bat -p --pager="less -Xr"', 'less -Xr', 'more -r'].compact
+        [
+          Doing.setting('editors.pager'),
+          ENV['PAGER'],
+          'less -Xr',
+          ENV['GIT_PAGER'],
+          git_pager,
+          'more -r'
+        ].remove_bad
       end
 
       def find_executable(*commands)
         execs = commands.empty? ? pagers : commands
         execs
-          .compact.map(&:strip).reject(&:empty?).uniq
+          .remove_bad.uniq
           .find { |cmd| TTY::Which.exist?(cmd.split.first) }
       end
 

data/lib/doing/plugin_manager.rb

@@ -4,10 +4,17 @@ module Doing
   # Plugin handling
   module Plugins
     class << self
+      # Return the user's home directory
       def user_home
         @user_home ||= Util.user_home
       end
 
+      # Storage for registered plugins. Hash with :import
+      # and :export keys containing hashes of available
+      # plugins.
+      #
+      # @return     [Hash] registered plugins
+      #
       def plugins
         @plugins ||= {
           import: {},
@@ -81,14 +88,25 @@ module Doing
         Doing.logger.debug('Plugin Manager:', "Registered #{type} plugin \"#{title}\"")
       end
 
+      ##
+      ## Verifies that a plugin is properly configured with
+      ## necessary methods for its type. If the plugin fails
+      ## validation, a PluginUncallable exception will be
+      ## raised.
+      ##
+      ## @param      title  [String] The title
+      ## @param      type   [Symbol] type, :import or
+      ##                    :export
+      ## @param      klass  [Class] Plugin class
+      ##
       def validate_plugin(title, type, klass)
         type = valid_type(type)
         if type == :import && !klass.respond_to?(:import)
-          raise Errors::PluginUncallable.new('Import plugins must respond to :import', type: type, plugin: title)
+          raise Errors::PluginUncallable.new('Import plugins must respond to :import', type, title)
         end
 
         if type == :export && !klass.respond_to?(:render)
-          raise Errors::PluginUncallable.new('Export plugins must respond to :render', type: type, plugin: title)
+          raise Errors::PluginUncallable.new('Export plugins must respond to :render', type, title)
         end
 
         type
@@ -113,7 +131,7 @@ module Doing
                when /^e(x(p(o(r(t)?)?)?)?)?$/
                  :export
                else
-                 raise Errors::InvalidPluginType, 'Invalid plugin type'
+                 raise Errors::InvalidPluginType.new('Invalid plugin type', 'unrecognized')
                end
 
         type.to_sym
@@ -122,8 +140,10 @@ module Doing
       ##
       ## List available plugins to stdout
       ##
-      ## @param      options  { type, separator }
+      ## @param      options  [Hash] additional options
       ##
+      ## @option options :column [Boolean] display results in a single column
+      ## @option options :type [String] Plugin type: all, import, or export
       def list_plugins(options = {})
         separator = options[:column] ? "\n" : "\t"
         type = options[:type].nil? || options[:type] =~ /all/i ? 'all' : valid_type(options[:type])
@@ -144,9 +164,9 @@ module Doing
       ##
       ## Return array of available plugin names
       ##
-      ## @param      type  Plugin type (:import, :export)
+      ## @param      type  [Symbol] Plugin type (:import, :export)
       ##
-      ## @return     [Array<String>] plugin names
+      ## @return     [Array] Array of plugin names (String)
       ##
       def available_plugins(type: :export)
         type = valid_type(type)
@@ -159,7 +179,7 @@ module Doing
       ## @param      type       Plugin type (:import, :export)
       ## @param      separator  The separator to join names with
       ##
-      ## @return     [String]   Plugin names
+      ## @return     [String]   Plugin names joined with separator
       ##
       def plugin_names(type: :export, separator: '|')
         type = valid_type(type)
@@ -190,7 +210,7 @@ module Doing
       ## @param      type  [Symbol] Plugin type (:import,
       ##                   :export)
       ##
-      ## @return     [Array<String>] template names
+      ## @return     [Array] Array of template names (String)
       ##
       def plugin_templates(type: :export)
         type = valid_type(type)
@@ -236,6 +256,9 @@ module Doing
       ## @param      trigger  [String] The trigger to test
       ## @param      type     [Symbol] the plugin type
       ##                      (:import, :export)
+      ## @param      save_to  [String] if a path is
+      ##                      specified, write the template
+      ##                      to that path. Nil for STDOUT
       ##
       ## @return     [String] string content of template for trigger
       ##
@@ -255,6 +278,8 @@ module Doing
         raise Errors::InvalidArgument, "No template type matched \"#{trigger}\""
       end
 
+      private
+
       def save_template(tpl, dir, filename)
         dir = File.expand_path(dir)
         FileUtils.mkdir_p(dir) unless File.exist?(dir)

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

@@ -5,6 +5,7 @@
 # author: Brett Terpstra
 # url: https://brettterpstra.com
 module Doing
+  # @private
   class MarkdownRenderer
     attr_accessor :items, :page_title, :totals
 
@@ -15,12 +16,13 @@ module Doing
     end
 
     def get_binding
-      binding()
+      binding
     end
   end
 
+  # Markdown Export Plugin
   class MarkdownExport
-    include Doing::Util
+    include Util
 
     def self.settings
       {

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

@@ -17,7 +17,7 @@ module Doing
     end
 
     def self.render(wwid, items, variables: {})
-      # Doing.logger.benchmark(:template_render, :start)
+      Doing.logger.benchmark(:template_render, :start)
       return if items.nil?
 
       opt = variables[:options]
@@ -126,18 +126,18 @@ module Doing
 
         output.gsub!(/\\%/, '%')
 
-        output.highlight_search!(opt[:search]) if opt[:template] =~ /^temp/ && opt[:search] && !opt[:not] && opt[:hilite]
+        output.highlight_search!(opt[:search]) if opt[:output] =~ /^temp/ && opt[:search] && !opt[:not] && opt[:hilite]
 
         out += "#{output}\n"
       end
 
-      # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:template]}")
+      # Doing.logger.debug('Template Export:', "#{items.count} items output to template #{opt[:output]}")
       if opt[:totals]
         out += wwid.tag_times(format: Doing.setting('timer_format').to_sym,
                               sort_by: opt[:sort_tags],
                               sort_order: opt[:tag_order])
       end
-      # Doing.logger.benchmark(:template_render, :finish)
+      Doing.logger.benchmark(:template_render, :finish)
       out
     end
 

data/lib/doing/plugins/import/doing_import.rb

@@ -125,7 +125,7 @@ module Doing
         next if line =~ /^\s*$/
 
         case line
-        when /^(\S[\S ]+):\s*(@\S+\s*)*$/
+        when /^(\S[\S ]+):(\s+@[\w\-_.]+(?= |$))*\s*$/
           section = Regexp.last_match(1)
           current = 0
         when /^\s*- (\d{4}-\d\d-\d\d \d\d:\d\d) \| (.*)/