rdf_context 0.5.8.2 → 0.5.9

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 0.5.9
+* Update to 2010-10-26 LC version of RDFa Core 1.1
+  * Deep processing of XMLLiterals
+  * Case sensitive Terms
+  * Updated processor graph vocabulary
+
 === 0.5.8.2
 * Don't create unnecessary namespaces when serializing RDF/XML.
 * Don't use regexp to substitute base URI in URI serialization.

data/VERSION

@@ -1 +1 @@
-0.5.8.2
+0.5.9

data/bin/rdf_context

@@ -8,10 +8,15 @@ class Parse
     puts "Parse: #{file.is_a?(StringIO) ? base_uri : file}" if $quiet
     graph_opts = {:identifier => base_uri}
     graph_opts[:store] = store if store
-    parser = Parser.new(:graph => Graph.new(graph_opts))
+    pg = RdfContext::Graph.new if $pg_format
+    parser = Parser.new(:graph => Graph.new(graph_opts), :processor_graph => pg)
     parser.parse(file.respond_to?(:read) ? file : File.open(file), base_uri, :strict => true)
     puts parser.graph.serialize(:format => $format.to_sym, :base => base_uri) unless $quiet
     puts parser.debug.to_a.join("\n\t") if $verbose
+    if pg
+      puts "\nProcessor Graph:\n"
+      puts pg.serialize(:format => $pg_format.to_sym) unless $quiet
+    end
   rescue RdfException => e
     puts "Parse failure: #{e.message}"
     puts parser.debug if $verbose && parser
@@ -29,12 +34,14 @@ raise "Mode must be one of 'parse'" unless mode == "parse"
 $verbose = false
 $quiet = false
 $format = "ttl"
+$pg_format = nil
 base_uri  = "http://example.com"
 store = :list_store
 opts = GetoptLong.new(
   ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--quiet", GetoptLong::NO_ARGUMENT],
   ["--debug", GetoptLong::NO_ARGUMENT],
+  ["--pg-format", GetoptLong::REQUIRED_ARGUMENT],
   ["--format", GetoptLong::REQUIRED_ARGUMENT],
   ["--store", GetoptLong::REQUIRED_ARGUMENT],
   ["--uri", GetoptLong::REQUIRED_ARGUMENT]
@@ -45,6 +52,7 @@ opts.each do |opt, arg|
   when '--quiet' then $quiet = true
   when '--debug' then ::RdfContext::debug = true
   when '--format' then $format = arg
+  when '--pg-format' then $pg_format = arg
   when '--uri' then base_uri = arg
   when '--store'
     case arg

data/lib/rdf_context.rb

@@ -64,6 +64,7 @@ module RdfContext
   DC_NS       = Namespace.new("http://purl.org/dc/terms/", "dc")
   OWL_NS      = Namespace.new("http://www.w3.org/2002/07/owl#", "owl")
   LOG_NS      = Namespace.new("http://www.w3.org/2000/10/swap/log#", "log")
+  PTR_NS      = Namespace.new("http://www.w3.org/2009/pointers#", "ptr")
   RDF_NS      = Namespace.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf")
   RDFA_NS     = Namespace.new("http://www.w3.org/ns/rdfa#", "rdfa")
   RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")

data/lib/rdf_context/literal.rb

@@ -240,6 +240,13 @@ module RdfContext
       end
 
       # Map namespaces from context to each top-level element found within node-set
+      #
+      # @param  [Object] contents
+      # @option options [Hash] :namespaces ({}) Use :__default__ or "" to declare default namespace
+      # @option options [String] :language (nil)
+      # @option options [Array<URIRef>] :profiles ([]) Profiles to add to elements
+      # @option options [Hash] :prefixes (nil) Prefixes to add to elements
+      # @option options [String] :default_vocabulary (nil) Default vocabulary to add to elements
       def encode_contents(contents, options)
         #puts "encode_contents: '#{contents}'"
         
@@ -260,14 +267,57 @@ module RdfContext
           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
+            #
+            # prefix mappings
+            # Look for @xmlns and @prefix mappings. Add any other mappings from options[:prefixes]
+            # that aren't already defined on this node
+            defined_mappings = {}
+            prefix_mappings = {}
+            
             c.traverse do |n|
               ns = n.namespace
               next unless ns
               prefix = ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns"
+              defined_mappings[ns.prefix.to_s] = ns.href.to_s
               c[prefix] = ns.href unless c.namespaces[prefix]
             end
             
-            # Add lanuage
+            mappings = c["prefix"].to_s.split(/\s+/)
+            while mappings.length > 0 do
+              prefix, uri = mappings.shift.downcase, mappings.shift
+              #puts "uri_mappings prefix #{prefix} <#{uri}>"
+              next unless prefix.match(/:$/)
+              prefix.chop!
+
+              # A Conforming RDFa Processor must ignore any definition of a mapping for the '_' prefix.
+              next if prefix == "_"
+
+              defined_mappings[prefix] = uri
+              prefix_mappings[prefix] = uri
+            end
+
+            # Add prefixes, being careful to honor mappings defined on the element
+            if options[:prefixes]
+              options[:prefixes].each_pair do |p, ns|
+                prefix_mappings[p] = ns.uri unless defined_mappings.has_key?(p)
+              end
+              if prefix_mappings.length
+                c["prefix"] = prefix_mappings.keys.sort.map {|p| "#{p}: #{prefix_mappings[p]}"}.join(" ")
+              end
+            end
+            
+            # Add profiles, being careful to honor profiles defined on the element
+            if options[:profiles].is_a?(Array) && options[:profiles].length > 0
+              profiles = c["profile"].to_s.split(" ")
+              profiles += options[:profiles]
+              c["profile"] = profiles.join(" ")
+            end
+            
+            # Add default vocabulary, being careful to honor any defined on the element
+            if options[:default_vocabulary] && !c["vocab"]
+              c["vocab"] = options[:default_vocabulary].to_s
+            end
+            
             if options[:language] && c["lang"].to_s.empty?
               c["xml:lang"] = options[:language]
             end

data/lib/rdf_context/parser.rb

@@ -161,18 +161,18 @@ module RdfContext
     # @param [XML Node, any] node:: XML Node or string for showing context
     # @param [String] message::
     def add_debug(node, message)
-      add_processor_message(node, message, RDFA_NS.InformationalMessage)
+      add_processor_message(node, message, RDFA_NS.Info)
     end
 
-    def add_info(node, message, process_class = RDFA_NS.InformationalMessage)
+    def add_info(node, message, process_class = RDFA_NS.Info)
       add_processor_message(node, message, process_class)
     end
     
-    def add_warning(node, message, process_class = RDFA_NS.MiscellaneousWarning)
+    def add_warning(node, message, process_class = RDFA_NS.Warning)
       add_processor_message(node, message, process_class)
     end
     
-    def add_error(node, message, process_class = RDFA_NS.MiscellaneousError)
+    def add_error(node, message, process_class = RDFA_NS.Error)
       add_processor_message(node, message, process_class)
       raise ParserException, message if @strict
     end
@@ -185,9 +185,13 @@ module RdfContext
         n = BNode.new
         @processor_graph << Triple.new(n, RDF_TYPE, process_class)
         @processor_graph << Triple.new(n, DC_NS.description, message)
-        @processor_graph << Triple.new(n, DC_NS.date, Literal.build_from(DateTime.now.to_date))
+        @processor_graph << Triple.new(n, DC_NS.date, Literal.build_from(DateTime.now))
         @processor_graph << Triple.new(n, RDFA_NS.sequence, Literal.build_from(@processor_sequence += 1))
-        @processor_graph << Triple.new(n, RDFA_NS.source, node_path(node))
+        @processor_graph << Triple.new(n, RDFA_NS.context, uri)
+        nc = BNode.new
+        @processor_graph << Triple.new(nc, RDF_TYPE, PTR_NS.XPathPointer)
+        @processor_graph << Triple.new(nc, PTR_NS.expression, node.path)
+        @processor_graph << Triple.new(n, RDFA_NS.context, nc)
       end
     end
     

data/lib/rdf_context/rdfaparser.rb

@@ -7,7 +7,7 @@ module RdfContext
   #
   # Based on processing rules described here:
   # @see http://www.w3.org/TR/rdfa-syntax/#s_model RDFa 1.0
-  # @see http://www.w3.org/2010/02/rdfa/drafts/2010/WD-rdfa-core-20100803/ RDFa 1.1
+  # @see http://www.w3.org/2010/02/rdfa/drafts/2010/WD-rdfa-core-20101026/ RDFa 1.1
   #
   # @author Ben Adida
   # @author Gregg Kellogg
@@ -67,6 +67,10 @@ 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}]
@@ -110,6 +114,7 @@ module RdfContext
         @base = base
         @parent_subject = @base
         @parent_object = nil
+        @profiles = []
         @uri_mappings = host_defaults.fetch(:uri_mappings, {})
         @incomplete_triples = []
         @language = nil
@@ -124,6 +129,7 @@ module RdfContext
           # clone the evaluation context correctly
           @uri_mappings = from.uri_mappings.clone
           @incomplete_triples = from.incomplete_triples.clone
+          @profiles = from.profiles.clone
       end
       
       def inspect
@@ -131,6 +137,7 @@ 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
@@ -180,8 +187,8 @@ module RdfContext
       else                               Nokogiri::XML.parse(stream, uri.to_s)
       end
       
-      add_error(nil, "Empty document", RDFA_NS.HostLanguageMarkupError) if @doc.nil?
-      add_warning(nil, "Synax errors:\n#{@doc.errors}", RDFA_NS.HostLanguageMarkupError) unless @doc.errors.empty?
+      add_error(nil, "Empty document", RDFA_NS.DocumentError) if @doc.nil?
+      add_warning(nil, "Synax errors:\n#{@doc.errors}", RDFA_NS.DocumentError) unless @doc.errors.empty?
       
       @callback = block
 
@@ -243,8 +250,8 @@ module RdfContext
     # Parse and process URI mappings, Term mappings and a default vocabulary from @profile
     #
     # Yields each mapping
-    def process_profile(element)
-      element.attributes['profile'].to_s.split(/\s/).reverse.each do |profile|
+    def process_profile(element, profiles)
+      profiles.reverse.each do |profile|
         # Don't try to open ourselves!
         if @uri == profile
           add_debug(element, "process_profile: skip recursive profile <#{profile}>")
@@ -321,7 +328,7 @@ module RdfContext
               # 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.to_s.downcase] = URIRef.intern(uri.to_s, :normalize => false) if term
+              tm[term.to_s] = URIRef.intern(uri.to_s, :normalize => false) if term
             end
           rescue Exception => e
             add_error(element, e.message, RDFA_NS.ProfileReferenceError)
@@ -363,7 +370,6 @@ module RdfContext
       # 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
@@ -418,13 +424,14 @@ module RdfContext
       content = attrs['content'].to_s if attrs['content']
       rel = attrs['rel'].to_s.strip if attrs['rel']
       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
 
       # 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.
       unless @version == :rdfa_1_0
         begin
-          process_profile(element) do |which, value|
+          process_profile(element, profiles) do |which, value|
             add_debug(element, "[Step 2] traverse, #{which}: #{value.inspect}")
             case which
             when :uri_mappings        then uri_mappings.merge!(value)
@@ -440,7 +447,10 @@ 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.
@@ -639,8 +649,20 @@ module RdfContext
           if datatype.to_s == XML_LITERAL.to_s
             # XML Literal
             add_debug(element, "[Step 11(1.1)] XML Literal: #{element.inner_html}")
-            recurse = false
-            Literal.typed(element.children, XML_LITERAL, :language => language, :namespaces => uri_mappings)
+            
+            # 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)
           else
             # plain literal
             add_debug(element, "[Step 11(1.1)] plain literal")
@@ -663,8 +685,6 @@ module RdfContext
         properties.each do |p|
           add_triple(element, new_subject, p, current_object_literal)
         end
-        # SPEC CONFUSION: "the triple has been created" ==> there may be more than one
-        # set the recurse flag above in the IF about xmlliteral, as it is the only place that can happen
       end
     
       if not skip and new_subject && !evaluation_context.incomplete_triples.empty?
@@ -686,6 +706,7 @@ module RdfContext
               uri_mappings == evaluation_context.uri_mappings &&
               term_mappings == evaluation_context.term_mappings &&
               default_vocabulary == evaluation_context.default_vocabulary &&
+              profiles == evaluation_context.profiles
             new_ec = evaluation_context
             add_debug(element, "[Step 13] skip: reused ec")
           else
@@ -694,6 +715,7 @@ module RdfContext
             new_ec.uri_mappings = uri_mappings
             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
@@ -706,6 +728,7 @@ module RdfContext
           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
       
@@ -758,11 +781,11 @@ module RdfContext
             # AbsURI does not use xml:base
             uri = URIRef.intern(value, restrictions.include?(:absuri) ? nil : evaluation_context.base, :normalize => false)
           rescue Addressable::URI::InvalidURIError => e
-            add_warning(element, "Malformed prefix #{value}", RDFA_NS.UndefinedPrefixError)
+            add_warning(element, "Malformed prefix #{value}", RDFA_NS.UnresolvedCURIE)
           rescue ParserException => e
             add_debug(element, e.message)
             if value.to_s =~ /^\(^\w\):/
-              add_warning(element, "Undefined prefix #{$1}", RDFA_NS.UndefinedPrefixError)
+              add_warning(element, "Undefined prefix #{$1}", RDFA_NS.UnresolvedCURIE)
             else
               add_warning(element, "Relative URI #{value}")
             end
@@ -780,16 +803,22 @@ module RdfContext
     # <em>options[:term_mappings]</em>:: Term mappings
     # <em>options[:vocab]</em>:: Default vocabulary
     def process_term(element, value, options)
-      case
-      when options[:term_mappings].is_a?(Hash) && options[:term_mappings].has_key?(value.to_s.downcase)
-        # If the term is in the local term mappings, use the associated URI.
-        options[:term_mappings][value.to_s.downcase]
-      when options[:vocab]
+      if options[:term_mappings].is_a?(Hash)
+        # If the term is in the local term mappings, use the associated URI (case sensitive).
+        return options[:term_mappings][value.to_s] if options[:term_mappings].has_key?(value.to_s)
+        
+        # Otherwise, check for case-insensitive match
+        options[:term_mappings].each_pair do |term, uri|
+          return uri if term.downcase == value.to_s.downcase
+        end
+      end
+      
+      if options[:vocab]
         # Otherwise, if there is a local default vocabulary the URI is obtained by concatenating that value and the term.
         URIRef.intern(options[:vocab].to_s + value)
       else
         # Finally, if there is no local default vocabulary, the term has no associated URI and must be ignored.
-        add_warning(element, "Term #{value} is not defined", RDFA_NS.UndefinedTermError)
+        add_warning(element, "Term #{value} is not defined", RDFA_NS.UnresolvedTerm)
         nil
       end
     end
@@ -812,7 +841,7 @@ module RdfContext
         elsif @host_defaults[:prefix]
           @host_defaults[:prefix].send("#{reference}_")
         else
-          #add_warning(element, "Default namespace prefix is not defined", RDFA_NS.UndefinedPrefixError)
+          #add_warning(element, "Default namespace prefix is not defined", RDFA_NS.UnresolvedCURIE)
           nil
         end
       elsif !curie.to_s.match(/:/)

data/script/tc

@@ -7,13 +7,21 @@ require 'getoptlong'
 
 def run_tc(tc)
   puts "run #{tc.name}"
-  graph = RdfContext::RdfaParser.parse(tc.input, tc.informationResourceInput, :strict => $strict, :version => tc.version)
+  puts tc.input if $verbose
+  pg = RdfContext::Graph.new if $pg_format
+  graph = RdfContext::RdfaParser.parse(tc.input, tc.informationResourceInput, :strict => $strict, :version => tc.version, :processor_graph => pg)
   puts graph.serialize(:format => $format.to_sym, :base => tc.informationResourceInput) unless $quiet
+  if pg
+    puts "\nProcessor Graph:\n"
+    puts pg.serialize(:format => $pg_format.to_sym) unless $quiet
+  end
 end
 
 $verbose = false
 $format = :ntriples
+$pg_format = nil
 $strict = false
+debug = false
 suite = "xhtml"
 opts = GetoptLong.new(
   ["--debug", GetoptLong::NO_ARGUMENT],
@@ -21,14 +29,16 @@ opts = GetoptLong.new(
   ["--quiet", GetoptLong::NO_ARGUMENT],
   ["--suite", GetoptLong::OPTIONAL_ARGUMENT],
   ["--strict", GetoptLong::NO_ARGUMENT],
-  ["--format", GetoptLong::REQUIRED_ARGUMENT]
+  ["--format", GetoptLong::REQUIRED_ARGUMENT],
+  ["--pg-format", GetoptLong::REQUIRED_ARGUMENT]
 )
 opts.each do |opt, arg|
   case opt
   when '--verbose' then $verbose = true
   when '--quiet' then $quiet = true
-  when '--debug' then ::RdfContext::debug = true
+  when '--debug' then debug = true
   when '--format' then $format = arg
+  when '--pg-format' then $pg_format = arg
   when '--suite' then suite = arg
   when '--strict' then $strict = true
   end
@@ -36,6 +46,8 @@ end
 
 test_cases = RdfaHelper::TestCase.test_cases(suite)
 
+::RdfContext::debug = debug
+
 puts test_cases.length
 
 test_cases = test_cases.detect do |tc|

data/spec/rdfa_helper.rb

@@ -237,7 +237,7 @@ module OpenURI
     when %r(http://rdfa.digitalbazaar.com/test-suite/test-cases/\w+)
       file = uri.to_s.sub(%r(http://rdfa.digitalbazaar.com/test-suite/test-cases/\w+),
         File.join(File.expand_path(File.dirname(__FILE__)), 'rdfa-test-suite', 'tests'))
-      puts "file: #{file}"
+      #puts "file: #{file}"
       File.open(file)
     when "http://www.w3.org/1999/xhtml/vocab"
       file = File.join(File.expand_path(File.dirname(__FILE__)), 'rdfa-test-suite', 'profile', "xhv")

data/spec/rdfa_parser_spec.rb

@@ -74,7 +74,7 @@ describe "RDFa parser" do
     xml = @parser.graph.to_rdfxml
 
     # Ensure that enclosed literal is also valid
-    xml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time")
+    xml.should include("E = mc")
   end
 
   it "should parse BNodes" do

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rdf_context
 version: !ruby/object:Gem::Version 
-  hash: 67
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 5
-  - 8
-  - 2
-  version: 0.5.8.2
+  - 9
+  version: 0.5.9
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -16,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-11 00:00:00 -07:00
+date: 2010-10-23 00:00:00 -07:00
 default_executable: rdf_context
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -138,7 +137,6 @@ extra_rdoc_files:
 files: 
 - .autotest
 - .gitignore
-- .yardoc
 - .yardopts
 - History.rdoc
 - README.rdoc