rdf-xsd 0.3.4 → 0.3.5

data/README.markdown

@@ -9,9 +9,11 @@ This gem adds additional RDF::Literal subclasses for extended [XSD datatypes][]
 * Additional xsd:integer subtypes
 * xsd:float based on xsd:double
 * xsd:duration
+* rdf:XMLLiteral
+* XML Exclusive Canonicalization (Nokogiri & REXML)
+* XML Literal comparisions (EquivalentXml, ActiveSupport or String)
 
-Examples
---------
+## Examples
 
     require 'rdf'
     require 'rdf/xsd'
@@ -46,11 +48,15 @@ Full documentation available on [Rubydoc.info][XSD doc]
 * {RDF::Literal::MonthDay}
 * {RDF::Literal::Month}
 * {RDF::Literal::Day}
+* {RDF::Literal::XML}
 
 ## Dependencies
 
 * [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
 * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
+* Soft dependency on [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.5.0)
+* Soft dependency on [EquivalentXML](http://rubygems.org/gems/equivalent-xml) (>= 0.2.8)
+* Soft dependency on [ActiveSupport](http://rubygems.org/gems/activesupport) (>= 2.3.0)
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.5

data/lib/rdf/xsd/duration.rb

@@ -139,11 +139,11 @@ module RDF; class Literal
       case other
       when Duration
         return super unless other.valid?
-        self.to_f == something.to_f
+        self.to_f == other.to_f
       when String
-        self.to_s(:xml) == something
+        self.to_s(:xml) == other
       when Numeric
-        self.to_f == something
+        self.to_f == other
       when Literal::DateTime, Literal::Time, Literal::Date
         false
       else

data/lib/rdf/xsd/extensions.rb

@@ -0,0 +1,203 @@
+begin
+  require 'nokogiri'
+rescue LoadError => e
+end
+require 'rexml/document'
+
+if defined?(::Nokogiri)
+  module ::Nokogiri::XML
+    ##
+    # XML Exclusive Canonicalization (c14n) for Nokogiri.
+    #
+    # Classes mixin this module to implement canonicalization methods.
+    #
+    # This implementation acts in two parts, first to canonicalize the Node
+    # or NoteSet in the context of its containing document, and second to
+    # serialize to a lexical representation.
+    #
+    # @see # @see   http://www.w3.org/TR/xml-exc-c14n/
+    class Node
+      ##
+      # Canonicalize the Node. Return a new instance of this node
+      # which is canonicalized and marked as such
+      #
+      # @param [Hash{Symbol => Object}] options
+      # @option options [Hash{String => String}] :namespaces
+      #   Namespaces to apply to node.
+      # @option options [#to_s] :language
+      #   Language to set on node, unless an xml:lang is already set.
+      def c14nxl(options = {})
+        @c14nxl = true
+        self
+      end
+
+      ##
+      # Serialize a canonicalized Node or NodeSet to XML
+      #
+      # Override standard #to_s implementation to output in c14n representation
+      # if the Node or NodeSet is marked as having been canonicalized
+      def to_s_with_c14nxl
+        if instance_variable_defined?(:@c14nxl)
+          serialize(:save_with => ::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)
+        else
+          to_s_without_c14nxl
+        end
+      end
+
+      alias_method :to_s_without_c14nxl, :to_s
+      alias_method :to_s, :to_s_with_c14nxl
+    end
+
+    class Element
+      ##
+      # Canonicalize the Element. Return a new instance of this node
+      # which is canonicalized and marked as such.
+      #
+      # Apply namespaces either passed as an option, or that are in scope.
+      #
+      # @param [Hash{Symbol => Object}] options
+      #   From {Nokogiri::XML::Node#c14nxl}
+      def c14nxl(options = {})
+        options[:namespaces] ||= self.namespace_scopes.compact.inject({}) do |memo, ns|
+          memo[ns.prefix] = ns.href.to_s
+          memo
+        end
+        element = self.clone
+
+        # Add in-scope namespace definitions
+        options[:namespaces].each do |prefix, href|
+          if prefix.to_s.empty?
+            element.default_namespace = href unless element.namespace
+          else
+            element.add_namespace(prefix.to_s, href) unless element.namespaces[prefix.to_s]
+          end
+        end
+
+        # Add language
+        element["xml:lang"] = options[:language].to_s if
+          options[:language] &&
+          element.attribute_with_ns("lang", "http://www.w3.org/XML/1998/namespace").to_s.empty? &&
+          element.attribute("lang").to_s.empty?
+
+        element
+      end
+    end
+
+    class NodeSet
+      ##
+      # Canonicalize the NodeSet. Return a new NodeSet marked
+      # as being canonical with all child nodes canonicalized.
+      #
+      # @param [Hash{Symbol => Object}] options
+      #   Passed to {Nokogiri::XML::Node#c14nxl}
+      def c14nxl(options = {})
+        # Create a new NodeSet
+        set = self.clone
+        set.instance_variable_set(:@c14nxl, true)
+
+        self.each {|c| set << c.c14nxl(options)}
+        set
+      end
+
+      ##
+      # Serialize a canonicalized Node or NodeSet to XML
+      #
+      # Override standard #to_s implementation to output in c14n representation
+      # if the Node or NodeSet is marked as having been canonicalized
+      def to_s_with_c14nxl
+        if instance_variable_defined?(:@c14nxl)
+          to_a.map {|c| c.serialize(:save_with => ::Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS)}.join("")
+        else
+          to_s_without_c14nxl
+        end
+      end
+
+      alias_method :to_s_without_c14nxl, :to_s
+      alias_method :to_s, :to_s_with_c14nxl
+    end
+
+    class Document
+      def doctype
+        self.children.first rescue false
+      end
+    end
+  end
+end
+
+## REXML C14N
+class Array
+  ##
+  # Canonicalize the NodeSet. Return a new NodeSet marked
+  # as being canonical with all child nodes canonicalized.
+  #
+  # @param [Hash{Symbol => Object}] options
+  #   Passed to {Nokogiri::XML::Node#c14nxl}
+  def c14nxl(options = {})
+    # Create a new NodeSet
+    set = []
+    set.instance_variable_set(:@c14nxl, true)
+
+    # Unless passed a set of namespaces, figure them out from namespace_scopes
+    #options[:namespaces] ||= first.parent.namespace_scopes.compact.inject({}) do |memo, ns|
+    #  memo[ns.prefix] = ns.href.to_s
+    #  memo
+    #end
+
+    self.each {|c| set << (c.respond_to?(:c14nxl) ? c.c14nxl(options) : c)}
+    set
+  end
+
+  ##
+  # Serialize a canonicalized Node or NodeSet to XML
+  #
+  # Override standard #to_s implementation to output in c14n representation
+  # if the Node or NodeSet is marked as having been canonicalized
+  def to_s_with_c14nxl
+    if instance_variable_defined?(:@c14nxl)
+      map {|c| c.to_s}.join("")
+    else
+      to_s_without_c14nxl
+    end
+  end
+
+  alias_method :to_s_without_c14nxl, :to_s
+  alias_method :to_s, :to_s_with_c14nxl
+end
+
+class REXML::Element
+  ##
+  # Canonicalize the Element. Return a new instance of this node
+  # which is canonicalized and marked as such.
+  #
+  # Apply namespaces either passed as an option, or that are in scope.
+  #
+  # @param [Hash{Symbol => Object}] options
+  #   From {Nokogiri::XML::Node#c14nxl}
+  def c14nxl(options = {})
+    # Add in-scope namespace definitions, unless supplied
+    options[:namespaces] ||= self.namespaces
+    element = options[:inplace] ? self : self.dup
+
+    # Add in-scope namespace definitions
+    options[:namespaces].each do |prefix, href|
+      if prefix.to_s.empty?
+        element.add_attribute("xmlns", href) unless element.attribute("xmlns")
+      else
+        element.add_attribute("xmlns:#{prefix}", href) unless element.attribute("xmlns:#{prefix}")
+      end
+    end
+
+    # Add language
+    element.add_attribute("xml:lang", options[:language].to_s) if
+      options[:language] &&
+      element.attribute("lang", "http://www.w3.org/XML/1998/namespace").to_s.empty? &&
+      element.attribute("lang").to_s.empty?
+
+    # Make sure it formats as open/close tags
+    element.text = "" if element.text == nil && element.children.empty?
+    
+    # Recurse through children to ensure tags are set properly
+    element.children.each {|c| c.c14nxl(:inplace => true, :namespaces => {}) if c.is_a?(REXML::Element)}
+    element
+  end
+end

data/lib/rdf/xsd/xml.rb

@@ -0,0 +1,139 @@
+# Use Nokogiri when available, and REXML otherwise:
+begin
+  raise LoadError, "not with java" if RUBY_PLATFORM == "java"
+  require 'nokogiri'
+  begin
+    require 'equivalent-xml'
+  rescue LoadError => e
+    STDERR.puts "Could not load gem 'equivalent-xml'; XMLLiteral comparison performed using REXML"
+  end
+rescue LoadError => e
+  :rexml
+end
+
+module RDF; class Literal
+  ##
+  # An XML literal.
+  #
+  # XML Literals are maintained in a lexical form, unless an object form is provided.
+  # The both lexical and object forms are presumed to be in Exclusive Canonical XML.
+  # As generating this form is dependent on the context of the XML Literal from the
+  # original document, canonicalization cannot be performed directly within this
+  # class.
+  #
+  # This gem includes Exclusive Canonical XML extensions {Nokogiri::XML::Node#c14nxl},
+  # {Nokogiri::XML::NodeSet#c14nxl}, {REXML::Element#c14nxl} and {Array#c14nxl} (necessary
+  # for REXML node children, which is the REXML implementation of a NodeSet)
+  #
+  # @see   http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
+  # @see   http://www.w3.org/TR/rdfa-core/#s_xml_literals
+  # @see   http://www.w3.org/TR/xml-exc-c14n/
+  # @since 0.2.1
+  class XML < Literal
+    #DATATYPE = RDF.XMLLiteral
+    #GRAMMAR  = nil
+
+    ##
+    # @param  [Object] value
+    # @option options [String] :lexical (nil)
+    # @option options [:nokogiri, :rexml] :library
+    #   Library to use, defaults to :nokogiri if available, :rexml otherwise
+    def initialize(value, options = {})
+      @datatype = options[:datatype] || DATATYPE
+      @string   = options[:lexical] if options.has_key?(:lexical)
+      if value.is_a?(String)
+        @string ||= value
+      else
+        @object = value
+      end
+
+      @library = case options[:library]
+      when nil
+        # Use Nokogiri when available, and REXML or Hpricot otherwise:
+        (defined?(::Nokogiri) && RUBY_PLATFORM != 'java') ? :nokogiri : :rexml
+      when :nokogiri, :rexml
+        options[:library]
+      else
+        raise ArgumentError.new("expected :rexml or :nokogiri, but got #{options[:library].inspect}")
+      end
+    end
+
+    ##
+    # Parse value, if necessary
+    #
+    # @return [Object]
+    def object
+      @object ||= case @library
+      when :nokogiri  then parse_nokogiri(value)
+      when :rexml     then parse_rexml(value)
+      end
+    end
+
+    def to_s
+      @string ||= (@object.is_a?(Array) ? @object.map(&:to_s).join("") : @object.to_s)
+    end
+
+    ##
+    # XML Equivalence. XML Literals can be compared with each other or with xsd:strings
+    #
+    # @param [Object] other
+    # @return [Boolean] `true` or `false`
+    #
+    # @see http://www.w3.org/TR/rdf-concepts/#section-XMLLiteral
+    def eql?(other)
+      if other.is_a?(Literal::XML)
+        case @library
+        when :nokogiri  then equivalent_nokogiri(other)
+        when :rexml     then equivalent_rexml(other)
+        end
+      elsif other.is_a?(Literal) && (other.plain? || other.datatype == RDF::XSD.string)
+        value == other.value
+      else
+        super
+      end
+    end
+
+    private
+    
+    # Nokogiri implementations
+    if defined?(::Nokogiri)
+      ##
+      # Parse the value either as a NodeSet, as results are equivalent if it is just a node
+      def parse_nokogiri(value)
+        Nokogiri::XML.parse("<root>#{value}</root>").root.children
+      end
+
+      # Use equivalent-xml to determine equivalence
+      def equivalent_nokogiri(other)
+        if defined?(::EquivalentXml)
+          EquivalentXml.equivalent?(object, other.object)
+        else
+          equivalent_rexml(other)
+        end
+      end
+    end
+    
+    ##
+    # Parse the value either as a NodeSet, as results are equivalent if it is just a node
+    def parse_rexml(value)
+      REXML::Document.new("<root>#{value}</root>").root.children
+    end
+    
+
+    # Simple equivalence test for REXML
+    def equivalent_rexml(other)
+      begin
+        require 'active_support/core_ext'
+      rescue LoadError => e
+        # string equivalence
+      end
+
+      if Hash.respond_to?(:from_xml)
+        Hash.from_xml("<root>#{self}</root>") == Hash.from_xml("<root>#{other}</root>")
+      else
+        # Poor mans equivalent
+        value == other.value
+      end
+    end
+  end # class XML
+end; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf-xsd
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
   prerelease: 
 platform: ruby
 authors:
@@ -10,11 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-15 00:00:00.000000000 Z
+date: 2011-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
-  requirement: &2160138240 !ruby/object:Gem::Requirement
+  requirement: &2152226860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,54 @@ dependencies:
         version: 0.3.4
   type: :runtime
   prerelease: false
-  version_requirements: *2160138240
+  version_requirements: *2152226860
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2152226100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152226100
+- !ruby/object:Gem::Dependency
+  name: equivalent-xml
+  requirement: &2152225100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.8
+  type: :development
+  prerelease: false
+  version_requirements: *2152225100
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: &2152224320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152224320
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &2152223060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2152223060
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2160117520 !ruby/object:Gem::Requirement
+  requirement: &2152221540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +77,10 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *2160117520
+  version_requirements: *2152221540
 - !ruby/object:Gem::Dependency
   name: rdf-spec
-  requirement: &2160116640 !ruby/object:Gem::Requirement
+  requirement: &2152219980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +88,10 @@ dependencies:
         version: 0.3.2
   type: :development
   prerelease: false
-  version_requirements: *2160116640
+  version_requirements: *2152219980
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &2160115500 !ruby/object:Gem::Requirement
+  requirement: &2152218640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +99,7 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *2160115500
+  version_requirements: *2152218640
 description: Adds RDF::Literal subclasses for extended XSD datatypes.
 email: public-rdf-ruby@w3.org
 executables: []
@@ -70,8 +114,10 @@ files:
 - lib/rdf/xsd/date.rb
 - lib/rdf/xsd/double.rb
 - lib/rdf/xsd/duration.rb
+- lib/rdf/xsd/extensions.rb
 - lib/rdf/xsd/integer.rb
 - lib/rdf/xsd/version.rb
+- lib/rdf/xsd/xml.rb
 - lib/rdf/xsd.rb
 homepage: http://github.com/gkellogg/rdf-xsd
 licenses:
@@ -99,3 +145,4 @@ signing_key:
 specification_version: 3
 summary: Extended XSD Datatypes for RDF.rb.
 test_files: []
+has_rdoc: false