perpetuity 0.4.7 → 0.4.8

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## Version 0.4.8
+
+- Provide configuration one-liner ability for simple configs
+- Memoize results for Retrieval objects
+- `Retrieval#count` sends a count query rather than retrieving the result set and returning the count of the array
+- Allow updating of objects that contain `Perpetuity::Reference`s to other persisted objects without first loading the association
+- Fix bug preventing objects with an array of referenced objects from being updated
+- Move serialization into the MongoDB adapter, allowing future adapters to implement their own serializations
+
 ## Version 0.4.7
 
 - Use instance variables rather than attr_readers in IdentityMap (avoids calling methods during `load_association!`).

data/lib/perpetuity/dereferencer.rb

@@ -0,0 +1,47 @@
+require 'perpetuity/identity_map'
+require 'perpetuity/reference'
+
+module Perpetuity
+  class Dereferencer
+    attr_reader :map, :mapper_registry
+
+    def initialize mapper_registry
+      @map = IdentityMap.new
+      @mapper_registry = mapper_registry
+    end
+
+    def load references
+      references = Array(references).flatten.select {|ref| referenceable?(ref) }
+
+      cache grouped(references).map { |klass, refs|
+        objects klass, refs.map(&:id)
+      }.flatten
+    end
+
+    def cache objects
+      objects.each { |object| map << object }
+    end
+
+    def [] reference
+      if referenceable?(reference)
+        map[reference.klass, reference.id]
+      else
+        reference
+      end
+    end
+
+    def grouped references
+      references.group_by(&:klass)
+    end
+
+    def objects klass, ids
+      mapper_registry[klass].select { |object|
+        object.id.in ids.uniq
+      }.to_a
+    end
+
+    def referenceable? ref
+      [:klass, :id].all? { |msg| ref.respond_to?(msg) }
+    end
+  end
+end

data/lib/perpetuity/identity_map.rb

@@ -1,25 +1,17 @@
 module Perpetuity
   class IdentityMap
-    def initialize objects, attribute, mapper_registry
-      @map = Hash[
-        objects.map { |object| object.instance_variable_get("@#{attribute}") }
-          .flatten
-          .group_by(&:klass)
-          .map { |klass, ref|
-            [
-              klass,
-              Hash[
-                mapper_registry[klass].select { |object|
-                  object.id.in ref.map(&:id).uniq
-                }.map { |obj| [obj.id, obj] }
-              ]
-            ]
-          }
-      ]
+    attr_reader :map
+
+    def initialize
+      @map = Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    def [] klass, id
+      map[klass][id]
     end
 
-    def [] klass
-      @map[klass]
+    def << object
+      map[object.class][object.id] = object
     end
   end
 end

data/lib/perpetuity/mapper.rb

@@ -2,8 +2,7 @@ require 'perpetuity/attribute_set'
 require 'perpetuity/attribute'
 require 'perpetuity/validations'
 require 'perpetuity/data_injectable'
-require 'perpetuity/serializer'
-require 'perpetuity/identity_map'
+require 'perpetuity/dereferencer'
 require 'perpetuity/retrieval'
 
 module Perpetuity
@@ -95,23 +94,23 @@ module Perpetuity
     end
 
     def delete object
-      data_source.delete object, mapped_class
+      id = object.is_a?(PersistedObject) ? object.id : object
+      data_source.delete id, mapped_class
     end
 
     def load_association! object, attribute
       objects = Array(object)
-      identity_map = IdentityMap.new(objects, attribute, mapper_registry)
+      dereferencer = Dereferencer.new(mapper_registry)
+      dereferencer.load objects.map { |obj| obj.instance_variable_get("@#{attribute}") }
 
-      objects.each do |object|
-        reference = object.instance_variable_get("@#{attribute}")
+      objects.each do |obj|
+        reference = obj.instance_variable_get("@#{attribute}")
         if reference.is_a? Array
           refs = reference
-          real_objects = refs.map { |ref| identity_map[ref.klass][ref.id] }
-          inject_attribute object, attribute, real_objects
+          real_objects = refs.map { |ref| dereferencer[ref] }
+          inject_attribute obj, attribute, real_objects
         else
-          klass = reference.klass
-          id = reference.id
-          inject_attribute object, attribute, identity_map[klass][id]
+          inject_attribute obj, attribute, dereferencer[reference]
         end
       end
     end
@@ -148,7 +147,7 @@ module Perpetuity
     end
 
     def serialize object
-      Serializer.new(self).serialize(object)
+      data_source.serialize(object, self)
     end
 
     def self.mapped_class

data/lib/perpetuity/mongodb/serializer.rb

@@ -0,0 +1,151 @@
+require 'perpetuity/data_injectable'
+
+module Perpetuity
+  class MongoDB
+    class Serializer
+      include DataInjectable
+
+      attr_reader :mapper, :mapper_registry
+
+      def initialize(mapper)
+        @mapper = mapper
+        @class = mapper.mapped_class
+        @mapper_registry = mapper.mapper_registry
+      end
+
+      def attribute_for object, attribute_name
+        object.instance_variable_get("@#{attribute_name}")
+      end
+
+      def serialize object
+        attrs = mapper.class.attribute_set.map do |attrib|
+          value = attribute_for object, attrib.name
+
+          serialized_value = if value.is_a? Reference
+            serialize_reference value
+          elsif value.is_a? Array
+            serialize_array(value, attrib.embedded?)
+          elsif mapper.data_source.can_serialize? value
+            value
+          elsif mapper_registry.has_mapper?(value.class)
+            serialize_with_foreign_mapper(value, attrib.embedded?)
+          else
+            Marshal.dump(value)
+          end
+
+          [attrib.name.to_s, serialized_value]
+        end
+
+        Hash[attrs]
+      end
+
+      def unserialize data
+        if data.is_a? Array
+          unserialize_object_array data
+        else
+          object = unserialize_object(data)
+          give_id_to object
+          object
+        end
+      end
+
+      def unserialize_object data, klass=@class
+        if data.is_a? Hash
+          object = klass.allocate
+          data.each do |attr, value|
+            inject_attribute object, attr, unserialize_attribute(value)
+          end
+          object
+        else
+          unserialize_attribute data
+        end
+      end
+
+      def unserialize_object_array objects
+        objects.map do |data|
+          object = unserialize_object data
+          give_id_to object
+          object
+        end
+      end
+
+      def unserialize_attribute data
+        if data.is_a?(String) && data.start_with?("\u0004") # if it's marshaled
+          Marshal.load(data)
+        elsif data.is_a? Array
+          data.map { |i| unserialize_attribute i }
+        elsif data.is_a? Hash
+          metadata = data.delete('__metadata__')
+          if metadata
+            klass = metadata['class'].split('::').inject(Kernel) do |scope, const_name|
+              scope.const_get(const_name)
+            end
+            id = metadata['id']
+
+            if id
+              object = Reference.new(klass, id)
+            else
+              object = unserialize_object(data, klass)
+            end
+          else
+            data
+          end
+        else
+          data
+        end
+      end
+
+      def serialize_with_foreign_mapper value, embedded = false
+        if embedded
+          value_mapper = mapper_registry[value.class]
+          value_serializer = Serializer.new(value_mapper)
+          attr = value_serializer.serialize(value)
+          attr.merge '__metadata__' =>  { 'class' => value.class }
+        else
+          serialize_reference(value)
+        end
+      end
+
+      def serialize_array enum, embedded
+        enum.map do |value|
+          if value.is_a? Reference
+            serialize_reference value
+          elsif value.is_a? Array
+            serialize_array(value)
+          elsif mapper.data_source.can_serialize? value
+            value
+          elsif mapper_registry.has_mapper?(value.class)
+            if embedded
+              {
+                '__metadata__' => {
+                  'class' => value.class.to_s
+                }
+              }.merge mapper_registry[value.class].serialize(value)
+            else
+              serialize_reference value
+            end
+          else
+            Marshal.dump(value)
+          end
+        end
+      end
+
+      def serialize_reference value
+        if value.is_a? Reference
+          reference = value
+        else
+          unless value.is_a? PersistedObject
+            mapper_registry[value.class].insert value
+          end
+          reference = Reference.new(value.class.to_s, value.id)
+        end
+        {
+          '__metadata__' => {
+            'class' => reference.klass.to_s,
+            'id'    => reference.id
+          }
+        }
+      end
+    end
+  end
+end

data/lib/perpetuity/mongodb.rb

@@ -1,6 +1,7 @@
 require 'moped'
 require 'perpetuity/mongodb/query'
 require 'perpetuity/mongodb/index'
+require 'perpetuity/mongodb/serializer'
 require 'set'
 require 'perpetuity/exceptions/duplicate_key_error'
 
@@ -45,12 +46,7 @@ module Perpetuity
     end
 
     def insert klass, attributes
-      if attributes.has_key? :id
-        attributes[:_id] = attributes[:id]
-        attributes.delete :id
-      else
-        attributes[:_id] = Moped::BSON::ObjectId.new
-      end
+      attributes[:_id] = attributes.delete(:id) || Moped::BSON::ObjectId.new
 
       collection(klass).insert attributes
       attributes[:_id]
@@ -63,8 +59,9 @@ module Perpetuity
       end
     end
 
-    def count klass
-      collection(klass).find.count
+    def count klass, criteria={}, options={}
+      criteria = to_bson_id(criteria)
+      collection(klass).find(criteria).count
     end
 
     def delete_all klass
@@ -80,27 +77,31 @@ module Perpetuity
 
     def retrieve klass, criteria, options = {}
       # MongoDB uses '_id' as its ID field.
-      if criteria.has_key?(:id)
-        if criteria[:id].is_a? String
-          criteria = { _id: (Moped::BSON::ObjectId(criteria[:id].to_s) rescue criteria[:id]) }
-        else
-          criteria[:_id] = criteria.delete(:id)
-        end
-      end
-
-      query = collection(klass.to_s).find(criteria)
+      criteria = to_bson_id(criteria)
 
       skipped = options[:page] ? (options[:page] - 1) * options[:limit] : 0
-      query = query.skip skipped
-      query = query.limit(options[:limit])
-      query = sort(query, options)
 
-      query.map do |document|
+      query = collection(klass.to_s)
+                .find(criteria)
+                .skip(skipped)
+                .limit(options[:limit])
+
+      sort(query, options).map do |document|
         document[:id] = document.delete("_id")
         document
       end
     end
 
+    def to_bson_id criteria
+      criteria = criteria.dup
+      if criteria.has_key?(:id)
+        criteria[:_id] = Moped::BSON::ObjectId(criteria[:id]) rescue criteria[:id]
+        criteria.delete :id
+      end
+
+      criteria
+    end
+
     def sort query, options
       return query unless options[:attribute] &&
                           options[:direction]
@@ -116,9 +117,7 @@ module Perpetuity
       retrieve klass, {}, {}
     end
     
-    def delete object_or_id, klass=nil
-      id = object_or_id.is_a?(PersistedObject) ? object_or_id.id : object_or_id
-      klass ||= object.class
+    def delete id, klass
       collection(klass.to_s).find("_id" => id).remove
     end
 
@@ -151,8 +150,7 @@ module Perpetuity
     end
 
     def active_indexes klass
-      indexes = collection(klass).indexes.to_a
-      indexes.map do |index|
+      collection(klass).indexes.map do |index|
         key = index['key'].keys.first
         direction = index['key'][key]
         unique = index['unique']
@@ -173,13 +171,21 @@ module Perpetuity
       coll = collection(index.collection)
       db_indexes = coll.indexes.select do |db_index|
         db_index['name'] =~ /\A#{index.attribute}/
-      end.map { |index| index['key'] }
+      end.map { |idx| idx['key'] }
 
       if db_indexes.any?
         collection(index.collection).indexes.drop db_indexes.first
       end
     end
 
+    def serialize object, mapper
+      Serializer.new(mapper).serialize object
+    end
+
+    def unserialize data, mapper
+      Serializer.new(mapper).unserialize data
+    end
+
     private
     def serializable_types
       @serializable_types ||= [NilClass, TrueClass, FalseClass, Fixnum, Float, String, Array, Hash, Time]

data/lib/perpetuity/persisted_object.rb

@@ -1,7 +1,7 @@
 module Perpetuity
   module PersistedObject
     def id
-      @id
+      @id if defined? @id
     end
   end
 end

data/lib/perpetuity/retrieval.rb

@@ -1,5 +1,4 @@
 require 'perpetuity/reference'
-require 'perpetuity/serializer'
 
 module Perpetuity
   class Retrieval
@@ -46,18 +45,20 @@ module Perpetuity
     end
 
     def to_a
-      options = {
+      @results ||= @data_source.unserialize(@data_source.retrieve(@class, @criteria, options), @mapper)
+    end
+
+    def count
+      @data_source.count(@class, @criteria, options)
+    end
+
+    def options
+      {
         attribute: sort_attribute,
         direction: sort_direction,
         limit: result_limit || quantity_per_page,
         page: result_page
       }
-      results = @data_source.retrieve(@class, @criteria, options)
-      unserialize results
-    end
-
-    def unserialize(data)
-      Serializer.new(@mapper).unserialize(data)
     end
 
     def [] index

data/lib/perpetuity/version.rb

@@ -1,3 +1,3 @@
 module Perpetuity
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/lib/perpetuity.rb

@@ -17,7 +17,7 @@ module Perpetuity
   def self.generate_mapper_for klass, &block
     mapper = Class.new(Mapper)
     mapper.map klass, mapper_registry
-    mapper.instance_exec &block if block_given?
+    mapper.instance_exec(&block) if block_given?
   end
 
   def self.[] klass
@@ -27,4 +27,10 @@ module Perpetuity
   def self.mapper_registry
     @mapper_registry ||= MapperRegistry.new
   end
+
+  def self.data_source adapter, db_name, options={}
+    adapters = { mongodb: MongoDB }
+
+    configure { data_source adapters[adapter].new(options.merge(db: db_name)) }
+  end
 end

data/spec/integration/associations_spec.rb

@@ -59,7 +59,39 @@ describe 'associations with other objects' do
 
       books = book_mapper.select { |book| book.id.in book_ids }.to_a
       book_mapper.load_association! books, :authors
-      books.map(&:authors).flatten.map(&:name).should include *%w(Dave Andy Matt Aslak)
+      books.map(&:authors).flatten.map(&:name).should include(*%w(Dave Andy Matt Aslak))
+    end
+
+    it 'does not try dereferencing non-reference objects' do
+      article = Article.new
+      foo = User.new('foo')
+      bar = 'bar'
+      article.author = [foo, bar]
+      mapper = Perpetuity[Article]
+
+      mapper.insert article
+      retrieved = mapper.find(article.id)
+      mapper.load_association! retrieved, :author
+      retrieved.author.should == [foo, bar]
+    end
+  end
+
+  describe 'embedded relationships' do
+    let(:mapper) { Perpetuity[GenericObject] }
+    let(:object) { GenericObject.new }
+
+    context 'with unserializable embedded attributes' do
+      let(:unserializable_object) { 1.to_c }
+      let(:serialized_attrs) do
+        [ Marshal.dump(unserializable_object) ]
+      end
+
+      before { object.embedded_attribute = [unserializable_object] }
+
+      it 'serializes attributes' do
+        mapper.insert object
+        mapper.find(object.id).embedded_attribute.should be == [unserializable_object]
+      end
     end
   end
 end

data/spec/integration/mongodb_spec.rb

@@ -62,6 +62,13 @@ module Perpetuity
       mongo.count(klass).should == 3
     end
 
+    it 'counts documents matching criteria' do
+      mongo.delete_all klass
+      3.times { mongo.insert klass, { name: 'foo' } }
+      3.times { mongo.insert klass, { name: 'bar' } }
+      mongo.count(klass, name: 'foo').should == 3
+    end
+
     it 'gets the first document in a collection' do
       value = {value: 1}
       mongo.insert klass, value

data/spec/integration/pagination_spec.rb

@@ -20,7 +20,7 @@ describe 'pagination' do
   it 'specifies per-page quantity' do
     Perpetuity[Article].delete_all
     5.times { |i| Perpetuity[Article].insert Article.new i }
-    data = Perpetuity[Article].all.page(3).per_page(2)
+    data = Perpetuity[Article].all.page(3).per_page(2).to_a
     data.should have(1).item
   end
 end