doing 2.0.25 → 2.1.0pre

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,6 +80,22 @@ 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[:log_level]
         self.log_level = options[:log_level].to_sym
@@ -229,7 +254,6 @@ module Doing
     ##
     def output_results
       total_counters
-
       results = @results.select { |msg| write_message?(msg[:level]) }.uniq
 
       if @logdev == $stdout
@@ -241,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

data/lib/doing/note.rb

@@ -5,12 +5,27 @@ module Doing
   ## This class describes an item note.
   ##
   class Note < Array
+
+    ##
+    ## Initializes a new note
+    ##
+    ## @param      note  [Array] Initial note, can be string
+    ##                   or array
+    ##
     def initialize(note = [])
       super()
 
       add(note) if note
     end
 
+    ##
+    ## Add note contents, optionally replacing existing note
+    ##
+    ## @param      note     [Array] The note to add, can be
+    ##                      string or array (Note)
+    ## @param      replace  [Boolean] replace existing
+    ##                      content
+    ##
     def add(note, replace: false)
       clear if replace
       if note.is_a?(String)
@@ -20,11 +35,22 @@ module Doing
       end
     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
@@ -34,6 +60,11 @@ module Doing
       replace compress
     end
 
+    ##
+    ## Remove blank lines and comment lines (#)
+    ##
+    ## @return     [Array] compressed array
+    ##
     def compress
       delete_if { |l| l =~ /^\s*$/ || l =~ /^#/ }
     end
@@ -42,14 +73,35 @@ module Doing
       replace strip_lines
     end
 
+    ##
+    ## Remove leading/trailing whitespace for
+    ##             every line of note
+    ##
+    ## @return     [Array] Stripped note
+    ##
     def strip_lines
       map(&:strip)
     end
 
+    ##
+    ## Note as multi-line string
     def to_s
-      compress.strip_lines.join("\n")
+      compress.strip_lines.map { |l| "\t\t#{l}" }.join("\n")
+    end
+
+    # @private
+    def inspect
+      "<Doing::Note - characters:#{compress.strip_lines.join(' ').length} lines:#{count}>"
     end
 
+    ##
+    ## Test if a note is equal (compare string
+    ##             representations)
+    ##
+    ## @param      other  [Note] The other Note
+    ##
+    ## @return     [Boolean] true if equal
+    ##
     def equal?(other)
       return false unless other.is_a?(Note)
 

data/lib/doing/pager.rb

@@ -1,23 +1,36 @@
 # frozen_string_literal: true
+require 'pathname'
 
 module Doing
   # Pagination
   module Pager
     class << self
+      # Boolean determines whether output is paginated
       def paginate
         @paginate ||= false
       end
 
+      # Enable/disable pagination
+      #
+      # @param      should_paginate  [Boolean] true to paginate
       def paginate=(should_paginate)
         @paginate = should_paginate
       end
 
+      # Page output. If @paginate is false, just dump to
+      # STDOUT
+      #
+      # @param      text  [String] text to paginate
+      #
       def page(text)
         unless @paginate
           puts text
           return
         end
 
+        pager = which_pager
+        Doing.logger.debug('Pager:', "Using #{pager}")
+
         read_io, write_io = IO.pipe
 
         input = $stdin
@@ -30,10 +43,8 @@ module Doing
           # Wait until we have input before we start the pager
           IO.select [input]
 
-          pager = which_pager
-          Doing.logger.debug('Pager:', "Using #{pager}")
           begin
-            exec(pager.join(' '))
+            exec(pager)
           rescue SystemCallError => e
             raise Errors::DoingStandardError, "Pager error, #{e}"
           end
@@ -51,44 +62,44 @@ module Doing
         status.success?
       end
 
-      def which_pager
-        pagers = [ENV['GIT_PAGER'], ENV['PAGER']]
-
-        if Util.exec_available('git')
-          git_pager = `git config --get-all core.pager || true`.split.first
-          git_pager && pagers.push(git_pager)
-        end
-
-        pagers.concat(%w[bat less more pager])
-
-        pagers.select! do |f|
-          if f
-            if f.strip =~ /[ |]/
-              f
-            elsif f == 'most'
-              Doing.logger.warn('most not allowed as pager')
-              false
-            else
-              system "which #{f}", out: File::NULL, err: File::NULL
-            end
-          else
-            false
+      private
+
+      def command_exist?(command)
+        exts = ENV.fetch("PATHEXT", "").split(::File::PATH_SEPARATOR)
+        if Pathname.new(command).absolute?
+          ::File.exist?(command) ||
+            exts.any? { |ext| ::File.exist?("#{command}#{ext}")}
+        else
+          ENV.fetch("PATH", "").split(::File::PATH_SEPARATOR).any? do |dir|
+            file = ::File.join(dir, command)
+            ::File.exist?(file) ||
+              exts.any? { |ext| ::File.exist?("#{file}#{ext}") }
           end
         end
+      end
+
+      def git_pager
+        command_exist?("git") ? `git config --get-all core.pager` : nil
+      end
 
-        pg = pagers.first
-        args = case pg
-               when /^more$/
-                 ' -r'
-               when /^less$/
-                 ' -Xr'
-               when /^bat$/
-                 ' -p --pager="less -Xr"'
-               else
-                 ''
-               end
-
-        [pg, args]
+      def pagers
+        [ENV['GIT_PAGER'], ENV['PAGER'], git_pager,
+         'bat -p --pager="less -Xr"', 'less -Xr', 'more -r'].compact
+      end
+
+      def find_executable(*commands)
+        execs = commands.empty? ? pagers : commands
+        execs
+          .compact.map(&:strip).reject(&:empty?).uniq
+          .find { |cmd| command_exist?(cmd.split.first) }
+      end
+
+      def exec_available?(*commands)
+        !find_executable(*commands).nil?
+      end
+
+      def which_pager
+        @which_pager ||= find_executable(*pagers)
       end
     end
   end

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

@@ -41,11 +41,11 @@ module Doing
       all_items = []
       items.each do |i|
         if String.method_defined? :force_encoding
-          title = i.title.force_encoding('utf-8').link_urls({format: :markdown})
-          note = i.note.map { |line| line.force_encoding('utf-8').strip.link_urls({format: :markdown}) } if i.note
+          title = i.title.force_encoding('utf-8').link_urls(format: :markdown)
+          note = i.note.map { |line| line.force_encoding('utf-8').strip.link_urls(format: :markdown) } if i.note
         else
-          title = i.title.link_urls({format: :markdown})
-          note = i.note.map { |line| line.strip.link_urls({format: :markdown}) } if i.note
+          title = i.title.link_urls(format: :markdown)
+          note = i.note.map { |line| line.strip.link_urls(format: :markdown) } if i.note
         end
 
         title = "#{title} @project(#{i.section})" unless variables[:is_single]

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

@@ -23,10 +23,10 @@ module Doing
       out = ''
       items.each do |item|
         if opt[:highlight] && item.title =~ /@#{wwid.config['marker_tag']}\b/i
-          flag = Doing::Color.send(wwid.config['marker_color'])
+          # flag = Doing::Color.send(wwid.config['marker_color'])
           reset = Doing::Color.default
         else
-          flag = ''
+          # flag = ''
           reset = ''
         end
 

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

@@ -27,7 +27,7 @@ module Doing
       options[:no_overlap] ||= false
       options[:autotag] ||= wwid.auto_tag
 
-      wwid.add_section(section) unless wwid.content.key?(section)
+      wwid.content.add_section(section) unless wwid.content.section?(section)
 
       tags = options[:tag] ? options[:tag].split(/[ ,]+/).map { |t| t.sub(/^@?/, '') } : []
       prefix = options[:prefix] || '[Calendar.app]'
@@ -59,7 +59,7 @@ module Doing
         title += " @done(#{end_time.strftime('%Y-%m-%d %H:%M')})"
         title.gsub!(/ +/, ' ')
         title.strip!
-        new_entry = { 'title' => title, 'date' => start_time, 'section' => section }
+        new_entry = Item.new(start_time, title, section)
         new_entry.note = entry['notes'].split(/\n/).map(&:chomp) if entry.key?('notes')
         new_items.push(new_entry)
       end
@@ -69,11 +69,11 @@ module Doing
       filtered = total - new_items.count
       Doing.logger.debug('Skipped:' , %(#{filtered} items that didn't match filter criteria)) if filtered.positive?
 
-      new_items = wwid.dedup(new_items, options[:no_overlap])
+      new_items = wwid.dedup(new_items, no_overlap: options[:no_overlap])
       dups = filtered - new_items.count
       Doing.logger.info(%(Skipped #{dups} items with overlapping times)) if dups.positive?
 
-      wwid.content[section][:items].concat(new_items)
+      wwid.content.concat(new_items)
       Doing.logger.info(%(Imported #{new_items.count} items to #{section}))
     end