doing 2.0.22 → 2.1.0pre

data/lib/doing/string.rb

@@ -20,8 +20,7 @@ module Doing
     ## can be separated by up to *distance* characters in
     ## haystack, spaces indicate unlimited distance.
     ##
-    ## @example    "this word".to_rx(2) =>
-    ## /t.{0,3}h.{0,3}i.{0,3}s.{0,3}.*?w.{0,3}o.{0,3}r.{0,3}d/
+    ## @example    `"this word".to_rx(2) => /t.{0,3}h.{0,3}i.{0,3}s.{0,3}.*?w.{0,3}o.{0,3}r.{0,3}d/`
     ##
     ## @param      distance   [Integer] Allowed distance
     ##                        between characters
@@ -63,6 +62,15 @@ module Doing
       end
     end
 
+    # Compress multiple spaces to single space
+    def compress
+      gsub(/ +/, ' ').strip
+    end
+
+    def compress!
+      replace compress
+    end
+
     ## @param (see #highlight_tags)
     def highlight_tags!(color = 'yellow')
       replace highlight_tags(color)
@@ -289,11 +297,29 @@ module Doing
       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)
+    ##
+    ## Add, rename, or remove a tag in place
+    ##
+    ## @see #tag
+    ##
+    def tag!(tag, **options)
+      replace tag(tag, **options)
     end
 
-    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false)
+    ##
+    ## Add, rename, or remove a tag
+    ##
+    ## @param      tag        The tag
+    ## @param      value      [String] Value for tag (@tag(value))
+    ## @param      remove     [Boolean] Remove the tag instead of adding
+    ## @param      rename_to  [String] Replace tag with this tag
+    ## @param      regex      [Boolean] Tag is regular expression
+    ## @param      single     [Boolean] Operating on a single item (for logging)
+    ## @param      force      [Boolean] With rename_to, add tag if it doesn't exist
+    ##
+    ## @return     [String] The string with modified tags
+    ##
+    def tag(tag, value: nil, remove: false, rename_to: nil, regex: false, single: false, force: false)
       log_level = single ? :info : :debug
       title = dup
       title.chomp!
@@ -307,13 +333,14 @@ module Doing
                end
 
       if remove || rename_to
-        return title unless title =~ /#{rx_tag}(?=[ (]|$)/
+        rx = Regexp.new("(?<=^| )@#{rx_tag}(?<parens>\\((?<value>[^)]*)\\))?(?= |$)", case_sensitive)
+        m = title.match(rx)
 
-        rx = Regexp.new("(^| )@#{rx_tag}(\\([^)]*\\))?(?= |$)", case_sensitive)
-        if title =~ rx
+        if m.nil? && rename_to && force
+          title.tag!(rename_to, value: value, single: single)
+        elsif m
           title.gsub!(rx) do
-            m = Regexp.last_match
-            rename_to ? "#{m[1]}@#{rename_to}#{m[2]}" : m[1]
+            rename_to ? "@#{rename_to}#{value.nil? ? m['parens'] : "(#{value})"}" : ''
           end
 
           title.dedup_tags!
@@ -373,9 +400,16 @@ module Doing
       title
     end
 
-    # Returns the last escape sequence from a string
+    # Returns the last escape sequence from a string.
+    #
+    # Actually returns all escape codes, with the assumption
+    # that the result of inserting them will generate the
+    # same color as was set at the end of the string.
+    # Because you can send modifiers like dark and bold
+    # separate from color codes, only using the last code
+    # may not render the same style.
     #
-    # @param      string  The string to examine
+    # @return     [String]  All escape codes in string
     #
     def last_color
       scan(/\e\[[\d;]+m/).join('')
@@ -386,42 +420,62 @@ module Doing
     ##
     ## @param      opt   [Hash] Additional Options
     ##
-    def link_urls!(opt = {})
-      replace link_urls(opt)
+    def link_urls!(**opt)
+      fmt = opt.fetch(:format, :html)
+      replace link_urls(format: fmt)
     end
 
-    def link_urls(opt = {})
-      opt[:format] ||= :html
-      str = self.dup
+    def link_urls(**opt)
+      fmt = opt.fetch(:format, :html)
+      return self unless fmt
 
-      if :format == :markdown
-        # Remove <self-linked> formatting
-        str.gsub!(/<(.*?)>/) do |match|
-          m = Regexp.last_match
-          if m[1] =~ /^https?:/
-            m[1]
-          else
-            match
-          end
+      str = dup
+
+      str = str.remove_self_links if fmt == :markdown
+
+      str.replace_qualified_urls(format: fmt).clean_unlinked_urls
+    end
+
+    # Remove <self-linked> formatting
+    def remove_self_links
+      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|
+    # Replace qualified urls
+    def replace_qualified_urls(**options)
+      fmt = options.fetch(:format, :html)
+      gsub(%r{(?mi)(?x:
+      (?<!["'\[(\\])
+      (?<protocol>(?:http|https)://)
+      (?<domain>[\w\-]+(?:\.[\w\-]+)+)
+      (?<path>[\w\-.,@?^=%&;:/~+#]*[\w\-@^=%&;/~+#])?
+      )}) do |_match|
         m = Regexp.last_match
-        proto = m[1].nil? ? 'http://' : ''
-        case opt[:format]
+        url = "#{m['domain']}#{m['path']}"
+        proto = m['protocol'].nil? ? 'http://' : m['protocol']
+        case fmt
+        when :terminal
+          TTY::Link.link_to("#{proto}#{url}", "#{proto}#{url}")
         when :html
-          %(<a href="#{proto}#{m[0]}" title="Link to #{m[0].sub(/^https?:\/\//, '')}">[#{m[3]}]</a>)
+          %(<a href="#{proto}#{url}" title="Link to #{m['domain']}">[#{url}]</a>)
         when :markdown
-          "[#{m[0]}](#{proto}#{m[0]})"
+          "[#{url}](#{proto}#{url})"
         else
           m[0]
         end
       end
+    end
 
-      # Clean up unlinked <urls>
-      str.gsub!(/<(\w+:.*?)>/) do |match|
+    # Clean up unlinked <urls>
+    def clean_unlinked_urls
+      gsub(/<(\w+:.*?)>/) do |match|
         m = Regexp.last_match
         if m[1] =~ /<a href/
           match
@@ -429,8 +483,42 @@ module Doing
           %(<a href="#{m[1]}" title="Link to #{m[1]}">[link]</a>)
         end
       end
+    end
 
-      str
+    def set_type(kind = nil)
+      if kind
+        case kind.to_s
+        when /^a/i
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^i/i
+          to_i
+        when /^f/i
+          to_f
+        when /^sy/i
+          sub(/^:/, '').to_sym
+        when /^b/i
+          self =~ /^(true|yes)$/ ? true : false
+        else
+          to_s
+        end
+      else
+        case self
+        when / *, */
+          gsub(/^\[ *| *\]$/, '').split(/ *, */)
+        when /^[0-9]+$/
+          to_i
+        when /^[0-9]+\.[0-9]+$/
+          to_f
+        when /^:\w+/
+          sub(/^:/, '').to_sym
+        when /^(true|yes)$/i
+          true
+        when /^(false|no)$/i
+          false
+        else
+          to_s
+        end
+      end
     end
   end
 end

data/lib/doing/util.rb

@@ -21,11 +21,17 @@ module Doing
     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
+      !TTY::Which.which(cli).nil?
+    end
+
+    ##
+    ## Return the first valid executable from a list of commands
+    ##
+    ## @example `Doing::Util.first_available_exec('bat', 'less -Xr', 'more -r', 'cat')`
+    ##
+    def first_available_exec(*commands)
+      commands.compact.map(&:strip).reject(&:empty?).uniq
+      .find { |cmd| exec_available(cmd.split.first) }
     end
 
     def merge_default_proc(target, overwrite)
@@ -116,6 +122,7 @@ module Doing
 
       File.open(file, 'w+') do |f|
         f.puts content
+        Doing.logger.debug('Write:', "File written: #{file}")
       end
 
       Hooks.trigger :post_write, file
@@ -183,7 +190,8 @@ module Doing
       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)
+        return TTY::Which.which(ed) if TTY::Which.which(ed)
+
         Doing.logger.debug('ENV:', "#{ed} not available")
       end
 

data/lib/doing/version.rb

@@ -1,3 +1,3 @@
 module Doing
-  VERSION = '2.0.22'
+  VERSION = '2.1.0pre'
 end