Class: Transaction::Simple::Group

Inherits:
Object
  • Object
show all
Defined in:
lib/transaction/simple/group.rb

Overview

A transaction group is an object wrapper that manages a group of objects as if they were a single object for the purpose of transaction management. All transactions for this group of objects should be performed against the transaction group object, not against individual objects in the group.

Transaction Group Usage

require 'transaction/simple/group'

x = "Hello, you."
y = "And you, too."

g = Transaction::Simple::Group.new(x, y)
g.start_transaction(:first)     # -> [ x, y ]
g.transaction_open?(:first)     # -> true
x.transaction_open?(:first)     # -> true
y.transaction_open?(:first)     # -> true

x.gsub!(/you/, "world")         # -> "Hello, world."
y.gsub!(/you/, "me")            # -> "And me, too."

g.start_transaction(:second)    # -> [ x, y ]
x.gsub!(/world/, "HAL")         # -> "Hello, HAL."
y.gsub!(/me/, "Dave")           # -> "And Dave, too."
g.rewind_transaction(:second)   # -> [ x, y ]
x                               # -> "Hello, world."
y                               # -> "And me, too."

x.gsub!(/world/, "HAL")         # -> "Hello, HAL."
y.gsub!(/me/, "Dave")           # -> "And Dave, too."

g.commit_transaction(:second)   # -> [ x, y ]
x                               # -> "Hello, HAL."
y                               # -> "And Dave, too."

g.abort_transaction(:first)     # -> [ x, y ]
x                               = -> "Hello, you."
y                               = -> "And you, too."

Direct Known Subclasses

ThreadSafe::Group

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*objects) ⇒ Group

Creates a transaction group for the provided objects. If a block is provided, the transaction group object is yielded to the block; when the block is finished, the transaction group object will be cleared with #clear.



59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/transaction/simple/group.rb', line 59

def initialize(*objects)
  @objects = objects || []
  @objects.freeze
  @objects.each { |obj| obj.extend(Transaction::Simple) }

  if block_given?
    begin
      yield self
    ensure
      self.clear
    end
  end
end

Instance Attribute Details

#objects ⇒ Object (readonly)

Returns the objects that are covered by this transaction group.



74
75
76
 
# File 'lib/transaction/simple/group.rb', line 74

def objects
  @objects
end

Instance Method Details

#abort_transaction(name = nil) ⇒ Object

Aborts the transaction. Resets the object state to what it was before the transaction was started and closes the transaction. If name is specified, then the intervening transactions and the named transaction will be aborted. Otherwise, only the current transaction is aborted.

If the current or named transaction has been started by a block (Transaction::Simple.start), then the execution of the block will be halted with break self.



120
121
122
 
# File 'lib/transaction/simple/group.rb', line 120

def abort_transaction(name = nil)
  @objects.each { |obj| obj.abort_transaction(name) }
end

#clear ⇒ Object

Clears the object group. Removes references to the objects so that they can be garbage collected.



78
79
80
 
# File 'lib/transaction/simple/group.rb', line 78

def clear
  @objects = @objects.dup.clear
end

#commit_transaction(name = nil) ⇒ Object

If name is nil (default), the current transaction level is closed out and the changes are committed.

If name is specified and name is in the list of named transactions, then all transactions are closed and committed until the named transaction is reached.



130
131
132
 
# File 'lib/transaction/simple/group.rb', line 130

def commit_transaction(name = nil)
  @objects.each { |obj| obj.commit_transaction(name) }
end

#rewind_transaction(name = nil) ⇒ Object

Rewinds the transaction. If name is specified, then the intervening transactions will be aborted and the named transaction will be rewound. Otherwise, only the current transaction is rewound.



108
109
110
 
# File 'lib/transaction/simple/group.rb', line 108

def rewind_transaction(name = nil)
  @objects.each { |obj| obj.rewind_transaction(name) }
end

#start_transaction(name = nil) ⇒ Object

Starts a transaction for the group. Stores the current object state. If a transaction name is specified, the transaction will be named. Transaction names must be unique. Transaction names of nil will be treated as unnamed transactions.



101
102
103
 
# File 'lib/transaction/simple/group.rb', line 101

def start_transaction(name = nil)
  @objects.each { |obj| obj.start_transaction(name) }
end

#transaction(action = nil, name = nil) ⇒ Object

Alternative method for calling the transaction methods. An optional name can be specified for named transaction support.

#transaction(:start)

#start_transaction

#transaction(:rewind)

#rewind_transaction

#transaction(:abort)

#abort_transaction

#transaction(:commit)

#commit_transaction

#transaction(:name)

#transaction_name

#transaction

#transaction_open?



143
144
145
 
# File 'lib/transaction/simple/group.rb', line 143

def transaction(action = nil, name = nil)
  @objects.each { |obj| obj.transaction(action, name) }
end

#transaction_name ⇒ Object

Returns the current name of the transaction for the group. Transactions not explicitly named are named nil.



93
94
95
 
# File 'lib/transaction/simple/group.rb', line 93

def transaction_name
  @objects[0].transaction_name
end

#transaction_open?(name = nil) ⇒ Boolean

Tests to see if all of the objects in the group have an open transaction. See Transaction::Simple#transaction_open? for more information.

Returns:

  • (Boolean) 


85
86
87
88
89
 
# File 'lib/transaction/simple/group.rb', line 85

def transaction_open?(name = nil)
  @objects.inject(true) do |val, obj|
    val = val and obj.transaction_open?(name)
  end
end