rdf_context 0.5.8.1 → 0.5.8.2

data/History.rdoc

@@ -1,4 +1,15 @@
-=== 0.5.8.1
+=== 0.5.8.2
+* Don't create unnecessary namespaces when serializing RDF/XML.
+* Don't use regexp to substitute base URI in URI serialization.
+* Added :profile_graph option to RdfaParser#parse. This MUST be a ConjunctiveGraph and will be used to save profiles that are encountered.
+  * Fixme, for now, retrieval should include HTTP headers and perform appropriate HTTP cache control and check for potential updates.
+* Added ConjunctiveGraph#add_quad. Adds a quad from the intended subject, predicate, object, and context.
+    @example
+     g = Graph.new
+     cg = ConjunctiveGraph.new
+     cg.add_quad(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new, g)
+     => results in the triple being added to g
+
 === 0.5.8
 * Remove dependency on whatlanguage.
 * Added support for Processor Graphs.

data/Rakefile

@@ -69,22 +69,24 @@ task :spec => :check_dependencies
 
 task :default => :spec
 
-require 'rake/rdoctask'
-Rake::RDocTask.new("doc:rdoc") do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = RdfContext::VERSION
-  end
+namespace :doc do
+  require 'rake/rdoctask'
+  Rake::RDocTask.new("rdoc") do |rdoc|
+    if File.exist?('VERSION')
+      version = File.read('VERSION')
+    else
+      version = RdfContext::VERSION
+    end
 
-  rdoc.rdoc_dir = 'doc/rdoc'
-  rdoc.title = "rdf_context #{version}"
-  rdoc.rdoc_files.include('README*', "History.rdoc")
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+    rdoc.rdoc_dir = 'doc/rdoc'
+    rdoc.title = "rdf_context #{version}"
+    rdoc.rdoc_files.include('README*', "History.rdoc")
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
 
-YARD::Rake::YardocTask.new do |t|
-  t.files   = %w(lib/**/*.rb README.rdoc History.rdoc)   # optional
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = %w(lib/**/*.rb README.rdoc History.rdoc)   # optional
+  end
 end
 
 desc "Generate RDF Core Manifest.yml"

data/VERSION

@@ -1 +1 @@
-0.5.8.1
+0.5.8.2

data/bin/rdf_context

@@ -15,7 +15,7 @@ class Parse
   rescue RdfException => e
     puts "Parse failure: #{e.message}"
     puts parser.debug if $verbose && parser
-    #raise
+    raise if RdfContext.debug?
   rescue Exception => e
     puts "Parser fault: #{e.message}"
     puts parser.debug if parser && !$quiet

data/lib/rdf_context/conjunctive_graph.rb

@@ -42,6 +42,28 @@ module RdfContext
       @store.triples(triple, nil, &block) || []
     end
 
+    # Adds a quad from the intended subject, predicate, object, and context.
+    #
+    # @example
+    #   g = Graph.new
+    #   cg = ConjunctiveGraph.new
+    #   cg.add_quad(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new, g)
+    #   # => results in the triple being added to g
+    #
+    # @param [URIRef, BNode] subject the subject of the triple
+    # @param [URIRef] predicate the predicate of the triple
+    # @param [URIRef, BNode, Literal] object the object of the triple
+    # @param [Graph, URIRef] context Graph or URIRef of graph context
+    # @return [Graph] Returns the graph
+    # @raise [Error] Checks parameter types and raises if they are incorrect.
+    def add_quad(subject, predicate, object, context)
+      graph = context if context.is_a?(Graph)
+      graph ||= contexts.detect {|g| g.identifier == context}
+      graph ||= Graph.new(:identifier => context, :store => @store)
+      graph.add_triple(subject, predicate, object)
+      graph
+    end
+
     # Parse source into a new context.
     #
     # Create a new context (Graph) and parse into that.

data/lib/rdf_context/graph.rb

@@ -214,7 +214,9 @@ module RdfContext
     # Adds a triple to a graph directly from the intended subject, predicate, and object.
     #
     # @example
-    #   g = Graph.new; g.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new) # => results in the triple being added to g; returns an array of g's triples
+    #   g = Graph.new
+    #   g.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    #   # => results in the triple being added to g
     #
     # @param [URIRef, BNode] subject the subject of the triple
     # @param [URIRef] predicate the predicate of the triple

data/lib/rdf_context/n3parser.rb

@@ -15,6 +15,7 @@ module RdfContext
     #
     # @param [String] n3_str:: the Notation3/Turtle string
     # @param [String] uri:: the URI of the document
+    # @option options [Graph] :graph (Graph.new) Graph to parse into, otherwise a new Graph instance is created
     # @option options [Array] :debug (nil) Array to place debug messages
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     # @return [Graph]

data/lib/rdf_context/parser.rb

@@ -17,20 +17,18 @@ module RdfContext
     # @return [RdfContext::Graph]
     attr_accessor :graph
     
-    # Graph instance containing informationa, warning and error statements
+    # Graph instance containing informational, warning and error statements
     # @return [RdfContext::Graph]
     attr_accessor :processor_graph
     
     ## 
     # Creates a new parser
     #
-    # @option options [Graph] :graph (nil) Graph to parse into, otherwise a new RdfContext::Graph instance is created
     # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
     # @option options [:rdfxml, :html, :n3] :type (nil)
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     def initialize(options = {})
       # initialize the triplestore
-      @graph = options[:graph]
       @processor_graph = options[:processor_graph] if options[:processor_graph]
       @debug = options[:debug] # XXX deprecated
       @strict = options[:strict]
@@ -41,6 +39,7 @@ module RdfContext
     #
     # @param  [#read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
     # @param [String] uri (nil) the URI of the document
+    # @option options [Graph] :graph (Graph.new) Graph to parse into, otherwise a new Graph instance is created
     # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
     # @option options [:rdfxml, :html, :n3] :type (nil)
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
@@ -64,6 +63,7 @@ module RdfContext
     #
     # @param  [#read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
     # @param [String] uri (nil) the URI of the document
+    # @option options [Graph] :graph (Graph.new) Graph to parse into, otherwise a new Graph instance is created
     # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
     # @option options [:rdfxml, :html, :n3] :type (nil)
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
@@ -74,22 +74,21 @@ module RdfContext
     # @return [Graph]:: Returns the graph containing parsed triples
     # @raise [Error]:: Raises RdfError if _strict_
     def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      @graph = options[:graph] || Graph.new(:identifier => @uri)
       if self.class == Parser
         
         options[:strict] ||= @strict if @strict
-        options[:graph] ||= @graph if @graph
+        options[:graph] ||= @graph
         options[:debug] ||= @debug if @debug  # XXX deprecated
-        @processor_graph = options[:processor_graph] if options[:processor_graph]
         # Intuit type, if not provided
         options[:type] ||= detect_format(stream, uri)
         
         # Create a delegate of a specific parser class
         @delegate ||= case options[:type].to_s
         when "n3", "ntriples", "turtle", "ttl", "n3", "notation3" then N3Parser.new(options)
-        when "rdfa", "html", "xhtml"                        then RdfaParser.new(options)
-        when "xml", "rdf", "rdfxml"                         then RdfXmlParser.new(options)
-        else
-          RdfXmlParser.new(options)
+        when "rdfa", "html", "xhtml"                              then RdfaParser.new(options)
+        when "xml", "rdf", "rdfxml"                               then RdfXmlParser.new(options)
+        else                                                           RdfXmlParser.new(options)
           # raise ParserException.new("type option must be one of :rdfxml, :html, or :n3")
         end
         @delegate.parse(stream, uri, options, &block)
@@ -98,8 +97,6 @@ module RdfContext
         @uri = URIRef.new(uri.to_s) unless uri.nil?
         @strict = options[:strict] if options.has_key?(:strict)
         @debug = options[:debug] if options.has_key?(:debug)
-        
-        @graph ||= Graph.new(:identifier => @uri)
       end
     end
     

data/lib/rdf_context/rdfaparser.rb

@@ -33,6 +33,10 @@ module RdfContext
     # @return [:rdfa_1_0, :rdfa_1_1]
     attr_reader :version
     
+    # Graph instance containing parsed profiles
+    # @return [RdfContext::Graph]
+    attr_accessor :profile_graph
+    
     # The Recursive Baggage
     # @private
     class EvaluationContext # :nodoc:
@@ -136,11 +140,13 @@ module RdfContext
     #
     # @option options [Graph] :graph (nil) Graph to parse into, otherwise a new RdfContext::Graph instance is created
     # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
+    # @option options [Graph] :profile_graph (nil) Graph to save profile graphs.
     # @option options [Array] :debug (nil) Array to place debug messages
     # @option options [:rdfxml, :html, :n3] :type (nil)
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     def initialize(options = {})
       super
+      @profile_graph = options[:profile_graph]
       @@vocabulary_cache ||= {}
     end
     
@@ -154,6 +160,9 @@ module RdfContext
     #
     # @param  [Nokogiri::HTML::Document, Nokogiri::XML::Document, #read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
     # @param [String] uri (nil) the URI of the document
+    # @option options [Graph] :graph (Graph.new) Graph to parse into, otherwise a new Graph
+    # @option options [Graph] :processor_graph (nil) Graph to record information, warnings and errors.
+    # @option options [ConjunctiveGraph] :profile_graph (nil) Graph to save profile graphs.
     # @option options [Array] :debug (nil) Array to place debug messages
     # @option options [:rdfa_1_0, :rdfa_1_1] :version (:rdfa_1_1) Parser version information
     # @option options [:xhtml] :host_language (:xhtml) Host Language
@@ -167,8 +176,8 @@ module RdfContext
 
       @doc = case stream
       when Nokogiri::HTML::Document then stream
-      when Nokogiri::XML::Document then stream
-      else   Nokogiri::XML.parse(stream, uri.to_s)
+      when Nokogiri::XML::Document  then stream
+      else                               Nokogiri::XML.parse(stream, uri.to_s)
       end
       
       add_error(nil, "Empty document", RDFA_NS.HostLanguageMarkupError) if @doc.nil?
@@ -201,6 +210,7 @@ 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}")
       # parse
@@ -242,6 +252,30 @@ module RdfContext
           add_debug(element, "process_profile: skip previously parsed profile <#{profile}>")
         else
           begin
+            p_graph = @profile_graph.contexts.detect {|g| g.identifier == profile} if @profile_graph
+            unless p_graph
+              add_debug(element, "process_profile: retrieve profile <#{profile}>")
+              # Fixme: Should using HTTP cache and conditional gets to make sure resource is up-to-date
+              prof_body = OpenURI.open_uri(profile)
+              raise ParserException, "Empty profile #{profile}" if prof_body.to_s.empty?
+      
+              # Parse profile, and extract mappings from graph
+              add_debug(element, "process_profile: parse profile <#{profile}>")
+              old_debug, old_verbose, = ::RdfContext::debug?, $verbose
+              parse_options = {}
+              if @profile_graph
+                parse_options[:profile_graph] = @profile_graph
+                parse_options[:graph] = Graph.new(:identifier => profile, :store => @profile_graph.store)
+              end
+              
+              ::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
+            end
+
+            add_debug(element, "process_profile: extract mappings from <#{profile}>")
             @@vocabulary_cache[profile] = {
               :uri_mappings => {},
               :term_mappings => {},
@@ -249,17 +283,6 @@ module RdfContext
             }
             um = @@vocabulary_cache[profile][:uri_mappings]
             tm = @@vocabulary_cache[profile][:term_mappings]
-            add_debug(element, "process_profile: parse profile <#{profile}>")
-            prof_body = OpenURI.open_uri(profile)
-            raise ParserException, "Empty profile #{profile}" if prof_body.to_s.empty?
-      
-            # Parse profile, and extract mappings from graph
-            old_debug, old_verbose, = ::RdfContext::debug?, $verbose
-            ::RdfContext::debug, $verbose = false, false
-            p_graph = Parser.parse(prof_body, profile)
-            ttl = p_graph.serialize(:format => :ttl) if @debug || ::RdfContext::debug?
-            ::RdfContext::debug, $verbose = old_debug, old_verbose
-            add_debug(element, ttl) if ttl
             p_graph.subjects.each do |subject|
               props = p_graph.properties(subject)
               #puts props.inspect

data/lib/rdf_context/rdfxmlparser.rb

@@ -36,7 +36,6 @@ module RdfContext
 
       # @param [String] base Base URI for creating absolute URIs from relative URIs
       # @param [Nokogiri::XML::Element] element XML Element context
-      # @param [Graph] graph Graph for binding Namespaces
       # @return [RdfXmlParser::EvaluationContext]
       def initialize(base, element, graph)
         # Initialize the evaluation context, [5.1]
@@ -141,6 +140,7 @@ module RdfContext
     # 
     # @param  [Nokogiri::XML::Document, #read, #to_s] stream the HTML+RDFa IO stream, string, Nokogiri::HTML::Document or Nokogiri::XML::Document
     # @param [String] uri (nil) the URI of the document
+    # @option options [Graph] :graph (Graph.new) Graph to parse into, otherwise a new Graph
     # @option options [Array] :debug (nil) Array to place debug messages
     # @option options [Boolean] :strict (false) Raise Error if true, continue with lax parsing, otherwise
     # @return [Graph] Returns the graph containing parsed triples

data/lib/rdf_context/serializer/abstract_serializer.rb

@@ -30,7 +30,7 @@ module RdfContext
     # @return [String]
     def relativize(uri)
       uri = uri.to_s
-      self.base ? uri.sub(/^#{self.base}/, "") : uri
+      self.base ? uri.sub(self.base, "") : uri
     end
   end
 end

data/lib/rdf_context/serializer/turtle_serializer.rb

@@ -43,8 +43,8 @@ module RdfContext
     
     def get_qname(uri)
       if uri.is_a?(URIRef)
-        md = uri.to_s.match(/^#{@base}(.*)$/) if @base
-        return "<#{md[1]}>" if md
+        md = relativize(uri)
+        return "<#{md}>" unless md == uri.to_s
         
         super(uri)
       end

data/lib/rdf_context/serializer/xml_serializer.rb

@@ -39,10 +39,9 @@ module RdfContext
       preprocess
 
       predicates = @graph.predicates.uniq
-      possible = predicates + @graph.objects.uniq
       namespaces = {}
       required_namespaces = {}
-      possible.each do |res|
+      predicates.each do |res|
         next unless res.is_a?(URIRef)
         if res.namespace
           add_namespace(res.namespace)

data/spec/rdfa_parser_spec.rb

@@ -77,7 +77,6 @@ describe "RDFa parser" do
     xml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\">2</sup>: The Most Urgent Problem of Our Time")
   end
 
-
   it "should parse BNodes" do
     sampledoc = <<-EOF
     <?xml version="1.0" encoding="UTF-8"?>
@@ -108,6 +107,113 @@ describe "RDFa parser" do
     xml.should include("Manu Sporny")
   end
   
+  describe :profiles do
+    before(:all) do
+      @prof = %(<?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE html>
+      <html xmlns="http://www.w3.org/1999/xhtml">
+        <head>
+          <title>Test mappings</title>
+        </head>
+        <body prefix="rdfa: http://www.w3.org/ns/rdfa#">
+          <p typeof=""><span property="rdfa:uri">#{DC_NS.uri}</span><span property="rdfa:prefix">dc</span></p>
+          <p typeof=""><span property="rdfa:uri">#{DC_NS.title}</span><span property="rdfa:term">title</span></p>
+        </body>
+      </html>
+      )
+      @doc = %(<?xml version="1.0" encoding="UTF-8"?>
+      <!DOCTYPE html>
+      <html xmlns="http://www.w3.org/1999/xhtml">
+        <body profile="http://example.com/profile">
+          <div about ="http://example.com/doc" typeof="dc:Agent">
+            <p property="title">A particular agent</p>
+          </div>
+        </body>
+      </html>
+      )
+    end
+
+    before(:each) do
+      @profile_graph = ConjunctiveGraph.new(:store => MemoryStore.new)
+      @parser = RdfaParser.new(:profile_graph => @profile_graph)
+      OpenURI.stub!(:open_uri).with("http://example.com/profile").and_return(@prof)
+    end
+    
+    describe "new profile" do
+      before(:each) do
+        # Clear vocabulary cache
+        #RdfContext.debug = true
+        RdfaParser.send(:class_variable_set, :@@vocabulary_cache, {})
+        @parser.parse(@doc, "http://example.com/doc")
+        #RdfContext.debug = false
+      end
+      
+      describe "profile graph" do
+        it "should have context http://example.com/profile" do
+          @profile_graph.contexts.map(&:identifier).should include("http://example.com/profile")
+        end
+      end
+      
+      describe "processed graph" do
+        it "should have type dc:Agent" do
+          @parser.graph.should be_contains(Triple.new("http://example.com/doc", RDF_TYPE, DC_NS.Agent))
+        end
+      
+        it "should have property dc:title" do
+          @parser.graph.should be_contains(Triple.new("http://example.com/doc", DC_NS.title, nil))
+        end
+      end
+    end
+    
+    describe "cached profile" do
+      before(:each) do
+        # Clear vocabulary cache
+        RdfaParser.send(:class_variable_set, :@@vocabulary_cache, {})
+        @parser.parse(@doc, "http://example.com/doc")
+      end
+      
+      it "should not re-parse profile" do
+        RdfaParser.send(:class_variable_set, :@@vocabulary_cache, {})
+        Parser.should_not_receive(:parse).with(@prof, "http://example.com/profile", :profile_graph => @parser.profile_graph).and_return(@prof_graph)
+        RdfaParser.new.parse(@doc, "http://example.com/doc")
+      end
+      
+      it "should create vocab_cache" do
+        RdfaParser.send(:class_variable_get, :@@vocabulary_cache).should be_a(Hash)
+      end
+      
+    end
+    
+    describe "profile content" do
+      before(:each) do
+        @prof_graph = Graph.new
+        bn_p = BNode.new("prefix")
+        bn_t = BNode.new("term")
+        @prof_graph.add(
+          Triple.new(bn_p, RDFA_NS.prefix_, "dc"),
+          Triple.new(bn_p, RDFA_NS.uri_, Literal.untyped(DC_NS.uri.to_s)),
+          Triple.new(bn_t, RDFA_NS.term_, "title"),
+          Triple.new(bn_t, RDFA_NS.uri_, Literal.untyped(DC_NS.title.to_s))
+        )
+        Parser.should_receive(:parse).with(@prof, "http://example.com/profile", :profile_graph => @profile_graph, :graph => instance_of(Graph)).and_return(@prof_graph)
+        
+        # Clear vocabulary cache
+        RdfaParser.send(:class_variable_set, :@@vocabulary_cache, {})
+        #RdfContext.debug = true
+        @parser.parse(@doc, "http://example.com/doc")
+        #RdfContext.debug = false
+      end
+      
+      it "should have type dc:Agent" do
+        @parser.graph.should be_contains(Triple.new("http://example.com/doc", RDF_TYPE, DC_NS.Agent))
+      end
+      
+      it "should have property dc:title" do
+        @parser.graph.should be_contains(Triple.new("http://example.com/doc", DC_NS.title, nil))
+      end
+    end
+  end
+  
   def self.test_cases(suite)
     RdfaHelper::TestCase.test_cases(suite)
   end

data/spec/xml_serializer_spec.rb

@@ -357,7 +357,7 @@ describe "XML Serializer" do
     doc.should be_a(Nokogiri::XML::Document)
     paths.each_pair do |path, value|
       puts "xpath: #{path.inspect}" if ::RdfContext::debug?
-      puts doc.root.at_xpath(path, @namespaces).inspect if ::RdfContext::debug?
+      puts doc.root.at_xpath(path, doc.namespaces).inspect if ::RdfContext::debug?
       case value
       when false
         doc.root.at_xpath(path, doc.namespaces).should be_nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rdf_context
 version: !ruby/object:Gem::Version 
-  hash: 69
+  hash: 67
   prerelease: false
   segments: 
   - 0
   - 5
   - 8
-  - 1
-  version: 0.5.8.1
+  - 2
+  version: 0.5.8.2
 platform: ruby
 authors: 
 - Gregg Kellogg
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 -07:00
+date: 2010-09-11 00:00:00 -07:00
 default_executable: rdf_context
 dependencies: 
 - !ruby/object:Gem::Dependency