nokogiri 1.3.3 → 1.4.0

data/lib/nokogiri/ffi/xml/text.rb

@@ -1,11 +1,11 @@
 module Nokogiri
   module XML
-    class Text < Node
+    class Text < CharacterData
 
       def self.new(string, document, *rest) # :nodoc:
         node_ptr = LibXML.xmlNewText(string)
         node_cstruct = LibXML::XmlNode.new(node_ptr)
-        node_cstruct[:doc] = document.cstruct
+        node_cstruct[:doc] = document.cstruct[:doc]
 
         node = Node.wrap(node_cstruct, self)
         node.send :initialize, string, document, *rest

data/lib/nokogiri/html.rb

@@ -1,6 +1,7 @@
 require 'nokogiri/html/entity_lookup'
 require 'nokogiri/html/document'
 require 'nokogiri/html/document_fragment'
+require 'nokogiri/html/sax/parser_context'
 require 'nokogiri/html/sax/parser'
 require 'nokogiri/html/element_description'
 

data/lib/nokogiri/html/document.rb

@@ -1,39 +1,54 @@
 module Nokogiri
   module HTML
     class Document < Nokogiri::XML::Document
+      ###
+      # Get the meta tag encoding for this document.  If there is no meta tag,
+      # then nil is returned
+      def meta_encoding
+        return nil unless meta = css('meta').find { |node|
+          node['http-equiv'] =~ /Content-Type/i
+        }
 
-      def initialize *args
-        super
+        /charset\s*=\s*([\w\d-]+)/i.match(meta['content'])[1]
       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")}
+      ###
+      # Set the meta tag encoding for this document.  If there is no meta 
+      # content tag, nil is returned and the encoding is not set.
+      def meta_encoding= encoding
+        return nil unless meta = css('meta').find { |node|
+          node['http-equiv'] =~ /Content-Type/i
+        }
 
-Please change to #{self.class}#serialize(:encoding => enc, :save_with => opts)
-          eowarn
-        end
+        meta['content'] = "text/html; charset=%s" % encoding
+        encoding
+      end
 
-        options = args.first.is_a?(Hash) ? args.shift : {
-          :encoding   => args[0],
-          :save_with  => args[1] || XML::Node::SaveOptions::FORMAT |
+      ####
+      # Serialize Node using +options+.  Save options can also be set using a
+      # block. See SaveOptions.
+      #
+      # These two statements are equivalent:
+      #
+      #  node.serialize(:encoding => 'UTF-8', :save_with => FORMAT | AS_XML)
+      #
+      # or
+      #
+      #   node.serialize(:encoding => 'UTF-8') do |config|
+      #     config.format.as_xml
+      #   end
+      #
+      def serialize options = {}, &block
+        options[:save_with] ||= XML::Node::SaveOptions::FORMAT |
             XML::Node::SaveOptions::AS_HTML |
             XML::Node::SaveOptions::NO_DECLARATION |
             XML::Node::SaveOptions::NO_EMPTY_TAGS
-        }
-        super(options)
+        super
       end
 
       ####
       # Create a Nokogiri::XML::DocumentFragment from +tags+
-      def fragment tags
+      def fragment tags = nil
         DocumentFragment.new(self, tags)
       end
 
@@ -58,13 +73,13 @@ Please change to #{self.class}#serialize(:encoding => enc, :save_with => opts)
 
           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)
+            return 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?
+          return new if string_or_io.nil? or string_or_io.empty?
 
-          self.read_memory(string_or_io, url, encoding, options.to_i)
+          read_memory(string_or_io, url, encoding, options.to_i)
         end
       end
 

data/lib/nokogiri/html/sax/parser.rb

@@ -31,7 +31,7 @@ module Nokogiri
         def parse_memory data, encoding = 'UTF-8'
           raise ArgumentError unless data
           return unless data.length > 0
-          native_parse_memory data, encoding
+          ParserContext.memory(data, encoding).parse_with self
         end
 
         ###
@@ -40,7 +40,7 @@ module Nokogiri
           raise ArgumentError unless filename
           raise Errno::ENOENT unless File.exists?(filename)
           raise Errno::EISDIR if File.directory?(filename)
-          native_parse_file filename, encoding
+          ParserContext.file(filename, encoding).parse_with self
         end
       end
     end

data/lib/nokogiri/html/sax/parser_context.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module HTML
+    module SAX
+      ###
+      # Context for HTML SAX parsers.  This class is usually not instantiated
+      # by the user.  Instead, you should be looking at
+      # Nokogiri::HTML::SAX::Parser
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
+        def self.new thing, encoding = 'UTF-8'
+          [:read, :close].all? { |x| thing.respond_to?(x) } ?  super :
+            memory(thing, encoding)
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/version.rb

@@ -1,6 +1,6 @@
 module Nokogiri
   # The version of Nokogiri you are using
-  VERSION = '1.3.3'
+  VERSION = '1.4.0'
 
   # More complete version information about libxml
   VERSION_INFO = {}

data/lib/nokogiri/xml.rb

@@ -1,7 +1,12 @@
+require 'nokogiri/xml/pp'
 require 'nokogiri/xml/parse_options'
 require 'nokogiri/xml/sax'
 require 'nokogiri/xml/fragment_handler'
 require 'nokogiri/xml/node'
+require 'nokogiri/xml/attribute_decl'
+require 'nokogiri/xml/element_decl'
+require 'nokogiri/xml/element_content'
+require 'nokogiri/xml/character_data'
 require 'nokogiri/xml/namespace'
 require 'nokogiri/xml/attr'
 require 'nokogiri/xml/dtd'
@@ -16,7 +21,7 @@ require 'nokogiri/xml/xpath_context'
 require 'nokogiri/xml/builder'
 require 'nokogiri/xml/reader'
 require 'nokogiri/xml/notation'
-require 'nokogiri/xml/entity_declaration'
+require 'nokogiri/xml/entity_decl'
 require 'nokogiri/xml/schema'
 require 'nokogiri/xml/relax_ng'
 

data/lib/nokogiri/xml/attr.rb

@@ -4,6 +4,11 @@ module Nokogiri
       alias :value :content
       alias :to_s :content
       alias :content= :value=
+
+      private
+      def inspect_attributes
+        [:name, :namespace, :value]
+      end
     end
   end
 end

data/lib/nokogiri/xml/attribute_decl.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    ###
+    # Represents an attribute declaration in a DTD
+    class AttributeDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/builder.rb

@@ -147,6 +147,53 @@ module Nokogiri
     #
     # All other options are still supported with this syntax, including
     # blocks and extra tag attributes.
+    #
+    # == Namespaces
+    #
+    # Namespaces are added similarly to attributes.  Nokogiri::XML::Builder
+    # assumes that when an attribute starts with "xmlns", it is meant to be
+    # a namespace:
+    #
+    #   builder = Nokogiri::XML::Builder.new { |xml|
+    #     xml.root('xmlns' => 'default', 'xmlns:foo' => 'bar') do
+    #       xml.tenderlove
+    #     end
+    #   }
+    #   puts builder.to_xml
+    #
+    # Will output XML like this:
+    #
+    #   <?xml version="1.0"?>
+    #   <root xmlns:foo="bar" xmlns="default">
+    #     <tenderlove/>
+    #   </root>
+    #
+    # === Referencing declared namespaces
+    #
+    # Tags that reference non-default namespaces (i.e. a tag "foo:bar") can be
+    # built by using the Nokogiri::XML::Builder#[] method.
+    #
+    # For example:
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root('xmlns:foo' => 'bar') {
+    #       xml.objects {
+    #         xml['foo'].object.classy.thing!
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Will output this XML:
+    #
+    #   <?xml version="1.0"?>
+    #   <root xmlns:foo="bar">
+    #     <objects>
+    #       <foo:object class="classy" id="thing"/>
+    #     </objects>
+    #   </root>
+    #
+    # Note the "foo:object" tag.
     class Builder
       # The current Document object being built
       attr_accessor :doc
@@ -159,6 +206,24 @@ module Nokogiri
 
       attr_accessor :arity # :nodoc:
 
+      ###
+      # Create a builder with an existing root object.  This is for use when
+      # you have an existing document that you would like to augment with
+      # builder methods.  The builder context created will start with the
+      # given +root+ node.
+      #
+      # For example:
+      #
+      #   doc = Nokogiri::XML(open('somedoc.xml'))
+      #   Nokogiri::XML::Builder.with(doc.at('some_tag')) do |xml|
+      #     # ... Use normal builder methods here ...
+      #     xml.awesome # add the "awesome" tag below "some_tag"
+      #   end
+      #
+      def self.with root, &block
+        builder = self.new({}, root, &block)
+      end
+
       ###
       # Create a new Builder object.  +options+ are sent to the top level
       # Document that is being built.
@@ -168,13 +233,21 @@ module Nokogiri
       #   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
+      def initialize options = {}, root = nil, &block
+
+        if root
+          @doc    = root.document
+          @parent = root
+        else
+          namespace     = self.class.name.split('::')
+          namespace[-1] = 'Document'
+          @doc          = eval(namespace.join('::')).new
+          @parent       = @doc
+        end
+
         @context  = nil
         @arity    = nil
+        @ns       = nil
 
         options.each do |k,v|
           @doc.send(:"#{k}=", v)
@@ -196,8 +269,7 @@ module Nokogiri
       ###
       # Create a Text Node with content of +string+
       def text string
-        node = Nokogiri::XML::Text.new(string.to_s, @doc)
-        insert(node)
+        insert @doc.create_text_node string
       end
 
       ###
@@ -207,21 +279,57 @@ module Nokogiri
         insert(node)
       end
 
+      ###
+      # Build a tag that is associated with namespace +ns+.  Raises an
+      # ArgumentError if +ns+ has not been defined higher in the tree.
+      def [] ns
+        @ns = @parent.namespace_definitions.find { |x| x.prefix == ns.to_s }
+        return self if @ns
+
+        @parent.ancestors.each do |a|
+          next if a == doc
+          @ns = a.namespace_definitions.find { |x| x.prefix == ns.to_s }
+          return self if @ns
+        end
+
+        raise ArgumentError, "Namespace #{ns} has not been defined"
+      end
+
       ###
       # Convert this Builder object to XML
-      def to_xml
-        @doc.to_xml
+      def to_xml(*args)
+        @doc.to_xml(*args)
+      end
+
+      ###
+      # Append the given raw XML +string+ to the document
+      def << string
+        @doc.fragment(string).children.each { |x| insert(x) }
       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|
+          node = @doc.create_element(method.to_s.sub(/[_!]$/, '')) { |n|
+            # Set up the namespace
+            if @ns
+              n.namespace = @ns
+              @ns = nil
+            end
+
             args.each do |arg|
               case arg
               when Hash
-                arg.each { |k,v| n[k.to_s] = v.to_s }
+                arg.each { |k,v|
+                  key = k.to_s
+                  if key =~ /^xmlns(:\w+)?$/
+                    ns_name = key.split(":", 2)[1]
+                    n.add_namespace_definition ns_name, v
+                    next
+                  end
+                  n[k.to_s] = v.to_s
+                }
               else
                 n.content = arg
               end
@@ -250,7 +358,7 @@ module Nokogiri
       end
 
       class NodeBuilder # :nodoc:
-        def initialize(node, doc_builder)
+        def initialize node, doc_builder
           @node = node
           @doc_builder = doc_builder
         end
@@ -272,7 +380,7 @@ module Nokogiri
           when /^(.*)=/
             @node[$1] = args.first
           else
-            @node['class'] = 
+            @node['class'] =
               ((@node['class'] || '').split(/\s/) + [method.to_s]).join(' ')
             @node.content = args.first if args.first
           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

@@ -8,6 +8,31 @@ module Nokogiri
     # For searching a Document, see Nokogiri::XML::Node#css and
     # Nokogiri::XML::Node#xpath
     class Document < Node
+      ###
+      # 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 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
 
@@ -15,6 +40,16 @@ module Nokogiri
         @decorators = nil
       end
 
+      # Create an element with +name+
+      def create_element name, &block
+        Nokogiri::XML::Element.new(name, self, &block)
+      end
+
+      # Create a text node with +text+
+      def create_text_node text, &block
+        Nokogiri::XML::Text.new(text.to_s, self, &block)
+      end
+
       # The name of this document.  Always returns "document"
       def name
         'document'
@@ -65,17 +100,19 @@ module Nokogiri
 
       # Get the hash of namespaces on the root Nokogiri::XML::Node
       def namespaces
-        root ? root.collect_namespaces : {}
+        root ? root.namespaces : {}
       end
 
       ####
       # Create a Nokogiri::XML::DocumentFragment from +tags+
-      def fragment tags
+      # Returns an empty fragment if +tags+ is nil.
+      def fragment tags = nil
         DocumentFragment.new(self, tags)
       end
 
       undef_method :swap, :parent, :namespace, :default_namespace=
-      undef_method :add_namespace_definition
+      undef_method :add_namespace_definition, :attributes
+      undef_method :namespace_definitions, :line
 
       def add_child child
         if [Node::ELEMENT_NODE, Node::DOCUMENT_FRAG_NODE].include? child.type
@@ -85,33 +122,10 @@ module Nokogiri
       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
+      private
+      def inspect_attributes
+        [:name, :children]
       end
-
     end
   end
 end