rdf_context 0.4.2

data/lib/rdf_context/triple.rb

@@ -0,0 +1,144 @@
+module RdfContext
+  # An RDF Triple, or statement.
+  #
+  # Statements are composed of _subjects_, _predicates_ and _objects_.
+  class Triple
+    attr_accessor :subject, :object, :predicate
+
+    ##
+    # 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.
+    #
+    # ==== 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
+    #
+    # @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)
+    # @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)
+      @predicate = self.class.coerce_predicate(predicate)
+      @object    = self.class.coerce_object(object)
+      @patern = subject.nil? || predicate.nil? || object.nil?
+    end
+
+    def is_patern?
+      @patern
+    end
+    
+    # Serialize Triple to N-Triples
+    def to_ntriples
+      raise RdfException.new("Can't serialize patern triple") if is_patern?
+      @subject.to_ntriples + " " + @predicate.to_ntriples + " " + @object.to_ntriples + " ."
+    end
+    
+    def to_s; self.to_ntriples; end
+    
+    def inspect
+      [@subject, @predicate, @object, @patern].inspect
+    end
+
+    # Is the predicate of this statment rdf:type?
+    def is_type?
+      @predicate.to_s == "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+    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
+    def eql? (other)
+      other.is_a?(Triple) &&
+      (other.subject == self.subject || other.subject.nil? || self.subject.nil?) &&
+      (other.predicate == self.predicate || other.predicate.nil? || self.predicate.nil?) &&
+      (other.object == self.object || other.object.nil? || self.object.nil?)
+    end
+
+    alias_method :==, :eql?
+
+    # Clone triple, keeping references to literals and URIRefs, but cloning BNodes
+    def clone
+      raise RdfException.new("Can't clone patern triple") if is_patern?
+      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
+    
+    # For indexes
+    def hash
+      [subject, predicate, object].hash
+    end
+    
+    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+/ # 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] subject:: If a String looks like a URI, a URI is created
+    # @raise[InvalidSubject]:: If subject can't be predicate.
+    def self.coerce_predicate(predicate)
+      case predicate
+      when Addressable::URI
+        URIRef.new(predicate.to_s)
+      when URIRef
+        predicate
+      when String
+        URIRef.new predicate
+      when nil
+        predicate
+      else
+        raise InvalidPredicate, "Predicate should be a URI"
+      end
+    rescue ParserException => e
+      raise InvalidPredicate, "Couldn't make a URIRef: #{e.message}"
+    end
+
+    # Coerce a 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[InvalidSubject]:: If subject can't be predicate.
+    def self.coerce_object(object)
+      case object
+      when Addressable::URI
+        URIRef.new(object.to_s)
+      when String
+        if object.to_s =~ /^\w+:\/\/\S+/ # does it smell like a URI?
+          URIRef.new(object.to_s)
+        else
+          Literal.untyped(object)
+        end
+      when Integer, Float
+        Literal.build_from(object)
+      when URIRef, BNode, Literal
+        object
+      when nil, regexp
+        object
+      else
+        raise InvalidObject, "#{object.class}: #{object.inspect} is not a valid object"
+      end
+    end
+  end
+end

data/lib/rdf_context/uriref.rb

@@ -0,0 +1,95 @@
+require 'net/http'
+
+module RdfContext
+  class URIRef
+    attr_accessor :uri
+    
+    # Create a URIRef from a URI  or a fragment and a URI
+    #
+    # ==== Example
+    #   u = URIRef.new("http://example.com")
+    #   u = URIRef.new("foo", u) => "http://example.com/foo"
+    # 
+    def initialize (*args)
+      args.each {|s| test_string(s)}
+      if args.size == 1
+        @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"
+      end
+      if !@uri.to_s.match(/^javascript/).nil?
+        raise ParserException, "Javascript pseudo-URIs are not acceptable"
+      end
+      
+      # 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]
+    end
+    
+    # Create a URI, either by appending a fragment, or using the input URI
+    def + (input)
+      input_uri = Addressable::URI.parse(input.to_s)
+      return URIRef.new(input_uri, self.to_s)
+    end
+    
+    def short_name
+      if @uri.fragment()
+        return @uri.fragment()
+      elsif @uri.path.split("/").last.class == String and @uri.path.split("/").last.length > 0
+        return @uri.path.split("/").last
+      else
+        return false
+      end
+    end
+  
+    def eql?(other)
+      @uri.to_s == other.to_s
+    end
+    alias_method :==, :eql?
+  
+    # Needed for uniq
+    def hash; to_s.hash; end
+  
+    def to_s
+      @uri.to_s
+    end
+  
+    def to_ntriples
+      "<" + @uri.to_s + ">"
+    end
+  
+    # Output URI as QName using URI binding
+    def to_qname(uri_binding = {})
+      uri_base = @uri.to_s
+      sn = short_name.to_s
+      uri_base = uri_base[0, uri_base.length - sn.length]
+      if uri_binding.has_key?(uri_base)
+        "#{uri_binding[uri_base]}:#{sn}"
+      else
+        raise ParserException, "Couldn't find QName for #{@uri}"
+      end
+    end
+    
+    # Output URI as resource reference for RDF/XML
+    def xml_args
+      [{"rdf:resource" => @uri.to_s}]
+    end
+    
+    def test_string (string)
+      string.to_s.each_byte do |b|
+        if b >= 0 and b <= 31
+          raise ParserException, "URI '#{string}' must not contain control characters"
+        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/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rdf_context.rb'}"
+puts "Loading rdf_context gem"
+exec "#{irb} #{libs} --simple-prompt"

data/spec/bnode_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe "Blank nodes" do
+  before(:all) { @context = {} }
+  
+  describe "which have custom identifiers" do
+    subject { BNode.new("foo", @context) }
+  
+    it "should return identifier" do
+      subject.identifier.should =~ /foo/
+      subject.to_s.should =~ /foo/
+    end
+
+    it "should be rejected if they are not acceptable" do
+      b = BNode.new("4cake", @context)
+      b.identifier.should_not =~ /4cake/
+    end
+
+    it "should be expressible in NT syntax" do
+      subject.to_ntriples.should =~ /foo/
+    end
+
+    it "should be able to determine equality" do
+      other = BNode.new(subject.to_s, @context)
+      should == other
+    end
+
+    it "should be able to determine inequality" do
+      other = URIRef.new('http://somehost.com/wherever.xml')
+      should_not == other
+    end
+
+    it "should resource hash for RDF/XML named bnode" do
+      subject.xml_args.should == [{"rdf:nodeID" => subject.to_s}]
+    end
+  end
+
+  describe "which has a blank identifier" do
+    subject { BNode.new("", @context) }
+    it "should not be the same as an anonymous identifier" do should_not == BNode.new end
+    it "should be the same as another blank identifier" do should == BNode.new("", @context) end
+  end
+
+  describe "which are anonymous" do
+    subject { BNode.new(@graph)}
+    it "should not be equivalent to another anonymous node" do
+      should_not == BNode.new
+    end
+    
+    it "should be equivalent it's clone" do
+      should == subject.clone
+    end
+    
+    it "should create resource hash for RDF/XML anonymous bnode" do
+      b = BNode.new
+      b.xml_args.should == [{"rdf:nodeID" => b.identifier}]
+    end
+  end
+end

data/spec/conjunctive_graph_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "ConjunctiveGraph" do
+  before(:each) do
+    @ex = Namespace.new("http://example.org/", "ex")
+    @identifier = URIRef.new("http://store.identifier")
+    @store = MemoryStore.new(@identifier)
+  end
+  
+  subject { ConjunctiveGraph.new(:store => @store)}
+  
+  it "should should have same identifier as store" do
+    subject.identifier.should == @identifier
+  end
+  
+  it "should have a default context" do
+    subject.default_context.should be_a(Graph)
+    subject.default_context.identifier.should == @identifier
+    subject.default_context.store.should == @store
+  end
+  
+  it "should add triples to default context" do
+    t = Triple.new(@ex.a, @ex.b, @ex.c)
+    subject.add(t)
+    
+    count = 0
+    subject.triples do |t, ctx|
+      t.should == t
+      ctx.should be_a(Graph)
+      ctx.identifier.should == @identifier
+      count += 1
+    end
+    count.should == 1
+  end
+  
+  it "should retrieve triples from all contexts" do
+    g = Graph.new(:store => @store)
+    t = Triple.new(@ex.a, @ex.b, @ex.c)
+    g.add(t)
+    
+    count = 0
+    subject.triples do |t, ctx|
+      t.should == t
+      ctx.should == g
+      count += 1
+    end
+    count.should == 1
+  end
+  
+  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"
+    subject.size.should == 1
+    t = subject.triples.first
+    t.subject.to_s.should == "http://example.org/"
+    t.predicate.to_s.should == "http://xmlns.com/foaf/0.1/name"
+    t.object.to_s.should == "Gregg Kellogg"
+  end
+end

data/spec/graph_spec.rb

@@ -0,0 +1,390 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Graphs" do
+  before(:all) do
+    @ex = Namespace.new("http://example.org/", "ex")
+    @foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    @bn_ctx = {}
+  end
+  
+  subject { Graph.new(:store => ListStore.new) }
+  it "should allow you to add one or more triples" do
+    lambda do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+  end
+  
+  it "should support << as an alias for add_triple" do
+    lambda do
+      subject << Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should_not raise_error
+    subject.size.should == 1
+  end
+  
+  it "should return bnode subjects" do
+    bn = BNode.new
+    subject.add_triple(bn, URIRef.new("http://xmlns.com/foaf/0.1/knows"), bn)
+    subject.subjects.should == [bn]
+  end
+  
+  it "should be able to determine whether or not it has existing BNodes" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    john = BNode.new('john', @bn_ctx)
+    jane = BNode.new('jane', @bn_ctx)
+    jack = BNode.new('jack', @bn_ctx)
+    
+    subject << Triple.new(john, foaf.knows, jane)
+    subject.has_bnode_identifier?(john).should be_true
+    subject.has_bnode_identifier?(jane).should be_true
+    subject.has_bnode_identifier?(jack).should_not be_true
+  end
+  
+  it "should allow you to create and bind Namespace objects" do
+    subject.bind(Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")).should be_a(Namespace)
+    subject.nsbinding["foaf"].uri.should == "http://xmlns.com/foaf/0.1/"
+  end
+  
+  it "should bind namespace" do
+    foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+    subject.bind(foaf).should == foaf
+  end
+  
+  it "should not allow you to bind things other than namespaces" do
+    lambda do
+      subject.bind(false)
+    end.should raise_error
+  end
+    
+  it "should follow the specification as to output identical triples" do
+    subject.add_triple(@ex.a, @ex.b, @ex.c)
+    subject.add_triple(@ex.a, @ex.b, @ex.c)
+    subject.size.should == 1
+  end
+  
+  it "should parse into existing graph" do
+    n3_string = "<http://example.org/> <http://xmlns.com/foaf/0.1/name> \"Gregg Kellogg\" . "
+    graph = subject.parse(n3_string, nil, :type => :n3)
+    graph.should == subject
+    graph.identifier.should be_a(BNode)
+    subject.size.should == 1
+    subject[0].subject.to_s.should == "http://example.org/"
+    subject[0].predicate.to_s.should == "http://xmlns.com/foaf/0.1/name"
+    subject[0].object.to_s.should == "Gregg Kellogg"
+  end
+  
+  it "should add multiple triples" do
+    subject.add(Triple.new(@ex.a, @ex.b, @ex.c), Triple.new(@ex.a, @ex.b, @ex.d))
+    subject.size.should == 2
+  end
+
+  describe "with identifier" do
+    before(:all) { @identifier = URIRef.new("http://foo.bar") }
+    subject { Graph.new(:identifier => @identifier) }
+    
+    it "should retrieve identifier" do
+      subject.identifier.should == @identifier
+      subject.identifier.should == @identifier.to_s
+    end
+  end
+  
+  describe "with named store" do
+    before(:all) do
+      @identifier = URIRef.new("http://foo.bar")
+      @store = ListStore.new(:identifier => @identifier)
+    end
+    
+    subject {
+      g = Graph.new(:identifier => @identifier, :store => @store)
+      g.add_triple(@ex.john, @foaf.knows, @ex.jane)
+      g.add_triple(@ex.john, @foaf.knows, @ex.rick)
+      g.add_triple(@ex.jane, @foaf.knows, @ex.rick)
+      g.bind(@foaf)
+      g
+    }
+    
+    it "should retrieve identifier" do
+      subject.identifier.should == @identifier
+      subject.identifier.should == @identifier.to_s
+    end
+    
+    it "should be same as graph with same store and identifier" do
+      g = Graph.new(:store => @store, :identifier => @identifier)
+      subject.should == g
+    end
+  end
+  
+  describe "with XML Literal objects" do
+    subject {
+      dc = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
+      xhtml = Namespace.new("http://www.w3.org/1999/xhtml", "")
+      g = Graph.new(:store => ListStore.new)
+      g << Triple.new(
+        URIRef.new("http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml"),
+        URIRef.new("http://purl.org/dc/elements/1.1/title"),
+        Literal.typed("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time",
+                      "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral",
+                      g.nsbinding)
+      )
+      g.bind(dc)
+      g.bind(xhtml)
+      g
+    }
+    
+    it "should output NTriple" do
+      nt = '<http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml> <http://purl.org/dc/elements/1.1/title> "E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral> .' + "\n"
+      subject.to_ntriples.should == nt
+    end
+
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml=\"http://www.w3.org/XML/1998/namespace\" xmlns:rdfs=\"http://www.w3.org/2000/01/rdf-schema#\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:xhv=\"http://www.w3.org/1999/xhtml/vocab#\">
+  <rdf:Description rdf:about="http://www.w3.org/2006/07/SWD/RDFa/testsuite/xhtml1-testcases/0011.xhtml">
+    <dc:title rdf:parseType="Literal">E = mc<sup xmlns="http://www.w3.org/1999/xhtml" xmlns:dc="http://purl.org/dc/elements/1.1/">2>/sup>: The Most Urgent Problem of Our Time</dc:title>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      subject.to_rdfxml.should include("E = mc<sup xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">2</sup>: The Most Urgent Problem of Our Time")
+    end
+  end
+  
+  describe "with bnodes" do
+    subject {
+      g = Graph.new(:store => ListStore.new)
+      a = BNode.new("a")
+      b = BNode.new("b")
+      
+      g << Triple.new(a, @foaf.name, Literal.untyped("Manu Sporny"))
+      g << Triple.new(a, @foaf.knows, b)
+      g << Triple.new(b, @foaf.name, Literal.untyped("Ralph Swick"))
+      g.bind(@foaf)
+      g
+    }
+    
+    it "should return bnodes" do
+      subject.bnodes.keys.length.should == 2
+      subject.bnodes.values.should == [2, 2]
+    end
+
+    it "should output RDF/XML" do
+      rdfxml = <<-HERE
+<?xml version="1.0" encoding="utf-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:nodeID="a">
+    <foaf:name>Manu Sporny</foaf:name>
+    <foaf:knows rdf:nodeID="b"/>
+  </rdf:Description>
+  <rdf:Description rdf:nodeID="b">
+    <foaf:name>Ralph Swick</foaf:name>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+      xml = subject.to_rdfxml
+      xml.should include("Ralph Swick")
+      xml.should include("Manu Sporny")
+    end
+  end
+  
+  describe "with triples" do
+    subject {
+      g = Graph.new(:store => ListStore.new)
+      g.add_triple(@ex.john, @foaf.knows, @ex.jane)
+      g.add_triple(@ex.john, @foaf.knows, @ex.rick)
+      g.add_triple(@ex.jane, @foaf.knows, @ex.rick)
+      g.bind(@foaf)
+      g
+    }
+
+    it "should detect included triple" do
+      subject.contains?(subject[0]).should be_true
+    end
+    
+    it "should tell you how large the graph is" do
+      subject.size.should == 3
+    end
+  
+    it "should return unique subjects" do
+      subject.subjects.should == [@ex.john.uri.to_s, @ex.jane.uri.to_s]
+    end
+    
+    it "should return unique predicates" do
+      subject.predicates.should == [@foaf.knows.uri.to_s]
+    end
+    
+    it "should return unique objects" do
+      subject.objects.should == [@ex.jane.uri.to_s, @ex.rick.uri.to_s]
+    end
+    
+    it "should allow you to select resources" do
+      subject.triples(Triple.new(@ex.john, nil, nil)).size.should == 2
+    end
+
+    it "should allow iteration" do
+      count = 0
+      subject.triples do |t|
+        count = count + 1
+        t.class.should == Triple
+      end
+      count.should == 3
+    end
+
+    it "should allow iteration over a particular subject" do
+      count = 0
+      subject.triples(Triple.new(@ex.john, nil, nil)) do |t|
+        count = count + 1
+        t.class.should == Triple
+        t.subject.should == @ex.john
+      end
+      count.should == 2
+    end
+
+    it "should give you a list of resources of a particular type" do
+      subject.add_triple(@ex.john, RDF_TYPE, @foaf.Person)
+      subject.add_triple(@ex.jane, RDF_TYPE, @foaf.Person)
+
+      subject.get_by_type("http://xmlns.com/foaf/0.1/Person").should == [@ex.john, @ex.jane]
+    end
+    
+    it "should remove a triple" do
+      subject.add(Triple.new(@ex.john, RDF_TYPE, @foaf.Person))
+      subject.size.should == 4
+      subject.remove(Triple.new(@ex.john, RDF_TYPE, @foaf.Person))
+      subject.size.should == 3
+    end
+
+    it "should remove all triples" do
+      subject.remove(Triple.new(nil, nil, nil))
+      subject.size.should == 0
+    end
+
+    describe "find triples" do
+      it "should find subjects" do
+        subject.triples(Triple.new(@ex.john, nil, nil)).size.should == 2
+        subject.triples(Triple.new(@ex.jane, nil, nil)).size.should == 1
+      end
+      
+      it "should find predicates" do
+        subject.triples(Triple.new(nil, @foaf.knows, nil)).size.should == 3
+      end
+      
+      it "should find objects" do
+        subject.triples(Triple.new(nil, nil, @ex.rick)).size.should == 2
+      end
+      
+      it "should find object with regexp" do
+        subject.triples(Triple.new(nil, nil, @ex.rick)).size.should == 2
+      end
+      
+      it "should find combinations" do
+        subject.triples(Triple.new(@ex.john, nil, @ex.rick)).size.should == 1
+      end
+    end
+    
+    describe "encodings" do
+      it "should output NTriple" do
+        nt = "<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/jane> .\n<http://example.org/john> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n<http://example.org/jane> <http://xmlns.com/foaf/0.1/knows> <http://example.org/rick> .\n"
+        subject.to_ntriples.should == nt
+      end
+    
+      it "should output RDF/XML" do
+        rdfxml = <<HERE
+<?xml version="1.0" encoding="UTF-8"?>
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xhv="http://www.w3.org/1999/xhtml/vocab#">
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/jane"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/john">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+  <rdf:Description rdf:about="http://example.org/jane">
+    <foaf:knows rdf:resource="http://example.org/rick"/>
+  </rdf:Description>
+</rdf:RDF>
+HERE
+        subject.to_rdfxml.should be_equivalent_xml(rdfxml)
+      end
+    end
+  end
+
+  describe "which are merged" do
+    it "should be able to integrate another graph" do
+      subject.add_triple(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+      g = Graph.new(:store => ListStore.new)
+      g.merge!(subject)
+      g.size.should == 1
+    end
+    
+    it "should not merge with non graph" do
+      lambda do
+        h.merge!("")
+      end.should raise_error
+    end
+    
+    # One does not, in general, obtain the merge of a set of graphs by concatenating their corresponding
+    # N-Triples documents and constructing the graph described by the merged document. If some of the
+    # documents use the same node identifiers, the merged document will describe a graph in which some of the
+    # blank nodes have been 'accidentally' identified. To merge N-Triples documents it is necessary to check
+    # if the same nodeID is used in two or more documents, and to replace it with a distinct nodeID in each
+    # of them, before merging the documents.
+    it "should remap bnodes to avoid duplicate bnode identifiers" do
+      subject.add_triple(BNode.new("a1", @bn_ctx), URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new("a2", @bn_ctx))
+      g = Graph.new(:store => ListStore.new)
+      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.should_not == s2
+      p1.should == p1
+      o1.should_not == o2
+    end
+
+    it "should remove duplicate triples" do
+      subject.add_triple(@ex.a, URIRef.new("http://xmlns.com/foaf/0.1/knows"), @ex.b)
+      g = Graph.new(:store => ListStore.new)
+      g.add_triple(@ex.a, URIRef.new("http://xmlns.com/foaf/0.1/knows"), @ex.b)
+      g.merge!(subject)
+      g.size.should == 1
+    end
+  end
+  
+  describe "that can be compared" do
+    {
+      "ListStore" => :list_store,
+      "MemoryStore" => :memory_store
+    }.each_pair do |t, s|
+      describe "using #{t}" do
+        subject { Graph.new(:store => s)}
+        
+        it "should be true for empty graphs" do
+          subject.should == Graph.new(:store => s, :identifier => subject.identifier)
+        end
+
+        it "should be false for different graphs" do
+          f = Graph.new(:store => s, :identifier => subject.identifier)
+          f.add_triple(URIRef.new("http://example.org/joe"), URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), URIRef.new("http://xmlns.com/foaf/0.1/Person"))
+          subject.should_not == f
+        end
+    
+        it "should be true for equivalent graphs with different BNode identifiers" do
+          subject.add_triple(@ex.a, @foaf.knows, BNode.new("a1", @bn_ctx))
+          subject.add_triple(BNode.new("a1", @bn_ctx), @foaf.knows, @ex.a)
+
+          f = Graph.new(:store => s, :identifier => subject.identifier)
+          f.add_triple(@ex.a, @foaf.knows, BNode.new("a2", @bn_ctx))
+          f.add_triple(BNode.new("a2", @bn_ctx), @foaf.knows, @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"))
+
+          f = Graph.new(:store => s, :identifier => subject.identifier)
+          f.add_triple(@ex.a, @foaf.knows, Literal.untyped("foo"))
+          subject.should == f
+        end
+      end
+    end
+  end
+end