akamai_bookmarklet 0.1.0

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/ffi/xml/xpath_context.rb

@@ -0,0 +1,135 @@
+module Nokogiri
+  module XML
+    class XPathContext
+
+      attr_accessor :cstruct # :nodoc:
+
+      def register_ns(prefix, uri) # :nodoc:
+        LibXML.xmlXPathRegisterNs(cstruct, prefix, uri)
+      end
+
+      def evaluate(search_path, xpath_handler=nil) # :nodoc:
+        lookup = nil # to keep lambda in scope long enough to avoid a possible GC tragedy
+        query = search_path.to_s
+
+        if xpath_handler
+          lookup = lambda do |ctx, name, uri|
+            return nil unless xpath_handler.respond_to?(name)
+            ruby_funcall name, xpath_handler
+          end
+          LibXML.xmlXPathRegisterFuncLookup(cstruct, lookup, nil);
+        end
+
+        exception_handler = lambda do |ctx, error|
+          raise XPath::SyntaxError.wrap(error)
+        end
+        LibXML.xmlResetLastError()
+        LibXML.xmlSetStructuredErrorFunc(nil, exception_handler)
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xmlSetGenericErrorFunc(nil, generic_exception_handler)
+
+        xpath_ptr = LibXML.xmlXPathEvalExpression(query, cstruct)
+
+        LibXML.xmlSetStructuredErrorFunc(nil, nil)
+        LibXML.xmlSetGenericErrorFunc(nil, nil)
+
+        if xpath_ptr.null?
+          error = LibXML.xmlGetLastError()
+          raise XPath::SyntaxError.wrap(error)
+        end
+
+        xpath = XML::XPath.new
+        xpath.cstruct = LibXML::XmlXpathObject.new(xpath_ptr)
+        xpath.document = cstruct[:doc]
+        xpath
+      end
+
+      def self.new(node) # :nodoc:
+        LibXML.xmlXPathInit()
+
+        ptr = LibXML.xmlXPathNewContext(node.cstruct[:doc])
+
+        ctx = allocate
+        ctx.cstruct = LibXML::XmlXpathContext.new(ptr)
+        ctx.cstruct[:node] = node.cstruct
+        ctx
+      end
+
+      private
+
+      #
+      #  returns a lambda that will call the handler function with marshalled parameters
+      #
+      def ruby_funcall(name, xpath_handler) # :nodoc:
+        lambda do |ctx, nargs|
+          parser_context = LibXML::XmlXpathParserContext.new(ctx)
+          context = parser_context.context
+          doc = context.doc.ruby_doc
+
+          params = []
+
+          nargs.times do |j|
+            obj = LibXML::XmlXpathObject.new(LibXML.valuePop(ctx))
+            case obj[:type]
+            when LibXML::XmlXpathObject::XPATH_STRING
+              params.unshift obj[:stringval]
+            when LibXML::XmlXpathObject::XPATH_BOOLEAN
+              params.unshift obj[:boolval] == 1
+            when LibXML::XmlXpathObject::XPATH_NUMBER
+              params.unshift obj[:floatval]
+            when LibXML::XmlXpathObject::XPATH_NODESET
+              ns_ptr = LibXML::XmlNodeSet.new(obj[:nodesetval])
+              set = NodeSet.allocate
+              set.cstruct = ns_ptr
+              params.unshift set
+            else
+              char_ptr = params.unshift LibXML.xmlXPathCastToString(obj)
+              string = char_ptr.read_string
+              LibXML.xmlFree(char_ptr)
+              string
+            end
+          end
+
+          result = xpath_handler.send(name, *params)
+
+          case result.class.to_s
+          when Fixnum.to_s, Float.to_s, Bignum.to_s
+            LibXML.xmlXPathReturnNumber(ctx, result)
+          when String.to_s
+            LibXML.xmlXPathReturnString(
+              ctx,
+              LibXML.xmlXPathWrapCString(result)
+              )
+          when TrueClass.to_s
+            LibXML.xmlXPathReturnTrue(ctx)
+          when FalseClass.to_s
+            LibXML.xmlXPathReturnFalse(ctx)
+          when NilClass.to_s
+            ;
+          when Array.to_s
+            node_set = XML::NodeSet.new(doc, result)
+            LibXML.xmlXPathReturnNodeSet(
+              ctx,
+              LibXML.xmlXPathNodeSetMerge(nil, node_set.cstruct)
+              )
+          else
+            if result.is_a?(XML::NodeSet)
+              LibXML.xmlXPathReturnNodeSet(
+                ctx,
+                LibXML.xmlXPathNodeSetMerge(nil, result.cstruct)
+                )
+            else
+              raise RuntimeError.new("Invalid return type #{result.class.inspect}")
+            end
+          end
+
+          nil
+        end # lambda
+      end # ruby_funcall
+
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/ffi/xslt/stylesheet.rb

@@ -0,0 +1,47 @@
+module Nokogiri
+  module XSLT
+    class Stylesheet
+
+      attr_accessor :cstruct # :nodoc:
+
+      def self.parse_stylesheet_doc(document) # :nodoc:
+        LibXML.exsltRegisterAll
+
+        generic_exception_handler = lambda do |ctx, msg|
+          raise RuntimeError.new(msg) # TODO: varargs
+        end
+        LibXML.xsltSetGenericErrorFunc(nil, generic_exception_handler)
+
+        ss = LibXML.xsltParseStylesheetDoc(LibXML.xmlCopyDoc(document.cstruct, 1)) # 1 => recursive
+
+        LibXML.xsltSetGenericErrorFunc(nil, nil)
+
+        obj = allocate
+        obj.cstruct = LibXML::XsltStylesheet.new(ss)
+        obj
+      end
+
+      def serialize(document) # :nodoc:
+        buf_ptr = FFI::MemoryPointer.new :pointer
+        buf_len = FFI::MemoryPointer.new :int
+        LibXML.xsltSaveResultToString(buf_ptr, buf_len, document.cstruct, cstruct)
+        buf = Nokogiri::LibXML::XmlAlloc.new(buf_ptr.read_pointer)
+        buf.pointer.read_string(buf_len.read_int)
+      end
+
+      def transform(document, params=[]) # :nodoc:
+        param_arr = FFI::MemoryPointer.new(:pointer, params.length + 1)
+        params.each_with_index do |param, j|
+          param_arr[j].put_pointer(0, FFI::MemoryPointer.from_string(param.to_s))
+        end
+        param_arr[params.length].put_pointer(0,nil)
+
+        ptr = LibXML.xsltApplyStylesheet(cstruct, document.cstruct, param_arr)
+        raise(RuntimeError, "could not perform xslt transform on document") if ptr.null?
+
+        XML::Document.wrap(ptr)
+      end
+
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/hpricot.rb

@@ -0,0 +1,92 @@
+require 'nokogiri'
+
+module Nokogiri
+  module Hpricot
+    # STag compatibility proxy
+    STag = String
+    # Elem compatibility proxy
+    Elem = XML::Node
+    # NamedCharacters compatibility proxy
+    NamedCharacters = Nokogiri::HTML::NamedCharacters
+    class << self
+      # parse proxy
+      def parse(*args)
+        warn <<-eomsg
+Nokogiri::Hpricot.parse is deprecated and will be extracted to it's own gem
+when Nokogiri 1.4.0 is released.  Please switch to Nokogiri(), or be prepared
+to install the compatibility layer.
+#{caller.first}
+eomsg
+        doc = Nokogiri.parse(*args)
+        add_decorators(doc)
+      end
+
+      # XML proxy
+      def XML(string)
+        warn <<-eomsg
+Nokogiri::Hpricot.parse is deprecated and will be extracted to it's own gem
+when Nokogiri 1.4.0 is released.  Please switch to Nokogiri::XML(), or be
+prepared to install the compatibility layer.
+#{caller.first}
+eomsg
+        doc = Nokogiri::XML::Document.parse(string)
+        add_decorators(doc)
+      end
+
+      # HTML proxy
+      def HTML(string)
+        warn <<-eomsg
+Nokogiri::Hpricot.parse is deprecated and will be extracted to it's own gem
+when Nokogiri 1.4.0 is released.  Please switch to Nokogiri::HTML(), or be
+prepared to install the compatibility layer.
+#{caller.first}
+eomsg
+        doc = Nokogiri::HTML::Document.parse(string)
+        add_decorators(doc)
+      end
+
+      # make proxy
+      def make string
+        warn <<-eomsg
+Nokogiri::Hpricot.parse is deprecated and will be extracted to it's own gem
+when Nokogiri 1.4.0 is released.  Please switch to Nokogiri::HTML.make(), or be
+prepared to install the compatibility layer.
+#{caller.first}
+eomsg
+        doc = XML::Document.new
+        ns = XML::NodeSet.new(doc)
+        ns << XML::Text.new(string, doc)
+        ns
+      end
+
+      # Add compatibility decorators
+      def add_decorators(doc)
+        doc.decorators(XML::Node) << Decorators::Hpricot::Node
+        doc.decorators(XML::NodeSet) << Decorators::Hpricot::NodeSet
+        doc.decorate!
+        doc
+      end
+    end
+  end
+
+  class << self
+    ###
+    # Parse a document and apply the Hpricot decorators for Hpricot
+    # compatibility mode.
+    def Hpricot(*args, &block)
+        warn <<-eomsg
+Nokogiri::Hpricot.parse is deprecated and will be extracted to it's own gem
+when Nokogiri 1.4.0 is released.  Please switch to Nokogiri(), or be
+prepared to install the compatibility layer.
+#{caller.first}
+eomsg
+      if block_given?
+        builder = Nokogiri::HTML::Builder.new(&block)
+        Nokogiri::Hpricot.add_decorators(builder.doc)
+      else
+        doc = Nokogiri.parse(*args)
+        Nokogiri::Hpricot.add_decorators(doc)
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/builder.rb

@@ -0,0 +1,35 @@
+module Nokogiri
+  module HTML
+    ###
+    # Nokogiri HTML builder is used for building HTML documents.  It is very
+    # similar to the Nokogiri::XML::Builder.  In fact, you should go read the
+    # documentation for Nokogiri::XML::Builder before reading this
+    # documentation.
+    #
+    # == Synopsis:
+    #
+    # Create an HTML document with a body that has an onload attribute, and a
+    # span tag with a class of "bold" that has content of "Hello world".
+    #
+    #   builder = Nokogiri::HTML::Builder.new do |doc|
+    #     doc.html {
+    #       doc.body(:onload => 'some_func();') {
+    #         doc.span.bold {
+    #           doc.text "Hello world"
+    #         }
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_html
+    #
+    # The HTML builder inherits from the XML builder, so make sure to read the
+    # Nokogiri::XML::Builder documentation.
+    class Builder < Nokogiri::XML::Builder
+      ###
+      # Convert the builder to HTML
+      def to_html
+        @doc.to_html
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/document.rb

@@ -0,0 +1,73 @@
+module Nokogiri
+  module HTML
+    class Document < Nokogiri::XML::Document
+
+      def initialize *args
+        super
+      end
+
+      ####
+      # Serialize this Document with +encoding+ using +options+
+      def serialize *args
+        if args.first && !args.first.is_a?(Hash)
+          $stderr.puts(<<-eowarn)
+#{self.class}#serialize(encoding, save_opts) is deprecated and will be removed in
+Nokogiri version 1.4.0 *or* after June 1 2009.
+You called serialize from here:
+
+  #{caller.join("\n")}
+
+Please change to #{self.class}#serialize(:encoding => enc, :save_with => opts)
+          eowarn
+        end
+
+        options = args.first.is_a?(Hash) ? args.shift : {
+          :encoding   => args[0],
+          :save_with  => args[1] || XML::Node::SaveOptions::FORMAT |
+            XML::Node::SaveOptions::AS_HTML |
+            XML::Node::SaveOptions::NO_DECLARATION |
+            XML::Node::SaveOptions::NO_EMPTY_TAGS
+        }
+        super(options)
+      end
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      def fragment tags
+        DocumentFragment.new(self, tags)
+      end
+
+      class << self
+        ###
+        # Parse HTML.  +thing+ may be a String, or any object that
+        # responds to _read_ and _close_ such as an IO, or StringIO.
+        # +url+ is resource where this document is located.  +encoding+ is the
+        # encoding that should be used when processing the document. +options+
+        # is a number that sets options in the parser, such as
+        # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
+        # Nokogiri::XML::ParseOptions.
+        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+
+          options = Nokogiri::XML::ParseOptions.new(options) if Fixnum === options
+          # Give the options to the user
+          yield options if block_given?
+
+          if string_or_io.respond_to?(:encoding)
+            encoding ||= string_or_io.encoding.name
+          end
+
+          if string_or_io.respond_to?(:read)
+            url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+            return self.read_io(string_or_io, url, encoding, options.to_i)
+          end
+
+          # read_memory pukes on empty docs
+          return self.new if string_or_io.nil? or string_or_io.empty?
+
+          self.read_memory(string_or_io, url, encoding, options.to_i)
+        end
+      end
+
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/document_fragment.rb

@@ -0,0 +1,15 @@
+module Nokogiri
+  module HTML
+    class DocumentFragment < Nokogiri::XML::DocumentFragment
+
+      class << self
+        ####
+        # Create a Nokogiri::XML::DocumentFragment from +tags+
+        def parse tags
+          self.new(HTML::Document.new, tags)
+        end
+      end
+
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/element_description.rb

@@ -0,0 +1,23 @@
+module Nokogiri
+  module HTML
+    class ElementDescription
+      ###
+      # Is this element a block element?
+      def block?
+        !inline?
+      end
+
+      ###
+      # Convert this description to a string
+      def to_s
+        "#{name}: #{description}"
+      end
+
+      ###
+      # Inspection information
+      def inspect
+        "#<#{self.class.name}: #{name} #{description}>"
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/entity_lookup.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module HTML
+    class EntityDescription < Struct.new(:value, :name, :description); end
+
+    class EntityLookup
+      ###
+      # Look up entity with +name+
+      def [] name
+        (val = get(name)) && val.value
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html/sax/parser.rb

@@ -0,0 +1,48 @@
+module Nokogiri
+  module HTML
+    ###
+    # Nokogiri lets you write a SAX parser to process HTML but get HTML
+    # correction features.
+    #
+    # See Nokogiri::HTML::SAX::Parser for a basic example of using a
+    # SAX parser with HTML.
+    #
+    # For more information on SAX parsers, see Nokogiri::XML::SAX
+    module SAX
+      ###
+      # This class lets you perform SAX style parsing on HTML with HTML
+      # error correction.
+      #
+      # Here is a basic usage example:
+      #
+      #   class MyDoc < Nokogiri::XML::SAX::Document
+      #     def start_element name, attributes = []
+      #       puts "found a #{name}"
+      #     end
+      #   end
+      #
+      #   parser = Nokogiri::HTML::SAX::Parser.new(MyDoc.new)
+      #   parser.parse(File.read(ARGV[0], 'rb'))
+      #
+      # For more information on SAX parsers, see Nokogiri::XML::SAX
+      class Parser < Nokogiri::XML::SAX::Parser
+        ###
+        # Parse html stored in +data+ using +encoding+
+        def parse_memory data, encoding = 'UTF-8'
+          raise ArgumentError unless data
+          return unless data.length > 0
+          native_parse_memory data, encoding
+        end
+
+        ###
+        # Parse a file with +filename+
+        def parse_file filename, encoding = 'UTF-8'
+          raise ArgumentError unless filename
+          raise Errno::ENOENT unless File.exists?(filename)
+          raise Errno::EISDIR if File.directory?(filename)
+          native_parse_file filename, encoding
+        end
+      end
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/html.rb

@@ -0,0 +1,34 @@
+require 'nokogiri/html/entity_lookup'
+require 'nokogiri/html/document'
+require 'nokogiri/html/document_fragment'
+require 'nokogiri/html/sax/parser'
+require 'nokogiri/html/element_description'
+
+module Nokogiri
+  class << self
+    ###
+    # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+      Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
+    end
+  end
+
+  module HTML
+    class << self
+      ###
+      # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
+        Document.parse(thing, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string
+        HTML::DocumentFragment.parse(string)
+      end
+    end
+
+    # Instance of Nokogiri::HTML::EntityLookup
+    NamedCharacters = EntityLookup.new
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/syntax_error.rb

@@ -0,0 +1,4 @@
+module Nokogiri
+  class SyntaxError < ::StandardError
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/version.rb

@@ -0,0 +1,33 @@
+module Nokogiri
+  # The version of Nokogiri you are using
+  VERSION = '1.3.3'
+
+  # More complete version information about libxml
+  VERSION_INFO = {}
+  VERSION_INFO['warnings']              = []
+  VERSION_INFO['nokogiri']              = VERSION
+  if defined?(LIBXML_VERSION)
+    VERSION_INFO['libxml']              = {}
+    VERSION_INFO['libxml']['binding']   = 'extension'
+    VERSION_INFO['libxml']['compiled']  = LIBXML_VERSION
+    VERSION_INFO['libxml']['loaded']    = LIBXML_PARSER_VERSION.scan(/^(.*)(..)(..)$/).first.collect{|j|j.to_i}.join(".")
+
+    if VERSION_INFO['libxml']['compiled'] != VERSION_INFO['libxml']['loaded']
+      warning = "Nokogiri was built against LibXML version #{VERSION_INFO['libxml']['compiled']}, but has dynamically loaded #{VERSION_INFO['libxml']['loaded']}"
+      VERSION_INFO['warnings'] << warning
+      warn "WARNING: #{warning}"
+    end
+  end
+
+  def self.uses_libxml? # :nodoc:
+    !Nokogiri::VERSION_INFO['libxml'].nil?
+  end
+
+  def self.ffi? # :nodoc:
+    uses_libxml? && Nokogiri::VERSION_INFO['libxml']['binding'] == 'ffi'
+  end
+
+  def self.is_2_6_16? # :nodoc:
+    Nokogiri::VERSION_INFO['libxml']['loaded'] <= '2.6.16'
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/version_warning.rb

@@ -0,0 +1,11 @@
+module Nokogiri
+  if self.is_2_6_16? && !defined?(I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2)
+    warn <<-eom
+HI.  You're using libxml2 version 2.6.16 which is over 4 years old and has
+plenty of bugs.  We suggest that for maximum HTML/XML parsing pleasure, you
+upgrade your version of libxml2 and re-install nokogiri.  If you like using
+libxml2 version 2.6.16, but don't like this warning, please define the constant
+I_KNOW_I_AM_USING_AN_OLD_AND_BUGGY_VERSION_OF_LIBXML2 before requring nokogiri.
+    eom
+  end
+end

data/vendor/gems/ruby/1.8/gems/nokogiri-1.3.3/lib/nokogiri/xml/attr.rb

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class Attr < Node
+      alias :value :content
+      alias :to_s :content
+      alias :content= :value=
+    end
+  end
+end