rdf-rdfxml 0.3.5 → 0.3.6

data/History.markdown

@@ -1,3 +1,8 @@
+### 0.3.6
+* Attempt at JRuby and REXML support; not quite there yet.
+* Element content uses `#inner_text`, rather than `#inner_html`; this performs entity decoding.
+* Use rdf-xsd gem instead of internal support for XMLLiterals.
+
 ### 0.3.5
 * RDF.rb 0.3.4 compatibility.
 * Added format detection.

data/README.markdown

@@ -24,7 +24,7 @@ Instantiate a parser and parse source, specifying type and base-URL
 
 ## Dependencies
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
-* [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.4.4)
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.5.0)
 
 ## Documentation
 Full documentation available on [RubyForge](http://rubydoc.info/github/gkellogg/rdf-rdfxml/master/frames)
@@ -41,7 +41,6 @@ Full documentation available on [RubyForge](http://rubydoc.info/github/gkellogg/
 ### Patches
 * {Array}
 * {RDF::Graph}
-* {RDF::Literal::XML}
 * {Nokogiri::XML::Node}
 
 ## TODO

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.3.6

data/lib/rdf/rdfxml.rb

@@ -23,8 +23,6 @@ module RDF
     require 'rdf/rdfxml/format'
     require 'rdf/rdfxml/vocab'
     require 'rdf/rdfxml/patches/array_hacks'
-    require 'rdf/rdfxml/patches/literal_hacks'
-    require 'rdf/rdfxml/patches/nokogiri_hacks'
     autoload :Reader,  'rdf/rdfxml/reader'
     autoload :Writer,  'rdf/rdfxml/writer'
     autoload :VERSION, 'rdf/rdfxml/version'
@@ -36,7 +34,7 @@ module RDF
         (?!\\\\u0301)             # ́ is a non-spacing acute accent.
                                   # It is legal within an XML Name, but not as the first character.
         (  [a-zA-Z_]
-         | \\\\u[0-9a-fA-F]
+         | \\\\u[0-9a-fA-F]{4}
         )
         (  [0-9a-zA-Z_\.-]
          | \\\\u([0-9a-fA-F]{4})

data/lib/rdf/rdfxml/format.rb

@@ -20,7 +20,6 @@ module RDF::RDFXML
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
-    content_type     'application/xml', :extension => :xml
     content_type     'application/rdf+xml', :extension => :rdf
     content_encoding 'utf-8'
 
@@ -40,17 +39,4 @@ module RDF::RDFXML
       sample.match(/<(\w+:)?(RDF)/)
     end
   end
-  
-  # Aliases for this format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an RDFXML format class
-  #   RDF::Format.for(:xml)         # RDF::RDFXML::XML
-  #   RDF::Format.for(:xml).reader  # RDF::RDFXML::Reader
-  #   RDF::Format.for(:xml).writer  # RDF::RDFXML::Writer
-  class XML < RDF::Format
-    reader { RDF::RDFXML::Reader }
-    writer { RDF::RDFXML::Writer }
-  end
 end

data/lib/rdf/rdfxml/patches/nokogiri_hacks.rb

@@ -10,7 +10,7 @@ class Nokogiri::XML::Node
     @display_path ||= case self
     when Nokogiri::XML::Document then ""
     when Nokogiri::XML::Element then parent ? "#{parent.display_path}/#{name}" : name
-    when Nokogiri::XML::Attr then "#{parent.display_path}@#{name}"
+    when Nokogiri::XML::Attr then "#{parent && parent.display_path}@#{name}"
     end
   end
   

data/lib/rdf/rdfxml/reader.rb

@@ -1,4 +1,9 @@
-require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
+begin
+  require 'nokogiri'
+rescue LoadError => e
+  :rexml
+end
+require 'rdf/xsd'
 
 module RDF::RDFXML
   ##
@@ -58,8 +63,8 @@ module RDF::RDFXML
 
       # Extract Evaluation Context from an element
       def extract_from_element(el, &cb)
-        b = el.attribute_with_ns("base", RDF::XML.to_s)
-        lang = el.attribute_with_ns("lang", RDF::XML.to_s)
+        b = el.base
+        lang = el.language
         self.base = self.base.join(b) if b
         self.language = lang if lang
         self.uri_mappings.merge!(extract_mappings(el, &cb))
@@ -101,6 +106,11 @@ module RDF::RDFXML
       end
     end
 
+    # Returns the XML implementation module for this reader instance.
+    #
+    # @attr_reader [Module]
+    attr_reader :implementation
+
     ##
     # Initializes the RDF/XML reader instance.
     #
@@ -108,6 +118,8 @@ module RDF::RDFXML
     #   the input stream to read
     # @param  [Hash{Symbol => Object}] options
     #   any additional options
+    # @option options [Symbol] :library
+    #   One of :nokogiri or :rexml. If nil/unspecified uses :nokogiri if available, :rexml otherwise.
     # @option options [Encoding] :encoding     (Encoding::UTF_8)
     #   the encoding of the input stream (Ruby 1.9+)
     # @option options [Boolean]  :validate     (false)
@@ -132,16 +144,27 @@ module RDF::RDFXML
         @debug = options[:debug]
         @base_uri = uri(options[:base_uri]) if options[:base_uri]
             
-        @doc = case input
-        when Nokogiri::XML::Document then input
-        else
-          Nokogiri::XML.parse(input, @base_uri.to_s) do |config|
-            config.noent
-          end
+        @library = case options[:library]
+          when nil
+            # Use Nokogiri when available, and REXML otherwise:
+            defined?(::Nokogiri) ? :nokogiri : :rexml
+          when :nokogiri, :rexml
+            options[:library]
+          else
+            raise ArgumentError.new("expected :rexml or :nokogiri, but got #{options[:library].inspect}")
         end
-        
-        raise RDF::ReaderError, "Synax errors:\n#{@doc.errors}" if !@doc.errors.empty? && validate?
-        raise RDF::ReaderError, "Empty document" if (@doc.nil? || @doc.root.nil?) && validate?
+
+        require "rdf/rdfxml/reader/#{@library}"
+        @implementation = case @library
+          when :nokogiri then Nokogiri
+          when :rexml    then REXML
+        end
+        self.extend(@implementation)
+
+        initialize_xml(input, options) rescue raise RDF::ReaderError.new($!.message)
+
+        raise RDF::ReaderError, "Empty document" if root.nil? && validate?
+        raise RDF::ReaderError, "Synax errors:\n#{doc_errors}" if !doc_errors.empty? && validate?
 
         block.call(self) if block_given?
       end
@@ -163,7 +186,7 @@ module RDF::RDFXML
       # Block called from add_statement
       @callback = block
 
-      root = @doc.root
+      raise "root must be a proxy not a #{root.class}" unless root.is_a?(@implementation::NodeProxy)
 
       add_debug(root, "base_uri: #{@base_uri || 'nil'}")
       
@@ -178,6 +201,7 @@ module RDF::RDFXML
         nodeElement(root, ec)
       else
         rdf_nodes.each do |node|
+          raise "node must be a proxy not a #{node.class}" unless node.is_a?(@implementation::NodeProxy)
           # XXX Skip this element if it's contained within another rdf:RDF element
 
           # Extract base, lang and namespaces from parents to create proper evaluation context
@@ -187,6 +211,7 @@ module RDF::RDFXML
           ec.extract_from_ancestors(node)
           node.children.each {|el|
             next unless el.elem?
+            raise "el must be a proxy not a #{el.class}" unless el.is_a?(@implementation::NodeProxy)
             new_ec = ec.clone(el) do |prefix, value|
               prefix(prefix, value)
             end
@@ -220,10 +245,7 @@ module RDF::RDFXML
     
     # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
     def node_path(node)
-      case node
-      when Nokogiri::XML::Node then node.display_path
-      else node.to_s
-      end
+      "<#{base_uri}>#{node.respond_to?(:display_path) ? node.display_path : node}"
     end
     
     # Add debug event to debug array, if specified
@@ -259,6 +281,7 @@ module RDF::RDFXML
     # @return [RDF::URI] subject:: The subject found for the node
     # @raise [RDF::ReaderError]:: Raises Exception if validating
     def nodeElement(el, ec)
+      raise "el must be a proxy not a #{el.class}" unless el.is_a?(@implementation::NodeProxy)
       # subject
       subject = ec.subject || parse_subject(el, ec)
       
@@ -290,6 +313,7 @@ module RDF::RDFXML
       # Handle the propertyEltList children events in document order
       li_counter = 0 # this will increase for each li we iterate through
       el.children.each do |child|
+        raise "child must be a proxy not a #{child.class}" unless child.is_a?(@implementation::NodeProxy)
         next unless child.elem?
         child_ec = ec.clone(child) do |prefix, value|
           prefix(prefix, value)
@@ -299,15 +323,25 @@ module RDF::RDFXML
         propertyElementURI_check(child)
         
         # Determine the content type of this property element
+        raise "child must be a proxy not a #{child.class}" unless child.is_a?(@implementation::NodeProxy)
+
         text_nodes = child.children.select {|e| e.text? && !e.blank?}
         element_nodes = child.children.select {|c| c.element? }
-        add_debug(child) {"#{text_nodes.length} text nodes, #{element_nodes.length} element nodes"}
+        add_debug(child) {"#{text_nodes.to_a.length} text nodes, #{element_nodes.to_a.length} element nodes"}
+
+        text_nodes.each do |node|
+          raise "text node must be a proxy not a #{node.class}" unless node.is_a?(@implementation::NodeProxy)
+        end
+        element_nodes.each do |node|
+          raise "element node must be a proxy not a #{node.class}" unless node.is_a?(@implementation::NodeProxy)
+        end
+
         if element_nodes.length > 1
           element_nodes.each do |node|
             add_debug(child) {"  node: #{node.to_s}"}
           end
         end
-
+        
         # List expansion
         predicate = ec.li_next if predicate == RDF.li
         
@@ -370,6 +404,7 @@ module RDF::RDFXML
             prefix(prefix, value)
           end
           new_node_element = element_nodes.first
+          raise "new_node_element must be a proxy not a #{new_node_element.class}" unless new_node_element.is_a?(@implementation::NodeProxy)
           add_debug(child) {"resourcePropertyElt: #{node_path(new_node_element)}"}
           new_subject = nodeElement(new_node_element, new_ec)
           add_triple(child, subject, predicate, new_subject)
@@ -383,7 +418,7 @@ module RDF::RDFXML
           else
             literal_opts[:language] = child_ec.language
           end
-          literal = RDF::Literal.new(child.inner_html, literal_opts)
+          literal = RDF::Literal.new(child.inner_text, literal_opts)
           add_triple(child, subject, predicate, literal)
           reify(id, child, subject, predicate, literal, ec) if id
         elsif parseType == "Resource"
@@ -412,10 +447,10 @@ module RDF::RDFXML
           # end-element()
           add_debug(child, "compose new sequence with rdf:Description")
           node = child.clone
-          pt_attr = node.attribute("parseType")
-          node.namespace = pt_attr.namespace
           node.attributes.keys.each {|a| node.remove_attribute(a)}
           node.node_name = "Description"
+          node.add_namespace(nil, RDF.to_uri.to_s)
+          add_debug(node) { "uri: #{node.uri}, namespace: #{node.namespace.inspect}"}
           new_ec = child_ec.clone(nil, :subject => n) do |prefix, value|
             prefix(prefix, value)
           end
@@ -466,13 +501,27 @@ module RDF::RDFXML
             raise RDF::ReaderError.new(warn) if validate?
           end
 
-          object = RDF::Literal.new(child.children, :datatype => RDF.XMLLiteral, :namespaces => child_ec.uri_mappings, :language => ec.language)
-          add_triple(child, subject, predicate, object)
+          begin
+            c14nxl = child.children.c14nxl(
+              :library => @library,
+              :language => ec.language,
+              :namespaces => child_ec.uri_mappings)
+            object = RDF::Literal.new(c14nxl,
+              :library => @library,
+              :datatype => RDF.XMLLiteral,
+              :validate => validate?,
+              :canonicalize => canonicalize?)
+
+            add_triple(child, subject, predicate, object)
+          rescue ArgumentError => e
+            add_error(child, e.message)
+          end
         elsif text_nodes.length == 0 && element_nodes.length == 0
           # Production emptyPropertyElt
           add_debug(child, "emptyPropertyElt")
 
           if attrs.empty? && resourceAttr.nil? && nodeID.nil?
+            
             literal = RDF::Literal.new("", :language => ec.language)
             add_triple(child, subject, predicate, literal)
             
@@ -530,9 +579,9 @@ module RDF::RDFXML
       old_property_check(el)
       
       nodeElementURI_check(el)
-      about = el.attribute("about")
-      id = el.attribute("ID")
-      nodeID = el.attribute("nodeID")
+      about = el.attribute_with_ns("about", RDF.to_uri.to_s)
+      id = el.attribute_with_ns("ID", RDF.to_uri.to_s)
+      nodeID = el.attribute_with_ns("nodeID", RDF.to_uri.to_s)
       
       if nodeID && about
         add_debug(el, "Cannot have rdf:nodeID and rdf:about.")

data/lib/rdf/rdfxml/reader/nokogiri.rb

@@ -0,0 +1,226 @@
+module RDF::RDFXML
+  class Reader < RDF::Reader
+    ##
+    # Nokogiri implementation of an XML parser.
+    #
+    # @see http://nokogiri.org/
+    module Nokogiri
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :nokogiri
+      end
+
+      # Proxy class to implement uniform element accessors
+      class NodeProxy
+        attr_reader :node
+        attr_reader :parent
+
+        def initialize(node, parent = nil)
+          @node = node
+          @parent = parent
+        end
+
+        ##
+        # Element language
+        #
+        # From HTML5 [3.2.3.3]
+        #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
+        #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
+        #   attribute in no namespace must be ignored for the purposes of determining the element's
+        #   language.
+        #
+        # @return [String]
+        def language
+          attribute_with_ns("lang", RDF::XML.to_s)
+        end
+
+        ##
+        # Return xml:base on element, if defined
+        #
+        # @return [String]
+        def base
+          attribute_with_ns("base", RDF::XML.to_s)
+        end
+
+        ##
+        # Monkey patch attribute_with_ns, to insure nil is returned for #null?
+        #
+        # Get the attribute node with name and namespace
+        #
+        # @param [String] name
+        # @param [String] namespace
+        # @return [Nokogiri::XML::Attr]
+        def attribute_with_ns(name, namespace)
+          a = @node.attribute_with_ns(name, namespace)
+
+          (a.respond_to?(:null?) && a.null?) ? nil : a # to ensure FFI Pointer compatibility
+        end
+        
+        def display_path
+          @display_path ||= begin
+            path = []
+            path << parent.display_path if parent
+            path << @node.name
+            case @node
+            when ::Nokogiri::XML::Element then path.join("/")
+            when ::Nokogiri::XML::Attr    then path.join("@")
+            else path.join("?")
+            end
+          end
+        end
+
+        ##
+        # Return true of all child elements are text
+        #
+        # @return [Array<:text, :element, :attribute>]
+        def text_content?
+          @text_content ||= @node.children.all? {|c| c.text?}
+        end
+
+        ##
+        # Retrieve XMLNS definitions for this element
+        #
+        # @return [Hash{String => String}]
+        def namespaces
+          @namespaces ||= @node.namespace_definitions.inject({}) {|memo, ns| memo[ns.prefix] = ns.href.to_s; memo }
+        end
+        
+        ##
+        # Children of this node
+        #
+        # @return [NodeSetProxy]
+        def children
+          @children ||= NodeSetProxy.new(@node.children, self)
+        end
+        
+        # Ancestors of this element, in order
+        def ancestors
+          @ancestors ||= parent ? parent.ancestors + [parent] : []
+        end
+
+        ##
+        # Inner text of an element. Decode Entities
+        #
+        # @return [String]
+        #def inner_text
+        #  coder = HTMLEntities.new
+        #  coder.decode(@node.inner_text)
+        #end
+
+        def attribute_nodes
+          @attribute_nodes ||= NodeSetProxy.new(@node.attribute_nodes, self)
+        end
+
+        def xpath(*args)
+          @node.xpath(*args).map {|n| NodeProxy.new(n)}
+        end
+
+        # For jRuby, there is a bug that prevents the namespace from being set on an element
+        if RUBY_PLATFORM == "java"
+          def add_namespace(prefix, href)
+            @def_namespace = href if prefix.nil?
+            @node.add_namespace(prefix, href)
+          end
+
+          def namespace
+            @def_namespace || @node.namespace
+          end
+        end
+
+        # URI of namespace + node_name
+        def uri
+          ns = namespace || RDF::XML.to_s
+          ns = ns.href if ns.respond_to?(:href)
+          RDF::URI.intern(ns + self.node_name)
+        end
+
+        ##
+        # Proxy for everything else to @node
+        def method_missing(method, *args)
+          @node.send(method, *args)
+        end
+      end
+
+      ##
+      # NodeSet proxy
+      class NodeSetProxy
+        attr_reader :node_set
+        attr_reader :parent
+
+        def initialize(node_set, parent)
+          @node_set = node_set
+          @parent = parent
+        end
+
+        ##
+        # Return a proxy for each child
+        #
+        # @yield(child)
+        # @yieldparam(NodeProxy)
+        def each
+          @node_set.each do |c|
+            yield NodeProxy.new(c, parent)
+          end
+        end
+        
+        ##
+        # Return selected NodeProxies based on selection
+        #
+        # @yield(child)
+        # @yieldparam(NodeProxy)
+        # @return [Array[NodeProxy]]
+        def select
+          @node_set.to_a.map {|n| NodeProxy.new(n, parent)}.select do |c|
+            yield c
+          end
+        end
+
+        ##
+        # Proxy for everything else to @node_set
+        def method_missing(method, *args)
+          @node_set.send(method, *args)
+        end
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(input, options = {})
+        require 'nokogiri' unless defined?(::Nokogiri)
+        @doc = case input
+        when ::Nokogiri::XML::Document
+          input
+        else
+          # Try to detect charset from input
+          options[:encoding] ||= input.charset if input.respond_to?(:charset)
+          
+          # Otherwise, default is utf-8
+          options[:encoding] ||= 'utf-8'
+
+          ::Nokogiri::XML.parse(input, base_uri.to_s, options[:encoding]) do |config|
+            config.noent
+          end
+        end
+      end
+
+      # Accessor methods to mask native elements & attributes
+      
+      ##
+      # Return proxy for document root
+      def root
+        @root ||= NodeProxy.new(@doc.root) if @doc && @doc.root
+      end
+      
+      ##
+      # Document errors
+      def doc_errors
+        @doc.errors
+      end
+    end
+  end
+end

data/lib/rdf/rdfxml/reader/rexml.rb

@@ -0,0 +1,215 @@
+module RDF::RDFXML
+  class Reader < RDF::Reader
+    ##
+    # REXML implementation of an XML parser.
+    #
+    # @see http://www.germane-software.com/software/rexml/
+    module REXML
+      ##
+      # Returns the name of the underlying XML library.
+      #
+      # @return [Symbol]
+      def self.library
+        :rexml
+      end
+
+      # Proxy class to implement uniform element accessors
+      class NodeProxy
+        attr_reader :node
+        attr_reader :parent
+
+        def initialize(node, parent = nil)
+          @node = node
+          @parent = parent
+        end
+
+        ##
+        # Element language
+        #
+        # From HTML5 [3.2.3.3]
+        #   If both the lang attribute in no namespace and the lang attribute in the XML namespace are set
+        #   on an element, user agents must use the lang attribute in the XML namespace, and the lang
+        #   attribute in no namespace must be ignored for the purposes of determining the element's
+        #   language.
+        #
+        # @return [String]
+        def language
+          @node.attribute("lang", RDF::XML.to_s)
+        end
+
+        ##
+        # Return xml:base on element, if defined
+        #
+        # @return [String]
+        def base
+          @node.attribute("base", RDF::XML.to_s)
+        end
+
+        def attribute_with_ns(name, namespace)
+          @node.attribute(name, namespace)
+        end
+
+        def display_path
+          @display_path ||= begin
+            path = []
+            path << parent.display_path if parent
+            path << @node.name
+            case @node
+            when ::REXML::Element   then path.join("/")
+            when ::REXML::Attribute then path.join("@")
+            else path.join("?")
+            end
+          end
+        end
+
+        # URI of namespace + name
+        def uri
+          ns = namespace || RDF::XML.to_s
+          ns = ns.href if ns.respond_to?(:href)
+          RDF::URI.intern(ns + @node.name)
+        end
+
+        ##
+        # Return true of all child elements are text
+        #
+        # @return [Array<:text, :element, :attribute>]
+        def text_content?
+          @node.children.all? {|c| c.is_a?(::REXML::Text)}
+        end
+
+        ##
+        # Retrieve XMLNS definitions for this element
+        #
+        # @return [Hash{String => String}]
+        def namespaces
+          ns_decls = {}
+          @node.attributes.each do |name, attr|
+            next unless name =~ /^xmlns(?:\:(.+))?/
+            ns_decls[$1] = attr
+          end
+          ns_decls
+        end
+        
+        ##
+        # Children of this node
+        #
+        # @return [NodeSetProxy]
+        def children
+          NodeSetProxy.new(@node.children, self)
+        end
+
+        # Ancestors of this element, in order
+        def ancestors
+          @ancestors ||= parent ? parent.ancestors + [parent] : []
+        end
+
+        ##
+        # Inner text of an element
+        #
+        # @see http://apidock.com/ruby/REXML/Element/get_text#743-Get-all-inner-texts
+        # @return [String]
+        def inner_text
+          coder = HTMLEntities.new
+          ::REXML::XPath.match(@node,'.//text()').map { |e|
+            coder.decode(e)
+          }.join
+        end
+
+        ##
+        # Node type accessors
+        #
+        # @return [Boolean]
+        def element?
+          @node.is_a?(::REXML::Element)
+        end
+
+        def attribute_nodes
+          @attribute_nodes ||= NodeSetProxy.new(@node.children.select {|n| n.is_a?(::REXML::Attribute)}, self)
+        end
+
+        def xpath(*args)
+          #NodeSetProxy.new(::REXML::XPath.match(@node, path, namespaces), self)
+          ::REXML::XPath.match(@node, *args).map {|n| NodeProxy.new(n)}
+        end
+
+        def elem?
+          @node.is_a?(::REXML::Element)
+        end
+
+        ##
+        # Proxy for everything else to @node
+        def method_missing(method, *args)
+          @node.send(method, *args)
+        end
+      end
+
+      ##
+      # NodeSet proxy
+      class NodeSetProxy
+        attr_reader :node_set
+        attr_reader :parent
+
+        def initialize(node_set, parent)
+          @node_set = node_set
+          @parent = parent
+        end
+
+        ##
+        # Return a proxy for each child
+        #
+        # @yield(child)
+        # @yieldparam(NodeProxy)
+        def each
+          @node_set.each do |c|
+            yield NodeProxy.new(c, parent)
+          end
+        end
+
+        ##
+        # Proxy for everything else to @node_set
+        def method_missing(method, *args)
+          @node_set.send(method, *args)
+        end
+      end
+
+      ##
+      # Initializes the underlying XML library.
+      #
+      # @param  [Hash{Symbol => Object}] options
+      # @return [void]
+      def initialize_xml(input, options = {})
+        require 'rexml/document' unless defined?(::REXML)
+        @doc = case input
+        when ::REXML::Document
+          input
+        else
+          # Try to detect charset from input
+          options[:encoding] ||= input.charset if input.respond_to?(:charset)
+          
+          # Otherwise, default is utf-8
+          options[:encoding] ||= 'utf-8'
+
+          # Set xml:base for the document element, if defined
+          @base_uri = base_uri ? base_uri.to_s : nil
+
+          # Only parse as XML, no HTML mode
+          ::REXML::Document.new(input.respond_to?(:read) ? input.read : input.to_s)
+        end
+      end
+
+      # Accessor methods to mask native elements & attributes
+      
+      ##
+      # Return proxy for document root
+      def root
+        @root ||= NodeProxy.new(@doc.root) if @doc && @doc.root
+      end
+      
+      ##
+      # Document errors
+      def doc_errors
+        []
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-rdfxml
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-14 00:00:00.000000000 Z
+date: 2012-03-12 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &2161650980 !ruby/object:Gem::Requirement
+  requirement: &70358239660100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,32 +22,54 @@ dependencies:
         version: 0.3.4
   type: :runtime
   prerelease: false
-  version_requirements: *2161650980
+  version_requirements: *70358239660100
 - !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: &2161650360 !ruby/object:Gem::Requirement
+  name: rdf-xsd
+  requirement: &70358239659640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.4
+        version: 0.3.5
   type: :runtime
   prerelease: false
-  version_requirements: *2161650360
+  version_requirements: *70358239659640
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &70358239688860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: *70358239688860
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: &70358239688400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.8
+  type: :development
+  prerelease: false
+  version_requirements: *70358239688400
 - !ruby/object:Gem::Dependency
   name: open-uri-cached
-  requirement: &2161649680 !ruby/object:Gem::Requirement
+  requirement: &70358239687940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.4
   type: :development
   prerelease: false
-  version_requirements: *2161649680
+  version_requirements: *70358239687940
 - !ruby/object:Gem::Dependency
   name: spira
-  requirement: &2161648620 !ruby/object:Gem::Requirement
+  requirement: &70358239687480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,21 +77,43 @@ dependencies:
         version: 0.0.12
   type: :development
   prerelease: false
-  version_requirements: *2161648620
+  version_requirements: *70358239687480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2161647120 !ruby/object:Gem::Requirement
+  requirement: &70358239687020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.5.0
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70358239687020
+- !ruby/object:Gem::Dependency
+  name: rdf-isomorphic
+  requirement: &70358239686560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+  type: :development
+  prerelease: false
+  version_requirements: *70358239686560
+- !ruby/object:Gem::Dependency
+  name: rdf-n3
+  requirement: &70358239686100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.3.4
   type: :development
   prerelease: false
-  version_requirements: *2161647120
+  version_requirements: *70358239686100
 - !ruby/object:Gem::Dependency
   name: rdf-spec
-  requirement: &2161627120 !ruby/object:Gem::Requirement
+  requirement: &70358239685640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -77,10 +121,10 @@ dependencies:
         version: 0.3.4
   type: :development
   prerelease: false
-  version_requirements: *2161627120
+  version_requirements: *70358239685640
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2161626020 !ruby/object:Gem::Requirement
+  requirement: &70358239685180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -88,7 +132,7 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *2161626020
+  version_requirements: *70358239685180
 description: RDF::RDFXML is an RDF/XML reader and writer for the RDF.rb library suite.
 email: public-rdf-ruby@w3.org
 executables: []
@@ -104,8 +148,9 @@ files:
 - lib/rdf/rdfxml/format.rb
 - lib/rdf/rdfxml/patches/array_hacks.rb
 - lib/rdf/rdfxml/patches/graph_properties.rb
-- lib/rdf/rdfxml/patches/literal_hacks.rb
 - lib/rdf/rdfxml/patches/nokogiri_hacks.rb
+- lib/rdf/rdfxml/reader/nokogiri.rb
+- lib/rdf/rdfxml/reader/rexml.rb
 - lib/rdf/rdfxml/reader.rb
 - lib/rdf/rdfxml/version.rb
 - lib/rdf/rdfxml/vocab.rb
@@ -132,8 +177,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rdf-rdfxml
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: RDF/XML reader/writer for RDF.rb.
 test_files: []
+has_rdoc: false

data/lib/rdf/rdfxml/patches/literal_hacks.rb

@@ -1,156 +0,0 @@
-# Use Nokogiri or LibXML when available, and REXML otherwise:
-begin
-  require 'nokogiri'
-rescue LoadError => e
-  begin
-    require 'libxml'
-  rescue LoadError => e
-    :rexml
-  end
-end
-
-module RDF; class Literal
-  ##
-  # An XML literal.
-  #
-  # @see   http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
-  # @see   http://www.w3.org/TR/rdfa-core/#s_xml_literals
-  # @since 0.2.1
-  class XML < Literal
-    ##
-    # @param  [Object] value
-    # @option options [String] :lexical (nil)
-    # @option options [Hash] :namespaces ({}) Use "" to declare default namespace
-    # @option options [Symbol] :language (nil)
-    # @option options [:nokogiri, :libxml, or :rexml] :library
-    def initialize(value, options = {})
-      options[:namespaces] ||= {}
-
-      @library = case options[:library]
-        when nil
-          case
-          when defined?(::Nokogiri) then :nokogiri
-          when defined?(::LibXML)   then :libxml
-          else                           :rexml
-          end
-        when :nokogiri, :libxml, :rexml
-          options[:library]
-        else
-          raise ArgumentError.new("expected :rexml, :libxml or :nokogiri, but got #{options[:library].inspect}")
-      end
-
-      @datatype = options[:datatype] || DATATYPE
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @object   = parse_value(value, options)
-      @string   = serialize_nodeset(@object)
-    end
-
-    ##
-    # Converts the literal into its canonical lexical representation.
-    #
-    # @return [Literal]
-    # @see    http://www.w3.org/TR/xml-exc-c14n/
-    def canonicalize
-      # This is the opportunity to use exclusive canonicalization library
-      self
-    end
-
-    ##
-    # Returns the value as a string.
-    #
-    # @return [String]
-    def to_s
-      @string
-    end
-    
-    private
-    
-    def parse_value(value, options)
-      ns_hash = {}
-      options[:namespaces].each_pair do |prefix, uri|
-        prefix = prefix.to_s
-        attr = prefix.empty? ? "xmlns" : "xmlns:#{prefix}"
-        ns_hash[attr] = uri.to_s
-      end
-
-      case @library
-      when :nokogiri  then parse_value_nokogiri(value, ns_hash, options)
-      when :libxml    then parse_value_libxml(value, ns_hash, options)
-      when :rexml     then parse_value_rexml(value, ns_hash, options)
-      else                 value.to_s
-      end
-    end
-    
-    def serialize_nodeset(object)
-      case @library
-      when :nokogiri  then serialize_nodeset_nokogiri(object)
-      when :libxml    then serialize_nodeset_libxml(object)
-      when :rexml     then serialize_nodeset_rexml(object)
-      else                 object
-      end
-    end
-    
-    # Nokogiri implementations
-    if defined?(::Nokogiri)
-      # A somewhat half-hearted attempt at C14N.
-      # Main problem is that it promotes all namespaces to top element, instead of demoting them
-      # to the required element, and does not properly order either namespaces or attributes.
-      #
-      # An open-issue in Nokogiri is to add support for C14N from the underlying libxml2 libraries.
-      def parse_value_nokogiri(value, ns_hash, options)
-        elements = if value.is_a?(Nokogiri::XML::NodeSet)
-          value
-        else
-          ns_strs = []
-          ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
-          # Add inherited namespaces to created root element so that they're inherited to sub-elements
-          Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
-        end
-
-        elements.map do |c|
-          if c.is_a?(Nokogiri::XML::Element)
-            c = Nokogiri::XML.parse(c.dup.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)).root
-
-            # Apply defined namespaces
-            ns_hash.each_pair do |prefix, href|
-              c[prefix] = href unless c.namespaces[prefix]
-            end
-            
-            # Add language
-            if options[:language] && c["lang"].to_s.empty?
-              c["xml:lang"] = options[:language].to_s
-            end
-          end
-          c
-        end
-      end
-    
-      def serialize_nodeset_nokogiri(object)
-        object.map {|c| c.to_xml(:save_with => Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)}.join("")
-      end
-    end   # Nokogiri
-    
-    if defined?(::LibXML)
-      # This should use Document#canonicalize if as and when it is available in libxml-ruby
-      def parse_value_libxml(value, ns_strs, language)
-        # Fixme
-      end
-
-      def serialize_nodeset_libxml(object)
-        # Fixme
-      end
-    end   # LibXML
-    
-    # REXML
-    # This could make use of the XMLCanonicalizer gem (http://rubygems.org/gems/XMLCanonicalizer)
-    # But, it hasn't been touched since 2007 and relies on log4r.
-    def parse_value_rexml(value, ns_strs, language)
-      # Fixme
-    end
-
-    def serialize_nodeset_rexml(object)
-      # Fixme
-    end
-    
-  end # class XML
-end; end