searchlink 2.3.59

data/lib/searchlink/searches/social.rb

@@ -0,0 +1,105 @@
+module SL
+  class SocialSearch
+    class << self
+      def settings
+        {
+          trigger: '@[tfilm]',
+          searches: [
+            ['@t', 'Twitter Handle'],
+            ['@f', 'Facebook Handle'],
+            ['@i', 'Instagram Handle'],
+            ['@l', 'LinkedIn Handle'],
+            ['@m', 'Mastodon Handle']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text = '')
+        type = case search_type
+               when /^@t/ # twitter-ify username
+                 unless search_terms.strip =~ /^@?[0-9a-z_$]+$/i
+                   return [false, "#{search_terms} is not a valid Twitter handle", link_text]
+
+                 end
+
+                 't'
+               when /^@fb?/ # fb-ify username
+                 unless search_terms.strip =~ /^@?[0-9a-z_]+$/i
+                   return [false, "#{search_terms} is not a valid Facebook username", link_text]
+
+                 end
+
+                 'f'
+               when /^@i/ # intagramify username
+                 unless search_terms.strip =~ /^@?[0-9a-z_]+$/i
+                   return [false, "#{search_terms} is not a valid Instagram username", link_text]
+
+                 end
+
+                 'i'
+               when /^@l/ # linked-inify username
+                 unless search_terms.strip =~ /^@?[0-9a-z_]+$/i
+                   return [false, "#{search_terms} is not a valid LinkedIn username", link_text]
+
+                 end
+
+                 'l'
+               when /^@m/ # mastodonify username
+                 unless search_terms.strip =~ /^@?[0-9a-z_]+@[0-9a-z_.]+$/i
+                   return [false, "#{search_terms} is not a valid Mastodon username", link_text]
+
+                 end
+
+                 'm'
+               else
+                 't'
+               end
+
+        url, title = social_handle(type, search_terms)
+        link_text = title if link_text == ''
+        [url, title, link_text]
+      end
+
+      def template_social(user, url, service)
+        template = SL.config['social_template'].dup
+
+        template.sub!(/%user%/, user)
+        template.sub!(/%service%/, service)
+        template.sub!(/%url%/, url.sub(%r{^https?://(www\.)?}, '').sub(%r{/$}, ''))
+
+        template
+      end
+
+      def social_handle(type, term)
+        handle = term.sub(/^@/, '').strip
+
+        case type
+        when /^t/i
+          url = "https://twitter.com/#{handle}"
+          title = template_social(handle, url, 'Twitter')
+        when /^f/i
+          url = "https://www.facebook.com/#{handle}"
+          title = template_social(handle, url, 'Facebook')
+        when /^l/i
+          url = "https://www.linkedin.com/in/#{handle}/"
+          title = template_social(handle, url, 'LinkedIn')
+        when /^i/i
+          url = "https://www.instagram.com/#{handle}/"
+          title = template_social(handle, url, 'Instagram')
+        when /^m/i
+          parts = handle.split(/@/)
+          return [false, term] unless parts.count == 2
+
+          url = "https://#{parts[1]}/@#{parts[0]}"
+          title = template_social(handle, url, 'Mastodon')
+        else
+          [false, term]
+        end
+
+        [url, title]
+      end
+    end
+
+    SL::Searches.register 'social', :search, self
+  end
+end

data/lib/searchlink/searches/software.rb

@@ -0,0 +1,27 @@
+module SL
+  # Software Search
+  class SoftwareSearch
+    class << self
+      def settings
+        {
+          trigger: 's',
+          searches: [
+            ['s', 'Software Search']
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        excludes = %w[apple.com postmates.com download.cnet.com softpedia.com softonic.com macupdate.com]
+        search_url = %(#{excludes.map { |x| "-site:#{x}" }.join(' ')} #{search_terms} app)
+
+        url, title, link_text = SL.ddg(search_url, link_text)
+        link_text = title if link_text == '' && !SL.titleize
+
+        [url, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'software', :search, self
+  end
+end

data/lib/searchlink/searches/spelling.rb

@@ -0,0 +1,59 @@
+module SL
+  # Spelling Search
+  class SpellSearch
+    class << self
+      def settings
+        {
+          trigger: 'sp(?:ell)?',
+          searches: [
+            %w[sp Spelling],
+            ['spell', nil]
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        title = SL.spell(search_terms)
+
+        [title, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'spelling', :search, self
+  end
+
+  class << self
+    def spell(phrase)
+      aspell = if File.exist?('/usr/local/bin/aspell')
+                 '/usr/local/bin/aspell'
+               elsif File.exist?('/opt/homebrew/bin/aspell')
+                 '/opt/homebrew/bin/aspell'
+               else
+                 `which aspell`.strip
+               end
+
+      if aspell.nil? || aspell.empty?
+        SL.add_error('Missing aspell', 'Install aspell in to allow spelling corrections')
+        return false
+      end
+
+      words = phrase.split(/\b/)
+      output = ''
+      words.each do |w|
+        if w =~ /[A-Za-z]+/
+          spell_res = `echo "#{w}" | #{aspell} --sug-mode=bad-spellers -C pipe | head -n 2 | tail -n 1`
+          if spell_res.strip == "\*"
+            output += w
+          else
+            spell_res.sub!(/.*?: /, '')
+            results = spell_res.split(/, /).delete_if { |word| phrase =~ /^[a-z]/ && word =~ /[A-Z]/ }
+            output += results[0]
+          end
+        else
+          output += w
+        end
+      end
+      output
+    end
+  end
+end

data/lib/searchlink/searches/spotlight.rb

@@ -0,0 +1,28 @@
+module SL
+  # Spotlight file search
+  class SpotlightSearch
+    class << self
+      def settings
+        {
+          trigger: 'file',
+          searches: [
+            ['file', 'Spotlight Search']
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        query = search_terms.gsub(/%22/, '"')
+        matches = `mdfind '#{query}' 2>/dev/null`.strip.split(/\n/)
+        res = matches.sort_by { |r| File.basename(r).length }.first
+        return [false, query, link_text] if res.strip.empty?
+
+        title = File.basename(res)
+        link_text = title if link_text.strip.empty? || link_text == search_terms
+        ["file://#{res.strip.gsub(/ /, '%20')}", title, link_text]
+      end
+    end
+
+    SL::Searches.register 'spotlight', :search, self
+  end
+end

data/lib/searchlink/searches/stackoverflow.rb

@@ -0,0 +1,31 @@
+module SL
+  # Stack Overflow search
+  class StackOverflowSearch
+    class << self
+      def settings
+        {
+          trigger: 'soa?',
+          searches: [
+            ['so', 'StackOverflow Search'],
+            ['soa', 'StackOverflow Accepted Answer']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        url, title, link_text = SL.ddg("site:stackoverflow.com #{search_terms}", link_text)
+        link_text = title if link_text == '' && !SL.titleize
+
+        if search_type =~ /a$/
+          body = `curl -SsL #{url}`.strip
+          m = body.match(/id="(?<id>answer-\d+)"[^>]+accepted-answer/)
+          url = "#{url}##{m['id']}" if m
+        end
+
+        [url, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'stackoverflow', :search, self
+  end
+end

data/lib/searchlink/searches/tmdb.rb

@@ -0,0 +1,52 @@
+module SL
+  # The Movie Database search
+  class TMDBSearch
+    class << self
+      def settings
+        {
+          trigger: 'tmdb[amt]?',
+          searches: [
+            ['tmdb', 'TMDB Multi Search'],
+            ['tmdba', 'TMDB Actor Search'],
+            ['tmdbm', 'TMDB Movie Search'],
+            ['tmdbt', 'TMDB TV Search']
+          ]
+        }
+      end
+
+      def search(search_type, terms, link_text)
+        type = case search_type
+               when /t$/
+                 'tv'
+               when /m$/
+                 'movie'
+               when /a$/
+                 'person'
+               else
+                 'multi'
+               end
+        body = `/usr/bin/curl -sSL 'https://api.themoviedb.org/3/search/#{type}?query=#{terms.url_encode}&api_key=2bd76548656d92517f14d64766e87a02'`
+        data = JSON.parse(body)
+        if data.key?('results') && data['results'].count.positive?
+          res = data['results'][0]
+          type = res['media_type'] if type == 'multi'
+          id = res['id']
+          url = "https://www.themoviedb.org/#{type}/#{id}"
+          title = res['name']
+          title ||= res['title']
+          title ||= terms
+        else
+          url, title, link_text = SL.ddg("site:imdb.com #{terms}", link_text)
+
+          return false unless url
+        end
+
+        link_text = title if link_text == '' && !SL.titleize
+
+        [url, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'tmdb', :search, self
+  end
+end

data/lib/searchlink/searches/twitter.rb

@@ -0,0 +1,46 @@
+module SL
+  class TwitterSearch
+    class << self
+      def settings
+        {
+          trigger: 'te',
+          searches: [
+            ['te', 'Twitter Embed']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        if SL::URL.url?(search_terms) && search_terms =~ %r{^https://twitter.com/}
+          url, title = twitter_embed(search_terms)
+        else
+          SL.add_error('Invalid Tweet URL', "#{search_terms} is not a valid link to a tweet or timeline")
+          url = false
+          title = false
+        end
+
+        [url, title, link_text]
+      end
+
+      def twitter_embed(tweet)
+        res = `curl -sSL 'https://publish.twitter.com/oembed?url=#{tweet.url_encode}'`.strip
+        if res
+          begin
+            json = JSON.parse(res)
+            url = 'embed'
+            title = json['html']
+          rescue StandardError
+            SL.add_error('Tweet Error', 'Error retrieving tweet')
+            url = false
+            title = tweet
+          end
+        else
+          return [false, 'Error retrieving tweet']
+        end
+        return [url, title]
+      end
+    end
+
+    SL::Searches.register 'twitter', :search, self
+  end
+end

data/lib/searchlink/searches/wikipedia.rb

@@ -0,0 +1,33 @@
+module SL
+  class WikipediaSearch
+    class << self
+      def settings
+        {
+          trigger: 'wiki',
+          searches: [
+            ['wiki', 'Wikipedia Search']
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        ## Hack to scrape wikipedia result
+        body = `/usr/bin/curl -sSL 'https://en.wikipedia.org/wiki/Special:Search?search=#{search_terms.url_encode}&go=Go'`
+        return false unless body
+
+        body = body.force_encoding('utf-8') if RUBY_VERSION.to_f > 1.9
+
+        begin
+          title = body.match(/"wgTitle":"(.*?)"/)[1]
+          url = body.match(/<link rel="canonical" href="(.*?)"/)[1]
+        rescue StandardError
+          return false
+        end
+
+        [url, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'wikipedia', :search, self
+  end
+end

data/lib/searchlink/searches/youtube.rb

@@ -0,0 +1,48 @@
+module SL
+  # YouTube Search/Linking
+  class YouTubeSearch
+    YOUTUBE_RX = %r{(?:youtu\.be/|youtube\.com/watch\?v=)?(?<id>[a-z0-9_\-]+)$}i.freeze
+
+    class << self
+      def settings
+        {
+          trigger: 'yte?',
+          searches: [
+            ['yt', 'YouTube Search'],
+            ['yte', 'YouTube Embed']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        if SL::URL.url?(search_terms) && search_terms =~ YOUTUBE_RX
+          url = search_terms
+        elsif search_terms =~ /^[a-z0-9_\-]+$/i
+          url = "https://youtube.com/watch?v=#{search_terms}"
+        else
+          url, title = SL.ddg("site:youtube.com #{search_terms}", link_text)
+        end
+
+        url, title = embed_for_url(url) if search_type =~ /e$/
+
+        [url, title]
+      end
+
+      def embed_for_url(url)
+        return unless url =~ YOUTUBE_RX
+
+        id = Regexp.last_match('id')
+        title = [
+          %(<iframe width="560" height="315" src="https://www.youtube.com/embed/#{id}"),
+          %(title="YouTube video player" frameborder="0"),
+          %(allow="accelerometer; autoplay; clipboard-write; encrypted-media;),
+          %(gyroscope; picture-in-picture; web-share"),
+          %(allowfullscreen></iframe>)
+        ].join(' ')
+        ['embed', title]
+      end
+    end
+
+    SL::Searches.register 'youtube', :search, self
+  end
+end

data/lib/searchlink/searches.rb

@@ -0,0 +1,194 @@
+module SL
+  module Searches
+    class << self
+      def plugins
+        @plugins ||= {}
+      end
+
+      def load_searches
+        Dir.glob(File.join(File.dirname(__FILE__), 'searches', '*.rb')).sort.each { |f| require f }
+      end
+
+      #
+      # Register a plugin with the plugin manager
+      #
+      # @param [String, Array] title title or array of titles
+      # @param [Symbol] type plugin type (:search)
+      # @param [Class] klass class that handles plugin actions. Search plugins 
+      #                must have a #settings and a #search method
+      #
+      def register(title, type, klass)
+        Array(title).each { |t| register_plugin(t, type, klass) }
+      end
+
+      def description_for_search(search_type)
+        description = "#{search_type} search"
+        plugins[:search].each do |_, plugin|
+          s = plugin[:searches].select { |s| s[0] == search_type }
+          unless s.empty?
+            description = s[0][1]
+            break
+          end
+        end
+        description
+      end
+
+      #
+      # Output an HTML table of available searches
+      #
+      # @return [String] Table HTML
+      #
+      def available_searches_html
+        searches = plugins[:search]
+                   .flat_map { |_, plugin| plugin[:searches] }
+                   .reject { |s| s[1].nil? }
+                   .sort_by { |s| s[0] }
+        out = ['<table id="searches">',
+               '<thead><td>Shortcut</td><td>Search Type</td></thead>',
+               '<tbody>']
+        searches.each { |s| out << "<tr><td><code>!#{s[0]}</code></td><td>#{s[1]}</td></tr>" }
+        out.concat(['</tbody>', '</table>']).join("\n")
+      end
+
+      #
+      # Aligned list of available searches
+      #
+      # @return [String] Aligned list of searches
+      #
+      def available_searches
+        searches = []
+        plugins[:search].each { |_, plugin| searches.concat(plugin[:searches].delete_if { |s| s[1].nil? }) }
+        out = ''
+        searches.each { |s| out += "!#{s[0]}#{s[0].spacer}#{s[1]}\n" }
+        out
+      end
+
+      def best_search_match(term)
+        searches = all_possible_searches.dup
+        searches.select { |s| s.matches_score(term, separator: '', start_word: false) > 8 }
+      end
+
+      def all_possible_searches
+        searches = []
+        plugins[:search].each { |_, plugin| plugin[:searches].each { |s| searches.push(s[0]) } }
+        searches.concat(SL.config['custom_site_searches'].keys)
+      end
+
+      def did_you_mean(term)
+        matches = best_search_match(term)
+        matches.empty? ? '' : ", did you mean #{matches.map { |m| "!#{m}" }.join(', ')}?"
+      end
+
+      def valid_searches
+        searches = []
+        plugins[:search].each { |_, plugin| searches.push(plugin[:trigger]) }
+        searches
+      end
+
+      def valid_search?(term)
+        valid = false
+        valid = true if term =~ /^(#{valid_searches.join('|')})$/
+        valid = true if SL.config['custom_site_searches'].keys.include? term
+        # SL.notify("Invalid search#{did_you_mean(term)}", term) unless valid
+        valid
+      end
+
+      def register_plugin(title, type, klass)
+        raise StandardError, "Plugin #{title} has no settings method" unless klass.respond_to? :settings
+
+        settings = klass.settings
+
+        raise StandardError, "Plugin #{title} has no search method" unless klass.respond_to? :search
+
+        plugins[type] ||= {}
+        plugins[type][title] = {
+          trigger: settings.fetch(:trigger, title).normalize_trigger,
+          searches: settings[:searches],
+          class: klass
+        }
+      end
+
+      def load_custom
+        plugins_folder = File.expand_path('~/.local/searchlink/plugins')
+        return unless File.directory?(plugins_folder)
+
+        Dir.glob(File.join(plugins_folder, '**/*.rb')).sort.each do |plugin|
+          require plugin
+        end
+      end
+
+      def do_search(search_type, search_terms, link_text, timeout: SL.config['timeout'])
+        plugins[:search].each do |_title, plugin|
+          trigger = plugin[:trigger].gsub(/(^\^|\$$)/, '')
+          if search_type =~ /^#{trigger}$/
+            search = proc { plugin[:class].search(search_type, search_terms, link_text) }
+            return SL::Util.search_with_timeout(search, timeout)
+          end
+        end
+      end
+    end
+  end
+end
+
+# import
+require_relative 'searches/applemusic'
+
+# import
+require_relative 'searches/itunes'
+
+# import
+require_relative 'searches/amazon'
+
+# import
+require_relative 'searches/bitly'
+
+# import
+require_relative 'searches/definition'
+
+# import
+require_relative 'searches/duckduckgo'
+
+# import
+require_relative 'searches/github'
+
+# import
+require_relative 'searches/google'
+
+# import
+require_relative 'searches/history'
+
+# import
+require_relative 'searches/hook'
+
+# import
+require_relative 'searches/lastfm'
+
+# import
+require_relative 'searches/pinboard'
+
+# import
+require_relative 'searches/social'
+
+# import
+require_relative 'searches/software'
+
+# import
+require_relative 'searches/spelling'
+
+# import
+require_relative 'searches/spotlight'
+
+# import
+require_relative 'searches/tmdb'
+
+# import
+require_relative 'searches/twitter'
+
+# import
+require_relative 'searches/wikipedia'
+
+# import
+require_relative 'searches/youtube'
+
+# import
+require_relative 'searches/stackoverflow'