rdf-rdfa 0.0.3 → 0.2.1

data/History.txt

@@ -1,3 +1,11 @@
+=== 0.2.1
+* Update for RDF 0.2.1
+
+=== 0.2.0
+* Updates for RDF 0.2.0
+  * Use URI#intern instead of URI#new
+  * Change use of Graph#predicates and Graph#objects to use as enumerables
+
 === 0.0.3
 * Removed interal graph in Reader and implement each_triple & each_statement to perform parsing
 

data/README.rdoc

@@ -25,16 +25,14 @@ Instantiate a parser and parse source, specifying type and base-URL
   end
 
 == Dependencies
-  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.1.6)
+  * [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0)
   * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.3.3)
-  * [Patron](http://rubygems.org/gems/patron) (>= 0.4.6) -- For RDFa profiles
 
 == TODO
 * Add support for LibXML and REXML bindings, and use the best available
 * Consider a SAX-based parser for improved performance
 * Port SPARQL tests to native SPARQL processor, when one becomes available.
 * Add generic XHTML+RDFa Writer
-* Only parse profiles if Patron included, don't force otherwise
 
 == Resources:
 * RDF.rb[http://rdf.rubyforge.org/]   

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'yard'
 
 begin
   gem 'jeweler'
@@ -12,12 +13,14 @@ begin
     gemspec.email = "gregg@kellogg-assoc.com"
     gemspec.homepage = "http://github.com/gkellogg/rdf-rdfa"
     gemspec.authors = ["Gregg Kellogg"]
-    gemspec.add_dependency('rdf', '>= 0.1.6')
+    gemspec.add_dependency('rdf', '>= 0.2.1')
     gemspec.add_dependency('nokogiri', '>= 1.3.3')
     gemspec.add_development_dependency('rspec')
-    gemspec.add_development_dependency('rdf-spec')
-    gemspec.add_development_dependency('activesupport', '>= 2.3.0')
-    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS)
+    gemspec.add_development_dependency('rdf-spec', '>= 0.2.1')
+    gemspec.add_development_dependency('rdf-rdfxml', '>= 0.2.1')
+    gemspec.add_development_dependency('rdf-isomorphic')
+    gemspec.add_development_dependency('yard')
+    gemspec.extra_rdoc_files     = %w(README.rdoc History.txt AUTHORS CONTRIBUTORS)
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
@@ -45,4 +48,24 @@ Spec::Rake::SpecTask.new("doc:spec") do |spec|
   spec.spec_opts = ["--format", "html:doc/spec.html"]
 end
 
+YARD::Rake::YardocTask.new do |t|
+  t.files   = %w(lib/**/*.rb README.rdoc History.txt AUTHORS CONTRIBUTORS)   # optional
+end
+
+desc "Generate RDF Core Manifest.yml"
+namespace :spec do
+  task :prepare do
+    $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+    require 'rdf/rdfa'
+    require 'spec/rdfa_helper'
+    require 'fileutils'
+
+    %w(xhtml html4 html5).each do |suite|
+      yaml = manifest_file = File.join(File.dirname(__FILE__), "spec", "#{suite}-manifest.yml")
+      FileUtils.rm_f(yaml)
+      RdfaHelper::TestCase.to_yaml(suite, yaml)
+    end
+  end
+end
+
 task :default => :spec

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.2.1

data/lib/rdf/rdfa.rb

@@ -25,6 +25,8 @@ module RDF
   module RDFa
     require 'rdf/rdfa/format'
     require 'rdf/rdfa/vocab'
+    require 'rdf/rdfa/patches/literal_hacks'
+    require 'rdf/rdfa/patches/uri_hacks'
     autoload :Reader,  'rdf/rdfa/reader'
     autoload :VERSION, 'rdf/rdfa/version'
   end

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

@@ -0,0 +1,147 @@
+# 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 (nil)
+    # @option options [Hash] :namespaces ({})
+    # @option options [Symbol] :language (nil)
+    # @option options [Symbol] :library (:nokogiri, :libxml, or :rexml)
+    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|
+        attr = prefix.to_s.empty? ? "xmlns" : "xmlns:#{prefix}"
+        ns_hash[attr] = uri.to_s
+      end
+      ns_strs = []
+      ns_hash.each_pair {|a, u| ns_strs << "#{a}=\"#{u}\""}
+
+      case @library
+      when :nokogiri  then parse_value_nokogiri(value, ns_strs, options[:language])
+      when :libxml    then parse_value_libxml(value, ns_strs, options[:language])
+      when :rexml     then parse_value_rexml(value, ns_strs, options[:language])
+      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)
+      def parse_value_nokogiri(value, ns_strs, language)
+        return value if value.is_a?(Nokogiri::XML::NodeSet)
+        # Add inherited namespaces to created root element so that they're inherited to sub-elements
+        elements = Nokogiri::XML::Document.parse("<foo #{ns_strs.join(" ")}>#{value.to_s}</foo>").root.children
+
+        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
+            # Gather namespaces from self and decendant nodes
+            c.traverse do |n|
+              ns = n.namespace
+              next unless ns
+              prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+              c[prefix] = ns.href.to_s unless c.namespaces[prefix]
+            end
+
+            # Add lanuage
+            if language && c["lang"].to_s.empty?
+              c["xml:lang"] = language
+            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)
+      def parse_value_libxml(value, ns_strs, language)
+        # Fixme
+      end
+
+      def serialize_nodeset_libxml(object)
+        # Fixme
+      end
+    end   # LibXML
+    
+    # REXML
+    def parse_value_rexml(value, ns_strs, language)
+      # Fixme
+    end
+
+    def serialize_nodeset_rexml(object)
+      # Fixme
+    end
+    
+  end unless defined?(::RDF::Literal::XML)# class XML
+end; end

data/lib/rdf/rdfa/patches/uri_hacks.rb

@@ -0,0 +1,19 @@
+module RDF
+  class URI
+    ##
+    # Joins several URIs together.
+    #
+    # @param  [Array<String, URI, #to_str>] uris
+    # @return [URI]
+    #
+    # GK -- don't add a "/" at the end of URIs, due to rdfcore/xmlbase/test002.rdf
+    def join(*uris)
+      result = @uri
+      uris.each do |uri|
+#        result.path += '/' unless result.path.match(/[\#\/]$/) || uri.to_s[0..0] == "#"
+        result = result.join(uri)
+      end
+      self.class.new(result)
+    end
+  end
+end

data/lib/rdf/rdfa/reader.rb

@@ -21,8 +21,6 @@ module RDF::RDFa
       $},
       Regexp::EXTENDED)
   
-    XML_LITERAL = RDF['XMLLiteral']
-    
     # Host language, One of:
     #   :xhtml_rdfa_1_0
     #   :xhtml_rdfa_1_1
@@ -71,9 +69,9 @@ module RDF::RDFa
         @base = base
         @parent_subject = @base
         @parent_object = nil
-        @uri_mappings = {}
         @incomplete_triples = []
         @language = nil
+        @uri_mappings = host_defaults.fetch(:uri_mappings, {})
         @term_mappings = host_defaults.fetch(:term_mappings, {})
         @default_voabulary = host_defaults.fetch(:voabulary, nil)
       end
@@ -97,11 +95,11 @@ module RDF::RDFa
     ##
     # Initializes the RDFa reader instance.
     #
-    # @param  [IO, File, String]::       input
-    # @param  [Hash{Symbol => Object}]:: options
-    # <em>options[:debug]</em>:: Array to place debug messages
-    # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
-    # <em>options[:base_uri]</em>:: Base URI to use for relative URIs.
+    # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, IO, File, String]       input
+    # @option options [Array] :debug (nil) Array to place debug messages
+    # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
+    # @option options [Boolean] :base_uri (nil) Base URI to use for relative URIs.
+    # @return [reader]
     # @yield  [reader]
     # @yieldparam [Reader] reader
     # @raise [RDF::ReaderError]:: Raises RDF::ReaderError if _strict_
@@ -109,7 +107,7 @@ module RDF::RDFa
       super do
         @debug = options[:debug]
         @strict = options[:strict]
-        @base_uri = RDF::URI.new(options[:base_uri])
+        @base_uri = RDF::URI.intern(options[:base_uri])
         @@vocabulary_cache ||= {}
 
         @doc = case input
@@ -124,8 +122,6 @@ module RDF::RDFa
       end
     end
 
-
-    # XXX Invoke the parser, and allow add_triple to make the callback?
     ##
     # Iterates the given block for each RDF statement in the input.
     #
@@ -150,6 +146,7 @@ module RDF::RDFa
         {
           :vocabulary => RDF::XHV.to_s,
           :prefix     => "xhv",
+          :uri_mappings => {"xhv" => RDF::XHV.to_s}, # RDF::XHTML is wrong
           :term_mappings => %w(
             alternate appendix bookmark cite chapter contents copyright first glossary help icon index
             last license meta next p3pv1 prev role section stylesheet subsection start top up
@@ -179,6 +176,12 @@ module RDF::RDFa
     
     private
 
+    # Keep track of allocated BNodes
+    def bnode(value = nil)
+      @bnode_cache ||= {}
+      @bnode_cache[value.to_s] ||= RDF::Node.new(value)
+    end
+    
     # Figure out the document path, if it is a Nokogiri::XML::Element or Attribute
     def node_path(node)
       case node
@@ -221,7 +224,7 @@ module RDF::RDFa
         base = base_el.attributes['href']
         # Strip any fragment from base
         base = base.to_s.split("#").first
-        @base_uri = RDF::URI.new(base)
+        @base_uri = RDF::URI.intern(base)
         add_debug(base_el, "parse_whole_doc: base='#{base}'")
       end
 
@@ -238,10 +241,17 @@ module RDF::RDFa
       # local list of URI mappings via @profile.
       # If @profile is present, its value is processed as defined in RDFa Profiles.
       element.attributes['profile'].to_s.split(/\s/).each do |profile|
-        # Don't try to open ourselves!
-        if @base_uri == profile
-          add_debug(element, "extract_mappings: skip recursive profile <#{profile}>")
+        if node_path(element) == "/html/head"
+          # Don't try to open ourselves!
+          add_debug(element, "extract_mappings: skip head profile <#{profile}>")
+          next
+        elsif @@vocabulary_cache[profile]
+          add_debug(element, "extract_mappings: cached profile <#{profile}>")
           @@vocabulary_cache[profile]
+        elsif @base_uri.to_s == profile
+          # Don't try to open ourselves!
+          add_debug(element, "extract_mappings: skip recursive profile <#{profile}>")
+          next
         elsif @@vocabulary_cache.has_key?(profile)
           add_debug(element, "extract_mappings: skip previously parsed profile <#{profile}>")
         else
@@ -258,7 +268,8 @@ module RDF::RDFa
             old_debug, old_verbose, = $DEBUG, $verbose
             $DEBUG, $verbose = false, false
             # FIXME: format shouldn't need to be specified here
-            p_graph = RDF::Graph.load(profile, :base_uri => profile, :format => :rdfa)
+            p_graph = RDF::Graph.load(profile, :base_uri => profile, :format => RDF::Format.for(profile) || :rdfa)
+            puts p_graph.inspect if old_debug
             $DEBUG, $verbose = old_debug, old_verbose
             p_graph.each_subject do |subject|
               # If one of the objects is not a Literal no mapping is created.
@@ -282,7 +293,7 @@ module RDF::RDFa
               # triple that is the common subject of an rdfa:term and an rdfa:uri predicate, create a
               # mapping from the object literal of the rdfa:term predicate to the object literal of the
               # rdfa:uri predicate. Add or update this mapping in the local term mappings.
-              tm[term.value] = RDF::URI.new(uri.value) if term
+              tm[term.value] = RDF::URI.intern(uri.value) if term
             end
           # FIXME: subject isn't in scope here
           #rescue RDF::ReaderError
@@ -317,7 +328,6 @@ module RDF::RDFa
       # Set mappings from @prefix
       # prefix is a whitespace separated list of prefix-name URI pairs of the form
       #   NCName ':' ' '+ xs:anyURI
-      # SPEC Confusion: prefix is forced to lower-case in @profile, but not specified here.
       mappings = element.attributes["prefix"].to_s.split(/\s+/)
       while mappings.length > 0 do
         prefix, uri = mappings.shift.downcase, mappings.shift
@@ -405,7 +415,8 @@ module RDF::RDFa
       else
         language
       end
-      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if attrs['lang']
+      language = nil if language.to_s.empty?
+      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language || 'nil'}") if attrs['lang']
     
       # rels and revs
       rels = process_uris(element, rel, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary)
@@ -439,7 +450,7 @@ module RDF::RDFa
             # From XHTML+RDFa 1.1:
             # if no URI is provided, then first check to see if the element is the head or body element.
             # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
-            new_subject = RDF::URI.new(evaluation_context.base)
+            new_subject = RDF::URI.intern(evaluation_context.base)
           elsif element.attributes['typeof']
             new_subject = RDF::Node.new
           else
@@ -465,7 +476,7 @@ module RDF::RDFa
             # From XHTML+RDFa 1.1:
             # if no URI is provided, then first check to see if the element is the head or body element.
             # If it is, then act as if there is an empty @about present, and process it according to the rule for @about.
-            new_subject = RDF::URI.new(evaluation_context.base)
+            new_subject = RDF::URI.intern(evaluation_context.base)
           elsif element.attributes['typeof']
             new_subject = RDF::Node.new
           else
@@ -528,18 +539,18 @@ module RDF::RDFa
       
         # the following 3 IF clauses should be mutually exclusive. Written as is to prevent extensive indentation.
         type_resource = process_uri(element, type, evaluation_context, :uri_mappings => uri_mappings, :term_mappings => term_mappings, :vocab => default_vocabulary) if type
-        if type and !type.empty? and (type_resource.to_s != XML_LITERAL.to_s)
+        if type and !type.empty? and (type_resource.to_s != RDF.XMLLiteral.to_s)
           # typed literal
           add_debug(element, "[Step 11] typed literal")
-          current_object_literal = RDF::Literal.new(content || element.inner_text, :datatype => type_resource, :language => language)
+          current_object_literal = RDF::Literal.new(content || element.inner_text.to_s, :datatype => type_resource, :language => language)
         elsif content or (children_node_types == [Nokogiri::XML::Text]) or (element.children.length == 0) or (type == '')
           # plain literal
           add_debug(element, "[Step 11] plain literal")
-          current_object_literal = RDF::Literal.new(content || element.inner_text, :language => language)
-        elsif children_node_types != [Nokogiri::XML::Text] and (type == nil or type_resource.to_s == XML_LITERAL.to_s)
+          current_object_literal = RDF::Literal.new(content || element.inner_text.to_s, :language => language)
+        elsif children_node_types != [Nokogiri::XML::Text] and (type == nil or type_resource.to_s == RDF.XMLLiteral.to_s)
           # XML Literal
           add_debug(element, "[Step 11] XML Literal: #{element.inner_html}")
-          current_object_literal = RDF::Literal.new(element.inner_html, :datatype => XML_LITERAL, :language => language, :namespaces => uri_mappings)
+          current_object_literal = RDF::Literal.new(element.inner_html, :datatype => RDF.XMLLiteral, :language => language, :namespaces => uri_mappings.merge("" => "http://www.w3.org/1999/xhtml"))
           recurse = false
         end
       
@@ -635,7 +646,7 @@ module RDF::RDFa
           add_debug(element, "process_uri: #{value} => CURIE => <#{uri}>")
         else
           ## FIXME: throw exception if there is no base uri set?
-          uri = RDF::URI.new(evaluation_context.base + value)
+          uri = RDF::URI.intern(RDF::URI.intern(evaluation_context.base).join(value))
           add_debug(element, "process_uri: #{value} => URI => <#{uri}>")
         end
         uri
@@ -656,7 +667,7 @@ module RDF::RDFa
         options[:term_mappings][value.to_s.downcase]
       when options[:vocab]
         # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
-        RDF::URI.new(options[:vocab] + value)
+        RDF::URI.intern(options[:vocab] + value)
       else
         # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
         nil
@@ -670,13 +681,13 @@ module RDF::RDFa
 
       # consider the bnode situation
       if prefix == "_"
-        RDF::Node.new(reference)
+        bnode(reference)
       elsif curie.to_s.match(/^:/)
         # Default prefix
         if uri_mappings[""]
-          RDF::URI.new(uri_mappings[""] + reference)
+          RDF::URI.intern(uri_mappings[""] + reference.to_s)
         elsif @host_defaults[:prefix]
-          RDF::URI.new(@host_defaults[:prefix] + reference)
+          RDF::URI.intern(uri_mappings[@host_defaults[:prefix]] + reference.to_s)
         end
       elsif !curie.to_s.match(/:/)
         # No prefix, undefined (in this context, it is evaluated as a term elsewhere)
@@ -685,7 +696,7 @@ module RDF::RDFa
         # Prefixes always downcased
         ns = uri_mappings[prefix.to_s.downcase]
         if ns
-          RDF::URI.new(ns +reference)
+          RDF::URI.intern(ns + reference.to_s)
         else
           add_debug(element, "curie_to_resource_or_bnode No namespace mapping for #{prefix.downcase}")
           nil