doing 2.1.39 → 2.1.40

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.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/string'
+require_relative 'completion/fish_completion'
+require_relative 'completion/zsh_completion'
+require_relative 'completion/bash_completion'
 
 module Doing
   # Completion script generator

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/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']
 

data/lib/doing/item/dates.rb

@@ -0,0 +1,112 @@
+module Doing
+  class Item
+    # def date=(new_date)
+    #   @date = new_date.is_a?(Time) ? new_date : Time.parse(new_date)
+    # end
+
+    ## If the entry doesn't have a @done date, return the elapsed time
+    def duration
+      return nil unless should_time? && should_finish?
+
+      return nil if @title =~ /(?<=^| )@done\b/
+
+      return Time.now - @date
+    end
+
+    ##
+    ## Get the difference between the item's start date and
+    ## the value of its @done tag (if present)
+    ##
+    ## @return     Interval in seconds
+    ##
+    def interval
+      @interval ||= calc_interval
+    end
+
+    ##
+    ## Get the value of the item's @done tag
+    ##
+    ## @return     [Time] @done value
+    ##
+    def end_date
+      @end_date ||= Time.parse(Regexp.last_match(1)) if @title =~ /@done\((\d{4}-\d\d-\d\d \d\d:\d\d.*?)\)/
+    end
+
+    def calculate_end_date(opt)
+      if opt[:took]
+        if @date + opt[:took] > Time.now
+          @date = Time.now - opt[:took]
+          Time.now
+        else
+          @date + opt[:took]
+        end
+      elsif opt[:back]
+        if opt[:back].is_a? Integer
+          @date + opt[:back]
+        else
+          @date + (opt[:back] - @date)
+        end
+      else
+        Time.now
+      end
+    end
+
+    ##
+    ## Test if two items occur at the same time (same start date and equal duration)
+    ##
+    ## @param      item_b  [Item] The item to compare
+    ##
+    ## @return     [Boolean] is equal?
+    ##
+    def same_time?(item_b)
+      date == item_b.date ? interval == item_b.interval : false
+    end
+
+    ##
+    ## Test if the interval between start date and @done
+    ## value overlaps with another item's
+    ##
+    ## @param      item_b  [Item] The item to compare
+    ##
+    ## @return     [Boolean] overlaps?
+    ##
+    def overlapping_time?(item_b)
+      return true if same_time?(item_b)
+
+      start_a = date
+      a_interval = interval
+      end_a = a_interval ? start_a + a_interval.to_i : start_a
+      start_b = item_b.date
+      b_interval = item_b.interval
+      end_b = b_interval ? start_b + b_interval.to_i : start_b
+      (start_a >= start_b && start_a <= end_b) || (end_a >= start_b && end_a <= end_b) || (start_a < start_b && end_a > end_b)
+    end
+
+    ##
+    ## Updates the title of the Item by expanding natural
+    ## language dates within configured date tags (tags
+    ## whose value is expected to be a date)
+    ##
+    ## @param      additional_tags  An array of additional
+    ##                              tag names to consider
+    ##                              dates
+    ##
+    def expand_date_tags(additional_tags = nil)
+      @title.expand_date_tags(additional_tags)
+    end
+
+    private
+
+    def calc_interval
+      return nil unless should_time? && should_finish?
+
+      done = end_date
+      return nil if done.nil?
+
+      start = @date
+
+      t = (done - start).to_i
+      t.positive? ? t : nil
+    end
+  end
+end