Release 1.1.3.

* Fully support REXML-only, including in testing environment.

Author: gkellogg

.gitignore

@@ -5,4 +5,4 @@
 /user-test-cases
 /.rbx/
 /spec/w3c-rdf
-Gemfile.lock
+*.lock

.travis.yml

@@ -9,10 +9,10 @@ rvm:
   - 2.1
   - jruby-19mode
   - rbx-2
+gemfile:
+  - Gemfile
+  - Gemfile-pure
 env:
   global:
     - CI=true
-  matrix:
-    - WITH_NOKOGIRI=true
-    - WITH_NOKOGIRI=false
 cache: bundler

Gemfile

@@ -4,9 +4,10 @@ gemspec
 
 gem "rdf",            :git => "git://github.com/ruby-rdf/rdf.git", :branch => "develop"
 gem "rdf-rdfa",       :git => "git://github.com/ruby-rdf/rdf-rdfa.git", :branch => "develop"
-gem "nokogiri" unless ENV["WITH_NOKOGIRI"] == "false"
+gem "nokogiri"
 
 group :development do
+  gem "equivalent-xml"
   gem "rdf-xsd",        :git => "git://github.com/ruby-rdf/rdf-xsd.git", :branch => "develop"
   gem 'json-ld',        :git => "git://github.com/ruby-rdf/json-ld.git", :branch => "develop"
   gem 'rdf-isomorphic', :git => "git://github.com/ruby-rdf/rdf-isomorphic.git", :branch => "develop"

Gemfile-pure

@@ -0,0 +1,28 @@
+# "Pure" version of Gemfile, without C bindings
+source "https://rubygems.org"
+
+gemspec
+
+gem "rdf",            :git => "git://github.com/ruby-rdf/rdf.git", :branch => "develop"
+gem "rdf-rdfa",       :git => "git://github.com/ruby-rdf/rdf-rdfa.git", :branch => "develop"
+
+group :development do
+  gem "rdf-xsd",        :git => "git://github.com/ruby-rdf/rdf-xsd.git", :branch => "develop"
+  gem 'json-ld',        :git => "git://github.com/ruby-rdf/json-ld.git", :branch => "develop"
+  gem 'rdf-isomorphic', :git => "git://github.com/ruby-rdf/rdf-isomorphic.git", :branch => "develop"
+  gem "rdf-spec",       :git => "git://github.com/ruby-rdf/rdf-spec.git", :branch => "develop"
+  gem "rdf-turtle",     :git => "git://github.com/ruby-rdf/rdf-turtle.git", :branch => "develop"
+end
+
+group :debug do
+  gem "wirble"
+  gem "ruby-debug", :platforms => :jruby
+  gem "debugger", :platforms => :mri_19
+  gem "byebug", :platforms => [:mri_20, :mri_21]
+end
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius', '~> 2.0'
+  gem 'json'
+end

VERSION

@@ -1 +1 @@
-1.1.2
+1.1.3

lib/rdf/rdfxml/patches/nokogiri_hacks.rb

@@ -5,14 +5,6 @@ def uri
     ns = self.namespace ? self.namespace.href : RDF::XML.to_s
     RDF::URI.intern(ns + self.node_name)
   end
-
-  def display_path
-    @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 && parent.display_path}@#{name}"
-    end
-  end
 
   alias_method :attribute_with_ns_without_ffi_null, :attribute_with_ns
   ##

lib/rdf/rdfxml/reader.rb

@@ -188,7 +188,7 @@ def each_statement(&block)
         add_debug(root, "base_uri: #{base_uri.inspect}")
 
         rdf_nodes = root.xpath("//rdf:RDF", "rdf" => RDF.to_uri.to_s)
-        if rdf_nodes.length == 0
+        if rdf_nodes.size == 0
           # If none found, root element may be processed as an RDF Node
 
           ec = EvaluationContext.new(base_uri, root, @graph) do |prefix, value|
@@ -207,7 +207,7 @@ def each_statement(&block)
               prefix(prefix, value)
             end
             node.children.each {|el|
-              next unless el.elem?
+              next unless el.element?
               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)
@@ -316,7 +316,7 @@ def nodeElement(el, ec)
       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?
+        next unless child.element?
         child_ec = ec.clone(child) do |prefix, value|
           prefix(prefix, value)
         end
@@ -338,7 +338,7 @@ def nodeElement(el, ec)
           raise "element node must be a proxy not a #{node.class}" unless node.is_a?(@implementation::NodeProxy)
         end
 
-        if element_nodes.length > 1
+        if element_nodes.size > 1
           element_nodes.each do |node|
             add_debug(child) {"  node: #{node.to_s}"}
           end
@@ -399,7 +399,7 @@ def nodeElement(el, ec)
         add_debug(child) {"nodeID: #{nodeID}"} if nodeID
         add_debug(child) {"id: #{id}"} if id
 
-        if attrs.empty? && datatype.nil? && parseType.nil? && element_nodes.length == 1
+        if attrs.empty? && datatype.nil? && parseType.nil? && element_nodes.size == 1
           # Production resourcePropertyElt
 
           new_ec = child_ec.clone(nil) do |prefix, value|
@@ -410,7 +410,7 @@ def nodeElement(el, ec)
           add_debug(child) {"resourcePropertyElt: #{node_path(new_node_element)}"}
           new_subject = nodeElement(new_node_element, new_ec)
           add_triple(child, subject, predicate, new_subject)
-        elsif attrs.empty? && parseType.nil? && element_nodes.length == 0 && text_nodes.length > 0
+        elsif attrs.empty? && parseType.nil? && element_nodes.size == 0 && text_nodes.size > 0
           # Production literalPropertyElt
           add_debug(child, "literalPropertyElt")
 
@@ -448,9 +448,9 @@ def nodeElement(el, ec)
           # c
           # end-element()
           add_debug(child, "compose new sequence with rdf:Description")
-          node = child.clone
-          node.attributes.keys.each {|a| node.remove_attribute(a)}
-          node.node_name = "Description"
+          #child.clone
+          #node.attributes.keys.each {|a| node.remove_attribute(a)}
+          node = el.create_node("Description", child.children)
           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|
@@ -518,7 +518,7 @@ def nodeElement(el, ec)
           rescue ArgumentError => e
             add_error(child, e.message)
           end
-        elsif text_nodes.length == 0 && element_nodes.length == 0
+        elsif text_nodes.size == 0 && element_nodes.size == 0
           # Production emptyPropertyElt
           add_debug(child, "emptyPropertyElt")
 

lib/rdf/rdfxml/reader/nokogiri.rb

@@ -23,6 +23,15 @@ def initialize(node, parent = nil)
           @parent = parent
         end
 
+        # Create a new element child of an existing node
+        def create_node(name, children)
+          native = ::Nokogiri::XML::Element.new(name, @node)
+          children.each do |c|
+            native.add_child(c.node)
+          end
+          NodeProxy.new(native, self)
+        end
+
         ##
         # Element language
         #
@@ -124,6 +133,10 @@ def xpath(*args)
           end
         end
 
+        def at_xpath(*args)
+          xpath(*args).first
+        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)
@@ -151,6 +164,8 @@ def uri
           RDF::URI.intern(ns + self.node_name)
         end
 
+        def to_s; @node.to_s; end
+
         ##
         # Proxy for everything else to @node
         def method_missing(method, *args)

lib/rdf/rdfxml/reader/rexml.rb

@@ -1,3 +1,5 @@
+require 'htmlentities'
+
 module RDF::RDFXML
   class Reader < RDF::Reader
     ##
@@ -13,6 +15,11 @@ def self.library
         :rexml
       end
 
+      # For Attribute namespaces
+      Namespace = Struct.new(:href, :prefix) do
+        def to_s; href; end
+      end
+
       # Proxy class to implement uniform element accessors
       class NodeProxy
         attr_reader :node
@@ -21,6 +28,28 @@ class NodeProxy
         def initialize(node, parent = nil)
           @node = node
           @parent = parent
+          @parent = NodeProxy.new(node.parent) if @parent.nil? &&
+                                                  node.respond_to?(:parent) &&
+                                                  node.parent &&
+                                                  !node.parent.is_a?(::REXML::Document)
+        end
+
+        # Create a new element child of an existing node
+        def create_node(name, children)
+          native = ::REXML::Element.new(name, @node)
+          children.each do |c|
+            case c.node
+            when ::REXML::Text
+              native.add_text(c.node)
+            when ::REXML::Element
+              native.add_element(c.node)
+            when ::REXML::Comment
+              # Skip comments
+            else
+              raise "Unexpected child node type: #{c.node.class}"
+            end
+          end
+          NodeProxy.new(native, self)
         end
 
         ##
@@ -89,7 +118,15 @@ def namespaces
           end
           ns_decls
         end
-        
+
+        def namespace
+          Namespace.new(@node.namespace, @node.prefix) unless @node.namespace.to_s.empty?
+        end
+
+        def add_namespace(prefix, uri)
+          prefix ? !@node.add_namespace(prefix, uri) : @node.add_namespace(uri)
+        end
+
         ##
         # Children of this node
         #
@@ -115,33 +152,46 @@ def inner_text
           }.join
         end
 
-        ##
-        # Node type accessors
-        #
-        # @return [Boolean]
-        def element?
-          @node.is_a?(::REXML::Element)
+        def attribute_nodes
+          attrs = @node.attributes.dup.keep_if do |name, attr|
+            !name.start_with?('xmlns')
+          end
+          @attribute_nodes ||= (attrs.empty? ? attrs : NodeSetProxy.new(attrs, self))
         end
 
-        def attribute_nodes
-          @attribute_nodes ||= NodeSetProxy.new(@node.children.select {|n| n.is_a?(::REXML::Attribute)}, self)
+        def remove_attribute(key)
+          @node.delete_attribute(key)
         end
 
         def xpath(*args)
           #NodeSetProxy.new(::REXML::XPath.match(@node, path, namespaces), self)
           ::REXML::XPath.match(@node, *args).map do |n|
-            # Get node ancestors
-            parent = n.ancestors.reverse.inject(nil) do |p,node|
-              NodeProxy.new(node, p)
-            end
             NodeProxy.new(n, parent)
           end
         end
 
-        def elem?
+        def at_xpath(*args)
+          xpath(*args).first
+        end
+
+        ##
+        # Node type accessors
+        #
+        # @return [Boolean]
+        def text?
+          @node.is_a?(::REXML::Text)
+        end
+
+        def element?
           @node.is_a?(::REXML::Element)
         end
 
+        def blank?
+          @node.is_a?(::REXML::Text) && @node.empty?
+        end
+
+        def to_s; @node.to_s; end
+
         ##
         # Proxy for everything else to @node
         def method_missing(method, *args)
@@ -166,10 +216,22 @@ def initialize(node_set, parent)
         # @yield child
         # @yieldparam [NodeProxy]
         def each
-          @node_set.each do |c|
+          @node_set.to_a.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

lib/rdf/rdfxml/writer.rb

@@ -1,4 +1,3 @@
-require 'nokogiri'  # FIXME: Implement using different modules as in RDF::TriX
 require 'rdf/rdfa'
 
 module RDF::RDFXML