searchlink 2.3.63 → 2.3.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fe46ed7fe6c7688ce62b32035592b22ada5ccfd918c39cb4efde42d40c328a4
-  data.tar.gz: 14c5b53c4b88f6fea15f729781fc8fb7bb21ecabc211e0d49fd7a3b2078d36b0
+  metadata.gz: bd9142e4c8363dca0dbbc82c7bb4be3112ce335f908641b4184dbde9e1525960
+  data.tar.gz: c8e7cf285e4de29c24a7fcb53014c2efa4da8a3c38a857f11747b97a8a653ba0
 SHA512:
-  metadata.gz: 560cbfc23c8ebcb47ccd67d896e1168ce9acb9d58adccde348df1bd11cea3e8d5e9990d2565088a2367239e4b3799bd50effd856fb41836d8007d4ae3f42e4ea
-  data.tar.gz: debe843ab12a7abd1075f36456d789f38f7cb402af6bb717c7c53ffb59205626e3a925aa515a17dd40c0fb34b9e2950203fc368a33d28e4a4fcc6857a10a7446
+  metadata.gz: 6d2336776d6526804d9df51e180a9996a89cc9786ef4c0cefa5fede4e3ba2c9a931c4240c2116809f6fd928dc8155c7c3b26b0141add9bf1ed39000bdf73ca2e
+  data.tar.gz: c7710d400e7346a79063604af305027a851f490ec055f7b762bc9d414db5f5ebf1d21504bff3acccb7e5832c42d5914ce844b324f483a7c0044ff72720b637dc

data/bin/searchlink

@@ -46,8 +46,7 @@ if !ARGV.empty?
 
   files.each do |file|
     if File.exist?(file) && `file -b "#{file}"|grep -c text`.to_i.positive?
-      input = RUBY_VERSION.to_f > 1.9 ? IO.read(file).force_encoding('utf-8') : IO.read(file)
-      input.scrub!
+      input = IO.read(file).scrubup
 
       backup_file = "#{file}.bak"
       backup_file = "#{file}.bak 1" if File.exist?(backup_file)
@@ -72,8 +71,7 @@ if !ARGV.empty?
     end
   end
 else
-  input = RUBY_VERSION.to_f > 1.9 ? $stdin.read.force_encoding('utf-8').encode : $stdin.read
-  input.scrub!
+  input = $stdin.read.scrubup
   sl.parse(input)
   output = SL.output&.join('')
 

data/lib/searchlink/curl/html.rb

@@ -107,6 +107,7 @@ module Curl
     ## @param      tag     The tag
     ## @param      source  [Boolean] Return full tag instead of contents
     ##
+    ## @return [Array] array of tag matches/contents
     def extract_tag_contents(tag, source: false)
       return @body.scan(%r{<#{tag}.*?>(?:.*?</#{tag}>)?}) if source
 
@@ -452,13 +453,11 @@ module Curl
         end
 
         # look for a charset in a content-encoding header
-        if content_type
-          encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1]
-        end
+        encoding ||= content_type[/charset=["']?(.*?)($|["';\s])/i, 1] if content_type
 
         # look for a charset in a meta tag in the first 1024 bytes
         unless encoding
-          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, "")
+          data = body[0..1023].gsub(/<!--.*?(-->|\Z)/m, '')
           data.scan(/<meta.*?>/im).each do |meta|
             encoding ||= meta[/charset=["']?([^>]*?)($|["'\s>])/im, 1]
           end

data/lib/searchlink/searches/github.rb

@@ -24,6 +24,8 @@ module SL
           url, title, link_text = github(search_terms, link_text)
         end
 
+        return SL.ddg("site:github.com #{search_terms}", link_text) unless url
+
         link_text = title if link_text == '' || link_text == search_terms
 
         [url, title, link_text]
@@ -32,9 +34,9 @@ module SL
       def github_search_curl(endpoint, query)
         headers = {
           'Accept' => 'application/vnd.github+json',
-          'X-GitHub-Api-Version' => '2022-11-28',
+          'X-GitHub-Api-Version' => '2022-11-28'
         }
-        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if Secrets::GH_AUTH_TOKEN
+        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if defined? Secrets::GH_AUTH_TOKEN
 
         url = "https://api.github.com/search/#{endpoint}?q=#{query.url_encode}&per_page=1&page=1&order=desc"
         res = Curl::Json.new(url, headers: headers)
@@ -51,7 +53,7 @@ module SL
           'Accept' => 'application/vnd.github+json',
           'X-GitHub-Api-Version' => '2022-11-28'
         }
-        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if Secrets::GH_AUTH_TOKEN
+        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if defined? Secrets::GH_AUTH_TOKEN
 
         url = "https://api.github.com/users/#{user}/gists?per_page=100&page=#{page}"
 
@@ -113,14 +115,18 @@ module SL
       end
 
       def search_github(search_terms, link_text)
-        search_terms.gsub!(%r{(\S+)/(\S+)}, 'user:\1 \2')
-        search_terms.gsub!(/\bu\w*:(\w+)/, 'user:\1')
-        search_terms.gsub!(/\bl\w*:(\w+)/, 'language:\1')
-        search_terms.gsub!(/\bin?:r\w*/, 'in:readme')
-        search_terms.gsub!(/\bin?:t\w*/, 'in:topics')
-        search_terms.gsub!(/\bin?:d\w*/, 'in:description')
-        search_terms.gsub!(/\bin?:(t(itle)?|n(ame)?)/, 'in:name')
-        search_terms.gsub!(/\br:/, 'repo:')
+        replacements = [
+          [%r{(\S+)/(\S+)}, 'user:\1 \2'],
+          [/\bu\w*:(\w+)/, 'user:\1'],
+          [/\bl\w*:(\w+)/, 'language:\1'],
+          [/\bin?:r\w*/, 'in:readme'],
+          [/\bin?:t\w*/, 'in:topics'],
+          [/\bin?:d\w*/, 'in:description'],
+          [/\bin?:(t(itle)?|n(ame)?)/, 'in:name'],
+          [/\br:/, 'repo:']
+        ]
+
+        replacements.each { |r| search_terms.gsub!(r[0], r[1]) }
 
         search_terms += ' in:title' unless search_terms =~ /(in|user|repo):/
 

data/lib/searchlink/string.rb

@@ -1,487 +1,489 @@
-# String helpers
-class ::String
-  # Scrub invalid characters from string
-  def scrub
-    encode('utf-16', invalid: :replace).encode('utf-8').gsub(/\u00A0/, ' ')
-  end
-
-  # @see #scrub
-  def scrub!
-    replace scrub
-  end
+module SL
+  # String helpers
+  class ::String
+    # Scrub invalid characters from string
+    def scrubup
+      encode('utf-16', invalid: :replace).encode('utf-8').gsub(/\u00A0/, ' ')
+    end
 
-  # URL Encode string
-  #
-  # @return     [String] url encoded string
-  #
-  def url_encode
-    ERB::Util.url_encode(gsub(/%22/, '"'))
-  end
+    # @see #scrub
+    def scrubup!
+      replace scrub
+    end
 
-  def url_decode
-    CGI.unescape(self)
-  end
+    # URL Encode string
+    #
+    # @return     [String] url encoded string
+    #
+    def url_encode
+      ERB::Util.url_encode(gsub(/%22/, '"'))
+    end
 
-  ##
-  ## Adds ?: to any parentheticals in a regular expression
-  ## to avoid match groups
-  ##
-  ## @return     [String] modified regular expression
-  ##
-  def normalize_trigger
-    gsub(/\((?!\?:)/, '(?:').gsub(/(^(\^|\\A)|(\$|\\Z)$)/, '').downcase
-  end
+    def url_decode
+      CGI.unescape(self)
+    end
 
-  ##
-  ## Generate a spacer based on character widths for help dialog display
-  ##
-  ## @return     [String] string containing tabs
-  ##
-  def spacer
-    len = length
-    scan(/[mwv]/).each { len += 1 }
-    scan(/t/).each { len -= 1 }
-    case len
-    when 0..3
-      "\t\t"
-    when 4..12
-      " \t"
+    ##
+    ## Adds ?: to any parentheticals in a regular expression
+    ## to avoid match groups
+    ##
+    ## @return     [String] modified regular expression
+    ##
+    def normalize_trigger
+      gsub(/\((?!\?:)/, '(?:').gsub(/(^(\^|\\A)|(\$|\\Z)$)/, '').downcase
     end
-  end
 
-  # parse command line flags into long options
-  def parse_flags
-    gsub(/(\+\+|--)([dirtvs]+)\b/) do
-      m = Regexp.last_match
-      bool = m[1] == '++' ? '' : 'no-'
-      output = ' '
-      m[2].split('').each do |arg|
-        output += case arg
-                  when 'd'
-                    "--#{bool}debug "
-                  when 'i'
-                    "--#{bool}inline "
-                  when 'r'
-                    "--#{bool}prefix_random "
-                  when 't'
-                    "--#{bool}include_titles "
-                  when 'v'
-                    "--#{bool}validate_links "
-                  when 's'
-                    "--#{bool}remove_seo "
-                  else
-                    ''
-                  end
+    ##
+    ## Generate a spacer based on character widths for help dialog display
+    ##
+    ## @return     [String] string containing tabs
+    ##
+    def spacer
+      len = length
+      scan(/[mwv]/).each { len += 1 }
+      scan(/t/).each { len -= 1 }
+      case len
+      when 0..3
+        "\t\t"
+      when 4..12
+        " \t"
       end
+    end
 
-      output
-    end.gsub(/ +/, ' ')
-  end
+    # parse command line flags into long options
+    def parse_flags
+      gsub(/(\+\+|--)([dirtvs]+)\b/) do
+        m = Regexp.last_match
+        bool = m[1] == '++' ? '' : 'no-'
+        output = ' '
+        m[2].split('').each do |arg|
+          output += case arg
+                    when 'd'
+                      "--#{bool}debug "
+                    when 'i'
+                      "--#{bool}inline "
+                    when 'r'
+                      "--#{bool}prefix_random "
+                    when 't'
+                      "--#{bool}include_titles "
+                    when 'v'
+                      "--#{bool}validate_links "
+                    when 's'
+                      "--#{bool}remove_seo "
+                    else
+                      ''
+                    end
+        end
 
-  def parse_flags!
-    replace parse_flags
-  end
+        output
+      end.gsub(/ +/, ' ')
+    end
 
-  ##
-  ## Convert file-myfile-rb to myfile.rb
-  ##
-  ## @return     { description_of_the_return_value }
-  ##
-  def fix_gist_file
-    sub(/^file-/, '').sub(/-([^\-]+)$/, '.\1')
-  end
+    def parse_flags!
+      replace parse_flags
+    end
 
-  # Turn a string into a slug, removing spaces and
-  # non-alphanumeric characters
-  #
-  # @return     [String] slugified string
-  #
-  def slugify
-    downcase.gsub(/[^a-z0-9_]/i, '-').gsub(/-+/, '-').sub(/-?$/, '')
-  end
+    ##
+    ## Convert file-myfile-rb to myfile.rb
+    ##
+    ## @return     { description_of_the_return_value }
+    ##
+    def fix_gist_file
+      sub(/^file-/, '').sub(/-([^\-]+)$/, '.\1')
+    end
 
-  # Destructive slugify
-  # @see #slugify
-  def slugify!
-    replace slugify
-  end
+    # Turn a string into a slug, removing spaces and
+    # non-alphanumeric characters
+    #
+    # @return     [String] slugified string
+    #
+    def slugify
+      downcase.gsub(/[^a-z0-9_]/i, '-').gsub(/-+/, '-').sub(/-?$/, '')
+    end
 
-  ##
-  ## Remove newlines, escape quotes, and remove Google
-  ## Analytics strings
-  ##
-  ## @return     [String] cleaned URL/String
-  ##
-  def clean
-    gsub(/\n+/, ' ')
-      .gsub(/"/, '&quot')
-      .gsub(/\|/, '-')
-      .gsub(/([&?]utm_[scm].+=[^&\s!,.)\]]++?)+(&.*)/, '\2')
-      .sub(/\?&/, '').strip
-  end
+    # Destructive slugify
+    # @see #slugify
+    def slugify!
+      replace slugify
+    end
 
-  # convert itunes to apple music link
-  #
-  # @return [String] apple music link
-  def to_am
-    input = dup
-    input.sub!(%r{/itunes\.apple\.com}, 'geo.itunes.apple.com')
-    append = input =~ %r{\?[^/]+=} ? '&app=music' : '?app=music'
-    input + append
-  end
+    ##
+    ## Remove newlines, escape quotes, and remove Google
+    ## Analytics strings
+    ##
+    ## @return     [String] cleaned URL/String
+    ##
+    def clean
+      gsub(/\n+/, ' ')
+        .gsub(/"/, '&quot')
+        .gsub(/\|/, '-')
+        .gsub(/([&?]utm_[scm].+=[^&\s!,.)\]]++?)+(&.*)/, '\2')
+        .sub(/\?&/, '').strip
+    end
 
-  ##
-  ## Remove the protocol from a URL
-  ##
-  ## @return     [String] just hostname and path of URL
-  ##
-  def remove_protocol
-    sub(%r{^(https?|s?ftp|file)://}, '')
-  end
+    # convert itunes to apple music link
+    #
+    # @return [String] apple music link
+    def to_am
+      input = dup
+      input.sub!(%r{/itunes\.apple\.com}, 'geo.itunes.apple.com')
+      append = input =~ %r{\?[^/]+=} ? '&app=music' : '?app=music'
+      input + append
+    end
 
-  ##
-  ## Return just the path of a URL
-  ##
-  ## @return     [String] The path.
-  ##
-  def url_path
-    URI.parse(self).path
-  end
+    ##
+    ## Remove the protocol from a URL
+    ##
+    ## @return     [String] just hostname and path of URL
+    ##
+    def remove_protocol
+      sub(%r{^(https?|s?ftp|file)://}, '')
+    end
 
-  # Extract the most relevant portions from a URL path
-  #
-  # @return     [Array] array of relevant path elements
-  #
-  def path_elements
-    path = url_path
-    # force trailing slash
-    path.sub!(%r{/?$}, '/')
-    # remove last path element
-    path.sub!(%r{/[^/]+[.\-][^/]+/$}, '')
-    # remove starting/ending slashes
-    path.gsub!(%r{(^/|/$)}, '')
-    # split at slashes, delete sections that are shorter
-    # than 5 characters or only consist of numbers
-    path.split(%r{/}).delete_if { |section| section =~ /^\d+$/ || section.length < 5 }
-  end
+    ##
+    ## Return just the path of a URL
+    ##
+    ## @return     [String] The path.
+    ##
+    def url_path
+      URI.parse(self).path
+    end
 
-  ##
-  ## Destructive punctuation close
-  ##
-  ## @see        #close_punctuation
-  ##
-  def close_punctuation!
-    replace close_punctuation
-  end
+    # Extract the most relevant portions from a URL path
+    #
+    # @return     [Array] array of relevant path elements
+    #
+    def path_elements
+      path = url_path
+      # force trailing slash
+      path.sub!(%r{/?$}, '/')
+      # remove last path element
+      path.sub!(%r{/[^/]+[.\-][^/]+/$}, '')
+      # remove starting/ending slashes
+      path.gsub!(%r{(^/|/$)}, '')
+      # split at slashes, delete sections that are shorter
+      # than 5 characters or only consist of numbers
+      path.split(%r{/}).delete_if { |section| section =~ /^\d+$/ || section.length < 5 }
+    end
 
-  ##
-  ## Complete incomplete punctuation pairs
-  ##
-  ## @return     [String] string with all punctuation
-  ##             properly paired
-  ##
-  def close_punctuation
-    return self unless self =~ /[“‘\[(<]/
-
-    words = split(/\s+/)
-
-    punct_chars = {
-      '“' => '”',
-      '‘' => '’',
-      '[' => ']',
-      '(' => ')',
-      '<' => '>'
-    }
-
-    left_punct = []
-
-    words.each do |w|
-      punct_chars.each do |k, v|
-        left_punct.push(k) if w =~ /#{Regexp.escape(k)}/
-        left_punct.delete_at(left_punct.rindex(k)) if w =~ /#{Regexp.escape(v)}/
-      end
+    ##
+    ## Destructive punctuation close
+    ##
+    ## @see        #close_punctuation
+    ##
+    def close_punctuation!
+      replace close_punctuation
     end
 
-    tail = ''
-    left_punct.reverse.each { |c| tail += punct_chars[c] }
+    ##
+    ## Complete incomplete punctuation pairs
+    ##
+    ## @return     [String] string with all punctuation
+    ##             properly paired
+    ##
+    def close_punctuation
+      return self unless self =~ /[“‘\[(<]/
+
+      words = split(/\s+/)
+
+      punct_chars = {
+        '“' => '”',
+        '‘' => '’',
+        '[' => ']',
+        '(' => ')',
+        '<' => '>'
+      }
+
+      left_punct = []
+
+      words.each do |w|
+        punct_chars.each do |k, v|
+          left_punct.push(k) if w =~ /#{Regexp.escape(k)}/
+          left_punct.delete_at(left_punct.rindex(k)) if w =~ /#{Regexp.escape(v)}/
+        end
+      end
 
-    gsub(/[^a-z)\]’”.…]+$/i, '...').strip + tail
-  end
+      tail = ''
+      left_punct.reverse.each { |c| tail += punct_chars[c] }
 
-  ##
-  ## Destructively remove SEO elements from a title
-  ##
-  ## @param      url   The url of the page from which the
-  ##                   title came
-  ##
-  ## @see        #remove_seo
-  ##
-  def remove_seo!(url)
-    replace remove_seo(url)
-  end
+      gsub(/[^a-z)\]’”.…]+$/i, '...').strip + tail
+    end
 
-  ##
-  ## Remove SEO elements from a title
-  ##
-  ## @param      url   The url of the page from which the title came
-  ##
-  ## @return     [String] cleaned title
-  ##
-  def remove_seo(url)
-    title = dup
-    url = URI.parse(url)
-    host = url.hostname
-    unless host
-      return self unless SL.config['debug']
+    ##
+    ## Destructively remove SEO elements from a title
+    ##
+    ## @param      url   The url of the page from which the
+    ##                   title came
+    ##
+    ## @see        #remove_seo
+    ##
+    def remove_seo!(url)
+      replace remove_seo(url)
+    end
 
-      SL.add_error('Invalid URL', "Could not remove SEO for #{url}")
-      return self
+    ##
+    ## Remove SEO elements from a title
+    ##
+    ## @param      url   The url of the page from which the title came
+    ##
+    ## @return     [String] cleaned title
+    ##
+    def remove_seo(url)
+      title = dup
+      url = URI.parse(url)
+      host = url.hostname
+      unless host
+        return self unless SL.config['debug']
+
+        SL.add_error('Invalid URL', "Could not remove SEO for #{url}")
+        return self
 
-    end
+      end
 
-    path = url.path
-    root_page = path =~ %r{^/?$} ? true : false
+      path = url.path
+      root_page = path =~ %r{^/?$} ? true : false
 
-    title.gsub!(/\s*(&ndash;|&mdash;)\s*/, ' - ')
-    title.gsub!(/&[lr]dquo;/, '"')
-    title.gsub!(/&[lr]dquo;/, "'")
-    title.gsub!(/&#8211;/, ' — ')
-    title = CGI.unescapeHTML(title)
-    title.gsub!(/ +/, ' ')
+      title.gsub!(/\s*(&ndash;|&mdash;)\s*/, ' - ')
+      title.gsub!(/&[lr]dquo;/, '"')
+      title.gsub!(/&[lr]dquo;/, "'")
+      title.gsub!(/&#8211;/, ' — ')
+      title = CGI.unescapeHTML(title)
+      title.gsub!(/ +/, ' ')
 
-    seo_title_separators = %w[| » « — – - · :]
+      seo_title_separators = %w[| » « — – - · :]
 
-    begin
-      re_parts = []
+      begin
+        re_parts = []
 
-      host_parts = host.sub(/(?:www\.)?(.*?)\.[^.]+$/, '\1').split(/\./).delete_if { |p| p.length < 3 }
-      h_re = !host_parts.empty? ? host_parts.map { |seg| seg.downcase.split(//).join('.?') }.join('|') : ''
-      re_parts.push(h_re) unless h_re.empty?
+        host_parts = host.sub(/(?:www\.)?(.*?)\.[^.]+$/, '\1').split(/\./).delete_if { |p| p.length < 3 }
+        h_re = !host_parts.empty? ? host_parts.map { |seg| seg.downcase.split(//).join('.?') }.join('|') : ''
+        re_parts.push(h_re) unless h_re.empty?
 
-      # p_re = path.path_elements.map{|seg| seg.downcase.split(//).join('.?') }.join('|')
-      # re_parts.push(p_re) if p_re.length > 0
+        # p_re = path.path_elements.map{|seg| seg.downcase.split(//).join('.?') }.join('|')
+        # re_parts.push(p_re) if p_re.length > 0
 
-      site_re = "(#{re_parts.join('|')})"
+        site_re = "(#{re_parts.join('|')})"
 
-      dead_switch = 0
+        dead_switch = 0
 
-      while title.downcase.gsub(/[^a-z]/i, '') =~ /#{site_re}/i
+        while title.downcase.gsub(/[^a-z]/i, '') =~ /#{site_re}/i
 
-        break if dead_switch > 5
+          break if dead_switch > 5
 
-        seo_title_separators.each_with_index do |sep, i|
-          parts = title.split(/ *#{Regexp.escape(sep)} +/)
+          seo_title_separators.each_with_index do |sep, i|
+            parts = title.split(/ *#{Regexp.escape(sep)} +/)
 
-          next if parts.length == 1
+            next if parts.length == 1
 
-          remaining_separators = seo_title_separators[i..].map { |s| Regexp.escape(s) }.join('')
-          seps = Regexp.new("^[^#{remaining_separators}]+$")
+            remaining_separators = seo_title_separators[i..].map { |s| Regexp.escape(s) }.join('')
+            seps = Regexp.new("^[^#{remaining_separators}]+$")
 
-          longest = parts.longest_element.strip
+            longest = parts.longest_element.strip
 
-          unless parts.empty?
-            parts.delete_if do |pt|
-              compressed = pt.strip.downcase.gsub(/[^a-z]/i, '')
-              compressed =~ /#{site_re}/ && pt =~ seps ? !root_page : false
+            unless parts.empty?
+              parts.delete_if do |pt|
+                compressed = pt.strip.downcase.gsub(/[^a-z]/i, '')
+                compressed =~ /#{site_re}/ && pt =~ seps ? !root_page : false
+              end
             end
-          end
 
-          title = if parts.empty?
-                    longest
-                  elsif parts.length < 2
-                    parts.join(sep)
-                  elsif parts.length > 2
-                    parts.longest_element.strip
-                  else
-                    parts.join(sep)
-                  end
+            title = if parts.empty?
+                      longest
+                    elsif parts.length < 2
+                      parts.join(sep)
+                    elsif parts.length > 2
+                      parts.longest_element.strip
+                    else
+                      parts.join(sep)
+                    end
+          end
+          dead_switch += 1
         end
-        dead_switch += 1
+      rescue StandardError => e
+        return self unless SL.config['debug']
+
+        SL.add_error("Error SEO processing title for #{url}", e)
+        return self
       end
-    rescue StandardError => e
-      return self unless SL.config['debug']
 
-      SL.add_error("Error SEO processing title for #{url}", e)
-      return self
-    end
+      seps = Regexp.new(" *[#{seo_title_separators.map { |s| Regexp.escape(s) }.join('')}] +")
+      if title =~ seps
+        seo_parts = title.split(seps)
+        title = seo_parts.longest_element.strip if seo_parts.length.positive?
+      end
 
-    seps = Regexp.new(" *[#{seo_title_separators.map { |s| Regexp.escape(s) }.join('')}] +")
-    if title =~ seps
-      seo_parts = title.split(seps)
-      title = seo_parts.longest_element.strip if seo_parts.length.positive?
+      title && title.length > 5 ? title.gsub(/\s+/, ' ') : CGI.unescapeHTML(self)
     end
 
-    title && title.length > 5 ? title.gsub(/\s+/, ' ') : CGI.unescapeHTML(self)
-  end
+    ##
+    ## Truncate in place
+    ##
+    ## @see        #truncate
+    ##
+    ## @param      max   [Number]  The maximum length
+    ##
+    def truncate!(max)
+      replace truncate(max)
+    end
 
-  ##
-  ## Truncate in place
-  ##
-  ## @see        #truncate
-  ##
-  ## @param      max   [Number]  The maximum length
-  ##
-  def truncate!(max)
-    replace truncate(max)
-  end
+    ##
+    ## Truncate string to given length, preserving words
+    ##
+    ## @param      max   [Number]  The maximum length
+    ##
+    def truncate(max)
+      return self if length < max
 
-  ##
-  ## Truncate string to given length, preserving words
-  ##
-  ## @param      max   [Number]  The maximum length
-  ##
-  def truncate(max)
-    return self if length < max
+      trunc_title = []
 
-    trunc_title = []
+      words = split(/\s+/)
+      words.each do |word|
+        break unless trunc_title.join(' ').length.close_punctuation + word.length <= max
 
-    words = split(/\s+/)
-    words.each do |word|
-      break unless trunc_title.join(' ').length.close_punctuation + word.length <= max
+        trunc_title << word
+      end
 
-      trunc_title << word
+      trunc_title.empty? ? words[0] : trunc_title.join(' ')
     end
 
-    trunc_title.empty? ? words[0] : trunc_title.join(' ')
-  end
+    ##
+    ## Test an AppleScript response, substituting nil for
+    ## 'Missing Value'
+    ##
+    ## @return     [Nil, String] nil if string is
+    ##             "missing value"
+    ##
+    def nil_if_missing
+      return nil if self =~ /missing value/
+
+      self
+    end
 
-  ##
-  ## Test an AppleScript response, substituting nil for
-  ## 'Missing Value'
-  ##
-  ## @return     [Nil, String] nil if string is
-  ##             "missing value"
-  ##
-  def nil_if_missing
-    return nil if self =~ /missing value/
-
-    self
-  end
+    ##
+    ## Score string based on number of matches, 0 - 10
+    ##
+    ## @param      terms       [String]      The terms to
+    ##                         match
+    ## @param      separator   [String]  The word separator
+    ## @param      start_word  [Boolean] Require match to be
+    ##                         at beginning of word
+    ##
+    def matches_score(terms, separator: ' ', start_word: true)
+      matched = 0
+      regexes = terms.to_rx_array(separator: separator, start_word: start_word)
+
+      regexes.each do |rx|
+        matched += 1 if self =~ rx
+      end
 
-  ##
-  ## Score string based on number of matches, 0 - 10
-  ##
-  ## @param      terms       [String]      The terms to
-  ##                         match
-  ## @param      separator   [String]  The word separator
-  ## @param      start_word  [Boolean] Require match to be
-  ##                         at beginning of word
-  ##
-  def matches_score(terms, separator: ' ', start_word: true)
-    matched = 0
-    regexes = terms.to_rx_array(separator: separator, start_word: start_word)
+      return 0 if matched.zero?
 
-    regexes.each do |rx|
-      matched += 1 if self =~ rx
+      ((matched / regexes.count.to_f) * 10).round(3)
     end
 
-    return 0 if matched.zero?
-
-    ((matched / regexes.count.to_f) * 10).round(3)
-  end
-
-  def matches_fuzzy(terms, separator: ' ', start_word: true, threshhold: 5)
-    sources = split(/(#{separator})+/)
-    words = terms.split(/(#{separator})+/)
-    matches = 0
-    sources.each do |src|
-      words.each do |term|
-        d = src.distance(term)
-        matches += 1 if d <= threshhold
+    def matches_fuzzy(terms, separator: ' ', start_word: true, threshhold: 5)
+      sources = split(/(#{separator})+/)
+      words = terms.split(/(#{separator})+/)
+      matches = 0
+      sources.each do |src|
+        words.each do |term|
+          d = src.distance(term)
+          matches += 1 if d <= threshhold
+        end
       end
-    end
 
-    ((matches / words.count.to_f) * 10).round(3)
-  end
+      ((matches / words.count.to_f) * 10).round(3)
+    end
 
-  def distance(t)
-    s = self.dup
-    m = s.length
-    n = t.length
-    return m if n == 0
-    return n if m == 0
-    d = Array.new(m+1) {Array.new(n+1)}
-
-    (0..m).each {|i| d[i][0] = i}
-    (0..n).each {|j| d[0][j] = j}
-    (1..n).each do |j|
-      (1..m).each do |i|
-        d[i][j] = if s[i-1] == t[j-1]  # adjust index into string
-                    d[i-1][j-1]       # no operation required
-                  else
-                    [ d[i-1][j]+1,    # deletion
-                      d[i][j-1]+1,    # insertion
-                      d[i-1][j-1]+1,  # substitution
-                    ].min
-                  end
+    def distance(t)
+      s = self.dup
+      m = s.length
+      n = t.length
+      return m if n == 0
+      return n if m == 0
+      d = Array.new(m+1) {Array.new(n+1)}
+
+      (0..m).each {|i| d[i][0] = i}
+      (0..n).each {|j| d[0][j] = j}
+      (1..n).each do |j|
+        (1..m).each do |i|
+          d[i][j] = if s[i-1] == t[j-1]  # adjust index into string
+                      d[i-1][j-1]       # no operation required
+                    else
+                      [ d[i-1][j]+1,    # deletion
+                        d[i][j-1]+1,    # insertion
+                        d[i-1][j-1]+1,  # substitution
+                      ].min
+                    end
+        end
       end
+      d[m][n]
     end
-    d[m][n]
-  end
 
-  ##
-  ## Test if self contains exactl match for string (case insensitive)
-  ##
-  ## @param      string [String] The string to match
-  ##
-  def matches_exact(string)
-    comp = gsub(/[^a-z0-9 ]/i, '')
-    comp =~ /\b#{string.gsub(/[^a-z0-9 ]/i, '').split(/ +/).map { |s| Regexp.escape(s) }.join(' +')}/i
-  end
+    ##
+    ## Test if self contains exactl match for string (case insensitive)
+    ##
+    ## @param      string [String] The string to match
+    ##
+    def matches_exact(string)
+      comp = gsub(/[^a-z0-9 ]/i, '')
+      comp =~ /\b#{string.gsub(/[^a-z0-9 ]/i, '').split(/ +/).map { |s| Regexp.escape(s) }.join(' +')}/i
+    end
 
-  ##
-  ## Test that self does not contain any of terms
-  ##
-  ## @param      terms [String] The terms to test
-  ##
-  def matches_none(terms)
-    rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
-    rx_terms.each { |rx| return false if gsub(/[^a-z0-9 ]/i, '') =~ rx }
-    true
-  end
+    ##
+    ## Test that self does not contain any of terms
+    ##
+    ## @param      terms [String] The terms to test
+    ##
+    def matches_none(terms)
+      rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
+      rx_terms.each { |rx| return false if gsub(/[^a-z0-9 ]/i, '') =~ rx }
+      true
+    end
 
-  ##
-  ## Test if self contains any of terms
-  ##
-  ## @param      terms [String] The terms to test
-  ##
-  def matches_any(terms)
-    rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
-    rx_terms.each { |rx| return true if gsub(/[^a-z0-9 ]/i, '') =~ rx }
-    false
-  end
+    ##
+    ## Test if self contains any of terms
+    ##
+    ## @param      terms [String] The terms to test
+    ##
+    def matches_any(terms)
+      rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
+      rx_terms.each { |rx| return true if gsub(/[^a-z0-9 ]/i, '') =~ rx }
+      false
+    end
 
-  ##
-  ## Test that self matches every word in terms
-  ##
-  ## @param      terms [String] The terms to test
-  ##
-  def matches_all(terms)
-    rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
-    rx_terms.each { |rx| return false unless gsub(/[^a-z0-9 ]/i, '') =~ rx }
-    true
-  end
+    ##
+    ## Test that self matches every word in terms
+    ##
+    ## @param      terms [String] The terms to test
+    ##
+    def matches_all(terms)
+      rx_terms = terms.is_a?(String) ? terms.to_rx_array : terms
+      rx_terms.each { |rx| return false unless gsub(/[^a-z0-9 ]/i, '') =~ rx }
+      true
+    end
 
-  ##
-  ## Break a string into an array of Regexps
-  ##
-  ## @param      separator   [String]  The word separator
-  ## @param      start_word  [Boolean] Require matches at
-  ##                         start of word
-  ##
-  ## @return     [Array] array of regular expressions
-  ##
-  def to_rx_array(separator: ' ', start_word: true)
-    bound = start_word ? '\b' : ''
-    str = gsub(/(#{separator})+/, separator)
-    str.split(/#{separator}/).map { |arg| /#{bound}#{arg.gsub(/[^a-z0-9]/i, '.?')}/i }
-  end
+    ##
+    ## Break a string into an array of Regexps
+    ##
+    ## @param      separator   [String]  The word separator
+    ## @param      start_word  [Boolean] Require matches at
+    ##                         start of word
+    ##
+    ## @return     [Array] array of regular expressions
+    ##
+    def to_rx_array(separator: ' ', start_word: true)
+      bound = start_word ? '\b' : ''
+      str = gsub(/(#{separator})+/, separator)
+      str.split(/#{separator}/).map { |arg| /#{bound}#{arg.gsub(/[^a-z0-9]/i, '.?')}/i }
+    end
 
-  ##
-  ## Indent each line of string with 4 spaces
-  ##
-  ## @return [String] indented string
-  def code_indent
-    split(/\n/).map { |l| "    #{l}" }.join("\n")
+    ##
+    ## Indent each line of string with 4 spaces
+    ##
+    ## @return [String] indented string
+    def code_indent
+      split(/\n/).map { |l| "    #{l}" }.join("\n")
+    end
   end
 end

data/lib/searchlink/version.rb

@@ -1,11 +1,14 @@
 module SL
-  VERSION = '2.3.63'
+  VERSION = '2.3.65'
 end
 
 module SL
   class << self
     def version_check
-      cachefile = File.expand_path('~/.searchlink_update_check')
+      cachefile = File.expand_path('~/.config/searchlink/cache/update.txt')
+
+      FileUtils.mkdir_p(File.dirname(cachefile)) unless File.directory?(File.dirname(cachefile))
+
       if File.exist?(cachefile)
         last_check, latest_tag = IO.read(cachefile).strip.split(/\|/)
         last_time = Time.parse(last_check)
@@ -22,12 +25,14 @@ module SL
       latest_tag ||= SL::VERSION
       latest = SemVer.new(latest_tag)
       current = SemVer.new(SL::VERSION)
-      
-      File.open(cachefile, 'w') { |f| f.puts("#{last_time.strftime('%c')}|#{latest.to_s}") }
 
-      return "SearchLink v#{current.to_s}, #{latest.to_s} available. Run 'update' to download." if latest_tag && current.older_than(latest)
+      File.open(cachefile, 'w') { |f| f.puts("#{last_time.strftime('%c')}|#{latest}") }
+
+      if latest_tag && current.older_than(latest)
+        return "SearchLink v#{current}, #{latest} available. Run 'update' to download."
+      end
 
-      "SearchLink v#{current.to_s}"
+      "SearchLink v#{current}"
     end
 
     # Check for a newer version than local copy using GitHub release tag
@@ -63,6 +68,11 @@ module SL
     end
 
     def update_searchlink
+      if %x{uname}.strip !~ /Darwin/
+        add_output('Auto updating only available on macOS')
+        return
+      end
+
       new_version = SL.new_version?
       if new_version
         folder = File.expand_path('~/Downloads')

data/lib/tokens.rb

@@ -1,3 +1,3 @@
 module Secrets
-  GH_AUTH_TOKEN = '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'
+  GH_AUTH_TOKEN = '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'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchlink
 version: !ruby/object:Gem::Version
-  version: 2.3.63
+  version: 2.3.65
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-29 00:00:00.000000000 Z
+date: 2024-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler