dock 1.0.1

data/lib/dock/adapters/couchdb.rb

@@ -0,0 +1,73 @@
+require 'couchrest'
+
+module Dock
+  class Couchdb < Base
+    def create(attributes = {})
+    
+    end
+    def find(id)
+    
+    end
+    def find!(id)
+    
+    end
+    def all(options = {})
+        conditions, order, limit, offset = extract_conditions!(options)
+        opts = { :conditions => conditions, :order => order_clause(order) }
+        opts = opts.merge({ :limit => limit }) unless limit.nil?
+        opts = opts.merge({ :offset => offset }) unless offset.nil?
+        model.all opts
+    end
+    def first(options = {})
+      conditions, order = extract_conditions!(options)
+      model.first :conditions => conditions, :order => order_clause(order)
+    end
+    def id()
+
+    end
+    def update(search_key, find_by, update_key, by_value)
+#2 zoo.attributes = { :name => 'The Glue Factory', :inception => Time.now }
+#3 zoo.save
+    end
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    def model_name()
+      model.class.name
+    end
+    def column_names()
+      model.properties.map(&:name)
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding()
+
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped?()
+
+    end
+    def embedded?()
+
+    end
+    def cyclic?()
+      
+    end
+    def supports_joins?()
+      false
+    end
+    def properties()
+
+    end
+  end
+end

data/lib/dock/adapters/datamapper.rb

@@ -0,0 +1,88 @@
+require 'dm-core'
+
+module Dock
+  class DataMapper < Base
+    # Checked
+    def create(attributes = {})
+        model.create(attributes)
+    end
+    # Checked
+    def find(id)
+      model.get(id)
+    end
+    # Checked
+    def find!(id)
+      model.get!(id)
+    end
+    # Checked
+    def all(options = {})
+        conditions, order, limit, offset = extract_conditions!(options)
+        opts = { :conditions => conditions, :order => order_clause(order) }
+        opts = opts.merge({ :limit => limit }) unless limit.nil?
+        opts = opts.merge({ :offset => offset }) unless offset.nil?
+        model.all opts
+    end
+    # Checked
+    def first(options = {})
+      conditions, order = extract_conditions!(options)
+      model.first :conditions => conditions, :order => order_clause(order)
+    end
+    # Checked
+    def id
+        # not supported?
+    end
+    def update(search_key, find_by, update_key, by_value)
+      entry = all(search_key find_by)
+      entry.attributes = {update_key => by_value}
+      entry.save
+    end
+    # Checked
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    def model_name
+      model.class.name
+    end
+    # Checked
+    def column_names
+      model.properties.map(&:name)
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped?
+      true
+    end
+    def embedded?
+      true
+    end
+    def cyclic?
+      false
+    end
+    def supports_joins?
+      false
+    end
+
+    def properties()
+
+    end
+    protected
+
+      def order_clause(order)
+        order.map {|pair| pair.first.send(pair.last)}
+      end
+    end
+  end

data/lib/dock/adapters/mongoid.rb

@@ -0,0 +1,98 @@
+require 'mongoid'
+
+module Dock
+  class Mongoid < Base
+    # Checked
+    def create(attributes = {})
+        model.create!(attributes)
+    end
+    # Checked
+    def find(id)
+      model.find(wrap_key(id))
+    end
+    # Checked
+    def find!(id)
+      model.where(:_id => wrap_key(id)).first
+    end
+    # Checked
+    def all(options = {})
+      conditions, order, limit, offset = extract_conditions!(options)
+      model.where(conditions_to_fields(conditions)).order_by(order).limit(limit).offset(offset)
+    end
+    # Checked
+    def first(options = {})
+      conditions, order = extract_conditions!(options)
+      model.limit(1).where(conditions_to_fields(conditions)).order_by(order).first
+    end
+    # Checked
+    def id
+      '_id'
+    end
+    # Checked
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.where(search_key, find_by)
+      entry.update_attributes!(update_key, by_value)
+    end
+    # Checked
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    # Checked
+    def model_name
+      model.class.name
+    end
+    # Checked
+    def column_names
+      model.fields.keys
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    # Checked
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    # Checked
+    def scoped?
+      model.scoped
+    end
+    # Checked
+    def embedded?
+      model.relations.values.detect { |a| a.macro.to_sym == :embedded_in }
+    end
+    # Checked
+    def cyclic?
+      model.cyclic?
+    end
+    # Checked
+    def supports_joins
+      false
+    end
+    def properties()
+
+    end
+    protected
+      # converts and documents to ids
+      def conditions_to_fields(conditions)
+        conditions.inject({}) do |fields, (key, value)|
+          if value.is_a?(Mongoid::Document) && model.fields.keys.include?("#{key}_id")
+            fields.merge("#{key}_id" => value.id)
+          elsif key.to_s == 'id'
+            fields.merge('_id' => value)
+          else
+            fields.merge(key => value)
+          end
+        end
+      end
+  end
+end

data/lib/dock/adapters/mongomapper.rb

@@ -0,0 +1,91 @@
+require 'mongo_mapper'
+
+module Dock
+  class MongoMapper < Base
+    def create(attributes = {})
+        model.create!(attributes)
+    end
+    def find(id)
+      model.find!(wrap_key(id))
+    end
+    def find!(id)
+      model.first({ :id => wrap_key(id) })
+    end
+    def all(conditions = {})
+      conditions, order, limit, offset = extract_conditions!(conditions)
+      conditions = conditions.merge(:sort => order) unless order.nil?
+      conditions = conditions.merge(:limit => limit) unless limit.nil?
+      conditions = conditions.merge(:offset => offset) unless limit.nil? || offset.nil?
+      model.all(conditions_to_fields(conditions))
+    end
+    def first(conditions = {})
+      conditions, order = extract_conditions!(conditions)
+      conditions = conditions.merge(:sort => order) unless order.nil?
+      model.first(conditions_to_fields(conditions))
+    end
+    def id
+      '_id'
+    end
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.where(search_key find_by)
+      entry.set(update_key => by_value)
+      entry.reload
+    end
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    def model_name
+      model.class.name
+    end
+    def column_names
+      model.fields.keys
+    end
+    # Checked
+    def count(conditions = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    # Checked
+    def scoped?
+      model.scoped
+    end
+    # Checked
+    def embedded?
+      model.relations.values.detect { |a| a.macro.to_sym == :embedded_in }
+    end
+    # Checked
+    def cyclic?
+      model.cyclic?
+    end
+    # Checked
+    def supports_joins
+      false
+    end
+    def properties()
+
+    end
+    protected
+
+      # converts and documents to ids
+      def conditions_to_fields(conditions)
+        conditions.inject({}) do |fields, (key, value)|
+          if value.is_a?(MongoMapper::Document) && model.key?("#{key}_id")
+            fields.merge("#{key}_id" => value.id)
+          else
+            fields.merge(key => value)
+          end
+        end
+      end
+    end
+  end

data/lib/dock/adapters/nobrainer.rb

@@ -0,0 +1,81 @@
+require 'nobrainer'
+
+module Dock
+  class NoBrainer < Base
+    def create(attributes = {})
+      model.create!(attributes)
+    end
+    def find(id)
+      model.find(wrap_key(id))
+    end
+    def find!(id)
+      model.find!(wrap_key(id))
+    end
+    def all(options = {})
+      conditions, order, limit, offset = extract_conditions!(options)
+      model.where(conditions).order_by(order_to_nql(order)).limit(limit).skip(offset)
+    end
+    def first(options = {})
+      conditions, order = extract_conditions!(options)
+      model.where(conditions).order_by(order_to_nql(order)).first
+    end
+    def id
+      'id'
+    end
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.where(search_key => find_by)
+      entry.update_attributes!(update_key => by_value)
+    end
+    def destroy(object)
+        object.destroy if valid_object?(object)
+    end
+    def associations()
+
+    end
+    def model_name
+      model.class.name
+    end
+    def column_names
+      model.fields.keys
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped
+      true
+    end
+    def embedded?
+      false
+    end
+    def cyclic?
+      false
+    end
+    def supports_joins?
+      false
+    end
+    def properties()
+
+    end
+
+    protected
+      # NoBrainer does not accept arrays as an `order_by` argument.
+      def order_to_nql(order)
+        if order.empty?
+          nil
+        else
+          order.to_h
+        end
+      end
+    end
+  end
+end

data/lib/dock/adapters/sequel.rb

@@ -0,0 +1,127 @@
+require 'sequel'
+
+module Dock
+  class Sequel < Base
+    def create()
+      associated_objects = []
+      attrs = {}
+
+      model.db.transaction do
+        attributes.each do |col, value|
+          if model.associations.include?(col)
+            Array(value).each{|v| associated_objects << [association_method(col), v]}
+          else
+            attrs.merge!(col => value) # pass it on
+          end
+        end
+
+        obj = model.create(attrs) # create main obj
+        associated_objects.each do |m,o|
+          obj.send(m, o)
+        end
+        obj.save
+      end # transaction
+    end
+    # Checked
+    def find(id)
+      model.find(wrap_key(model.primary_key => id))
+    end
+    # Checked
+    def find!(id)
+      model[wrap_key(id)] || raise(Error, "#{model.name} not found with #{model.primary_key} of #{wrap_key(id)}")
+    end
+    # Checked
+    def all(options = {})
+      conditions, order = extract_conditions!(options)
+      model.filter(conditions_to_hash(conditions)).order(*order_clause(order)).all
+    end
+    # Checked
+    def first(options = {})
+      conditions, order = extract_conditions!(options)
+      model.filter(conditions_to_hash(conditions)).order(*order_clause(order)).first
+    end
+    # Checked
+    def id
+      'primary_key'
+    end
+    def update(search_key, find_by, update_key, by_value)
+      entry = model.where(search_key, find_by)
+      entry.update(update_key by_value)
+    end
+    # Checked
+    def destroy(object)
+      object.destroy && true if valid_object?(object)
+    end
+    def associations()
+
+    end
+    # Checked
+    def model_name
+      model.class.name
+    end
+    # Checked
+    def column_names
+      model.columns
+    end
+    # Checked
+    def count(options = {})
+      all(options).count
+    end
+    def encoding
+      'UTF-8'
+    end
+    def belongs_to()
+
+    end
+    def has_many()
+
+    end
+    def scoped?
+      false
+    end
+    def embedded?
+      false
+    end
+    def cyclic?
+      true
+    end
+    # Checked
+    def supports_joins?
+      true
+    end
+    def properties()
+
+    end
+    protected
+
+      def conditions_to_hash(conditions)
+        conditions.inject({}) do |cond_hash, (col, value)|
+          # make sure the key is a symbol
+          col = col.to_sym
+
+          if value.is_a?(Sequel::Model)
+            # look up the column name for the assoc
+            key = model.association_reflection(col)[:key]
+            cond_hash.merge(key => value.id)
+          else
+            cond_hash.merge(col => value)
+          end
+        end
+      end
+
+      def order_clause(order)
+        m = order.map {|pair| pair.first.send(pair.last)}
+        m.empty? ? nil : m
+      end
+
+      def association_method(col)
+        assoc = model.association_reflection(col)
+        case assoc[:type]
+        when :one_to_many, :many_to_many
+          assoc.add_method
+        else # when :many_to_one, :one_to_one
+          assoc.setter_method
+        end
+      end
+  end
+end