transaction-simple 1.4.0 → 1.4.0.2

data/{History.txt → History.rdoc}

@@ -1,4 +1,13 @@
-== Transaction::Simple 1.4.0 / 2007.02.03
+== 1.4.0.2 / 2012-06-20
+* Bookkeeping release that fixes install in scenarios where the RubyGem
+  indicated it had a runtime dependency on hoe. Thanks to Michael Grosser
+  (https://github.com/grosser) for the inspiration.
+* Marked all files as UTF-8.
+
+== 1.4.0.1 / 2007-10-01
+* Fixed a simple bug with the #transaction method handling.
+
+== 1.4.0 / 2007-02-03
 
 * Adding a post-rewind hook (#_post_transaction_rewind) so that complex
   graph objects can correct themselves after rewinding. See the
@@ -12,13 +21,13 @@
   - Cleaned up the code a little further.
   - Changed non-gem installer to setup.rb version 3.4.1.
 
-== Transaction::Simple 1.3.1
+== 1.3.1
 
 * Explicitly clearing the transaction checkpoint on objects when the
   last open transaction is committed or aborted.
 * Fixed up behaviour to remove a lot of #respond_to? calls.
 
-== Transaction::Simple 1.3.0
+== 1.3.0
 
 * Updated to fix a lot of warnings.
 * Added a per-transaction-object list of excluded instance variables.
@@ -30,16 +39,16 @@
   to an object after a transaction was started would remain.
 * Reorganised unit tests.
 
-== Transaction::Simple 1.2.0
+== 1.2.0
 
 * Added a RubyGem.
 * Added a block form of Transaction::Simple.
 
-== Transaction::Simple 1.1.1
+== 1.1.1
 
 * Cleaned up some documentation.
 
-== Transaction::Simple 1.1
+== 1.1
 
 * Added Transaction::Simple::ThreadSafe for truly atomic and thread-safe
   transactions.
@@ -50,18 +59,6 @@
   explicitly committing, aborting, or rewinding the intervening
   transactions.
 
-== Transaction::Simple 1.0
+== 1.0
 
 * Created. Initial release.
-
-== Copyright
-  Transaction::Simple
-  Simple object transaction support for Ruby
-  http://rubyforge.org/projects/trans-simple/
-
-  Licensed under a MIT-style licence. See Licence.txt in the main
-  distribution for full licensing information.
-
-  Copyright (c) 2003 - 2007 Austin Ziegler
-
-  $Id: History.txt 50 2007-02-03 20:26:19Z austin $

data/Licence.rdoc

@@ -0,0 +1,23 @@
+== Licence
+
+This software is available under the terms of the MIT license.
+
+* Copyright 2003–2012 Austin Ziegler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Manifest.txt

@@ -1,15 +1,16 @@
-History.txt
-Install.txt
-Licence.txt
+History.rdoc
+Licence.rdoc
 Manifest.txt
+README.rdoc
 Rakefile
-Readme.txt
+lib/transaction-simple.rb
 lib/transaction/simple.rb
 lib/transaction/simple/group.rb
 lib/transaction/simple/threadsafe.rb
 lib/transaction/simple/threadsafe/group.rb
-setup.rb
-test/test_all.rb
+research/instance_variable_defined.rb
+research/special-dumpable-string.rb
+research/special-dumpable.rb
 test/test_broken_graph.rb
 test/test_transaction_simple.rb
 test/test_transaction_simple_group.rb

data/{Readme.txt → README.rdoc}

@@ -1,43 +1,53 @@
 = Transaction::Simple for Ruby
 
-Transaction::Simple provides a generic way to add active transaction
-support to objects. The transaction methods added by this module will work
-with most objects, excluding those that cannot be Marshal-ed (bindings,
-procedure objects, IO instances, or singleton objects).
+home :: http://trans-simple.rubyforge.org/
+code :: https://github.com/halostatue/transaction-simple
+bugs :: https://github.com/halostatue/transaction-simple/issues
+rdoc :: http://trans-simple.rubyforge.org/
 
-The transactions supported by Transaction::Simple are not associated with
-any sort of data store. They are "live" transactions occurring in memory
-on the object itself. This is to allow "test" changes to be made to an
-object before making the changes permanent.
+== Description
+
+Transaction::Simple provides a generic way to add active transaction support to
+objects. The transaction methods added by this module will work with most
+objects, excluding those that cannot be Marshal-ed (bindings, procedure
+objects, IO instances, or singleton objects).
+
+The transactions supported by Transaction::Simple are not associated with any
+sort of data store. They are "live" transactions occurring in memory on the
+object itself. This is to allow "test" changes to be made to an object before
+making the changes permanent.
 
 Transaction::Simple can handle an "infinite" number of transaction levels
-(limited only by memory). If I open two transactions, commit the second,
-but abort the first, the object will revert to the original version.
+(limited only by memory). If I open two transactions, commit the second, but
+abort the first, the object will revert to the original version.
 
-Transaction::Simple supports "named" transactions, so that multiple levels
-of transactions can be committed, aborted, or rewound by referring to the
+Transaction::Simple supports "named" transactions, so that multiple levels of
+transactions can be committed, aborted, or rewound by referring to the
 appropriate name of the transaction. Names may be any object except nil.
 
-Transaction groups are also supported. 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 groups are also supported. 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.
 
 Version 1.4.0 of Transaction::Simple adds a new post-rewind hook so that
 complex graph objects of the type in tests/tc_broken_graph.rb can correct
 themselves.
 
-Copyright:: Copyright (c) 2003 - 2007 by Austin Ziegler
-Version::   1.4.0
-Homepage::  http://rubyforge.org/projects/trans-simple/
-Licence::   MIT-Style; see Licence.txt
+Version 1.4.0.1 just fixes a simple bug with #transaction method handling
+during the deprecation warning.
 
-Thanks to David Black, Mauricio Fernandez, Patrick Hurley, Pit Capitain, and
-Matz for their assistance with this library.
+Version 1.4.0.2 is a small update for people who use Transaction::Simple in
+bundler (adding lib/transaction-simple.rb) and other scenarios where having Hoe
+as a runtime dependency (a bug fixed in Hoe several years ago, but not visible
+in Transaction::Simple because it has not needed a re-release). All of the
+files internally have also been marked as UTF-8, ensuring full Ruby 1.9
+compatibility.
 
 == Usage
-  include 'transaction/simple'
+
+  require 'transaction/simple'
 
   v = "Hello, you."               # -> "Hello, you."
   v.extend(Transaction::Simple)   # -> "Hello, you."
@@ -65,6 +75,7 @@ Matz for their assistance with this library.
   v.transaction_open?             # -> false
 
 == Named Transaction Usage
+
   v = "Hello, you."               # -> "Hello, you."
   v.extend(Transaction::Simple)   # -> "Hello, you."
 
@@ -97,10 +108,11 @@ Matz for their assistance with this library.
   v.transaction_open?             # -> false
 
 == Block Transaction Usage
+
   v = "Hello, you."               # -> "Hello, you."
   Transaction::Simple.start(v) do |tv|
-      # v has been extended with Transaction::Simple and an unnamed
-      # transaction has been started.
+    # v has been extended with Transaction::Simple and an unnamed transaction
+    # has been started.
     tv.transaction_open?          # -> true
     tv.gsub!(/you/, "world")      # -> "Hello, world."
 
@@ -108,11 +120,11 @@ Matz for their assistance with this library.
     tv.transaction_open?          # -> true
 
     tv.gsub!(/you/, "HAL")        # -> "Hello, HAL."
-      # The following breaks out of the transaction block after
-      # aborting the transaction.
+    # The following breaks out of the transaction block after aborting the
+    # transaction.
     tv.abort_transaction          # -> "Hello, you."
   end
-    # v still has Transaction::Simple applied from here on out.
+  # v still has Transaction::Simple applied from here on out.
   v.transaction_open?             # -> false
 
   Transaction::Simple.start(v) do |tv|
@@ -121,9 +133,9 @@ Matz for their assistance with this library.
     tv.transaction_open?          # -> true
     tv.gsub!(/you/, "HAL")        # -> "Hello, HAL."
 
-      # If #commit_transaction were called without having started a
-      # second transaction, then it would break out of the transaction
-      # block after committing the transaction.
+    # If #commit_transaction were called without having started a second
+    # transaction, then it would break out of the transaction block after
+    # committing the transaction.
     tv.commit_transaction         # -> "Hello, HAL."
     tv.transaction_open?          # -> true
     tv.abort_transaction          # -> "Hello, you."
@@ -131,6 +143,7 @@ Matz for their assistance with this library.
   v.transaction_open?             # -> false
 
 == Transaction Groups
+
   require 'transaction/simple/group'
 
   x = "Hello, you."
@@ -165,6 +178,7 @@ Matz for their assistance with this library.
   y                               = -> "And you, too."
 
 == Thread Safety
+
 Threadsafe versions of Transaction::Simple and Transaction::Simple::Group
 exist; these are loaded from 'transaction/simple/threadsafe' and
 'transaction/simple/threadsafe/group', respectively, and are represented in
@@ -172,24 +186,25 @@ Ruby code as Transaction::Simple::ThreadSafe and
 Transaction::Simple::ThreadSafe::Group, respectively.
 
 == Contraindications
+
 While Transaction::Simple is very useful, it has limitations that must be
 understood prior to using it. Transaction::Simple:
 
 * uses Marshal. Thus, any object which cannot be Marshal-ed cannot use
-  Transaction::Simple. In my experience, this affects singleton objects
-  more often than any other object.
+  Transaction::Simple. In my experience, this affects singleton objects more
+  often than any other object.
 * does not manage external resources. Resources external to the object and
   its instance variables are not managed at all. However, all instance
-  variables and objects "belonging" to those instance variables are
-  managed. If there are object reference counts to be handled,
-  Transaction::Simple will probably cause problems.
+  variables and objects "belonging" to those instance variables are managed. If
+  there are object reference counts to be handled, Transaction::Simple will
+  probably cause problems.
 * is not thread-safe. In the ACID ("atomic, consistent, isolated,
   durable") test, Transaction::Simple provides consistency and durability, but
   cannot itself provide isolation. Transactions should be considered "critical
   sections" in multi-threaded applications. Thread safety of the transaction
   acquisition and release process itself can be ensured with the thread-safe
-  version, Transaction::Simple::ThreadSafe. With transaction groups, some
-  level of atomicity is assured.
+  version, Transaction::Simple::ThreadSafe. With transaction groups, some level
+  of atomicity is assured.
 * does not maintain Object#__id__ values on rewind or abort. This only affects
   complex self-referential graphs. tests/tc_broken_graph.rb demonstrates this
   and its mitigation with the new post-rewind hook. #_post_transaction_rewind.
@@ -201,4 +216,4 @@ understood prior to using it. Transaction::Simple:
 * Can be a memory hog if you use many levels of transactions on many
   objects.
 
-$Id: Readme.txt 50 2007-02-03 20:26:19Z austin $
+:include: Licence.rdoc

data/Rakefile

@@ -1,122 +1,24 @@
-#! /usr/bin/env rake
-#--
-# 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: Rakefile 51 2007-02-03 21:45:27Z austin $
-#++
+# -*- ruby encoding: utf-8 -*-
 
 require 'rubygems'
 require 'hoe'
 
-$LOAD_PATH.unshift('lib')
+Hoe.plugin :doofus
+Hoe.plugin :gemspec
+Hoe.plugin :rubyforge
+Hoe.plugin :git
 
-require 'transaction/simple'
+Hoe.spec 'transaction-simple' do
+  self.rubyforge_name = "trans-simple"
 
-TSVER     = Transaction::Simple::TRANSACTION_SIMPLE_VERSION
-DISTDIR   = "transaction-simple-#{TSVER}"
-TARFILE   = "pkg/#{DISTDIR}.tar.gz"
-MANIFEST  = File.read("Manifest.txt").split
+  developer('Austin Ziegler', 'austin@rubyforge.org')
 
-Hoe.new "transaction-simple", TSVER do |p|
-  p.rubyforge_name  = "trans-simple"
-  # This is a lie becasue I will continue to use Archive::Tar::Minitar.
-  p.need_tar        = false
-  # need_zip - Should package create a zipfile? [default: false]
+  self.remote_rdoc_dir = ''
+  self.rsync_args << ' --exclude=statsvn/'
 
-  p.author          = "Austin Ziegler"
-  p.email           = "austin@rubyforge.org"
-  p.url             = "http://rubyforge.org/projects/trans-simple"
-  p.summary         = "Simple object transaction support for Ruby."
-  p.changes         = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  p.description     = p.paragraphs_of("Readme.txt", 1..1).join("\n\n")
-
-  p.spec_extras[:required_ruby_version] = ">=1.8.2"
-  p.spec_extras[:extra_rdoc_files] = MANIFEST.grep(/txt$/) -
-    ["Manifest.txt"]
-  p.clean_globs     << "./**/log"
-
-  # extra_deps - An array of rubygem dependencies.
-  # clean_globs - An array of file patterns to delete on clean.
-  # rdoc_pattern - A regexp to match documentation files against the manifest.
-  # spec_extras - A hash of extra values to set in the gemspec.
-  # test_globs - An array of test file patterns [default: test/**/test_*.rb]
-
-  # bin_files
-  # lib_files
-  # spec
-  # test_files
+  self.history_file = 'History.rdoc'
+  self.readme_file = 'README.rdoc'
+  self.extra_rdoc_files = FileList["*.rdoc"].to_a
 end
 
-desc "Build a Transaction::Simple .tar.gz distribution."
-task :tar => [ TARFILE ]
-file TARFILE => [ :test ] do |t|
-  require 'archive/tar/minitar'
-  require 'zlib'
-  files = MANIFEST.map { |f|
-    fn = File.join(DISTDIR, f)
-    tm = File.stat(f).mtime
-
-    if File.directory?(f)
-      { :name => fn, :mode => 0755, :dir => true, :mtime => tm }
-    else
-      mode = if f =~ %r{^bin}
-               0755
-             else
-               0644
-             end
-      data = File.read(f)
-      { :name => fn, :mode => mode, :data => data, :size => data.size,
-        :mtime => tm }
-    end
-  }
-
-  begin
-    unless File.directory?(File.dirname(t.name))
-      require 'fileutils'
-      File.mkdir_p File.dirname(t.name)
-    end
-    tf = File.open(t.name, 'wb')
-    gz = Zlib::GzipWriter.new(tf)
-    tw = Archive::Tar::Minitar::Writer.new(gz)
-
-    files.each do |entry|
-      if entry[:dir]
-        tw.mkdir(entry[:name], entry)
-      else
-        tw.add_file_simple(entry[:name], entry) { |os|
-          os.write(entry[:data])
-        }
-      end
-    end
-  ensure
-    tw.close if tw
-    gz.close if gz
-  end
-end
-task :package => [ TARFILE ]
-
-task :build_manifest do |t|
-  require 'find'
-
-  paths = []
-  Find.find(".") do |path|
-    next if File.directory?(path)
-    next if path =~ /\.svn/
-    next if path =~ %r{/research/}
-    next if path =~ /\.swp$/
-    next if path =~ /~$/
-    paths << path.sub(%r{^\./}, '')
-  end
-
-  File.open("Manifest.txt", "w") do |f|
-    f.puts paths.sort.join("\n")
-  end
-end
+# vim: syntax=ruby

data/lib/transaction-simple.rb

@@ -0,0 +1,5 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'transaction/simple'
+
+# vim: syntax=ruby

data/lib/transaction/simple.rb

@@ -1,19 +1,6 @@
-# :title: Transaction::Simple -- Active Object Transaction Support for Ruby
-# :main: Readme.txt
-
-#--
-# 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: simple.rb 50 2007-02-03 20:26:19Z austin $
-#++
+# -*- ruby encoding: utf-8 -*-
+
+# :main: README.rdoc
 
 # The "Transaction" namespace can be used for additional transaction support
 # objects and modules.
@@ -44,13 +31,19 @@ module Transaction
     :cannot_commit_named_transaction => te % "cannot commit nonexistant transaction %s.",
     :cannot_start_empty_block_transaction => te % "cannot start a block transaction with no objects.",
     :cannot_obtain_transaction_lock => te % "cannot obtain transaction lock for #%s.",
+    :transaction => "Transaction",
+    :opened => "open",
+    :closed => "closed",
+    :transaction_name => "Transaction Name",
+    :start_transaction => "Start Transaction",
+    :rewind_transaction => "Rewind Transaction",
+    :commit_transaction => "Commit Transaction",
+    :abort_transaction => "Abort Transaction",
   }
 end
 
-# = Transaction::Simple for Ruby
-# Simple object transaction support for Ruby
 module Transaction::Simple
-  TRANSACTION_SIMPLE_VERSION = '1.4.0'
+  VERSION = TRANSACTION_SIMPLE_VERSION = '1.4.0.2'
 
   class << self
     # Sets the Transaction::Simple debug object. It must respond to #<<.
@@ -66,6 +59,10 @@ module Transaction::Simple
       end
     end
 
+    # Set to +true+ if you want the checkpoint printed with debugging
+    # messages where it matters.
+    attr_accessor :debug_with_checkpoint
+
     # Returns +true+ if we are debugging.
     def debugging?
       defined? @debugging and @debugging
@@ -76,31 +73,70 @@ module Transaction::Simple
       @tdi ||= ""
       @tdi
     end
+
+    # Fast debugging.
+    def debug(format, *args)
+      return unless debugging?
+      debug_io << (format % args)
+    end
+  end
+
+  def ___tmessage
+    Transaction::Messages
+  end
+  private :___tmessage
+
+  def ___tdebug(char, format, *args)
+    return unless Transaction::Simple.debugging?
+    if @__transaction_level__ > 0
+      Transaction::Simple.debug "#{char * @__transaction_level__} #{format}", args
+    else
+      Transaction::Simple.debug "#{format}", args
+    end
   end
+  private :___tdebug
+
+  def ___tdebug_checkpoint
+    return unless Transaction::Simple.debugging?
+    return unless Transaction::Simple.debug_with_checkpoint
+
+    ___tdebug '|', '%s', @__transaction_checkpoint__.inspect
+  end
+  private :___tdebug_checkpoint
 
   # If +name+ is +nil+ (default), then returns +true+ if there is currently
   # a transaction open. If +name+ is specified, then returns +true+ if there
   # is currently a transaction known as +name+ open.
   def transaction_open?(name = nil)
     defined? @__transaction_checkpoint__ or @__transaction_checkpoint__ = nil
+
+    has_t = nil
+
     if name.nil?
-      Transaction::Simple.debug_io << "Transaction " << "[#{(@__transaction_checkpoint__.nil?) ? 'closed' : 'open'}]\n" if Transaction::Simple.debugging?
-      return (not @__transaction_checkpoint__.nil?)
+      has_t = (not @__transaction_checkpoint__.nil?)
     else
-      Transaction::Simple.debug_io << "Transaction(#{name.inspect}) " << "[#{(@__transaction_checkpoint__.nil?) ? 'closed' : 'open'}]\n" if Transaction::Simple.debugging?
-      return ((not @__transaction_checkpoint__.nil?) and @__transaction_names__.include?(name))
+      has_t = ((not @__transaction_checkpoint__.nil?) and
+               @__transaction_names__.include?(name))
     end
+
+    ___tdebug '>', "%s [%s]", ___tmessage[:transaction], ___tmessage[has_t ? :opened : :closed]
+
+    has_t
   end
 
   # Returns the current name of the transaction. Transactions not explicitly
   # named are named +nil+.
   def transaction_name
-    raise Transaction::TransactionError, Transaction::Messages[:no_transaction_open] if @__transaction_checkpoint__.nil?
-    Transaction::Simple.debug_io << "#{'|' * @__transaction_level__} " << "Transaction Name: #{@__transaction_names__[-1].inspect}\n" if Transaction::Simple.debugging?
-    if @__transaction_names__[-1].kind_of?(String)
-      @__transaction_names__[-1].dup
+    raise Transaction::TransactionError, ___tmessage[:no_transaction_open] if @__transaction_checkpoint__.nil?
+
+    name = @__transaction_names__.last
+
+    ___tdebug '|', "%s(%s)", ___tmessage[:transaction_name], name.inspect
+
+    if name.kind_of?(String)
+      name.dup
     else
-      @__transaction_names__[-1]
+      name
     end
   end
 
@@ -114,17 +150,15 @@ module Transaction::Simple
 
     name = name.dup.freeze if name.kind_of?(String)
 
-    raise Transaction::TransactionError, Transaction::Messages[:unique_names] if name and @__transaction_names__.include?(name)
+    raise Transaction::TransactionError, ___tmessage[:unique_names] if name and @__transaction_names__.include?(name)
 
     @__transaction_names__ << name
     @__transaction_level__ += 1
 
-    if Transaction::Simple.debugging?
-      ss = "(#{name.inspect})"
-      ss = "" unless ss
+    ___tdebug '>', "%s(%s)", ___tmessage[:start_transaction], name.inspect
+    ___tdebug_checkpoint
 
-      Transaction::Simple.debug_io << "#{'>' * @__transaction_level__} " << "Start Transaction#{ss}\n"
-    end
+    checkpoint = Marshal.dump(self)
 
     @__transaction_checkpoint__ = Marshal.dump(self)
   end
@@ -185,36 +219,39 @@ module Transaction::Simple
   #   parent.abort_transaction
   #   puts parent.valid? # => true
   def rewind_transaction(name = nil)
-    raise Transaction::TransactionError, Transaction::Messages[:cannot_rewind_no_transaction] if @__transaction_checkpoint__.nil?
+    raise Transaction::TransactionError, ___tmessage[:cannot_rewind_no_transaction] if @__transaction_checkpoint__.nil?
 
-    # Check to see if we are trying to rewind a transaction that is
-    # outside of the current transaction block.
+    # Check to see if we are trying to rewind a transaction that is outside
+    # of the current transaction block.
     defined? @__transaction_block__ or @__transaction_block__ = nil
     if @__transaction_block__ and name
       nix = @__transaction_names__.index(name) + 1
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_rewind_transaction_before_block] if nix < @__transaction_block__
+      raise Transaction::TransactionError, ___tmessage[:cannot_rewind_transaction_before_block] if nix < @__transaction_block__
     end
 
     if name.nil?
       checkpoint = @__transaction_checkpoint__
       __rewind_this_transaction
       @__transaction_checkpoint__ = checkpoint
-      ss = "" if Transaction::Simple.debugging?
     else
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_rewind_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
-      ss = "(#{name})" if Transaction::Simple.debugging?
+      raise Transaction::TransactionError, ___tmessage[:cannot_rewind_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
 
-      while @__transaction_names__[-1] != name
+      while @__transaction_names__.last != name
+        ___tdebug_checkpoint
         @__transaction_checkpoint__ = __rewind_this_transaction
-        Transaction::Simple.debug_io << "#{'|' * @__transaction_level__} " << "Rewind Transaction#{ss}\n" if Transaction::Simple.debugging?
+        ___tdebug '<', ___tmessage[:rewind_transaction], name
         @__transaction_level__ -= 1
         @__transaction_names__.pop
       end
+
       checkpoint = @__transaction_checkpoint__
       __rewind_this_transaction
       @__transaction_checkpoint__ = checkpoint
     end
-    Transaction::Simple.debug_io << "#{'|' * @__transaction_level__} " << "Rewind Transaction#{ss}\n" if Transaction::Simple.debugging?
+
+    ___tdebug '|', "%s(%s)", ___tmessage[:rewind_transaction], name.inspect
+    ___tdebug_checkpoint
+
     self
   end
 
@@ -230,7 +267,7 @@ module Transaction::Simple
   # (Transaction::Simple.start), then the execution of the block will be
   # halted with +break+ +self+.
   def abort_transaction(name = nil)
-    raise Transaction::TransactionError, Transaction::Messages[:cannot_abort_no_transaction] if @__transaction_checkpoint__.nil?
+    raise Transaction::TransactionError, ___tmessage[:cannot_abort_no_transaction] if @__transaction_checkpoint__.nil?
 
     # Check to see if we are trying to abort a transaction that is outside
     # of the current transaction block. Otherwise, raise TransactionAborted
@@ -238,8 +275,7 @@ module Transaction::Simple
     defined? @__transaction_block__ or @__transaction_block__ = nil
     if @__transaction_block__ and name
       nix = @__transaction_names__.index(name) + 1
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_abort_transaction_before_block] if nix < @__transaction_block__
-
+      raise Transaction::TransactionError, ___tmessage[:cannot_abort_transaction_before_block] if nix < @__transaction_block__
       raise Transaction::TransactionAborted if @__transaction_block__ == nix
     end
 
@@ -248,7 +284,7 @@ module Transaction::Simple
     if name.nil?
       __abort_transaction(name)
     else
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_abort_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
+      raise Transaction::TransactionError, ___tmessage[:cannot_abort_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
       __abort_transaction(name) while @__transaction_names__.include?(name)
     end
 
@@ -262,7 +298,7 @@ module Transaction::Simple
   # then all transactions are closed and committed until the named
   # transaction is reached.
   def commit_transaction(name = nil)
-    raise Transaction::TransactionError, Transaction::Messages[:cannot_commit_no_transaction] if @__transaction_checkpoint__.nil?
+    raise Transaction::TransactionError, ___tmessage[:cannot_commit_no_transaction] if @__transaction_checkpoint__.nil?
     @__transaction_block__ ||= nil
 
     # Check to see if we are trying to commit a transaction that is outside
@@ -270,7 +306,7 @@ module Transaction::Simple
     # TransactionCommitted if they are the same.
     if @__transaction_block__ and name
       nix = @__transaction_names__.index(name) + 1
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_commit_transaction_before_block] if nix < @__transaction_block__
+      raise Transaction::TransactionError, ___tmessage[:cannot_commit_transaction_before_block] if nix < @__transaction_block__
 
       raise Transaction::TransactionCommitted if @__transaction_block__ == nix
     end
@@ -278,21 +314,23 @@ module Transaction::Simple
     raise Transaction::TransactionCommitted if @__transaction_block__ == @__transaction_level__
 
     if name.nil?
-      ss = "" if Transaction::Simple.debugging?
+      ___tdebug "<", "%s(%s)", ___tmessage[:commit_transaction], name.inspect
       __commit_transaction
-      Transaction::Simple.debug_io << "#{'<' * @__transaction_level__} " << "Commit Transaction#{ss}\n" if Transaction::Simple.debugging?
     else
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_commit_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
-      ss = "(#{name})" if Transaction::Simple.debugging?
+      raise Transaction::TransactionError, ___tmessage[:cannot_commit_named_transaction] % name.inspect unless @__transaction_names__.include?(name)
 
-      while @__transaction_names__[-1] != name
-        Transaction::Simple.debug_io << "#{'<' * @__transaction_level__} " << "Commit Transaction#{ss}\n" if Transaction::Simple.debugging?
+      while @__transaction_names__.last != name
+        ___tdebug "<", "%s(%s)", ___tmessage[:commit_transaction], name.inspect
         __commit_transaction
+        ___tdebug_checkpoint
       end
-      Transaction::Simple.debug_io << "#{'<' * @__transaction_level__} " << "Commit Transaction#{ss}\n" if Transaction::Simple.debugging?
+
+      ___tdebug "<", "%s(%s)", ___tmessage[:commit_transaction], name.inspect
       __commit_transaction
     end
 
+    ___tdebug_checkpoint
+
     self
   end
 
@@ -317,19 +355,19 @@ module Transaction::Simple
               else nil
               end
 
-    if method
-      warn "The #transaction method has been deprecated. Use #{method} instead."
+    if _method
+      warn "The #transaction method has been deprecated. Use #{_method} instead."
     else
       warn "The #transaction method has been deprecated."
     end
 
-    case method
+    case _method
     when :transaction_name
-      __send__ method
+      __send__ _method
     when nil
       nil
     else
-      __send__ method, name
+      __send__ _method, name
     end
   end
 
@@ -344,7 +382,7 @@ module Transaction::Simple
 
   class << self
     def __common_start(name, vars, &block)
-      raise Transaction::TransactionError, Transaction::Messages[:cannot_start_empty_block_transaction] if vars.empty?
+      raise Transaction::TransactionError, ___tmessage[:cannot_start_empty_block_transaction] if vars.empty?
 
       if block
         begin
@@ -414,30 +452,25 @@ module Transaction::Simple
   def __abort_transaction(name = nil) #:nodoc:
     @__transaction_checkpoint__ = __rewind_this_transaction
 
-    if Transaction::Simple.debugging?
-      if name.nil?
-        ss = ""
-      else
-        ss = "(#{name.inspect})"
-      end
-
-      Transaction::Simple.debug_io << "#{'<' * @__transaction_level__} " << "Abort Transaction#{ss}\n"
-    end
+    ___tdebug '<', "%s(%s)", ___tmessage[:abort_transaction], name.inspect
+    ___tdebug_checkpoint
 
     @__transaction_level__ -= 1
     @__transaction_names__.pop
+
     if @__transaction_level__ < 1
       @__transaction_level__ = 0
       @__transaction_names__ = []
       @__transaction_checkpoint__ = nil
     end
   end
+  private :__abort_transaction
 
   SKIP_TRANSACTION_VARS = %w(@__transaction_checkpoint__ @__transaction_level__)
 
   def __rewind_this_transaction #:nodoc:
     defined? @__transaction_checkpoint__ or @__transaction_checkpoint__ = nil
-    raise Transaction::TransactionError, Transaction::Messages[:cannot_rewind_no_transaction] if @__transaction_checkpoint__.nil?
+    raise Transaction::TransactionError, ___tmessage[:cannot_rewind_no_transaction] if @__transaction_checkpoint__.nil?
     rr = Marshal.restore(@__transaction_checkpoint__)
 
     replace(rr) if respond_to?(:replace)
@@ -461,10 +494,11 @@ module Transaction::Simple
     $-w = w # 20070203 OH is this very UGLY
     res
   end
+  private :__rewind_this_transaction
 
   def __commit_transaction #:nodoc:
     defined? @__transaction_checkpoint__ or @__transaction_checkpoint__ = nil
-    raise Transaction::TransactionError, Transaction::Messages[:cannot_commit_no_transaction] if @__transaction_checkpoint__.nil?
+    raise Transaction::TransactionError, ___tmessage[:cannot_commit_no_transaction] if @__transaction_checkpoint__.nil?
     old = Marshal.restore(@__transaction_checkpoint__)
     w, $-w = $-w, false # 20070203 OH is this very UGLY
     @__transaction_checkpoint__ = old.instance_variable_get(:@__transaction_checkpoint__)
@@ -479,8 +513,7 @@ module Transaction::Simple
       @__transaction_checkpoint__ = nil
     end
   end
-
-  private :__abort_transaction
-  private :__rewind_this_transaction
   private :__commit_transaction
 end
+
+# vim: syntax=ruby