the-experimenters-rdf-rdfxml 0.3.3

data/etc/doap.xml

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns="http://usefulinc.com/ns/doap#"
+    xmlns:log="http://www.w3.org/2000/10/swap/log#"
+    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+
+    <Person xmlns="http://xmlns.com/foaf/0.1/"
+        rdf:about="#_ggenid1">
+        <mbox_sha1sum>c69f3255ff0639543cc5edfd8116eac8df16fab8</mbox_sha1sum>
+        <name>Hellekin O. Wolf</name>
+    </Person>
+
+    <Person xmlns="http://xmlns.com/foaf/0.1/"
+        rdf:about="#_ggenid3">
+        <mbox_sha1sum>bedbbf2451e5beb38d59687c0460032aff92cd3c</mbox_sha1sum>
+        <name>Pius Uzamere</name>
+    </Person>
+
+    <Person xmlns="http://xmlns.com/foaf/0.1/"
+        rdf:about="#_ggenid2">
+        <mbox_sha1sum>f7653fc1ac0e82ebb32f092389bd5fc728eaae12</mbox_sha1sum>
+        <name>John Fieber</name>
+    </Person>
+
+    <Person xmlns="http://xmlns.com/foaf/0.1/"
+        rdf:about="http://ar.to/#self">
+        <isDefinedBy xmlns="http://www.w3.org/2000/01/rdf-schema#"
+            rdf:resource="http://datagraph.org/bendiken/foaf"/>
+        <homepage rdf:resource="http://ar.to/"/>
+        <made rdf:resource="http://rubygems.org/gems/rdf"/>
+        <mbox rdf:resource="mailto:arto.bendiken@gmail.com"/>
+        <mbox_sha1sum>a033f652c84a4d73b8c26d318c2395699dd2bdfb</mbox_sha1sum>
+        <mbox_sha1sum>d0737cceb55eb7d740578d2db1bc0727e3ed49ce</mbox_sha1sum>
+        <name>Arto Bendiken</name>
+    </Person>
+
+    <Person xmlns="http://xmlns.com/foaf/0.1/"
+        rdf:about="http://bhuga.net/#ben">
+        <isDefinedBy xmlns="http://www.w3.org/2000/01/rdf-schema#"
+            rdf:resource="http://datagraph.org/bhuga/foaf"/>
+        <homepage rdf:resource="http://bhuga.net/"/>
+        <mbox rdf:resource="mailto:blavender@gmail.com"/>
+        <mbox_sha1sum>dbf45f4ffbd27b67aa84f02a6a31c144727d10af</mbox_sha1sum>
+        <name>Ben Lavender</name>
+    </Person>
+
+    <Project rdf:about="http://rubygems.org/gems/rdf">
+        <creator xmlns="http://purl.org/dc/terms/"
+            rdf:resource="http://ar.to/#self"/>
+        <blog rdf:resource="http://ar.to/"/>
+        <blog rdf:resource="http://blog.datagraph.org/"/>
+        <bug-database rdf:resource="http://github.com/bendiken/rdf/issues"/>
+        <category rdf:resource="http://dbpedia.org/resource/Resource_Description_Framework"/>
+        <category rdf:resource="http://dbpedia.org/resource/Ruby_(programming_language)"/>
+        <created>2007-10-23</created>
+        <description xml:lang="en">RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data.</description>
+        <developer rdf:resource="http://ar.to/#self"/>
+        <developer rdf:resource="http://bhuga.net/#ben"/>
+        <documenter rdf:resource="http://ar.to/#self"/>
+        <download-page rdf:resource="http://rubyforge.org/projects/rdf/"/>
+        <helper rdf:resource="#_ggenid1"/>
+        <helper rdf:resource="#_ggenid2"/>
+        <helper rdf:resource="#_ggenid3"/>
+        <homepage rdf:resource="http://rdf.rubyforge.org/"/>
+        <license rdf:resource="http://creativecommons.org/licenses/publicdomain/"/>
+        <maintainer rdf:resource="http://ar.to/#self"/>
+        <name>RDF.rb</name>
+        <platform>Ruby</platform>
+        <shortdesc xml:lang="en">A Ruby library for working with Resource Description Framework (RDF) data.</shortdesc>
+        <vendor rdf:resource="http://datagraph.org/"/>
+        <maker xmlns="http://xmlns.com/foaf/0.1/"
+            rdf:resource="http://ar.to/#self"/>
+    </Project>
+</rdf:RDF>

data/example.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rubygems'
+require 'rdf/rdfxml'
+
+data = <<-EOF;
+  <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+  xmlns:ex="http://www.example.org/" xml:lang="en" xml:base="http://www.example.org/foo">
+    <ex:Thing rdf:about="http://example.org/joe" ex:name="bar">
+      <ex:belongsTo rdf:resource="http://tommorris.org/" />
+      <ex:sampleText rdf:datatype="http://www.w3.org/2001/XMLSchema#string">foo</ex:sampleText>
+      <ex:hadADodgyRelationshipWith>
+        <rdf:Description>
+          <ex:name>Tom</ex:name>
+          <ex:hadADodgyRelationshipWith>
+            <rdf:Description>
+              <ex:name>Rob</ex:name>
+              <ex:hadADodgyRelationshipWith>
+                <rdf:Description>
+                  <ex:name>Mary</ex:name>
+                </rdf:Description>
+              </ex:hadADodgyRelationshipWith>
+            </rdf:Description>
+          </ex:hadADodgyRelationshipWith>
+        </rdf:Description>
+      </ex:hadADodgyRelationshipWith>
+    </ex:Thing>
+  </rdf:RDF>
+EOF
+
+RDF::RDFXML::Reader.new(data, :base_uri => 'http://example.org/example.xml') do |reader|
+  reader.each_statement do |statement|
+    statement.inspect!
+  end
+end

data/lib/rdf/rdfxml.rb

@@ -0,0 +1,50 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+require 'rdf'
+
+module RDF
+  ##
+  # **`RDF::RDFXML`** is an RDF/XML plugin for RDF.rb.
+  #
+  # @example Requiring the `RDF::RDFXML` module
+  #   require 'rdf/rdfxml'
+  #
+  # @example Parsing RDF statements from an XHTML+RDFXML file
+  #   RDF::RDFXML::Reader.open("etc/foaf.xml") do |reader|
+  #     reader.each_statement do |statement|
+  #       puts statement.inspect
+  #     end
+  #   end
+  #
+  # @see http://rdf.rubyforge.org/
+  # @see http://www.w3.org/TR/REC-rdf-syntax/
+  #
+  # @author [Gregg Kellogg](http://kellogg-assoc.com/)
+  module RDFXML
+    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'
+    autoload :XML,     'rdf/rdfxml/vocab'
+
+    # Regexp matching an NCName.
+    NC_REGEXP = Regexp.new(
+      %{^
+        (?!\\\\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]
+        )
+        (  [0-9a-zA-Z_\.-]
+         | \\\\u([0-9a-fA-F]{4})
+        )*
+      $},
+      Regexp::EXTENDED)
+  
+    def self.debug?; @debug; end
+    def self.debug=(value); @debug = value; end
+  end
+end

data/lib/rdf/rdfxml/format.rb

@@ -0,0 +1,43 @@
+module RDF::RDFXML
+  ##
+  # RDFXML format specification.
+  #
+  # @example Obtaining an RDFXML format class
+  #   RDF::Format.for(:rdf)         # RDF::RDFXML::Format
+  #   RDF::Format.for(:rdfxml)      # RDF::RDFXML::Format
+  #   RDF::Format.for("etc/foaf.xml")
+  #   RDF::Format.for(:file_name      => "etc/foaf.xml")
+  #   RDF::Format.for(:file_extension => "xml")
+  #   RDF::Format.for(:file_extension => "rdf")
+  #   RDF::Format.for(:content_type   => "application/xml")
+  #   RDF::Format.for(:content_type   => "application/rdf+xml")
+  #
+  # @example Obtaining serialization format MIME types
+  #   RDF::Format.content_types      #=> {"application/rdf+xml" => [RDF::RDFXML::Format]}
+  #
+  # @example Obtaining serialization format file extension mappings
+  #   RDF::Format.file_extensions    #=> {:rdf => "application/rdf+xml"}
+  #
+  # @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'
+
+    reader { RDF::RDFXML::Reader }
+    writer { RDF::RDFXML::Writer }
+  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/array_hacks.rb

@@ -0,0 +1,53 @@
+class Array
+  # http://wiki.rubygarden.org/Ruby/page/show/ArrayPermute
+  # Permute an array, and call a block for each permutation
+  # Author: Paul Battley
+  def permute(prefixed=[])
+    if (length < 2)
+      # there are no elements left to permute
+      yield(prefixed + self)
+    else
+      # recursively permute the remaining elements
+      each_with_index do |e, i|
+        (self[0,i]+self[(i+1)..-1]).permute(prefixed+[e]) { |a| yield a }
+      end
+    end
+  end unless Array.method_defined?(:permute)
+  
+  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  def to_sentence(options = {})
+    default_words_connector     = ", "
+    default_two_words_connector = " and "
+    default_last_word_connector = ", and "
+
+    # Try to emulate to_senteces previous to 2.3
+    if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
+      ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
+      ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
+
+      skip_last_comma = options.delete :skip_last_comma
+      if connector = options.delete(:connector)
+        options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
+      else
+        options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
+      end
+    end
+
+#    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+    options = {:words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector}.merge(options)
+
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end unless Array.method_defined?(:to_sentence)
+end

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

@@ -0,0 +1,34 @@
+module RDF
+  class Graph
+    # Resource properties
+    #
+    # Properties arranged as a hash with the predicate Term as index to an array of resources or literals
+    #
+    # Example:
+    #   graph.load(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+    #   graph.resources(URI.new("http://example.com/subject")) =>
+    #   {
+    #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+    #     "http://example.com/#label"                       => ["An example"]
+    #   }
+    def properties(subject, recalc = false)
+      @properties ||= {}
+      @properties.delete(subject.to_s) if recalc
+      @properties[subject.to_s] ||= begin
+        hash = Hash.new
+        self.query(:subject => subject) do |statement|
+          pred = statement.predicate.to_s
+
+          hash[pred] ||= []
+          hash[pred] << statement.object
+        end
+        hash
+      end
+    end
+
+    # Get type(s) of subject, returns a list of symbols
+    def type_of(subject)
+      query(:subject => subject, :predicate => RDF.type).map {|st| st.object}
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# 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