active_mongoid 0.1.0

data/lib/active_mongoid/associations/one.rb

@@ -0,0 +1,21 @@
+module ActiveMongoid
+  module Associations
+    class One < Proxy
+
+      def clear
+        target.delete
+      end
+
+      def respond_to?(name, include_private = false)
+        target.respond_to?(name, include_private) || super
+      end
+
+      def ==(other)
+        return false unless other
+        return true if target.object_id == other.object_id
+        return true if target.attributes == other.attributes
+        target == other
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/proxy.rb

@@ -0,0 +1,38 @@
+module ActiveMongoid
+  module Associations
+    class Proxy
+
+      instance_methods.each do |method|
+        undef_method(method) unless
+          method =~ /(^__|^send|^object_id|^respond_to|^tap)/
+      end
+
+      delegate :bind_one, :unbind_one, to: :binding
+
+      attr_accessor :base, :target, :__metadata__
+
+      def init(base, target, metadata)
+        @base = base
+        @target = target
+        @__metadata__ = metadata
+        yield(self) if block_given?
+      end
+
+      def method_missing(name, *args, &block)
+        target.send(name, *args, &block)
+      end
+
+      def klass
+        __metadata__ ? __metadata__.klass : nil
+      end
+
+      def ==(other)
+        # return false unless other
+        # return true if target.object_id == other.object_id
+        # return true if target.attributes == other.attributes
+        target == other
+      end
+
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/accessors.rb

@@ -0,0 +1,80 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Accessors
+        extend ActiveSupport::Concern
+
+        def build_record(name, object, metadata)
+          relation = create_record_relation(object, metadata)
+          set_record_relation(name, relation)
+        end
+
+        def set_record_relation(name, object)
+          instance_variable_set("@#{name}", object)
+        end
+
+        def create_record_relation(object, metadata)
+          type = self.attributes[metadata.inverse_type]
+          target = metadata.builder(self, object).build(type)
+          target ? metadata.relation.new(self, target, metadata) : nil
+        end
+
+
+        private
+
+        def get_record_relation(name, metadata, object, reload = false)
+          if !reload && (value = instance_variable_get("@#{name}")) != nil
+            value
+          else
+            if object && needs_no_database_query?(object, metadata)
+              build_record(name, object, metadata)
+            else
+              build_record(name, attributes.with_indifferent_access[metadata.key].to_s, metadata)
+            end
+          end
+        end
+
+        def needs_no_database_query?(object, metadata)
+          object.is_a?(::ActiveRecord::Base) && object.id == attributes[metadata.key]
+        end
+
+
+        module ClassMethods
+
+          private
+
+          def existence_check(name)
+            module_eval <<-END
+              def #{name}?
+                !__send__(:#{name}).blank?
+              end
+              alias :has_#{name}? :#{name}?
+            END
+            self
+          end
+
+          def record_getter(name, metadata)
+            self.instance_eval do
+              define_method(name) do |reload = false|
+                get_record_relation(name, metadata, nil, reload)
+              end
+            end
+          end
+
+          def record_setter(name, metadata)
+            self.instance_eval do
+              define_method("#{name}=") do |object|
+                if value = get_record_relation(name, metadata, object)
+                  set_record_relation(name, value.substitute(object))
+                else
+                  build_record(name, object, metadata)
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/associations.rb

@@ -0,0 +1,33 @@
+require "active_mongoid/associations/record_relation/macros"
+require "active_mongoid/associations/record_relation/accessors"
+require "active_mongoid/associations/record_relation/builders"
+require "active_mongoid/associations/record_relation/auto_save"
+require "active_mongoid/associations/record_relation/dependent"
+require "active_mongoid/associations/record_relation/bindings/one"
+require "active_mongoid/associations/record_relation/bindings/in"
+require "active_mongoid/associations/record_relation/bindings/many"
+require "active_mongoid/associations/record_relation/referenced/one"
+require "active_mongoid/associations/record_relation/referenced/in"
+require "active_mongoid/associations/record_relation/referenced/many"
+
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Associations
+        extend ActiveSupport::Concern
+
+        attr_accessor :__metadata__
+
+        included do
+          include RecordRelation::Macros
+          include RecordRelation::Accessors
+          include RecordRelation::Builders
+          include RecordRelation::AutoSave
+          include RecordRelation::Dependent
+        end
+
+      end
+    end
+  end
+end
+

data/lib/active_mongoid/associations/record_relation/auto_save.rb

@@ -0,0 +1,43 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module AutoSave
+        extend ActiveSupport::Concern
+
+        def record_changed_for_autosave?(obj)
+          obj.new_record? || obj.changed? || obj.marked_for_destruction?
+        end
+
+        module ClassMethods
+
+          def autosave_records(metadata)
+            if metadata.autosave?
+              save_method = :"autosave_records_for_#{metadata.name}"
+              define_method(save_method) do
+                if relation = instance_variable_get("@#{metadata.name}")
+                  Array(relation).each { |d| d.save if record_changed_for_autosave?(d) }
+                end
+              end
+              after_save save_method
+            end
+            autosave_record_id(metadata)
+          end
+
+          def autosave_record_id(metadata)
+            if metadata.stores_foreign_key?
+              save_method = :"autosave_record_id_for_#{metadata.name}"
+              define_method(save_method) do
+                if relation = instance_variable_get("@#{metadata.name}")
+                  self.send(metadata.foreign_key_setter, relation.send(metadata.primary_key))
+                end
+              end
+              before_save save_method
+            end
+          end
+
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/bindings/in.rb

@@ -0,0 +1,48 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Bindings
+        class In < Associations::Binding
+
+          def bind_one
+            check_inverse!(target)
+            bind_foreign_key(base, record_id(target))
+            bind_polymorphic_inverse_type(base, target.class.name)
+            unless _binding?
+              _binding do
+                if inverse = __metadata__.inverse(target)
+                  if set_base_metadata
+                    if base.referenced_many_documents?
+                      target.__send__(inverse).push(base)
+                    else
+                      target.set_document_relation(inverse, base)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          def unbind_one
+            inverse = __metadata__.inverse(target)
+            bind_foreign_key(base, nil)
+            bind_polymorphic_inverse_type(base, nil)
+            unless _binding?
+              _binding do
+                if inverse
+                  set_base_metadata
+                  if base.referenced_many_documents?
+                    target.__send__(inverse).delete(base)
+                  else
+                    target.set_document_relation(inverse, nil)
+                  end
+                end
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/bindings/many.rb

@@ -0,0 +1,19 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Bindings
+        class Many < Associations::Binding
+
+          def bind_one(record)
+            bind_from_relational_parent(record)
+          end
+
+          def unbind_one(record)
+            unbind_from_relational_parent(record)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/bindings/one.rb

@@ -0,0 +1,19 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Bindings
+        class One < Associations::Binding
+
+          def bind_one
+            bind_from_relational_parent(target)
+          end
+
+          def unbind_one
+            unbind_from_relational_parent(target)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/builders.rb

@@ -0,0 +1,31 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Builders
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def record_builder(name, metadata)
+            define_method("build_#{name}") do |attributes = {}|
+              record = metadata.klass.new(attributes)
+              send("#{name}=", record)
+            end
+            self
+          end
+
+          def record_creator(name, metadata)
+            define_method("create_#{name}") do |attributes = {}|
+              record = metadata.klass.new(attributes)
+              obj = send("#{name}=", record)
+              record.save
+              save if metadata.stores_foreign_key?
+              obj
+            end
+            self
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/dependent.rb

@@ -0,0 +1,26 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Dependent
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def dependent_records(metadata)
+            if metadata.dependent
+              dependent_method = :"dependent_records_for_#{metadata.name}"
+              define_method(dependent_method) do
+                relation = get_record_relation(metadata.name, metadata, nil, true)
+                Array(relation).each { |d| d.send(metadata.dependent) }
+              end
+
+              before_destroy dependent_method
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/macros.rb

@@ -0,0 +1,65 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Macros
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def belongs_to_record(name, options = {})
+            meta = characterize_association(name, Referenced::In, options)
+            reference_record(meta)
+            relate_one_to_one_record(name, meta)
+          end
+
+          def has_one_record(name, options = {})
+            meta = characterize_association(name, Referenced::One, options)
+            relate_one_to_one_record(name, meta)
+          end
+
+          def has_many_records(name, options = {})
+            meta = characterize_association(name, Referenced::Many, options)
+            relate_record(name, meta)
+            # document_ids_setter(name, metadata)
+            # document_ids_getter(name, metadata)
+          end
+
+          private
+
+          def reference_record(metadata)
+            key = metadata.foreign_key
+            if metadata.stores_foreign_key? && !fields.include?(key)
+              field(
+                key,
+                type: Integer,
+                default: metadata.foreign_key_default
+              )
+              if metadata.polymorphic?
+                self.polymorphic = true
+                field(metadata.inverse_type, type: String)
+              end
+            end
+          end
+
+          def relate_one_to_one_record(name, metadata)
+            relate_record(name, metadata)
+            record_builder(name, metadata)
+            record_creator(name, metadata)
+          end
+
+
+          def relate_record(name, metadata)
+            self.am_relations = am_relations.merge(name.to_s => metadata)
+            record_getter(name, metadata)
+            record_setter(name, metadata)
+            autosave_records(metadata)
+            dependent_records(metadata)
+            existence_check(name)
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/active_mongoid/associations/record_relation/referenced/in.rb

@@ -0,0 +1,72 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Referenced
+        class In < Associations::One
+
+          def initialize(base, target, metadata)
+            init(base, target, metadata) do
+              bind_one
+            end
+          end
+
+          def substitute(replacement)
+            unbind_one
+            return nil unless replacement
+            self.target = normalize(replacement)
+            bind_one
+            self
+          end
+
+          private
+
+          def binding
+            Bindings::In.new(base, target, __metadata__)
+          end
+
+          def normalize(replacement)
+            return replacement if replacement.is_a?(::ActiveRecord::Base)
+            __metadata__.builder(klass, replacement).build
+          end
+
+          class << self
+
+            def stores_foreign_key?
+              true
+            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
+              :belongs_to_record
+            end
+
+            def builder(base, meta, object)
+              ActiveMongoid::Associations::Builders::In.new(base, meta, object)
+            end
+
+            def criteria(metadata, object, type = nil)
+              type.where(metadata.primary_key => object)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end