Class: Transaction::Simple::Group

Class | Transaction::Simple::Group
In: | lib/transaction/simple/group.rb
Parent: | Object

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."

### Methods

abort_transaction clear commit_transaction new rewind_transaction start_transaction transaction transaction_name transaction_open?

### Attributes

objects | [R] | Returns the objects that are covered by this transaction group.

### Public Class methods

new(*objects) {|self| ...}

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.

### Public Instance methods

abort_transaction(name = nil)

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`.

clear()

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

commit_transaction(name = nil)

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.

rewind_transaction(name = nil)

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.

start_transaction(name = nil)

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.

transaction(action = nil, name = nil)

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?

transaction_name()

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

transaction_open?(name = nil)

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

[Validate]