transaction-simple 1.3.0 → 1.4.0

data/History.txt

@@ -0,0 +1,67 @@
+== Transaction::Simple 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
+  documentation for #rewind_transaction and tests/tc_broken_graph.rb for
+  more information.
+* Removed all warnings.
+* Deprecated the #transaction method.
+* Various administrative changes:
+  - Converted to a hoe-driven project.
+  - Made the gem and .tar.gz files idempotent.
+  - Cleaned up the code a little further.
+  - Changed non-gem installer to setup.rb version 3.4.1.
+
+== Transaction::Simple 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
+
+* Updated to fix a lot of warnings.
+* Added a per-transaction-object list of excluded instance variables.
+* Moved Transaction::simple::ThreadSafe to transaction/simple/threadsafe.
+* Added transaction groups. Transaction groups are wrapper objects to
+  allow the coordination of transactions with a group of objects. There
+  are both normal and threadsafe versions of transaction groups.
+* Fixed a long-standing problem where instance variables that were added
+  to an object after a transaction was started would remain.
+* Reorganised unit tests.
+
+== Transaction::Simple 1.2.0
+
+* Added a RubyGem.
+* Added a block form of Transaction::Simple.
+
+== Transaction::Simple 1.1.1
+
+* Cleaned up some documentation.
+
+== Transaction::Simple 1.1
+
+* Added Transaction::Simple::ThreadSafe for truly atomic and thread-safe
+  transactions.
+* Fixed the description of Transaction::Simple to note that it is *not*
+  atomic because it is not implicitly thread-safe.
+* Added support for named transactions. Named transactions can be used to
+  make checkpoints that can be committed, aborted, or rewound without
+  explicitly committing, aborting, or rewinding the intervening
+  transactions.
+
+== Transaction::Simple 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/Install.txt

@@ -0,0 +1,21 @@
+== Installing Transaction::Simple
+
+Transaction::Simple requires Ruby version 1.8.2 or better. It may be
+installed with:
+
+  % ruby setup.rb
+
+Alternatively, the RubyGems version of Transaction::Simple may be
+installed from the usual sources.
+
+== 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: Install.txt 47 2007-02-03 15:02:51Z austin $

data/Licence.txt

@@ -0,0 +1,25 @@
+Transaction::Simple
+Simple object transaction support for Ruby
+http://rubyforge.org/projects/trans-simple/
+
+Copyright (c) 2003 - 2007 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.
+
+$Id: simple.rb,v 1.7 2005/06/12 19:48:17 austin Exp $

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Install.txt
+Licence.txt
+Manifest.txt
+Rakefile
+Readme.txt
+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
+test/test_broken_graph.rb
+test/test_transaction_simple.rb
+test/test_transaction_simple_group.rb
+test/test_transaction_simple_threadsafe.rb

data/Rakefile

@@ -1,114 +1,122 @@
 #! /usr/bin/env rake
-$LOAD_PATH.unshift('lib')
+#--
+# 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 $
+#++
 
 require 'rubygems'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-require 'transaction/simple'
-require 'archive/tar/minitar'
-require 'zlib'
-
-DISTDIR = "transaction-simple-#{Transaction::Simple::TRANSACTION_SIMPLE_VERSION}"
-TARDIST = "../#{DISTDIR}.tar.gz"
-
-DATE_RE = %r<(\d{4})[./-]?(\d{2})[./-]?(\d{2})(?:[\sT]?(\d{2})[:.]?(\d{2})[:.]?(\d{2})?)?>
-
-if ENV['RELEASE_DATE']
-  year, month, day, hour, minute, second = DATE_RE.match(ENV['RELEASE_DATE']).captures
-  year ||= 0
-  month ||= 0
-  day ||= 0
-  hour ||= 0
-  minute ||= 0
-  second ||= 0
-  ReleaseDate = Time.mktime(year, month, day, hour, minute, second)
-else
-  ReleaseDate = nil
-end
-
-task :test do |t|
-  require 'test/unit/testsuite'
-  require 'test/unit/ui/console/testrunner'
-
-  runner = Test::Unit::UI::Console::TestRunner
+require 'hoe'
 
-  $LOAD_PATH.unshift('tests')
-  $stderr.puts "Checking for test cases:" if t.verbose
-  Dir['tests/**/tc_*.rb'].each do |testcase|
-    $stderr.puts "\t#{testcase}" if t.verbose
-    load testcase
-  end
-
-  suite = Test::Unit::TestSuite.new("Transaction::Simple")
-
-  ObjectSpace.each_object(Class) do |testcase|
-    suite << testcase.suite if testcase < Test::Unit::TestCase
-  end
+$LOAD_PATH.unshift('lib')
 
-  runner.run(suite)
-end
+require 'transaction/simple'
 
-spec = eval(File.read("transaction-simple.gemspec"))
-spec.version = Transaction::Simple::TRANSACTION_SIMPLE_VERSION
-desc "Build the RubyGem for Transaction::Simple"
-task :gem => [ :test ]
-Rake::GemPackageTask.new(spec) do |g|
-  g.need_tar    = false
-  g.need_zip    = false
-  g.package_dir = ".."
+TSVER     = Transaction::Simple::TRANSACTION_SIMPLE_VERSION
+DISTDIR   = "transaction-simple-#{TSVER}"
+TARFILE   = "pkg/#{DISTDIR}.tar.gz"
+MANIFEST  = File.read("Manifest.txt").split
+
+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]
+
+  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
 end
 
 desc "Build a Transaction::Simple .tar.gz distribution."
-task :tar => [ TARDIST ]
-file TARDIST => [ :test ] do |t|
-  current = File.basename(Dir.pwd)
-  Dir.chdir("..") do
-    begin
-      files = Dir["#{current}/**/*"].select { |dd| dd !~ %r{(?:/CVS/?|~$)} }
-      files.map! do |dd|
-        ddnew = dd.gsub(/^#{current}/, DISTDIR)
-        mtime = ReleaseDate || File.stat(dd).mtime
-        if File.directory?(dd)
-          { :name => ddnew, :mode => 0755, :dir => true, :mtime => mtime }
-        else
-          if dd =~ %r{bin/}
-            mode = 0755
-          else
-            mode = 0644
-          end
-          data = File.read(dd)
-          { :name => ddnew, :mode => mode, :data => data, :size => data.size,
-            :mtime => mtime }
-        end
-      end
-
-      ff = File.open(t.name.gsub(%r{^\.\./}o, ''), "wb")
-      gz = Zlib::GzipWriter.new(ff)
-      tw = Archive::Tar::Minitar::Writer.new(gz)
+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
+  }
 
-      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
+  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
-    ensure
-      tw.close if tw
-      gz.close if gz
     end
+  ensure
+    tw.close if tw
+    gz.close if gz
   end
 end
-task TARDIST => [ :test ]
-
-desc "Build the rdoc documentation for Transaction::Simple"
-task :docs do
-  require 'rdoc/rdoc'
-  rdoc_options = %w(--title Transaction::Simple --main Readme --line-numbers)
-  files = FileList[*%w(Readme Changelog bin/**/*.rb lib/**/*.rb)]
-  rdoc_options += files.to_a
-  RDoc::RDoc.new.document(rdoc_options)
-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
 
-desc "Build everything."
-task :default => [ :tar, :gem ]
+  File.open("Manifest.txt", "w") do |f|
+    f.puts paths.sort.join("\n")
+  end
+end

data/{Readme → Readme.txt}

@@ -1,38 +1,40 @@
 = 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).
-
-The transactions supported by Transaction::Simple are not backend
-transaction; that is, they are not associated with any sort of data
-store. They are "live" transactions occurring in memory and in 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.
-
-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.
-
-Version 1.3.0 of Transaction::Simple adds transaction groups. 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.
-
-Copyright:    Copyright � 2003 - 2005 by Austin Ziegler
-Version:      1.3.0
-Licence:      MIT-Style
-
-Thanks to David Black and Mauricio Fern�ndez for their help with this
-library.
+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.
+
+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.
+
+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
+
+Thanks to David Black, Mauricio Fernandez, Patrick Hurley, Pit Capitain, and
+Matz for their assistance with this library.
 
 == Usage
   include 'transaction/simple'
@@ -163,31 +165,40 @@ library.
   y                               = -> "And you, too."
 
 == Thread Safety
-Threadsafe version of Transaction::Simple and Transaction::Simple::Group
+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 Ruby code as Transaction::Simple::ThreadSafe and
+'transaction/simple/threadsafe/group', respectively, and are represented in
+Ruby code as Transaction::Simple::ThreadSafe and
 Transaction::Simple::ThreadSafe::Group, respectively.
 
 == Contraindications
-While Transaction::Simple is very useful, it has some severe limitations
-that must be understood. Transaction::Simple:
+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. It may be that Ruby 2.0 will solve
-  this problem.
-* does not manage resources. Resources external to the object and its
-  instance variables are not managed at all. However, all instance
+  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.
 * is not thread-safe. In the ACID ("atomic, consistent, isolated,
-  durable") test, Transaction::Simple provides C and D, but it is up to
-  the user of Transaction::Simple to provide isolation. Transactions
-  should be considered "critical sections" in multi-threaded
-  applications. Thread safety can be ensured with
-  Transaction::Simple::ThreadSafe. With transaction groups, some level
-  of atomicity is assured.
-* does not maintain Object#__id__ values on rewind or abort. This may
-  change for future versions.
+  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.
+* 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.
+  Matz has implemented an experimental feature in Ruby 1.9 that may find its
+  way into the released Ruby 1.9.1 and ultimately Ruby 2.0 that would obviate
+  the need for #_post_transaction_rewind. Pit Capitain has also suggested a
+  workaround that does not require changes to core Ruby, but does not work in
+  all cases. A final resolution is still pending further discussion.
+* 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 $