doing 2.1.25 → 2.1.29

data/lib/doing/changelog/changes.rb

@@ -4,27 +4,54 @@ module Doing
   # A collection of Changes
   class Changes
     attr_reader :changes
+    attr_writer :changes_only
 
-    def initialize(lookup: nil, search: nil)
+    def initialize(lookup: nil, search: nil, changes: false, sort: :desc)
+      @changes_only = changes
       changelog = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'CHANGELOG.md'))
       raise 'Error locating changelog' unless File.exist?(changelog)
 
       @content = IO.read(changelog)
       parse_changes(lookup, search)
+
+      @changes.reverse! if sort == :asc
     end
 
     def latest
-      @changes[0].to_s.force_encoding('utf-8')
+      if @changes_only
+        @changes[0].changes_only.force_encoding('utf-8')
+      else
+        @changes[0].to_s.force_encoding('utf-8')
+      end
+    end
+
+    def versions
+      @changes.select { |change| change.entries&.count > 0 }.map { |change| change.version }
+    end
+
+    def interactive
+      Doing::Prompt.choose_from(versions,
+                                prompt: 'Select a version to see its changelog',
+                                sorted: false,
+                                fzf_args: [
+                                  %(--preview='doing changes --render -l {1}'),
+                                  '--disabled',
+                                  '--preview-window="right,70%"'
+                                ])
     end
 
     def to_s
-      @changes.map(&:to_s).join("\n\n").force_encoding('utf-8')
+      if @changes_only
+        @changes.map(&:changes_only).join().force_encoding('utf-8')
+      else
+        @changes.map(&:to_s).join("\n\n").force_encoding('utf-8')
+      end
     end
 
     private
 
     def parse_changes(lookup, search)
-      change_rx = /(?<=\n|\A)### (\d+\.\d+\.\d+(?:\w*))(.*)(?=\n### |\Z)/m
+      change_rx = /(?<=\n|\A)### (\d+\.\d+\.\d+(?:\w*))(.*?)(?=\n### |\Z)/m
       @changes = @content.scan(change_rx).each_with_object([]) do |m, a|
         next if m[0].nil? || m[1].nil?
 

data/lib/doing/chronify/chronify.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'array'
+require_relative 'numeric'
+require_relative 'string'

data/lib/doing/colors.rb

@@ -6,61 +6,67 @@ module Doing
   module Color
     # :stopdoc:
     ATTRIBUTES = [
-      [:clear,   0],     # String#clear is already used to empty string in Ruby 1.9
-      [:reset,   0],     # synonym for :clear
-      [:bold,   1],
-      [:dark,   2],
-      [:italic, 3], # not widely implemented
-      [:underline, 4],
-      [:underscore, 4], # synonym for :underline
-      [:blink, 5],
-      [:rapid_blink, 6], # not widely implemented
-      [:negative, 7], # no reverse because of String#reverse
-      [:concealed, 8],
-      [:strikethrough, 9], # not widely implemented
-      [:black, 30],
-      [:red, 31],
-      [:green, 32],
-      [:yellow, 33],
-      [:blue, 34],
-      [:magenta, 35],
-      [:purple, 35],
-      [:cyan, 36],
-      [:white, 37],
-      [:bgblack, 40],
-      [:bgred, 41],
-      [:bggreen, 42],
-      [:bgyellow, 43],
-      [:bgblue, 44],
-      [:bgmagenta, 45],
-      [:bgpurple, 45],
-      [:bgcyan, 46],
-      [:bgwhite, 47],
-      [:boldblack, 90], # High intensity, aixterm (works in OS X)
-      [:boldred, 91],
-      [:boldgreen, 92],
-      [:boldyellow, 93],
-      [:boldblue, 94],
-      [:boldmagenta, 95],
-      [:boldpurple, 95],
-      [:boldcyan, 96],
-      [:boldwhite, 97],
-      [:boldbgblack, 100], # High intensity background, aixterm (works in OS X)
-      [:boldbgred, 101],
-      [:boldbggreen, 102],
-      [:boldbgyellow, 103],
-      [:boldbgblue, 104],
-      [:boldbgmagenta, 105],
-      [:boldbgpurple, 105],
-      [:boldbgcyan, 106],
-      [:boldbgwhite, 107],
-      [:softpurple, '0;35;40'],
-      [:hotpants, '7;34;40'],
+      [:clear,               0], # String#clear is already used to empty string in Ruby 1.9
+      [:reset,               0], # synonym for :clear
+      [:bold,                1],
+      [:dark,                2],
+      [:italic,              3], # not widely implemented
+      [:underline,           4],
+      [:underscore,          4], # synonym for :underline
+      [:blink,               5],
+      [:rapid_blink,         6], # not widely implemented
+      [:negative,            7], # no reverse because of String#reverse
+      [:concealed,           8],
+      [:strikethrough,       9], # not widely implemented
+      [:strike,              9], # not widely implemented
+      [:black,              30],
+      [:red,                31],
+      [:green,              32],
+      [:yellow,             33],
+      [:blue,               34],
+      [:magenta,            35],
+      [:purple,             35],
+      [:cyan,               36],
+      [:white,              37],
+      [:bgblack,            40],
+      [:bgred,              41],
+      [:bggreen,            42],
+      [:bgyellow,           43],
+      [:bgblue,             44],
+      [:bgmagenta,          45],
+      [:bgpurple,           45],
+      [:bgcyan,             46],
+      [:bgwhite,            47],
+      [:boldblack,          90],
+      [:boldred,            91],
+      [:boldgreen,          92],
+      [:boldyellow,         93],
+      [:boldblue,           94],
+      [:boldmagenta,        95],
+      [:boldpurple,         95],
+      [:boldcyan,           96],
+      [:boldwhite,          97],
+      [:boldbgblack,       100],
+      [:boldbgred,         101],
+      [:boldbggreen,       102],
+      [:boldbgyellow,      103],
+      [:boldbgblue,        104],
+      [:boldbgmagenta,     105],
+      [:boldbgpurple,      105],
+      [:boldbgcyan,        106],
+      [:boldbgwhite,       107],
+      [:softpurple,  '0;35;40'],
+      [:hotpants,    '7;34;40'],
       [:knightrider, '7;30;40'],
-      [:flamingo, '7;31;47'],
-      [:yeller, '1;37;43'],
-      [:whiteboard, '1;30;47'],
-      [:default, '0;39']
+      [:flamingo,    '7;31;47'],
+      [:yeller,      '1;37;43'],
+      [:whiteboard,  '1;30;47'],
+      [:chalkboard,  '1;37;40'],
+      [:led,         '0;32;40'],
+      [:redacted,    '0;30;40'],
+      [:alert,       '1;31;43'],
+      [:error,       '1;37;41'],
+      [:default,        '0;39']
     ].map(&:freeze).freeze
 
     ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
@@ -78,6 +84,40 @@ module Doing
       end
     end
 
+    # Template coloring
+    class ::String
+      ##
+      ## Extract the longest valid %color name from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ##
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        normalize_color.split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym)
+        end
+
+        valid_color
+      end
+
+      ##
+      ## Normalize a color name, removing underscores,
+      ## replacing "bright" with "bold", and converting
+      ## bgbold to boldbg
+      ##
+      ## @return     [String] Normalized color name
+      ##
+      def normalize_color
+        gsub(/_/, '').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+      end
+    end
+
     class << self
       # Returns true, if the coloring function of this module
       # is switched on, false otherwise.
@@ -113,6 +153,27 @@ module Doing
           result
         end
       EOT
+
+      # Accept brightwhite in addition to boldwhite
+      if c =~ /bold/
+        eval <<-EOT
+          def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
+            result = ''
+            result << "\e[#{v}m" if Doing::Color.coloring?
+            if block_given?
+              result << yield
+            elsif string.respond_to?(:to_str)
+              result << string.to_str
+            elsif respond_to?(:to_str)
+              result << to_str
+            else
+              return result #only switch on
+            end
+            result << "\e[0m" if Doing::Color.coloring?
+            result
+          end
+        EOT
+      end
     end
 
     # Regular expression that is used to scan for ANSI-sequences while

data/lib/doing/configuration.rb

@@ -29,6 +29,7 @@ module Doing
         'plugin_path' => File.join(Util.user_home, '.config', 'doing', 'plugins'),
         'command_path' => File.join(Util.user_home, '.config', 'doing', 'commands')
       },
+      'disabled_commands' => [],
       'doing_file' => '~/.local/share/doing/what_was_i_doing.md',
       'doing_file_sort' => 'desc',
       'backup_dir' => '~/.local/share/doing/doing_backup',
@@ -178,6 +179,10 @@ module Doing
       end
     end
 
+    def fetch(*path, default)
+      @settings.dig(*path) || default
+    end
+
     ##
     ## Resolve a fuzzy-matched key path
     ##

data/lib/doing/good.rb

@@ -48,6 +48,10 @@ module Doing
     def good?
       false
     end
+
+    def normalize_tag_sort
+      :time
+    end
   end
 
   class ::TrueClass
@@ -60,5 +64,9 @@ module Doing
     def good?
       true
     end
+
+    def normalize_tag_sort
+      :name
+    end
   end
 end

data/lib/doing/help_monkey_patch.rb

@@ -4,15 +4,15 @@ module GLI
   module Commands
     # Help Command Monkeypatch for paginated output
     class Help < Command
-      def show_help(global_options,options,arguments,out,error)
+      def show_help(global_options, options, arguments, out, error)
         Doing::Pager.paginate = true
 
-        command_finder = HelpModules::CommandFinder.new(@app,arguments,error)
+        command_finder = HelpModules::CommandFinder.new(@app, arguments, error)
         if options[:c]
-          help_output = HelpModules::HelpCompletionFormat.new(@app,command_finder,arguments).format
+          help_output = HelpModules::HelpCompletionFormat.new(@app, command_finder, arguments).format
           out.puts help_output unless help_output.nil?
         elsif arguments.empty? || options[:c]
-          Doing::Pager.page HelpModules::GlobalHelpFormat.new(@app,@sorter,@text_wrapping_class).format
+          Doing::Pager.page HelpModules::GlobalHelpFormat.new(@app, @sorter, @text_wrapping_class).format
         else
           name = arguments.shift
           command = command_finder.find_command(name)
@@ -22,7 +22,8 @@ module GLI
               @app,
               @sorter,
               @synopsis_formatter_class,
-              @text_wrapping_class).format
+              @text_wrapping_class
+            ).format
           end
         end
       end

data/lib/doing/item.rb

@@ -177,7 +177,7 @@ module Doing
       tags.each do |tag|
         bool = remove ? :and : :not
         if tags?(tag, bool)
-          @title.tag!(tag, **options).strip!
+          @title = @title.tag(tag, **options).strip
           remove ? removed.push(tag) : added.push(tag)
         end
       end
@@ -278,7 +278,7 @@ module Doing
       case_type ||= prefs.fetch('case', 'smart').normalize_case
       new_note = Note.new
 
-      if search.is_rx? || matching == :fuzzy
+      if search.rx? || matching == :fuzzy
         rx = search.to_rx(distance: distance, case_type: case_type)
         new_title = @title.gsub(rx) { |m| yellow(m) }
         new_note.add(@note.to_s.gsub(rx) { |m| yellow(m) })
@@ -316,7 +316,7 @@ module Doing
       distance ||= prefs.fetch('distance', 3).to_i
       case_type ||= prefs.fetch('case', 'smart').normalize_case
 
-      if search.is_rx? || matching == :fuzzy
+      if search.rx? || matching == :fuzzy
         matches = @title + @note.to_s =~ search.to_rx(distance: distance, case_type: case_type)
       else
         query = search.strip.to_phrase_query
@@ -335,7 +335,7 @@ module Doing
       #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
       # end
 
-      # if search.is_rx? || !fuzzy
+      # if search.rx? || !fuzzy
       #   matches = text =~ search.to_rx(distance: distance, case_type: case_type)
       # else
       #   distance = 0.25 if distance > 1
@@ -393,7 +393,7 @@ module Doing
 
       Doing.logger.count(@section == 'Archive' ? :archived : :moved) if log
       Doing.logger.debug("#{@section == 'Archive' ? 'Archived' : 'Moved'}:",
-                         "#{@title.truncate(60)} from #{from} to #{@section}")
+                         "#{@title.trunc(60)} from #{from} to #{@section}")
       self
     end
 

data/lib/doing/items.rb

@@ -102,7 +102,7 @@ module Doing
 
       self[s_idx] = new_item
       Doing.logger.count(:updated)
-      Doing.logger.info('Entry updated:', self[s_idx].title.truncate(60))
+      Doing.logger.info('Entry updated:', self[s_idx].title.trunc(60))
       new_item
     end
 
@@ -132,7 +132,7 @@ module Doing
       @sections.each do |section|
         out.push(section.original)
         items = in_section(section.title).sort_by { |i| i.date }
-        items.reverse! if Doing.config.settings['doing_file_sort'].normalize_order == 'desc'
+        items.reverse! if Doing.config.settings['doing_file_sort'].normalize_order == :desc
         items.each { |item| out.push(item.to_s)}
       end
 

data/lib/doing/log_adapter.rb

@@ -277,17 +277,50 @@ module Doing
 
     def log_benchmarks
       if ENV['DOING_BENCHMARK']
+
         output = []
-        @benchmarks.each do |k, timers|
+        beginning = @benchmarks[:total][:start]
+        ending = @benchmarks[:total][:finish]
+        total = ending - beginning
+        factor = TTY::Screen.columns / total
+
+        cols = Array.new(TTY::Screen.columns)
+
+        colors = %w[bgred bggreen bgyellow bgblue bgmagenta bgcyan bgwhite boldbgred boldbggreen boldbgyellow boldbgblue boldbgwhite]
+        idx = 0
+        # @benchmarks.delete(:total)
+
+        @benchmarks.sort_by { |_, timers| [timers[:start], timers[:finish]] }.each do |k, timers|
           if timers[:finish] && timers[:start]
-            output << "#{k}: #{timers[:finish] - timers[:start]}"
+            color = colors[idx % colors.count]
+            fg = if idx < 7
+                   Color.boldblack
+                 else
+                   Color.boldwhite
+                 end
+            color = Color.send(color) + fg
+
+            start = ((timers[:start] - beginning) * factor).floor
+            finish = ((timers[:finish] - beginning) * factor).ceil
+
+            cols.fill("#{color}-", start..finish)
+            cols[start] = "#{color}|"
+            cols[finish] = "#{color}|"
+            output << "#{color}#{k}#{Color.default}: #{timers[:finish] - timers[:start]}"
           else
             output << "#{k}: error"
           end
+
+          idx += 1
         end
+
         output.each do |msg|
           $stdout.puts color_message(:debug, 'Benchmark:', msg)
         end
+
+        $stdout.puts color_message(:debug, 'Benchmark:', "Total: #{total}")
+
+        $stdout.puts cols[0..TTY::Screen.columns-1].join + Color.reset
       end
     end
 

data/lib/doing/normalize.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## String to symbol conversion
+  ##
+  class ::String
+    ##
+    ## Convert tag sort string to a qualified type
+    ##
+    ## @return     [Symbol] :name or :time
+    ##
+    def normalize_tag_sort(default = :name)
+      case self
+      when /^n/i
+        :name
+      when /^t/i
+        :time
+      else
+        default
+      end
+    end
+
+    ## @see #normalize_tag_sort
+    def normalize_tag_sort!(default = :name)
+      replace normalize_tag_sort(default)
+    end
+
+    ##
+    ## Convert an age string to a qualified type
+    ##
+    ## @return     [Symbol] :oldest or :newest
+    ##
+    def normalize_age(default = :newest)
+      case self
+      when /^o/i
+        :oldest
+      when /^n/i
+        :newest
+      else
+        default
+      end
+    end
+
+    ## @see #normalize_age
+    def normalize_age!(default = :newest)
+      replace normalize_age(default)
+    end
+
+    ##
+    ## Convert a sort order string to a qualified type
+    ##
+    ## @return     [Symbol] :asc or :desc
+    ##
+    def normalize_order!(default = :asc)
+      replace normalize_order(default)
+    end
+
+    def normalize_order(default = :asc)
+      case self
+      when /^a/i
+        :asc
+      when /^d/i
+        :desc
+      else
+        default
+      end
+    end
+
+    ##
+    ## Convert a case sensitivity string to a symbol
+    ##
+    ## @return     Symbol :smart, :sensitive, :ignore
+    ##
+    def normalize_case(default = :smart)
+      case self
+      when /^(c|sens)/i
+        :sensitive
+      when /^i/i
+        :ignore
+      when /^s/i
+        :smart
+      else
+        default.is_a?(Symbol) ? default : default.normalize_case
+      end
+    end
+
+    ## @see #normalize_case
+    def normalize_case!(default = :smart)
+      replace normalize_case(default)
+    end
+
+    ##
+    ## Convert a boolean string to a symbol
+    ##
+    ## @return     Symbol :and, :or, or :not
+    ##
+    def normalize_bool(default = :and)
+      case self
+      when /(and|all)/i
+        :and
+      when /(any|or)/i
+        :or
+      when /(not|none)/i
+        :not
+      when /^p/i
+        :pattern
+      else
+        default.is_a?(Symbol) ? default : default.normalize_bool
+      end
+    end
+
+    ## @see #normalize_bool
+    def normalize_bool!(default = :and)
+      replace normalize_bool(default)
+    end
+
+    ##
+    ## Convert a matching configuration string to a symbol
+    ##
+    ## @param      default  [Symbol] the default matching
+    ##                      type to return if the string
+    ##                      doesn't match a known symbol
+    ## @return     Symbol :fuzzy, :pattern, :exact
+    ##
+    def normalize_matching(default = :pattern)
+      case self
+      when /^f/i
+        :fuzzy
+      when /^p/i
+        :pattern
+      when /^e/i
+        :exact
+      else
+        default.is_a?(Symbol) ? default : default.normalize_matching
+      end
+    end
+
+    ## @see #normalize_matching
+    def normalize_matching!(default = :pattern)
+      replace normalize_bool(default)
+    end
+
+    ##
+    ## Adds ?: to any parentheticals in a regular expression
+    ## to avoid match groups
+    ##
+    ## @return     [String] modified regular expression
+    ##
+    def normalize_trigger
+      gsub(/\((?!\?:)/, '(?:').downcase
+    end
+
+    ## @see #normalize_trigger
+    def normalize_trigger!
+      replace normalize_trigger
+    end
+  end
+
+  ##
+  ## Symbol helpers
+  ##
+  class ::Symbol
+    def normalize_tag_sort(default = :name)
+      to_s.normalize_tag_sort
+    end
+
+    def normalize_bool(default = :and)
+      to_s.normalize_bool(default)
+    end
+
+    def normalize_age(default = :newest)
+      to_s.normalize_age(default)
+    end
+
+    def normalize_order(default = :asc)
+      to_s.normalize_order(default)
+    end
+
+    def normalize_case(default = :smart)
+      to_s.normalize_case(default)
+    end
+
+    def normalize_matching(default = :pattern)
+      to_s.normalize_matching(default)
+    end
+  end
+end

data/lib/doing/pager.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'pathname'
 
 module Doing

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

@@ -129,7 +129,7 @@ module Doing
                    self.template('dayone')
                  end
 
-      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      totals = opt[:totals] ? wwid.tag_times(format: :markdown, sort_by: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
 
       case digest
       when :day

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

@@ -70,7 +70,7 @@ module Doing
                 self.template('css')
               end
 
-      totals = opt[:totals] ? wwid.tag_times(format: :html, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
+      totals = opt[:totals] ? wwid.tag_times(format: :html, sort_by: opt[:sort_tags], sort_order: opt[:tag_order]) : ''
       engine = Haml::Engine.new(template)
       Doing.logger.debug('HTML Export:', "#{items_out.count} items output to HTML")
       @out = engine.render(Object.new,

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

@@ -91,7 +91,7 @@ module Doing
         JSON.pretty_generate({
           'section' => variables[:page_title],
           'items' => items_out,
-          'timers' => wwid.tag_times(format: :json, sort_by_name: opt[:sort_tags], sort_order: opt[:tag_order])
+          'timers' => wwid.tag_times(format: :json, sort_by: opt[:sort_tags], sort_order: opt[:tag_order])
         })
       elsif opt[:output] == 'timeline'
         template = <<~EOTEMPLATE