doing 1.0.91 → 2.0.3.pre

data/lib/doing/configuration.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      Configuration object
+  ##
+  class Configuration
+    attr_reader :settings
+
+    attr_writer :ignore_local
+
+    MissingConfigFile = Class.new(RuntimeError)
+
+    DEFAULTS = {
+      'autotag' => {
+        'whitelist' => [],
+        'synonyms' => {}
+      },
+      'editors' => {
+        'default' => ENV['DOING_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR'],
+        'doing_file' => nil,
+        'config' => nil
+      },
+      'plugins' => {
+        'plugin_path' => File.join(Util.user_home, '.config', 'doing', 'plugins'),
+        'command_path' => File.join(Util.user_home, '.config', 'doing', 'commands')
+      },
+      'doing_file' => '~/what_was_i_doing.md',
+      'current_section' => 'Currently',
+      'paginate' => false,
+      'never_time' => [],
+      'never_finish' => [],
+
+      'templates' => {
+        'default' => {
+          'date_format' => '%Y-%m-%d %H:%M',
+          'template' => '%date | %title%note',
+          'wrap_width' => 0,
+          'order' => 'asc'
+        },
+        'today' => {
+          'date_format' => '%_I:%M%P',
+          'template' => '%date: %title %interval%note',
+          'wrap_width' => 0,
+          'order' => 'asc'
+        },
+        'last' => {
+          'date_format' => '%-I:%M%P on %a',
+          'template' => '%title (at %date)%odnote',
+          'wrap_width' => 88
+        },
+        'recent' => {
+          'date_format' => '%_I:%M%P',
+          'template' => '%shortdate: %title (%section)',
+          'wrap_width' => 88,
+          'count' => 10,
+          'order' => 'asc'
+        }
+      },
+
+      'export_templates' => {},
+
+      'views' => {
+        'done' => {
+          'date_format' => '%_I:%M%P',
+          'template' => '%date | %title%note',
+          'wrap_width' => 0,
+          'section' => 'All',
+          'count' => 0,
+          'order' => 'desc',
+          'tags' => 'done complete cancelled',
+          'tags_bool' => 'OR'
+        },
+        'color' => {
+          'date_format' => '%F %_I:%M%P',
+          'template' => '%boldblack%date %boldgreen| %boldwhite%title%default%note',
+          'wrap_width' => 0,
+          'section' => 'Currently',
+          'count' => 10,
+          'order' => 'asc'
+        }
+      },
+      'marker_tag' => 'flagged',
+      'marker_color' => 'red',
+      'default_tags' => [],
+      'tag_sort' => 'name',
+      'include_notes' => true
+    }
+
+    def initialize(file = nil, options: {})
+      if file
+        cf = File.expand_path(file)
+        # raise MissingConfigFile, "Config not found (#{cf})" unless File.exist?(cf)
+
+        @config_file = cf
+      end
+
+      @settings = configure(options)
+    end
+
+    def additional_configs
+      @additional_configs ||= find_local_config
+    end
+
+    def value_for_key(keypath = '')
+      cfg = @settings
+      unless keypath =~ /^[.*]?$/
+        paths = keypath.split(/[:.]/)
+        while paths.length.positive? && !cfg.nil?
+          path = paths.shift
+          new_cfg = nil
+          cfg.each do |key, val|
+            next unless key =~ /#{path.to_rx(2)}/
+
+            new_cfg = val
+            break
+          end
+
+          if new_cfg.nil?
+            Doing.logger.error("Key match not found: #{path}")
+            break
+          end
+
+          cfg = new_cfg
+        end
+      end
+
+      cfg
+    end
+
+    # It takes the input, fills in the defaults where values do not exist.
+    #
+    # user_config - a Hash or Configuration of overrides.
+    #
+    # Returns a Configuration filled with defaults.
+    def from(user_config)
+      Util.deep_merge_hashes(DEFAULTS, Configuration[user_config].stringify_keys)
+    end
+
+    def config_file
+      @config_file ||= File.join(Util.user_home, '.doingrc')
+    end
+
+    def config_file=(file)
+      @config_file = file
+    end
+
+    ##
+    ## @brief      Read user configuration and merge with defaults
+    ##
+    ## @param      opt   (Hash) Additional Options
+    ##
+    def configure(opt = {})
+      @ignore_local = opt[:ignore_local] if opt[:ignore_local]
+
+      config = read_config.dup
+
+      plugin_config = Util.deep_merge_hashes(DEFAULTS['plugins'], config['plugins'] || {})
+
+      load_plugins(plugin_config['plugin_path'])
+
+      Plugins.plugins.each do |_type, plugins|
+        plugins.each do |title, plugin|
+          plugin_config[title] = plugin[:config] if plugin[:config] && !plugin[:config].empty?
+          config['export_templates'][title] ||= nil if plugin[:templates] && !plugin[:templates].empty?
+        end
+      end
+
+      config = Util.deep_merge_hashes({
+                                        'plugins' => plugin_config
+                                      }, config)
+
+      config = find_deprecations(config)
+
+      if !File.exist?(config_file) || opt[:rewrite]
+        Util.write_to_file(config_file, YAML.dump(config), backup: true)
+        Doing.logger.warn('Config:', "Config file written to #{config_file}")
+      end
+
+      Hooks.trigger :post_config, self
+
+      # config = local_config.deep_merge(config) unless @ignore_local
+      config = Util.deep_merge_hashes(config, local_config) unless @ignore_local
+
+      Hooks.trigger :post_local_config, self
+
+      config
+    end
+
+    private
+
+    def find_deprecations(config)
+      deprecated = false
+      if config.key?('editor')
+        deprecated = true
+        config['editors']['default'] ||= config['editor']
+        config.delete('editor')
+        Doing.logger.debug('Deprecated:', "config key 'editor' is now 'editors->default', please update your config.")
+      end
+
+      if config.key?('config_editor_app') && !config['editors']['config']
+        deprecated = true
+        config['editors']['config'] = config['config_editor_app']
+        config.delete('config_editor_app')
+        Doing.logger.debug('Deprecated:', "config key 'config_editor_app' is now 'editors->config', please update your config.")
+      end
+
+      if config.key?('editor_app') && !config['editors']['doing_file']
+        deprecated = true
+        config['editors']['doing_file'] = config['editor_app']
+        config.delete('editor_app')
+        Doing.logger.debug('Deprecated:', "config key 'editor_app' is now 'editors->doing_file', please update your config.")
+      end
+
+      Doing.logger.warn('Deprecated:', 'outdated keys found, please run `doing config --update`.') if deprecated
+      config
+    end
+
+    ##
+    ## @brief      Read local configurations
+    ##
+    ## @return     Hash of config options
+    ##
+    def local_config
+      return {} if @ignore_local
+
+      local_configs = read_local_configs || {}
+
+      if additional_configs&.count
+        file_list = additional_configs.map { |p| p.sub(/^#{Util.user_home}/, '~') }.join(', ')
+        Doing.logger.debug('Config:', "Local config files found: #{file_list}")
+      end
+
+      local_configs
+    end
+
+    def read_local_configs
+      local_configs = {}
+
+      begin
+        additional_configs.each do |cfg|
+          local_configs.deep_merge(Util.safe_load_file(cfg))
+        end
+      rescue StandardError
+        Doing.logger.error('Config:', 'Error reading local configuration(s)')
+      end
+
+      local_configs
+    end
+
+    ##
+    ## @brief      Reads a configuration.
+    ##
+    def read_config
+      unless File.exist?(config_file)
+        Doing.logger.info('Config:', 'Config file doesn\'t exist, using default configuration' )
+        return {}.deep_merge(DEFAULTS)
+      end
+
+      begin
+        user_config = Util.safe_load_file(config_file)
+        if user_config.key?('html_template')
+          user_config['export_templates'] ||= {}
+          user_config['export_templates'].deep_merge(user_config.delete('html_template'))
+        end
+
+        user_config['include_notes'] = user_config.delete(':include_notes') if user_config.key?(':include_notes')
+
+        user_config.deep_merge(DEFAULTS)
+      rescue StandardError => e
+        Doing.logger.error('Config:', 'Error reading default configuration')
+        Doing.logger.error('Error:', e.message)
+        user_config = DEFAULTS
+      end
+
+      user_config
+    end
+
+    ##
+    ## @brief      Finds a project-specific configuration file
+    ##
+    ## @return     (String) A file path
+    ##
+    def find_local_config
+      dir = Dir.pwd
+
+      local_config_files = []
+
+      while dir != '/' && (dir =~ %r{[A-Z]:/}).nil?
+        local_config_files.push(File.join(dir, '.doingrc')) if File.exist? File.join(dir, '.doingrc')
+
+        dir = File.dirname(dir)
+      end
+
+      local_config_files.delete(config_file)
+
+      local_config_files
+    end
+
+    def load_plugins(add_dir = nil)
+      begin
+        FileUtils.mkdir_p(add_dir) if add_dir && !File.exist?(add_dir)
+      rescue
+        nil
+      end
+
+      Plugins.load_plugins(add_dir)
+    end
+  end
+end

data/lib/doing/errors.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Doing
+  module Errors
+
+    class UserCancelled < ::StandardError
+      def initialize(msg='Cancelled')
+        Doing.logger.output_results
+        Doing.logger.log_now(:warn, 'Exited:', msg)
+        Process.exit 1
+      end
+    end
+
+    class EmptyInput < ::StandardError
+      def initialize(msg='No input')
+        Doing.logger.output_results
+        Doing.logger.log_now(:warn, 'Exited:', 'Input empty')
+        Process.exit 1
+      end
+    end
+
+    class DoingStandardError < ::StandardError
+      def initialize(msg='')
+        Doing.logger.output_results
+
+        super
+      end
+    end
+
+    class DoingRuntimeError < ::RuntimeError
+      def initialize(msg='')
+        Doing.logger.output_results
+
+        super
+      end
+    end
+
+    class NoResults < ::StandardError
+      def initialize(msg='No results')
+        Doing.logger.output_results
+        Process.exit 0
+
+      end
+    end
+
+    class DoingNoTraceError < ::StandardError
+      def initialize(msg = nil, level = nil)
+        level ||= :error
+        Doing.logger.output_results
+        if msg
+          Doing.logger.log_now(level, msg)
+        end
+
+        Process.exit 1
+      end
+    end
+
+    class PluginException < ::StandardError
+      attr_reader :plugin
+
+      def initialize(msg = 'Plugin error', type: nil, plugin: nil)
+        @plugin = plugin || 'Unknown Plugin'
+
+        type ||= 'Unknown'
+        @type = case type.to_s
+                when /^i/
+                  'Import plugin'
+                when /^e/
+                  'Export plugin'
+                else
+                  type.to_s
+                end
+
+        msg = "(#{@type}: #{@plugin}) #{msg}"
+
+        Doing.logger.error('Plugin Error:', msg)
+        Doing.logger.output_results
+        Process.exit 1
+      end
+    end
+
+    HookUnavailable = Class.new(PluginException)
+    InvalidPluginType = Class.new(PluginException)
+    PluginUncallable = Class.new(PluginException)
+
+    InvalidArgument = Class.new(DoingRuntimeError)
+    MissingArgument = Class.new(DoingRuntimeError)
+    MissingFile = Class.new(DoingRuntimeError)
+    MissingEditor = Class.new(DoingRuntimeError)
+    NonInteractive = Class.new(StandardError)
+
+    NoEntryError = Class.new(DoingRuntimeError)
+
+    InvalidTimeExpression = Class.new(DoingRuntimeError)
+    InvalidSection = Class.new(DoingRuntimeError)
+    InvalidView = Class.new(DoingRuntimeError)
+
+    ItemNotFound = Class.new(DoingRuntimeError)
+    # FatalException = Class.new(::RuntimeError)
+    # InvalidPluginName = Class.new(FatalException)
+  end
+end

data/lib/doing/hash.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Doing
+  # Hash helpers
+  class ::Hash
+    ##
+    ## @brief      Freeze all values in a hash
+    ##
+    ## @return     { description_of_the_return_value }
+    ##
+    def deep_freeze
+      map { |k, v| v.is_a?(Hash) ? v.deep_freeze : v.freeze }.freeze
+    end
+
+    def deep_freeze!
+      replace deep_freeze
+    end
+
+    # Turn all keys into string
+    #
+    # Return a copy of the hash where all its keys are strings
+    def stringify_keys
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v.is_a?(Hash) ? v.stringify_keys : v }
+    end
+
+    # Turn all keys into symbols
+    def symbolize_keys
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v }
+    end
+  end
+end

data/lib/doing/hooks.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Doing
+  # Hook manager
+  module Hooks
+    DEFAULT_PRIORITY = 20
+
+    @registry = {
+      post_config: [],
+      post_local_config: [],
+      post_read: [],
+      pre_write: [],
+      post_write: []
+    }
+
+    # map of all hooks and their priorities
+    @hook_priority = {}
+
+    # register hook(s) to be called later, public API
+    def self.register(event, priority: DEFAULT_PRIORITY, &block)
+      register_one(event, priority_value(priority), &block)
+    end
+
+    # Ensure the priority is a Fixnum
+    def self.priority_value(priority)
+      return priority if priority.is_a?(Integer)
+
+      PRIORITY_MAP[priority] || DEFAULT_PRIORITY
+    end
+
+    # 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}"
+      end
+
+      raise Doing::Errors::PluginUncallable, 'Hooks must respond to :call' unless block.respond_to? :call
+
+      Doing.logger.debug('Hook Manager:', "Registered #{event} hook") if ENV['DOING_PLUGIN_DEBUG']
+
+      insert_hook event, priority, &block
+    end
+
+    def self.insert_hook(event, priority, &block)
+      @hook_priority[block] = [-priority, @hook_priority.size]
+      @registry[event] << block
+    end
+
+    def self.trigger(event, *args)
+      hooks = @registry[event]
+      return if hooks.nil? || hooks.empty?
+
+      # sort and call hooks according to priority and load order
+      hooks.sort_by { |h| @hook_priority[h] }.each do |hook|
+        hook.call(*args)
+      end
+    end
+  end
+end

data/lib/doing/item.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      This class describes a single WWID item
+  ##
+  class Item
+    attr_accessor :date, :title, :section, :note
+
+    def initialize(date, title, section, note = nil)
+      @date = date.is_a?(Time) ? date : Time.parse(date)
+      @title = title
+      @section = section
+      @note = Note.new(note)
+    end
+
+    # def date=(new_date)
+    #   @date = new_date.is_a?(Time) ? new_date : Time.parse(new_date)
+    # end
+
+    def interval
+      @interval ||= calc_interval
+    end
+
+    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 equal?(other)
+      return false if @title.strip != other.title.strip
+
+      return false if @date != other.date
+
+      return false unless @note.equal?(other.note)
+
+      true
+    end
+
+    def same_time?(item_b)
+      date == item_b.date ? interval == item_b.interval : false
+    end
+
+    def overlapping_time?(item_b)
+      return true if same_time?(item_b)
+
+      start_a = date
+      interval = interval
+      end_a = interval ? start_a + interval.to_i : start_a
+      start_b = item_b.date
+      interval = item_b.interval
+      end_b = interval ? start_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
+
+    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false)
+      @title.tag!(tag, value: value, remove: remove, rename_to: rename_to, regex: regex).strip!
+    end
+
+    def tags
+      @title.scan(/(?<= |\A)@([^\s(]+)/).map {|tag| tag[0]}.sort.uniq
+    end
+
+    def tags?(tags, bool = :and)
+      tags = split_tags(tags)
+      bool = bool.normalize_bool
+
+      case bool
+      when :and
+        all_tags?(tags)
+      when :not
+        no_tags?(tags)
+      else
+        any_tags?(tags)
+      end
+    end
+
+    def search(search)
+      text = @title + @note.to_s
+      pattern = case search.strip
+                when %r{^/.*?/$}
+                  search.sub(%r{/(.*?)/}, '\1')
+                when /^'/
+                  case_sensitive = true
+                  search.sub(/^'(.*?)'?$/, '\1')
+                else
+                  case_sensitive = true if search =~ /[A-Z]/
+                  search.split('').join('.{0,3}')
+                end
+      rx = Regexp.new(pattern, !case_sensitive)
+
+      text =~ rx
+    end
+
+    def should_finish?
+      should?('never_finish')
+    end
+
+    def should_time?
+      should?('never_time')
+    end
+
+    private
+
+    def should?(key)
+      config = Doing.config.settings
+      return true unless config[key].is_a?(Array)
+
+      config[key].each do |tag|
+        if tag =~ /^@/
+          return false if tags?(tag.sub(/^@/, '').downcase)
+        elsif section.downcase == tag.downcase
+          return false
+        end
+      end
+
+      true
+    end
+
+    def calc_interval
+      done = end_date
+      return nil if done.nil?
+
+      start = @date
+
+      t = (done - start).to_i
+      t > 0 ? t : nil
+    end
+
+    def all_tags?(tags)
+      tags.each do |tag|
+        return false unless @title =~ /@#{tag}/
+      end
+      true
+    end
+
+    def no_tags?(tags)
+      tags.each do |tag|
+        return false if @title =~ /@#{tag}/
+      end
+      true
+    end
+
+    def any_tags?(tags)
+      tags.each do |tag|
+        return true if @title =~ /@#{tag}/
+      end
+      false
+    end
+
+    def split_tags(tags)
+      tags = tags.split(/ *, */) if tags.is_a? String
+      tags.map { |t| t.strip.sub(/^@/, '') }
+    end
+  end
+end