jamieorc-mongo_mapper 0.11.1.1

data/lib/mongo_mapper/plugins/associations/single_association.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Associations
+      class SingleAssociation < Base
+        def setup(model)
+          @model = model
+          model.associations_module.module_eval <<-end_eval
+            def #{name}
+              proxy = get_proxy(associations[#{name.inspect}])
+              proxy.nil? ? nil : proxy
+            end
+
+            def #{name}=(value)
+              association = associations[#{name.inspect}]
+              proxy = get_proxy(association)
+
+              if proxy.nil? || proxy.target != value
+                proxy = build_proxy(association)
+              end
+
+              proxy.replace(value)
+              value
+            end
+
+            def #{name}?
+              get_proxy(associations[#{name.inspect}]).present?
+            end
+
+            def build_#{name}(attrs={})
+              get_proxy(associations[#{name.inspect}]).build(attrs)
+            end
+
+            def create_#{name}(attrs={})
+              get_proxy(associations[#{name.inspect}]).create(attrs)
+            end
+
+            def create_#{name}!(attrs={})
+              get_proxy(associations[#{name.inspect}]).create!(attrs)
+            end
+          end_eval
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/caching.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Caching
+      extend ActiveSupport::Concern
+
+      def cache_key(*suffixes)
+        cache_key = case
+                      when !persisted?
+                        "#{self.class.name}/new"
+                      when timestamp = self[:updated_at]
+                        "#{self.class.name}/#{id}-#{timestamp.to_s(:number)}"
+                      else
+                        "#{self.class.name}/#{id}"
+                    end
+        cache_key += "/#{suffixes.join('/')}" unless suffixes.empty?
+        cache_key
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/callbacks.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      def destroy
+        run_callbacks(:destroy) { super }
+      end
+      
+      def touch(*)
+        run_callbacks(:touch) { super }
+      end
+
+    private
+      def create_or_update(*)
+        run_callbacks(:save) { super }
+      end
+
+      def create(*)
+        run_callbacks(:create) { super }
+      end
+
+      def update(*)
+        run_callbacks(:update) { super }
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/clone.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Clone
+      extend ActiveSupport::Concern
+
+      def initialize_copy(other)
+        @_new       = true
+        @_destroyed = false
+        @_id        = nil
+        associations.each do |name, association|
+          instance_variable_set(association.ivar, nil)
+        end
+        self.attributes = other.attributes.clone.except(:_id).inject({}) do |hash, entry|
+          key, value = entry
+          hash[key] = value.duplicable? ? value.clone : value
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/dirty.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Dirty
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Dirty
+
+      def initialize(*)
+        # never register initial id assignment as a change
+        super.tap { changed_attributes.delete('_id') }
+      end
+
+      def initialize_from_database(*)
+        super.tap { changed_attributes.clear }
+      end
+
+      def save(*)
+        clear_changes { super }
+      end
+
+      def reload(*)
+        super.tap { clear_changes }
+      end
+
+      protected
+
+      def attribute_method?(attr)
+        # This overrides ::ActiveSupport::Dirty#attribute_method? to allow attributes to be any key
+        # in the attributes hash ( default ) or any key defined on the model that may not yet have
+        # had a value stored in the attributes collection.
+        super || key_names.include?(attr)
+      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
+
+      private
+
+      def write_key(key, value)
+        key = key.to_s
+        attribute_will_change!(key) unless attribute_changed?(key)
+        super(key, value).tap do
+          changed_attributes.delete(key) unless attribute_value_changed?(key)
+        end
+      end
+
+      def attribute_value_changed?(key_name)
+        attribute_was(key_name) != read_key(key_name)
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/document.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Document
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def embeddable?
+          false
+        end
+      end
+
+      def new?
+        @_new
+      end
+
+      def destroyed?
+        @_destroyed == true
+      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| instance_variable_set(ivar, nil) }
+          load_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/mongo_mapper/plugins/dynamic_querying.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/dynamic_querying/dynamic_finder'
+
+module MongoMapper
+  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/mongo_mapper/plugins/dynamic_querying/dynamic_finder.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+module MongoMapper
+  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/mongo_mapper/plugins/embedded_callbacks.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+module MongoMapper
+  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 :touch, :only => [:after]
+
+        embedded_callbacks_on
+      end
+
+      module ClassMethods
+        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 == true
+        end
+
+        def embedded_callbacks_off?
+          !embedded_callbacks_on?
+        end
+      end
+
+      def run_callbacks(callback, *args, &block)
+
+        if self.class.embedded_callbacks_on?
+          embedded_docs = []
+
+          embedded_associations.each do |association|
+            embedded_docs += Array(get_proxy(association).send(:load_target))
+          end
+
+          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/mongo_mapper/plugins/embedded_document.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+module MongoMapper
+  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/mongo_mapper/plugins/equality.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+module MongoMapper
+  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