searchlink 2.3.59

data/lib/searchlink/plist.rb

@@ -0,0 +1,213 @@
+# = plist
+#
+# Copyright 2006-2010 Ben Bleything and Patrick May
+# Distributed under the MIT License
+module Plist ; end
+
+# === Load a plist file
+# This is the main point of the library:
+#
+#   r = Plist::parse_xml( filename_or_xml )
+module Plist
+  def Plist::parse_xml( filename_or_xml )
+    listener = Listener.new
+    parser = StreamParser.new(filename_or_xml, listener)
+    parser.parse
+    listener.result
+  end
+
+  class Listener
+    attr_accessor :result, :open
+
+    def initialize
+      @result = nil
+      @open = Array.new
+    end
+
+    def tag_start(name, attributes)
+      @open.push PTag::mappings[name].new
+    end
+
+    def text( contents )
+      @open.last.text = contents if @open.last
+    end
+
+    def tag_end(name)
+      last = @open.pop
+      if @open.empty?
+        @result = last.to_ruby
+      else
+        @open.last.children.push last
+      end
+    end
+  end
+
+  class StreamParser
+    def initialize( plist_data_or_file, listener )
+      if plist_data_or_file.respond_to? :read
+        @xml = plist_data_or_file.read
+      elsif File.exists? plist_data_or_file
+        @xml = File.read( plist_data_or_file )
+      else
+        @xml = plist_data_or_file
+      end
+
+      @listener = listener
+    end
+
+    TEXT       = /([^<]+)/
+    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/um
+    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um
+    COMMENT_START = /\A<!--/u
+    COMMENT_END = /.*?-->/um
+
+    def parse
+      plist_tags = PTag::mappings.keys.join('|')
+      start_tag  = /<(#{plist_tags})([^>]*)>/i
+      end_tag    = /<\/(#{plist_tags})[^>]*>/i
+
+      require 'strscan'
+
+      @scanner = StringScanner.new(@xml)
+      until @scanner.eos?
+        if @scanner.scan(COMMENT_START)
+          @scanner.scan(COMMENT_END)
+        elsif @scanner.scan(XMLDECL_PATTERN)
+        elsif @scanner.scan(DOCTYPE_PATTERN)
+        elsif @scanner.scan(start_tag)
+          @listener.tag_start(@scanner[1], nil)
+          if (@scanner[2] =~ /\/$/)
+            @listener.tag_end(@scanner[1])
+          end
+        elsif @scanner.scan(TEXT)
+          @listener.text(@scanner[1])
+        elsif @scanner.scan(end_tag)
+          @listener.tag_end(@scanner[1])
+        else
+          raise "Unimplemented element"
+        end
+      end
+    end
+  end
+
+  class PTag
+    @@mappings = { }
+    def PTag::mappings
+      @@mappings
+    end
+
+    def PTag::inherited( sub_class )
+      key = sub_class.to_s.downcase
+      key.gsub!(/^plist::/, '' )
+      key.gsub!(/^p/, '')  unless key == "plist"
+
+      @@mappings[key] = sub_class
+    end
+
+    attr_accessor :text, :children
+    def initialize
+      @children = Array.new
+    end
+
+    def to_ruby
+      raise "Unimplemented: " + self.class.to_s + "#to_ruby on #{self.inspect}"
+    end
+  end
+
+  class PList < PTag
+    def to_ruby
+      children.first.to_ruby if children.first
+    end
+  end
+
+  class PDict < PTag
+    def to_ruby
+      dict = Hash.new
+      key = nil
+
+      children.each do |c|
+        if key.nil?
+          key = c.to_ruby
+        else
+          dict[key] = c.to_ruby
+          key = nil
+        end
+      end
+
+      dict
+    end
+  end
+
+  class PKey < PTag
+    def to_ruby
+      CGI::unescapeHTML(text || '')
+    end
+  end
+
+  class PString < PTag
+    def to_ruby
+      CGI::unescapeHTML(text || '')
+    end
+  end
+
+  class PArray < PTag
+    def to_ruby
+      children.collect do |c|
+        c.to_ruby
+      end
+    end
+  end
+
+  class PInteger < PTag
+    def to_ruby
+      text.to_i
+    end
+  end
+
+  class PTrue < PTag
+    def to_ruby
+      true
+    end
+  end
+
+  class PFalse < PTag
+    def to_ruby
+      false
+    end
+  end
+
+  class PReal < PTag
+    def to_ruby
+      text.to_f
+    end
+  end
+
+  require 'date'
+  class PDate < PTag
+    def to_ruby
+      DateTime.parse(text)
+    end
+  end
+
+  require 'base64'
+  class PData < PTag
+    def to_ruby
+      data = Base64.decode64(text.gsub(/\s+/, ''))
+
+      begin
+        return Marshal.load(data)
+      rescue Exception
+        io = StringIO.new
+        io.write data
+        io.rewind
+        return io
+      end
+    end
+  end
+end
+
+
+# module Plist
+#   VERSION = '3.1.0'
+# end
+

data/lib/searchlink/search.rb

@@ -0,0 +1,70 @@
+# Main SearchLink class
+module SL
+  include URL
+
+  class SearchLink
+    include Plist
+
+    attr_reader :originput, :output, :clipboard
+
+    private
+
+    #
+    # Run a search
+    #
+    # @param[String]  search_type   The search type (abbreviation)
+    # @param[String]  search_terms  The search terms
+    # @param[String]  link_text     The link text
+    # @param[Integer] search_count  The current search count
+    #
+    # @return [Array] [Url, link, text]
+    #
+    def do_search(search_type, search_terms, link_text = '', search_count = 0)
+      if (search_count % 5).zero?
+        SL.notify('Throttling for 5s')
+        sleep 5
+      end
+
+      description = SL::Searches.description_for_search(search_type)
+
+      SL.notify(description, search_terms)
+      return [false, search_terms, link_text] if search_terms.empty?
+
+      if SL::Searches.valid_search?(search_type)
+        url, title, link_text = SL::Searches.do_search(search_type, search_terms, link_text)
+      else
+        case search_type
+        when /^r$/ # simple replacement
+          if SL.config['validate_links'] && !SL::URL.valid_link?(search_terms)
+            return [false, "Link not valid: #{search_terms}", link_text]
+          end
+
+          title = SL::URL.title(search_terms) || search_terms
+
+          link_text = title if link_text == ''
+          return [search_terms, title, link_text]
+        else
+          if search_terms
+            if search_type =~ /.+?\.\w{2,}$/
+              url, title, link_text = SL.ddg(%(site:#{search_type} #{search_terms}), link_text)
+            else
+              url, title, link_text = SL.ddg(search_terms, link_text)
+            end
+          end
+        end
+      end
+
+      if link_text == ''
+        link_text = SL.titleize ? title : search_terms
+      end
+
+      if url && SL.config['validate_links'] && !SL::URL.valid_link?(url) && search_type !~ /^sp(ell)?/
+        [false, "Not found: #{url}", link_text]
+      elsif !url
+        [false, "No results: #{url}", link_text]
+      else
+        [url, title, link_text]
+      end
+    end
+  end
+end

data/lib/searchlink/searches/amazon.rb

@@ -0,0 +1,25 @@
+module SL
+  # Amazon Search
+  class AmazonSearch
+    class << self
+      def settings
+        {
+          trigger: 'a',
+          searches: [
+            ['a', 'Amazon Search']
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        az_url, = SL.ddg("site:amazon.com #{search_terms}", link_text)
+        url, title = SL::URL.amazon_affiliatize(az_url, SL.config['amazon_partner'])
+        title ||= search_terms
+
+        [url, title, link_text]
+      end
+    end
+
+    SL::Searches.register 'amazon', :search, self
+  end
+end

data/lib/searchlink/searches/applemusic.rb

@@ -0,0 +1,123 @@
+# title: Apple Music Search
+# description: Search Apple Music
+module SL
+  # Apple Music Search
+  class AppleMusicSearch
+    class << self
+      def settings
+        {
+          trigger: 'am(pod|art|alb|song)?e?',
+          searches: [
+            ['am', 'Apple Music'],
+            ['ampod', 'Apple Music Podcast'],
+            ['amart', 'Apple Music Artist'],
+            ['amalb', 'Apple Music Album'],
+            ['amsong', 'Apple Music Song'],
+            ['amalbe', 'Apple Music Album Embed'],
+            ['amsong', 'Apple Music Song Embed']
+          ]
+        }
+      end
+
+      def search(search_type, search_terms, link_text)
+        stype = search_type.downcase.sub(/^am/, '')
+        otype = :link
+        if stype =~ /e$/
+          otype = :embed
+          stype.sub!(/e$/, '')
+        end
+        result = case stype
+                 when /^pod$/
+                   applemusic(search_terms, 'podcast')
+                 when /^art$/
+                   applemusic(search_terms, 'music', 'musicArtist')
+                 when /^alb$/
+                   applemusic(search_terms, 'music', 'album')
+                 when /^song$/
+                   applemusic(search_terms, 'music', 'musicTrack')
+                 else
+                   applemusic(search_terms)
+                 end
+
+        return [false, "Not found: #{search_terms}", link_text] unless result
+
+        # {:type=>,:id=>,:url=>,:title=>}
+        if otype == :embed && result[:type] =~ /(album|song)/
+          url = 'embed'
+          if result[:type] =~ /song/
+            link = %(https://embed.music.apple.com/#{SL.config['country_code'].downcase}/album/#{result[:album]}?i=#{result[:id]}&app=music#{SL.config['itunes_affiliate']})
+            height = 150
+          else
+            link = %(https://embed.music.apple.com/#{SL.config['country_code'].downcase}/album/#{result[:id]}?app=music#{SL.config['itunes_affiliate']})
+            height = 450
+          end
+
+          title = [
+            %(<iframe src="#{link}" allow="autoplay *; encrypted-media *;"),
+            %(frameborder="0" height="#{height}"),
+            %(style="width:100%;max-width:660px;overflow:hidden;background:transparent;"),
+            %(sandbox="allow-forms allow-popups allow-same-origin),
+            %(allow-scripts allow-top-navigation-by-user-activation"></iframe>)
+          ].join(' ')
+        else
+          url = result[:url]
+          title = result[:title]
+        end
+        [url, title, link_text]
+      end
+
+      # Search apple music
+      # terms => search terms (unescaped)
+      # media => music, podcast
+      # entity => optional: artist, song, album, podcast
+      # returns {:type=>,:id=>,:url=>,:title}
+      def applemusic(terms, media = 'music', entity = '')
+        url = "http://itunes.apple.com/search?term=#{terms.url_encode}&country=#{SL.config['country_code']}&media=#{media}&entity=#{entity}"
+        page = Curl::Json.new(url, compressed: true, symbolize_names: true)
+        json = page.json
+        return false unless json[:resultCount]&.positive?
+
+        output = process_result(json[:results][0])
+
+        return false if output.empty?
+
+        output
+      end
+
+      def process_result(result)
+        output = {}
+        aff = SL.config['itunes_affiliate']
+
+        case result[:wrapperType]
+        when 'track'
+          if result[:kind] == 'podcast'
+            output[:type] = 'podcast'
+            output[:id] = result[:collectionId]
+            output[:url] = result[:collectionViewUrl].to_am + aff
+            output[:title] = result[:collectionName]
+          else
+            output[:type] = 'song'
+            output[:album] = result[:collectionId]
+            output[:id] = result[:trackId]
+            output[:url] = result[:trackViewUrl].to_am + aff
+            output[:title] = "#{result[:trackName]} by #{result[:artistName]}"
+          end
+        when 'collection'
+          output[:type] = 'album'
+          output[:id] = result[:collectionId]
+          output[:url] = result[:collectionViewUrl].to_am + aff
+          output[:title] = "#{result[:collectionName]} by #{result[:artistName]}"
+        when 'artist'
+          output[:type] = 'artist'
+          output[:id] = result[:artistId]
+          output[:url] = result[:artistLinkUrl].to_am + aff
+          output[:title] = result[:artistName]
+        end
+
+        output
+      end
+    end
+
+    SL::Searches.register 'applemusic', :search, self
+  end
+end

data/lib/searchlink/searches/bitly.rb

@@ -0,0 +1,50 @@
+module SL
+  # Bit.ly link shortening
+  class BitlySearch
+    class << self
+      def settings
+        {
+          trigger: 'b(l|itly)',
+          searches: [
+            ['bl', 'bit.ly Shorten'],
+            ['bitly', 'bit.ly shorten']
+          ]
+        }
+      end
+
+      def search(_, search_terms, link_text)
+        if SL::URL.url?(search_terms)
+          link = search_terms
+        else
+          link, rtitle = SL.ddg(search_terms, link_text)
+        end
+
+        url, title = bitly_shorten(link, rtitle)
+        link_text = title || url
+        [url, title, link_text]
+      end
+
+      def bitly_shorten(url, title = nil)
+        unless SL.config.key?('bitly_access_token') && !SL.config['bitly_access_token'].empty?
+          SL.add_error('Bit.ly not configured', 'Missing access token')
+          return [false, title]
+        end
+
+        domain = SL.config.key?('bitly_domain') ? SL.config['bitly_domain'] : 'bit.ly'
+        long_url = url.dup
+        curl = TTY::Which.which('curl')
+        cmd = [
+          %(#{curl} -SsL -H 'Authorization: Bearer #{SL.config['bitly_access_token']}'),
+          %(-H 'Content-Type: application/json'),
+          '-X POST', %(-d '{ "long_url": "#{url}", "domain": "#{domain}" }'), 'https://api-ssl.bitly.com/v4/shorten'
+        ]
+        data = JSON.parse(`#{cmd.join(' ')}`.strip)
+        link = data['link']
+        title ||= SL::URL.title(long_url)
+        [link, title]
+      end
+    end
+
+    SL::Searches.register 'bitly', :search, self
+  end
+end

data/lib/searchlink/searches/definition.rb

@@ -0,0 +1,67 @@
+module SL
+  # Dictionary Definition Search
+  class DefinitionSearch
+    class << self
+      # Returns a hash of settings for the search
+      #
+      # @return     [Hash] the settings for the search
+      #
+      def settings
+        {
+          trigger: 'def(?:ine)?',
+          searches: [
+            ['def', 'Dictionary Definition'],
+            ['define', nil]
+          ]
+        }
+      end
+
+      # Searches for a definition of the given terms
+      #
+      # @param      _             [String] unused
+      # @param      search_terms  [String] the terms to
+      #                           search for
+      # @param      link_text     [String] the text to use
+      #                           for the link
+      # @return     [Array] the url, title, and link text for the
+      #             search
+      #
+      def search(_, search_terms, link_text)
+        fix = SL.spell(search_terms)
+
+        if fix && search_terms.downcase != fix.downcase
+          SL.add_error('Spelling', "Spelling altered for '#{search_terms}' to '#{fix}'")
+          search_terms = fix
+          link_text = fix
+        end
+
+        url, title = define(search_terms)
+
+        url ? [url, title, link_text] : [false, false, link_text]
+      end
+
+      # Searches for a definition of the given terms
+      #
+      # @param      terms  [String] the terms to search for
+      # @return     [Array] the url and title for the search
+      #
+      def define(terms)
+        def_url = "https://www.wordnik.com/words/#{terms.url_encode}"
+        curl = TTY::Which.which('curl')
+        body = `#{curl} -sSL '#{def_url}'`
+        if body =~ /id="define"/
+          first_definition = body.match(%r{(?mi)(?:id="define"[\s\S]*?<li>)([\s\S]*?)</li>})[1]
+          parts = first_definition.match(%r{<abbr title="partOfSpeech">(.*?)</abbr> (.*?)$})
+          return [def_url, "(#{parts[1]}) #{parts[2]}".gsub(%r{</?.*?>}, '').strip]
+        end
+
+        false
+      rescue StandardError
+        false
+      end
+    end
+
+    # Registers the search with the SL::Searches module
+    SL::Searches.register 'definition', :search, self
+  end
+end