searchlink 2.3.59

data/lib/searchlink/searches/history.rb

@@ -0,0 +1,166 @@
+#import
+require_relative 'helpers/chromium'
+
+#import
+require_relative 'helpers/firefox'
+
+#import
+require_relative 'helpers/safari'
+
+module SL
+  # Browser history/bookmark search
+  class HistorySearch
+    class << self
+      def settings
+        {
+          trigger: 'h(([scfabe])([hb])?)*',
+          searches: [
+            ['h', 'Browser History/Bookmark Search'],
+            ['hsh', 'Safari History Search'],
+            ['hsb', 'Safari Bookmark Search'],
+            ['hshb', nil],
+            ['hsbh', nil],
+            ['hch', 'Chrome History Search'],
+            ['hcb', 'Chrome Bookmark Search'],
+            ['hchb', nil],
+            ['hcbh', nil],
+            ['hfh', 'Firefox History Search'],
+            ['hfb', 'Firefox Bookmark Search'],
+            ['hfhb', nil],
+            ['hfbh', nil],
+            ['hah', 'Arc History Search'],
+            ['hab', 'Arc Bookmark Search'],
+            ['hahb', nil],
+            ['habh', nil],
+            ['hbh', 'Brave History Search'],
+            ['hbb', 'Brave Bookmark Search'],
+            ['hbhb', nil],
+            ['hbbh', nil],
+            ['heh', 'Edge History Search'],
+            ['heb', 'Edge Bookmark Search'],
+            ['hehb', nil],
+            ['hebh', nil]
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        str = search_type.match(/^h(([scfabe])([hb])?)*$/)[1]
+
+        types = []
+        while str && str.length.positive?
+          if str =~ /^s([hb]*)/
+            t = Regexp.last_match(1)
+            if t.length > 1 || t.empty?
+              types.push('safari_history')
+              types.push('safari_bookmarks')
+            elsif t == 'h'
+              types.push('safari_history')
+            elsif t == 'b'
+              types.push('safari_bookmarks')
+            end
+            str.sub!(/^s([hb]*)/, '')
+          end
+
+          if str =~ /^c([hb]*)/
+            t = Regexp.last_match(1)
+            if t.length > 1 || t.empty?
+              types.push('chrome_bookmarks')
+              types.push('chrome_history')
+            elsif t == 'h'
+              types.push('chrome_history')
+            elsif t == 'b'
+              types.push('chrome_bookmarks')
+            end
+            str.sub!(/^c([hb]*)/, '')
+          end
+
+          if str =~ /^f([hb]*)$/
+            t = Regexp.last_match(1)
+            if t.length > 1 || t.empty?
+              types.push('firefox_bookmarks')
+              types.push('firefox_history')
+            elsif t == 'h'
+              types.push('firefox_history')
+            elsif t == 'b'
+              types.push('firefox_bookmarks')
+            end
+            str.sub!(/^f([hb]*)/, '')
+          end
+
+          if str =~ /^e([hb]*)$/
+            t = Regexp.last_match(1)
+            if t.length > 1 || t.empty?
+              types.push('edge_bookmarks')
+              types.push('edge_history')
+            elsif t == 'h'
+              types.push('edge_history')
+            elsif t == 'b'
+              types.push('edge_bookmarks')
+            end
+            str.sub!(/^e([hb]*)/, '')
+          end
+
+          if str =~ /^b([hb]*)$/
+            t = Regexp.last_match(1)
+            if t.length > 1 || t.empty?
+              types.push('brave_bookmarks')
+              types.push('brave_history')
+            elsif t == 'h'
+              types.push('brave_history')
+            elsif t == 'b'
+              types.push('brave_bookmarks')
+            end
+            str.sub!(/^b([hb]*)/, '')
+          end
+
+          next unless str =~ /^a([hb]*)$/
+
+          t = Regexp.last_match(1)
+          if t.length > 1 || t.empty?
+            types.push('arc_bookmarks')
+            types.push('arc_history')
+          elsif t == 'h'
+            types.push('arc_history')
+          elsif t == 'b'
+            types.push('arc_bookmarks')
+          end
+          str.sub!(/^a([hb]*)/, '')
+        end
+
+        url, title = search_history(search_terms, types)
+        link_text = title if link_text == '' || link_text == search_terms
+        [url, title, link_text]
+      end
+
+      def search_history(term, types = [])
+        if types.empty?
+          return false unless SL.config['history_types']
+
+          types = SL.config['history_types']
+        end
+
+        results = []
+
+        if !types.empty?
+          types.each do |type|
+            url, title, date = send("search_#{type}", term)
+
+            results << { 'url' => url, 'title' => title, 'date' => date } if url
+          end
+
+          if results.empty?
+            false
+          else
+            out = results.sort_by! { |r| r['date'] }.last
+            [out['url'], out['title']]
+          end
+        else
+          false
+        end
+      end
+    end
+
+    SL::Searches.register 'history', :search, self
+  end
+end

data/lib/searchlink/searches/hook.rb

@@ -0,0 +1,77 @@
+module SL
+  #
+  # Hookmark String helpers
+  #
+  class ::String
+    def split_hook
+      elements = split(/\|\|/)
+      {
+        name: elements[0].nil_if_missing,
+        url: elements[1].nil_if_missing,
+        path: elements[2].nil_if_missing
+      }
+    end
+
+    def split_hooks
+      split(/\^\^/).map(&:split_hook)
+    end
+  end
+
+  ##
+  ## Hookmark Search
+  ##
+  class HookSearch
+    class << self
+      def settings
+        {
+          trigger: 'hook',
+          searches: [
+            ['hook', 'Hookmark Bookmark Search']
+          ]
+        }
+      end
+
+      # Main search method
+      def search(_, search_terms, link_text)
+        url, title = search_hook(search_terms)
+        [url, title, link_text]
+      end
+
+      ##
+      ## Run the AppleScript Hookmark query
+      ##
+      ## @param      query [String]  The query
+      ##
+      def run_query(query)
+        `osascript <<'APPLESCRIPT'
+          tell application "Hook"
+            set _marks to every bookmark whose #{query}
+            set _out to {}
+            repeat with _hook in _marks
+              set _out to _out & (name of _hook & "||" & address of _hook & "||" & path of _hook)
+            end repeat
+            set {astid, AppleScript's text item delimiters} to {AppleScript's text item delimiters, "^^"}
+            set _output to _out as string
+            set AppleScript's text item delimiters to astid
+            return _output
+          end tell
+        APPLESCRIPT`.strip.split_hooks
+      end
+
+      # Search bookmark paths and addresses. Return array of bookmark hashes.
+      def search_hook(search)
+        types = %w[name path address]
+        query = search.strip.split(' ').map { |s| types.map { |t| %(#{t} contains "#{s}") }.join(' or ') }
+        query = query.map { |q| "(#{q})" }.join(' and ')
+        path_matches = run_query(query)
+
+        top_match = path_matches.uniq.first
+        return false unless top_match
+
+        [top_match[:url], top_match[:name]]
+      end
+    end
+
+    SL::Searches.register 'hook', :search, self
+  end
+end

data/lib/searchlink/searches/itunes.rb

@@ -0,0 +1,97 @@
+# title: iTunes Search
+# description: Search iTunes
+module SL
+  class ITunesSearch
+    class << self
+      def settings
+        {
+          trigger: '(i(pod|art|alb|song|tud?)|masd?)',
+          searches: [
+            ['ipod', 'iTunes podcast'],
+            ['iart', 'iTunes artist'],
+            ['ialb', 'iTunes album'],
+            ['isong', 'iTunes song'],
+            ['itu', 'iOS App Store Search'],
+            ['itud', 'iOS App Store Developer Link'],
+            ['mas', 'Mac App Store Search'],
+            ['masd', 'Mac App Store Developer Link']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        case search_type
+        when /^ialb$/ # iTunes Album Search
+          url, title = search_itunes('album', search_terms, false)
+        when /^iart$/ # iTunes Artist Search
+          url, title = search_itunes('musicArtist', search_terms, false)
+        when /^imov?$/ # iTunes movie search
+          dev = false
+          url, title = search_itunes('movie', search_terms, dev, SL.config['itunes_affiliate'])
+        when /^ipod$/
+          url, title = search_itunes('podcast', search_terms, false)
+        when /^isong$/ # iTunes Song Search
+          url, title = search_itunes('song', search_terms, false)
+        when /^itud?$/ # iTunes app search
+          dev = search_type =~ /d$/
+          url, title = search_itunes('iPadSoftware', search_terms, dev, SL.config['itunes_affiliate'])
+        when /^masd?$/ # Mac App Store search (mas = itunes link, masd = developer link)
+          dev = search_type =~ /d$/
+          url, title = search_itunes('macSoftware', search_terms, dev, SL.config['itunes_affiliate'])
+        end
+
+        [url, title, link_text]
+      end
+
+      def search_itunes(entity, terms, dev, aff = nil)
+        aff ||= SL.config['itunes_affiliate']
+
+        url = "http://itunes.apple.com/search?term=#{terms.url_encode}&country=#{SL.config['country_code']}&entity=#{entity}&limit=1"
+
+        begin
+          page = Curl::Json.new(url, compressed: true)
+          json = page.json
+        rescue StandardError => e
+          SL.add_error('Invalid response', "Search for #{terms}: (#{e})")
+          return false
+        end
+        return false unless json
+
+        return false unless json['resultCount']&.positive?
+
+        result = json['results'][0]
+        case entity
+        when /movie/
+          # dev parameter probably not necessary in this case
+          output_url = result['trackViewUrl']
+          output_title = result['trackName']
+        when /(mac|iPad)Software/
+          output_url = dev && result['sellerUrl'] ? result['sellerUrl'] : result['trackViewUrl']
+          output_title = result['trackName']
+        when /(musicArtist|song|album)/
+          case result['wrapperType']
+          when 'track'
+            output_url = result['trackViewUrl']
+            output_title = "#{result['trackName']} by #{result['artistName']}"
+          when 'collection'
+            output_url = result['collectionViewUrl']
+            output_title = "#{result['collectionName']} by #{result['artistName']}"
+          when 'artist'
+            output_url = result['artistLinkUrl']
+            output_title = result['artistName']
+          end
+        when /podcast/
+          output_url = result['collectionViewUrl']
+          output_title = result['collectionName']
+        end
+        return false unless output_url && output_title
+
+        return [output_url, output_title] if dev
+
+        [output_url + aff, output_title]
+      end
+    end
+
+    SL::Searches.register 'itunes', :search, self
+  end
+end

data/lib/searchlink/searches/lastfm.rb

@@ -0,0 +1,41 @@
+module SL
+  class LastFMSearch
+    class << self
+      def settings
+        {
+          trigger: 'l(art|song)',
+          searches: [
+            ['lart', 'Last.fm Artist Search'],
+            ['lsong', 'Last.fm Song Search']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        type = search_type =~ /art$/ ? 'artist' : 'track'
+
+        url = "http://ws.audioscrobbler.com/2.0/?method=#{type}.search&#{type}=#{search_terms.url_encode}&api_key=2f3407ec29601f97ca8a18ff580477de&format=json"
+        json = Curl::Json.new(url).json
+        return false unless json['results']
+
+        begin
+          case type
+          when 'track'
+            result = json['results']['trackmatches']['track'][0]
+            url = result['url']
+            title = "#{result['name']} by #{result['artist']}"
+          when 'artist'
+            result = json['results']['artistmatches']['artist'][0]
+            url = result['url']
+            title = result['name']
+          end
+          [url, title, link_text]
+        rescue StandardError
+          false
+        end
+      end
+    end
+
+    SL::Searches.register 'lastfm', :search, self
+  end
+end

data/lib/searchlink/searches/lyrics.rb

@@ -0,0 +1,91 @@
+# Always start with module SL
+module SL
+  # Give it a unique class name
+  class LyricsSearch
+    class << self
+      # Settings block is required with `trigger` and `searches`
+      def settings
+        {
+          # `trigger` is A regular expression that will trigger this plugin
+          # when used with a bang. The one below will trigger on !lyrics or
+          # !lyricse.
+          trigger: 'lyrics?e?',
+          # Every search that the plugin should execute should be individually
+          # listed and described in the searches array. This is used for
+          # completion and help generation. Do not include the bang (!) in the
+          # search keyword.
+          searches: [
+            ['lyric', 'Song Lyrics Search'],
+            ['lyrice', 'Song Lyrics Embed']
+          ]
+        }
+      end
+
+      # Every plugin must contain a #search method that takes 3 arguments:
+      #
+      # - `search_type` will contain the !search trigger that was used (minus the !)
+      # - `search_terms` will include everything that came after the !search
+      # - `link_text` will contain the text that will be used for the linked
+      # text portion of the link. This can usually remain untouched but must
+      # be passed back at the end of the function.
+      def search(search_type, search_terms, link_text)
+        # You can branch to multiple searches by testing the search_type
+        case search_type
+        when /e$/
+          url, title = SL.ddg("site:genius.com #{search_terms}", link_text)
+          if url
+            title = get_lyrics(url)
+            # To return an embed, set url (first parameter in the return
+            # array) to 'embed', and put the embed contents in the second
+            # parameter.
+            title ? ['embed', title, link_text] : false
+          else
+            # Use `SL#add_error(title, text)` to add errors to the HTML
+            # report. The report will only be shown if errors have been added.
+            SL.add_error('No lyrics found', "Song lyrics for #{search_terms} not found")
+            false
+          end
+        else
+          # You can perform a DuckDuckGo search using SL#ddg, passing the
+          # search terms and link_text. It will return url, title, and
+          # link_text. SL#ddg will add its own errors, and if it returns false
+          # that will automatically be tested for, no additional error
+          # handling is required.
+          url, title, link_text = SL.ddg("site:genius.com #{search_terms}", link_text)
+          # Always return an array containing the resulting URL, the title,
+          # and the link_text variable that was passed in, even if it's
+          # unmodified.
+          [url, title, link_text]
+        end
+      end
+
+      # Any additional helper methods can be defined after #search
+      def get_lyrics(url)
+        if SL::URL.valid_link?(url)
+          # You can use Ruby's net/http methods for retrieving pages, but
+          # `curl -SsL` is faster and easier. Curl::Html.new(url) returns a
+          # new object containing :body
+          body = Curl::Html.new(url).body
+
+          matches = body.scan(%r{class="Lyrics__Container-.*?>(.*?)</div><div class="LyricsFooter})
+
+          lyrics = matches.join("\n")
+
+          if lyrics
+            "```\n#{CGI.unescape(lyrics).gsub(%r{<br/?>}, "  \n").gsub(%r{</?.*?>}, '').gsub(/&#x27;/, "'")}\n```"
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+    end
+
+    # At the end of the search class, you must register it as a plugin. This
+    # method takes a title, a type (:search for a search plugin), and the
+    # unique class. When running #register within the search class itself,
+    # you can just use `self`.
+    SL::Searches.register 'lyrics', :search, self
+  end
+end

data/lib/searchlink/searches/pinboard.rb

@@ -0,0 +1,183 @@
+module SL
+  class PinboardSearch
+    PINBOARD_CACHE = SL::Util.cache_file_for('pinboard')
+
+    class << self
+      def settings
+        {
+          trigger: 'pb',
+          searches: [
+            ['pb', 'Pinboard Bookmark Search']
+          ]
+        }
+      end
+
+      def pinboard_bookmarks
+        curl = TTY::Which.which('curl')
+        bookmarks = `#{curl} -sSL "https://api.pinboard.in/v1/posts/all?auth_token=#{SL.config['pinboard_api_key']}&format=json"`
+        bookmarks = bookmarks.force_encoding('utf-8')
+        bookmarks.gsub!(/[^[:ascii:]]/) do |non_ascii|
+          non_ascii.force_encoding('utf-8')
+                   .encode('utf-16be')
+                   .unpack('H*')
+                   .gsub(/(....)/, '\u\1')
+        end
+
+        bookmarks.gsub!(/[\u{1F600}-\u{1F6FF}]/, '')
+
+        bookmarks = JSON.parse(bookmarks)
+        updated = Time.now
+        { 'update_time' => updated, 'bookmarks' => bookmarks }
+      end
+
+      def save_pinboard_cache(cache)
+        cachefile = PINBOARD_CACHE
+
+        # file = File.new(cachefile,'w')
+        # file = Zlib::GzipWriter.new(File.new(cachefile,'w'))
+        begin
+          File.open(cachefile, 'wb') { |f| f.write(Marshal.dump(cache)) }
+        rescue IOError
+          SL.add_error('Pinboard cache error', 'Failed to write stash to disk')
+          return false
+        end
+        true
+      end
+
+      def load_pinboard_cache
+        refresh_cache = false
+        cachefile = PINBOARD_CACHE
+
+        if File.exist?(cachefile)
+          begin
+            # file = IO.read(cachefile) # Zlib::GzipReader.open(cachefile)
+            # cache = Marshal.load file
+            cache = Marshal.load(File.binread(cachefile))
+            # file.close
+          rescue IOError # Zlib::GzipFile::Error
+            SL.add_error('Error loading pinboard cache', "IOError reading #{cachefile}")
+            cache = pinboard_bookmarks
+            save_pinboard_cache(cache)
+          rescue StandardError
+            SL.add_error('Error loading pinboard cache', "StandardError reading #{cachefile}")
+            cache = pinboard_bookmarks
+            save_pinboard_cache(cache)
+          end
+          curl = TTY::Which.which('curl')
+          updated = JSON.parse(`#{curl} -SsL 'https://api.pinboard.in/v1/posts/update?auth_token=#{SL.config['pinboard_api_key']}&format=json'`)
+          last_bookmark = Time.parse(updated['update_time'])
+          if cache&.key?('update_time')
+            last_update = cache['update_time']
+            refresh_cache = true if last_update < last_bookmark
+          else
+            refresh_cache = true
+          end
+        else
+          refresh_cache = true
+        end
+
+        if refresh_cache
+          cache = pinboard_bookmarks
+          save_pinboard_cache(cache)
+        end
+
+        cache
+      end
+
+      # Search pinboard bookmarks
+      # Begin query with '' to force exact matching (including description text)
+      # Regular matching searches for each word of query and scores the bookmarks
+      # exact matches in title get highest score
+      # exact matches in description get second highest score
+      # other bookmarks are scored based on the number of words that match
+      #
+      # After sorting by score, bookmarks will be sorted by date and the most recent
+      # will be returned
+      #
+      # Exact matching is case and punctuation insensitive
+      def search(_, search_terms, link_text)
+        unless SL.config['pinboard_api_key']
+          SL.add_error('Missing Pinboard API token',
+                       'Find your api key at https://pinboard.in/settings/password and add it
+                        to your configuration (pinboard_api_key: YOURKEY)')
+          return false
+        end
+
+        exact_match = false
+        match_phrases = []
+
+        # If search terms start with ''term, only search for exact string matches
+        case search_terms
+        when /^ *'/
+          exact_match = true
+          search_terms.gsub!(/(^ *'+|'+ *$)/, '')
+        when /%22(.*?)%22/
+          match_phrases = search_terms.scan(/%22(\S.*?\S)%22/)
+          search_terms.gsub!(/%22(\S.*?\S)%22/, '')
+        end
+
+        cache = load_pinboard_cache
+        # cache = pinboard_bookmarks
+        bookmarks = cache['bookmarks']
+
+        if exact_match
+          bookmarks.each do |bm|
+            text = [bm['description'], bm['extended'], bm['tags']].join(' ')
+
+            return [bm['href'], bm['description']] if text.matches_exact(search_terms)
+          end
+
+          return false
+        end
+
+        unless match_phrases.empty?
+          bookmarks.delete_if do |bm|
+            matched = tru
+            full_text = [bm['description'], bm['extended'], bm['tags']].join(' ')
+            match_phrases.each do |phrase|
+              matched = false unless full_text.matches_exact(phrase)
+            end
+            !matched
+          end
+        end
+
+        matches = []
+        bookmarks.each do |bm|
+          title_tags = [bm['description'], bm['tags']].join(' ')
+          full_text = [bm['description'], bm['extended'], bm['tags']].join(' ')
+
+          score = if title_tags.matches_exact(search_terms)
+                    14.0
+                  elsif full_text.matches_exact(search_terms)
+                    13.0
+                  elsif full_text.matches_any(search_terms)
+                    full_text.matches_score(search_terms)
+                  else
+                    0
+                  end
+
+          return [bm['href'], bm['description']] if score == 14
+
+          next unless score.positive?
+
+          matches.push({
+                         score: score,
+                         href: bm['href'],
+                         title: bm['description'],
+                         date: bm['time']
+                       })
+        end
+
+        return false if matches.empty?
+
+        top = matches.max_by { |bm| [bm[:score], bm[:date]] }
+
+        return false unless top
+
+        [top[:href], top[:title], link_text]
+      end
+    end
+
+    SL::Searches.register 'pinboard', :search, self
+  end
+end