class OrmAdapter::Base

def self.inherited(adapter)

Other tags:
    See: orm_adapters/mongoid -
    See: orm_adapters/datamapper -
    See: orm_adapters/active_record - 
def self.inherited(adapter)
  OrmAdapter.adapters << adapter
  super
end

def self.model_classes

Gets a list of the available models for this adapter 
def self.model_classes
  raise NotImplementedError, "return a list of available models for this adapter"
end

def column_names

Get a list of column/property/field names 
def column_names
  raise NotSupportedError
end

def create!(attributes)

Create a model using attributes 
def create!(attributes)
  raise NotSupportedError
end

def extract_conditions_and_order!(options = {})

given an options hash, with optional :conditions and :order keys, returns conditions and normalized order 
def extract_conditions_and_order!(options = {})
  order = normalize_order(options.delete(:order))
  conditions = options.delete(:conditions) || options
  [conditions, order]
end

def find_all(options)

Other tags:
    See: OrmAdapter::Base#find_first - for how to specify order and conditions 
def find_all(options)
  raise NotSupportedError
end

def find_first(options)


* an array of single args or pairs (with :asc or :desc as last), e.g. :order => [[:name, :asc], [:age, :desc]]
* a single pair with :asc, or :desc as last, e.g. :order => [:name, :desc]
* a single arg e.g. :order => :name
When specifying :order, it may be

User.to_adapter.find_first :order => :name, :conditions => {:age => 18}
User.to_adapter.find_first :order => [:age, :desc]
User.to_adapter.find_first :conditions => {:name => "Fred", :age => 23}

Or you can specify :order, and :conditions as keys

User.to_adapter.find_first :name => "Fred", :age => 23

You can call with just conditions, providing a hash

Find the first instance, optionally matching conditions, and specifying order 
def find_first(options)
  raise NotSupportedError
end

def get


User.to_adapter.get(@user.to_key) == @user

This should comply with ActiveModel#to_key API, i.e.:
Get an instance by id of the model. Returns nil if a model is not found. 
def get
  raise NotSupportedError
end

def get!(id)


User.to_adapter.get!(@user.to_key) == @user

This should comply with ActiveModel#to_key API, i.e.:
Get an instance by id of the model. Raises an error if a model is not found. 
def get!(id)
  raise NotSupportedError
end

def initialize(klass) 

def initialize(klass)
  @klass = klass
end

def normalize_order(order)

given an order argument, returns an array of pairs, with each pair containing the attribute, and :asc or :desc 
def normalize_order(order)
  order = Array(order)
  
  if order.length == 2 && !order[0].is_a?(Array) && [:asc, :desc].include?(order[1])
    order = [order]
  else
    order = order.map {|pair| pair.is_a?(Array) ? pair : [pair, :asc] }
  end
  
  order.each do |pair|
    pair.length == 2 or raise ArgumentError, "each order clause must be a pair (unknown clause #{pair.inspect})"
    [:asc, :desc].include?(pair[1]) or raise ArgumentError, "order must be specified with :asc or :desc (unknown key #{pair[1].inspect})"
  end
  
  order
end

def wrap_key(key) 

def wrap_key(key)
  key.is_a?(Array) ? key.first : key
end