doing 1.0.93 → 2.0.6.pre

data/lib/doing/string.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      String helpers
+  ##
+  class ::String
+    include Doing::Color
+    def to_rx(distance)
+      gsub(/(.)/, "\\1.{0,#{distance}}")
+    end
+
+    def truthy?
+      if self =~ /^(0|f(alse)?|n(o)?)$/i
+        false
+      else
+        true
+      end
+    end
+
+    def highlight_tags!(color = 'yellow')
+      replace highlight_tags(color)
+    end
+
+    def highlight_tags(color = 'yellow')
+      escapes = scan(/(\e\[[\d;]+m)[^\e]+@/)
+      tag_color = Doing::Color.send(color)
+      last_color = if !escapes.empty?
+                     escapes[-1][0]
+                   else
+                     Doing::Color.default
+                   end
+      gsub(/(\s|m)(@[^ ("']+)/, "\\1#{tag_color}\\2#{last_color}")
+    end
+
+    ##
+    ## @brief      Test if line should be ignored
+    ##
+    ## @return     [Boolean] line is empty or comment
+    ##
+    def ignore?
+      line = self
+      line =~ /^#/ || line =~ /^\s*$/
+    end
+
+    ##
+    ## @brief      Truncate to nearest word
+    ##
+    ## @param      len   The length
+    ##
+    def truncate(len, ellipsis: '...')
+      return self if length <= len
+
+      total = 0
+      res = []
+
+      split(/ /).each do |word|
+        break if total + 1 + word.length > len
+
+        total += 1 + word.length
+        res.push(word)
+      end
+      res.join(' ') + ellipsis
+    end
+
+    def truncate!(len, ellipsis: '...')
+      replace truncate(len, ellipsis: ellipsis)
+    end
+
+    ##
+    ## @brief      Truncate string in the middle
+    ##
+    ## @param      len       The length
+    ## @param      ellipsis  The ellipsis
+    ##
+    def truncmiddle(len, ellipsis: '...')
+      return self if length <= len
+      len -= (ellipsis.length / 2).to_i
+      total = length
+      half = total / 2
+      cut = (total - len) / 2
+      sub(/(.{#{half - cut}}).*?(.{#{half - cut}})$/, "\\1#{ellipsis}\\2")
+    end
+
+    def truncmiddle!(len, ellipsis: '...')
+      replace truncmiddle(len, ellipsis: ellipsis)
+    end
+
+    ##
+    ## @brief      Remove color escape codes
+    ##
+    ## @return     clean string
+    ##
+    def uncolor
+      gsub(/\e\[[\d;]+m/,'')
+    end
+
+    def uncolor!
+      replace uncolor
+    end
+
+    ##
+    ## @brief      Wrap string at word breaks, respecting tags
+    ##
+    ## @param      len     [Integer] The length
+    ## @param      offset  [Integer] (Optional) The width to pad each subsequent line
+    ## @param      prefix  [String] (Optional) A prefix to add to each line
+    ##
+    def wrap(len, pad: 0, indent: '  ', offset: 0, prefix: '', after: '', reset: '')
+      note_rx = /(?i-m)(%(?:[io]d|(?:\^[\s\S])?(?:(?:[ _t]|[^a-z0-9])?\d+)?(?:[\s\S][ _t]?)?)?note)/
+      str = gsub(/@\w+\(.*?\)/) { |tag| tag.gsub(/\s/, '%%%%') }
+      words = str.split(/ /).map { |word| word.gsub(/%%%%/, ' ') }
+      out = []
+      line = []
+      words.each do |word|
+        if line.join(' ').length + word.length + 1 > len
+          out.push(line.join(' '))
+          line.clear
+        end
+
+        line << word
+      end
+      out.push(line.join(' '))
+      note = ''
+      after.sub!(note_rx) do
+        note = Regexp.last_match(0)
+        ''
+      end
+
+      out[0] = format("%-#{pad}s%s", out[0], after)
+      left_pad = ' ' * (offset)
+      left_pad += indent
+      out.map { |l| "#{left_pad}#{prefix}#{l}" }.join("\n").strip + " #{note}".chomp
+    end
+
+    ##
+    ## @brief      Capitalize on the first character on string
+    ##
+    ## @return     Capitalized string
+    ##
+    def cap_first
+      sub(/^\w/) do |m|
+        m.upcase
+      end
+    end
+
+    ##
+    ## @brief      Convert a sort order string to a qualified type
+    ##
+    ## @return     (String) 'asc' or 'desc'
+    ##
+    def normalize_order!
+      replace normalize_order
+    end
+
+    def normalize_order(default = 'asc')
+      case self
+      when /^a/i
+        'asc'
+      when /^d/i
+        'desc'
+      else
+        default
+      end
+    end
+
+    ##
+    ## @brief      Convert a boolean string to a symbol
+    ##
+    ## @return     Symbol :and, :or, or :not
+    ##
+    def normalize_bool!
+      replace normalize_bool
+    end
+
+    def normalize_bool(default = :and)
+      case self
+      when /(and|all)/i
+        :and
+      when /(any|or)/i
+        :or
+      when /(not|none)/i
+        :not
+      else
+        default.is_a?(Symbol) ? default : default.normalize_bool
+      end
+    end
+
+    def normalize_trigger!
+      replace normalize_trigger
+    end
+
+    def normalize_trigger
+      gsub(/\((?!\?:)/, '(?:').downcase
+    end
+
+    def to_tags
+      gsub(/ *, */, ' ').gsub(/ +/, ' ').split(/ /).sort.uniq.map { |t| t.strip.sub(/^@/, '') }
+    end
+
+    def add_tags!(tags, remove: false)
+      replace add_tags(tags, remove: remove)
+    end
+
+    def add_tags(tags, remove: false)
+      title = self.dup
+      tags = tags.to_tags if tags.is_a?(String)
+      tags.each { |tag| title.tag!(tag, remove: remove) }
+      title
+    end
+
+    def tag!(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false)
+      replace tag(tag, value: value, remove: remove, rename_to: rename_to, regex: regex, single: single)
+    end
+
+    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false)
+      log_level = single ? :info : :debug
+      title = dup
+      title.chomp!
+      tag = tag.sub(/^@?/, '')
+      case_sensitive = tag !~ /[A-Z]/
+
+      rx_tag = if regex
+                 tag.gsub(/\./, '\S')
+               else
+                 tag.gsub(/\?/, '.').gsub(/\*/, '\S*?')
+               end
+
+      if remove || rename_to
+        return title unless title =~ /#{rx_tag}(?=[ (]|$)/
+
+        rx = Regexp.new("(^| )@#{rx_tag}(\\([^)]*\\))?(?= |$)", case_sensitive)
+        if title =~ rx
+          title.gsub!(rx) do
+            m = Regexp.last_match
+            rename_to ? "#{m[1]}@#{rename_to}#{m[2]}" : m[1]
+          end
+
+          title.dedup_tags!
+          title.chomp!
+
+          if rename_to
+            f = "@#{tag}".cyan
+            t = "@#{rename_to}".cyan
+            Doing.logger.write(log_level, 'Tag:', %(renamed #{f} to #{t} in "#{title}"))
+          else
+            f = "@#{tag}".cyan
+            Doing.logger.write(log_level, 'Tag:', %(removed #{f} from "#{title}"))
+          end
+        else
+          Doing.logger.debug('Skipped:', "not tagged #{"@#{tag}".cyan}")
+        end
+      elsif title =~ /@#{tag}(?=[ (]|$)/
+        Doing.logger.debug('Skipped:', "already tagged #{"@#{tag}".cyan}")
+        return title
+      else
+        add = tag
+        add += "(#{value})" unless value.nil?
+        title.chomp!
+        title += " @#{add}"
+
+        title.dedup_tags!
+        title.chomp!
+        Doing.logger.write(log_level, 'Tag:', %(added #{('@' + tag).cyan} to "#{title}"))
+      end
+
+      title.gsub(/ +/, ' ')
+    end
+
+    ##
+    ## @brief      Remove duplicate tags, leaving only first occurrence
+    ##
+    ## @return     Deduplicated string
+    ##
+    def dedup_tags!
+      replace dedup_tags
+    end
+
+    def dedup_tags
+      title = dup
+      tags = title.scan(/(?<=^| )(@(\S+?)(\([^)]+\))?)(?= |$)/).uniq
+      tags.each do |tag|
+        found = false
+        title.gsub!(/( |^)#{tag[1]}(\([^)]+\))?(?= |$)/) do |m|
+          if found
+            ''
+          else
+            found = true
+            m
+          end
+        end
+      end
+      title
+    end
+
+    ##
+    ## @brief      Turn raw urls into HTML links
+    ##
+    ## @param      opt   (Hash) Additional Options
+    ##
+    def link_urls!(opt = {})
+      replace link_urls(opt)
+    end
+
+    def link_urls(opt = {})
+      opt[:format] ||= :html
+      str = self.dup
+
+      if :format == :markdown
+        # Remove <self-linked> formatting
+        str.gsub!(/<(.*?)>/) do |match|
+          m = Regexp.last_match
+          if m[1] =~ /^https?:/
+            m[1]
+          else
+            match
+          end
+        end
+      end
+
+      # Replace qualified urls
+      str.gsub!(%r{(?mi)(?<!["'\[(\\])((http|https)://)([\w\-_]+(\.[\w\-_]+)+)([\w\-.,@?^=%&amp;:/~+#]*[\w\-@^=%&amp;/~+#])?}) do |_match|
+        m = Regexp.last_match
+        proto = m[1].nil? ? 'http://' : ''
+        case opt[:format]
+        when :html
+          %(<a href="#{proto}#{m[0]}" title="Link to #{m[0].sub(/^https?:\/\//, '')}">[#{m[3]}]</a>)
+        when :markdown
+          "[#{m[0]}](#{proto}#{m[0]})"
+        else
+          m[0]
+        end
+      end
+
+      # Clean up unlinked <urls>
+      str.gsub!(/<(\w+:.*?)>/) do |match|
+        m = Regexp.last_match
+        if m[1] =~ /<a href/
+          match
+        else
+          %(<a href="#{m[1]}" title="Link to #{m[1]}">[link]</a>)
+        end
+      end
+
+      str
+    end
+  end
+end

data/lib/doing/symbol.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Doing
+  ##
+  ## @brief      Symbol helpers
+  ##
+  class ::Symbol
+    def normalize_bool
+      to_s.normalize_bool
+    end
+
+    def normalize_order
+      to_s.normalize_order
+    end
+  end
+end

data/lib/doing/time.rb

@@ -0,0 +1,18 @@
+module Doing
+  ##
+  ## @brief      Date helpers
+  ##
+  class ::Time
+    def relative_date
+      if self > Date.today.to_time
+        strftime('%_I:%M%P')
+      elsif self > (Date.today - 6).to_time
+        strftime('%a %_I:%M%P')
+      elsif self.year == Date.today.year
+        strftime('%m/%d %_I:%M%P')
+      else
+        strftime('%m/%d/%Y %_I:%M%P')
+      end
+    end
+  end
+end

data/lib/doing/util.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Doing
+  # Utilities
+  module Util
+    extend self
+
+    def user_home
+      if Dir.respond_to?('home')
+        Dir.home
+      else
+        File.expand_path('~')
+      end
+    end
+
+    ##
+    ## @brief      Test if command line tool is available
+    ##
+    ## @param      cli   (String) The name or path of the cli
+    ##
+    def exec_available(cli)
+      return false if cli.nil?
+
+      if File.exist?(File.expand_path(cli))
+        File.executable?(File.expand_path(cli))
+      else
+        system "which #{cli}", out: File::NULL, err: File::NULL
+      end
+    end
+
+    def merge_default_proc(target, overwrite)
+      return unless target.is_a?(Hash) && overwrite.is_a?(Hash) && target.default_proc.nil?
+
+      target.default_proc = overwrite.default_proc
+    end
+
+    def duplicate_frozen_values(target)
+      target.each do |key, val|
+        target[key] = val.dup if val.frozen? && duplicable?(val)
+      end
+    end
+
+    # Non-destructive version of deep_merge_hashes! See that method.
+    #
+    # Returns the merged hashes.
+    def deep_merge_hashes(master_hash, other_hash)
+      deep_merge_hashes!(master_hash.dup, other_hash)
+    end
+
+    # Merges a master hash with another hash, recursively.
+    #
+    # master_hash - the "parent" hash whose values will be overridden
+    # other_hash  - the other hash whose values will be persisted after the merge
+    #
+    # This code was lovingly stolen from some random gem:
+    # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+    #
+    # Thanks to whoever made it.
+    def deep_merge_hashes!(target, overwrite)
+      merge_values(target, overwrite)
+      merge_default_proc(target, overwrite)
+      duplicate_frozen_values(target)
+
+      target
+    end
+
+    def duplicable?(obj)
+      case obj
+      when nil, false, true, Symbol, Numeric
+        false
+      else
+        true
+      end
+    end
+
+    def mergable?(value)
+      value.is_a?(Hash)
+    end
+
+    def merge_values(target, overwrite)
+      target.merge!(overwrite) do |_key, old_val, new_val|
+        if new_val.nil?
+          old_val
+        elsif mergable?(old_val) && mergable?(new_val)
+          deep_merge_hashes(old_val, new_val)
+        else
+          new_val
+        end
+      end
+    end
+
+    ##
+    ## @brief      Write content to a file
+    ##
+    ## @param      file     (String) The path to the file to (over)write
+    ## @param      content  (String) The content to write to the file
+    ## @param      backup   (Boolean) create a ~ backup
+    ##
+    def write_to_file(file, content, backup: true)
+      unless file
+        puts content
+        return
+      end
+
+      file = File.expand_path(file)
+
+      if File.exist?(file) && backup
+        # Create a backup copy for the undo command
+        FileUtils.cp(file, "#{file}~")
+      end
+
+      File.open(file, 'w+') do |f|
+        f.puts content
+      end
+
+      Hooks.trigger :post_write, file
+    end
+
+    def safe_load_file(filename)
+      SafeYAML.load_file(filename) || {}
+    end
+
+    def default_editor
+      @default_editor = find_default_editor
+    end
+
+    def editor_with_args
+      args_for_editor(default_editor)
+    end
+
+    def args_for_editor(editor)
+      return editor if editor =~ /-\S/
+
+      args = case editor
+             when /^(subl|code|mate)$/
+               ['-w']
+             when /^(vim|mvim)$/
+               ['-f']
+             else
+               []
+             end
+      "#{editor} #{args.join(' ')}"
+    end
+
+    def find_default_editor(editor_for = 'default')
+      if ENV['DOING_EDITOR_TEST']
+        return ENV['EDITOR']
+      end
+
+      editor_config = Doing.config.settings['editors']
+
+      if editor_config.is_a?(String)
+        Doing.logger.warn('Deprecated:', "Please update your configuration, 'editors' should be a mapping. Delete the key and run `doing config --update`.")
+        return editor_config
+      end
+
+      if editor_config[editor_for]
+        editor = editor_config[editor_for]
+        Doing.logger.debug('Editor:', "Using #{editor} from config 'editors->#{editor_for}'")
+        return editor unless editor.nil? || editor.empty?
+      end
+
+      if editor_for != 'editor' && editor_config['default']
+        editor = editor_config['default']
+        Doing.logger.debug('Editor:', "Using #{editor} from config: 'editors->default'")
+        return editor unless editor.nil? || editor.empty?
+      end
+
+      editor ||= ENV['DOING_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
+
+      unless editor.nil? || editor.empty?
+        Doing.logger.debug('Editor:', "Found editor in environment variables: #{editor}")
+        return editor
+      end
+
+      Doing.logger.debug('ENV:', 'No EDITOR environment variable, testing available editors')
+      editors = %w[vim vi code subl mate mvim nano emacs]
+      editors.each do |ed|
+        return ed if exec_available(ed)
+        Doing.logger.debug('ENV:', "#{ed} not available")
+      end
+
+      nil
+    end
+  end
+end

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '1.0.93'
+  VERSION = '2.0.6.pre'
 end