rdf_context 0.4.8 → 0.5.0

data/lib/rdf_context/triple.rb

@@ -12,8 +12,8 @@ module RdfContext
     ##
     # Creates a new triple directly from the intended subject, predicate, and object.
     #
-    # Any or all of _subject_, _predicate_ or _object_ may be nil, to create a triple patern.
-    # A patern may not be added to a graph.
+    # Any or all of _subject_, _predicate_ or _object_ may be nil, to create a triple pattern.
+    # A pattern may not be added to a graph.
     #
     # ==== Example
     #   Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new) # => results in the creation of a new triple and returns it
@@ -21,24 +21,24 @@ module RdfContext
     # @param [URIRef, BNode] subject:: the subject of the triple
     # @param [URIRef] predicate:: the predicate of the triple
     # @param [URIRef, BNode, Literal, TypedLiteral] object:: the object of the triple
-    # @return [Triple]:: An array of the triples (leaky abstraction? consider returning the graph instead)
+    # @return [Triple]:: Generated triple
     # @raise [Error]:: Checks parameter types and raises if they are incorrect.
     #
     # @author Tom Morris
     def initialize (subject, predicate, object)
-      @subject   = self.class.coerce_subject(subject)
+      @subject   = self.class.coerce_node(subject)
       @predicate = self.class.coerce_predicate(predicate)
-      @object    = self.class.coerce_object(object)
-      @patern = subject.nil? || predicate.nil? || object.nil?
+      @object    = self.class.coerce_node(object)
+      @pattern = subject.nil? || predicate.nil? || object.nil?
     end
 
-    def is_patern?
-      @patern
+    def is_pattern?
+      @pattern
     end
     
     # Serialize Triple to N3
     def to_n3
-      raise RdfException.new("Can't serialize patern triple") if is_patern?
+      raise RdfException.new("Can't serialize pattern triple '#{@subject.inspect}, #{@predicate.inspect}, #{@object.inspect}'") if is_pattern?
       @subject.to_ntriples + " " + @predicate.to_ntriples + " " + @object.to_ntriples + " ."
     end
     alias_method :to_ntriples, :to_n3
@@ -55,7 +55,7 @@ module RdfContext
     end
 
     # Two triples are equal if their of their subjects, predicates and objects are equal.
-    # Or self or other is a patern and subject, predicate, object matches
+    # Or self or other is a pattern and subject, predicate, object matches
     def eql? (other)
       other.is_a?(Triple) &&
       (other.subject == self.subject || other.subject.nil? || self.subject.nil?) &&
@@ -67,13 +67,19 @@ module RdfContext
 
     # Clone triple, keeping references to literals and URIRefs, but cloning BNodes
     def clone
-      raise RdfException.new("Can't clone patern triple") if is_patern?
+      raise RdfException.new("Can't clone pattern triple") if is_pattern?
       s = subject.is_a?(BNode) ? subject.clone : subject
       p = predicate.is_a?(BNode) ? predicate.clone : predicate
       o = object.is_a?(BNode) ? object.clone : object
       Triple.new(subject, predicate, object)
     end
     
+    # Validate that this triple is legal RDF, not extended for Notation-3
+    def validate_rdf
+      raise InvalidNode, "Triple has illegal RDF subject #{subject.inspect}" unless subject.is_a?(URIRef) || subject.is_a?(BNode)
+      raise InvalidPredicate, "Triple has illegal RDF predicate #{predicate.inspect}" unless predicate.is_a?(URIRef)
+    end
+    
     # For indexes
     def hash
       [subject, predicate, object].hash
@@ -81,25 +87,6 @@ module RdfContext
     
     protected
 
-    # Coerce a subject to the appropriate RdfContext type.
-    # 
-    # @param[URI, URIRef, String] subject:: If a String looks like a URI, a URI is created, otherwise a BNode.
-    # @raise[InvalidSubject]:: If subject can't be intuited.
-    def self.coerce_subject(subject)
-      case subject
-      when Addressable::URI
-        URIRef.new(subject.to_s)
-      when URIRef, BNode
-        subject
-      when nil
-        subject
-      when /^\w+:\/\/\S+/, /^file:\S+/ # does it smell like a URI?
-        URIRef.new(subject)
-      else
-        raise InvalidSubject, "Subject is not of a known class (#{subject.class}: #{subject.inspect})"
-      end
-    end
-
     # Coerce a predicate to the appropriate RdfContext type.
     # 
     # @param[URI, URIRef, String] predicate:: If a String looks like a URI, a URI is created
@@ -108,7 +95,7 @@ module RdfContext
       case predicate
       when Addressable::URI
         URIRef.new(predicate.to_s)
-      when URIRef
+      when URIRef, BNode
         predicate
       when String
         URIRef.new predicate
@@ -118,31 +105,29 @@ module RdfContext
         raise InvalidPredicate, "Predicate should be a URI"
       end
     rescue ParserException => e
-      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
+      raise InvalidPredicate, "#{predicate.class}: #{predicate.inspect} is not a valid predicate"
     end
 
-    # Coerce a object to the appropriate RdfContext type.
+    # Coerce a node (subject or object) to the appropriate RdfContext type.
     # 
     # @param[URI, URIRef, String, Integer, Float, BNode, Literal] object:: If a String looks like a URI, a URI is created, otherwise an untyped Literal.
-    # @raise[InvalidObject]:: If object can't be predicate.
-    def self.coerce_object(object)
-      case object
+    # @raise[InvalidNode]:: If node can't be predicate.
+    def self.coerce_node(node)
+      case node
       when Addressable::URI
-        URIRef.new(object.to_s)
+        URIRef.new(node.to_s)
       when String
-        if object.to_s =~ /^\w+:\/\/\S+/ # does it smell like a URI?
-          URIRef.new(object.to_s)
+        if node.to_s =~ /^\w+:\/\/\S+/ # does it smell like a URI?
+          URIRef.new(node.to_s)
         else
-          Literal.untyped(object)
+          Literal.untyped(node)
         end
-      when Integer, Float, Date
-        Literal.build_from(object)
-      when URIRef, BNode, Literal
-        object
-      when nil
-        object
+      when Numeric, Date, Duration, Time, DateTime
+        Literal.build_from(node)
+      when URIRef, BNode, Literal, Graph, nil
+        node
       else
-        raise InvalidObject, "#{object.class}: #{object.inspect} is not a valid object"
+        raise InvalidNode, "#{node.class}: #{node.inspect} is not a valid node"
       end
     end
   end

data/lib/rdf_context/uriref.rb

@@ -11,24 +11,31 @@ module RdfContext
     #   u = URIRef.new("http://example.com")
     #   u = URIRef.new("foo", u) => "http://example.com/foo"
     # 
+    # Last argument may be an options hash to set:
+    # @options[:normalize]:: Normalize URI when transforming to string, defaults to true
+    # @options[:namespace]:: Namespace used to create this URI, useful for to_qname
     def initialize (*args)
+      options = args.last.is_a?(Hash) ? args.pop : { :normalize => true }
+      @normalize = options[:normalize]
+      @namespace = options[:namespace]
+
       args.each {|s| test_string(s)}
       if args.size == 1
-        @uri = Addressable::URI.parse(args[0].to_s)
+        uri = Addressable::URI.parse(args[0].to_s)
       else
-        @uri = Addressable::URI.join(*args.map{|s| s.to_s}.reverse)
-      end
-      if @uri.relative?
-        raise ParserException, "<" + @uri.to_s + "> is a relative URI"
+        uri = Addressable::URI.join(*args.map{|s| s.to_s}.reverse)
       end
-      if !@uri.to_s.match(/^javascript/).nil?
-        raise ParserException, "Javascript pseudo-URIs are not acceptable"
-      end
-      
+
+      raise ParserException, "<" + uri.to_s + "> is a relative URI" if uri.relative?
+
       # Unique URI through class hash to ensure that URIRefs can be easily compared
       @@uri_hash ||= {}
-      @@uri_hash[@uri.to_s] ||= @uri.freeze
-      @uri = @@uri_hash[@uri.to_s]
+      @uri = @@uri_hash["#{uri}#{@normalize}"] ||= begin
+        # Special case if URI has no path, and the authority ends with a '#'
+        uri = Addressable::URI.parse($1) if @normalize && uri.to_s.match(/^(.*)\#$/)
+
+        @normalize ? uri.normalize : uri
+      end.freeze
     end
     
     # Create a URI, either by appending a fragment, or using the input URI
@@ -40,7 +47,9 @@ module RdfContext
     # short_name of URI for creating QNames.
     #   "#{base]{#short_name}}" == uri
     def short_name
-      @short_name ||= if @uri.fragment()
+      @short_name ||= if @namespace
+        self.to_s.sub(@namespace.uri.to_s, "")
+      elsif @uri.fragment()
         @uri.fragment()
       elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
         @uri.path.split("/").last
@@ -53,14 +62,14 @@ module RdfContext
     #   "#{base]{#short_name}}" == uri
     def base
       @base ||= begin
-        uri_base = @uri.to_s
+        uri_base = self.to_s
         sn = short_name.to_s
         uri_base[0, uri_base.length - sn.length]
       end
     end
   
     def eql?(other)
-      @uri.to_s == other.to_s
+      self.to_s == other.to_s
     end
     alias_method :==, :eql?
   
@@ -68,24 +77,26 @@ module RdfContext
     def hash; to_s.hash; end
   
     def to_s
-      @uri.to_s
+      @to_s ||= @uri.to_s
     end
   
     def to_n3
-      "<" + @uri.to_s + ">"
+      "<" + self.to_s + ">"
     end
     alias_method :to_ntriples, :to_n3
   
     # Output URI as QName using URI binding
     def to_qname(uri_binding = {})
-      "#{namespace(uri_binding).prefix}:#{self.short_name}"
+      ns = namespace(uri_binding)
+      sn = self.to_s.sub(ns.uri.to_s, "")
+      "#{ns.prefix}:#{sn}"
     end
     
     def namespace(uri_binding = {})
       @namespace ||= begin
-        ns = uri_binding[self.base]
-        raise RdfException, "Couldn't find namespace for #{@uri}" unless ns
-        ns
+        uri = uri_binding.keys.detect {|u| self.to_s.index(u) == 0 }
+        raise RdfException, "Couldn't find namespace for #{@uri}" unless uri
+        uri_binding[uri]
       end
     end
     
@@ -95,9 +106,10 @@ module RdfContext
     
     # Output URI as resource reference for RDF/XML
     def xml_args
-      [{"rdf:resource" => @uri.to_s}]
+      [{"rdf:resource" => self.to_s}]
     end
     
+    protected
     def test_string (string)
       string.to_s.each_byte do |b|
         if b >= 0 and b <= 31
@@ -105,10 +117,5 @@ module RdfContext
         end
       end
     end
-
-#    def load_graph
-#      get = Net::HTTP.start(@uri.host, @uri.port) {|http| [:xml, http.get(@uri.path)] }
-#      return RdfContext::RdfXmlParser.new(get[1].body, @uri.to_s).graph if get[0] == :xml
-#    end
   end
 end

data/spec/aggregate_graph_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "AggregateGraph" do
+  before(:all) do
+    @store = MemoryStore.new(@identifier)
+    @graph1 = Graph.new(:store => @store)
+    @graph2 = Graph.new(:store => @store)
+    @graph3 = Graph.new(:store => @store)
+    
+    @graph1.parse(%(
+    @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+    @prefix : <http://test/> .
+    :foo a rdfs:Class.
+    :bar :d :c.
+    :a :d :c.
+    ), "http://test/")
+    
+    @graph2.parse(%(
+    @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+    @prefix : <http://test/> .
+    @prefix log: <http://www.w3.org/2000/10/swap/log#>.
+    :foo a rdfs:Resource.
+    :bar rdfs:isDefinedBy [ a log:Formula ].
+    :a :d :e.
+    ), "http://test/")
+    
+    @graph3.parse(%(
+    @prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+    @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+    @prefix log: <http://www.w3.org/2000/10/swap/log#>.
+    @prefix : <http://test/> .
+    <> a log:N3Document.
+    ), "http://test/")
+  end
+  
+  subject { AggregateGraph.new(@graph1, @graph2, @graph3)}
+  
+  it "should return types" do
+    subject.triples(Triple.new(nil, RDF_TYPE, nil)).length.should == 4
+  end
+
+  it "should return subjects" do
+    subject.triples(Triple.new("http://test/bar", nil, nil)).length.should == 2
+  end
+
+  it "should return predicates" do
+    subject.triples(Triple.new(nil, "http://test/d", nil)).length.should == 3
+  end
+  
+  it "should have size sum of graphs" do
+    subject.size.should == @graph1.size + @graph2.size + @graph3.size
+  end
+  
+  it "should contain a triple" do
+    subject.contains?(Triple.new("http://test/foo", RDF_TYPE, RDFS_NS.Resource)).should be_true
+  end
+end

data/spec/conjunctive_graph_spec.rb

@@ -56,7 +56,7 @@ describe "ConjunctiveGraph" do
   it "should parse into new context" do
     n3_string = "<http://example.org/> <http://xmlns.com/foaf/0.1/name> \"Gregg Kellogg\" . "
     graph = subject.parse(n3_string, "http://foo.bar", :type => :n3)
-    graph.identifier.should == "http://foo.bar"
+    graph.identifier.should == "http://foo.bar/"
     subject.size.should == 1
     t = subject.triples.first
     t.subject.to_s.should == "http://example.org/"

data/spec/cwm_spec.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+include RdfContext
+
+describe "N3 parser" do
+  describe "w3c cwm tests" do
+    require 'rdf_helper'
+
+    def self.test_cases
+      RdfHelper::TestCase.test_cases(CWM_TEST, SWAP_DIR) rescue []
+    end
+
+    # Negative parser tests should raise errors.
+    test_cases.each do |t|
+      #next unless t.about.uri.to_s =~ /rdfms-rdf-names-use/
+      #next unless t.name =~ /11/
+      #puts t.inspect
+      specify "test #{t.name}: " + (t.description || "#{t.inputDocument} against #{t.outputDocument}") do
+        begin
+          t.run_test do |rdf_string, parser|
+            parser.parse(rdf_string, t.about.uri.to_s, :strict => true, :debug => [])
+          end
+        rescue #Spec::Expectations::ExpectationNotMetError => e
+          if t.status == "pending"
+            pending("Formulae not supported") {  raise } 
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/spec/graph_spec.rb

@@ -188,6 +188,43 @@ HERE
       xml.should include("Ralph Swick")
       xml.should include("Manu Sporny")
     end
+
+    it "should find bnodes" do
+      subject.bnodes.length.should == 2
+    end
+    
+    it "should find predicate bnodes" do
+      subject.allow_n3 = true
+      c = BNode.new("c")
+      subject << Triple.new(URIRef.new("http://foo"), c, Literal.untyped("BNode predicate"))
+      subject.bnodes.length.should == 3
+      subject.bnodes.should include(c)
+    end
+  end
+  
+  describe "with namespaces" do
+    subject { Graph.new(:store => ListStore.new) }
+    
+    it "should use namespace with trailing slash" do
+      ns = Namespace.new("http://www.example.com/ontologies/test/", "test")
+      subject.bind(ns)
+      subject.add_triple("http://example.com", ns.hasChallenge, "Interesting Title")
+      subject.to_rdfxml.should =~ /<test:hasChallenge/
+    end
+    
+    it "should use namespace with trailing #" do
+      ns = Namespace.new("http://www.example.com/ontologies/test#", "test")
+      subject.bind(ns)
+      subject.add_triple("http://example.com", ns.hasChallenge, "Interesting Title")
+      subject.to_rdfxml.should =~ /<test:hasChallenge/
+    end
+
+    it "should use namespace with trailing word" do
+      ns = Namespace.new("http://www.example.com/ontologies/test", "test")
+      subject.bind(ns)
+      subject.add_triple("http://example.com", ns.hasChallenge, "Interesting Title")
+      subject.to_rdfxml.should =~ /<test:hasChallenge/
+    end
   end
   
   describe "with triples" do
@@ -307,6 +344,41 @@ HERE
         subject.to_rdfxml.should be_equivalent_xml(rdfxml)
       end
     end
+
+    describe "rdf:_n sequences" do
+      subject {
+        g = Graph.new(:store => ListStore.new)
+        g.add_triple(@ex.Seq, RDF_TYPE, RDF_NS.Seq)
+        g.add_triple(@ex.Seq, RDF_NS._1, @ex.john)
+        g.add_triple(@ex.Seq, RDF_NS._2, @ex.jane)
+        g.add_triple(@ex.Seq, RDF_NS._3, @ex.rick)
+        g.bind(@ex)
+        g
+      }
+      
+      it "should return object list" do
+        subject.seq(@ex.Seq).should == [@ex.john, @ex.jane, @ex.rick]
+      end
+    end
+    
+    describe "rdf:first/rdf:rest sequences" do
+      subject {
+        a, b = BNode.new("a"), BNode.new("b"), BNode.new("c")
+        g = Graph.new(:store => ListStore.new)
+        g.add_triple(@ex.List, RDF_NS.first, @ex.john)
+        g.add_triple(@ex.List, RDF_NS.rest, a)
+        g.add_triple(a, RDF_NS.first, @ex.jane)
+        g.add_triple(a, RDF_NS.rest, b)
+        g.add_triple(b, RDF_NS.first,  @ex.rick)
+        g.add_triple(b, RDF_NS.rest, RDF_NS.nil)
+        g.bind(@ex)
+        g
+      }
+      
+      it "should return object list" do
+        subject.seq(@ex.List).should == [@ex.john, @ex.jane, @ex.rick]
+      end
+    end
   end
 
   describe "which are merged" do
@@ -335,9 +407,9 @@ HERE
       g.add_triple(BNode.new("a1", @bn_ctx), URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new("a2", @bn_ctx))
       g.merge!(subject)
       g.size.should == 2
-      s1, s2 = g.triples.map(&:subject)
-      p1, p2 = g.triples.map(&:predicate)
-      o1, o2 = g.triples.map(&:object)
+      s1, s2 = g.triples.map {|s| s.subject}
+      p1, p2 = g.triples.map {|p| p.predicate}
+      o1, o2 = g.triples.map {|o| o.object}
       s1.should_not == s2
       p1.should == p1
       o1.should_not == o2
@@ -380,6 +452,17 @@ HERE
           subject.should == f
         end
     
+        it "should be true for equivalent graphs with different BNode predicates" do
+          subject.allow_n3 = true
+          subject.add_triple(@ex.a, BNode.new("knows", @bn_ctx), @ex.b)
+          subject.add_triple(@ex.b, BNode.new("knows", @bn_ctx), @ex.a)
+
+          f = Graph.new(:store => s, :identifier => subject.identifier, :allow_n3 => true)
+          f.add_triple(@ex.a, BNode.new("knows", @bn_ctx), @ex.b)
+          f.add_triple(@ex.b, BNode.new("knows", @bn_ctx), @ex.a)
+          subject.should == f
+        end
+    
         it "should be true for graphs with literals" do
           subject.add_triple(@ex.a, @foaf.knows, Literal.untyped("foo"))
 
@@ -390,4 +473,32 @@ HERE
       end
     end
   end
+  
+  describe "Bnode Permutation matching" do
+    {
+      "a1"  => %w(aA),
+      "a1b1"  => %w(aAbB aBbA),
+      "a2b1"  => %w(aAbB),
+      "a2b2c1"  => %w(aAbBcC aBbAcC),
+      "a2b2c3d3e1f4" => %w(
+        aAbBcCdDeEfF
+        aBbAcCdDeEfF
+        aAbBcDdCeEfF
+        aBbAcDdCeEfF
+      )
+    }.each_pair do |list, perms|
+      it "should permute #{list} as #{perms.to_sentence}" do
+        h_source = list.scan(/\w\d/).inject({}) {|hash, ad| hash[ad[0,1]] = ad[1,1]; hash}
+        h_dest = list.upcase.scan(/\w\d/).inject({}) {|hash, ad| hash[ad[0,1]] = ad[1,1]; hash}
+        subject.send(:bnode_permutations, h_source, h_dest) do |hash|
+          perm = ""
+          #puts hash.inspect
+          hash.keys.sort.each {|k| perm << "#{k}#{hash[k]}"}
+          perms.should include(perm)
+          perms -= [perm]
+        end
+        perms.should be_empty
+      end
+    end
+  end
 end