akamai_bookmarklet 0.1.0

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

@@ -0,0 +1,297 @@
+module Nokogiri
+  module XML
+    ###
+    # Nokogiri builder can be used for building XML and HTML documents.
+    #
+    # == Synopsis:
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.products {
+    #         xml.widget {
+    #           xml.id_ "10"
+    #           xml.name "Awesome widget"
+    #         }
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Will output:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <products>
+    #       <widget>
+    #         <id>10</id>
+    #         <name>Awesome widget</name>
+    #       </widget>
+    #     </products>
+    #   </root>
+    #
+    #
+    # === Builder scope
+    #
+    # The builder allows two forms.  When the builder is supplied with a block
+    # that has a parameter, the outside scope is maintained.  This means you
+    # can access variables that are outside your builder.  If you don't need
+    # outside scope, you can use the builder without the "xml" prefix like
+    # this:
+    #
+    #   builder = Nokogiri::XML::Builder.new do
+    #     root {
+    #       products {
+    #         widget {
+    #           id_ "10"
+    #           name "Awesome widget"
+    #         }
+    #       }
+    #     }
+    #   end
+    #
+    # == Special Tags
+    #
+    # The builder works by taking advantage of method_missing.  Unfortunately
+    # some methods are defined in ruby that are difficult or dangerous to
+    # remove.  You may want to create tags with the name "type", "class", and
+    # "id" for example.  In that case, you can use an underscore to
+    # disambiguate your tag name from the method call.
+    #
+    # Here is an example of using the underscore to disambiguate tag names from
+    # ruby methods:
+    #
+    #   @objects = [Object.new, Object.new, Object.new]
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         @objects.each do |o|
+    #           xml.object {
+    #             xml.type_   o.type
+    #             xml.class_  o.class.name
+    #             xml.id_     o.id
+    #           }
+    #         end
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # The underscore may be used with any tag name, and the last underscore
+    # will just be removed.  This code will output the following XML:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <objects>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48390</id>
+    #       </object>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48380</id>
+    #       </object>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48370</id>
+    #       </object>
+    #     </objects>
+    #   </root>
+    #
+    # == Tag Attributes
+    #
+    # Tag attributes may be supplied as method arguments.  Here is our
+    # previous example, but using attributes rather than tags:
+    #
+    #   @objects = [Object.new, Object.new, Object.new]
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         @objects.each do |o|
+    #           xml.object(:type => o.type, :class => o.class, :id => o.id)
+    #         end
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # === Tag Attribute Short Cuts
+    #
+    # A couple attribute short cuts are available when building tags.  The
+    # short cuts are available by special method calls when building a tag.
+    #
+    # This example builds an "object" tag with the class attribute "classy"
+    # and the id of "thing":
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         xml.object.classy.thing!
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Which will output:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <objects>
+    #       <object class="classy" id="thing"/>
+    #     </objects>
+    #   </root>
+    #
+    # All other options are still supported with this syntax, including
+    # blocks and extra tag attributes.
+    class Builder
+      # The current Document object being built
+      attr_accessor :doc
+
+      # The parent of the current node being built
+      attr_accessor :parent
+
+      # A context object for use when the block has no arguments
+      attr_accessor :context
+
+      attr_accessor :arity # :nodoc:
+
+      ###
+      # Create a new Builder object.  +options+ are sent to the top level
+      # Document that is being built.
+      #
+      # Building a document with a particular encoding for example:
+      #
+      #   Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+      #     ...
+      #   end
+      def initialize options = {}, &block
+        namespace = self.class.name.split('::')
+        namespace[-1] = 'Document'
+        @doc      = eval(namespace.join('::')).new
+        @parent   = @doc
+        @context  = nil
+        @arity    = nil
+
+        options.each do |k,v|
+          @doc.send(:"#{k}=", v)
+        end
+
+        return unless block_given?
+
+        @arity = block.arity
+        if @arity <= 0
+          @context = eval('self', block.binding)
+          instance_eval(&block)
+        else
+          yield self
+        end
+
+        @parent = @doc
+      end
+
+      ###
+      # Create a Text Node with content of +string+
+      def text string
+        node = Nokogiri::XML::Text.new(string.to_s, @doc)
+        insert(node)
+      end
+
+      ###
+      # Create a CDATA Node with content of +string+
+      def cdata string
+        node = Nokogiri::XML::CDATA.new(@doc, string.to_s)
+        insert(node)
+      end
+
+      ###
+      # Convert this Builder object to XML
+      def to_xml
+        @doc.to_xml
+      end
+
+      def method_missing method, *args, &block # :nodoc:
+        if @context && @context.respond_to?(method)
+          @context.send(method, *args, &block)
+        else
+          node = Nokogiri::XML::Node.new(method.to_s.sub(/[_!]$/, ''), @doc) { |n|
+            args.each do |arg|
+              case arg
+              when Hash
+                arg.each { |k,v| n[k.to_s] = v.to_s }
+              else
+                n.content = arg
+              end
+            end
+          }
+          insert(node, &block)
+        end
+      end
+
+      private
+      ###
+      # Insert +node+ as a child of the current Node
+      def insert(node, &block)
+        node.parent = @parent
+        if block_given?
+          @parent = node
+          @arity ||= block.arity
+          if @arity <= 0
+            instance_eval(&block)
+          else
+            block.call(self)
+          end
+          @parent = node.parent
+        end
+        NodeBuilder.new(node, self)
+      end
+
+      class NodeBuilder # :nodoc:
+        def initialize(node, doc_builder)
+          @node = node
+          @doc_builder = doc_builder
+        end
+
+        def []= k, v
+          @node[k] = v
+        end
+
+        def [] k
+          @node[k]
+        end
+
+        def method_missing(method, *args, &block)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          case method.to_s
+          when /^(.*)!$/
+            @node['id'] = $1
+            @node.content = args.first if args.first
+          when /^(.*)=/
+            @node[$1] = args.first
+          else
+            @node['class'] = 
+              ((@node['class'] || '').split(/\s/) + [method.to_s]).join(' ')
+            @node.content = args.first if args.first
+          end
+
+          # Assign any extra options
+          opts.each do |k,v|
+            @node[k.to_s] = ((@node[k.to_s] || '').split(/\s/) + [v]).join(' ')
+          end
+
+          if block_given?
+            old_parent = @doc_builder.parent
+            @doc_builder.parent = @node
+            value = @doc_builder.instance_eval(&block)
+            @doc_builder.parent = old_parent
+            return value
+          end
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class CDATA < Nokogiri::XML::Text
+      ###
+      # Get the name of this CDATA node
+      def name
+        '#cdata-section'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Nokogiri
+  module XML
+    ####
+    # Nokogiri::XML::Document is the main entry point for dealing with
+    # XML documents.  The Document is created by parsing an XML document.
+    # See Nokogiri.XML()
+    #
+    # For searching a Document, see Nokogiri::XML::Node#css and
+    # Nokogiri::XML::Node#xpath
+    class Document < Node
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      attr_accessor :errors
+
+      def initialize *args
+        @decorators = nil
+      end
+
+      # The name of this document.  Always returns "document"
+      def name
+        'document'
+      end
+
+      # A reference to +self+
+      def document
+        self
+      end
+
+      # Get the list of decorators given +key+
+      def decorators key
+        @decorators ||= Hash.new
+        @decorators[key] ||= []
+      end
+
+      ###
+      # Validate this Document against it's DTD.  Returns a list of errors on
+      # the document or +nil+ when there is no DTD.
+      def validate
+        return nil unless internal_subset
+        internal_subset.validate self
+      end
+
+      ###
+      # Explore a document with shortcut methods.
+      def slop!
+        unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
+          decorators(XML::Node) << Nokogiri::Decorators::Slop
+          decorate!
+        end
+
+        self
+      end
+
+      ###
+      # Apply any decorators to +node+
+      def decorate node
+        return unless @decorators
+        @decorators.each { |klass,list|
+          next unless node.is_a?(klass)
+          list.each { |moodule| node.extend(moodule) }
+        }
+      end
+
+      alias :to_xml :serialize
+      alias :clone :dup
+
+      # Get the hash of namespaces on the root Nokogiri::XML::Node
+      def namespaces
+        root ? root.collect_namespaces : {}
+      end
+
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      def fragment tags
+        DocumentFragment.new(self, tags)
+      end
+
+      undef_method :swap, :parent, :namespace, :default_namespace=
+      undef_method :add_namespace_definition
+
+      def add_child child
+        if [Node::ELEMENT_NODE, Node::DOCUMENT_FRAG_NODE].include? child.type
+          raise "Document already has a root node" if root
+        end
+        super
+      end
+      alias :<< :add_child
+
+      class << self
+        ###
+        # Parse an XML file.  +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 = ParseOptions::DEFAULT_XML, &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?(: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/xml/document_fragment.rb

@@ -0,0 +1,49 @@
+module Nokogiri
+  module XML
+    class DocumentFragment < Nokogiri::XML::Node
+      def initialize document, tags=nil
+        if tags
+          parser = if self.kind_of?(Nokogiri::HTML::DocumentFragment)
+                     HTML::SAX::Parser.new(FragmentHandler.new(self, tags))
+                   else
+                     XML::SAX::Parser.new(FragmentHandler.new(self, tags))
+                   end
+          parser.parse(tags)
+        end
+      end
+
+      ###
+      # return the name for DocumentFragment
+      def name
+        '#document-fragment'
+      end
+
+      def to_s
+        children.to_s
+      end
+
+      def to_html *args
+        children.to_html(*args)
+      end
+
+      def to_xhtml *args
+        children.to_xhtml(*args)
+      end
+
+      def to_xml *args
+        children.to_xml(*args)
+      end
+
+      alias :serialize :to_s
+
+      class << self
+        ####
+        # Create a Nokogiri::XML::DocumentFragment from +tags+
+        def parse tags
+          self.new(XML::Document.new, tags)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class DTD < Nokogiri::XML::Node
+      ###
+      # Return attributes for DTD.  Always returns +nil+
+      def attributes
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Nokogiri
+  module XML
+    class EntityDeclaration < Nokogiri::XML::Node
+      ###
+      # return attributes.  Always returns +nil+
+      def attributes
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Nokogiri
+  module XML
+    class FragmentHandler < Nokogiri::XML::SAX::Document # :nodoc:
+      def initialize node, original_html
+        @doc_started    = false
+        @document       = node.document
+        @stack          = [node]
+        @klass          = if node.kind_of?(Nokogiri::HTML::DocumentFragment)
+                            Nokogiri::HTML::DocumentFragment
+                          else
+                            Nokogiri::XML::DocumentFragment
+                          end
+        #
+        # the regexes used in start_element() and characters() anchor at
+        # start-of-line, but we really only want them to anchor at
+        # start-of-doc. so let's only save up to the first newline.
+        #
+        # this implementation choice was the result of some benchmarks, if
+        # you're curious: http://gist.github.com/115936
+        #
+        @original_html = original_html.lstrip
+        newline_index = @original_html.index("\n")
+        @original_html = @original_html[0,newline_index] if newline_index
+      end
+
+      def start_element name, attrs = []
+        regex = (@klass == Nokogiri::HTML::DocumentFragment) ? %r{^\s*<#{Regexp.escape(name)}}i \
+                                                             : %r{^\s*<#{Regexp.escape(name)}}
+        @doc_started = true if @original_html =~ regex
+        return unless @doc_started
+
+        node = Element.new(name, @document)
+        attrs << "" unless (attrs.length % 2) == 0
+        Hash[*attrs].each do |k,v|
+          node[k] = v
+        end
+        @stack.last << node
+        @stack << node
+      end
+
+      def characters string
+        @doc_started = true if @original_html.strip =~ %r{^\s*#{Regexp.escape(string.strip)}}
+        @stack.last << Nokogiri::XML::Text.new(string, @document)
+      end
+
+      def comment string
+        @stack.last << Nokogiri::XML::Comment.new(@document, string)
+      end
+
+      def cdata_block string
+        @stack.last << Nokogiri::XML::CDATA.new(@document, string)
+      end
+
+      def end_element name
+        return unless @stack.last.name == name
+        @stack.pop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Nokogiri
+  module XML
+    class Namespace
+      attr_reader :document
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Nokogiri
+  module XML
+    class Node
+      ###
+      # Save options for serializing nodes
+      class SaveOptions
+        # Format serialized xml
+        FORMAT          = 1
+        # Do not include delcarations
+        NO_DECLARATION  = 2
+        # Do not include empty tags
+        NO_EMPTY_TAGS   = 4
+        # Do not save XHTML
+        NO_XHTML        = 8
+        # Save as XHTML
+        AS_XHTML        = 16
+        # Save as XML
+        AS_XML          = 32
+        # Save as HTML
+        AS_HTML         = 64
+
+        # Integer representation of the SaveOptions
+        attr_reader :options
+
+        # Create a new SaveOptions object with +options+
+        def initialize options = 0; @options = options; end
+        constants.each do |constant|
+          class_eval %{
+            def #{constant.downcase}
+              @options |= #{constant}
+              self
+            end
+
+            def #{constant.downcase}?
+              #{constant} & @options == #{constant}
+            end
+          }
+        end
+      end
+    end
+  end
+end