doing 2.1.39 → 2.1.40

data/lib/doing/items.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Doing
-  # Items Array
+  # A collection of Item objects
   class Items < Array
     attr_accessor :sections
 
@@ -27,13 +27,29 @@ module Doing
     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
+      @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
-      has_section
+
+      section
     end
 
     # Add a new section to the sections array. Accepts
@@ -131,17 +147,26 @@ module Doing
     end
 
     ##
-    ## Return Items containing items that don't exist in receiver
+    ## 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)
-      diff = Items.new
-      each do |item|
-        res = items.select { |i| i.equal?(item) }
-        diff.push(item) unless res.count.positive?
+      a = clone
+      b = items.clone
+
+      a.delete_if do |item|
+        if b.index(item)
+          b.delete(item)
+          true
+        else
+          false
+        end
       end
-      diff
+      { deleted: b, added: a }
     end
 
     ##

data/lib/doing/plugin_manager.rb

@@ -84,11 +84,11 @@ module Doing
       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 +113,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

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/util_backup.rb

@@ -62,7 +62,7 @@ module Doing
         filename ||= Doing.setting('doing_file')
 
         backup_file = last_backup(filename, count: count)
-        raise DoingRuntimeError, 'End of undo history' if backup_file.nil?
+        raise HistoryLimitError, 'End of undo history' if backup_file.nil?
 
         save_undone(filename)
         FileUtils.mv(backup_file, filename)
@@ -86,7 +86,7 @@ module Doing
         skipped = undones.slice!(0, count)
         undone = skipped.pop
 
-        raise DoingRuntimeError, 'End of redo history' if undone.nil?
+        raise HistoryLimitError, 'End of redo history' if undone.nil?
 
         redo_file = File.join(backup_dir, undone)
 
@@ -118,8 +118,7 @@ module Doing
         filename ||= Doing.setting('doing_file')
 
         undones = Dir.glob("undone*#{File.basename(filename)}", base: backup_dir).sort
-
-        raise DoingRuntimeError, 'End of redo history' if undones.empty?
+        raise HistoryLimitError, 'End of redo history' if undones.empty?
 
         total = undones.count
         options = undones.each_with_object([]) do |file, arr|
@@ -128,8 +127,7 @@ module Doing
 
           arr.push("#{d.time_ago}\t#{File.join(backup_dir, file)}")
         end
-
-        raise DoingRuntimeError, 'No backup files to load' if options.empty?
+        raise MissingBackupFile, 'No backup files to load' if options.empty?
 
         backup_file = show_menu(options, filename)
         idx = undones.index(File.basename(backup_file))
@@ -163,7 +161,7 @@ module Doing
           arr.push("#{d.time_ago}\t#{File.join(backup_dir, file)}")
         end
 
-        raise DoingRuntimeError, 'No backup files to load' if options.empty?
+        raise MissingBackupFile, 'No backup files to load' if options.empty?
 
         backup_file = show_menu(options, filename)
         Util.write_to_file(File.join(backup_dir, "undone___#{File.basename(filename)}"), IO.read(filename), backup: false)
@@ -281,7 +279,7 @@ module Doing
       def create_backup_dir
         dir = File.expand_path(Doing.setting('backup_dir')) || File.join(user_home, '.doing_backup')
         if File.exist?(dir) && !File.directory?(dir)
-          raise DoingRuntimeError, "Backup error: #{dir} is not a directory"
+          raise DoingNoTraceError.new("#{dir} is not a directory", topic: 'History:', exit_code: 27)
 
         end
 

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.1.39'
+  VERSION = '2.1.40'
 end

data/lib/doing/wwid/display.rb

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+module Doing
+  class WWID
+    # Display methods for WWID class
+    module Display
+      ##
+      ## Display contents of a section based on options
+      ##
+      ## @param      opt   [Hash] Additional Options
+      ##
+      def list_section(opt, items: Items.new)
+        logger.benchmark(:list_section, :start)
+        opt[:config_template] ||= 'default'
+
+        tpl_cfg = Doing.setting(['templates', opt[:config_template]])
+
+        cfg = if opt[:view_template]
+                Doing.setting(['views', opt[:view_template]]).deep_merge(tpl_cfg, { extend_existing_arrays: true, sort_merged_arrays: true })
+              else
+                tpl_cfg
+              end
+
+        cfg.deep_merge({
+                         'wrap_width' => Doing.setting('wrap_width') || 0,
+                         'date_format' => Doing.setting('default_date_format'),
+                         'order' => Doing.setting('order') || :asc,
+                         'tags_color' => Doing.setting('tags_color'),
+                         'duration' => Doing.setting('duration'),
+                         'interval_format' => Doing.setting('interval_format')
+                       }, { extend_existing_arrays: true, sort_merged_arrays: true })
+
+        opt[:duration] ||= cfg['duration'] || false
+        opt[:interval_format] ||= cfg['interval_format'] || 'text'
+        opt[:count] ||= 0
+        opt[:age] ||= :newest
+        opt[:age] = opt[:age].normalize_age
+        opt[:format] ||= cfg['date_format']
+        opt[:order] ||= cfg['order'] || :asc
+        opt[:tag_order] ||= :asc
+        opt[:tags_color] = cfg['tags_color'] || false if opt[:tags_color].nil?
+        opt[:template] ||= cfg['template']
+        opt[:sort_tags] ||= opt[:tag_sort]
+
+        # opt[:highlight] ||= true
+        title = ''
+        is_single = true
+        if opt[:section].nil?
+          opt[:section] = choose_section
+          title = opt[:section]
+        elsif opt[:section].instance_of?(String)
+          title = if opt[:section] =~ /^all$/i
+                    if opt[:page_title]
+                      opt[:page_title]
+                    elsif opt[:tag_filter] && opt[:tag_filter]['bool'].normalize_bool != :not
+                      opt[:tag_filter]['tags'].map { |tag| "@#{tag}" }.join(' + ')
+                    else
+                      'doing'
+                    end
+                  else
+                    guess_section(opt[:section])
+                  end
+        end
+
+        items = filter_items(items, opt: opt)
+
+        items.reverse! unless opt[:order].normalize_order == :desc
+
+        if opt[:delete]
+          delete_items(items, force: opt[:force])
+
+          write(@doing_file)
+          return
+        elsif opt[:editor]
+          edit_items(items)
+
+          write(@doing_file)
+          return
+        elsif opt[:interactive]
+          opt[:menu] = !opt[:force]
+          opt[:query] = '' # opt[:search]
+          opt[:multiple] = true
+          selected = Prompt.choose_from_items(items.reverse, include_section: opt[:section] =~ /^all$/i, **opt)
+
+          raise NoResults, 'no items selected' if selected.nil? || selected.empty?
+
+          act_on(selected, opt)
+          return
+        end
+
+        opt[:output] ||= 'template'
+        opt[:wrap_width] ||= Doing.setting('templates.default.wrap_width', 0)
+
+        logger.benchmark(:list_section, :finish)
+        output(items, title, is_single, opt)
+      end
+
+      ##
+      ## Display entries within a date range
+      ##
+      ## @param      dates    [Array] [start, end]
+      ## @param      section  [String] The section
+      ## @param      times    (Bool) Show times
+      ## @param      output   [String] Output format
+      ## @param      opt      [Hash] Additional Options
+      ##
+      def list_date(dates, section, times = nil, output = nil, opt)
+        opt ||= {}
+        opt[:totals] ||= false
+        opt[:sort_tags] ||= false
+        section = guess_section(section)
+        # :date_filter expects an array with start and end date
+        dates = dates.split_date_range if dates.instance_of?(String)
+
+        opt[:section] = section
+        opt[:count] = 0
+        opt[:order] = :asc
+        opt[:date_filter] = dates
+        opt[:times] = times
+        opt[:output] = output
+
+        time_rx = /^(\d{1,2}+(:\d{1,2}+)?( *(am|pm))?|midnight|noon)$/
+        if opt[:from] && opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
+          opt[:time_filter] = opt[:from]
+        end
+
+        list_section(opt)
+      end
+
+      ##
+      ## Show all entries from the current day
+      ##
+      ## @param      times   [Boolean] show times
+      ## @param      output  [String] output format
+      ## @param      opt     [Hash] Options
+      ##
+      def today(times = true, output = nil, opt)
+        opt ||= {}
+        opt[:totals] ||= false
+        opt[:sort_tags] ||= false
+
+        cfg = Doing.setting('templates').deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
+          'wrap_width' => Doing.setting('wrap_width') || 0,
+          'date_format' => Doing.setting('default_date_format'),
+          'order' => Doing.setting('order') || :asc,
+          'tags_color' => Doing.setting('tags_color'),
+          'duration' => Doing.setting('duration'),
+          'interval_format' => Doing.setting('interval_format')
+        }, { extend_existing_arrays: true, sort_merged_arrays: true })
+
+        template = opt[:template] || cfg['template']
+
+        opt[:duration] ||= cfg['duration'] || false
+        opt[:interval_format] ||= cfg['interval_format'] || 'text'
+
+        options = {
+          after: opt[:after],
+          before: opt[:before],
+          count: 0,
+          duration: opt[:duration],
+          from: opt[:from],
+          format: cfg['date_format'],
+          interval_format: opt[:interval_format],
+          only_timed: opt[:only_timed],
+          order: cfg['order'] || :asc,
+          output: output,
+          section: opt[:section],
+          sort_tags: opt[:sort_tags],
+          template: template,
+          times: times,
+          today: true,
+          totals: opt[:totals],
+          wrap_width: cfg['wrap_width'],
+          tags_color: cfg['tags_color'],
+          config_template: opt[:config_template]
+        }
+        list_section(options)
+      end
+
+      ##
+      ## Show entries from the previous day
+      ##
+      ## @param      section  [String] The section
+      ## @param      times    (Bool) Show times
+      ## @param      output   [String] Output format
+      ## @param      opt      [Hash] Additional Options
+      ##
+      def yesterday(section, times = nil, output = nil, opt)
+        opt ||= {}
+        opt[:totals] ||= false
+        opt[:sort_tags] ||= false
+        opt[:config_template] ||= 'today'
+        opt[:yesterday] = true
+
+        section = guess_section(section)
+        y = (Time.now - (60 * 60 * 24)).strftime('%Y-%m-%d')
+        opt[:after] = "#{y} #{opt[:after]}" if opt[:after]
+        opt[:before] = "#{y} #{opt[:before]}" if opt[:before]
+
+        opt[:output] = output
+        opt[:section] = section
+        opt[:times] = times
+        opt[:count] = 0
+
+        list_section(opt)
+      end
+
+      ##
+      ## Show recent entries
+      ##
+      ## @param      count    [Integer] The number to show
+      ## @param      section  [String] The section to show from, default Currently
+      ## @param      opt      [Hash] Additional Options
+      ##
+      def recent(count = 10, section = nil, opt)
+        opt ||= {}
+        times = opt[:t] || true
+        opt[:totals] ||= false
+        opt[:sort_tags] ||= false
+
+        cfg = Doing.setting('templates.recent').deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
+          'wrap_width' => Doing.setting('wrap_width') || 0,
+          'date_format' => Doing.setting('default_date_format'),
+          'order' => Doing.setting('order') || :asc,
+          'tags_color' => Doing.setting('tags_color'),
+          'duration' => Doing.setting('duration'),
+          'interval_format' => Doing.setting('interval_format')
+        }, { extend_existing_arrays: true, sort_merged_arrays: true })
+        opt[:duration] ||= cfg['duration'] || false
+        opt[:interval_format] ||= cfg['interval_format'] || 'text'
+
+        section ||= Doing.setting('current_section')
+        section = guess_section(section)
+
+        opt[:section] = section
+        opt[:wrap_width] = cfg['wrap_width']
+        opt[:count] = count
+        opt[:format] = cfg['date_format']
+        opt[:template] = opt[:template] || cfg['template']
+        opt[:order] = :asc
+        opt[:times] = times
+
+        list_section(opt)
+      end
+
+      ##
+      ## Show the last entry
+      ##
+      ## @param      times    (Bool) Show times
+      ## @param      section  [String] Section to pull from, default Currently
+      ##
+      def last(times: true, section: nil, options: {})
+        section = section.nil? || section =~ /all/i ? 'All' : guess_section(section)
+        cfg = Doing.setting(['templates', options[:config_template]]).deep_merge(Doing.setting('templates.default'), { extend_existing_arrays: true, sort_merged_arrays: true }).deep_merge({
+          'wrap_width' => Doing.setting('wrap_width', 0),
+          'date_format' => Doing.setting('default_date_format'),
+          'order' => Doing.setting('order', :asc),
+          'tags_color' => Doing.setting('tags_color'),
+          'duration' => Doing.setting('duration'),
+          'interval_format' => Doing.setting('interval_format')
+        }, { extend_existing_arrays: true, sort_merged_arrays: true })
+        options[:duration] ||= cfg['duration'] || false
+        options[:interval_format] ||= cfg['interval_format'] || 'text'
+
+        opts = {
+          case: options[:case],
+          config_template: options[:config_template] || 'last',
+          count: 1,
+          delete: options[:delete],
+          duration: options[:duration],
+          format: cfg['date_format'],
+          interval_format: options[:interval_format],
+          not: options[:negate],
+          output: options[:output],
+          section: section,
+          template: options[:template] || cfg['template'],
+          times: times,
+          val: options[:val],
+          wrap_width: cfg['wrap_width']
+        }
+
+        if options[:tag]
+          opts[:tag_filter] = {
+            'tags' => options[:tag],
+            'bool' => options[:tag_bool]
+          }
+        end
+
+        opts[:search] = options[:search] if options[:search]
+
+        list_section(opts)
+      end
+
+      ##
+      ## Return the content of the last note for a given section
+      ##
+      ## @param      section  [String] The section to retrieve from, default
+      ##                      All
+      ##
+      def last_note(section = 'All')
+        section = guess_section(section)
+
+        last_item = last_entry({ section: section })
+
+        raise NoEntryError, 'No entry found' unless last_item
+
+        logger.log_now(:info, 'Edit note:', last_item.title)
+
+        note = last_item.note&.to_s || ''
+        "#{last_item.title}\n# EDIT BELOW THIS LINE ------------\n#{note}"
+      end
+
+      ##
+      ## Get the last entry
+      ##
+      ## @param      opt   [Hash] Additional Options
+      ##
+      def last_entry(opt)
+        opt ||= {}
+        opt[:tag_bool] ||= :and
+        opt[:section] ||= Doing.setting('current_section')
+
+        items = filter_items(Items.new, opt: opt)
+
+        logger.debug('Filtered:', "Parameters matched #{items.count} entries")
+
+        if opt[:interactive]
+          last_entry = Prompt.choose_from_items(items, include_section: opt[:section] =~ /^all$/i,
+            menu: true,
+            header: '',
+            prompt: 'Select an entry > ',
+            multiple: false,
+            sort: false,
+            show_if_single: true
+           )
+        else
+          last_entry = items.max_by { |item| item.date }
+        end
+
+        last_entry
+      end
+
+      private
+
+      ##
+      ## Generate output using available export plugins
+      ##
+      ## @param      items      [Array] The items
+      ## @param      title      [String] Page title
+      ## @param      is_single  [Boolean] Indicates if single
+      ##                        section
+      ## @param      opt        [Hash] Additional options
+      ##
+      ## @return     [String] formatted output based on opt[:output]
+      ##             template trigger
+      ## @api private
+      def output(items, title, is_single, opt)
+        logger.benchmark(:output, :start)
+        opt ||= {}
+        out = nil
+
+        raise InvalidArgument, 'Unknown output format' unless opt[:output] =~ Plugins.plugin_regex(type: :export)
+
+        export_options = { page_title: title, is_single: is_single, options: opt }
+
+        Hooks.trigger :pre_export, self, opt[:output], items
+
+        Plugins.plugins[:export].each do |_, options|
+          next unless opt[:output] =~ /^(#{options[:trigger].normalize_trigger})$/i
+
+          out = options[:class].render(self, items, variables: export_options)
+          break
+        end
+
+        logger.debug('Output:', "#{items.count} #{items.count == 1 ? 'item' : 'items'} shown")
+        logger.benchmark(:output, :finish)
+        out
+      end
+
+      ##
+      ## Get next item in the index
+      ##
+      ## @param      item     [Item] target item
+      ## @param      options  [Hash] additional options
+      ## @see #filter_items
+      ##
+      ## @return     [Item] the next chronological item in the index
+      ##
+      def next_item(item, options = {})
+        options ||= {}
+        items = filter_items(Items.new, opt: options)
+
+        idx = items.index(item)
+
+        idx.positive? ? items[idx - 1] : nil
+      end
+    end
+  end
+end