lookout-mongo_mapper 0.11.3

data/lib/mongo_mapper/plugins/keys/key.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Keys
+      class Key
+        attr_accessor :name, :type, :options, :default_value
+
+        def initialize(*args)
+          options = args.extract_options!
+          @name, @type = args.shift.to_s, args.shift
+          self.options = (options || {}).symbolize_keys
+          self.default_value = self.options[:default]
+        end
+
+        def ==(other)
+          @name == other.name && @type == other.type
+        end
+
+        def embeddable?
+          return false unless type.respond_to?(:embeddable?)
+          type.embeddable?
+        end
+
+        def number?
+          type == Integer || type == Float
+        end
+
+        def get(value)
+          if value.nil? && !default_value.nil?
+            if default_value.respond_to?(:call)
+              return default_value.call
+            else
+              # Using Marshal is easiest way to get a copy of mutable objects
+              # without getting an error on immutable objects
+              return Marshal.load(Marshal.dump(default_value))
+            end
+          end
+
+          if options[:typecast].present?
+            type.from_mongo(value).map! { |v| typecast_class.from_mongo(v) }
+          else
+            type.from_mongo(value)
+          end
+        end
+
+        def set(value)
+          type.to_mongo(value).tap do |values|
+            if options[:typecast].present?
+              values.map! { |v| typecast_class.to_mongo(v) }
+            end
+          end
+        end
+
+        private
+          def typecast_class
+            @typecast_class ||= options[:typecast].constantize
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/logger.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Logger
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def logger
+          MongoMapper.logger
+        end
+      end
+
+      def logger
+        self.class.logger
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Modifiers
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def increment(*args)
+          modifier_update('$inc', args)
+        end
+
+        def decrement(*args)
+          criteria, keys, options = criteria_and_keys_from_args(args)
+          values, to_decrement = keys.values, {}
+          keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
+          collection.update(criteria, {'$inc' => to_decrement}, :multi => true)
+        end
+
+        def set(*args)
+          criteria, updates, options = criteria_and_keys_from_args(args)
+          updates.each do |key, value|
+            updates[key] = keys[key.to_s].set(value) if key?(key)
+          end
+          modifier_update('$set', [criteria, updates, options])
+        end
+
+        def unset(*args)
+          if args[0].is_a?(Hash)
+            criteria, keys = args.shift, args
+            options = keys.last.is_a?(Hash) ? keys.pop : {}
+          else
+            keys, ids = args.partition { |arg| arg.is_a?(Symbol) }
+            options = ids.last.is_a?(Hash) ? ids.pop : {}
+            criteria = {:id => ids}
+          end
+
+          criteria = criteria_hash(criteria).to_hash
+          updates = keys.inject({}) { |hash, key| hash[key] = 1; hash }
+          modifier_update('$unset', [criteria, updates, options])
+        end
+
+        def push(*args)
+          modifier_update('$push', args)
+        end
+
+        def push_all(*args)
+          modifier_update('$pushAll', args)
+        end
+
+        def add_to_set(*args)
+          modifier_update('$addToSet', args)
+        end
+        alias push_uniq add_to_set
+
+        def pull(*args)
+          modifier_update('$pull', args)
+        end
+
+        def pull_all(*args)
+          modifier_update('$pullAll', args)
+        end
+
+        def pop(*args)
+          modifier_update('$pop', args)
+        end
+
+        private
+          def modifier_update(modifier, args)
+            criteria, updates, options = criteria_and_keys_from_args(args)
+            if options
+              collection.update(criteria, {modifier => updates}, options.merge(:multi => true))
+            else
+              collection.update(criteria, {modifier => updates}, :multi => true)
+            end    
+          end
+
+          def criteria_and_keys_from_args(args)
+            if args[0].is_a?(Hash)
+              criteria = args[0]
+              updates = args[1]
+              options = args[2]
+            else
+              split_args = args.partition{|a| a.is_a?(BSON::ObjectId)}
+              criteria = {:id => split_args[0]}
+              updates = split_args[1].first
+              options = split_args[1].last
+            end    
+            [criteria_hash(criteria).to_hash, updates, options]
+          end
+      end
+
+      def unset(*args)
+        self.class.unset(id, *args)
+      end
+
+      def increment(hash, options=nil)
+        self.class.increment(id, hash, options)
+      end
+
+      def decrement(hash, options=nil)
+        self.class.decrement(id, hash, options)
+      end
+
+      def set(hash, options=nil)
+        self.class.set(id, hash, options)
+      end
+
+      def push(hash, options=nil)
+        self.class.push(id, hash, options)
+      end
+
+      def push_all(hash, options=nil)
+        self.class.push_all(id, hash, options)
+      end
+
+      def pull(hash, options=nil)
+        self.class.pull(id, hash, options)
+      end
+
+      def pull_all(hash, options=nil)
+        self.class.pull_all(id, hash, options)
+      end
+
+      def add_to_set(hash, options=nil)
+        self.class.push_uniq(id, hash, options)
+      end
+      alias push_uniq add_to_set
+
+      def pop(hash, options=nil)
+        self.class.pop(id, hash, options)
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/pagination.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Pagination
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def per_page; 25 end
+
+        def paginate(opts={})
+          query.paginate({:per_page => per_page}.merge(opts))
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/persistence.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def connection(mongo_connection=nil)
+          assert_supported
+          if mongo_connection.nil?
+            @connection ||= MongoMapper.connection
+          else
+            @connection = mongo_connection
+          end
+          @connection
+        end
+
+        def set_database_name(name)
+          assert_supported
+          @database_name = name
+        end
+
+        def database_name
+          assert_supported
+          @database_name
+        end
+
+        def database
+          assert_supported
+          if database_name.nil?
+            MongoMapper.database
+          else
+            connection.db(database_name)
+          end
+        end
+
+        def set_collection_name(name)
+          assert_supported
+          @collection_name = name
+        end
+
+        def collection_name
+          assert_supported
+          @collection_name ||= self.to_s.tableize.gsub(/\//, '.')
+        end
+
+        def collection
+          assert_supported
+          database.collection(collection_name)
+        end
+
+        private
+          def assert_supported
+            if embeddable?
+              raise NotSupported.new('This is not supported for embeddable documents at this time.')
+            end
+          end
+      end
+
+      def collection
+        _root_document.class.collection
+      end
+
+      def database
+        _root_document.class.database
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/protected.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+require 'set'
+
+module MongoMapper
+  module Plugins
+    module Protected
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :protected_attributes
+      end
+
+      module ClassMethods
+        def attr_protected(*attrs)
+          raise AccessibleOrProtected.new(name) if try(:accessible_attributes?)
+          self.protected_attributes = Set.new(attrs) + (protected_attributes || [])
+        end
+
+        def key(*args)
+          key = super
+          attr_protected key.name.to_sym if key.options[:protected]
+          key
+        end
+      end
+
+      def attributes=(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      def update_attributes(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      def update_attributes!(attrs={})
+        super(filter_protected_attrs(attrs))
+      end
+
+      protected
+        def filter_protected_attrs(attrs)
+          return attrs if protected_attributes.blank? || attrs.blank?
+          attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
+        end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/querying.rb

@@ -0,0 +1,165 @@
+# encoding: UTF-8
+require 'mongo_mapper/plugins/querying/decorator'
+
+module MongoMapper
+  module Plugins
+    module Querying
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        extend Forwardable
+
+        def_delegators :query, *Querying::Methods
+
+        def find_by_id(id)
+          find_one(:_id => id)
+        end
+
+        def first_or_create(args)
+          first(args) || create(args.reject { |key, value| !key?(key) })
+        end
+
+        def first_or_new(args)
+          first(args) || new(args.reject { |key, value| !key?(key) })
+        end
+
+        def create(*docs)
+          initialize_each(*docs) { |doc| doc.save }
+        end
+
+        def create!(*docs)
+          initialize_each(*docs) { |doc| doc.save! }
+        end
+
+        def update(*args)
+          if args.length == 1
+            update_multiple(args[0])
+          else
+            id, attributes = args
+            update_single(id, attributes)
+          end
+        end
+
+        def delete(*ids)
+          query(:_id => ids.flatten).remove
+        end
+
+        def delete_all(options={})
+          query(options).remove
+        end
+
+        def destroy(*ids)
+          find_some!(ids.flatten).each { |doc| doc.destroy }
+        end
+
+        def destroy_all(options={})
+          find_each(options) { |document| document.destroy }
+        end
+
+        # @api private for now
+        def query(options={})
+          query = Plucky::Query.new(collection, :transformer => transformer)
+          query.extend(Decorator)
+          query.object_ids(object_id_keys)
+          query.amend(options)
+          query.model(self)
+          query
+        end
+
+        # @api private for now
+        def criteria_hash(criteria={})
+          Plucky::CriteriaHash.new(criteria, :object_ids => object_id_keys)
+        end
+
+        private
+          def transformer
+            @transformer ||= lambda { |doc| load(doc) }
+          end
+
+          def find_some(ids, options={})
+            query = query(options).amend(:_id => ids.flatten.compact.uniq)
+            query.all
+          end
+
+          def find_some!(ids, options={})
+            ids  = ids.flatten.compact.uniq
+            docs = find_some(ids, options)
+
+            if ids.size != docs.size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{docs.size}, but was expecting #{ids.size}"
+            end
+
+            docs
+          end
+
+          def initialize_each(*docs)
+            instances = []
+            docs = [{}] if docs.blank?
+            docs.flatten.each do |attrs|
+              doc = new(attrs)
+              yield(doc)
+              instances << doc
+            end
+            instances.size == 1 ? instances[0] : instances
+          end
+
+          def update_single(id, attrs)
+            if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+              raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+            end
+
+            find(id).tap do |doc|
+              doc.update_attributes(attrs)
+            end
+          end
+
+          def update_multiple(docs)
+            unless docs.is_a?(Hash)
+              raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+            end
+
+            instances = []
+            docs.each_pair { |id, attrs| instances << update(id, attrs) }
+            instances
+          end
+      end
+
+      def save(options={})
+        options.assert_valid_keys(:validate, :safe)
+        create_or_update(options)
+      end
+
+      def save!(options={})
+        options.assert_valid_keys(:safe)
+        save(options) || raise(DocumentNotValid.new(self))
+      end
+
+      def destroy
+        delete
+      end
+
+      def delete
+        self.class.delete(id).tap { @_destroyed = true } if persisted?
+      end
+
+      private
+        def create_or_update(options={})
+          result = persisted? ? update(options) : create(options)
+          result != false
+        end
+
+        def create(options={})
+          save_to_collection(options)
+        end
+
+        def update(options={})
+          save_to_collection(options)
+        end
+
+        def save_to_collection(options={})
+          @_new = false
+          collection.save(to_mongo, :safe => options[:safe])
+        end
+    end
+  end
+end