doing 2.1.89 → 2.1.90

data/lib/doing/util_backup.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'zlib'
 
 module Doing
@@ -17,7 +18,7 @@ module Doing
         backups = get_backups(filename)
         return unless backups.count > limit
 
-        backups[limit..-1].each do |file|
+        backups[limit..].each do |file|
           FileUtils.rm(File.join(backup_dir, file))
         end
 
@@ -45,18 +46,18 @@ module Doing
       ##                       different from default
       ##
       def restore_last_backup(filename = nil, count: 1)
-        Doing.logger.benchmark(:restore_backup, :start)
-        filename ||= Doing.setting('doing_file')
+        Doing.logger.measure(:restore_backup) do
+          filename ||= Doing.setting('doing_file')
 
-        backup_file = last_backup(filename, count: count)
-        raise HistoryLimitError, 'End of undo history' if backup_file.nil?
+          backup_file = last_backup(filename, count: count)
+          raise HistoryLimitError, 'End of undo history' if backup_file.nil?
 
-        save_undone(filename)
-        move_backup(backup_file, filename)
+          save_undone(filename)
+          move_backup(backup_file, filename)
 
-        prune_backups_after(File.basename(backup_file))
-        Doing.logger.warn('File update:', "restored from #{backup_file}")
-        Doing.logger.benchmark(:restore_backup, :finish)
+          prune_backups_after(File.basename(backup_file))
+          Doing.logger.warn('File update:', "restored from #{backup_file}")
+        end
       end
 
       ##
@@ -138,13 +139,15 @@ module Doing
         options = get_backups(filename).each_with_object([]) do |file, arr|
           d, _base = date_of_backup(file)
           next if d.nil?
+
           arr.push("#{d.time_ago}\t#{File.join(backup_dir, file)}")
         end
 
         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)
+        Util.write_to_file(File.join(backup_dir, "undone___#{File.basename(filename)}"), IO.read(filename),
+                           backup: false)
         move_backup(backup_file, filename)
         prune_backups_after(File.basename(backup_file))
         Doing.logger.warn('File update:', "restored from #{backup_file}")
@@ -157,25 +160,25 @@ module Doing
       ## @param      filename  [String] The filename
       ##
       def write_backup(filename = nil)
-        Doing.logger.benchmark(:_write_backup, :start)
-        filename ||= Doing.setting('doing_file')
+        Doing.logger.measure(:_write_backup) do
+          filename ||= Doing.setting('doing_file')
 
-        unless File.exist?(filename)
-          Doing.logger.debug('Backup:', "original file doesn't exist (#{filename})")
-          return
-        end
+          unless File.exist?(filename)
+            Doing.logger.debug('Backup:', "original file doesn't exist (#{filename})")
+            return
+          end
 
-        backup_file = File.join(backup_dir, "#{timestamp_filename}___#{File.basename(filename)}")
-        # compressed = Zlib::Deflate.deflate(content)
-        # Zlib::GzipWriter.open(backup_file + '.gz') do |gz|
-        #   gz.write(IO.read(filename))
-        # end
+          backup_file = File.join(backup_dir, "#{timestamp_filename}___#{File.basename(filename)}")
+          # compressed = Zlib::Deflate.deflate(content)
+          # Zlib::GzipWriter.open(backup_file + '.gz') do |gz|
+          #   gz.write(IO.read(filename))
+          # end
 
-        FileUtils.cp(filename, backup_file)
+          FileUtils.cp(filename, backup_file)
 
-        prune_backups(filename, Doing.setting('history_size').to_i)
-        clear_undone(filename)
-        Doing.logger.benchmark(:_write_backup, :finish)
+          prune_backups(filename, Doing.setting('history_size').to_i)
+          clear_undone(filename)
+        end
       end
 
       private

data/lib/doing/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Doing
-  VERSION = '2.1.89'
+  VERSION = '2.1.90'
 end

data/lib/doing/wwid/display.rb

@@ -8,91 +8,108 @@ module Doing
     ## @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 })
+      logger.measure(:list_section) do
+        cfg = nil
+        logger.measure(:list_section_config) do
+          opt[:config_template] ||= 'default'
 
-      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].is_a?(Array)
-        title = opt[:section].join(', ')
-      elsif opt[:section].is_a?(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
+          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
-                  guess_section(opt[:section])
+                  tpl_cfg
                 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
+          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 })
+        end
+
+        logger.measure(:list_section_options) do
+          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]
+        end
+
+        title = ''
+        is_single = true
+        logger.measure(:list_section_title) do
+          # opt[:highlight] ||= true
+          if opt[:section].nil?
+            opt[:section] = choose_section
+            title = opt[:section]
+          elsif opt[:section].is_a?(Array)
+            title = opt[:section].join(', ')
+          elsif opt[:section].is_a?(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
+        end
+
+        logger.measure(:list_section_filter) do
+          items = filter_items(items, opt: opt)
+        end
+
+        logger.measure(:list_section_sort) do
+          items.reverse! unless opt[:order].normalize_order == :desc
+        end
+
+        logger.measure(:list_section_actions) do
+          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
+        end
+
+        logger.measure(:list_section_output) do
+          opt[:output] ||= 'template'
+          opt[:wrap_width] ||= Doing.setting('templates.default.wrap_width', 0)
+
+          output(items, title, is_single, opt)
+        end
       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
 
     ##
@@ -120,9 +137,7 @@ module Doing
       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
+      opt[:time_filter] = opt[:from] if opt[:from] && opt[:from][0].is_a?(String) && opt[:from][0] =~ time_rx
 
       list_section(opt)
     end
@@ -220,33 +235,40 @@ module Doing
     ## @param      opt      [Hash] Additional Options
     ##
     def recent(count = 10, section = nil, opt)
-      opt ||= {}
-      opt[:times] ||= false
-      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
-
-      list_section(opt)
+      logger.measure(:recent_method) do
+        opt ||= {}
+        opt[:times] ||= false
+        opt[:totals] ||= false
+        opt[:sort_tags] ||= false
+
+        cfg = nil
+        logger.measure(:recent_config_merge) do
+          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'
+        end
+
+        logger.measure(:recent_section_setup) do
+          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
+        end
+
+        list_section(opt)
+      end
     end
 
     ##
@@ -259,13 +281,17 @@ module Doing
       section = section[0] if section.is_a?(Array) && section.count == 1
       section = section.nil? ? '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 })
+                                                                                                                                                                                            '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'
 
@@ -313,7 +339,7 @@ module Doing
 
       logger.log_now(:info, 'Edit note:', last_item.title)
 
-      note = last_item.note&.to_s || ''
+      note = last_item.note.to_s
       "#{last_item.title}\n# EDIT BELOW THIS LINE ------------\n#{note}"
     end
 
@@ -332,19 +358,16 @@ module Doing
       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
-         )
+        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 }
+        items.max_by(&:date)
       end
-
-      last_entry
     end
 
     private
@@ -362,29 +385,37 @@ module Doing
     ##             template trigger
     ## @api private
     def output(items, title, is_single, opt)
-      logger.benchmark(:output, :start)
-      opt ||= {}
-      out = nil
-
-      unless opt[:output] =~ Plugins.plugin_regex(type: :export)
-        raise InvalidPlugin.new('Unknown output format', opt[:output])
-
+      logger.measure(:output) do
+        opt ||= {}
+        out = nil
+
+        logger.measure(:output_validation) do
+          unless opt[:output] =~ Plugins.plugin_regex(type: :export)
+            raise InvalidPlugin.new('Unknown output format', opt[:output])
+          end
+        end
+
+        export_options = nil
+        logger.measure(:output_setup) do
+          export_options = { page_title: title, is_single: is_single, options: opt }
+        end
+
+        logger.measure(:output_hooks) do
+          Hooks.trigger :pre_export, self, opt[:output], items
+        end
+
+        logger.measure(:output_render) do
+          Plugins.plugins[:export].each_value do |options|
+            next unless opt[:output] =~ /^(#{options[:trigger].normalize_trigger})$/i
+
+            out = options[:class].render(self, items, variables: export_options)
+            break
+          end
+        end
+
+        logger.debug('Output:', "#{items.count} #{items.count == 1 ? 'item' : 'items'} shown")
+        out
       end
-
-      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
 
     ##

data/lib/doing/wwid/editor.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'English'
 module Doing
   class WWID
     ##
@@ -37,7 +38,7 @@ module Doing
       Process.wait(pid)
 
       begin
-        if $?.exitstatus == 0
+        if $CHILD_STATUS.exitstatus.zero?
           input = IO.read(tmpfile.path)
         else
           exit_now! 'Cancelled'
@@ -84,7 +85,7 @@ module Doing
       end
 
       note = Note.new
-      note.add(input_lines[1..-1]) if input_lines.length > 1
+      note.add(input_lines[1..]) if input_lines.length > 1
       # If title line ends in a parenthetical, use that as the note
       if note.empty? && title =~ /\s+\(.*?\)$/
         title.sub!(/\s+\((?<note>.*?)\)$/) do
@@ -123,24 +124,24 @@ module Doing
     end
 
     def edit_items(items)
-      items.sort_by! { |i| i.date }
+      items.sort_by!(&:date)
       editable_items = []
 
       items.each do |i|
         editable = "#{i.date.strftime('%F %R')} | #{i.title}"
-        old_note = i.note ? i.note.strip_lines.join("\n") : nil
+        old_note = i.note&.strip_lines&.join("\n")
         editable += "\n#{old_note}" unless old_note.nil?
         editable_items << editable
       end
-      divider = "-----------"
-      notice =<<~EONOTICE
+      divider = '-----------'
+      notice = <<~EONOTICE
 
-      # - You may delete entries, but leave all divider lines (---) in place.
-      # - Start and @done dates replaced with a time string (yesterday 3pm) will
-      #   be parsed automatically. Do not delete the pipe (|) between start date
-      #   and entry title.
+        # - You may delete entries, but leave all divider lines (---) in place.
+        # - Start and @done dates replaced with a time string (yesterday 3pm) will
+        #   be parsed automatically. Do not delete the pipe (|) between start date
+        #   and entry title.
       EONOTICE
-      input =  "#{editable_items.map(&:strip).join("\n#{divider}\n")}\n"
+      input = "#{editable_items.map(&:strip).join("\n#{divider}\n")}\n"
 
       new_items = fork_editor(input, message: notice).split(/^#{divider}/).map(&:strip)
 
@@ -162,7 +163,7 @@ module Doing
           item.date = date || items[i].date
           item.title = title
           item.note = note
-          if (item.equal?(old_item))
+          if item.equal?(old_item)
             Doing.logger.count(:skipped, level: :debug)
           else
             Doing.logger.count(:updated)

data/lib/doing/wwid/filetools.rb

@@ -8,7 +8,7 @@ module Doing
     ## @param      path  [String] Override path to a doing file, optional
     ##
     def init_doing_file(path = nil)
-      @doing_file =  File.expand_path(Doing.setting('doing_file'))
+      @doing_file = File.expand_path(Doing.setting('doing_file'))
 
       if path.nil?
         create(@doing_file) unless File.exist?(@doing_file)
@@ -107,7 +107,7 @@ module Doing
       keep = opt[:keep] || 0
       tags = []
       tags.concat(opt[:tag].split(/ *, */).map { |t| t.sub(/^@/, '').strip }) if opt[:tag]
-      bool  = opt[:bool] || :and
+      bool = opt[:bool] || :and
 
       sect = opt[:section] !~ /^all$/i ? guess_section(opt[:section]) : 'all'
 
@@ -121,27 +121,29 @@ module Doing
 
       section_items.each do |item|
         break if counter >= max
+
         if opt[:before]
           time_string = opt[:before]
           cutoff = time_string.chronify(guess: :begin)
         end
 
-        unless ((!tags.empty? && !item.tags?(tags, bool)) || (opt[:search] && !item.search(opt[:search].to_s)) || (opt[:before] && item.date >= cutoff))
-          new_item = @content.delete(item)
-          Hooks.trigger :post_entry_removed, self, item.clone
-          raise DoingRuntimeError, "Error deleting item: #{item}" if new_item.nil?
+        next if (!tags.empty? && !item.tags?(tags,
+                                             bool)) || (opt[:search] && !item.search(opt[:search].to_s)) || (opt[:before] && item.date >= cutoff)
 
-          new_content.add_section(new_item.section, log: false)
-          new_content.push(new_item)
-          counter += 1
-        end
+        new_item = @content.delete(item)
+        Hooks.trigger :post_entry_removed, self, item.clone
+        raise DoingRuntimeError, "Error deleting item: #{item}" if new_item.nil?
+
+        new_content.add_section(new_item.section, log: false)
+        new_content.push(new_item)
+        counter += 1
       end
 
       if counter.positive?
         logger.count(:rotated,
                      level: :info,
                      count: counter,
-                     message: "Rotated %count %items")
+                     message: 'Rotated %count %items')
       else
         logger.info('Skipped:', 'No items were rotated')
       end