Add wrap_transaction keyword parameter to RDF::List#initialize.

For #417.

Author: gkellogg

lib/rdf/model/list.rb

@@ -49,14 +49,23 @@ def self.[](*values)
     #     g = RDF::Graph.new << l
     #     g.count # => l.count
     #
+    # @example use a transaction for block initialization
+    #     l = RDF::List(graph: graph, wrap_transaction: true) do |list|
+    #       list << RDF::Literal(1)
+    #       # list.graph.rollback will rollback all list changes within this block.
+    #     end
+    #     list.count #=> 1
+    #
     # @param  [RDF::Resource]         subject (RDF.nil)
     #   Subject should be an {RDF::Node}, not a {RDF::URI}. A list with an IRI head will not validate, but is commonly used to detect if a list is valid.
     # @param  [RDF::Graph]        graph (RDF::Graph.new)
     # @param  [Array<RDF::Term>]  values
     #   Any values which are not terms are coerced to `RDF::Literal`.
+    # @param [Boolean] wrap_transaction (false)
+    #   Wraps the callback in a transaction, and replaces the graph with that transaction for the duraction of the callback. This has the effect of allowing any list changes to be made atomically, or rolled back.
     # @yield  [list]
     # @yieldparam [RDF::List] list
-    def initialize(subject: nil, graph: nil, values: nil, &block)
+    def initialize(subject: nil, graph: nil, values: nil, wrap_transaction: false, &block)
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
       is_empty = @graph.query({subject: subject, predicate: RDF.first}).empty?
@@ -78,9 +87,25 @@ def initialize(subject: nil, graph: nil, values: nil, &block)
       end
 
       if block_given?
-        case block.arity
-          when 1 then block.call(self)
-          else instance_eval(&block)
+        if wrap_transaction
+          old_graph = @graph
+          begin
+            Transaction.begin(@graph, graph_name: @graph.graph_name, mutable: @graph.mutable?) do |trans|
+              @graph = trans
+              case block.arity
+                when 1 then block.call(self)
+                else instance_eval(&block)
+              end
+              trans.execute if trans.mutated?
+            end
+          ensure
+            @graph = old_graph
+          end
+        else
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
         end
       end
     end

spec/model_list_spec.rb

@@ -148,6 +148,48 @@
           described_class.new(RDF::Node.new, graph)
         }.to raise_error ArgumentError
       end
+
+      it "adds values to graph" do
+        n = RDF::Node.new
+        l = RDF::List.new(subject: n, graph: graph, values: [RDF::Literal(1), RDF::Literal(2)])
+        expect(l.to_a).to include(RDF::Literal(1), RDF::Literal(2))
+        expect(graph.first_object(subject: n, predicate: RDF.first)).to eql(RDF::Literal(1))
+      end
+
+      it "yields itself" do
+        expect {|b| described_class.new(&b)}.to yield_with_args(RDF::List)
+      end
+
+      context :with_transaction do
+        it "uses a transaction for the graph" do
+          n = RDF::Node.new
+          l = RDF::List.new(subject: n, graph: graph, wrap_transaction: true) do |list|
+            expect(list.graph).to be_a(RDF::Transaction)
+            expect(list.graph).not_to equal graph
+          end
+        end
+
+        it "adds values in a transaction" do
+          n = RDF::Node.new
+          l = RDF::List.new(graph: graph, wrap_transaction: true) do |list|
+            list << RDF::Literal(1)
+            expect(graph.first_object(subject: list.subject, predicate: RDF.first)).to be_nil
+          end
+          expect(graph.first_object(subject: l.subject, predicate: RDF.first)).to eql RDF::Literal(1)
+          expect(l.to_a).to include(RDF::Literal(1))
+        end
+
+        it "rollback added values in a transaction" do
+          n = RDF::Node.new
+          l = RDF::List.new(graph: graph, wrap_transaction: true) do |list|
+            list << RDF::Literal(1)
+            expect(graph.first_object(subject: list.subject, predicate: RDF.first)).to be_nil
+            list.graph.rollback
+          end
+          expect(graph.first_object(subject: l.subject, predicate: RDF.first)).to be_nil
+          expect(l.to_a).to be_empty
+        end
+      end
     end
   end