nokogiri-maglev- 1.5.0.1

data/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/lib/nokogiri/xml/character_data.rb

@@ -0,0 +1,7 @@
+module Nokogiri
+  module XML
+    class CharacterData < Nokogiri::XML::Node
+      include Nokogiri::XML::PP::CharacterData
+    end
+  end
+end

data/lib/nokogiri/xml/document.rb

@@ -0,0 +1,234 @@
+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 < Nokogiri::XML::Node
+      ##
+      # Parse an XML file.  +string_or_io+ 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 self.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 read_io(string_or_io, url, encoding, options.to_i)
+        end
+
+        # read_memory pukes on empty docs
+        return new if string_or_io.nil? or string_or_io.empty?
+
+        read_memory(string_or_io, url, encoding, options.to_i)
+      end
+
+      # A list of Nokogiri::XML::SyntaxError found when parsing a document
+      attr_accessor :errors
+
+      def initialize *args # :nodoc:
+        @errors     = []
+        @decorators = nil
+      end
+
+      ##
+      # Create an element with +name+, and optionally setting the content and attributes.
+      #
+      #   doc.create_element "div" # <div></div>
+      #   doc.create_element "div", :class => "container" # <div class='container'></div>
+      #   doc.create_element "div", "contents" # <div>contents</div>
+      #   doc.create_element "div", "contents", :class => "container" # <div class='container'>contents</div>
+      #   doc.create_element "div" { |node| node['class'] = "container" } # <div class='container'></div>
+      #
+      def create_element name, *args, &block
+        elm = Nokogiri::XML::Element.new(name, self, &block)
+        args.each do |arg|
+          case arg
+          when Hash
+            arg.each { |k,v|
+              key = k.to_s
+              if key =~ /^xmlns(:\w+)?$/
+                ns_name = key.split(":", 2)[1]
+                elm.add_namespace_definition ns_name, v
+                next
+              end
+              elm[k.to_s] = v.to_s
+            }
+          else
+            elm.content = arg
+          end
+        end
+        elm
+      end
+
+      # Create a text node with +text+
+      def create_text_node text, &block
+        Nokogiri::XML::Text.new(text.to_s, self, &block)
+      end
+
+      # Create a CDATA element containing +text+
+      def create_cdata text
+        Nokogiri::XML::CDATA.new(self, text.to_s)
+      end
+
+      # The name of this document.  Always returns "document"
+      def name
+        'document'
+      end
+
+      # A reference to +self+
+      def document
+        self
+      end
+
+      ##
+      # Recursively get all namespaces from this node and its subtree and
+      # return them as a hash.
+      #
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:hello="world" />
+      #   </root>
+      #
+      # This method will return:
+      #
+      #   { 'xmlns:foo' => 'bar', 'xmlns:hello' => 'world' }
+      #
+      # WARNING: this method will clobber duplicate names in the keys.
+      # For example, given this document:
+      #
+      #   <root xmlns:foo="bar">
+      #     <bar xmlns:foo="baz" />
+      #   </root>
+      #
+      # The hash returned will look like this: { 'xmlns:foo' => 'bar' }
+      #
+      # Non-prefixed default namespaces (as in "xmlns=") are not included
+      # in the hash.
+      #
+      # Note this is a very expensive operation in current implementation, as it
+      # traverses the entire graph, and also has to bring each node accross the
+      # libxml bridge into a ruby object.
+      def collect_namespaces
+        ns = {}
+        traverse { |j| ns.merge!(j.namespaces) }
+        ns
+      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. See Nokogiri::Slop for details.
+      #
+      # Note that any nodes that have been instantiated before #slop!
+      # is called will not be decorated with sloppy behavior. So, if you're in
+      # irb, the preferred idiom is:
+      #
+      #   irb> doc = Nokogiri::Slop my_markup
+      #
+      # and not
+      #
+      #   irb> doc = Nokogiri::HTML my_markup
+      #   ... followed by irb's implicit inspect (and therefore instantiation of every node) ...
+      #   irb> doc.slop!
+      #   ... which does absolutely nothing.
+      #
+      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.namespaces : {}
+      end
+
+      ##
+      # Create a Nokogiri::XML::DocumentFragment from +tags+
+      # Returns an empty fragment if +tags+ is nil.
+      def fragment tags = nil
+        DocumentFragment.new(self, tags, self.root)
+      end
+
+      undef_method :swap, :parent, :namespace, :default_namespace=
+      undef_method :add_namespace_definition, :attributes
+      undef_method :namespace_definitions, :line, :add_namespace
+
+      def add_child child
+        raise "Document already has a root node" if root
+        if child.type == Node::DOCUMENT_FRAG_NODE
+          raise "Document cannot have multiple root nodes" if child.children.size > 1
+          super(child.children.first)
+        else
+          super
+        end
+      end
+      alias :<< :add_child
+
+      ##
+      # +JRuby+
+      # Wraps Java's org.w3c.dom.document and returns Nokogiri::XML::Document
+      def self.wrap document
+        raise "JRuby only method" unless Nokogiri.jruby?
+        return wrapJavaDocument(document)
+      end
+
+      ##
+      # +JRuby+
+      # Returns Java's org.w3c.dom.document of this Document.
+      def to_java
+        raise "JRuby only method" unless Nokogiri.jruby?
+        return toJavaDocument()
+      end
+
+      private
+      def implied_xpath_context
+        "/"
+      end
+
+      def inspect_attributes
+        [:name, :children]
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/document_fragment.rb

@@ -0,0 +1,98 @@
+module Nokogiri
+  module XML
+    class DocumentFragment < Nokogiri::XML::Node
+      ##
+      #  Create a new DocumentFragment from +tags+.
+      #
+      #  If +ctx+ is present, it is used as a context node for the
+      #  subtree created, e.g., namespaces will be resolved relative
+      #  to +ctx+.
+      def initialize document, tags = nil, ctx = nil
+        return self unless tags
+
+        children = if ctx
+                     ctx.parse(tags)
+                   else
+                     XML::Document.parse("<root>#{tags}</root>") \
+                       .xpath("/root/node()")
+                   end
+        children.each { |child| child.parent = self }
+      end
+
+      ###
+      # return the name for DocumentFragment
+      def name
+        '#document-fragment'
+      end
+
+      ###
+      # Convert this DocumentFragment to a string
+      def to_s
+        children.to_s
+      end
+
+      ###
+      # Convert this DocumentFragment to html
+      # See Nokogiri::XML::NodeSet#to_html
+      def to_html *args
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
+          end
+          args.insert(0, options)
+        end
+        children.to_html(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xhtml
+      # See Nokogiri::XML::NodeSet#to_xhtml
+      def to_xhtml *args
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_XHTML
+          end
+          args.insert(0, options)
+        end
+        children.to_xhtml(*args)
+      end
+
+      ###
+      # Convert this DocumentFragment to xml
+      # See Nokogiri::XML::NodeSet#to_xml
+      def to_xml *args
+        children.to_xml(*args)
+      end
+
+      ###
+      # Search this fragment.  See Nokogiri::XML::Node#css
+      def css *args
+        if children.any?
+          children.css(*args)
+        else
+          NodeSet.new(document)
+        end
+      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
+
+      private
+
+      def coerce data
+        return super unless String === data
+
+        document.fragment(data).children
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/dtd.rb

@@ -0,0 +1,22 @@
+module Nokogiri
+  module XML
+    class DTD < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :values
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def keys
+        attributes.keys
+      end
+
+      def each &block
+        attributes.each { |key, value|
+          block.call([key, value])
+        }
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_content.rb

@@ -0,0 +1,36 @@
+module Nokogiri
+  module XML
+    ###
+    # Represents the allowed content in an Element Declaration inside a DTD:
+    #
+    #   <?xml version="1.0"?><?TEST-STYLE PIDATA?>
+    #   <!DOCTYPE staff SYSTEM "staff.dtd" [
+    #      <!ELEMENT div1 (head, (p | list | note)*, div2*)>
+    #   ]>
+    #   </root>
+    #
+    # ElementContent represents the tree inside the <!ELEMENT> tag shown above
+    # that lists the possible content for the div1 tag.
+    class ElementContent
+      # Possible definitions of type
+      PCDATA  = 1
+      ELEMENT = 2
+      SEQ     = 3
+      OR      = 4
+
+      # Possible content occurrences
+      ONCE    = 1
+      OPT     = 2
+      MULT    = 3
+      PLUS    = 4
+
+      attr_reader :document
+
+      ###
+      # Get the children of this ElementContent node
+      def children
+        [c1, c2].compact
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/element_decl.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module XML
+    class ElementDecl < Nokogiri::XML::Node
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/entity_decl.rb

@@ -0,0 +1,19 @@
+module Nokogiri
+  module XML
+    class EntityDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def self.new name, doc, *args
+        doc.create_entity(name, *args)
+      end
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end