class ActiveRecord::ConnectionAdapters::OpenTransaction

:nodoc:

def add_record(record) 

def add_record(record)
  if record.has_transactional_callbacks?
    records << record
  else
    record.set_transaction_state(@state)
  end
end

def begin(options = {}) 

def begin(options = {})
  if finishing?
    parent.begin
  else
    SavepointTransaction.new(connection, self, options)
  end
end

def closed? 

def closed?
  false
end

def commit 

def commit
  @finishing = true
  perform_commit
  parent
end

def commit_records 

def commit_records
  @state.set_state(:committed)
  records.uniq.each do |record|
    begin
      record.committed!
    rescue => e
      record.logger.error(e) if record.respond_to?(:logger) && record.logger
    end
  end
end

def finishing?

find a better way to structure it in the future.
happen in a commit/rollback. But it's kinda distasteful. Maybe we can
This state is necessary so that we correctly handle stuff that might 
def finishing?
  @finishing
end

def initialize(connection, parent, options = {}) 

def initialize(connection, parent, options = {})
  super connection
  @parent    = parent
  @records   = []
  @finishing = false
  @joinable  = options.fetch(:joinable, true)
end

def joinable? 

def joinable?
  @joinable && !finishing?
end

def number 

def number
  if finishing?
    parent.number
  else
    parent.number + 1
  end
end

def open? 

def open?
  true
end

def rollback 

def rollback
  @finishing = true
  perform_rollback
  parent
end

def rollback_records 

def rollback_records
  @state.set_state(:rolledback)
  records.uniq.each do |record|
    begin
      record.rolledback!(parent.closed?)
    rescue => e
      record.logger.error(e) if record.respond_to?(:logger) && record.logger
    end
  end
end