Class: Transaction::Simple::Group

### Home Classes Methods

### In Files

- lib/transaction/simple/group.rb

### Parent

Object

### Methods

- ::new
- #abort_transaction
- #clear
- #commit_transaction
- #rewind_transaction
- #start_transaction
- #transaction
- #transaction_name
- #transaction_open?

### Files

- History.rdoc
- Manifest.txt
- README.rdoc

### Class/Module Index

Quicksearch

- Transaction
- Transaction::Simple
- Transaction::Simple::Group
- Transaction::Simple::ThreadSafe
- Transaction::Simple::ThreadSafe::Group
- Transaction::TransactionAborted
- Transaction::TransactionCommitted
- Transaction::TransactionError
- Transaction::TransactionThreadError

No matching classes.

# Transaction::Simple::Group

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

### Attributes

objects[R]

Returns the objects that are covered by this transaction group.

### Public Class Methods

new(*objects) click to toggle source

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.

    # File lib/transaction/simple/group.rb, line 46
    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

### Public Instance Methods

abort_transaction(name = nil) click to toggle source

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

    # File lib/transaction/simple/group.rb, line 107
    def abort_transaction(name = nil)
      @objects.each { |obj| obj.abort_transaction(name) }
    end

clear() click to toggle source

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

    # File lib/transaction/simple/group.rb, line 65
    def clear
      @objects = @objects.dup.clear
    end

commit_transaction(name = nil) click to toggle source

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.

    # File lib/transaction/simple/group.rb, line 117
    def commit_transaction(name = nil)
      @objects.each { |obj| obj.commit_transaction(name) }
    end

rewind_transaction(name = nil) click to toggle source

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.

    # File lib/transaction/simple/group.rb, line 95
    def rewind_transaction(name = nil)
      @objects.each { |obj| obj.rewind_transaction(name) }
    end

start_transaction(name = nil) click to toggle source

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.

    # File lib/transaction/simple/group.rb, line 88
    def start_transaction(name = nil)
      @objects.each { |obj| obj.start_transaction(name) }
    end

transaction(action = nil, name = nil) click to toggle source

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?

    # File lib/transaction/simple/group.rb, line 130
    def transaction(action = nil, name = nil)
      @objects.each { |obj| obj.transaction(action, name) }
    end

transaction_name() click to toggle source

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

    # File lib/transaction/simple/group.rb, line 80
    def transaction_name
      @objects[0].transaction_name
    end

transaction_open?(name = nil) click to toggle source

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

    # File lib/transaction/simple/group.rb, line 72
    def transaction_open?(name = nil)
      @objects.inject(true) do |val, obj|
        val = val and obj.transaction_open?(name)
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.