mack-pdf_writer 0.8.1 → 0.8.2

data/lib/gems/transaction-simple-1.4.0/lib/transaction/simple/group.rb

@@ -0,0 +1,146 @@
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: group.rb 47 2007-02-03 15:02:51Z austin $
+#++
+require 'transaction/simple'
+
+  # 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."
+class Transaction::Simple::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.
+  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
+
+    # Returns the objects that are covered by this transaction group.
+  attr_reader :objects
+
+    # Clears the object group. Removes references to the objects so that
+    # they can be garbage collected.
+  def clear
+    @objects = @objects.dup.clear
+  end
+
+    # Tests to see if all of the objects in the group have an open
+    # transaction. See Transaction::Simple#transaction_open? for more
+    # information.
+  def transaction_open?(name = nil)
+    @objects.inject(true) do |val, obj|
+      val = val and obj.transaction_open?(name)
+    end
+  end
+
+    # Returns the current name of the transaction for the group.
+    # Transactions not explicitly named are named +nil+.
+  def transaction_name
+    @objects[0].transaction_name
+  end
+
+    # 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.
+  def start_transaction(name = nil)
+    @objects.each { |obj| obj.start_transaction(name) }
+  end
+
+    # 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.
+  def rewind_transaction(name = nil)
+    @objects.each { |obj| obj.rewind_transaction(name) }
+  end
+
+    # 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+.
+  def abort_transaction(name = nil)
+    @objects.each { |obj| obj.abort_transaction(name) }
+  end
+
+    # 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.
+  def commit_transaction(name = nil)
+    @objects.each { |obj| obj.commit_transaction(name) }
+  end
+
+    # 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?
+  def transaction(action = nil, name = nil)
+    @objects.each { |obj| obj.transaction(action, name) }
+  end
+end

data/lib/gems/transaction-simple-1.4.0/lib/transaction/simple/threadsafe/group.rb

@@ -0,0 +1,36 @@
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: group.rb 47 2007-02-03 15:02:51Z austin $
+#++
+require 'transaction/simple/threadsafe'
+
+  # 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. This is the threadsafe version of a transaction
+  # group.
+class Transaction::Simple::ThreadSafe::Group < Transaction::Simple::Group
+  def initialize(*objects)
+    @objects = objects || []
+    @objects.freeze
+    @objects.each { |obj| obj.extend(Transaction::Simple::ThreadSafe) }
+
+    if block_given?
+      begin
+        yield self
+      ensure
+        self.clear
+      end
+    end
+  end
+end

data/lib/gems/transaction-simple-1.4.0/lib/transaction/simple/threadsafe.rb

@@ -0,0 +1,68 @@
+#--
+# Transaction::Simple
+# Simple object transaction support for Ruby
+# http://rubyforge.org/projects/trans-simple/
+#   Version 1.4.0
+#
+# Licensed under a MIT-style licence. See Licence.txt in the main
+# distribution for full licensing information.
+#
+# Copyright (c) 2003 - 2007 Austin Ziegler
+#
+# $Id: threadsafe.rb 50 2007-02-03 20:26:19Z austin $
+#++
+require 'transaction/simple'
+require 'thread'
+
+module Transaction
+  # A standard exception for transaction errors involving threadsafe
+  # transactions.
+  class TransactionThreadError < TransactionError; end
+end
+
+  # = Transaction::Simple::ThreadSafe
+  # Thread-safe simple object transaction support for Ruby.
+  # Transaction::Simple::ThreadSafe is used in the same way as
+  # Transaction::Simple. Transaction::Simple::ThreadSafe uses a Mutex object
+  # to ensure atomicity at the cost of performance in threaded applications.
+  #
+  # Transaction::Simple::ThreadSafe will not wait to obtain a lock; if the
+  # lock cannot be obtained immediately, a
+  # Transaction::TransactionThreadError will be raised.
+  #
+  # Thanks to Mauricio Fernandez for help with getting this part working.
+  #
+  # Threadsafe transactions can be used in any place that normal
+  # transactions would. The main difference would be in setup:
+  #
+  #   require 'transaction/simple/threadsafe'
+  #
+  #   x = "Hello, you."
+  #   x.extend(Transaction::Simple::ThreadSafe) # Threadsafe
+  #
+  #   y = "Hello, you."
+  #   y.extend(Transaction::Simple)             # Not threadsafe
+module Transaction::Simple::ThreadSafe
+  include Transaction::Simple
+
+  SKIP_TRANSACTION_VARS = Transaction::Simple::SKIP_TRANSACTION_VARS.dup #:nodoc:
+  SKIP_TRANSACTION_VARS << "@__transaction_mutex__"
+
+  Transaction::Simple.instance_methods(false) do |meth|
+    next if meth == "transaction"
+    arg = "(name = nil)" unless meth == "transaction_name"
+    module_eval <<-EOS
+    def #{meth}#{arg}
+      if (@__transaction_mutex__ ||= Mutex.new).try_lock
+        result = super
+        @__transaction_mutex__.unlock
+        return result
+      else
+        raise TransactionThreadError, Messages[:cannot_obtain_transaction_lock] % meth
+      end
+    ensure
+      @__transaction_mutex__.unlock
+    end
+    EOS
+  end
+end