searchlink 2.3.85 → 2.3.87

data/lib/searchlink/plist/generator.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+# = plist
+#
+# Copyright 2006-2010 Ben Bleything and Patrick May
+# Distributed under the MIT License
+#
+
+module Plist
+  # === Create a plist
+  # You can dump an object to a plist in one of two ways:
+  #
+  # * <tt>Plist::Emit.dump(obj)</tt>
+  # * <tt>obj.to_plist</tt>
+  #   * This requires that you mixin the <tt>Plist::Emit</tt> module, which is already done for +Array+ and +Hash+.
+  #
+  # The following Ruby classes are converted into native plist types:
+  #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time, true, false
+  # * +Array+ and +Hash+ are both recursive; their elements will be converted into plist nodes inside the <array> and <dict> containers (respectively).
+  # * +IO+ (and its descendants) and +StringIO+ objects are read from and their contents placed in a <data> element.
+  # * User classes may implement +to_plist_node+ to dictate how they should be serialized; otherwise the object will be passed to <tt>Marshal.dump</tt> and the result placed in a <data> element.
+  #
+  # For detailed usage instructions, refer to USAGE[link:files/docs/USAGE.html] and the methods documented below.
+  module Emit
+    DEFAULT_INDENT = "\t"
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.dump</tt> with +self+.
+    def to_plist(envelope = true, options = {})
+      Plist::Emit.dump(self, envelope, options)
+    end
+
+    # Helper method for injecting into classes.  Calls <tt>Plist::Emit.save_plist</tt> with +self+.
+    def save_plist(filename, options = {})
+      Plist::Emit.save_plist(self, filename, options)
+    end
+
+    # The following Ruby classes are converted into native plist types:
+    #   Array, Bignum, Date, DateTime, Fixnum, Float, Hash, Integer, String, Symbol, Time
+    #
+    # Write us (via RubyForge) if you think another class can be coerced safely into one of the expected plist classes.
+    #
+    # +IO+ and +StringIO+ objects are encoded and placed in <data> elements; other objects are <tt>Marshal.dump</tt>'ed unless they implement +to_plist_node+.
+    #
+    # The +envelope+ parameters dictates whether or not the resultant plist fragment is wrapped in the normal XML/plist header and footer.  Set it to false if you only want the fragment.
+    def self.dump(obj, envelope = true, options = {})
+      options = { :indent => DEFAULT_INDENT }.merge(options)
+
+      output = PlistBuilder.new(options[:indent]).build(obj)
+      output = wrap(output) if envelope
+
+      output
+    end
+
+    # Writes the serialized object's plist to the specified filename.
+    def self.save_plist(obj, filename, options = {})
+      File.open(filename, 'wb') do |f|
+        f.write(obj.to_plist(true, options))
+      end
+    end
+
+    private
+
+    class PlistBuilder
+      def initialize(indent_str)
+        @indent_str = indent_str.to_s
+      end
+
+      def build(element, level=0)
+        if element.respond_to? :to_plist_node
+          element.to_plist_node
+        else
+          case element
+          when Array
+            if element.empty?
+              tag('array', nil, level)
+            else
+              tag('array', nil, level) {
+                element.collect {|e| build(e, level + 1) }.join
+              }
+            end
+          when Hash
+            if element.empty?
+              tag('dict', nil, level)
+            else
+              tag('dict', '', level) do
+                element.sort_by{|k,v| k.to_s }.collect do |k,v| 
+                  tag('key', CGI.escapeHTML(k.to_s), level + 1) +
+                  build(v, level + 1)
+                end.join
+              end
+            end
+          when true, false
+            tag(element, nil, level)
+          when Time
+            tag('date', element.utc.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
+          when Date # also catches DateTime
+            tag('date', element.strftime('%Y-%m-%dT%H:%M:%SZ'), level)
+          when String, Symbol, Integer, Float
+            tag(element_type(element), CGI.escapeHTML(element.to_s), level)
+          when IO, StringIO
+            data = element.tap(&:rewind).read 
+            data_tag(data, level)
+          else
+            data = Marshal.dump(element)
+            comment_tag('The <data> element below contains a Ruby object which has been serialized with Marshal.dump.') +
+            data_tag(data, level)
+          end
+        end
+      end
+
+      private
+
+      def tag(type, contents, level, &block)
+        if block_given?
+          indent("<#{type}>\n", level) +
+          block.call +
+          indent("</#{type}>\n", level)
+        elsif contents.to_s.empty?
+          indent("<#{type}/>\n", level)
+        else
+          indent("<#{type}>#{contents.to_s}</#{type}>\n", level)
+        end
+      end
+
+      def data_tag(data, level)
+        # note that apple plists are wrapped at a different length then
+        # what ruby's pack wraps by default.
+        tag('data', nil, level) do
+          [data].pack("m") # equivalent to Base64.encode64(data)
+                .gsub(/\s+/, '')
+                .scan(/.{1,68}/o)
+                .collect { |line| indent(line, level) }
+                .join("\n")
+                .concat("\n")
+        end
+      end
+
+      def indent(str, level)
+        @indent_str.to_s * level + str
+      end
+
+      def element_type(item)
+        case item
+        when String, Symbol
+          'string'
+        when Integer
+          'integer'
+        when Float
+          'real'
+        else
+          raise "Don't know about this data type... something must be wrong!"
+        end
+      end
+
+      def comment_tag(content)
+        return "<!-- #{content} -->\n"
+      end
+    end
+
+    def self.wrap(contents)
+      output =  '<?xml version="1.0" encoding="UTF-8"?>' + "\n"
+      output << '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' + "\n"
+      output << '<plist version="1.0">' + "\n"
+      output << contents
+      output << '</plist>' + "\n"
+
+      output
+    end
+  end
+end
+
+class Array #:nodoc:
+  include Plist::Emit
+end
+
+class Hash #:nodoc:
+  include Plist::Emit
+end

data/lib/searchlink/plist/parser.rb

@@ -0,0 +1,263 @@
+# encoding: utf-8
+
+# = plist
+#
+# Copyright 2006-2010 Ben Bleything and Patrick May
+# Distributed under the MIT License
+#
+
+# Plist parses Mac OS X xml property list files into ruby data structures.
+#
+# === Load a plist file
+# This is the main point of the library:
+#
+#   r = Plist.parse_xml(filename_or_xml)
+module Plist
+  # Raised when an element is not implemented
+  class UnimplementedElementError < RuntimeError; end
+
+  # Note that I don't use these two elements much:
+  #
+  #  + Date elements are returned as DateTime objects.
+  #  + Data elements are implemented as Tempfiles
+  #
+  # Plist.parse_xml will blow up if it encounters a Date element.
+  # If you encounter such an error, or if you have a Date element which
+  # can't be parsed into a Time object, please create an issue
+  # attaching your plist file at https://github.com/patsplat/plist/issues
+  # so folks can implement the proper support.
+  #
+  # By default, <data> will be assumed to be a marshaled Ruby object and
+  # interpreted with <tt>Marshal.load</tt>. Pass <tt>marshal: false</tt>
+  # to disable this behavior and return the raw binary data as an IO
+  # object instead.
+  def self.parse_xml(filename_or_xml, options={})
+    listener = Listener.new(options)
+    # parser = REXML::Parsers::StreamParser.new(File.new(filename), listener)
+    parser = StreamParser.new(filename_or_xml, listener)
+    parser.parse
+    listener.result
+  end
+
+  class Listener
+    # include REXML::StreamListener
+
+    attr_accessor :result, :open
+
+    def initialize(options={})
+      @result = nil
+      @open   = []
+      @options = { :marshal => true }.merge(options).freeze
+    end
+
+    def tag_start(name, attributes)
+      @open.push PTag.mappings[name].new(@options)
+    end
+
+    def text(contents)
+      if @open.last
+        @open.last.text ||= ''.dup
+        @open.last.text.concat(contents)
+      end
+    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.exist? plist_data_or_file
+        @xml = File.read(plist_data_or_file)
+      else
+        @xml = plist_data_or_file
+      end
+
+      @listener = listener
+    end
+
+    TEXT = /([^<]+)/
+    CDATA = /<!\[CDATA\[(.*?)\]\]>/
+    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/m
+    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/m
+    COMMENT_START = /\A<!--/
+    COMMENT_END = /.*?-->/m
+    UNIMPLEMENTED_ERROR = 'Unimplemented element. ' \
+      'Consider reporting via https://github.com/patsplat/plist/issues'
+
+    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)
+          encoding = parse_encoding_from_xml_declaration(@scanner[1])
+          next if encoding.nil?
+
+          # use the specified encoding for the rest of the file
+          next unless String.method_defined?(:force_encoding)
+          @scanner.string = @scanner.rest.force_encoding(encoding)
+        elsif @scanner.scan(DOCTYPE_PATTERN)
+          next
+        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(CDATA)
+          @listener.text(@scanner[1])
+        elsif @scanner.scan(end_tag)
+          @listener.tag_end(@scanner[1])
+        else
+          raise UnimplementedElementError.new(UNIMPLEMENTED_ERROR)
+        end
+      end
+    end
+
+    private
+
+    def parse_encoding_from_xml_declaration(xml_declaration)
+      return unless defined?(Encoding)
+
+      xml_encoding = xml_declaration.match(/(?:\A|\s)encoding=(?:"(.*?)"|'(.*?)')(?:\s|\Z)/)
+
+      return if xml_encoding.nil?
+
+      begin
+        Encoding.find(xml_encoding[1])
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+
+  class PTag
+    def self.mappings
+      @mappings ||= {}
+    end
+
+    def self.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, :options
+    def initialize(options)
+      @children = []
+      @options = options
+    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 = {}
+      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
+
+  class PData < PTag
+    def to_ruby
+      # unpack("m")[0] is equivalent to Base64.decode64
+      data = text.gsub(/\s+/, '').unpack("m")[0] unless text.nil?
+      begin
+        return Marshal.load(data) if options[:marshal]
+      rescue Exception
+      end
+      io = StringIO.new
+      io.write data
+      io.rewind
+      io
+    end
+  end
+end

data/lib/searchlink/plist/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Plist
+  VERSION = '3.7.2'.freeze
+end

data/lib/searchlink/plist.rb

@@ -1,212 +1,22 @@
-# frozen_string_literal: true
+# encoding: utf-8
 
 # = plist
 #
+# This is the main file for plist. Everything interesting happens in
+# Plist and Plist::Emit.
+#
 # 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 self.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 = []
-    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)
-      @xml = if plist_data_or_file.respond_to? :read
-               plist_data_or_file.read
-             elsif File.exist? plist_data_or_file
-               File.read(plist_data_or_file)
-             else
-               plist_data_or_file
-             end
-
-      @listener = listener
-    end
-
-    TEXT = /([^<]+)/.freeze
-    XMLDECL_PATTERN = /<\?xml\s+(.*?)\?>*/um.freeze
-    DOCTYPE_PATTERN = /\s*<!DOCTYPE\s+(.*?)(\[|>)/um.freeze
-    COMMENT_START = /\A<!--/u.freeze
-    COMMENT_END = /.*?-->/um.freeze
-
-    def parse
-      plist_tags = PTag.mappings.keys.join("|")
-      start_tag = /<(#{plist_tags})([^>]*)>/i
-      end_tag = %r{</(#{plist_tags})[^>]*>}i
-
-      require "strscan"
-
-      @scanner = StringScanner.new(@xml)
-      until @scanner.eos?
-        next unless @scanner.scan(COMMENT_START)
-
-        @scanner.scan(COMMENT_END)
-        if @scanner.scan(start_tag)
-          @listener.tag_start(@scanner[1], nil)
-          @listener.tag_end(@scanner[1]) if @scanner[2] =~ %r{/$}
-        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
-
-    class PTag
-      @@mappings = {}
-      def self.mappings
-        @@mappings
-      end
-
-      def self.inherited(sub_class)
-        key = sub_class.to_s.downcase
-        key.gsub!(/^plist::/, "")
-        key.gsub!(/^p/, "") unless key == "plist"
-
-        @@mappings[key] = sub_class
-        super
-      end
-
-      attr_accessor :text, :children
-
-      def initialize
-        @children = []
-      end
-
-      def to_ruby
-        raise "Unimplemented: #{self.class}#to_ruby on #{inspect}"
-      end
-    end
-
-    class PList < PTag
-      def to_ruby
-        children.first&.to_ruby
-      end
-    end
-
-    class PDict < PTag
-      def to_ruby
-        dict = {}
-        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(&:to_ruby)
-      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"
+require "cgi"
+require "stringio"
 
-    class PData < PTag
-      def to_ruby
-        data = Base64.decode64(text.gsub(/\s+/, ""))
+# import
+require_relative "plist/generator"
 
-        begin
-          Marshal.load(data)
-        rescue Exception
-          io = StringIO.new
-          io.write data
-          io.rewind
-          io
-        end
-      end
-    end
-  end
-end
+# import
+require_relative "plist/parser"
 
-# module Plist
-#   VERSION = '3.1.0'
-# end
+# import
+require_relative "plist/version"

data/lib/searchlink/script_plugin.rb

@@ -55,9 +55,7 @@ module SL
           end
 
           %w[url title link_text].each do |key|
-            unless res.key?(key)
-              raise PluginError.new(%("#{File.basename(@script)}" output missing key "#{key}"), plugin: @filename)
-            end
+            raise PluginError.new(%("#{File.basename(@script)}" output missing key "#{key}"), plugin: @filename) unless res.key?(key)
           end
 
           [res["url"], res["title"], res["link_text"]]

data/lib/searchlink/search.rb

@@ -5,8 +5,6 @@ module SL
   include URL
 
   class SearchLink
-    include Plist
-
     attr_reader :originput, :output, :clipboard
 
     private
@@ -37,9 +35,7 @@ module SL
       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
+          return [false, "Link not valid: #{search_terms}", link_text] if SL.config["validate_links"] && !SL::URL.valid_link?(search_terms)
 
           title = SL::URL.title(search_terms) || search_terms
 

data/lib/searchlink/searches/google.rb

@@ -43,7 +43,9 @@ module SL
           return false
         end
 
-        url = "https://customsearch.googleapis.com/customsearch/v1?cx=338419ee5ac894523&q=#{ERB::Util.url_encode(search_terms.gsub(/%22/, '"'))}&num=1&key=#{@api_key}"
+        url = "https://customsearch.googleapis.com/customsearch/v1?cx=338419ee5ac894523&q=#{ERB::Util.url_encode(search_terms.gsub(
+                                                                                                                   '%22', '"'
+                                                                                                                 ))}&num=1&key=#{@api_key}"
         json = Curl::Json.new(url).json
 
         if json["error"] && json["error"]["code"].to_i == 429