mongodb_adapter 0.1.0 → 0.1.1

data/README.rdoc

@@ -4,3 +4,19 @@ A mostly functional DataMapper adapter for MongoDB.
 
 4 specs are not passing, to do with OR conditions or
 negated regular expressions.
+
+== Installation
+
+gem install mongodb_adapter
+
+== Usage
+
+adapter: mongodb
+database: databasename
+host: hostname   # defaults to 'localhost'
+port: portnum    # defaults to 27017
+
+== Notes
+
+Uses the 'mongo' gem. For extra performance you should install the
+'mongo_ext' gem which adds native compiled components.

data/Rakefile

@@ -5,9 +5,9 @@ require 'rake/gempackagetask'
 gemspec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.name = "mongodb_adapter"
-  s.version = "0.1.0"
+  s.version = "0.1.1"
   s.author = "Mark Rendle"
-  s.date = "2009-12-30"
+  s.date = "2010-01-13"
   s.email = "mark@okify.com"
 
   s.add_dependency "mongo", ">= 0.18.0"

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.1

data/lib/mongodb_adapter.rb

@@ -7,157 +7,186 @@ require 'json'
 require 'uuidtools'
 require 'pp'
 
-module DataMapper::Adapters
-  class MongoDBAdapter < AbstractAdapter
-
-    def initialize(name, options)
-      super
-      
-      @hostname   = @options[:hostname] || 'localhost'
-      @port       = @options[:port]     || 27017
-      @database   = @options[:database] || 'dm-mongodb-test'
+module DataMapper
+  module Adapters
+    class MongoDBAdapter < AbstractAdapter
+
+      def initialize(name, options)
+        super
+        
+        @hostname   = @options[:hostname] || 'localhost'
+        @port       = @options[:port]     || 27017
+        @database   = @options[:database] || 'dm-mongodb-test'
+        
+        @db = Mongo::Connection.new(@hostname, @port).db(@database)
+      end
       
-      @db = Mongo::Connection.new(@hostname, @port).db(@database)
-    end
-    
-    # Create mongodb entry
-    def create(resources)
-      resources.each do |resource|
-        collection = @db.collection(resource.model.storage_name)
-        id_hash = {}
-        Mongo::ObjectID.create_pk(id_hash)
-        initialize_serial(resource, id_hash[:_id].to_s.to_i(16))
-        doc = resource.attributes(:field)
-        doc[:_id] = id_hash[:_id]
-        doc = stringify_bignums(doc)
-        collection.insert(doc)
+      # Create mongodb entry
+      def create(resources)
+        resources.each do |resource|
+          collection = @db.collection(resource.model.storage_name)
+          id_hash = {}
+          Mongo::ObjectID.create_pk(id_hash)
+          initialize_serial(resource, id_hash[:_id].to_s.to_i(16))
+          doc = resource.attributes(:field)
+          doc[:_id] = id_hash[:_id]
+          doc = stringify_bignums(doc)
+          doc = stringify_discriminators(doc)
+          collection.insert(doc)
+        end
       end
-    end
 
-    def read(query)
-      collection = @db.collection(query.model.storage_name)
-      criteria = conditions_to_hash(query.conditions)
+      def read(query)
+        collection = @db.collection(query.model.storage_name)
+        criteria = conditions_to_hash(query.conditions)
 
-      result = []
+        result = []
 
-      cur = collection.find(criteria)
-      cur = cur.limit(query.limit) if query.limit
-      cur.each do |document|
-        document['__bignums'].each do |key|
-          document[key] = document[key].to_i
+        cur = collection.find(criteria)
+        cur = cur.limit(query.limit) if query.limit
+        cur.each do |document|
+          document['__bignums'].each do |key|
+            document[key] = document[key].to_i
+          end
+          document['__discriminators'].each do |key|
+            document[key] = eval(document[key])
+          end
+          result << document
         end
-        result << document
-      end
-
-      result
-    end
 
-    def update(attributes,resources)
-      collection = @db.collection(resources[0].model.storage_name)
-      resources.each do |resource|
-        doc = resource.attributes(:field)
-        serial = resource.model.serial(name).get(resource)
-        doc[:_id] = Mongo::ObjectID.from_string(serial.to_s(16))
-        doc = stringify_bignums(doc)
-        collection.save(doc)
+        result
       end
-      resources.length
-    end
 
-    def delete(resources)
-      collection = @db.collection(resources[0].model.storage_name)
-      ids = []
-      resources.each do |resource|
-        serial = resource.model.serial(name).get(resource)
-        ids << Mongo::ObjectID.from_string(serial.to_s(16))
+      def update(attributes,resources)
+        collection = @db.collection(resources[0].model.storage_name)
+        resources.each do |resource|
+          doc = resource.attributes(:field)
+          serial = resource.model.serial(name).get(resource)
+          doc[:_id] = Mongo::ObjectID.from_string(serial.to_s(16))
+          doc = stringify_bignums(doc)
+          doc = stringify_discriminators(doc)
+          collection.save(doc)
+        end
+        resources.length
       end
-      collection.remove(:_id => {'$in' => ids})
-    end
-    
-    private
-      # Generates uuid from mongodb ruby driver
-      def generate_id
-        UUIDTools::UUID.random_create.to_i
+
+      def delete(resources)
+        collection = @db.collection(resources[0].model.storage_name)
+        ids = []
+        resources.each do |resource|
+          serial = resource.model.serial(name).get(resource)
+          ids << Mongo::ObjectID.from_string(serial.to_s(16))
+        end
+        collection.remove(:_id => {'$in' => ids})
       end
+      
+      private
+        # Generates uuid from mongodb ruby driver
+        def generate_id
+          UUIDTools::UUID.random_create.to_i
+        end
 
-      def stringify_bignums(hash)
-        hash['__bignums'] = []
+        def stringify_bignums(hash)
+          hash['__bignums'] = []
 
-        hash.each do |key, value|
-          if value.class == Bignum
-            hash[key] = value.to_s
-            hash['__bignums'] << key
+          hash.each do |key, value|
+            if value.class == Bignum
+              hash[key] = value.to_s
+              hash['__bignums'] << key
+            end
           end
+          hash
         end
-        hash
-      end
 
-      def conditions_to_hash(conditions, hash = {}, negate = false)
-        case conditions
-          when DataMapper::Query::Conditions::NotOperation then operation_to_hash(conditions, hash, !negate)
-          when DataMapper::Query::Conditions::AbstractOperation then operation_to_hash(conditions, hash, negate)
-          when DataMapper::Query::Conditions::AbstractComparison then comparison_to_hash(conditions, hash, negate)
+        def stringify_discriminators(hash)
+          hash['__discriminators'] = []
+
+          hash.each do |key, value|
+            if value.class == Class
+              hash[key] = value.name
+              hash['__discriminators'] << key
+            end
+          end
+          hash
         end
-        hash
-      end
 
-      def operation_to_hash(operation, hash, negate)
-        operation.each do |operand|
-          conditions_to_hash(operand, hash, negate)
+        def conditions_to_hash(conditions, hash = {}, negate = false)
+          case conditions
+            when DataMapper::Query::Conditions::NotOperation then operation_to_hash(conditions, hash, !negate)
+            when DataMapper::Query::Conditions::AbstractOperation then operation_to_hash(conditions, hash, negate)
+            when DataMapper::Query::Conditions::AbstractComparison then comparison_to_hash(conditions, hash, negate)
+          end
+          hash
         end
-      end
 
-      def comparison_to_hash(comparison, hash, negate)
-        value = nil
-        if comparison.slug == :eql
-          value = mongify_value(comparison.value,negate)
-        elsif [:gt,:gte,:lt,:lte].include?(comparison.slug)
-          value = mongify_value(comparison.value,negate)
-          value = value.first[1] if value.is_a?(Hash)
-          value = {mongify_inequality(comparison.slug, negate) => value}
-        elsif comparison.slug == :in
-          value = mongify_value(comparison.value,negate)
-        elsif comparison.slug == :like
-          value = Regexp.new(comparison.value.gsub(/%/, '.*'))
-          value = mongify_value(value,negate)
-        elsif comparison.slug == :regexp
-          value = Regexp.new(comparison.value)
-          value = mongify_value(value,negate)
-        else
-          puts "!!! Not handling #{comparison.slug} !!!"
+        def operation_to_hash(operation, hash, negate)
+          operation.each do |operand|
+            conditions_to_hash(operand, hash, negate)
+          end
         end
-        hash[comparison.subject.name.to_s] = value
-      end
 
-      def mongify_value(value, negate)
-        case value
-          when Bignum then mongify_value(value.to_s, negate)
-          when Array then {negate ? '$nin' : '$in' => value}
-          when Range then mongify_range(value, negate)
-          else negate ? {'$ne' => value} : value
+        def comparison_to_hash(comparison, hash, negate)
+          value = nil
+          if comparison.slug == :eql
+            value = mongify_value(comparison.value,negate)
+          elsif [:gt,:gte,:lt,:lte].include?(comparison.slug)
+            value = mongify_value(comparison.value,negate)
+            value = value.first[1] if value.is_a?(Hash)
+            value = {mongify_inequality(comparison.slug, negate) => value}
+          elsif comparison.slug == :in
+            value = mongify_value(comparison.value,negate)
+          elsif comparison.slug == :like
+            value = Regexp.new(comparison.value.gsub(/%/, '.*'))
+            value = mongify_value(value,negate)
+          elsif comparison.slug == :regexp
+            value = Regexp.new(comparison.value)
+            value = mongify_value(value,negate)
+          else
+            puts "!!! Not handling #{comparison.slug} !!!"
+          end
+          hash[comparison.subject.name.to_s] = value
         end
-      end
 
-      def mongify_range(value, negate)
-        first_op = negate ? '$lt' : '$gte'
-        if value.exclude_end?
-          last_op = negate ? '$gte' : '$lt'
-        else
-          last_op = negate ? '$gt' : '$lte'
+        def mongify_value(value, negate)
+          case value
+            when Bignum then mongify_value(value.to_s, negate)
+            when Class then mongify_value(value.name, negate)
+            when Array then {negate ? '$nin' : '$in' => value}
+            when Range then mongify_range(value, negate)
+            else negate ? {'$ne' => value} : value
+          end
+        end
+
+        def mongify_range(value, negate)
+          first_op = negate ? '$lt' : '$gte'
+          if value.exclude_end?
+            last_op = negate ? '$gte' : '$lt'
+          else
+            last_op = negate ? '$gt' : '$lte'
+          end
+          {first_op => value.first, last_op => value.last}
         end
-        {first_op => value.first, last_op => value.last}
-      end
 
-      def mongify_inequality(slug, negate)
-        case slug
-          when :gt then negate ? '$lte' : '$gt'
-          when :gte then negate ? '$lt' : '$gte'
-          when :lt then negate ? '$gte' : '$lt'
-          when :lte then negate ? '$gt' : '$lte'
+        def mongify_inequality(slug, negate)
+          case slug
+            when :gt then negate ? '$lte' : '$gt'
+            when :gte then negate ? '$lt' : '$gte'
+            when :lt then negate ? '$gte' : '$lt'
+            when :lte then negate ? '$gt' : '$lte'
+          end
         end
-      end
-    
-  end # class MongodbAdapter
+      
+    end # class MongodbAdapter
+
+    MongodbAdapter = MongoDBAdapter
+  end
+
+  module Types
+
+    class Array < DataMapper::Type
+      primitive ::Object
+    end
+
+  end
 
-  MongodbAdapter = MongoDBAdapter
 end

data/mongodb_adapter.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongodb_adapter}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mark Rendle"]
-  s.date = %q{2009-12-30}
+  s.date = %q{2010-01-13}
   s.email = %q{mark@okify.com}
   s.extra_rdoc_files = [
     "LICENSE",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongodb_adapter
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Mark Rendle
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-30 00:00:00 +00:00
+date: 2010-01-13 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency