Use new RDF.rb transaction support instead of iterating twice.

Author: gkellogg

lib/ld/patch/algebra/patch.rb

@@ -10,31 +10,25 @@ class Patch < SPARQL::Algebra::Operator
     NAME = :patch
 
     ##
-    # Executes this upate on the given `writable` graph or repository.
+    # Executes this upate on the given `repository`.
     #
-    # @param  [RDF::Queryable] queryable
-    #   the graph or repository to write
+    # @param  [RDF::Repository] repository
+    #   the repository to update.
     # @param  [Hash{Symbol => Object}] options
     #   any additional options
-    # @return [RDF::Queryable]
-    #   Returns queryable.
+    # @return [RDF::Repository]
+    #   Returns repository.
     # @raise [Error]
     #   If any error is caught along the way, and rolls back the transaction
-    def execute(queryable, options = {})
+    def execute(repository, options = {})
       debug(options) {"Delete"}
 
-      # FIXME: due to insufficient transaction support, this is implemented by running through operands twice: the first using a clone of the graph, and the second acting on the graph directly
-      graph = RDF::Graph.new << queryable
-      loop do
+      repository.transaction(mutable: true) do |tx|
         operands.inject(RDF::Query::Solutions.new([RDF::Query::Solution.new])) do |bindings, op|
           # Invoke operand using bindings from prvious operation
-          op.execute(graph, options.merge(bindings: bindings))
+          op.execute(tx, options.merge(bindings: bindings))
         end
-
-        break if graph.equal?(queryable)
-        graph = queryable
       end
-      queryable
     end
   end
 end

spec/algebra_spec.rb

@@ -418,9 +418,9 @@
       },
     }.each do |name, props|
       it name do
-        graph = RDF::Graph.new << RDF::NTriples::Reader.new(props[:data])
+        graph = RDF::Repository.new << RDF::NTriples::Reader.new(props[:data])
         operator = LD::Patch::Parser.new(props[:patch]).parse
-        result = RDF::Graph.new << RDF::NTriples::Reader.new(props[:result])
+        result = RDF::Repository.new << RDF::NTriples::Reader.new(props[:result])
         operator.execute(graph)
         expect(graph).to be_equivalent_graph(result)
       end
@@ -469,7 +469,7 @@
       },
     }.each do |name, props|
       it name do
-        graph = RDF::Graph.new << RDF::NTriples::Reader.new(props[:data])
+        graph = RDF::Repository.new << RDF::NTriples::Reader.new(props[:data])
         operator = LD::Patch::Parser.new(props[:patch]).parse
         expect {operator.execute(graph)}.to raise_error(LD::Patch::Error)
       end

spec/suite_helper.rb

@@ -150,15 +150,15 @@ def data
       end
 
       def target_graph
-        @graph ||= RDF::Graph.load(URI.decode(data), base_uri: base)
+        @graph ||= RDF::Repository.load(URI.decode(data), base_uri: base)
       end
 
       def expected
         @expected ||= RDF::Util::File.open_file(URI.decode(result)) {|f| f.read}
       end
 
       def expected_graph
-        @expected_graph ||= RDF::Graph.load(URI.decode(result), base_uri: base)
+        @expected_graph ||= RDF::Repository.load(URI.decode(result), base_uri: base)
       end
 
       def evaluate?