rdf_context 0.5.9.1 → 0.5.10

data/lib/rdf_context/n3_grammar.treetop

@@ -1,6 +1,6 @@
 #encoding: utf-8
 grammar N3Grammer
-  # Entry point to grammer
+  # Entry point to grammar
   rule document
     statements
   end
@@ -81,7 +81,7 @@ grammar N3Grammer
   end
   
   rule language
-    [a-z]+ ( "-" [a-z0-9]+ )*
+    [a-zA-Z]+ ( "-" [a-zA-Z0-9]+ )*
   end
 
   rule literal

data/lib/rdf_context/n3parser.rb

@@ -1,5 +1,4 @@
 require 'treetop'
-require File.join(File.dirname(__FILE__), 'parser')
 
 Treetop.load(File.join(File.dirname(__FILE__), "n3_grammar"))
 
@@ -270,7 +269,7 @@ module RdfContext
     
     def process_uri(uri)
       uri = uri.text_value if uri.respond_to?(:text_value)
-      URIRef.intern(uri, @uri, :normalize => false)
+      URIRef.intern(uri.to_s.rdf_unescape, @uri, :normalize => false)
     end
     
     def process_properties(properties)
@@ -338,15 +337,18 @@ module RdfContext
       end
 
       uri = if @graph.nsbinding[prefix]
-        @graph.nsbinding[prefix] + localname.to_s.rdf_unescape.rdf_escape
+        @graph.nsbinding[prefix] + localname.to_s
       elsif prefix == '_'
         BNode.new(localname, @named_bnodes)
       elsif prefix == "rdf"
         # A special case
-        RDF_NS + localname.to_s.rdf_unescape.rdf_escape
+        RDF_NS + localname.to_s
+      elsif prefix == "xsd"
+        # A special case
+        XSD_NS + localname.to_s
       else
         @default_ns ||= Namespace.new("#{@uri}#", "")
-        @default_ns + localname.to_s.rdf_unescape.rdf_escape
+        @default_ns + localname.to_s
       end
       add_debug(*expression.info("build_uri: #{uri.inspect}")) if expression.respond_to?(:info)
       uri

data/lib/rdf_context/parser.rb

@@ -1,5 +1,3 @@
-require File.join(File.dirname(__FILE__), 'graph')
-
 module RdfContext
   # Generic RdfContext Parser class
   class Parser
@@ -131,7 +129,7 @@ module RdfContext
       when /\.(nt|n3|txt)$/    then :n3
       else
         # Got to look into the file to see
-        if stream.is_a?(IO) || stream.is_a?(StringIO)
+        if stream.respond_to?(:read)
           stream.rewind
           string = stream.read(1000)
           stream.rewind
@@ -145,6 +143,7 @@ module RdfContext
         else                 :n3
         end
       end
+      format
     end
 
     protected

data/lib/rdf_context/quoted_graph.rb

@@ -1,5 +1,3 @@
-require File.join(File.dirname(__FILE__), "graph")
-
 module RdfContext
   # QuotedGraph - Supports N3 Formulae.
   #

data/lib/rdf_context/rdfaparser.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), 'parser')
+require File.join(File.dirname(__FILE__), "nokogiri_hacks")
 require 'open-uri'
 
 module RdfContext
@@ -67,14 +67,15 @@ module RdfContext
       #
       # @return URIRef
       attr :parent_object, true
-      # A list of current, in-scope profiles.
-      #
-      # @return [Array<URIRef>]
-      attr :profiles, true
       # A list of current, in-scope URI mappings.
       #
       # @return [Hash{String => Namespace}]
       attr :uri_mappings, true
+      # A list of current, in-scope Namespaces. This is the subset of uri_mappings
+      # which are defined using xmlns.
+      #
+      # @return [Hash{String => Namespace}]
+      attr :namespaces, true
       # A list of incomplete triples.
       #
       # A triple can be incomplete when no object resource
@@ -114,8 +115,8 @@ module RdfContext
         @base = base
         @parent_subject = @base
         @parent_object = nil
-        @profiles = []
         @uri_mappings = host_defaults.fetch(:uri_mappings, {})
+        @namespaces = {}
         @incomplete_triples = []
         @language = nil
         @term_mappings = host_defaults.fetch(:term_mappings, {})
@@ -129,7 +130,7 @@ module RdfContext
           # clone the evaluation context correctly
           @uri_mappings = from.uri_mappings.clone
           @incomplete_triples = from.incomplete_triples.clone
-          @profiles = from.profiles.clone
+          @namespaces = from.namespaces.clone
       end
       
       def inspect
@@ -137,7 +138,6 @@ module RdfContext
         v << "uri_mappings[#{uri_mappings.keys.length}]"
         v << "incomplete_triples[#{incomplete_triples.length}]"
         v << "term_mappings[#{term_mappings.keys.length}]"
-        v << "profiles[#{profiles.length}]"
         v.join(",")
       end
     end
@@ -193,7 +193,11 @@ module RdfContext
       @callback = block
 
       @version = options[:version] ? options[:version].to_sym : :rdfa_1_1
-      @host_language = options[:host_language] || :xhtml
+      @host_language = options[:host_language] || case @doc.root.name.downcase.to_sym
+      when :html  then :xhtml
+      when :svg   then :svg
+      else             :xhtml
+      end
 
       # Section 4.2 RDFa Host Language Conformance
       #
@@ -204,7 +208,7 @@ module RdfContext
       when :xhtml
         @graph.bind(XHV_NS)
         {
-          :vocabulary => XHV_NS.uri,
+          :vocabulary => nil,
           :prefix     => XHV_NS,
           :uri_mappings => {"xhv" => XHV_NS}, # RDF::XHTML is wrong
           :term_mappings => %w(
@@ -216,7 +220,6 @@ module RdfContext
         {}
       end
 
-      @host_defaults.delete(:vocabulary) if @version == :rdfa_1_0
       @profile_graph ||= options[:profile_graph] if options.has_key?(:profile_graph)
       
       add_debug(@doc.root, "version = #{@version.inspect},  host_language = #{@host_language}")
@@ -231,18 +234,21 @@ module RdfContext
     # Parsing an RDFa document (this is *not* the recursive method)
     def parse_whole_document(doc, base)
       # find if the document has a base element
-      # XXX - HTML specific
-      base_el = doc.css('html>head>base').first
-      if (base_el)
-        base = base_el.attributes['href']
+      case @host_language
+      when :xhtml
+        base_el = doc.at_css("html>head>base")
+        base = base_el.attribute("href").to_s.split("#").first if base_el
+      end
+      
+      if (base)
         # Strip any fragment from base
         base = base.to_s.split("#").first
-        @uri = URIRef.intern(base, :normalize => false, :normalize => false)
-        add_debug(base_el, "parse_whole_doc: base='#{base}'")
+        base = URIRef.intern(base, :normalize => false, :normalize => false)
+        add_debug("", "parse_whole_doc: base='#{base}'")
       end
 
       # initialize the evaluation context with the appropriate base
-      evaluation_context = EvaluationContext.new(@uri, @host_defaults)
+      evaluation_context = EvaluationContext.new(base, @host_defaults)
 
       traverse(doc.root, evaluation_context)
     end
@@ -277,9 +283,10 @@ module RdfContext
               
               ::RdfContext::debug, $verbose = false, false
               p_graph = Parser.parse(prof_body, profile, parse_options)
-              ttl = p_graph.serialize(:format => :ttl) if @debug || ::RdfContext::debug?
               ::RdfContext::debug, $verbose = old_debug, old_verbose
-              add_debug(element, ttl) if ttl
+              add_debug(element, "process_profile: extracted #{p_graph.size} statements")
+              #ttl = p_graph.serialize(:format => :ttl) if @debug || ::RdfContext::debug?
+              #add_debug(element, ttl) if ttl
             end
 
             add_debug(element, "process_profile: extract mappings from <#{profile}>")
@@ -343,7 +350,7 @@ module RdfContext
     end
 
     # Extract the XMLNS mappings from an element
-    def extract_mappings(element, uri_mappings)
+    def extract_mappings(element, uri_mappings, namespaces)
       # look for xmlns
       # (note, this may be dependent on @host_language)
       # Regardless of how the mapping is declared, the value to be mapped must be converted to lower case,
@@ -358,8 +365,12 @@ module RdfContext
           # Downcase prefix for RDFa 1.1
           pfx_lc = (@version == :rdfa_1_0 || ns.prefix.nil?) ? ns.prefix : ns.prefix.to_s.downcase
           if ns.prefix
-            uri_mappings[pfx_lc] = @graph.bind(Namespace.new(ns.href, ns.prefix.to_s))
+            namespace = Namespace.new(ns.href, ns.prefix.to_s)
+            uri_mappings[pfx_lc] = @graph.bind(namespace)
+            namespaces[pfx_lc] ||= ns.href.to_s
             add_debug(element, "extract_mappings: xmlns:#{ns.prefix} => <#{ns.href}>")
+          else
+            namespaces[""] ||= ns.href.to_s
           end
           
         rescue RdfException => e
@@ -401,6 +412,7 @@ module RdfContext
       new_subject = nil
       current_object_resource = nil
       uri_mappings = evaluation_context.uri_mappings.clone
+      namespaces = evaluation_context.namespaces.clone
       incomplete_triples = []
       language = evaluation_context.language
       term_mappings = evaluation_context.term_mappings.clone
@@ -416,6 +428,9 @@ module RdfContext
       resource = attrs['resource']
       href = attrs['href']
       vocab = attrs['vocab']
+      xml_base = element.attribute_with_ns("base", XML_NS.uri.to_s)
+      base = xml_base.to_s if xml_base && @host_language != :xhtml
+      base ||= evaluation_context.base
 
       # Pull out the attributes needed for the skip test.
       property = attrs['property'].to_s.strip if attrs['property']
@@ -426,6 +441,23 @@ module RdfContext
       rev = attrs['rev'].to_s.strip if attrs['rev']
       profiles = attrs['profile'].to_s.split(/\s/)  # In-scope profiles in order for passing to XMLLiteral
 
+      attrs = {
+        :about => about,
+        :src => src,
+        :resource => resource,
+        :href => href,
+        :vocab => vocab,
+        :base => xml_base,
+        :property => property,
+        :typeof => typeof,
+        :daetatype => datatype,
+        :rel => rel,
+        :rev => rev,
+        :profiles => (profiles.empty? ? nil : profiles),
+      }.select{|k,v| v}
+      
+      add_debug(element, "traverse " + attrs.map{|a| "#{a.first}: #{a.last}"}.join(", ")) unless attrs.empty?
+
       # Local term mappings [7.5 Steps 2]
       # Next the current element is parsed for any updates to the local term mappings and local list of URI mappings via @profile.
       # If @profile is present, its value is processed as defined in RDFa Profiles.
@@ -447,10 +479,7 @@ module RdfContext
           return
         end
       end
-
-      # Add on proviles from parent contexts to update new context
-      profiles += evaluation_context.profiles.clone
-
+    
       # Default vocabulary [7.5 Step 3]
       # Next the current element is examined for any change to the default vocabulary via @vocab.
       # If @vocab is present and contains a value, its value updates the local default vocabulary.
@@ -469,7 +498,7 @@ module RdfContext
       # Local term mappings [7.5 Steps 4]
       # Next, the current element is then examined for URI mapping s and these are added to the local list of URI mappings.
       # Note that a URI mapping will simply overwrite any current mapping in the list that has the same name
-      extract_mappings(element, uri_mappings)
+      extract_mappings(element, uri_mappings, namespaces)
     
       # Language information [7.5 Step 5]
       # From HTML5 [3.2.3.3]
@@ -485,39 +514,37 @@ module RdfContext
       else
         language
       end
-      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if attrs['lang']
+      add_debug(element, "HTML5 [3.2.3.3] traverse, lang: #{language}") if language
     
       # rels and revs
-      rels = process_uris(element, rel, evaluation_context,
+      rels = process_uris(element, rel, evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
                           :restrictions => TERMorCURIEorAbsURI[@version])
-      revs = process_uris(element, rev, evaluation_context,
+      revs = process_uris(element, rev, evaluation_context, base,
                           :uri_mappings => uri_mappings,
                           :term_mappings => term_mappings,
                           :vocab => default_vocabulary,
                           :restrictions => TERMorCURIEorAbsURI[@version])
     
-      add_debug(element, "traverse, about: #{about.nil? ? 'nil' : about}, src: #{src.nil? ? 'nil' : src}, resource: #{resource.nil? ? 'nil' : resource}, href: #{href.nil? ? 'nil' : href}")
-      add_debug(element, "traverse, property: #{property.nil? ? 'nil' : property}, typeof: #{typeof.nil? ? 'nil' : typeof}, datatype: #{datatype.nil? ? 'nil' : datatype}, content: #{content.nil? ? 'nil' : content}")
-      add_debug(element, "traverse, rels: #{rels.join(" ")}, revs: #{revs.join(" ")}")
+      add_debug(element, "traverse, rels: #{rels.join(" ")}, revs: #{revs.join(" ")}") unless (rels + revs).empty?
 
       if !(rel || rev)
         # Establishing a new subject if no rel/rev [7.5 Step 6]
         # May not be valid, but can exist
         new_subject = if about
-          process_uri(element, about, evaluation_context,
+          process_uri(element, about, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif src
-          process_uri(element, src, evaluation_context, :restrictions => [:uri])
+          process_uri(element, src, evaluation_context, base, :restrictions => [:uri])
         elsif resource
-          process_uri(element, resource, evaluation_context,
+          process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif href
-          process_uri(element, href, evaluation_context, :restrictions => [:uri])
+          process_uri(element, href, evaluation_context, base, :restrictions => [:uri])
         end
 
         # If no URI is provided by a resource attribute, then the first match from the following rules
@@ -526,11 +553,14 @@ module RdfContext
         # otherwise,
         #   if parent object is present, new subject is set to the value of parent object.
         # Additionally, if @property is not present then the skip element flag is set to 'true';
-        new_subject ||= if @host_language == :xhtml && element.name =~ /^(head|body)$/ && evaluation_context.base
+        new_subject ||= if @host_language == :xhtml && element.name =~ /^(head|body)$/ && base
           # 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.
-          evaluation_context.base
+          base
+        elsif @host_language != :xhtml && base
+          # XXX Spec confusion, assume that this is true
+          base
         elsif element.attributes['typeof']
           BNode.new
         else
@@ -543,10 +573,10 @@ module RdfContext
         # [7.5 Step 7]
         # If the current element does contain a @rel or @rev attribute, then the next step is to
         # establish both a value for new subject and a value for current object resource:
-        new_subject = process_uri(element, about, evaluation_context,
+        new_subject = process_uri(element, about, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => SafeCURIEorCURIEorURI[@version]) ||
-                      process_uri(element, src, evaluation_context,
+                      process_uri(element, src, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :restrictions => [:uri])
 
@@ -555,7 +585,7 @@ module RdfContext
           # 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.
-          evaluation_context.base
+          base
         elsif element.attributes['typeof']
           BNode.new
         else
@@ -566,11 +596,11 @@ module RdfContext
       
         # Then the current object resource is set to the URI obtained from the first match from the following rules:
         current_object_resource = if resource
-          process_uri(element, resource, evaluation_context,
+          process_uri(element, resource, evaluation_context, base,
                       :uri_mappings => uri_mappings,
                       :restrictions => SafeCURIEorCURIEorURI[@version])
         elsif href
-          process_uri(element, href, evaluation_context,
+          process_uri(element, href, evaluation_context, base,
                       :restrictions => [:uri])
         end
 
@@ -580,7 +610,7 @@ module RdfContext
       # Process @typeof if there is a subject [Step 8]
       if new_subject and typeof
         # Typeof is TERMorCURIEorAbsURIs
-        types = process_uris(element, typeof, evaluation_context,
+        types = process_uris(element, typeof, evaluation_context, base,
                             :uri_mappings => uri_mappings,
                             :term_mappings => term_mappings,
                             :vocab => default_vocabulary,
@@ -616,7 +646,7 @@ module RdfContext
     
       # Establish current object literal [Step 11]
       if property
-        properties = process_uris(element, property, evaluation_context,
+        properties = process_uris(element, property, evaluation_context, base,
                                   :uri_mappings => uri_mappings,
                                   :term_mappings => term_mappings,
                                   :vocab => default_vocabulary,
@@ -636,7 +666,7 @@ module RdfContext
         children_node_types = element.children.collect{|c| c.class}.uniq
       
         # the following 3 IF clauses should be mutually exclusive. Written as is to prevent extensive indentation.
-        datatype = process_uri(element, datatype, evaluation_context,
+        datatype = process_uri(element, datatype, evaluation_context, base,
                               :uri_mappings => uri_mappings,
                               :term_mappings => term_mappings,
                               :vocab => default_vocabulary,
@@ -651,18 +681,12 @@ module RdfContext
             add_debug(element, "[Step 11(1.1)] XML Literal: #{element.inner_html}")
             
             # In order to maintain maximum portability of this literal, any children of the current node that are
-            # elements must have the current in scope profiles, default vocabulary, prefix mappings, and XML
-            # namespace declarations (if any) declared on the serialized element using their respective attributes.
-            # Since the child element node could also declare new prefix mappings or XML namespaces, the RDFa
-            # Processor must be careful to merge these together when generating the serialized element definition.
-            # For avoidance of doubt, any re-declarations on the child node must take precedence over declarations
-            # that were active on the current node.
-            Literal.typed(element.children, XML_LITERAL,
-                          :language => language,
-                          :namespaces => uri_mappings,
-                          :profiles => profiles,
-                          :prefixes => uri_mappings,
-                          :default_vocabulary => default_vocabulary)
+            # elements must have the current in scope XML namespace declarations (if any) declared on the
+            # serialized element using their respective attributes. Since the child element node could also
+            # declare new XML namespaces, the RDFa Processor must be careful to merge these together when
+            # generating the serialized element definition. For avoidance of doubt, any re-declarations on the
+            # child node must take precedence over declarations that were active on the current node.
+            Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => namespaces)
           else
             # plain literal
             add_debug(element, "[Step 11(1.1)] plain literal")
@@ -677,7 +701,7 @@ module RdfContext
             # XML Literal
             add_debug(element, "[Step 11 (1.0)] XML Literal: #{element.inner_html}")
             recurse = false
-            Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => uri_mappings)
+            Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => namespaces)
           end
         end
       
@@ -706,29 +730,30 @@ module RdfContext
               uri_mappings == evaluation_context.uri_mappings &&
               term_mappings == evaluation_context.term_mappings &&
               default_vocabulary == evaluation_context.default_vocabulary &&
-              profiles == evaluation_context.profiles
+              base == evaluation_context.base
             new_ec = evaluation_context
             add_debug(element, "[Step 13] skip: reused ec")
           else
             new_ec = evaluation_context.clone
+            new_ec.base = base
             new_ec.language = language
             new_ec.uri_mappings = uri_mappings
+            new_ec.namespaces = namespaces
             new_ec.term_mappings = term_mappings
             new_ec.default_vocabulary = default_vocabulary
-            new_ec.profiles = profiles
             add_debug(element, "[Step 13] skip: cloned ec")
           end
         else
           # create a new evaluation context
-          new_ec = EvaluationContext.new(evaluation_context.base, @host_defaults)
+          new_ec = EvaluationContext.new(base, @host_defaults)
           new_ec.parent_subject = new_subject || evaluation_context.parent_subject
           new_ec.parent_object = current_object_resource || new_subject || evaluation_context.parent_subject
           new_ec.uri_mappings = uri_mappings
+          new_ec.namespaces = namespaces
           new_ec.incomplete_triples = incomplete_triples
           new_ec.language = language
           new_ec.term_mappings = term_mappings
           new_ec.default_vocabulary = default_vocabulary
-          new_ec.profiles = profiles
           add_debug(element, "[Step 13] new ec")
         end
       
@@ -740,13 +765,13 @@ module RdfContext
     end
 
     # space-separated TERMorCURIEorAbsURI or SafeCURIEorCURIEorURI
-    def process_uris(element, value, evaluation_context, options)
+    def process_uris(element, value, evaluation_context, base, options)
       return [] if value.to_s.empty?
       add_debug(element, "process_uris: #{value}")
-      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, options)}.compact
+      value.to_s.split(/\s+/).map {|v| process_uri(element, v, evaluation_context, base, options)}.compact
     end
 
-    def process_uri(element, value, evaluation_context, options = {})
+    def process_uri(element, value, evaluation_context, base, options = {})
       return if value.nil?
       restrictions = options[:restrictions]
       add_debug(element, "process_uri: #{value}, restrictions = #{restrictions.inspect}")
@@ -779,7 +804,7 @@ module RdfContext
         elsif restrictions.include?(:absuri) || restrictions.include?(:uri)
           begin
             # AbsURI does not use xml:base
-            uri = URIRef.intern(value, restrictions.include?(:absuri) ? nil : evaluation_context.base, :normalize => false)
+            uri = URIRef.intern(value, restrictions.include?(:absuri) ? nil : base, :normalize => false)
           rescue Addressable::URI::InvalidURIError => e
             add_warning(element, "Malformed prefix #{value}", RDFA_NS.UnresolvedCURIE)
           rescue ParserException => e