jnunemaker-mongomapper 0.1.2 → 0.2.0

data/.gitignore

@@ -3,3 +3,4 @@
 coverage
 rdoc
 pkg
+*~

data/History

@@ -1,3 +1,16 @@
+0.2.0 7/7/2009
+* 2 major additions (observers, associations), several minor additions, and a few bug fixes
+  * Added observers
+  * many now supports embedded docs or docs in another collection (dcu on github)
+  * added belongs_to association (dcu)
+  * added validates_uniqueness_of (dcu)
+  * added :unique key shortcut to add validates_uniqueness_of automatically
+  * now tracking descendants of document (dcu)
+  * added validates_exclusion_of and validates_inclusion_of
+  * Bumped required version of validatable for callback fixes
+  * More thorough use of converting find conditions and options to mongo speak
+  * #attributes= no longer bombs when given nil
+  
 0.1.2 7/3/2009
 * 2 minor changes
   * Straightened out callbacks and added validate, validate_on_create and validate_on_update.

data/Rakefile

@@ -13,7 +13,7 @@ begin
     
     gem.add_dependency('activesupport')
     gem.add_dependency('mongodb-mongo', '0.9')
-    gem.add_dependency('jnunemaker-validatable', '1.7.0')
+    gem.add_dependency('jnunemaker-validatable', '1.7.1')
     
     gem.add_development_dependency('mocha', '0.9.4')
     gem.add_development_dependency('jnunemaker-matchy', '0.4.0')

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/lib/mongomapper.rb

@@ -3,7 +3,7 @@ require 'rubygems'
 
 gem 'activesupport'
 gem 'mongodb-mongo', '0.9'
-gem 'jnunemaker-validatable', '1.7.0'
+gem 'jnunemaker-validatable', '1.7.1'
 
 require 'activesupport'
 require 'mongo'
@@ -16,6 +16,20 @@ require dir + 'finder_options'
 require dir + 'rails_compatibility'
 require dir + 'save_with_validation'
 require dir + 'serialization'
+require dir + 'callbacks'
+require dir + 'observing'
+require dir + 'validations'
+
+require dir + 'associations/proxy'
+require dir + 'associations/array_proxy'
+require dir + 'associations/base'
+
+require dir + 'associations/has_many_proxy'
+require dir + 'associations/has_many_embedded_proxy'
+require dir + 'associations/belongs_to_proxy'
+require dir + 'associations/polymorphic_belongs_to_proxy'
+require dir + 'associations'
+
 require dir + 'embedded_document'
 require dir + 'document'
 
@@ -27,20 +41,20 @@ module MongoMapper
       super("Validation failed: #{@document.errors.full_messages.join(", ")}")
     end
   end
-  
+
   def self.connection
     @@connection ||= XGen::Mongo::Driver::Mongo.new
   end
-  
+
   def self.connection=(new_connection)
     @@connection = new_connection
   end
-  
+
   def self.database=(name)
     @@database = MongoMapper.connection.db(name)
   end
-  
+
   def self.database
     @@database
   end
-end
+end

data/lib/mongomapper/associations.rb

@@ -0,0 +1,69 @@
+module MongoMapper
+  module Associations
+    module ClassMethods
+      def belongs_to(association_id, options = {})
+        association = create_association(:belongs_to, association_id, options)
+
+        ref_id = "#{association_id}_id"
+        key ref_id, String
+
+        define_method("#{ref_id}=") do |value|
+          write_attribute(ref_id, value)
+        end
+
+        if options[:polymorphic]
+          ref_type = "#{association_id}_type"
+          key ref_type, String
+
+          define_method("#{ref_type}=") do |value|
+            write_attribute(ref_type, value)
+          end
+        end
+
+        define_association_methods(association)
+
+        self
+      end
+
+      def many(association_id, options = {})
+        association = create_association(:many, association_id, options)
+        define_association_methods(association)
+
+        self
+      end
+
+      def associations
+        @associations ||= HashWithIndifferentAccess.new
+      end
+
+      private
+      def create_association(type, name, options)
+        association = Associations::Base.new(type, name, options)
+        associations[association.name] = association
+        association
+      end
+
+      def define_association_methods(association)
+        define_method(association.name) do
+          get_proxy(association)
+        end
+
+        define_method("#{association.name}=") do |value|
+          get_proxy(association).replace(value)
+          value
+        end
+      end
+    end
+
+    module InstanceMethods
+      def get_proxy(association)
+        proxy = self.instance_variable_get(association.ivar)
+        if proxy.nil?
+          proxy = association.proxy_class.new(self, association)
+          self.instance_variable_set(association.ivar, proxy)
+        end
+        proxy
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/array_proxy.rb

@@ -0,0 +1,6 @@
+module MongoMapper
+  module Associations
+    class ArrayProxy < Proxy
+    end
+  end
+end

data/lib/mongomapper/associations/base.rb

@@ -0,0 +1,50 @@
+module MongoMapper
+  module Associations
+    class Base
+      attr_reader :type, :name, :options
+
+      def initialize(type, name, options = {})
+        @options = options
+        @type = type
+        @name = name
+      end
+
+      def klass
+        class_name.constantize
+      end
+
+      def class_name
+        @class_name ||= begin
+          if cn = options[:class_name]
+            cn
+          elsif @type == :many
+            name.to_s.singularize.camelize
+          else
+            name.to_s.camelize
+          end
+        end
+      end
+
+      def ivar
+        @ivar ||= "@_#{name}"
+      end
+
+      def proxy_class
+        case @type
+          when :belongs_to
+            if @options[:polymorphic]
+              PolymorphicBelongsToProxy
+            else
+              BelongsToProxy
+            end
+          when :many
+            if self.klass.embeddable?
+              HasManyEmbeddedProxy
+            else
+              HasManyProxy
+            end
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/belongs_to_proxy.rb

@@ -0,0 +1,26 @@
+module MongoMapper
+  module Associations
+    class BelongsToProxy < Proxy
+      def replace(v)
+        ref_id = "#{@association.name}_id"
+
+        if v
+          v.save if v.new?
+          @owner.__send__(:write_attribute, ref_id, v.id)
+        else
+          @owner.__send__(:write_attribute, ref_id, nil)
+        end
+
+        reload_target
+      end
+
+      protected
+      def find_target
+        ref = @owner.__send__(:read_attribute, "#{@association.name}_id")
+        if ref
+          @association.klass.find(ref)
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/has_many_embedded_proxy.rb

@@ -0,0 +1,19 @@
+module MongoMapper
+  module Associations
+    class HasManyEmbeddedProxy < ArrayProxy
+      def replace(v)
+        @_values = v.map { |e| e.kind_of?(EmbeddedDocument) ? e.attributes : e }
+        @target = nil
+
+        reload_target
+      end
+
+      protected
+      def find_target
+        (@_values || []).map do |e|
+          @association.klass.new(e)
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/has_many_proxy.rb

@@ -0,0 +1,28 @@
+module MongoMapper
+  module Associations
+    class HasManyProxy < ArrayProxy
+      def replace(v)
+        if load_target
+          @target.map(&:destroy)
+        end
+
+        v.each do |o|
+          @owner.save if @owner.new?
+          o.__send__(:write_attribute, self.foreign_key, @owner.id)
+          o.save
+          o
+        end
+        reload_target
+      end
+
+      protected
+      def find_target
+        @association.klass.find(:all, {:conditions => {self.foreign_key => @owner.id}})
+      end
+
+      def foreign_key
+        @association.options[:foreign_key] || @owner.class.name.underscore.gsub("/", "_") + "_id"
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/polymorphic_belongs_to_proxy.rb

@@ -0,0 +1,31 @@
+module MongoMapper
+  module Associations
+    class PolymorphicBelongsToProxy < Proxy
+      def replace(v)
+        ref_id = "#{@association.name}_id"
+        ref_type = "#{@association.name}_type"
+
+        if v
+          v.save if v.new?
+          @owner.__send__(:write_attribute, ref_id, v.id)
+          @owner.__send__(:write_attribute, ref_type, v.class.name)
+        else
+          @owner.__send__(:write_attribute, ref_id, nil)
+          @owner.__send__(:write_attribute, ref_type, nil)
+        end
+        @owner.save
+
+        reload_target
+      end
+
+      protected
+      def find_target
+        ref_id = @owner.__send__(:read_attribute, "#{@association.name}_id")
+        ref_type = @owner.__send__(:read_attribute, "#{@association.name}_type")
+        if ref_id && ref_type
+          ref_type.constantize.find(ref_id)
+        end
+      end
+    end
+  end
+end

data/lib/mongomapper/associations/proxy.rb

@@ -0,0 +1,60 @@
+module MongoMapper
+  module Associations
+    class Proxy
+      attr_reader :owner, :association
+
+      instance_methods.each do |m|
+        undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/
+      end
+
+      def initialize(owner, association)
+        @owner= owner
+        @association = association
+
+        reset
+      end
+
+      def respond_to?(*methods)
+        (load_target && @target.respond_to?(*methods))
+      end
+
+      def reset
+        @target = nil
+      end
+
+      def reload_target
+        reset
+        load_target
+        self
+      end
+
+      def send(method, *args)
+        load_target
+        @target.send(method, *args)
+      end
+
+      def replace(v)
+        raise NotImplementedError
+      end
+
+      protected
+      def method_missing(method, *args)
+        if load_target
+          if block_given?
+            @target.send(method, *args)  { |*block_args| yield(*block_args) }
+          else
+            @target.send(method, *args)
+          end
+        end
+      end
+
+      def load_target
+        @target ||= find_target
+      end
+
+      def find_target
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/mongomapper/callbacks.rb

@@ -0,0 +1,106 @@
+module MongoMapper
+  module Callbacks    
+    def self.included(model) #:nodoc:
+      model.class_eval do
+        extend Observable
+        include ActiveSupport::Callbacks
+        
+        define_callbacks *%w(
+          before_save after_save before_create after_create before_update after_update before_validation
+          after_validation before_validation_on_create after_validation_on_create before_validation_on_update
+          after_validation_on_update before_destroy after_destroy
+        )
+        
+        [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
+      end
+    end
+
+    def before_save() end
+
+    def after_save()  end
+    def create_or_update_with_callbacks #:nodoc:
+      return false if callback(:before_save) == false
+      if result = create_or_update_without_callbacks
+        callback(:after_save)
+      end
+      result
+    end
+    private :create_or_update_with_callbacks
+
+    def before_create() end
+
+    def after_create() end
+    def create_with_callbacks #:nodoc:
+      return false if callback(:before_create) == false
+      result = create_without_callbacks
+      callback(:after_create)
+      result
+    end
+    private :create_with_callbacks
+
+    def before_update() end
+
+    def after_update() end
+
+    def update_with_callbacks(*args) #:nodoc:
+      return false if callback(:before_update) == false
+      result = update_without_callbacks(*args)
+      callback(:after_update)
+      result
+    end
+    private :update_with_callbacks
+
+    def before_validation() end
+
+    def after_validation() end
+
+    def before_validation_on_create() end
+
+    def after_validation_on_create()  end
+
+    def before_validation_on_update() end
+
+    def after_validation_on_update()  end
+
+    def valid_with_callbacks? #:nodoc:
+      return false if callback(:before_validation) == false
+      result = new? ? callback(:before_validation_on_create) : callback(:before_validation_on_update)
+      return false if false == result
+      
+      result = valid_without_callbacks?
+      callback(:after_validation)
+      
+      new? ? callback(:after_validation_on_create) : callback(:after_validation_on_update)
+      return result
+    end
+
+    def before_destroy() end
+
+    def after_destroy()  end
+    def destroy_with_callbacks #:nodoc:
+      return false if callback(:before_destroy) == false
+      result = destroy_without_callbacks
+      callback(:after_destroy)
+      result
+    end
+
+    private
+      def callback(method)
+        result = run_callbacks(method) { |result, object| false == result }
+        
+        if result != false && respond_to_without_attributes?(method)
+          result = send(method)
+        end
+        
+        notify(method)
+        return result
+      end
+      
+      def notify(method) #:nodoc:
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
+  end
+end