doing 2.1.39 → 2.1.42

data/lib/doing/array/tags.rb

@@ -4,12 +4,14 @@ module Doing
   ##
   ## Array helpers
   ##
-  class ::Array
+  module ArrayTags
     ##
     ## Convert an array of @tags to plain strings
     ##
-    ## @return     [Array] array of strings
+    ## @return     [Array] array of strings without @ symbols
     ##
+    ## @example Convert an array of tags to strings
+    ##   ['@one', '@two', 'three'].to_tags => ['one', 'two', 'three']
     def tags_to_array
       map(&:remove_at).map(&:strip)
     end
@@ -18,9 +20,8 @@ module Doing
     #
     # @return     [Array] Array of @tags
     #
-    # @example
-    #   ['one', '@two', 'three'].to_tags
-    #   # => ['@one', '@two', '@three']
+    # @example Convert an array of strings with or without @ symbols
+    #   ['one', '@two', 'three'].to_tags => ['@one', '@two', '@three']
     def to_tags
       map(&:add_at)
     end

data/lib/doing/changelog/changelog.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'version'
+require_relative 'entry'
+require_relative 'change'
+require_relative 'changes'

data/lib/doing/chronify/array.rb

@@ -2,12 +2,60 @@
 
 module Doing
   # Chronify array helpers
-  class ::Array
+  module ChronifyArray
+    # Convert [d, h, m] to [y, d, h, m]
+    def to_years
+      d, h, m = self
+
+      if d.zero? && h > 24
+        d = (h / 24).floor
+        h = h % 24
+      end
+
+      if d > 365
+        y = (d / 365).floor
+        d = d % 365
+      else
+        y = 0
+      end
+
+      [y, d, h, m]
+    end
+
+    def to_natural
+      y, d, h, m = to_years
+      human = []
+      human.push(format('%<y>d %<s>s', y: y, s: 'year'.to_p(y))) if y.positive?
+      human.push(format('%<d>d %<s>s', d: d, s: 'day'.to_p(d))) if d.positive?
+      human.push(format('%<h>d %<s>s', h: h, s: 'hour'.to_p(h))) if h.positive?
+      human.push(format('%<m>d %<s>s', m: m, s: 'minute'.to_p(m))) if m.positive?
+      human
+    end
+
+    def to_abbr(years: false, separator: '')
+      if years
+        y, d, h, m = to_years
+      else
+        y = 0
+        d, h, m = self
+
+        if d.zero? && h > 24
+          d = (h / 24).floor
+          h = h % 24
+        end
+      end
+
+      output = []
+      output.push(format('%<y>dy', y: y)) if y.positive?
+      output.push(format('%<d>dd', d: d)) if d.positive?
+      output.push(format('%<h>dh', h: h)) if h.positive?
+      output.push(format('%<m>dm', m: m)) if m.positive?
+      output.join(separator)
+    end
+
     ##
     ## Format [d, h, m] as string
     ##
-    ## @accept     [Array] Array of [days, hours, minutes]
-    ##
     ## @param      format  [Symbol] The format, :dhm, :hm,
     ##                     :m, :clock, :natural
     ## @return     [String] formatted string
@@ -23,16 +71,13 @@ module Doing
           h = h % 24
         end
         format('%<d>02d:%<h>02d:%<m>02d', d: d, h: h, m: m)
+      when :hmclock
+        h += d * 24 if d.positive?
+        format('%<h>02d:%<m>02d', h: h, m: m)
+      when :ydhm
+        to_abbr(years: true, separator: ' ')
       when :dhm
-        if d.zero? && h > 24
-          d = (h / 24).floor
-          h = h % 24
-        end
-        output = []
-        output.push(format('%<d>dd', d: d)) if d.positive?
-        output.push(format('%<h>dh', h: h)) if h.positive?
-        output.push(format('%<m>dm', m: m)) if m.positive?
-        output.join(' ')
+        to_abbr(years: false, separator: ' ')
       when :hm
         h += d * 24 if d.positive?
         format('%<h> 4dh %<m>02dm', h: h, m: m)
@@ -40,25 +85,20 @@ module Doing
         h += d * 24 if d.positive?
         m += h * 60 if h.positive?
         format('%<m> 4dm', m: m)
+      when :tight
+        to_abbr(years: true, separator: '')
       when :natural
-        human = []
-        human.push(format('%<d>d %<s>s', d: d, s: 'day'.to_p(d))) if d.positive?
-        human.push(format('%<h>d %<s>s', h: h, s: 'hour'.to_p(h))) if h.positive?
-        human.push(format('%<m>d %<s>s', m: m, s: 'minute'.to_p(m))) if m.positive?
-        human.join(', ')
+        to_natural.join(', ')
       when :speech
-        human = []
-        human.push(format('%<d>d %<s>s', d: d, s: 'day'.to_p(d))) if d.positive?
-        human.push(format('%<h>d %<s>s', h: h, s: 'hour'.to_p(h))) if h.positive?
-        human.push(format('%<m>d %<s>s', m: m, s: 'minute'.to_p(m))) if m.positive?
+        human = to_natural
         last = human.pop
         case human.count
-        when 2
-          human.join(', ') + ", and #{last}"
-        when 1
-          "#{human[0]} and #{last}"
         when 0
           last
+        when 1
+          "#{human[0]} and #{last}"
+        else
+          human.join(', ') + ", and #{last}"
         end
       end
     end

data/lib/doing/chronify/chronify.rb

@@ -3,3 +3,15 @@
 require_relative 'array'
 require_relative 'numeric'
 require_relative 'string'
+
+class ::String
+  include Doing::ChronifyString
+end
+
+class ::Array
+  include Doing::ChronifyArray
+end
+
+class ::Numeric
+  include Doing::ChronifyNumeric
+end

data/lib/doing/chronify/numeric.rb

@@ -4,11 +4,12 @@ module Doing
   ##
   ## Number helpers
   ##
-  class ::Numeric
+  module ChronifyNumeric
     ##
     ## Format human readable time from seconds
     ##
-    ## @param      seconds  [Integer] Seconds
+    ## @param      human  [Boolean] if True, don't convert
+    ##                    hours into days
     ##
     def format_time(human: false)
       return [0, 0, 0] if nil?

data/lib/doing/chronify/string.rb

@@ -2,7 +2,7 @@
 
 module Doing
   # Chronify methods for strings
-  class ::String
+  module ChronifyString
     ##
     ## Converts input string into a Time object when input
     ## takes on the following formats:

data/lib/doing/colors.rb

@@ -2,9 +2,18 @@
 
 # Cribbed from <https://github.com/flori/term-ansicolor>
 module Doing
-  # Terminal color functions
+  # Terminal output color functions.
   module Color
-    # :stopdoc:
+    # All available color names. Available as methods and string extensions.
+    #
+    # @example Use a color as a method. Color reset will be added to end of string.
+    #   Color.yellow('This text is yellow') => "\e[33mThis text is yellow\e[0m"
+    #
+    # @example Use a color as a string extension. Color reset added automatically.
+    #   'This text is green'.green => "\e[1;32mThis text is green\e[0m"
+    #
+    # @example Send a text string as a color
+    #   Color.send('red') => "\e[31m"
     ATTRIBUTES = [
       [:clear,               0], # String#clear is already used to empty string in Ruby 1.9
       [:reset,               0], # synonym for :clear
@@ -66,7 +75,7 @@ module Doing
       [:redacted,    '0;30;40'],
       [:alert,       '1;31;43'],
       [:error,       '1;37;41'],
-      [:default,        '0;39']
+      [:default, '0;39']
     ].map(&:freeze).freeze
 
     ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
@@ -119,24 +128,60 @@ module Doing
     end
 
     class << self
-      # Returns true, if the coloring function of this module
+      # Returns true if the coloring function of this module
       # is switched on, false otherwise.
       def coloring?
         @coloring
       end
 
-      # Turns the coloring on or off globally, so you can easily do
-      # this for example:
-      #  Doing::Color::coloring = STDOUT.isatty
       attr_writer :coloring
 
+      ##
+      ## Enables colored output
+      ##
+      ## @example Turn color on or off based on TTY
+      ##   Doing::Color.coloring = STDOUT.isatty
       def coloring
         @coloring ||= true
       end
+
+      ##
+      ## Convert a template string to a colored string.
+      ## Colors are specified with single letters inside
+      ## curly braces. Uppercase changes background color.
+      ##
+      ## w: white, k: black, g: green, l: blue, y: yellow, c: cyan,
+      ## m: magenta, r: red, b: bold, u: underline, i: italic,
+      ## x: reset (remove background, color, emphasis)
+      ##
+      ## @example Convert a templated string
+      ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
+      ##
+      ## @param      input  [String, Array] The template
+      ##                    string. If this is an array, the
+      ##                    elements will be joined with a
+      ##                    space.
+      ##
+      ## @return     [String] Colorized string
+      ##
+      def template(input)
+        input = input.join(' ') if input.is_a? Array
+        fmt = input.gsub(/\{(\w+)\}/) do
+          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+        end
+
+        colors = { w: white, k: black, g: green, l: blue,
+                   y: yellow, c: cyan, m: magenta, r: red,
+                   W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                   Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                   b: bold, u: underline, i: italic, x: reset }
+
+        format(fmt, colors)
+      end
     end
 
     ATTRIBUTES.each do |c, v|
-      eval <<-EOT
+      new_method = <<-EOSCRIPT
         def #{c}(string = nil)
           result = ''
           result << "\e[#{v}m" if Doing::Color.coloring?
@@ -152,33 +197,37 @@ module Doing
           result << "\e[0m" if Doing::Color.coloring?
           result
         end
-      EOT
+      EOSCRIPT
+
+      module_eval(new_method)
+
+      next unless c =~ /bold/
 
       # 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
+      new_method = <<-EOSCRIPT
+        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
-        EOT
-      end
+          result << "\e[0m" if Doing::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
     end
 
     # Regular expression that is used to scan for ANSI-sequences while
     # uncoloring strings.
-    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/
+    COLORED_REGEXP = /\e\[(?:(?:[349]|10)[0-7]|[0-9])?m/.freeze
 
     # Returns an uncolored version of the string, that is all
     # ANSI-sequences are stripped from the string.
@@ -194,8 +243,6 @@ module Doing
       end
     end
 
-    module_function
-
     # Returns an array of all Doing::Color attributes as symbols.
     def attributes
       ATTRIBUTE_NAMES

data/lib/doing/completion/completion_string.rb

@@ -0,0 +1,25 @@
+module Doing
+  module Completion
+    module StringUtils
+      def short_desc
+        split(/[,.]/)[0].sub(/ \(.*?\)?$/, '').strip
+      end
+
+      def ltrunc(max)
+        if length > max
+          sub(/^.*?(.{#{max - 3}})$/, '...\1')
+        else
+          self
+        end
+      end
+
+      def ltrunc!(max)
+        replace ltrunc(max)
+      end
+    end
+  end
+end
+
+class ::String
+  include Doing::Completion::StringUtils
+end

data/lib/doing/completion.rb

@@ -2,11 +2,10 @@
 
 require 'tty-progressbar'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'completion'))
-require 'string'
-require 'fish_completion'
-require 'zsh_completion'
-require 'bash_completion'
+require_relative 'completion/completion_string'
+require_relative 'completion/fish_completion'
+require_relative 'completion/zsh_completion'
+require_relative 'completion/bash_completion'
 
 module Doing
   # Completion script generator

data/lib/doing/configuration.rb

@@ -23,7 +23,8 @@ module Doing
       'editors' => {
         'default' => ENV['DOING_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR'],
         'doing_file' => nil,
-        'config' => nil
+        'config' => nil,
+        'pager' => nil
       },
       'plugins' => {
         'plugin_path' => File.join(Util.user_home, '.config', 'doing', 'plugins'),
@@ -204,6 +205,7 @@ module Doing
       real_path = []
       unless keypath =~ /^[.*]?$/
         paths = keypath.split(/[:.]/)
+        element_count = paths.count
         while paths.length.positive? && !cfg.nil?
           path = paths.shift
           new_cfg = nil
@@ -220,6 +222,8 @@ module Doing
           end
 
           if new_cfg.nil?
+            return real_path if real_path[-1] == path && real_path.count == element_count
+
             if distance < 5 && !create
               return resolve_key_path(keypath, create: false, distance: distance + 1)
             else
@@ -228,12 +232,12 @@ module Doing
 
             resolved = real_path.count.positive? ? "Resolved #{real_path.join('.')}, but " : ''
             Doing.logger.log_now(:warn, "#{resolved}#{path} is unknown")
-            new_path = [*real_path, path, *paths].join('.')
+            new_path = [*real_path, path, *paths].compact.join('.')
             Doing.logger.log_now(:warn, "Continuing will create the path #{new_path}")
             res = Prompt.yn('Key path not found, create it?', default_response: true)
             raise InvalidArgument, 'Invalid key path' unless res
 
-            real_path.push(path).concat(paths)
+            real_path.push(path).concat(paths).compact!
             Doing.logger.debug('Config:', "translated key path #{keypath} to #{real_path.join('.')}")
             return real_path
           end

data/lib/doing/errors.rb

@@ -2,19 +2,27 @@
 
 module Doing
   module Errors
-    class UserCancelled < ::StandardError
-      def initialize(msg = 'Cancelled', topic = 'Exited:')
+    class DoingNoTraceError < ::StandardError
+      def initialize(msg = nil, level: nil, topic: 'Error:', exit_code: 1)
+        level ||= :error
         Doing.logger.output_results
-        Doing.logger.log_now(:warn, topic, msg)
-        Process.exit 1
+        if msg
+          Doing.logger.log_now(level, topic, msg)
+        end
+
+        Process.exit exit_code
       end
     end
 
-    class EmptyInput < ::StandardError
+    class UserCancelled < DoingNoTraceError
+      def initialize(msg = 'Cancelled', topic = 'Exited:')
+        super(msg, level: :warn, topic: topic, exit_code: 1)
+      end
+    end
+
+    class EmptyInput < DoingNoTraceError
       def initialize(msg = 'No input', topic = 'Exited:')
-        Doing.logger.output_results
-        Doing.logger.log_now(:warn, topic, msg)
-        Process.exit 1
+        super(msg, level: :warn, topic: topic, exit_code: 6)
       end
     end
 
@@ -22,44 +30,47 @@ module Doing
       def initialize(msg = '')
         Doing.logger.output_results
 
-        super
+        super(msg)
       end
     end
 
-    class WrongCommand < ::StandardError
+    class WrongCommand < DoingNoTraceError
       def initialize(msg = 'wrong command', topic: 'Error:')
-        Doing.logger.warn(topic, msg)
-
-        super(msg)
+        super(msg, level: :warn, topic: topic, exit_code: 2)
       end
     end
 
     class DoingRuntimeError < ::RuntimeError
-      def initialize(msg = 'Runtime Error', topic: 'Error:')
+      def initialize(msg = 'Runtime Error', exit_code = nil, topic: 'Error:')
         Doing.logger.output_results
         Doing.logger.log_now(:error, topic, msg)
-        Process.exit 1
+
+        Process.exit exit_code if exit_code
       end
     end
 
-    class NoResults < ::StandardError
+    class NoResults < DoingNoTraceError
       def initialize(msg = 'No results', topic = 'Exited:')
-        Doing.logger.output_results
-        Doing.logger.log_now(:warn, topic, msg)
-        Process.exit 0
+        super(msg, level: :warn, topic: topic, exit_code: 0)
 
       end
     end
 
-    class DoingNoTraceError < ::StandardError
-      def initialize(msg = nil, level = nil, topic = nil)
-        level ||= :error
-        Doing.logger.output_results
-        if msg
-          Doing.logger.log_now(level, topic, msg)
-        end
+    class HistoryLimitError < DoingNoTraceError
+      def initialize(msg, exit_code = 24)
+        super(msg, level: :error, topic: 'History:', exit_code: exit_code)
+      end
+    end
 
-        Process.exit 1
+    class MissingBackupFile < DoingNoTraceError
+      def initialize(msg, exit_code = 26)
+        super(msg, level: :error, topic: 'History:', exit_code: exit_code)
+      end
+    end
+
+    class InvalidPlugin < DoingRuntimeError
+      def initialize(kind = 'output', msg = nil)
+        super(%(Invalid #{kind} type (#{msg})), 128, topic: 'Invalid:')
       end
     end
 
@@ -75,6 +86,10 @@ module Doing
                   'Import plugin'
                 when /^e/
                   'Export plugin'
+                when /^h/
+                  'Hook'
+                when /^u/
+                  'Unrecognized'
                 else
                   type.to_s
                 end
@@ -82,7 +97,8 @@ module Doing
         msg = "(#{@type}: #{@plugin}) #{msg}"
 
         Doing.logger.log_now(:error, 'Plugin:', msg)
-        Process.exit 1
+
+        super(msg)
       end
     end
 
@@ -90,17 +106,17 @@ module Doing
     InvalidPluginType = Class.new(PluginException)
     PluginUncallable = Class.new(PluginException)
 
-    InvalidArgument = Class.new(DoingRuntimeError)
-    MissingArgument = Class.new(DoingRuntimeError)
-    MissingFile = Class.new(DoingRuntimeError)
-    MissingEditor = Class.new(DoingRuntimeError)
+    InvalidArgument = Class.new(DoingNoTraceError)
+    MissingArgument = Class.new(DoingNoTraceError)
+    MissingFile = Class.new(DoingNoTraceError)
+    MissingEditor = Class.new(DoingNoTraceError)
     NonInteractive = Class.new(StandardError)
 
-    NoEntryError = Class.new(DoingRuntimeError)
+    NoEntryError = Class.new(DoingNoTraceError)
 
     InvalidTimeExpression = Class.new(DoingRuntimeError)
-    InvalidSection = Class.new(DoingRuntimeError)
-    InvalidView = Class.new(DoingRuntimeError)
+    InvalidSection = Class.new(DoingNoTraceError)
+    InvalidView = Class.new(DoingNoTraceError)
 
     ItemNotFound = Class.new(DoingRuntimeError)
     # FatalException = Class.new(::RuntimeError)

data/lib/doing/good.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
 module Doing
+  # Numeric helpers
+  class ::Numeric
+    # Test of number is positive
+    def good?
+      positive?
+    end
+  end
+
   # Object helpers
   class ::Object
     ##

data/lib/doing/hooks.rb

@@ -15,7 +15,7 @@ module Doing
       post_entry_removed: [], # wwid, entry.dup
       pre_export: [],         # wwid, format, entries
       pre_write: [],          # wwid, file
-      post_write: []          # wwid, file
+      post_write: []          # file
     }
 
     # map of all hooks and their priorities
@@ -40,10 +40,10 @@ module Doing
     # register a single hook to be called later, internal API
     def self.register_one(event, priority, &block)
       unless @registry[event]
-        raise Doing::Errors::HookUnavailable, "Invalid hook. Doing only supports #{@registry.keys.inspect}"
+        raise Doing::Errors::HookUnavailable.new("Invalid hook. Doing only supports #{@registry.keys.inspect}", 'hook', event)
       end
 
-      raise Doing::Errors::PluginUncallable, 'Hooks must respond to :call' unless block.respond_to? :call
+      raise Doing::Errors::PluginUncallable.new('Hooks must respond to :call', 'hook', event) unless block.respond_to? :call
 
       Doing.logger.debug('Hook Manager:', "Registered #{event} hook") if ENV['DOING_PLUGIN_DEBUG']