Support using graph_name in addition to (as eventual replacement for) context.

gkellogg · gkellogg · commit 0d7b9f3fd77e · 2015-10-12T20:14:16.000-07:00
diff --git a/lib/rdf/spec/enumerable.rb b/lib/rdf/spec/enumerable.rb
@@ -19,7 +19,7 @@
       end
     end
 
-    @supports_context = enumerable.supports?(:context) rescue true
+    @supports_named_graphs = enumerable.supports?(:graph_name) rescue true
   end
 
   let(:subject_count) {@statements.map(&:subject).uniq.length}
@@ -82,19 +82,19 @@
     it {is_expected.to respond_to(:has_statement?)}
     context "#has_statement?" do
       let(:unknown_statement) {RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)}
-      it "is_expected.to have all statements" do
+      it "should have all statements" do
         # Don't check for BNodes, as equivalence depends on their being exactly the same, not just the same identifier. If subject is loaded separately, these won't match.
         non_bnode_statements.each do |statement|
           is_expected.to have_statement(statement)
         end
       end
 
-      it "does not have statement in different context" do
-        if @supports_context
-          context = RDF::URI.new("urn:context:1")
+      it "does not have statement in different named graph" do
+        if @supports_named_graphs
+          graph_name = RDF::URI.new("urn:graph_name:1")
           non_bnode_statements.each do |statement|
             s = statement.dup
-            s.context = context
+            s.graph_name = graph_name
             is_expected.not_to have_statement(s)
           end
         end
@@ -115,7 +115,7 @@
     its(:enum_statement) {is_expected.to be_enumerable}
     its(:enum_statement) {is_expected.to be_queryable}
     context "#enum_statement" do
-      it "is_expected.to enumerate all statements" do
+      it "should enumerate all statements" do
         expect(subject.enum_statement.count).to eq enumerable.each_statement.count
         subject.enum_statement.each do |s|
           expect(s).to be_a_statement
@@ -148,7 +148,7 @@
     its(:each_triple) {is_expected.to be_an_enumerator}
     context "#each_triple" do
       specify {expect(subject.each_triple).to all(be_a_triple)}
-      it "is_expected.to iterate over all triples" do
+      it "should iterate over all triples" do
         subject.each_triple do |*triple|
           expect(triple.each).to all(be_a_term)
           expect(enumerable).to have_triple(triple) unless triple.any?(&:node?)
@@ -159,7 +159,7 @@
     its(:enum_triple) {is_expected.to be_an_enumerator}
     its(:enum_triple) {is_expected.to be_countable}
     context "#enum_triple" do
-      it "is_expected.to enumerate all triples" do
+      it "should enumerate all triples" do
         expect(subject.enum_triple.count).to eq enumerable.each_triple.count
         subject.enum_triple.each do |s, p, o|
           expect([s, p, o]).to all(be_a_term)
@@ -183,7 +183,7 @@
 
     context "#has_quad?" do
       specify do
-        if @supports_context
+        if @supports_named_graphs
           non_bnode_statements.each do |statement|
             is_expected.to have_quad(statement.to_quad)
           end
@@ -194,7 +194,7 @@
     its(:each_quad) {is_expected.to be_an_enumerator}
     context "#each_quad" do
       specify {expect(subject.each_quad).to all(be_a_quad)}
-      it "is_expected.to iterate over all quads" do
+      it "should iterate over all quads" do
         subject.each_quad do |*quad|
           expect(quad.compact).to all(be_a_term)
           expect(enumerable).to have_quad(quad) unless quad.compact.any?(&:node?)
@@ -205,7 +205,7 @@
     its(:enum_quad) {is_expected.to be_an_enumerator}
     its(:enum_quad) {is_expected.to be_countable}
     context "#enum_quad" do
-      it "is_expected.to enumerate all quads" do
+      it "should enumerate all quads" do
         expect(subject.enum_quad.count).to eq enumerable.each_quad.count
         subject.enum_quad.each do |s, p, o, c|
           expect([s, p, o, c].compact).to all(be_a_term)
@@ -257,7 +257,7 @@
     its(:enum_subject) {is_expected.to be_countable}
     context "#enum_subject" do
       specify {expect(subject.enum_subject.to_a.reject(&:node?).size).to eq subjects.reject(&:node?).size}
-      it "is_expected.to enumerate all subjects" do
+      it "should enumerate all subjects" do
         subject.enum_subject.each do |s|
           expect(s).to be_a_resource
           expect(subjects.to_a).to include(s) unless s.node?
@@ -307,7 +307,7 @@
     its(:enum_predicate) {is_expected.to be_an_enumerator}
     its(:enum_predicate) {is_expected.to be_countable}
     context "#enum_predicate" do
-      it "is_expected.to enumerate all predicates" do
+      it "should enumerate all predicates" do
         expect(subject.enum_predicate.to_a).to include(*predicates)
       end
     end
@@ -354,7 +354,7 @@
     its(:enum_object) {is_expected.to be_an_enumerator}
     its(:enum_object) {is_expected.to be_countable}
     context "#enum_object" do
-      it "is_expected.to enumerate all objects" do
+      it "should enumerate all objects" do
         subject.enum_object.each do |o|
           expect(o).to be_a_term
           expect(objects.to_a).to include(o) unless o.node?
@@ -374,15 +374,15 @@
       subject { enumerable.contexts }
       specify {is_expected.to be_an_enumerator}
       specify {is_expected.to all(be_a_resource)}
-      context ":unique => false" do
+      context "unique: false" do
         subject { enumerable.contexts(:unique => false) }
         specify {is_expected.to be_an_enumerator}
         specify {is_expected.to all(be_a_resource)}
       end
     end
 
     it "is_expected.to implement #has_context?" do
-      if @supports_context
+      if @supports_named_graphs
         @statements.each do |statement|
           if statement.has_context?
             expect(enumerable).to have_context(statement.context)
@@ -397,7 +397,7 @@
     context "#each_context" do
       let(:contexts) {@statements.map { |s| s.context }.uniq.compact}
       it "has appropriate number of contexts" do
-        if @supports_context
+        if @supports_named_graphs
           expect(subject.each_context.to_a.size).to eq contexts.size
         end
       end
@@ -410,7 +410,7 @@
     its(:enum_context) {is_expected.to be_an_enumerator}
     its(:enum_context) {is_expected.to be_countable}
     context "#enum_context" do
-      it "is_expected.to enumerate all contexts" do
+      it "should enumerate all contexts" do
         expect(subject.enum_context.to_a).to include(*enumerable.each_context.to_a)
       end
     end
@@ -436,11 +436,63 @@
     end
   end
 
+  context "when enumerating graphs" do
+    it {is_expected.to respond_to(:graph_names)}
+    it {is_expected.to respond_to(:has_graph?)}
+    it {is_expected.to respond_to(:each_graph)}
+    it {is_expected.to respond_to(:enum_graph)}
+
+    its(:graph_names) {is_expected.to be_a(Array)}
+    describe "#graph_names" do
+      subject { enumerable.graph_names }
+      specify {is_expected.to be_a(Array)}
+      specify {is_expected.to all(be_a_resource)}
+      context ":unique => false" do
+        subject { enumerable.graph_names(:unique => false) }
+        specify {is_expected.to be_a(Array)}
+        specify {is_expected.to all(be_a_resource)}
+      end
+    end
+
+    it "should implement #has_graph?" do
+      if @supports_named_graphs
+        @statements.each do |statement|
+          if statement.has_graph?
+            expect(enumerable).to have_graph(statement.graph_name)
+          end
+        end
+        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+        expect(enumerable).not_to have_graph(uri)
+      end
+    end
+
+    its(:each_graph) {is_expected.to be_an_enumerator}
+
+    describe "#each_graph" do
+      let(:graph_names) {@statements.map { |s| s.graph_name }.uniq.compact}
+      subject { enumerable.each_graph }
+      it {is_expected.to be_an_enumerator}
+      specify {expect(subject.each_graph).to all(be_a_graph)}
+      it "has appropriate number of graphs" do
+        expect(subject.each_graph.to_a.size).to eq (graph_names.size + 1)
+      end if @supports_named_graphs
+    end
+
+    describe "#enum_graph" do
+      subject { enumerable.enum_graph }
+      it {is_expected.to be_an_enumerator}
+      it {is_expected.to be_countable}
+      it "enumerates the same as #each_graph" do
+        expect(subject.to_a).to include(*enumerable.each_graph.to_a)
+      end if @supports_named_graphs # expect with match problematic
+    end
+  end
+
   context "when converting" do
     it {is_expected.to respond_to(:to_hash)}
     its(:to_hash) {is_expected.to be_instance_of(Hash)}
     context "#to_hash" do
-      it "is_expected.to have as many keys as subjects" do
+      it "should have as many keys as subjects" do
         expect(subject.to_hash.keys.size).to eq enumerable.subjects.to_a.size
       end
     end
@@ -449,7 +501,7 @@
   context "when dumping" do
     it {is_expected.to respond_to(:dump)}
 
-    it "is_expected.to implement #dump" do
+    it "should implement #dump" do
       expect(subject.dump(:ntriples)).to eq RDF::NTriples::Writer.buffer() {|w| w << enumerable}
     end
 
diff --git a/lib/rdf/spec/mutable.rb b/lib/rdf/spec/mutable.rb
@@ -8,11 +8,11 @@
     raise 'mutable must be defined with let(:mutable)' unless
       defined? mutable
 
-    @supports_context = mutable.respond_to?(:supports?) && mutable.supports?(:context)
+    @supports_named_graphs = mutable.respond_to?(:supports?) && mutable.supports?(:graph_name)
   end
 
   let(:resource) { RDF::URI('http://rubygems.org/gems/rdf') }
-  let(:context) { RDF::URI('http://example.org/context') }
+  let(:graph_name) { RDF::URI('http://example.org/graph_name') }
 
   describe RDF::Mutable do
     subject { mutable }
@@ -65,10 +65,17 @@
       end
 
       it "is_expected.to load statements with a context override" do
-        skip("mutability and contextuality") unless (subject.mutable? && @supports_context)
-        subject.load RDF::Spec::TRIPLES_FILE, :context => context
-        is_expected.to have_context(context)
-        expect(subject.query(:context => context).size).to eq subject.size
+        skip("mutability and contextuality") unless (subject.mutable? && @supports_named_graphs)
+        subject.load RDF::Spec::TRIPLES_FILE, context: graph_name
+        is_expected.to have_context(graph_name)
+        expect(subject.query(context: graph_name).size).to eq subject.size
+      end
+
+      it "is_expected.to load statements with a graph_name override" do
+        skip("mutability and contextuality") unless (subject.mutable? && @supports_named_graphs)
+        subject.load RDF::Spec::TRIPLES_FILE, graph_name: graph_name
+        is_expected.to have_graph(graph_name)
+        expect(subject.query(graph_name: graph_name).size).to eq subject.size
       end
     end
 
@@ -119,27 +126,27 @@
         is_expected.to be_empty
       end
 
-      it "is_expected.to only delete statements when the context matches" do
+      it "is_expected.to only delete statements when the graph_name matches" do
         skip("mutability") unless subject.mutable?
-        # Setup three statements identical except for context
-        count = subject.count + (@supports_context ? 3 : 1)
+        # Setup three statements identical except for graph_name
+        count = subject.count + (@supports_named_graphs ? 3 : 1)
         s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
         s2 = s1.dup
-        s2.context = RDF::URI.new("urn:context:1")
+        s2.graph_name = RDF::URI.new("urn:graph_name:1")
         s3 = s1.dup
-        s3.context = RDF::URI.new("urn:context:2")
+        s3.graph_name = RDF::URI.new("urn:graph_name:2")
         subject.insert(s1)
         subject.insert(s2)
         subject.insert(s3)
         expect(subject.count).to eq count
 
         # Delete one by one
         subject.delete(s1)
-        expect(subject.count).to eq count - (@supports_context ? 1 : 1)
+        expect(subject.count).to eq count - (@supports_named_graphs ? 1 : 1)
         subject.delete(s2)
-        expect(subject.count).to eq count - (@supports_context ? 2 : 1)
+        expect(subject.count).to eq count - (@supports_named_graphs ? 2 : 1)
         subject.delete(s3)
-        expect(subject.count).to eq count - (@supports_context ? 3 : 1)
+        expect(subject.count).to eq count - (@supports_named_graphs ? 3 : 1)
       end
     end
   end
diff --git a/lib/rdf/spec/queryable.rb b/lib/rdf/spec/queryable.rb
@@ -320,6 +320,42 @@
             end
           end
         end
+
+        context "with graph_name" do
+          it "returns statements from all graphs with no graph_name" do
+            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: nil)
+            solutions = []
+            subject.send(:query_pattern, pattern) {|s| solutions << s}
+            expect(solutions.size).to eq @statements.size
+          end
+
+          it "returns statements from unnamed graphss with false graph_name" do
+            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: false)
+            solutions = []
+            subject.send(:query_pattern, pattern) {|s| solutions << s}
+            named_statements = subject.statements.reject {|st| st.has_name?}.length
+            expect(solutions.size).to eq named_statements
+          end
+
+          it "returns statements from named graphss with variable graph_name" do
+            unless subject.graph_names.to_a.empty?
+              pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: :c)
+              solutions = []
+              subject.send(:query_pattern, pattern) {|s| solutions << s}
+              named_statements = subject.statements.select {|st| st.has_name?}.length
+              expect(solutions.size).to eq named_statements
+            end
+          end
+
+          it "returns statements from specific graph with URI graph_name" do
+            unless subject.graph_names.to_a.empty?
+              pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: RDF::URI("http://ar.to/#self"))
+              solutions = []
+              subject.send(:query_pattern, pattern) {|s| solutions << s}
+              expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+            end
+          end
+        end
       end
     end
 
@@ -328,7 +364,7 @@
     describe "#first" do
       let(:failing_pattern) {[RDF::URI("http://no-such-resource"), RDF.type, RDF::Node.new]}
 
-      it "is_expected.to respond to #first" do
+      it "should respond to #first" do
         is_expected.to respond_to(:first)
       end
 
@@ -360,7 +396,7 @@
     describe "#first_subject" do
       let(:failing_pattern) {[RDF::URI("http://no-such-resource"), nil, nil]}
 
-      it "is_expected.to respond to #first_subject" do
+      it "should respond to #first_subject" do
         is_expected.to respond_to(:first_subject)
       end
 
diff --git a/lib/rdf/spec/transaction.rb b/lib/rdf/spec/transaction.rb
@@ -6,7 +6,7 @@
 shared_examples "an RDF::Transaction" do |klass|
   include RDF::Spec::Matchers
 
-  subject {klass.new(:context => RDF::URI("name"), :insert => RDF::Graph.new, :delete => RDF::Graph.new)}
+  subject {klass.new(graph_name: RDF::URI("name"), inser: RDF::Graph.new, delete: RDF::Graph.new)}
 
   describe "#initialize" do
     subject {klass}
@@ -27,6 +27,17 @@
       expect(this.context).to eq c
     end
 
+    it "accepts a graph_name" do
+      c = double("graph_name")
+      this = subject.new(:graph => c)
+      expect(this.graph).to eq c
+      expect(this.graph_name).to eq c
+
+      this = subject.new(:graph_name => c)
+      expect(this.graph).to eq c
+      expect(this.graph_name).to eq c
+    end
+
     it "accepts inserts" do
       g = double("inserts")
       this = subject.new(:insert => g)
diff --git a/lib/rdf/spec/writable.rb b/lib/rdf/spec/writable.rb
