active_mongoid 0.1.0

data/lib/active_mongoid/associations/document_relation/referenced/one.rb

@@ -0,0 +1,75 @@
+module ActiveMongoid
+  module Associations
+    module DocumentRelation
+      module Referenced
+        class One < Associations::One
+
+          def initialize(base, target, metadata)
+            init(base, target, metadata) do
+              bind_one
+            end
+          end
+
+          def substitute(replacement)
+            unbind_one
+            if base.persisted?
+              if __metadata__.destructive?
+                send(__metadata__.dependent)
+              else
+                save if persisted?
+              end
+            end
+            One.new(base, replacement, __metadata__) if replacement
+          end
+
+          private
+
+          def binding
+            Bindings::One.new(base, target, __metadata__)
+          end
+
+          class << self
+
+            def stores_foreign_key?
+              false
+            end
+
+            def foreign_key(name)
+              "#{name}#{foreign_key_suffix}"
+            end
+
+            def foreign_key_default
+              nil
+            end
+
+            def foreign_key_suffix
+              "_id"
+            end
+
+            def primary_key_default
+              "id"
+            end
+
+            def macro
+              :has_one_document
+            end
+
+            def builder(base, meta, object)
+              ActiveMongoid::Associations::Builders::One.new(base, meta, object)
+            end
+
+            def criteria(metadata, object, type = nil)
+              crit = metadata.klass.where(metadata.foreign_key => object)
+              if metadata.polymorphic?
+                crit = crit.where(metadata.type => type.name)
+              end
+              crit
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/many.rb

@@ -0,0 +1,211 @@
+module ActiveMongoid
+  module Associations
+    class Many < Proxy
+      include ::Mongoid::Threaded::Lifecycle
+
+      delegate :avg, :max, :min, :sum, to: :criteria
+      delegate :length, :size, to: :target
+      delegate :count, to: :criteria
+      delegate :first, :in_memory, :last, :reset, :uniq, to: :target
+
+      def initialize(base, target, metadata)
+        init(base, ActiveMongoid::Associations::Targets::Enumerable.new(target), metadata) do
+        end
+      end
+
+      def <<(*args)
+        objs = args.flatten
+        return concat(objs) if objs.size > 1
+        if objs = objs.first
+          append(objs)
+          objs.save if base.persisted? && !_binding?
+        end
+        self
+      end
+      alias :push :<<
+
+      def build(attributes = {}, type = nil)
+        obj = (type || klass).new(attributes)
+        append(obj)
+        yield(obj) if block_given?
+        obj
+      end
+      alias :new :build
+
+      def concat(objects)
+        objs, inserts = [], []
+        objects.each do |obj|
+          next unless obj
+          append(obj)
+          save_or_delay(obj, objs, inserts) if base.persisted?
+        end
+        persist_delayed(objs, inserts)
+        self
+      end
+
+      def purge
+        unless __metadata__.destructive?
+          nullify
+        else
+          after_remove_error = nil
+          criteria.delete_all
+          many = target.clear do |obj|
+            unbind_one(obj)
+            obj.destroyed = true if obj.respond_to?(:destroyed=)
+          end
+          many
+        end
+      end
+      alias :clear :purge
+
+      def delete(object)
+        target.delete(object) do |obj|
+          unbind_one(obj) if obj
+          cascade!(obj) if obj
+        end
+      end
+
+      def delete_all(conditions = nil)
+        remove_all(conditions, :delete_all)
+      end
+
+      def destroy_all(conditions = nil)
+        remove_all(conditions, :destroy_all)
+      end
+
+      def each
+        if block_given?
+          target.each { |obj| yield(obj) }
+        else
+          to_enum
+        end
+      end
+
+      def exists?
+        criteria.exists?
+      end
+
+      def find(*args)
+        begin
+          matching = criteria.find(*args)
+        rescue Exception => e
+        end
+        Array(matching).each { |obj| target.push(obj) }
+        matching
+      end
+
+      def nullify
+        criteria.update_all(__metadata__.foreign_key => nil)
+        target.clear do |obj|
+          unbind_one(obj)
+          obj.changed_attributes.delete(__metadata__.foreign_key)
+        end
+      end
+      alias :nullify_all :nullify
+
+      def blank?
+        size == 0
+      end
+
+      def create(attributes = nil, type = nil, &block)
+        if attributes.is_a?(::Array)
+          attributes.map { |attrs| create(attrs, type, &block) }
+        else
+          obj = build(attributes, type, &block)
+          base.persisted? ? obj.save : raise_unsaved(obj)
+          obj
+        end
+      end
+
+      def create!(attributes = nil, type = nil, &block)
+        if attributes.is_a?(::Array)
+          attributes.map { |attrs| create!(attrs, type, &block) }
+        else
+          obj = build(attributes, type, &block)
+          base.persisted? ? obj.save! : raise_unsaved(obj)
+          obj
+        end
+      end
+
+      def find_or_create_by(attrs = {}, type = nil, &block)
+        find_or(:create, attrs, type, &block)
+      end
+
+      def find_or_initialize_by(attrs = {}, type = nil, &block)
+        find_or(:build, attrs, type, &block)
+      end
+
+      def nil?
+        false
+      end
+
+      def respond_to?(name, include_private = false)
+        [].respond_to?(name, include_private) ||
+          klass.respond_to?(name, include_private) || super
+      end
+
+      def scoped
+        criteria
+      end
+
+      def unscoped
+        criteria.unscoped
+      end
+
+      def raise_unsaved(obj)
+        # raise new exception
+      end
+
+      def substitute(replacement)
+        if replacement
+          new_objs, objs = replacement.compact, []
+          new_ids = new_objs.map { |obj| obj.id }
+          remove_not_in(new_ids)
+          new_objs.each do |obj|
+            objs.push(obj) if obj.send(__metadata__.foreign_key) != base.id
+          end
+          concat(objs)
+        else
+          purge
+        end
+        self
+      end
+
+      def unscoped
+        klass.unscoped.where(__metadata__.foreign_key => base.id)
+      end
+
+      private
+
+      def find_or(method, attrs = {}, type = nil, &block)
+        attrs["_type"] = type.to_s if type
+        where(attrs).first || send(method, attrs, type, &block)
+      end
+
+      def append(object)
+        target.push(object)
+        # characterize_one(object)
+        bind_one(object)
+      end
+
+      def cascade!(object)
+        if base.persisted?
+          if __metadata__.destructive?
+            object.send(__metadata__.dependent)
+          else
+            object.save
+          end
+        end
+      end
+
+      def with_polymorphic_criterion(criteria, metadata, type = nil)
+        if metadata.polymorphic?
+          criteria.where(metadata.type => type.name)
+        else
+          criteria
+        end
+      end
+
+    end
+  end
+end

data/lib/active_mongoid/associations/metadata.rb

@@ -0,0 +1,229 @@
+module ActiveMongoid
+  module Associations
+    class Metadata < Hash
+
+      delegate :primary_key_default, :foreign_key_default, :stores_foreign_key?, :macro, to: :relation
+
+      def as
+        self[:as]
+      end
+
+      def as?
+        !!as
+      end
+
+      def initialize(properties = {})
+        merge!(properties)
+      end
+
+      def autosave
+        self[:autosave]
+      end
+
+      def autosave?
+        !!autosave
+      end
+
+      def builder(base, object)
+        relation.builder(base, self, object)
+      end
+
+      def order
+        self[:order]
+      end
+
+      def criteria(object, type = nil)
+        query = relation.criteria(self, object, type)
+        if order
+          query = query.respond_to?(:order_by) ? query.order_by(order) : query.order(order)
+        end
+        query
+      end
+
+      def key
+        relation.stores_foreign_key? ? foreign_key : primary_key
+      end
+
+      def foreign_key
+        @foreign_key ||= determine_foreign_key
+      end
+
+      def foreign_key_setter
+        @foreign_key_setter ||= "#{foreign_key}="
+      end
+
+      def type_setter
+        @type_setter ||= "#{type}="
+      end
+
+      def determine_key
+        relation.stores_foreign_key? ? foreign_key : primary_key
+      end
+
+      def primary_key
+        @primary_key ||= (self[:primary_key] || primary_key_default)
+      end
+
+      def determine_foreign_key
+        return self[:foreign_key].to_s if self[:foreign_key]
+
+        if relation.stores_foreign_key?
+          relation.foreign_key(name)
+        else
+          inverse_metadata.foreign_key
+        end
+      end
+
+      def object_class
+        class_name.constantize
+      end
+      alias_method :klass, :object_class
+
+      def class_name
+        (self[:class_name] || name.to_s.singularize.titleize.delete(' ')).sub(/\A::/,"")
+      end
+
+      def name
+        self[:name].to_s
+      end
+
+      def object_name
+        name.to_s.singularize
+      end
+
+      def plural_anme
+        name.to_s.pluralize
+      end
+
+      def relation
+        self[:relation]
+      end
+
+      def inverse_klass
+        @inverse_klass ||= inverse_class_name.constantize if inverse_class_name
+      end
+
+      def inverse_class_name
+        self[:as] || self[:inverse_class_name]
+      end
+
+      def inverses(other = nil)
+        if self[:polymorphic]
+          lookup_inverses(other)
+        else
+          @inverses ||= determine_inverses
+        end
+      end
+
+      def polymorphic?
+        @polymorphic ||= (!!self[:as] || !!self[:polymorphic])
+      end
+
+      def lookup_inverses(other)
+        return [ inverse_of ] if inverse_of
+        if other
+          matches = []
+          other.class.am_relations.values.each do |meta|
+            if meta.as.to_s == name && meta.class_name == inverse_class_name
+              matches.push(meta.name)
+            end
+          end
+          matches
+        end
+      end
+
+      def determine_inverse_for(field)
+        relation.stores_foreign_key? && polymorphic? ? "#{name}_#{field}" : nil
+      end
+
+      def inverse_type
+        @inverse_type ||= determine_inverse_for(:type)
+      end
+
+      def inverse(other = nil)
+        invs = inverses(other)
+        invs.first if invs.count == 1
+      end
+
+      def inverse_of
+        self[:inverse_of]
+      end
+
+      def inverse_setter(other = nil)
+        "#{inverse(other)}="
+      end
+
+      def inverse_metadata(object = nil)
+        object = object || object_class
+        object.reflect_on_am_association(inverse(object))
+      end
+
+      def determine_inverses
+        return [ inverse_of ] if has_key?(:inverse_of)
+        return [ as ] if has_key?(:as)
+        [ inverse_relation ]
+      end
+
+      def inverse_relation
+        @inverse_relation ||= determine_inverse_relation
+      end
+
+      def determine_inverse_relation
+        default = foreign_key_match || klass.am_relations[inverse_klass.name.underscore]
+        return default.name if default
+        klass.am_relations.each_pair do |key, meta|
+          next if meta.name == name
+          if meta.class_name == inverse_class_name
+            return key.to_sym
+          end
+        end
+        return nil
+      end
+
+      def foreign_key_match
+        if fk = self[:foreign_key]
+          relations_metadata.detect do |meta|
+            fk == meta.foreign_key if meta.stores_foreign_key?
+          end
+        end
+      end
+
+      def relations_metadata
+        klass.am_relations.values
+      end
+
+      def dependent
+        self[:dependent]
+      end
+
+      def destructive?
+        @destructive ||= (dependent == :delete || dependent == :destroy)
+      end
+
+      def polymorphic?
+        @polymorphic ||= (!!self[:as] || !!self[:polymorphic])
+      end
+
+      def type
+        @type ||= polymorphic? ? "#{as}_type" : nil
+      end
+
+      def type_setter
+        @type_setter ||= "#{type}="
+      end
+
+      def determine_inverse_for(field)
+        relation.stores_foreign_key? && polymorphic? ? "#{name}_#{field}" : nil
+      end
+
+      def inverse_type
+        @inverse_type ||= determine_inverse_for(:type)
+      end
+
+      def inverse_type_setter
+        @inverse_type_setter ||= "#{inverse_type}="
+      end
+
+    end
+  end
+end