active_mongoid 0.1.0

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

@@ -0,0 +1,128 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      module Referenced
+        class Many < Associations::Many
+
+          private
+
+          def criteria
+            Many.criteria(__metadata__, base.send(__metadata__.primary_key), base.class)
+          end
+
+          def binding
+            Bindings::Many.new(base, target, __metadata__)
+          end
+
+          # TODO: look into AR analog to collection insert
+          def persist_delayed(objs, inserts)
+            unless objs.empty?
+              # collection.insert(inserts)
+              inserts.each do |insert|
+                insert.save
+              end
+              objs.each do |obj|
+                # obj.save
+                # obj.post_persist
+              end
+            end
+          end
+
+          def save_or_delay(obj, objs, inserts)
+            if obj.new_record? && obj.valid?(:create)
+              # obj.run_before_callbacks(:save, :create)
+              obj.save
+              objs.push(obj)
+              inserts.push(obj)
+            else
+              obj.save
+            end
+          end
+
+          def remove_all(conditions = nil, method = :delete_all)
+            conditions = conditions || {}
+            removed = klass.send(method, conditions.merge!(criteria.where_values_hash))
+            target.delete_if do |obj|
+              if matches?(obj, conditions)
+                unbind_one(obj) and true
+              end
+            end
+            removed
+          end
+
+          def matches?(obj, conditions)
+            conditions.all? {|key, value| obj.attributes[key] == value}
+          end
+
+          def remove_not_in(ids)
+            removed = criteria.where("id not in (?)", ids)
+            if __metadata__.destructive?
+              removed.delete_all
+            else
+              removed.update_all(__metadata__.foreign_key => nil)
+            end
+            in_memory.each do |obj|
+              if !ids.include?(obj.id)
+                unbind_one(obj)
+                target.delete(obj)
+                if __metadata__.destructive?
+                  obj.mark_for_destruction
+                end
+              end
+            end
+          end
+
+          def method_missing(name, *args, &block)
+            if target.respond_to?(name)
+              target.send(name, *args, &block)
+            else
+              criteria.scoping do
+                criteria.public_send(name, *args, &block)
+              end
+            end
+          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_many_records
+            end
+
+            def builder(base, meta, object)
+              ActiveMongoid::Associations::Builders::Many.new(base, meta, object || [])
+            end
+
+            def criteria(metadata, object, type = nil)
+              crit = metadata.klass.where(metadata.foreign_key => object.to_s)
+              if metadata.polymorphic?
+                crit = crit.where(metadata.type => type.name)
+              end
+              crit
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module ActiveMongoid
+  module Associations
+    module RecordRelation
+      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_record
+            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/targets/enumerable.rb

@@ -0,0 +1,161 @@
+require 'mongoid'
+
+module ActiveMongoid
+  module Associations
+    module Targets
+      class Enumerable
+        include ::Enumerable
+
+        attr_accessor :added, :loaded, :unloaded
+
+        delegate :===, :is_a?, :kind_of?, :to => :added
+
+        def ==(other)
+          return false unless other.respond_to?(:entries)
+          entries == other.entries
+        end
+
+        def <<(document)
+          added.push(document)
+        end
+        alias :push :<<
+
+        def clear
+          if block_given?
+            in_memory { |doc| yield(doc) }
+          end
+          loaded.clear and added.clear
+        end
+
+        def clone
+          collect { |doc| doc.clone }
+        end
+
+        def delete(document)
+          (loaded.delete_one(document) || added.delete_one(document)).tap do |doc|
+            unless doc
+              key = document.is_a?(::Mongoid::Document) ? :_id : :id
+              if unloaded && unloaded.where(key => document.id).exists?
+                yield(document) if block_given?
+                return document
+              end
+            end
+            yield(doc) if block_given?
+          end
+        end
+
+        def delete_if(&block)
+          load_all!
+          tap do
+            loaded.delete_if(&block)
+            added.delete_if(&block)
+          end
+        end
+
+        def each
+          if loaded?
+            loaded.each do |doc|
+              yield(doc)
+            end
+          else
+            unloaded.each do |doc|
+              document = added.delete(doc) || loaded.delete(doc) || doc
+              yield(document)
+              loaded.push(document)
+            end
+          end
+          added.each do |doc|
+            yield(doc)
+          end
+          @executed = true
+        end
+
+        def empty?
+          if loaded?
+            in_memory.count == 0
+          else
+            unloaded.count + added.count == 0
+          end
+        end
+
+        def first
+          added.first || (loaded? ? loaded.first : unloaded.first)
+        end
+
+        def initialize(target)
+          if target.is_a?(::Mongoid::Criteria) || target.is_a?(::ActiveRecord::Relation)
+            @added, @loaded, @unloaded = [], [], target
+          else
+            @added, @executed, @loaded = [], true, target
+          end
+        end
+
+        def inspect
+          entries.inspect
+        end
+
+        def in_memory
+          (loaded + added).tap do |docs|
+            docs.each { |doc| yield(doc) } if block_given?
+          end
+        end
+
+        def last
+          added.last || (loaded? ? loaded.last : unloaded.last)
+        end
+
+        alias :load_all! :entries
+
+        def loaded?
+          !!@executed
+        end
+
+        def reset
+          loaded.clear and added.clear
+          @executed = false
+        end
+
+        def respond_to?(name, include_private = false)
+          [].respond_to?(name, include_private) || super
+        end
+
+        def size
+          count = (unloaded ? unloaded.count : loaded.count)
+          if count.zero?
+            count + added.count
+          else
+            count + added.count{ |d| d.new_record? }
+          end
+        end
+        alias :length :size
+
+        def to_json(options = {})
+          entries.to_json(options)
+        end
+
+        def as_json(options = {})
+          entries.as_json(options)
+        end
+
+        def uniq
+          entries.uniq
+        end
+
+        def where(opts = :chain, *rest)
+          if unloaded.is_a?(::Mongoid::Criteria) || unloaded.is_a?(::ActiveRecord::Relation)
+            unloaded.where(opts, *rest)
+          else
+            raise NoMethodError
+          end
+        end
+
+        private
+
+        def method_missing(name, *args, &block)
+          entries.send(name, *args, &block)
+        end
+
+      end
+    end
+  end
+end

data/lib/active_mongoid/bson_id.rb

@@ -0,0 +1,44 @@
+module ActiveMongoid
+  module BsonId
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def bsonify_attr(name, options = {})
+        bson_attr_setter(name)
+        bson_attr_getter(name)
+        bson_attr_init(name) if options[:initialize]
+      end
+
+      private
+
+      def bson_attr_setter(name)
+        self.instance_eval do
+          define_method("#{name}=") do |object|
+            attribute = object.nil? ? nil : object.to_s
+            write_attribute(name, attribute)
+          end
+        end
+      end
+
+      def bson_attr_getter(name)
+        self.instance_eval do
+          define_method(name) do
+            attribute = read_attribute(name)
+            attribute.nil? ? nil : ::ActiveMongoid::BSON::ObjectId.from_string(attribute)
+          end
+        end
+      end
+
+      def bson_attr_init(name)
+        init_method = :"init_attr_for_#{name}"
+        define_method(init_method) do
+          self.send("#{name}=", ::ActiveMongoid::BSON::ObjectId.new) unless read_attribute(name)
+        end
+        after_initialize init_method
+      end
+
+    end
+
+  end
+end

data/lib/active_mongoid/finder_proxy.rb

@@ -0,0 +1,55 @@
+module ActiveMongoid
+  class FinderProxy
+    instance_methods.each do |method|
+      undef_method(method) unless method =~ /(^__|^object_id|^tap)/
+    end
+
+    attr_accessor :__target
+    attr_accessor :__target_class
+
+
+    def initialize(target)
+      @__target = target
+      @__target_class = target.respond_to?(:klass) ? target.klass : target
+    end
+
+    def find(*args)
+      key = args.flatten.first
+      if !key.is_a?(Fixnum) && (key.is_a?(::ActiveMongoid::BSON::ObjectId) || ::ActiveMongoid::BSON::ObjectId.legal?(key))
+        where({_id: key.to_s}).first.tap do |obj|
+          raise ActiveRecord::RecordNotFound unless obj
+        end
+      else
+        FinderProxy.new(__target.send(:find, *args))
+      end
+    end
+
+    def where(opts = :chain, *rest)
+      if opts && opts.is_a?(Hash)
+        bson_opts = opts.select{|k,v| v.is_a?(::ActiveMongoid::BSON::ObjectId)}
+
+        if bson_opts[:id]
+          opts.delete(:id)
+          bson_opts[:_id] = bson_opts.delete(:id)
+        end
+
+        bson_opts.each do |k,v|
+          bson_opts[k] = v.to_s
+        end
+
+        opts.merge!(bson_opts)
+      end
+      FinderProxy.new(__target.send(:where, opts, *rest))
+    end
+
+    def method_missing(name, *args, &block)
+      resp = __target.send(name, *args, &block)
+      if resp == __target_class || (resp.is_a?(ActiveRecord::Relation) && resp.klass == __target_class)
+        FinderProxy.new(resp)
+      else
+        resp
+      end
+    end
+
+  end
+end