mongomodel 0.1

data/lib/mongomodel/concerns/associations/base/association.rb

@@ -0,0 +1,33 @@
+module MongoModel
+  module Associations
+    module Base
+      class Association
+        attr_reader :definition, :instance
+        delegate :name, :klass, :polymorphic?, :to => :definition
+        
+        def initialize(definition, instance)
+          @definition, @instance = definition, instance
+        end
+        
+        def proxy
+          @proxy ||= proxy_class.new(self)
+        end
+        
+        def replace(obj)
+          proxy.target = obj
+          proxy
+        end
+      
+      protected
+        def ensure_class(value)
+          raise AssociationTypeMismatch, "expected instance of #{klass} but got #{value.class}" unless value.is_a?(klass)
+        end
+      
+      private
+        def proxy_class
+          self.class.parent::Proxy rescue Base::Proxy
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/associations/base/definition.rb

@@ -0,0 +1,56 @@
+module MongoModel
+  module Associations
+    module Base
+      class Definition
+        attr_reader :owner, :name, :options
+
+        def initialize(owner, name, options={})
+          @owner, @name, @options = owner, name, options
+        end
+
+        def for(instance)
+          association_class.new(self, instance)
+        end
+
+        def define!
+          owner.instance_exec(self, &self.class.properties) if self.class.properties
+          owner.instance_exec(self, &self.class.methods) if self.class.methods
+
+          self
+        end
+
+        def klass
+          case options[:class]
+          when Class
+            options[:class]
+          when String
+            options[:class].constantize
+          else
+            name.to_s.classify.constantize
+          end
+        end
+        
+        def singular_name
+          name.to_s.singularize
+        end
+
+        def polymorphic?
+          options[:polymorphic]
+        end
+
+        def self.properties(&block)
+          block_given? ? write_inheritable_attribute(:properties, block) : read_inheritable_attribute(:properties)
+        end
+
+        def self.methods(&block)
+          block_given? ? write_inheritable_attribute(:methods, block) : read_inheritable_attribute(:methods)
+        end
+
+      private
+        def association_class
+          self.class::Association rescue Base::Association
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/associations/base/proxy.rb

@@ -0,0 +1,58 @@
+module MongoModel
+  module Associations
+    module Base
+      class Proxy
+        alias_method :proxy_respond_to?, :respond_to?
+        alias_method :proxy_extend, :extend
+
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/ }
+
+        attr_reader :association
+
+        def initialize(association)
+          @association = association
+        end
+  
+        def target=(new_target)
+          @target = new_target
+          loaded!
+          @target
+        end
+
+        def target
+          load_target
+          @target
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def loaded!
+          @loaded = true
+        end
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || target.respond_to?(*args)
+        end
+
+      private
+        def method_missing(*args, &block)
+          target.send(*args, &block)
+        end
+
+        def load_target
+          @target = @association.find_target unless loaded?
+          loaded!
+        rescue MongoModel::DocumentNotFound
+          reset
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/associations/belongs_to.rb

@@ -0,0 +1,68 @@
+module MongoModel
+  module Associations
+    class BelongsTo < Base::Definition
+      def foreign_key
+        :"#{name}_id"
+      end
+      
+      def type_key
+        :"#{name}_type"
+      end
+      
+      properties do |association|
+        property association.foreign_key, String, :internal => true
+        property association.type_key, String, :internal => true if association.polymorphic?
+      end
+      
+      methods do |association|
+        define_method(association.name) do |*args|
+          force_reload = args.first || false
+          
+          associations[association.name].proxy.reset if force_reload
+          associations[association.name].proxy
+        end
+        
+        define_method("#{association.name}=") { |obj| associations[association.name].replace(obj) }
+        
+        unless association.polymorphic?
+          define_method("build_#{association.name}") do |*args|
+            associations[association.name].replace(association.klass.new(*args))
+          end
+        
+          define_method("create_#{association.name}") do |*args|
+            associations[association.name].replace(association.klass.create(*args))
+          end
+        end
+      end
+      
+      class Association < Base::Association
+        delegate :foreign_key, :type_key, :to => :definition
+        
+        def target_id
+          instance[foreign_key]
+        end
+        
+        def target_class
+          if polymorphic?
+            instance[type_key].constantize rescue nil
+          else
+            klass
+          end
+        end
+        
+        def replace(obj)
+          ensure_class(obj) unless polymorphic?
+          
+          instance[foreign_key] = obj.id
+          instance[type_key] = obj.class if polymorphic?
+          
+          super
+        end
+        
+        def find_target
+          target_class.find(target_id) unless target_id.nil? || target_class.nil?
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/associations/has_many_by_foreign_key.rb

@@ -0,0 +1,159 @@
+module MongoModel
+  module Associations
+    class HasManyByForeignKey < Base::Definition
+      def foreign_key
+        options[:foreign_key] || :"#{inverse_of}_id"
+      end
+      
+      def inverse_of
+        options[:inverse_of] || owner.to_s.downcase.demodulize.singularize.to_sym
+      end
+      
+      def define!
+        raise "has_many :by => :foreign_key is only valid on Document" unless owner.ancestors.include?(Document)
+        super
+      end
+      
+      methods do |association|
+        define_method(association.name) { associations[association.name].proxy }
+        define_method("#{association.name}=") { |obj| associations[association.name].replace(obj) }
+      end
+      
+      class Association < Base::Association
+        delegate :foreign_key, :inverse_of, :to => :definition
+        
+        def find_target
+          klass.find(:all, :conditions => { foreign_key => instance.id }) + new_documents
+        end
+        
+        def build(*args, &block)
+          doc = klass.new(*args, &block)
+          new_documents << doc
+          doc
+        end
+        
+        def create(*args, &block)
+          klass.create(*args) do |doc|
+            if doc.respond_to?("#{inverse_of}=")
+              doc.send("#{inverse_of}=", instance)
+            else
+              doc[foreign_key] = instance.id
+            end
+            
+            block.call(doc) if block
+          end
+        end
+        
+        def replace(array)
+          ensure_class(array)
+          array.each { |doc| assign(doc) }
+          super
+        end
+        
+        def assign(doc)
+          if doc.respond_to?("#{inverse_of}=")
+            doc.send("#{inverse_of}=", instance)
+          else
+            doc[foreign_key] = instance.id
+          end
+          
+          doc.save(false) unless doc.new_record?
+        end
+        
+        def send_to_klass_with_scope(*args, &block)
+          fk = foreign_key
+          id = instance.id
+          
+          klass.instance_eval do
+            with_scope(:find => { :conditions => { fk => id } }) do
+              send(*args, &block)
+            end
+          end
+        end
+      
+      protected
+        def new_documents
+          @new_documents ||= []
+        end
+        
+        def ensure_class(array)
+          array.is_a?(Array) ? array.each { |i| super(i) } : super
+        end
+      end
+      
+      class Proxy < Base::Proxy
+        # Pass these methods to the association class rather than the Array target
+        OVERRIDE_METHODS = [ :find ]
+        
+        delegate :ensure_class, :to => :association
+        
+        def build(*args, &block)
+          doc = association.build(*args, &block)
+          self << doc
+          doc
+        end
+        
+        def create(*args, &block)
+          doc = association.create(*args, &block)
+          self << doc
+          doc
+        end
+        
+        def []=(index, doc)
+          ensure_class(doc)
+          association.assign(doc)
+          super if loaded?
+          self
+        end
+        
+        def <<(doc)
+          ensure_class(doc)
+          association.assign(doc)
+          super if loaded?
+          self
+        end
+        
+        def concat(documents)
+          ensure_class(documents)
+          documents.each { |doc| association.assign(doc) }
+          super if loaded?
+          self
+        end
+        
+        def insert(index, doc)
+          ensure_class(doc)
+          association.assign(doc)
+          super if loaded?
+          self
+        end
+        
+        def push(*documents)
+          ensure_class(documents)
+          documents.each { |doc| association.assign(doc) }
+          super if loaded?
+          self
+        end
+        
+        def unshift(*documents)
+          ensure_class(documents)
+          documents.each { |doc| association.assign(doc) }
+          super if loaded?
+          self
+        end
+        
+        def ids
+          target.map { |doc| doc.id }
+        end
+      
+      private
+        def method_missing(method_id, *args, &block)
+          if target.respond_to?(method_id) && !OVERRIDE_METHODS.include?(method_id.to_sym)
+            super(method_id, *args, &block)
+          else
+            association.send_to_klass_with_scope(method_id, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/concerns/associations/has_many_by_ids.rb

@@ -0,0 +1,175 @@
+module MongoModel
+  module Associations
+    class HasManyByIds < Base::Definition
+      def property_name
+        :"#{singular_name}_ids"
+      end
+      
+      properties do |association|
+        property association.property_name, Collection[String], :internal => true, :default => []
+      end
+      
+      methods do |association|
+        define_method(association.name) { associations[association.name].proxy }
+        define_method("#{association.name}=") { |obj| associations[association.name].replace(obj) }
+      end
+      
+      class Association < Base::Association
+        delegate :property_name, :to => :definition
+        
+        def ids
+          instance[property_name]
+        end
+        
+        def replace(array)
+          ensure_class(array)
+          
+          instance[property_name] = array.map { |i| i.id }
+          super
+        end
+        
+        def find_target
+          ids.any? ? Array(klass.find(*(ids - new_document_ids))) + new_documents : []
+        end
+        
+        def build(*args, &block)
+          doc = klass.new(*args, &block)
+          new_documents << doc
+          doc
+        end
+        
+        def create(*args, &block)
+          klass.create(*args, &block)
+        end
+        
+        def send_to_klass_with_scope(*args, &block)
+          scope_ids = ids
+          
+          klass.instance_eval do
+            with_scope(:find => { :conditions => { :id.in => scope_ids } }) do
+              send(*args, &block)
+            end
+          end
+        end
+        
+      protected
+        def new_documents
+          @new_documents ||= []
+        end
+        
+        def new_document_ids
+          new_documents.map { |doc| doc.id }
+        end
+      
+        def ensure_class(array)
+          array.is_a?(Array) ? array.each { |i| super(i) } : super
+        end
+      end
+      
+      class Proxy < Base::Proxy
+        # Pass these methods to the association class rather than the Array target
+        OVERRIDE_METHODS = [ :find ]
+        
+        delegate :ensure_class, :to => :association
+        
+        def build(*args, &block)
+          doc = association.build(*args, &block)
+          self << doc
+          doc
+        end
+        
+        def create(*args, &block)
+          doc = association.create(*args, &block)
+          self << doc
+          doc
+        end
+        
+        def []=(index, doc)
+          ensure_class(doc)
+          super if loaded?
+          ids[index] = doc.id
+          self
+        end
+        
+        def <<(doc)
+          ensure_class(doc)
+          super if loaded?
+          ids << doc.id
+          self
+        end
+        
+        def concat(documents)
+          ensure_class(documents)
+          super if loaded?
+          ids.concat(documents.map { |doc| doc.id })
+          self
+        end
+        
+        def insert(index, doc)
+          ensure_class(doc)
+          super if loaded?
+          ids.insert(index, doc.id)
+          self
+        end
+        
+        def replace(documents)
+          ensure_class(documents)
+          super if loaded?
+          ids.replace(documents.map { |doc| doc.id })
+          self
+        end
+        
+        def push(*documents)
+          ensure_class(documents)
+          super if loaded?
+          ids.push(*documents.map { |doc| doc.id })
+          self
+        end
+        
+        def unshift(*documents)
+          ensure_class(documents)
+          super if loaded?
+          ids.unshift(*documents.map { |doc| doc.id })
+          self
+        end
+        
+        def clear
+          super if loaded?
+          ids.clear
+          self
+        end
+        
+        def delete(doc)
+          super if loaded?
+          ids.delete(doc.id)
+          self
+        end
+        
+        def delete_at(index)
+          super if loaded?
+          ids.delete_at(index)
+          self
+        end
+        
+        def delete_if(&block)
+          super
+          ids.replace(map { |doc| doc.id })
+          self
+        end
+        
+        def ids
+          association.ids
+        end
+      
+      private
+        def method_missing(method_id, *args, &block)
+          if target.respond_to?(method_id) && !OVERRIDE_METHODS.include?(method_id.to_sym)
+            super(method_id, *args, &block)
+          else
+            association.send_to_klass_with_scope(method_id, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end