lookout-mongo_mapper 0.11.3

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

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+require 'forwardable'
+module MongoMapper
+  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 mongomapper 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
+
+        def replace(v)
+          raise NotImplementedError
+        end
+
+        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)
+          if proxy_respond_to?(method)
+            super
+          else
+            load_target
+            target.send(method, *args)
+          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 MongoMapper::DocumentNotFound
+            reset
+          end
+
+          def find_target
+            raise NotImplementedError
+          end
+
+          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/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