ardm-transactions 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 10896a2c7320a29dcc5ed6a1f64a228dd8c7df05
+  data.tar.gz: 3d7cc2c2e29e306e83f45f2b87f37b62b80e8b4f
+SHA512:
+  metadata.gz: 5eb9144e58d1b7f58928ef452b652773fd4423c6bbcdba01189f690ea68fa6d48ffb982fa8cfc352765f60c26bca1f255da0942162db7ffa5998afa32d9542bc
+  data.tar.gz: 8788e5183a35cc4d3208d0cc601dca0482c6118ca195006803b7ca4d4c4b955a53b3d9686f847456e383f6a657f402ef009c22ca6fe770efa040e370b41a6f67

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,36 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+
+## PROJECT::GENERAL
+*.gem
+coverage
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.*
+
+## PROJECT::SPECIFIC
+spec/db/
+spec/log/

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+sudo: false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0
+matrix:
+  allow_failures:
+    - rvm: 2.1.5
+    - rvm: 2.2.0

data/Gemfile

@@ -0,0 +1,47 @@
+require 'pathname'
+
+source 'https://rubygems.org'
+
+gemspec
+
+SOURCE         = ENV.fetch('SOURCE', :git).to_sym
+REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
+DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/ar-dm'
+DM_VERSION     = '~> 1.2.0'
+DO_VERSION     = '~> 0.10.6'
+DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
+CURRENT_BRANCH = ENV.fetch('GIT_BRANCH', 'master')
+
+gem 'ardm-core', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-core#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+
+group :datamapper do
+
+  adapters = ENV['ADAPTER'] || ENV['ADAPTERS']
+  adapters = adapters.to_s.tr(',', ' ').split.uniq - %w[ in_memory ]
+
+  if (do_adapters = DM_DO_ADAPTERS & adapters).any?
+    do_options = {}
+    do_options[:git] = "#{DATAMAPPER}/do#{REPO_POSTFIX}" if ENV['DO_GIT'] == 'true'
+
+    gem 'data_objects', DO_VERSION, do_options.dup
+
+    do_adapters.each do |adapter|
+      adapter = 'sqlite3' if adapter == 'sqlite'
+      gem "do_#{adapter}", DO_VERSION, do_options.dup
+    end
+
+    gem 'ardm-do-adapter', DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-do-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  adapters.each do |adapter|
+    gem "ardm-#{adapter}-adapter", DM_VERSION, SOURCE => "#{DATAMAPPER}/ardm-#{adapter}-adapter#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+  plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+  plugins = plugins.to_s.tr(',', ' ').split.push('ardm-migrations').uniq
+
+  plugins.each do |plugin|
+    gem plugin, DM_VERSION, SOURCE => "#{DATAMAPPER}/#{plugin}#{REPO_POSTFIX}", :branch => CURRENT_BRANCH
+  end
+
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 snusnu
+
+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/README.rdoc

@@ -0,0 +1,23 @@
+= dm-transactions
+
+This gem adds transaction support for datamapper. The currently supported adapters are
+
+* postgres
+* mysql
+* sqlite3
+* oracle
+* sqlserver
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 snusnu. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/ardm-transactions.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dm-transactions/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name             = "ardm-transactions"
+  gem.version          = DataMapper::Transactions::VERSION
+
+  gem.authors          = [ 'Martin Emde', 'Dirkjan Bussink (dbussink)', 'Dan Kubb (dkubb)' ]
+  gem.email            = [ 'me@martinemde.com', "gamsnjaga@gmail.com" ]
+  gem.summary          = "Ardm fork of dm-transactions"
+  gem.description      = "Makes transaction support available for adapters that support them"
+  gem.homepage         = "https://github.com/ar-dm/ardm-transactions"
+  gem.license          = 'MIT'
+
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  gem.extra_rdoc_files = %w[LICENSE README.rdoc]
+
+  gem.require_paths    = [ "lib" ]
+
+  gem.add_runtime_dependency 'ardm-core', '~> 1.2'
+
+  gem.add_development_dependency 'rake',  '~> 0.9'
+  gem.add_development_dependency 'rspec', '~> 1.3'
+end

data/lib/ardm-transactions.rb

@@ -0,0 +1 @@
+require 'dm-transactions'

data/lib/dm-transactions.rb

@@ -0,0 +1,443 @@
+require 'dm-core'
+
+module DataMapper
+  class Transaction
+    extend Chainable
+
+    # @api private
+    attr_accessor :state
+
+    # @api private
+    def none?
+      state == :none
+    end
+
+    # @api private
+    def begin?
+      state == :begin
+    end
+
+    # @api private
+    def rollback?
+      state == :rollback
+    end
+
+    # @api private
+    def commit?
+      state == :commit
+    end
+
+    # Create a new Transaction
+    #
+    # @see Transaction#link
+    #
+    # In fact, it just calls #link with the given arguments at the end of the
+    # constructor.
+    #
+    # @api public
+    def initialize(*things)
+      @transaction_primitives = {}
+      self.state = :none
+      @adapters = {}
+      link(*things)
+      if block_given?
+        warn "Passing block to #{self.class.name}.new is deprecated (#{caller[0]})"
+        commit { |*block_args| yield(*block_args) }
+      end
+    end
+
+    # Associate this Transaction with some things.
+    #
+    # @param [Object] things
+    #   the things you want this Transaction associated with:
+    #
+    #   Adapters::AbstractAdapter subclasses will be added as
+    #     adapters as is.
+    #   Arrays will have their elements added.
+    #   Repository will have it's own @adapters added.
+    #   Resource subclasses will have all the repositories of all
+    #     their properties added.
+    #   Resource instances will have all repositories of all their
+    #     properties added.
+    #
+    # @param [Proc] block
+    #   a block (taking one argument, the Transaction) to execute within
+    #   this transaction. The transaction will begin and commit around
+    #   the block, and rollback if an exception is raised.
+    #
+    # @api private
+    def link(*things)
+      unless none?
+        raise "Illegal state for link: #{state}"
+      end
+
+      things.each do |thing|
+        case thing
+          when DataMapper::Adapters::AbstractAdapter
+            @adapters[thing] = :none
+          when DataMapper::Repository
+            link(thing.adapter)
+          when DataMapper::Model
+            link(*thing.repositories)
+          when DataMapper::Resource
+            link(thing.model)
+          when Array
+            link(*thing)
+          else
+            raise "Unknown argument to #{self.class}#link: #{thing.inspect} (#{thing.class})"
+        end
+      end
+
+      if block_given?
+        commit { |*block_args| yield(*block_args) }
+      else
+        self
+      end
+    end
+
+    # Begin the transaction
+    #
+    # Before #begin is called, the transaction is not valid and can not be used.
+    #
+    # @api private
+    def begin
+      unless none?
+        raise "Illegal state for begin: #{state}"
+      end
+
+      each_adapter(:connect_adapter, [:log_fatal_transaction_breakage])
+      each_adapter(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      self.state = :begin
+    end
+
+    # Commit the transaction
+    #
+    #   If no block is given, it will simply commit any changes made since the
+    #   Transaction did #begin.
+    #
+    # @param block<Block>   a block (taking the one argument, the Transaction) to
+    #   execute within this transaction. The transaction will begin and commit
+    #   around the block, and roll back if an exception is raised.
+    #
+    # @api private
+    def commit
+      if block_given?
+        unless none?
+          raise "Illegal state for commit with block: #{state}"
+        end
+
+        begin
+          self.begin
+          rval = within { |*block_args| yield(*block_args) }
+        rescue Exception => exception
+          if begin?
+            rollback
+          end
+          raise exception
+        ensure
+          unless exception
+            if begin?
+              commit
+            end
+            return rval
+          end
+        end
+      else
+        unless begin?
+          raise "Illegal state for commit without block: #{state}"
+        end
+        each_adapter(:commit_adapter, [:log_fatal_transaction_breakage])
+        each_adapter(:close_adapter, [:log_fatal_transaction_breakage])
+        self.state = :commit
+      end
+    end
+
+    # Rollback the transaction
+    #
+    # Will undo all changes made during the transaction.
+    #
+    # @api private
+    def rollback
+      unless begin?
+        raise "Illegal state for rollback: #{state}"
+      end
+      each_adapter(:rollback_adapter_if_begin, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      each_adapter(:close_adapter_if_open, [:log_fatal_transaction_breakage])
+      self.state = :rollback
+    end
+
+    # Execute a block within this Transaction.
+    #
+    # No #begin, #commit or #rollback is performed in #within, but this
+    # Transaction will pushed on the per thread stack of transactions for each
+    # adapter it is associated with, and it will ensures that it will pop the
+    # Transaction away again after the block is finished.
+    #
+    # @param block<Block> the block of code to execute.
+    #
+    # @api private
+    def within
+      unless block_given?
+        raise 'No block provided'
+      end
+
+      unless begin?
+        raise "Illegal state for within: #{state}"
+      end
+
+      adapters = @adapters
+
+      adapters.each_key do |adapter|
+        adapter.push_transaction(self)
+      end
+
+      begin
+        yield self
+      ensure
+        adapters.each_key do |adapter|
+          adapter.pop_transaction
+        end
+      end
+    end
+
+    # @api private
+    def method_missing(method, *args, &block)
+      first_arg = args.first
+
+      return super unless args.size == 1 && first_arg.kind_of?(Adapters::AbstractAdapter)
+      return super unless match = method.to_s.match(/\A(.*)_(if|unless)_(none|begin|rollback|commit)\z/)
+
+      action, condition, expected_state = match.captures
+      return super unless respond_to?(action, true)
+
+      state   = state_for(first_arg).to_s
+      execute = (condition == 'if') == (state == expected_state)
+
+      send(action, first_arg) if execute
+    end
+
+    # @api private
+    def primitive_for(adapter)
+      unless @adapters.include?(adapter)
+        raise "Unknown adapter #{adapter}"
+      end
+
+      unless @transaction_primitives.include?(adapter)
+        raise "No primitive for #{adapter}"
+      end
+
+      @transaction_primitives[adapter]
+    end
+
+    private
+
+    # @api private
+    def validate_primitive(primitive)
+      [:close, :begin, :rollback, :commit].each do |meth|
+        unless primitive.respond_to?(meth)
+          raise "Invalid primitive #{primitive}: doesnt respond_to?(#{meth.inspect})"
+        end
+      end
+
+      primitive
+    end
+
+    # @api private
+    def each_adapter(method, on_fail)
+      adapters = @adapters
+      begin
+        adapters.each_key do |adapter|
+          send(method, adapter)
+        end
+      rescue Exception => exception
+        adapters.each_key do |adapter|
+          on_fail.each do |fail_handler|
+            begin
+              send(fail_handler, adapter)
+            rescue Exception => inner_exception
+              DataMapper.logger.fatal("#{self}#each_adapter(#{method.inspect}, #{on_fail.inspect}) failed with #{exception.inspect}: #{exception.backtrace.join("\n")} - and when sending #{fail_handler} to #{adapter} we failed again with #{inner_exception.inspect}: #{inner_exception.backtrace.join("\n")}")
+            end
+          end
+        end
+        raise exception
+      end
+    end
+
+    # @api private
+    def state_for(adapter)
+      unless @adapters.include?(adapter)
+        raise "Unknown adapter #{adapter}"
+      end
+
+      @adapters[adapter]
+    end
+
+    # @api private
+    def do_adapter(adapter, what, prerequisite)
+      unless @transaction_primitives.include?(adapter)
+        raise "No primitive for #{adapter}"
+      end
+
+      state = state_for(adapter)
+
+      unless state == prerequisite
+        raise "Illegal state for #{what}: #{state}"
+      end
+
+      DataMapper.logger.debug("#{adapter.name}: #{what}")
+      @transaction_primitives[adapter].send(what)
+      @adapters[adapter] = what
+    end
+
+    # @api private
+    def log_fatal_transaction_breakage(adapter)
+      DataMapper.logger.fatal("#{self} experienced a totally broken transaction execution. Presenting member #{adapter.inspect}.")
+    end
+
+    # @api private
+    def connect_adapter(adapter)
+      if @transaction_primitives.key?(adapter)
+        raise "Already a primitive for adapter #{adapter}"
+      end
+
+      @transaction_primitives[adapter] = validate_primitive(adapter.transaction_primitive)
+    end
+
+    # @api private
+    def close_adapter_if_open(adapter)
+      if @transaction_primitives.include?(adapter)
+        close_adapter(adapter)
+      end
+    end
+
+    # @api private
+    def close_adapter(adapter)
+      unless @transaction_primitives.include?(adapter)
+        raise 'No primitive for adapter'
+      end
+
+      @transaction_primitives[adapter].close
+      @transaction_primitives.delete(adapter)
+    end
+
+    # @api private
+    def begin_adapter(adapter)
+      do_adapter(adapter, :begin, :none)
+    end
+
+    # @api private
+    def commit_adapter(adapter)
+      do_adapter(adapter, :commit, :begin)
+    end
+
+    # @api private
+    def rollback_adapter(adapter)
+      do_adapter(adapter, :rollback, :begin)
+    end
+
+    # @api private
+    def rollback_and_close_adapter(adapter)
+      rollback_adapter(adapter)
+      close_adapter(adapter)
+    end
+
+    module Repository
+
+      # Produce a new Transaction for this Repository
+      #
+      # @return [Adapters::Transaction]
+      #   a new Transaction (in state :none) that can be used
+      #   to execute code #with_transaction
+      #
+      # @api public
+      def transaction
+        Transaction.new(self)
+      end
+    end # module Repository
+
+    module Model
+      # @api private
+      def self.included(mod)
+        mod.descendants.each { |model| model.extend self }
+      end
+
+      # Produce a new Transaction for this Resource class
+      #
+      # @return <Adapters::Transaction
+      #   a new Adapters::Transaction with all Repositories
+      #   of the class of this Resource added.
+      #
+      # @api public
+      def transaction
+        transaction = Transaction.new(self)
+        transaction.commit { |block_args| yield(*block_args) }
+      end
+    end # module Model
+
+    module Resource
+
+      # Produce a new Transaction for the class of this Resource
+      #
+      # @return [Adapters::Transaction]
+      #   a new Adapters::Transaction for the Repository
+      #   of the class of this Resource added.
+      #
+      # @api public
+      def transaction
+        model.transaction { |*block_args| yield(*block_args) }
+      end
+    end # module Resource
+
+    def self.include_transaction_api
+      [ :Repository, :Model, :Resource ].each do |name|
+        DataMapper.const_get(name).send(:include, const_get(name))
+      end
+      Adapters::AbstractAdapter.descendants.each do |adapter_class|
+        Adapters.include_transaction_api(DataMapper::Inflector.demodulize(adapter_class.name))
+      end
+    end
+
+  end # class Transaction
+
+  module Adapters
+
+    def self.include_transaction_api(const_name)
+      require transaction_extensions(const_name)
+      if Transaction.const_defined?(const_name)
+        adapter = const_get(const_name)
+        adapter.send(:include, transaction_module(const_name))
+      end
+    rescue LoadError
+      # Silently ignore the fact that no adapter extensions could be required
+      # This means that the adapter in use doesn't support transactions
+    end
+
+    def self.transaction_module(const_name)
+      Transaction.const_get(const_name)
+    end
+
+    class << self
+    private
+
+      # @api private
+      def transaction_extensions(const_name)
+        name = adapter_name(const_name)
+        name = 'do' if name == 'dataobjects'
+        "dm-transactions/adapters/dm-#{name}-adapter"
+      end
+
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+        include_transaction_api(const_name)
+        super
+      end
+    end
+
+  end # module Adapters
+
+  Transaction.include_transaction_api
+
+end # module DataMapper

data/lib/dm-transactions/adapters/dm-do-adapter.rb

@@ -0,0 +1,112 @@
+module DataMapper
+  class Transaction
+
+    module DataObjectsAdapter
+      extend Chainable
+
+      # Produces a fresh transaction primitive for this Adapter
+      #
+      # Used by Transaction to perform its various tasks.
+      #
+      # @return [Object]
+      #   a new Object that responds to :close, :begin, :commit,
+      #   and :rollback,
+      #
+      # @api private
+      def transaction_primitive
+        if current_transaction && supports_savepoints?
+          DataObjects::SavePoint.create_for_uri(normalized_uri, current_connection)
+        else
+          DataObjects::Transaction.create_for_uri(normalized_uri)
+        end
+      end
+
+      # Pushes the given Transaction onto the per thread Transaction stack so
+      # that everything done by this Adapter is done within the context of said
+      # Transaction.
+      #
+      # @param [Transaction] transaction
+      #   a Transaction to be the 'current' transaction until popped.
+      #
+      # @return [Array(Transaction)]
+      #   the stack of active transactions for the current thread
+      #
+      # @api private
+      def push_transaction(transaction)
+        transactions << transaction
+      end
+
+      # Pop the 'current' Transaction from the per thread Transaction stack so
+      # that everything done by this Adapter is no longer necessarily within the
+      # context of said Transaction.
+      #
+      # @return [Transaction]
+      #   the former 'current' transaction.
+      #
+      # @api private
+      def pop_transaction
+        transactions.pop
+      end
+
+      # Retrieve the current transaction for this Adapter.
+      #
+      # Everything done by this Adapter is done within the context of this
+      # Transaction.
+      #
+      # @return [Transaction]
+      #   the 'current' transaction for this Adapter.
+      #
+      # @api private
+      def current_transaction
+        transactions.last
+      end
+
+      chainable do
+        protected
+
+        # @api semipublic
+        def open_connection
+          current_connection || super
+        end
+
+        # @api semipublic
+        def close_connection(connection)
+          super unless current_connection.equal?(connection)
+        end
+      end
+
+      private
+
+      # @api private
+      def transactions
+        Thread.current[:dm_transactions]            ||= {}
+        Thread.current[:dm_transactions][object_id] ||= []
+      end
+
+      # Retrieve the current connection for this Adapter.
+      #
+      # @return [Transaction]
+      #   the 'current' connection for this Adapter.
+      #
+      # @api private
+      def current_connection
+        if transaction = current_transaction
+          transaction.primitive_for(self).connection
+        end
+      end
+
+      # Indicate whether adapter supports transactional savepoints.  Not all DO
+      # adapters do, so default to false.
+      #
+      # @return [Boolean]
+      #   whether or not the adapter supports savepoints
+      #
+      # @api private
+      def supports_savepoints?
+        false
+      end
+
+    end # module DataObjectsAdapter
+
+  end # class Transaction
+end # module DataMapper

data/lib/dm-transactions/adapters/dm-mysql-adapter.rb

@@ -0,0 +1,15 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module MysqlAdapter
+      include DataObjectsAdapter
+
+      def supports_savepoints?
+        true
+      end
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-oracle-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module OracleAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-postgres-adapter.rb

@@ -0,0 +1,15 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module PostgresAdapter
+      include DataObjectsAdapter
+
+      def supports_savepoints?
+        true
+      end
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-sqlite-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module SqliteAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/adapters/dm-sqlserver-adapter.rb

@@ -0,0 +1,11 @@
+require 'dm-transactions/adapters/dm-do-adapter'
+
+module DataMapper
+  class Transaction
+
+    module SqlserverAdapter
+      include DataObjectsAdapter
+    end
+
+  end
+end

data/lib/dm-transactions/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Transactions
+    VERSION = '1.2.0'
+  end
+end

data/spec/isolated/require_after_setup_spec.rb

@@ -0,0 +1,21 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+if %w[ postgres mysql sqlite oracle sqlserver ].include?(ENV['ADAPTER'])
+
+  describe "require 'dm-transactions after calling DataMapper.setup" do
+
+    before(:all) do
+      @adapter = DataMapper::Spec.adapter
+      require 'dm-transactions'
+    end
+
+    it_should_behave_like "require 'dm-transactions'"
+
+  end
+
+end

data/spec/isolated/require_before_setup_spec.rb

@@ -0,0 +1,21 @@
+require 'spec'
+require 'isolated/require_spec'
+require 'dm-core/spec/setup'
+
+# To really test this behavior, this spec needs to be run in isolation and not
+# as part of the typical rake spec run, which requires dm-transactions upfront
+
+if %w[ postgres mysql sqlite oracle sqlserver ].include?(ENV['ADAPTER'])
+
+  describe "require 'dm-transactions' before calling DataMapper.setup" do
+
+    before(:all) do
+      require 'dm-transactions'
+      @adapter = DataMapper::Spec.adapter
+    end
+
+    it_should_behave_like "require 'dm-transactions'"
+
+  end
+
+end

data/spec/isolated/require_spec.rb

@@ -0,0 +1,15 @@
+shared_examples_for "require 'dm-transactions'" do
+
+  %w[ Repository Model Resource ].each do |name|
+    it "should include the transaction api in DataMapper::#{name}" do
+      (DataMapper.const_get(name) < DataMapper::Transaction.const_get(name)).should be(true)
+    end
+  end
+
+  it "should include the transaction api into the adapter" do
+    @adapter.respond_to?(:push_transaction   ).should be(true)
+    @adapter.respond_to?(:pop_transaction    ).should be(true)
+    @adapter.respond_to?(:current_transaction).should be(true)
+  end
+
+end

data/spec/public/dm-transactions_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe DataMapper::Resource, 'Transactions' do
+  before :all do
+    module ::Blog
+      class User
+        include DataMapper::Resource
+
+        property :name,        String, :key => true
+        property :age,         Integer
+        property :summary,     Text
+        property :description, Text
+        property :admin,       Boolean, :accessor => :private
+
+        belongs_to :parent, self, :required => false
+        has n, :children, self, :inverse => :parent
+
+        belongs_to :referrer, self, :required => false
+        has n, :comments
+
+        # FIXME: figure out a different approach than stubbing things out
+        def comment=(*)
+          # do nothing with comment
+        end
+      end
+
+      class Author < User; end
+
+      class Comment
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        belongs_to :user
+      end
+
+      class Article
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+
+        has n, :paragraphs
+      end
+
+      class Paragraph
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :text, String
+
+        belongs_to :article
+      end
+    end
+
+    class ::Default
+      include DataMapper::Resource
+
+      property :name, String, :key => true, :default => 'a default value'
+    end
+
+    @user_model      = Blog::User
+    @author_model    = Blog::Author
+    @comment_model   = Blog::Comment
+    @article_model   = Blog::Article
+    @paragraph_model = Blog::Paragraph
+  end
+
+  supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+    before :all do
+      user = @user_model.create(:name => 'dbussink', :age => 25, :description => 'Test')
+
+      @user = @user_model.get(*user.key)
+    end
+
+    before do
+      # --- Temporary private api use to get around rspec limitations ---
+      @repository.scope do |repository|
+        transaction = DataMapper::Transaction.new(repository)
+        transaction.begin
+        repository.adapter.push_transaction(transaction)
+      end
+    end
+
+    after do
+      while @repository.adapter.current_transaction
+        @repository.adapter.pop_transaction.rollback
+      end
+    end
+
+    it_should_behave_like 'A public Resource'
+    it_should_behave_like 'A Resource supporting Strategic Eager Loading'
+  end
+
+  describe '#transaction' do
+    before :all do
+      class ::Author
+        include DataMapper::Resource
+
+        property :name, String, :key => true
+      end
+    end
+
+    supported_by :postgres, :mysql do
+      before do
+        @user_model.destroy!
+      end
+
+      it 'should support nested transactions' do
+        # can't assume dm-aggregates
+        begin
+          @user_model.all.length.should == 0
+
+          @user_model.transaction do # txn 1
+            @user_model.create(:name => 'jpr5')
+
+            @user_model.all.length.should == 1
+
+            begin
+              @user_model.transaction do # savepoint 1
+                @user_model.create(:name => 'dkubb')
+                @user_model.all.length.should == 2
+
+                raise
+              end
+            rescue => e
+              @user_model.all.length.should == 1
+            end
+
+            raise
+          end
+        rescue => e
+          @user_model.all.length.should == 0
+        end
+      end
+    end
+
+    supported_by :postgres, :mysql, :sqlite, :oracle, :sqlserver do
+      before do
+        @user_model.destroy!
+      end
+
+      it 'should have access to resources presisted before the transaction' do
+        @user_model.create(:name => 'carllerche')
+        @user_model.transaction do
+          @user_model.first.name.should == 'carllerche'
+        end
+      end
+
+      it 'should have access to resources persisted in the transaction' do
+        @user_model.transaction do
+          @user_model.create(:name => 'carllerche')
+          @user_model.first.name.should == 'carllerche'
+        end
+      end
+
+      it 'should not mark saved resources as new records' do
+        @user_model.transaction do
+          @user_model.create(:name => 'carllerche').should_not be_new
+        end
+      end
+
+      it 'should rollback when an error is raised in a transaction' do
+        @user_model.all.size.should == 0
+        lambda {
+          @user_model.transaction do
+            @user_model.create(:name => 'carllerche')
+            raise 'I love coffee'
+          end
+        }.should raise_error('I love coffee')
+        @user_model.all.size.should == 0
+      end
+
+      it 'should close the transaction if return is called within the closure' do
+        @txn = nil
+
+        def doit
+          @user_model.transaction do |transaction|
+            @txn = transaction
+            return
+          end
+        end
+        doit
+
+        @txn.instance_variable_get(:@state).should == :commit
+        @txn = nil
+      end
+
+      it 'should return the last statement in the transaction block' do
+        @user_model.transaction { 1 }.should == 1
+      end
+
+      with_alternate_adapter do
+        before :all do
+          class ::Article
+            include DataMapper::Resource
+
+            def self.default_repository_name
+              :alternate
+            end
+
+            property :title, String, :key => true
+          end
+
+          DataMapper.auto_migrate!(:alternate)
+        end
+
+        it 'should work with other repositories' do
+          expect {
+            DataMapper.repository.transaction.commit do
+              Author.create(:name => 'Dan Kubb')
+
+              # save a resource to another repository
+              Article.create(:title => 'DataMapper Rocks!')
+            end
+          }.should_not raise_error
+        end
+      end
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'dm-transactions'
+
+require 'dm-core/spec/setup'
+require 'dm-core/spec/lib/spec_helper'
+require 'dm-core/spec/lib/pending_helpers'
+require 'dm-core/spec/lib/adapter_helpers'
+require 'dm-core/spec/lib/counter_adapter'
+require 'dm-core/spec/shared/resource_spec'
+require 'dm-core/spec/shared/sel_spec'
+
+Spec::Runner.configure do |config|
+
+  config.extend(DataMapper::Spec::Adapters::Helpers)
+  config.include(DataMapper::Spec::PendingHelpers)
+
+  config.after :all do
+    DataMapper::Spec.cleanup_models
+  end
+
+end

data/tasks/spec.rake

@@ -0,0 +1,38 @@
+spec_defaults = lambda do |spec|
+  spec.pattern    = 'spec/**/*_spec.rb'
+  spec.libs      << 'lib' << 'spec'
+  spec.spec_opts << '--options' << 'spec/spec.opts'
+end
+
+begin
+  require 'spec/rake/spectask'
+
+  Spec::Rake::SpecTask.new(:spec, &spec_defaults)
+rescue LoadError
+  task :spec do
+    abort 'rspec is not available. In order to run spec, you must: gem install rspec'
+  end
+end
+
+begin
+  require 'rcov'
+  require 'spec/rake/verify_rcov'
+
+  Spec::Rake::SpecTask.new(:rcov) do |rcov|
+    spec_defaults.call(rcov)
+    rcov.rcov      = true
+    rcov.rcov_opts = File.read('spec/rcov.opts').split(/\s+/)
+  end
+
+  RCov::VerifyTask.new(:verify_rcov => :rcov) do |rcov|
+    rcov.threshold = 100
+  end
+rescue LoadError
+  %w[ rcov verify_rcov ].each do |name|
+    task name do
+      abort "rcov is not available. In order to run #{name}, you must: gem install rcov"
+    end
+  end
+end
+
+task :default => :spec

data/tasks/yard.rake

@@ -0,0 +1,9 @@
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yard do
+    abort 'YARD is not available. In order to run yard, you must: gem install yard'
+  end
+end

data/tasks/yardstick.rake

@@ -0,0 +1,19 @@
+begin
+  require 'pathname'
+  require 'yardstick/rake/measurement'
+  require 'yardstick/rake/verify'
+
+  # yardstick_measure task
+  Yardstick::Rake::Measurement.new
+
+  # verify_measurements task
+  Yardstick::Rake::Verify.new do |verify|
+    verify.threshold = 100
+  end
+rescue LoadError
+  %w[ yardstick_measure verify_measurements ].each do |name|
+    task name.to_s do
+      abort "Yardstick is not available. In order to run #{name}, you must: gem install yardstick"
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ardm-transactions
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Martin Emde
+- Dirkjan Bussink (dbussink)
+- Dan Kubb (dkubb)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ardm-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Makes transaction support available for adapters that support them
+email:
+- me@martinemde.com
+- gamsnjaga@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- ".document"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.rdoc
+- Rakefile
+- ardm-transactions.gemspec
+- lib/ardm-transactions.rb
+- lib/dm-transactions.rb
+- lib/dm-transactions/adapters/dm-do-adapter.rb
+- lib/dm-transactions/adapters/dm-mysql-adapter.rb
+- lib/dm-transactions/adapters/dm-oracle-adapter.rb
+- lib/dm-transactions/adapters/dm-postgres-adapter.rb
+- lib/dm-transactions/adapters/dm-sqlite-adapter.rb
+- lib/dm-transactions/adapters/dm-sqlserver-adapter.rb
+- lib/dm-transactions/version.rb
+- spec/isolated/require_after_setup_spec.rb
+- spec/isolated/require_before_setup_spec.rb
+- spec/isolated/require_spec.rb
+- spec/public/dm-transactions_spec.rb
+- spec/rcov.opts
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/spec.rake
+- tasks/yard.rake
+- tasks/yardstick.rake
+homepage: https://github.com/ar-dm/ardm-transactions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ardm fork of dm-transactions
+test_files: []
+has_rdoc: