gkellogg-reddy 0.2.1

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+begin
+  require 'spec'
+  require 'active_support'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'spec'
+  gem 'active_support'
+  require 'active_support'
+end
+
+ActiveSupport::XmlMini.backend = 'Nokogiri'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift File.dirname(__FILE__)
+require 'reddy'
+require 'matchers'
+
+include Reddy
+
+Spec::Runner.configure do |config|
+  config.include(Matchers)
+end

data/spec/store_spec.rb

@@ -0,0 +1,205 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Store" do
+  {
+    "List Store" => { :klass => ListStore, :configuration => {}, :context_aware => false, :ctx => URIRef.new("http://identifier")},
+    "Memory Store" => { :klass => MemoryStore, :configuration => {}, :context_aware => true, :ctx => URIRef.new("http://identifier")},
+    "Memory Store with ctx" => { :klass => MemoryStore, :configuration => {}, :context_aware => true, :ctx => URIRef.new("http://context")},
+  }.each_pair do |label, hash|
+    describe label.to_s do
+      before(:all) do
+        @identifier = URIRef.new("http://identifier")
+        @ctx = hash[:ctx]
+        @ex = Namespace.new("http://example.org/", "ex")
+        @foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+      end
+    
+      subject { hash[:klass].new(@identifier, hash[:configuration]) }
+    
+      it "should be an AbstractStore" do
+        subject.should be_a(AbstractStore)
+      end
+    
+      it "should allow you to add a triple" do
+        subject.add(Triple.new(@ex.a, @ex.b, @ex.c), @ctx)
+        subject.add(Triple.new(@ex.a, @ex.b, @ex.d), @ctx)
+        subject.size.should == 2
+      end
+      
+      it "should allow you to create and bind Namespace objects" do
+        foaf = Namespace.new("http://xmlns.com/foaf/0.1/", "foaf")
+        subject.bind(foaf).should == foaf
+      end
+
+      it "should retrieve identifier" do
+        subject.identifier.should == @identifier
+      end
+      
+      describe "with triples" do
+        before(:each) do
+          subject.add(Triple.new(@ex.john, @foaf.knows, @ex.jane), @ctx)
+          subject.add(Triple.new(@ex.john, @foaf.knows, @ex.rick), @ctx)
+          subject.add(Triple.new(@ex.jane, @foaf.knows, @ex.rick), @ctx)
+          subject.bind(@foaf)
+        end
+        
+        it "should detect included triple" do
+          subject.contains?(Triple.new(@ex.john, @foaf.knows, @ex.jane), @ctx).should be_true
+        end
+        
+        it "should contain different triple paterns" do
+          [
+            Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),URIRef.new("http://baz")),
+            Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),Literal.untyped("baz")),
+            Triple.new(URIRef.new("http://foo"),"http://bar",Literal.untyped("baz")),
+            Triple.new(BNode.new("foo"),URIRef.new("http://bar"),Literal.untyped("baz")),
+            Triple.new(BNode.new,URIRef.new("http://bar"),Literal.untyped("baz")),
+            Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),Literal.typed(5, "http://www.w3.org/2001/XMLSchema#int")),
+            Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),Literal.typed("gregg", "http://www.w3.org/2001/XMLSchema#string")),
+            Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),"gregg"),
+          ].each do |t|
+            subject.add(t, @ctx)
+            subject.contains?(t, @ctx)
+          end
+        end
+        
+        it "should tell you how large the store is" do
+          subject.size.should == 3
+        end
+        
+        it "should allow you to select resources" do
+          subject.triples(Triple.new(@ex.john, nil, nil), @ctx).size.should == 2
+        end
+        
+        it "should allow iteration" do
+          count = 0
+          subject.triples(Triple.new(nil, nil, nil), @ctx) do |t, context|
+            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), @ctx) do |t, context|
+            count = count + 1
+            t.class.should == Triple
+          end
+          count.should == 2
+        end
+        
+        it "should allow iteration over a particular predicate" do
+          count = 0
+          subject.triples(Triple.new(nil, @foaf.knows, nil), @ctx) do |t, context|
+            count = count + 1
+            t.class.should == Triple
+          end
+          count.should == 3
+        end
+        
+        it "should allow iteration over a particular object" do
+          count = 0
+          subject.triples(Triple.new(nil, nil, @ex.jane), @ctx) do |t, context|
+            count = count + 1
+            t.class.should == Triple
+          end
+          count.should == 1
+        end
+        
+        it "should find combinations" do
+          subject.triples(Triple.new(@ex.john, @foaf.knows, nil), @ctx).length.should == 2
+          subject.triples(Triple.new(@ex.john, nil, @ex.jane), @ctx).length.should == 1
+          subject.triples(Triple.new(nil, @foaf.knows, @ex.jane), @ctx).length.should == 1
+        end
+        
+        it "should retrieve indexed item" do
+          subject.item(0).should be_a(Triple)
+        end
+
+        it "should detect included triple" do
+          t = subject.item(0)
+          subject.contains?(t).should be_true
+        end
+      end
+
+      it "should remove a triple" do
+        subject.add(Triple.new(@ex.john, RDF_TYPE, @foaf.Person), @ctx)
+        subject.size(@ctx).should == 1
+        subject.remove(Triple.new(@ex.john, RDF_TYPE, @foaf.Person), @ctx)
+        subject.size(@ctx).should == 0
+      end
+
+      if hash[:context_aware]
+        describe "is context aware" do
+          before(:all) do
+            @triple = Triple.new(@ex.a, @ex.b, @ex.c)
+            @ctx1 = URIRef.new("http://new1.ctx")
+            @ctx2 = URIRef.new("http://new2.ctx")
+          end
+          
+          it "should add triple to default context" do
+            subject.add(@triple, nil)
+            found = false
+            subject.triples(@triple, nil) do |triple, context|
+              @triple.should == @triple
+              context.should == @identifier
+              found = true
+            end
+            found.should be_true
+          end
+          
+          it "should add to multiple contexts" do
+            subject.add(@triple, @ctx1)
+            subject.add(@triple, @ctx2)
+            subject.triples(@triple, @ctx1).length.should == 1
+            subject.triples(@triple, @ctx2).length.should == 1
+            found = 0
+            subject.triples(@triple, nil) do |triple, context|
+              found += 1
+            end
+            found.should == 2
+          end
+          
+          it "should remove from specific context" do
+            subject.add(@triple, @ctx1)
+            subject.add(@triple, @ctx2)
+            subject.remove(@triple, @ctx1)
+            subject.triples(@triple, @ctx1).length.should == 0
+            subject.triples(@triple, @ctx2).length.should == 1
+            found = 0
+            subject.triples(@triple, nil) do |triple, context|
+              found += 1
+            end
+            found.should == 1
+          end
+          
+          it "should remove from multiple contexts" do
+            subject.add(@triple, @ctx1)
+            subject.add(@triple, @ctx2)
+            subject.remove(@triple, nil)
+            subject.triples(@triple, @ctx1).length.should == 0
+            subject.triples(@triple, @ctx2).length.should == 0
+            found = 0
+            subject.triples(@triple, nil) do |triple, context|
+              found += 1
+            end
+            found.should == 0
+          end
+
+          it "should remove context" do
+            subject.add(@triple, @ctx1)
+            subject.add(@triple, @ctx2)
+            #subject.dump
+            subject.remove(Triple.new(nil, nil, nil), @ctx2)
+            subject.contexts.should_not include(@ctx2)
+            #subject.dump
+            subject.triples(@triple, @ctx1).length.should == 1
+            subject.triples(@triple, @ctx2).length.should == 0
+          end
+
+        end
+      end
+    end
+  end
+end

data/spec/string_hacks_spec.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe "String RDF encoding" do
+  {
+    "Gregg" => 'Gregg',
+    "Dürst" => 'D\u00FCrst',
+    "simple literal"  => 'simple literal',
+    "backslash:\\" => 'backslash:\\\\',
+    "dquote:\"" => 'dquote:\\"',
+    "newline:\n" => 'newline:\\n',
+    "return:\r" => 'return:\\r',
+    "tab:\t" => 'tab:\\t',
+  }.each_pair do |raw, encoded|
+    specify "'#{raw}' should escape to '#{encoded}'" do
+      raw.rdf_escape.should == encoded
+    end
+
+    specify "'#{encoded}' should unescape to '#{raw}'" do
+      encoded.rdf_unescape.should == raw
+    end
+  end
+end

data/spec/triple_spec.rb

@@ -0,0 +1,172 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Triples" do
+  before(:all) { @graph = Graph.new(:store => ListStore.new) }
+  it "should require that the subject is a URIRef or BNode" do
+   lambda do
+     Triple.new(Literal.new("foo"), URIRef.new("http://xmlns.com/foaf/0.1/knows"), BNode.new)
+    end.should raise_error
+  end
+
+  it "should require that the predicate is a URIRef" do
+    lambda do
+      Triple.new(BNode.new, BNode.new, BNode.new)
+    end.should raise_error
+  end
+
+  it "should require that the object is a URIRef, BNode, Literal or Typed Literal" do
+    lambda do
+      Triple.new(BNode.new, URIRef.new("http://xmlns.com/foaf/0.1/knows"), [])
+    end.should raise_error
+  end
+
+  describe "with BNodes" do
+    subject do
+      Triple.new(BNode.new, URIRef.new('http://xmlns.com/foaf/0.1/knows'), BNode.new)
+    end
+
+    it "should have a subject" do
+      subject.subject.class.should == BNode
+    end
+    
+    it "should emit an NTriple" do
+      subject.to_ntriples.should == "#{subject.subject.to_n3} <http://xmlns.com/foaf/0.1/knows> #{subject.object.to_n3} ."
+    end
+  end
+
+  describe "with URIRefs" do
+    subject {
+      s = URIRef.new("http://tommorris.org/foaf#me")
+      p = URIRef.new("http://xmlns.com/foaf/0.1/name")
+      o = Literal.untyped("Tom Morris")
+      Triple.new(s,p,o)
+    }
+
+    it "should emit an NTriple" do
+      subject.to_ntriples.should == "<http://tommorris.org/foaf#me> <http://xmlns.com/foaf/0.1/name> \"Tom Morris\" ."
+    end
+  end
+
+  describe "with coerced subject" do
+    it "should accept a URIRef" do
+      ref = URIRef.new('http://localhost/')
+      Triple.coerce_subject(ref).should == ref
+    end
+
+    it "should accept a BNode" do
+      node = BNode.new('a')
+      Triple.coerce_subject(node).should == node
+    end
+
+    it "should accept a uri string and make URIRef" do
+      Triple.coerce_subject('http://localhost/').should == URIRef.new('http://localhost/')
+    end
+    
+    it "should accept an Addressable::URI object and make URIRef" do
+      Triple.coerce_subject(Addressable::URI.parse("http://localhost/")).should == URIRef.new("http://localhost/")
+    end
+    
+    it "should raise an InvalidSubject exception with any other class argument" do
+      lambda do
+        Triple.coerce_subject(Object.new)
+      end.should raise_error(Triple::InvalidSubject)
+    end
+  end
+
+  describe "with coerced predicate" do
+    it "should make a string into a URI ref" do
+      Triple.coerce_predicate("http://localhost/").should == URIRef.new('http://localhost/')
+    end
+
+    it "should leave a URIRef alone" do
+      ref = URIRef.new('http://localhost/')
+      Triple.coerce_predicate(ref).should == ref
+    end
+
+    it "should barf on an illegal uri string" do
+      lambda do
+        Triple.coerce_predicate("I'm just a soul whose intention is good")
+      end.should raise_error(InvalidPredicate)
+    end
+  end
+
+  describe "with coerced object" do
+    it "should leave URIRefs alone" do
+      ref = URIRef.new("http://localhost/")
+      Triple.coerce_object(ref).should == ref
+    end
+    
+    it "should accept an Addressable::URI object and make URIRef" do
+      Triple.coerce_object(Addressable::URI.parse("http://localhost/")).should == URIRef.new("http://localhost/")
+    end
+    
+    it "should leave BNodes alone" do
+      ref = BNode.new()
+      Triple.coerce_object(ref).should == ref
+    end
+    
+    it "should leave Literals alone" do
+      ref = Literal.untyped('foo')
+      Triple.coerce_object(ref).should == ref
+      
+      typedref = Literal.build_from('foo')
+      Triple.coerce_object(ref).should == ref
+    end
+    
+  end
+  
+  describe "with wildcards" do
+    it "should accept nil" do
+      t = Triple.new(nil, nil, nil)
+      t.is_patern?.should be_true
+    end
+  end
+  
+  describe "equivalence" do
+    before(:all) do
+      @test_cases = [
+        Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),URIRef.new("http://baz")),
+        Triple.new(URIRef.new("http://foo"),URIRef.new("http://bar"),Literal.untyped("baz")),
+        Triple.new(URIRef.new("http://foo"),"http://bar",Literal.untyped("baz")),
+        Triple.new(BNode.new("foo"),URIRef.new("http://bar"),Literal.untyped("baz")),
+        Triple.new(BNode.new,URIRef.new("http://bar"),Literal.untyped("baz")),
+      ]
+    end
+    it "should be equal to itself" do
+      @test_cases.each {|triple| triple.should == triple}
+    end
+
+    it "should not be equal to something else" do
+      t = Triple.new(URIRef.new("http://fab"),URIRef.new("http://bar"),URIRef.new("http://baz")),
+      @test_cases.each {|triple| triple.should_not == t}
+    end
+
+    it "should be equal to equivalent" do
+      @test_cases.each do |triple|
+        t = Triple.new(triple.subject, triple.predicate, triple.object)
+        triple.should == t
+      end
+    end
+    
+    it "should be equal to paterns" do
+      @test_cases.each do |triple|
+        [
+          Triple.new(triple.subject, triple.predicate, triple.object),
+
+          Triple.new(nil, triple.predicate, triple.object),
+          Triple.new(triple.subject, nil, triple.object),
+          Triple.new(triple.subject, triple.predicate, nil),
+
+          Triple.new(nil, nil, triple.object),
+          Triple.new(triple.subject, nil, nil),
+          Triple.new(nil, triple.predicate, nil),
+
+          Triple.new(nil, nil, nil),
+        ].each do |t|
+          triple.should == t
+          t.should == triple
+        end
+      end
+    end
+  end
+end

data/spec/uriref_spec.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'webrick'
+include WEBrick
+#require 'lib/uriref'
+
+describe "URI References" do
+  it "should output NTriples" do
+    f = URIRef.new("http://tommorris.org/foaf/")
+    f.to_ntriples.should == "<http://tommorris.org/foaf/>"
+  end
+  
+  it "should handle Unicode symbols inside URLs" do
+    lambda do
+      f = URIRef.new("http://example.org/#Andr%E9")
+    end.should_not raise_error
+  end
+  
+  # it "do not contain any control characters (#x00 - #x1F, #x74-#x9F)" do
+  #   lambda do
+  #     f = URIRef.new("http://tommorris.org/blog/")
+  #     f.test_string("http://tommorris.org/blog")
+  #   end.should_not raise_error
+  #   
+  #   lambda do
+  #     f = URIRef.new("http://xmlns.com/foaf/0.1/knows")
+  #     f.test_string("http://xmlns.com/foaf/0.1/knows")
+  #   end.should_not raise_error
+  # end
+  
+  it "should return the 'last fragment' name" do
+    fragment = URIRef.new("http://example.org/foo#bar")
+    fragment.short_name.should == "bar"
+    
+    path = URIRef.new("http://example.org/foo/bar")
+    path.short_name.should == "bar"
+    
+    nonetest = URIRef.new("http://example.org/")
+    nonetest.short_name.should == false
+  end
+  
+  it "should append fragment to uri" do
+    URIRef.new("foo", "http://example.org").should == "http://example.org/foo"
+  end
+  
+  it "should produce a valid URI character sequence (per RFC 2396 §2.1) representing an absolute URI with optional fragment identifier" do
+    pending "TODO: figure out a series of tests for RFC 2396 §2.1 adherence"
+  end
+  
+  it "should throw errors on suspicious protocols and non-protocols" do
+    lambda do
+      URIRef.new("javascript:alert(\"pass\")")
+    end.should raise_error
+  end
+  
+  it "must not be a relative URI" do
+    lambda do
+      URIRef.new("foo")
+    end.should raise_error
+  end
+  
+  it "should discourage use of %-escaped characters" do
+    pending "TODO: figure out a way to discourage %-escaped character usage"
+  end
+  
+  it "should allow another URIRef to be added" do
+    uri = URIRef.new("http://example.org/") + "foo#bar"
+    uri.to_s.should == "http://example.org/foo#bar"
+    uri.class.should == URIRef
+    
+    uri2 = URIRef.new("http://example.org/") + Addressable::URI.parse("foo#bar")
+    uri2.to_s.should == "http://example.org/foo#bar"
+  end
+
+  it "should create QName from URI with namespace" do
+    uri = URIRef.new("http://example.org/foo#bar")
+    uri.to_qname("http://example.org/foo#" => "ex").should == "ex:bar"
+    
+    uri = URIRef.new("http://xmlns.com/foaf/0.1/knows")
+    uri.to_qname("http://xmlns.com/foaf/0.1/" => "foaf").should == "foaf:knows"
+  end
+  
+  it "should create resource hash for RDF/XML" do
+    uri = URIRef.new("http://example.org/foo#bar")
+    uri.xml_args.should == [{"rdf:resource" => uri.to_s}]
+  end
+  
+  it "should be equivalent to string" do
+    URIRef.new("http://example.org/foo#bar").should == "http://example.org/foo#bar"
+  end
+  
+#   TEST turned off until parser is working.  
+#   it "should allow the programmer to Follow His Nose" do
+#     a = URIRef.new("http://127.0.0.1:3001/test")
+#     
+#     # server
+#     test_proc = lambda { |req, resp|
+#       resp['Content-Type'] = "application/rdf+xml"
+#       resp.body = <<-EOF;
+# <?xml version="1.0" ?>
+# <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:foaf="http://xmlns.com/foaf/0.1/">
+#   <rdf:Description rdf:about="http://localhost:3001/test">
+#     <foaf:name>Testy McTest</foaf:name>
+#   </rdf:Description>
+# </rdf:RDF>
+#       EOF
+#     }
+#     test = HTTPServlet::ProcHandler.new(test_proc)
+#     s = HTTPServer.new(:Port => 3001)
+#     s.mount("/test", test)
+#     trap("INT"){ s.shutdown }
+#     thread = Thread.new { s.start }
+#     graph = a.load_graph
+#     s.shutdown
+#     graph.class.should == Reddy::Graph
+#     graph.size.should == 1
+#   end
+end