dm-transactions 1.0.0.rc1

data/.document

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

data/.gitignore

@@ -0,0 +1,37 @@
+## 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.local
+Gemfile.lock
+
+## PROJECT::SPECIFIC
+spec/db/
+spec/log/

data/Gemfile

@@ -0,0 +1,141 @@
+# If you're working on more than one datamapper gem at a time, then it's
+# recommended to create a local Gemfile and use this instead of the git
+# sources. This will make sure that you are  developing against your
+# other local datamapper sources that you currently work on. Gemfile.local
+# will behave identically to the standard Gemfile apart from the fact that
+# it fetches the datamapper gems from local paths. This means that you can use
+# the same environment variables, like ADAPTER(S) or PLUGIN(S) when running
+# bundle commands. Gemfile.local is added to .gitignore, so you don't need to
+# worry about accidentally checking local development paths into git.
+# In order to create a local Gemfile, all you need to do is run:
+#
+#   bundle exec rake local_gemfile
+#
+# This will give you a Gemfile.local file that points to your local clones of
+# the various datamapper gems. It's assumed that all datamapper repo clones
+# reside in the same directory. You can use the Gemfile.local like so for
+# running any bundle command:
+#
+#   BUNDLE_GEMFILE=Gemfile.local bundle foo
+#
+# You can also specify which adapter(s) should be part of the bundle by setting
+# an environment variable. This of course also works when using the Gemfile.local
+#
+#   bundle foo                        # dm-sqlite-adapter
+#   ADAPTER=mysql bundle foo          # dm-mysql-adapter
+#   ADAPTERS=sqlite,mysql bundle foo  # dm-sqlite-adapter and dm-mysql-adapter
+#
+# Of course you can also use the ADAPTER(S) variable when using the Gemfile.local
+# and running specs against selected adapters.
+#
+# For easily working with adapters supported on your machine, it's recommended
+# that you first install all adapters that you are planning to use or work on
+# by doing something like
+#
+#   ADAPTERS=sqlite,mysql,postgres bundle install
+#
+# This will clone the various repositories and make them available to bundler.
+# Once you have them installed you can easily switch between adapters for the
+# various development tasks. Running something like
+#
+#   ADAPTER=mysql bundle exec rake spec
+#
+# will make sure that the dm-mysql-adapter is part of the bundle, and will be used
+# when running the specs.
+#
+# You can also specify which plugin(s) should be part of the bundle by setting
+# an environment variable. This also works when using the Gemfile.local
+#
+#   bundle foo                                 # dm-migrations
+#   PLUGINS=dm-validations bundle foo          # dm-migrations and dm-validations
+#   PLUGINS=dm-validations,dm-types bundle foo # dm-migrations, dm-validations and dm-types
+#
+# Of course you can combine the PLUGIN(S) and ADAPTER(S) env vars to run specs
+# for certain adapter/plugin combinations.
+#
+# Finally, to speed up running specs and other tasks, it's recommended to run
+#
+#   bundle lock
+#
+# after running 'bundle install' for the first time. This will make 'bundle exec' run
+# a lot faster compared to the unlocked version. With an unlocked bundle you would
+# typically just run 'bundle install' from time to time to fetch the latest sources from
+# upstream. When you locked your bundle, you need to run
+#
+#   bundle install --relock
+#
+# to make sure to fetch the latest updates and then lock the bundle again. Gemfile.lock
+# is added to the .gitignore file, so you don't need to worry about accidentally checking
+# it into version control.
+
+source 'http://rubygems.org'
+
+DATAMAPPER = 'git://github.com/datamapper'
+DM_VERSION = '~> 1.0.0.rc1'
+DO_VERSION = '~> 0.10.2'
+
+group :runtime do # Runtime dependencies (as in the gemspec)
+
+  if ENV['EXTLIB']
+    gem 'extlib',        '~> 0.9.15',      :git => "#{DATAMAPPER}/extlib.git"
+  else
+    gem 'activesupport', '~> 3.0.0.beta3', :git => 'git://github.com/rails/rails.git', :require => nil
+  end
+
+  gem 'dm-core', DM_VERSION, :git => "#{DATAMAPPER}/dm-core.git"
+
+end
+
+group(:development) do # Development dependencies (as in the gemspec)
+
+  gem 'rake',           '~> 0.8.7'
+  gem 'rspec',          '~> 1.3'
+  gem 'jeweler',        '~> 1.4'
+
+end
+
+group :quality do # These gems contain rake tasks that check the quality of the source code
+
+  gem 'metric_fu',      '~> 1.3'
+  gem 'rcov',           '~> 0.9.7'
+  gem 'reek',           '~> 1.2.7'
+  gem 'roodi',          '~> 2.1'
+  gem 'yard',           '~> 0.5'
+  gem 'yardstick',      '~> 0.1'
+
+end
+
+group :datamapper do # We need this because we want to pin these dependencies to their git master sources
+
+  adapters = ENV['ADAPTER'] || ENV['ADAPTERS']
+  adapters = adapters.to_s.gsub(',',' ').split(' ') - ['in_memory']
+
+  unless adapters.empty?
+
+    DM_DO_ADAPTERS = %w[sqlite postgres mysql oracle sqlserver]
+
+    gem 'data_objects',  DO_VERSION, :git => "#{DATAMAPPER}/do.git"
+
+    adapters.each do |adapter|
+      if DM_DO_ADAPTERS.any? { |dm_do_adapter| dm_do_adapter =~ /#{adapter}/  }
+        adapter = 'sqlite3' if adapter == 'sqlite'
+        gem "do_#{adapter}", DO_VERSION, :git => "#{DATAMAPPER}/do.git"
+      end
+    end
+
+    gem 'dm-do-adapter', DM_VERSION, :git => "#{DATAMAPPER}/dm-do-adapter.git"
+
+    adapters.each do |adapter|
+      gem "dm-#{adapter}-adapter", DM_VERSION, :git => "#{DATAMAPPER}/dm-#{adapter}-adapter.git"
+    end
+
+  end
+
+  plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+  plugins = (plugins.to_s.gsub(',',' ').split(' ') + ['dm-migrations']).uniq
+
+  plugins.each do |plugin|
+    gem plugin, DM_VERSION, :git => "#{DATAMAPPER}/#{plugin}.git"
+  end
+
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 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) 2010 snusnu. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'rake'
+
+begin
+
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "dm-transactions"
+    gem.summary     = %Q{Adds transaction support to datamapper}
+    gem.description = %Q{Makes transaction support available for adapters that support them}
+    gem.email       = "gamsnjaga@gmail.com"
+    gem.homepage    = "http://github.com/datamapper/dm-transactions"
+    gem.authors     = ["Dirkjan Bussink (dbussink)", "Dan Kubb (dkubb)"]
+
+    gem.add_dependency 'dm-core', '~> 1.0.0.rc1'
+
+    gem.add_development_dependency 'rspec',   '~> 1.3'
+
+  end
+
+  Jeweler::GemcutterTasks.new
+
+  FileList['tasks/**/*.rake'].each { |task| import task }
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0.rc1

data/dm-transactions.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-transactions}
+  s.version = "1.0.0.rc1"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dirkjan Bussink (dbussink)", "Dan Kubb (dkubb)"]
+  s.date = %q{2010-05-19}
+  s.description = %q{Makes transaction support available for adapters that support them}
+  s.email = %q{gamsnjaga@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "Gemfile",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "dm-transactions.gemspec",
+     "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",
+     "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/ci.rake",
+     "tasks/local_gemfile.rake",
+     "tasks/metrics.rake",
+     "tasks/spec.rake",
+     "tasks/yard.rake",
+     "tasks/yardstick.rake"
+  ]
+  s.homepage = %q{http://github.com/datamapper/dm-transactions}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Adds transaction support to datamapper}
+  s.test_files = [
+    "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/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<dm-core>, ["~> 1.0.0.rc1"])
+      s.add_development_dependency(%q<rspec>, ["~> 1.3"])
+    else
+      s.add_dependency(%q<dm-core>, ["~> 1.0.0.rc1"])
+      s.add_dependency(%q<rspec>, ["~> 1.3"])
+    end
+  else
+    s.add_dependency(%q<dm-core>, ["~> 1.0.0.rc1"])
+    s.add_dependency(%q<rspec>, ["~> 1.3"])
+  end
+end
+

data/lib/dm-transactions.rb

@@ -0,0 +1,444 @@
+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, Transaction.const_get(name))
+      end
+      DataMapper::Repository.adapters.values.each do |adapter|
+        Adapters.include_transaction_api(ActiveSupport::Inflector.demodulize(adapter.class.name))
+      end
+    end
+
+  end # class Transaction
+
+  module Adapters
+
+    class << self
+
+      def include_transaction_api(const_name)
+        require transaction_extensions(const_name)
+        adapter = const_get(const_name)
+        if DataMapper::Transaction.const_defined?(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 transaction_module(const_name)
+        DataMapper::Transaction.const_get(const_name)
+      end
+
+    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