mark_mapper 0.0.1

data/lib/mark_mapper/plugins/dirty.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Dirty
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Dirty
+
+      def initialize(*)
+        # never register initial id assignment as a change
+        # Chaining super into tap breaks implicit block passing in Ruby 1.8
+        doc = super
+        doc.tap { changed_attributes.delete('_id') }
+      end
+
+      def save(*)
+        clear_changes { super }
+      end
+
+      def reload(*)
+        doc = super
+        doc.tap { clear_changes }
+      end
+
+      def clear_changes
+        previous = changes
+        (block_given? ? yield : true).tap do |result|
+          unless result == false #failed validation; nil is OK.
+            @previously_changed = previous
+            changed_attributes.clear
+          end
+        end
+      end
+
+      protected
+
+      # We don't call super here to avoid invoking #attributes, which builds a whole new hash per call.
+      def attribute_method?(attr_name)
+        keys.key?(attr_name) || !embedded_associations.detect {|a| a.name == attr_name }.nil?
+      end
+
+      private
+
+      def write_key(key, value)
+        key = unalias_key(key)
+        if !keys.key?(key)
+          super
+        else
+          attribute_will_change!(key) unless attribute_changed?(key)
+          super.tap do
+            changed_attributes.delete(key) unless attribute_value_changed?(key)
+          end
+        end
+      end
+
+      def attribute_value_changed?(key_name)
+        changed_attributes[key_name] != read_key(key_name)
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/document.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Document
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def embeddable?
+          false
+        end
+      end
+
+      def new?
+        !!(@_new ||= false)
+      end
+
+      def destroyed?
+        !!(@_destroyed ||= false)
+      end
+
+      def reload
+        if doc = collection.find_one(:_id => id)
+          self.class.associations.each_value do |association|
+            get_proxy(association).reset
+          end
+          instance_variables.each { |ivar| remove_instance_variable(ivar) }
+          initialize_from_database(doc)
+          self
+        else
+          raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
+        end
+      end
+
+      # Used by embedded docs to find root easily without if/respond_to? stuff.
+      # Documents are always root documents.
+      def _root_document
+        self
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/dumpable.rb

@@ -0,0 +1,22 @@
+require 'set'
+
+module MarkMapper
+  module Plugins
+    module Dumpable
+      DUMP_BLACKLIST = Set.new([:@errors])
+
+      def marshal_dump
+        instance_variables.map(&:to_sym).inject({}) do |h, var|
+          h[var] = instance_variable_get(var) unless DUMP_BLACKLIST.include?(var) or var.to_s.start_with?("@__")
+          h
+        end
+      end
+
+      def marshal_load(data)
+        data.each do |k, v|
+          instance_variable_set(k, v)
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/dynamic_querying.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+require 'mark_mapper/plugins/dynamic_querying/dynamic_finder'
+
+module MarkMapper
+  module Plugins
+    module DynamicQuerying
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def dynamic_find(finder, args)
+          attributes = {}
+
+          finder.attributes.each_with_index do |attr, index|
+            attributes[attr] = args[index]
+          end
+
+          options = args.extract_options!.merge(attributes)
+
+          if result = send(finder.finder, options)
+            result
+          else
+            if finder.raise?
+              raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+            end
+
+            if finder.instantiator
+              self.send(finder.instantiator, attributes)
+            end
+          end
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            finder = DynamicFinder.new(method)
+
+            if finder.found?
+              dynamic_find(finder, args)
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/dynamic_querying/dynamic_finder.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module DynamicQuerying
+      class DynamicFinder
+        attr_reader :method, :attributes, :finder, :bang, :instantiator
+
+        def initialize(method)
+          @method = method
+          @finder = :first
+          @bang   = false
+          match
+        end
+
+        def found?
+          @finder.present?
+        end
+
+        def raise?
+          bang == true
+        end
+
+        protected
+          def match
+            case method.to_s
+              when /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+                @finder = :all if $1 == 'all_by'
+                names = $2
+              when /^find_by_([_a-zA-Z]\w*)\!$/
+                @bang = true
+                names = $1
+              when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
+                @instantiator = $1 == 'initialize' ? :new : :create
+                names = $2
+              else
+                @finder = nil
+            end
+
+            @attributes = names && names.split('_and_')
+          end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/embedded_callbacks.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module EmbeddedCallbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend  ::ActiveModel::Callbacks
+
+        define_model_callbacks :save, :create, :update, :destroy, :only => [:before, :after]
+        define_model_callbacks :initialize, :find, :touch, :only => [:after]
+
+        proxy_callbacks(
+          :before => [:save, :create, :update, :destroy],
+          :after  => [:save, :create, :update, :destroy, :touch]
+        )
+
+        @embedded_callbacks_status = nil
+      end
+
+      module ClassMethods
+        def define_callbacks(*args)
+          embedded_callbacks_on if @embedded_callbacks_status.nil?
+          super
+        end
+
+        def embedded_callbacks_on
+          @embedded_callbacks_status = true
+        end
+
+        def embedded_callbacks_off
+          @embedded_callbacks_status = false
+        end
+
+        def embedded_callbacks_on?
+          !!@embedded_callbacks_status
+        end
+
+        def embedded_callbacks_off?
+          !@embedded_callbacks_status
+        end
+
+        def proxy_callbacks(definition)
+          definition.each do |prefix, suffixes|
+            suffixes.each do |suffix|
+              callback = "%s_%s" % [prefix, suffix]
+              class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+                class << self
+                  alias_method :__original_#{callback}, :#{callback}
+
+                  def #{callback}(*args, &block)
+                    embedded_callbacks_on if @embedded_callbacks_status.nil?
+                    __original_#{callback}(*args, &block)
+                  end
+                end
+              CALLBACK
+            end
+          end
+        end
+      end
+
+      def run_callbacks(callback, *args, &block)
+        if self.class.embedded_callbacks_on? and embedded_associations.length > 0
+          embedded_docs = embedded_associations.map do |association|
+            Array(get_proxy(association).send(:load_target))
+          end.flatten(1)
+
+          block = embedded_docs.inject(block) do |chain, doc|
+            if doc.class.respond_to?("_#{callback}_callbacks")
+              lambda { doc.run_callbacks(callback, *args, &chain) }
+            else
+              chain
+            end
+          end
+        end
+
+        super callback, *args, &block
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/embedded_document.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module EmbeddedDocument
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :_parent_document
+      end
+
+      module ClassMethods
+        def embeddable?
+          true
+        end
+
+        def embedded_in(owner_name)
+          alias_method owner_name, :_parent_document
+        end
+      end
+
+      def new?
+        _root_document.try(:new?) || @_new
+      end
+
+      def destroyed?
+        !!_root_document.try(:destroyed?)
+      end
+
+      def save(options={})
+        _root_document.try(:save, options).tap do |result|
+          persist(options) if result
+        end
+      end
+
+      def save!(options={})
+        valid? || raise(DocumentNotValid.new(self))
+        _root_document.try(:save!, options).tap do |result|
+          persist(options) if result
+        end
+      end
+
+      def persist(options={})
+        @_new = false
+        clear_changes if respond_to?(:clear_changes)
+        save_to_collection(options)
+      end
+
+      def _root_document
+        @_root_document ||= _parent_document.try(:_root_document)
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/equality.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Equality
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def ===(other)
+          other.is_a?(self)
+        end
+      end
+
+      def eql?(other)
+        other.is_a?(self.class) && _id == other._id
+      end
+      alias :== :eql?
+
+      def hash
+        _id.hash
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/identity_map.rb

@@ -0,0 +1,144 @@
+# encoding: UTF-8
+require 'set'
+
+module MarkMapper
+  module Plugins
+    module IdentityMap
+      extend ActiveSupport::Concern
+
+      def self.enabled=(flag)
+        Thread.current[:mark_mapper_identity_map_enabled] = flag
+      end
+
+      def self.enabled
+        Thread.current[:mark_mapper_identity_map_enabled]
+      end
+
+      def self.enabled?
+        enabled == true
+      end
+
+      def self.repository
+        Thread.current[:mark_mapper_identity_map] ||= {}
+      end
+
+      def self.clear
+        repository.clear
+      end
+
+      def self.include?(document)
+        repository.key?(IdentityMap.key(document.class, document._id))
+      end
+
+      def self.key(model, id)
+        "#{model.single_collection_root.name}:#{id}"
+      end
+
+      def self.use
+        old, self.enabled = enabled, true
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+        clear
+      end
+
+      def self.without
+        old, self.enabled = enabled, false
+
+        yield if block_given?
+      ensure
+        self.enabled = old
+      end
+
+      module ClassMethods
+        # Private - Looks for a document in the identity map
+        def get_from_identity_map(id)
+          IdentityMap.repository[IdentityMap.key(self, id)]
+        end
+
+        def query(opts={})
+          super.tap do |query|
+            query.identity_map = self if Thread.current[:mark_mapper_identity_map_enabled]
+          end
+        end
+
+        def remove_documents_from_map(*documents)
+          documents.flatten.compact.each do |document|
+            document.remove_from_identity_map
+          end
+        end
+
+        def load(attrs, with_cast = false)
+          return super unless Thread.current[:mark_mapper_identity_map_enabled]
+          return nil unless attrs
+          document = get_from_identity_map(attrs['_id'])
+
+          if !document
+            document = super
+            document.add_to_identity_map
+          end
+
+          document
+        end
+      end
+
+      def save(*args)
+        super.tap { |result| add_to_identity_map if result }
+      end
+
+      def delete
+        super.tap { remove_from_identity_map }
+      end
+
+      def add_to_identity_map
+        if IdentityMap.enabled?
+          key = IdentityMap.key(self.class, _id)
+          IdentityMap.repository[key] = self
+        end
+      end
+
+      def remove_from_identity_map
+        if IdentityMap.enabled?
+          key = IdentityMap.key(self.class, _id)
+          IdentityMap.repository.delete(key)
+        end
+      end
+    end
+  end
+end
+
+module MarkMapperMethods
+  module ClassMethods
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :identity_map
+
+      alias_method :first, :find_one
+      alias_method :each, :find_each
+    end
+
+    def find_one(opts={})
+      query = clone.amend(opts)
+
+      if identity_map && query.simple? && (document = identity_map.get_from_identity_map(query[:_id]))
+        document
+      else
+        super.tap do |doc|
+          doc.remove_from_identity_map if doc && query.fields?
+        end
+      end
+    end
+
+    def find_each(opts={})
+      query = clone.amend(opts)
+      super(opts) do |doc|
+        doc.remove_from_identity_map if doc && query.fields?
+        yield doc if block_given?
+      end
+    end
+  end
+end
+
+::MarkMapper::Plugins::Querying::DecoratedMarkMapperQuery.send :include, ::MarkMapperMethods::ClassMethods