searchlink 2.3.59

data/lib/searchlink/searches/duckduckgo.rb

@@ -0,0 +1,167 @@
+module SL
+  # DuckDuckGo Search
+  class DuckDuckGoSearch
+    class << self
+      # Returns a hash of settings for the DuckDuckGoSearch
+      # class
+      #
+      # @return     [Hash] settings for the DuckDuckGoSearch
+      #             class
+      #
+      def settings
+        {
+          trigger: '(?:g|ddg|z|ddgimg)',
+          searches: [
+            ['g', 'Google/DuckDuckGo Search'],
+            ['ddg', 'DuckDuckGo Search'],
+            ['z', 'DDG Zero Click Search'],
+            ['ddgimg', 'Return the first image from the destination page']
+          ]
+        }
+      end
+
+      # Searches DuckDuckGo for the given search terms
+      #
+      # @param      search_type   [String] the type of
+      #                           search to perform
+      # @param      search_terms  [String] the terms to
+      #                           search for
+      # @param      link_text     [String] the text to
+      #                           display for the link
+      # @return     [Array] an array containing the URL, title, and
+      #             link text
+      #
+      def search(search_type, search_terms, link_text)
+        return zero_click(search_terms, link_text) if search_type =~ /^z$/
+
+        # return SL.ddg(search_terms, link_text) if search_type == 'g' && SL::GoogleSearch.test_for_key
+
+        begin
+          terms = "%5C#{search_terms.url_encode}"
+          page = Curl::Html.new("https://duckduckgo.com/?q=#{terms}", compressed: true)
+
+          locs = page.meta['refresh'].match(%r{/l/\?uddg=(.*?)$})
+          locs = page.body.match(%r{/l/\?uddg=(.*?)'}) if locs.nil?
+          locs = page.body.match(/url=(.*?)'/) if locs.nil?
+
+          return false if locs.nil?
+
+          url = locs[1].url_decode.sub(/&rut=\w+/, '')
+
+          result = url.strip.url_decode || false
+          return false unless result
+
+          return false if result =~ /internal-search\.duckduckgo\.com/
+
+          # output_url = CGI.unescape(result)
+          output_url = result
+
+          output_title = if SL.config['include_titles'] || SL.titleize
+                           SL::URL.title(output_url) || ''
+                         else
+                           ''
+                         end
+
+          output_url = SL.first_image(output_url) if search_type =~ /img$/
+
+          [output_url, output_title, link_text]
+        end
+      end
+
+      # Searches DuckDuckGo for the given search terms and
+      # returns a zero click result
+      #
+      # @param      search_terms  [String] the terms to
+      #                           search for
+      # @param      link_text     [String] the text to
+      #                           display for the link
+      # @param      disambiguate  [Boolean] whether to
+      #                           disambiguate the search
+      #
+      # @return     [Array] an array containing the URL,
+      #             title, and link text
+      #
+      def zero_click(search_terms, link_text, disambiguate: false)
+        search_terms.gsub!(/%22/, '"')
+        d = disambiguate ? '0' : '1'
+        url = "http://api.duckduckgo.com/?q=#{search_terms.url_encode}&format=json&no_redirect=1&no_html=1&skip_disambig=#{d}"
+        result = Curl::Json.new(url, symbolize_names: true).json
+        return SL.ddg(terms, link_text) unless result
+
+        wiki_link = result[:AbstractURL] || result[:Redirect]
+        title = result[:Heading] || false
+
+        if !wiki_link.empty? && !title.empty?
+          [wiki_link, title, link_text]
+        elsif disambiguate
+          SL.ddg(search_terms, link_text)
+        else
+          zero_click(search_terms, link_text, disambiguate: true)
+        end
+      end
+    end
+
+    # Registers the DuckDuckGoSearch class with the Searches
+    # module
+    # @param      name   [String] the name of the search
+    # @param      type   [Symbol] the type of search to
+    #                    perform
+    # @param      klass  [Class] the class to register
+    SL::Searches.register 'duckduckgo', :search, self
+  end
+end
+
+# SL module methods
+module SL
+  class << self
+    # Performs a Google search if API key is available,
+    # otherwise defaults to DuckDuckGo
+    #
+    # @param      search_terms  [String] The search terms
+    # @param      link_text     [String] The link text
+    # @param      timeout       [Integer] The timeout
+    #
+    def google(search_terms, link_text = nil, timeout: SL.config['timeout'], image: false)
+      if SL::GoogleSearch.test_for_key
+        s_class = 'google'
+        s_type = image ? 'img' : 'gg'
+      else
+        s_class = 'duckduckgo'
+        s_type = image ? 'ddgimg' : 'g'
+      end
+      search = proc { SL::Searches.plugins[:search][s_class][:class].search(s_type, search_terms, link_text) }
+      SL::Util.search_with_timeout(search, timeout)
+    end
+
+    # Performs a DuckDuckGo search with the given search
+    # terms and link text. If link text is not provided, the
+    # first result will be returned. The search will timeout
+    # after the given number of seconds.
+    #
+    # @param      search_terms  [String] The search terms to
+    #                           use
+    # @param      link_text     [String] The text of the
+    #                           link to search for
+    # @param      timeout       [Integer] The timeout for
+    #                           the search in seconds
+    # @return     [SL::Searches::Result] The search result
+    #
+    def ddg(search_terms, link_text = nil, timeout: SL.config['timeout'], google: true, image: false)
+      if google && SL::GoogleSearch.test_for_key
+        s_class = 'google'
+        s_type = image ? 'img' : 'gg'
+      else
+        s_class = 'duckduckgo'
+        s_type = image ? 'ddgimg' : 'g'
+      end
+
+      search = proc { SL::Searches.plugins[:search][s_class][:class].search(s_type, search_terms, link_text) }
+      SL::Util.search_with_timeout(search, timeout)
+    end
+
+    def first_image(url)
+      images = Curl::Html.new(url).images
+      images.filter { |img| img[:type] == 'img' }.first[:src]
+    end
+  end
+end

data/lib/searchlink/searches/github.rb

@@ -0,0 +1,245 @@
+module SL
+  # GitHub search
+  class GitHubSearch
+    class << self
+      def settings
+        {
+          trigger: '(?:giste?|ghu?)',
+          searches: [
+            ['gh', 'GitHub User/Repo Link'],
+            ['ghu', 'GitHub User Search'],
+            ['gist', 'Gist Search'],
+            ['giste', 'Gist Embed']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        case search_type
+        when /^gist/
+          url, title, link_text = gist(search_terms, search_type, link_text)
+        when /^ghu$/
+          url, title, link_text = github_user(search_terms, link_text)
+        else
+          url, title, link_text = github(search_terms, link_text)
+        end
+
+        link_text = title if link_text == '' || link_text == search_terms
+
+        [url, title, link_text]
+      end
+
+      def github_search_curl(endpoint, query)
+        headers = {
+          'Accept' => 'application/vnd.github+json',
+          'X-GitHub-Api-Version' => '2022-11-28',
+        }
+        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if 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)
+
+        if res.json.key?('total_count') && res.json['total_count'].positive?
+          res.json['items'][0]
+        else
+          false
+        end
+      end
+
+      def user_gists(user, search_terms, page = 1)
+        headers = {
+          'Accept' => 'application/vnd.github+json',
+          'X-GitHub-Api-Version' => '2022-11-28'
+        }
+        headers['Authorization'] = "Bearer #{Secrets::GH_AUTH_TOKEN}" if Secrets::GH_AUTH_TOKEN
+
+        url = "https://api.github.com/users/#{user}/gists?per_page=100&page=#{page}"
+
+        res = Curl::Json.new(url, headers: headers).json
+
+        best = nil
+        best = filter_gists(res, search_terms) if res
+
+        if !best && res.count == 100
+          SL.notify('Paging', "Getting page #{page + 1} of #{user} gists")
+          best = user_gists(user, search_terms, page + 1)
+        end
+
+        best
+      end
+
+      def github(search_terms, link_text)
+        terms = search_terms.split(%r{[ /]+})
+        # SL.config['remove_seo'] = false
+
+        url = case terms.count
+              when 2
+                "https://github.com/#{terms[0]}/#{terms[1]}"
+              when 1
+                "https://github.com/#{terms[0]}"
+              else
+                nurl, title, link_text = SL.ddg("site:github.com #{search_terms}", link_text)
+                nurl
+              end
+
+        if SL::URL.valid_link?(url)
+          title = SL::URL.title(url) if url && title.nil?
+
+          [url, title, link_text]
+        else
+          SL.notify('Searching GitHub', 'Repo not found, performing search')
+          search_github(search_terms, link_text)
+        end
+      end
+
+      def github_user(search_terms, link_text)
+        if search_terms.split(/ /).count > 1
+          query = %(#{search_terms} in:name)
+          res = github_search_curl('users', query)
+        else
+          query = %(user:#{search_terms})
+          res = github_search_curl('users', query)
+          res ||= github_search_curl('users', search_terms)
+        end
+
+        if res
+          url = res['html_url']
+          title = res['login']
+
+          [url, title, link_text]
+        else
+          [false, false, link_text]
+        end
+      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:')
+
+        search_terms += ' in:title' unless search_terms =~ /(in|user|repo):/
+
+        res = github_search_curl('repositories', search_terms)
+
+        return false unless res
+
+        url = res['html_url']
+        title = res['description'] || res['full_name']
+        [url, title, link_text]
+      end
+
+      def search_user_gists(user, search_terms)
+        best_gist = user_gists(user, search_terms, 1)
+
+        return false unless best_gist
+
+        best_gist
+      end
+
+      def filter_gists(gists, search_terms)
+        score = 0
+        gists.map! do |g|
+          {
+            url: g['html_url'],
+            description: g['description'],
+            files: g['files'].map { |file, info| { filename: file, raw: info['raw_url'] } }
+          }
+        end
+        matches = []
+        gists.each do |g|
+          if g.key?(:files)
+            g[:files].each do |f|
+              next unless f[:filename]
+
+              score = f[:filename].matches_score(search_terms.gsub(/[^a-z0-9]/, ' '))
+
+              if score > 5
+                url = "#{g[:url]}#file-#{f[:filename].gsub(/\./, '-')}"
+                matches << { url: url, title: f[:filename], score: score }
+              end
+            end
+          end
+
+          score = g[:description].nil? ? 0 : g[:description].matches_score(search_terms.gsub(/[^a-z0-9]/, ' '))
+          matches << { url: g[:url], title: g[:files][0][:filename], score: score } if score > 5
+        end
+
+        return false if matches.empty?
+
+        matches.max_by { |m| m[:score] }
+      end
+
+      def gist(terms, type, link_text)
+        terms.strip!
+        case terms
+        # If an id (and optional file) are given, expand it to include username an generate link
+        when %r{^(?<id>[a-z0-9]{32}|[0-9]{6,10})(?:[#/](?<file>(?:file-)?.*?))?$}
+          m = Regexp.last_match
+          res = Curl::Html.new("https://gist.github.com/#{m['id']}", headers_only: true)
+          url = res.headers['location']
+          title = SL::URL.title(url)
+
+          url = "#{url}##{m['file']}" if m['file']
+        # If a user an id (an o) are given, convert to a link
+        when %r{^(?<u>\w+)/(?<id>[a-z0-9]{32}|[0-9]{6,10})(?:[#/](?<file>(?:file-)?.*?))?$}
+          m = Regexp.last_match
+          url = "https://gist.github.com/#{m['u']}/#{m['id']}"
+          title = SL::URL.title(url)
+
+          url = "#{url}##{m['file']}" if m['file']
+        # if a full gist URL is given, simply clean it up
+        when %r{(?<url>https://gist.github.com/(?:(?<user>\w+)/)?(?<id>[a-z0-9]{32}|[0-9]{6,10}))(?:[#/](?<file>(?:file-)?.*?))?$}
+          m = Regexp.last_match
+          url = m['url']
+          title = SL::URL.title(url)
+
+          url = "#{url}##{m['file']}" if m['file']
+        # Otherwise do a search of gist.github.com for the keywords
+        else
+          if terms.split(/ +/).count > 1
+            parts = terms.split(/ +/)
+            gist = search_user_gists(parts[0], parts[1..].join(' '))
+
+            if gist
+              url = gist[:url]
+              title = gist[:title]
+            else
+              url, title, link_text = SL.ddg("site:gist.github.com #{terms}", link_text)
+            end
+          else
+            url, title, link_text = SL.ddg("site:gist.github.com #{terms}", link_text)
+          end
+        end
+
+        # Assuming we retrieved a full gist URL
+        if url =~ %r{https://gist.github.com/(?:(?<user>[^/]+)/)?(?<id>[a-z0-9]+?)(?:[#/](?<file>(?:file-)?.*?))?$}
+          m = Regexp.last_match
+          user = m['user']
+          id = m['id']
+
+          # If we're trying to create an embed, convert elements to a JS embed script
+          if type =~ /e$/
+            url = if m['file']
+                    "https://gist.github.com/#{user}/#{id}.js?file=#{m['file'].fix_gist_file}"
+                  else
+                    "https://gist.github.com/#{user}/#{id}.js"
+                  end
+
+            ['embed', %(<script src="#{url}"></script>), link_text]
+          else
+            [url, title, link_text]
+          end
+        else
+          [false, title, link_text]
+        end
+      end
+    end
+
+    SL::Searches.register 'github', :search, self
+  end
+end

data/lib/searchlink/searches/google.rb

@@ -0,0 +1,67 @@
+module SL
+  # Google Search
+  class GoogleSearch
+    class << self
+      attr_reader :api_key
+
+      def settings
+        {
+          trigger: '(g(oo)?g(le?)?|img)',
+          searches: [
+            ['gg', 'Google Search'],
+            ['img', 'First image from result']
+          ]
+        }
+      end
+
+      def test_for_key
+        return false unless SL.config.key?('google_api_key') && SL.config['google_api_key']
+
+        key = SL.config['google_api_key']
+        return false if key =~ /^(x{4,})?$/i
+
+        @api_key = key
+
+        true
+      end
+
+      def search(search_type, search_terms, link_text)
+        image = search_type =~ /img$/ ? true : false
+
+        unless test_for_key
+          SL.add_error('api key', 'Missing Google API Key')
+          return false
+        end
+
+        url = "https://customsearch.googleapis.com/customsearch/v1?cx=338419ee5ac894523&q=#{ERB::Util.url_encode(search_terms)}&num=1&key=#{@api_key}"
+        json = Curl::Json.new(url).json
+
+        if json['error'] && json['error']['code'].to_i == 429
+          SL.notify('api limit', 'Google API limit reached, defaulting to DuckDuckGo')
+          return SL.ddg(terms, link_text, google: false, image: image)
+        end
+
+        unless json['queries']['request'][0]['totalResults'].to_i.positive?
+          SL.notify('no results', 'Google returned no results, defaulting to DuckDuckGo')
+          return SL.ddg(terms, link_text, google: false, image: image)
+        end
+
+        result = json['items'][0]
+        return false if result.nil?
+
+        output_url = result['link']
+        output_title = result['title']
+        output_title.remove_seo!(output_url) if SL.config['remove_seo']
+
+        output_url = SL.first_image if search_type =~ /img$/
+
+        [output_url, output_title, link_text]
+      rescue StandardError
+        SL.notify('Google error', 'Error fetching Google results, switching to DuckDuckGo')
+        SL.ddg(search_terms, link_text, google: false, image: image)
+      end
+    end
+
+    SL::Searches.register 'google', :search, self
+  end
+end