mark_mapper 0.0.1

data/lib/mark_mapper/plugins/associations/one_proxy.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Associations
+      class OneProxy < Proxy
+        def build(attrs={}, &block)
+          instantiate_target(:new, attrs, &block)
+        end
+
+        def create(attrs={}, &block)
+          instantiate_target(:create, attrs, &block)
+        end
+
+        def create!(attrs={}, &block)
+          instantiate_target(:create!, attrs, &block)
+        end
+
+        def replace(doc)
+          load_target
+
+          if !target.nil? && target != doc
+            if target.persisted?
+              case options[:dependent]
+                when :delete  then target.delete
+                when :destroy then target.destroy
+                else
+                  nullify_scope(target)
+                  target.save
+              end
+            end
+          end
+
+          unless doc.nil?
+            proxy_owner.save unless proxy_owner.persisted?
+            doc = klass.new(doc) unless doc.is_a?(klass)
+            apply_scope(doc)
+            doc.save unless doc.persisted?
+          end
+
+          loaded
+          @target = doc
+        end
+
+        def destroy
+          target.destroy
+          reset
+        end
+
+        def delete
+          target.delete
+          reset
+        end
+
+        def nullify
+          nullify_scope(target)
+          target.save
+          reset
+        end
+
+        protected
+          def find_target
+            target_class.first(association.query_options.merge(criteria))
+          end
+
+          def instantiate_target(instantiator, attrs={}, &block)
+            @target = target_class.send(instantiator, attrs.update(criteria), &block)
+            loaded
+            @target
+          end
+
+          def target_class
+            @target_class ||= options[:class] || (options[:class_name] || association.name.to_s.camelize).constantize
+          end
+
+          def foreign_key
+            options[:foreign_key] || proxy_owner.class.name.foreign_key
+          end
+
+          def criteria
+            {self.foreign_key => proxy_owner.id}
+          end
+
+          def nullify_scope(doc)
+            criteria.each { |key, value| doc[key] = nil }
+            doc
+          end
+
+          def apply_scope(doc)
+            criteria.each { |key, value| doc[key] = value }
+            doc
+          end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/associations/proxy.rb

@@ -0,0 +1,138 @@
+# encoding: UTF-8
+require 'forwardable'
+module MarkMapper
+  module Plugins
+    module Associations
+      class Proxy
+        extend Forwardable
+
+        alias :proxy_respond_to? :respond_to?
+        alias :proxy_extend :extend
+
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^respond_to_missing\?$|^object_id$)/ }
+
+        attr_reader :proxy_owner, :association, :target
+
+        alias :proxy_target :target
+        alias :proxy_association :association
+
+        def_delegators :proxy_association, :klass, :options
+        def_delegator  :klass, :collection
+
+        def initialize(owner, association)
+          @proxy_owner, @association, @loaded = owner, association, false
+          Array(association.options[:extend]).each { |ext| proxy_extend(ext) }
+          reset
+        end
+
+        # Active support in rails 3 beta 4 can override to_json after this is loaded,
+        # at least when run in markmapper tests. The implementation was changed in master
+        # some time after this, so not sure whether this is still a problem.
+        #
+        # In rails 2, this isn't a problem however it also solves an issue where
+        # to_json isn't forwarded because it supports to_json itself
+        def to_json(*options)
+          load_target
+          target.to_json(*options)
+        end
+
+        # see comments to to_json
+        def as_json(*options)
+          load_target
+          target.as_json(*options)
+        end
+
+        def inspect
+          load_target
+          target.inspect
+        end
+
+        def loaded?
+          @loaded
+        end
+
+        def loaded
+          @loaded = true
+        end
+
+        def nil?
+          load_target
+          target.nil?
+        end
+
+        def blank?
+          load_target
+          target.blank?
+        end
+
+        def present?
+          load_target
+          target.present?
+        end
+
+        def reload
+          reset
+          load_target
+          self unless target.nil?
+        end
+
+        # :nocov:
+        def replace(v)
+          raise NotImplementedError
+        end
+        # :nocov:
+
+        def reset
+          @loaded = false
+          @target = nil
+        end
+
+        def respond_to?(*args)
+          proxy_respond_to?(*args) || (load_target && target.respond_to?(*args))
+        end
+
+        def send(method, *args, &block)
+          if proxy_respond_to?(method, true)
+            super
+          else
+            load_target
+            target.send(method, *args, &block)
+          end
+        end
+
+        protected
+          def method_missing(method, *args, &block)
+            if load_target
+              target.send(method, *args, &block)
+            end
+          end
+
+          def load_target
+            unless loaded?
+              if @target.is_a?(Array) && @target.any?
+                @target = find_target + @target.find_all { |record| !record.persisted? }
+              else
+                @target = find_target
+              end
+              loaded
+            end
+            @target
+          rescue MarkMapper::DocumentNotFound
+            reset
+          end
+
+          # :nocov:
+          def find_target
+            raise NotImplementedError
+          end
+          # :nocov:
+
+          def flatten_deeper(array)
+            array.collect do |element|
+              (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element
+            end.flatten
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+module MarkMapper
+  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={}, &block)
+              get_proxy(associations[#{name.inspect}]).build(attrs, &block)
+            end
+
+            def create_#{name}(attrs={}, &block)
+              get_proxy(associations[#{name.inspect}]).create(attrs, &block)
+            end
+
+            def create_#{name}!(attrs={}, &block)
+              get_proxy(associations[#{name.inspect}]).create!(attrs, &block)
+            end
+          end_eval
+        end
+      end
+    end
+  end
+end

data/lib/mark_mapper/plugins/caching.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+module MarkMapper
+  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/mark_mapper/plugins/callbacks.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      def initialize(*)
+        run_callbacks(:initialize) { super }
+      end
+
+      def initialize_from_database(*)
+        run_callbacks(:initialize) do
+          run_callbacks(:find) do
+            super
+          end
+        end
+      end
+
+      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/mark_mapper/plugins/clone.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+module MarkMapper
+  module Plugins
+    module Clone
+      extend ActiveSupport::Concern
+
+      def initialize_copy(other)
+        @_new       = true
+        @_destroyed = false
+        remove_instance_variable :@_id if instance_variable_defined?(:@_id)
+        init_ivars
+
+        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/mark_mapper/plugins/counter_cache.rb

@@ -0,0 +1,97 @@
+module MarkMapper
+  module Plugins
+    # Counter Caching for MarkMapper::Document
+    #
+    # Examples:
+    #
+    #   class Post
+    #     belongs_to :user
+    #     counter_cache :user
+    #   end
+    #
+    #   or:
+    #
+    #   class Post
+    #     belongs_to :user
+    #     counter_cache :user, :custom_posts_count
+    #   end
+    #
+    # Field names follow rails conventions, so counter_cache :user will increment the Integer field `posts_count' on User
+    #
+    # Alternatively, you can also use the more common ActiveRecord syntax:
+    #
+    #   class Post
+    #     belongs_to :user, :counter_cache => true
+    #   end
+    #
+    # Or with an alternative field name:
+    #
+    #   class Post
+    #     belongs_to :user, :counter_cache => :custom_posts_count
+    #   end
+    #
+    module CounterCache
+      class InvalidCounterCacheError < StandardError; end
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def counter_cache(association_name, options = {})
+          options.symbolize_keys!
+
+          field = options[:field] ?
+            options[:field] :
+            "#{self.collection_name.gsub(/.*\./, '')}_count"
+
+          association = associations[association_name]
+
+          if !association
+            raise InvalidCounterCacheError, "You must define an association with name `#{association_name}' on model #{self}"
+          end
+
+          # make a define-time check to make sure the counter cache field is defined.
+          # note: this can only be done in non-polymorphic classes
+          # (since we may not know the class on the other side of the association)
+          if !association.polymorphic?
+            association_class = association.klass
+            key_names = association_class.keys.keys
+
+            if !key_names.include?(field.to_s)
+              _raise_when_missing_counter_cache_key(association_class, field)
+            end
+          end
+
+          after_create do
+            if obj = self.send(association_name)
+              if !obj.respond_to?(field)
+                self.class._raise_when_missing_counter_cache_key(obj.class, field)
+              end
+
+              obj.increment(field => 1)
+              obj.write_attribute(field, obj.read_attribute(field) + 1)
+            end
+
+            true
+          end
+
+          after_destroy do
+            if obj = self.send(association_name)
+              if !obj.respond_to?(field)
+                self.class._raise_when_missing_counter_cache_key(obj.class, field)
+              end
+
+              obj.decrement(field => 1)
+              obj.write_attribute(field, obj.read_attribute(field) - 1)
+            end
+
+            true
+          end
+        end
+
+        def _raise_when_missing_counter_cache_key(klass, field)
+          raise InvalidCounterCacheError, "Missing `key #{field.to_sym.inspect}, Integer, :default => 0' on model #{klass}"
+        end
+      end
+    end
+  end
+end