searchlink 2.3.59

data/lib/searchlink/url.rb

@@ -0,0 +1,153 @@
+module SL
+  module URL
+    class << self
+      # Validates that a link exists and returns 200
+      def valid_link?(uri_str, limit = 5)
+        return false unless uri_str
+
+        SL.notify('Validating', uri_str)
+        return false if limit.zero?
+
+        url = URI(uri_str)
+        return true unless url.scheme
+
+        url.path = '/' if url.path == ''
+        # response = Net::HTTP.get_response(URI(uri_str))
+        response = false
+
+        Net::HTTP.start(url.host, url.port, use_ssl: url.scheme == 'https') do |http|
+          response = http.request_head(url.path)
+        end
+
+        case response
+        when Net::HTTPMethodNotAllowed, Net::HTTPServiceUnavailable
+          unless /amazon\.com/ =~ url.host
+            SL.add_error('link validation', "Validation blocked: #{uri_str} (#{e})")
+          end
+          SL.notify('Error validating', uri_str)
+          true
+        when Net::HTTPSuccess
+          true
+        when Net::HTTPRedirection
+          location = response['location']
+          valid_link?(location, limit - 1)
+        else
+          SL.notify('Error validating', uri_str)
+          false
+        end
+      rescue StandardError => e
+        SL.notify('Error validating', uri_str)
+        SL.add_error('link validation', "Possibly invalid => #{uri_str} (#{e})")
+        true
+      end
+
+      def url?(input)
+        input =~ %r{^(#.*|https?://\S+|/\S+|\S+/|[^!]\S+\.\S+)(\s+".*?")?$}
+      end
+
+      def only_url?(input)
+        input =~ %r{(?i)^((http|https)://)?([\w\-_]+(\.[\w\-_]+)+)([\w\-.,@?^=%&amp;:/~+#]*[\w\-@^=%&amp;/~+#])?$}
+      end
+
+      def ref_title_for_url(url)
+        url = URI.parse(url) if url.is_a?(String)
+
+        parts = url.hostname.split(/\./)
+        domain = if parts.count > 1
+                   parts.slice(-2, 1).join('')
+                 else
+                   parts.join('')
+                 end
+
+        path = url.path.split(%r{/}).last
+        if path
+          path.gsub!(/-/, ' ').gsub!(/\.\w{2-4}$/, '')
+        else
+          path = domain
+        end
+
+        path.length > domain.length ? path : domain
+      end
+
+      def url_to_link(url, type)
+        input = url.dup
+
+        if only_url?(input)
+          input.sub!(%r{(?mi)^(?!https?://)(.*?)$}, 'https://\1')
+          url = URI.parse(input.downcase)
+
+          title = if type == :ref_title
+                    ref_title_for_url(url)
+                  else
+                    title(url.to_s) || input.sub(%r{^https?://}, '')
+                  end
+
+          return [url.to_s, title] if url.hostname
+        end
+        false
+      end
+
+      def amazon_affiliatize(url, amazon_partner)
+        return url if amazon_partner.nil? || amazon_partner.empty?
+
+        unless url =~ %r{https?://(?<subdomain>.*?)amazon.com/(?:(?<title>.*?)/)?(?<type>[dg])p/(?<id>[^?]+)}
+          return [url, '']
+        end
+
+        m = Regexp.last_match
+        sd = m['subdomain']
+        title = m['title'].gsub(/-/, ' ')
+        t = m['type']
+        id = m['id']
+        ["https://#{sd}amazon.com/#{t}p/#{id}/?ref=as_li_ss_tl&ie=UTF8&linkCode=sl1&tag=#{amazon_partner}", title]
+      end
+
+      def title(url)
+        title = nil
+
+        ## Gather proving too inexact
+        # gather = false
+        # ['/usr/local/bin', '/opt/homebrew/bin'].each do |root|
+        #   if File.exist?(File.join(root, 'gather')) && File.executable?(File.join(root, 'gather'))
+        #     gather = File.join(root, 'gather')
+        #     break
+        #   end
+        # end
+
+        # if gather
+        #   cmd = %(#{gather} --title-only '#{url.strip}' --fallback-title 'Unknown')
+        #   title = SL::Util.exec_with_timeout(cmd, 15)
+        #   if title
+        #     title = title.strip.gsub(/\n+/, ' ').gsub(/ +/, ' ')
+        #     title.remove_seo!(url) if SL.config['remove_seo']
+        #     return title.remove_protocol
+        #   else
+        #     SL.add_error('Error retrieving title', "Gather timed out on #{url}")
+        #     SL.notify('Error retrieving title', 'Gather timed out')
+        #   end
+        # end
+
+        begin
+          page = Curl::Html.new(url)
+
+          title = page.title || nil
+
+          if title.nil? || title =~ /^\s*$/
+            SL.add_error('Title not found', "Warning: missing title for #{url.strip}")
+            title = url.gsub(%r{(^https?://|/.*$)}, '').gsub(/-/, ' ').strip
+          else
+            title = title.gsub(/\n/, ' ').gsub(/\s+/, ' ').strip # .sub(/[^a-z]*$/i,'')
+            title.remove_seo!(url) if SL.config['remove_seo']
+          end
+          title.gsub!(/\|/, '—')
+          title.remove_seo!(url.strip) if SL.config['remove_seo']
+          title.remove_protocol
+        rescue StandardError
+          SL.add_error('Error retrieving title', "Error determining title for #{url.strip}")
+          warn "Error retrieving title for #{url.strip}"
+          url.remove_protocol
+        end
+      end
+    end
+  end
+end

data/lib/searchlink/util.rb

@@ -0,0 +1,87 @@
+module SL
+  module Util
+    class << self
+      ## Execute system command with deadman's switch
+      ##
+      ## <https://stackoverflow.com/questions/8292031/ruby-timeouts-and-system-commands>
+      ## <https://stackoverflow.com/questions/12189904/fork-child-process-with-timeout-and-capture-output>
+      ##
+      ## @param      cmd      The command to execute
+      ## @param      timeout  The timeout
+      ##
+      ## @return     [String] STDOUT output
+      ##
+      def exec_with_timeout(cmd, timeout)
+        begin
+          # stdout, stderr pipes
+          rout, wout = IO.pipe
+          rerr, werr = IO.pipe
+          stdout, stderr = nil
+
+          pid = Process.spawn(cmd, pgroup: true, out: wout, err: werr)
+
+          Timeout.timeout(timeout) do
+            Process.waitpid(pid)
+
+            # close write ends so we can read from them
+            wout.close
+            werr.close
+
+            stdout = rout.readlines.join
+            stderr = rerr.readlines.join
+          end
+        rescue Timeout::Error
+          Process.kill(-9, pid)
+          Process.detach(pid)
+        ensure
+          wout.close unless wout.closed?
+          werr.close unless werr.closed?
+          # dispose the read ends of the pipes
+          rout.close
+          rerr.close
+        end
+
+        stdout&.strip
+      end
+
+      ##
+      ## Execute a search with deadman's switch
+      ##
+      ## @param      search   [Proc] The search command
+      ## @param      timeout  [Number] The timeout
+      ##
+      ## @return     [Array] url, title, link_text
+      ##
+      def search_with_timeout(search, timeout)
+        url = nil
+        title = nil
+        link_text = nil
+
+        begin
+          Timeout.timeout(timeout) do
+            url, title, link_text = search.call
+          end
+        rescue Timeout::Error
+          SL.add_error('Timeout', 'Search timed out')
+          url, title, link_text = false
+        end
+
+        [url, title, link_text]
+      end
+
+      ##
+      ## Get the path for a cache file
+      ##
+      ## @param      filename  [String]  The filename to
+      ##                       generate the cache for
+      ##
+      ## @return     [String] path to new cache file
+      ##
+      def cache_file_for(filename)
+        cache_folder = File.expand_path('~/.local/share/searchlink/cache')
+        FileUtils.mkdir_p(cache_folder) unless File.directory?(cache_folder)
+        File.join(cache_folder, filename.sub(/(\.cache)?$/, '.cache'))
+      end
+    end
+  end
+end

data/lib/searchlink/version.rb

@@ -0,0 +1,93 @@
+module SL
+  VERSION = '2.3.59'
+end
+
+module SL
+  class << self
+    def version_check
+      cachefile = File.expand_path('~/.searchlink_update_check')
+      if File.exist?(cachefile)
+        last_check, latest_tag = IO.read(cachefile).strip.split(/\|/)
+        last_time = Time.parse(last_check)
+      else
+        latest_tag = new_version?
+        last_time = Time.now
+      end
+
+      if last_time + (24 * 60 * 60) < Time.now
+        latest_tag = new_version?
+        last_time = Time.now
+      end
+
+      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)
+
+      "SearchLink v#{current.to_s}"
+    end
+
+    # Check for a newer version than local copy using GitHub release tag
+    #
+    # @return false if no new version, or semantic version of latest release
+    def new_version?
+      headers = {
+        'Accept' => 'application/vnd.github+json',
+        'X-GitHub-Api-Version' => '2022-11-28'
+      }
+      headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if defined? Secrets::GH_AUTH_TOKEN
+
+      url = 'https://api.github.com/repos/ttscoff/searchlink/releases/latest'
+      page = Curl::Json.new(url, headers: headers)
+      result = page.json
+
+      if result
+        latest_tag = result['tag_name']
+
+        return false unless latest_tag
+
+        return false if latest_tag =~ /^#{Regexp.escape(SL::VERSION)}$/
+
+        latest = SemVer.new(latest_tag)
+        current = SemVer.new(SL::VERSION)
+
+        return latest_tag if current.older_than(latest)
+      else
+        warn 'Check for new version failed.'
+      end
+
+      false
+    end
+
+    def update_searchlink
+      new_version = SL.new_version?
+      if new_version
+        folder = File.expand_path('~/Downloads')
+        services = File.expand_path('~/Library/Services')
+        dl = File.join(folder, 'SearchLink.zip')
+        curl = TTY::Which.which('curl')
+        `#{curl} -SsL -o "#{dl}" https://github.com/ttscoff/searchlink/releases/latest/download/SearchLink.zip`
+        Dir.chdir(folder)
+        `unzip -qo #{dl} -d #{folder}`
+        FileUtils.rm(dl)
+
+        ['SearchLink', 'SearchLink File', 'Jump to SearchLink Error'].each do |workflow|
+          wflow = "#{workflow}.workflow"
+          src = File.join(folder, 'SearchLink Services', wflow)
+          dest = File.join(services, wflow)
+          if File.exist?(src) && File.exist?(dest)
+            FileUtils.rm_rf(dest)
+            FileUtils.mv(src, dest, force: true)
+          end
+        end
+        add_output("Installed SearchLink #{new_version}")
+        FileUtils.rm_rf('SearchLink Services')
+      else
+        add_output('Already up to date.')
+      end
+    end
+  end
+end

data/lib/searchlink/which.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+# From <https://github.com/piotrmurach/tty-which/tree/master>
+# [MIT License](https://github.com/piotrmurach/tty-which/blob/master/LICENSE.txt)
+
+module TTY
+  module Which
+    VERSION = "0.5.0"
+  end # Which
+end # TTY
+
+module TTY
+  # A class responsible for finding an executable in the PATH
+  module Which
+    # Find an executable in a platform independent way
+    #
+    # @param [String] cmd
+    #   the command to search for
+    # @param [Array<String>] paths
+    #   the paths to look through
+    #
+    # @example
+    #   which("ruby")                 # => "/usr/local/bin/ruby"
+    #   which("/usr/local/bin/ruby")  # => "/usr/local/bin/ruby"
+    #   which("foo")                  # => nil
+    #
+    # @example
+    #   which("ruby", paths: ["/usr/locale/bin", "/usr/bin", "/bin"])
+    #
+    # @return [String, nil]
+    #   the absolute path to executable if found, `nil` otherwise
+    #
+    # @api public
+    def which(cmd, paths: search_paths)
+      if file_with_path?(cmd)
+        return cmd if executable_file?(cmd)
+
+        extensions.each do |ext|
+          exe = "#{cmd}#{ext}"
+          return ::File.absolute_path(exe) if executable_file?(exe)
+        end
+        return nil
+      end
+
+      paths.each do |path|
+        if file_with_exec_ext?(cmd)
+          exe = ::File.join(path, cmd)
+          return ::File.absolute_path(exe) if executable_file?(exe)
+        end
+        extensions.each do |ext|
+          exe = ::File.join(path, "#{cmd}#{ext}")
+          return ::File.absolute_path(exe) if executable_file?(exe)
+        end
+      end
+      nil
+    end
+    module_function :which
+
+    # Check if executable exists in the path
+    #
+    # @param [String] cmd
+    #   the executable to check
+    #
+    # @param [Array<String>] paths
+    #   paths to check
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def exist?(cmd, paths: search_paths)
+      !which(cmd, paths: paths).nil?
+    end
+    module_function :exist?
+
+    # Find default system paths
+    #
+    # @param [String] path
+    #   the path to search through
+    #
+    # @example
+    #   search_paths("/usr/local/bin:/bin")
+    #   # => ["/bin"]
+    #
+    # @return [Array<String>]
+    #   the array of paths to search
+    #
+    # @api private
+    def search_paths(path = ENV["PATH"])
+      paths = if path && !path.empty?
+                path.split(::File::PATH_SEPARATOR)
+              else
+                %w[/usr/local/bin /usr/ucb /usr/bin /bin /opt/homebrew/bin]
+              end
+      paths.select(&Dir.method(:exist?))
+    end
+    module_function :search_paths
+
+    # All possible file extensions
+    #
+    # @example
+    #   extensions(".exe;cmd;.bat")
+    #   # => [".exe", ".bat"]
+    #
+    # @param [String] path_ext
+    #   a string of semicolon separated filename extensions
+    #
+    # @return [Array<String>]
+    #   an array with valid file extensions
+    #
+    # @api private
+    def extensions(path_ext = ENV["PATHEXT"])
+      return [""] unless path_ext
+
+      path_ext.split(::File::PATH_SEPARATOR).select { |part| part.include?(".") }
+    end
+    module_function :extensions
+
+    # Determines if filename is an executable file
+    #
+    # @example Basic usage
+    #   executable_file?("/usr/bin/less") # => true
+    #
+    # @example Executable in directory
+    #   executable_file?("less", "/usr/bin") # => true
+    #   executable_file?("less", "/usr") # => false
+    #
+    # @param [String] filename
+    #   the path to file
+    # @param [String] dir
+    #   the directory within which to search for filename
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def executable_file?(filename, dir = nil)
+      path = ::File.join(dir, filename) if dir
+      path ||= filename
+      ::File.file?(path) && ::File.executable?(path)
+    end
+    module_function :executable_file?
+
+    # Check if command itself has executable extension
+    #
+    # @param [String] filename
+    #   the path to executable file
+    #
+    # @example
+    #   file_with_exec_ext?("file.bat")
+    #   # => true
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def file_with_exec_ext?(filename)
+      extension = ::File.extname(filename)
+      return false if extension.empty?
+
+      extensions.any? { |ext| extension.casecmp(ext).zero? }
+    end
+    module_function :file_with_exec_ext?
+
+    # Check if executable file is part of absolute/relative path
+    #
+    # @param [String] cmd
+    #   the executable to check
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def file_with_path?(cmd)
+      ::File.expand_path(cmd) == cmd
+    end
+    module_function :file_with_path?
+  end # Which
+end # TTY

data/lib/searchlink.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# SearchLink by Brett Terpstra 2015 <http://brettterpstra.com/projects/searchlink/>
+# MIT License, please maintain attribution
+require 'net/https'
+require 'uri'
+require 'rexml/document'
+require 'shellwords'
+require 'yaml'
+require 'cgi'
+require 'fileutils'
+require 'tempfile'
+require 'zlib'
+require 'time'
+require 'json'
+require 'erb'
+
+# import
+require 'tokens' if File.exist?('lib/tokens.rb')
+
+# import
+require 'searchlink/util'
+
+# import
+require 'searchlink/curl'
+
+# import
+require 'searchlink/semver'
+
+# import
+require 'searchlink/version'
+
+# import
+require 'searchlink/array'
+
+# import
+require 'searchlink/string'
+
+# import
+require 'searchlink/plist'
+
+# import
+require 'searchlink/config'
+
+# import
+require 'searchlink/searches'
+
+# import
+require 'searchlink/url'
+
+# import
+require 'searchlink/search'
+
+# import
+require 'searchlink/help'
+
+# import
+require 'searchlink/parse'
+
+# import
+require 'searchlink/output'
+
+# import
+require 'searchlink/which'
+
+module Secrets; end

data/lib/tokens.rb

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