lookout-mongo_mapper 0.11.3

data/lib/mongo_mapper/plugins/querying/decorator.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Querying
+      Methods = Plucky::Methods + [:find!]
+
+      module Decorator
+        include DynamicQuerying::ClassMethods
+
+        def model(model=nil)
+          return @model if model.nil?
+          @model = model
+          self
+        end
+
+        def find!(*ids)
+          raise DocumentNotFound, "Couldn't find without an ID" if ids.size == 0
+
+          find(*ids).tap do |result|
+            if result.nil? || ids.size != Array(result).size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.join(',')}). Found #{Array(result).size}, but was expecting #{ids.size}"
+            end
+          end
+        end
+
+        private
+          def method_missing(method, *args, &block)
+            return super unless model.respond_to?(method)
+            result = model.send(method, *args, &block)
+            return super unless result.is_a?(Plucky::Query)
+            merge(result)
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Rails
+      autoload :ActiveRecordAssociationAdapter, "mongo_mapper/plugins/rails/active_record_association_adapter"
+      extend ActiveSupport::Concern
+
+      def to_param
+        id.to_s if persisted?
+      end
+
+      def to_model
+        self
+      end
+
+      def to_key
+        [id] if persisted?
+      end
+
+      def new_record?
+        new?
+      end
+
+      def read_attribute(name)
+        self[name]
+      end
+
+      def read_attribute_before_type_cast(name)
+        read_key_before_type_cast(name)
+      end
+
+      def write_attribute(name, value)
+        self[name] = value
+      end
+
+      module ClassMethods
+        def has_one(*args)
+          one(*args)
+        end
+
+        def has_many(*args, &extension)
+          many(*args, &extension)
+        end
+
+        def column_names
+          keys.keys
+        end
+
+        # Returns returns an ActiveRecordAssociationAdapter for an association. This adapter has an API that is a
+        # subset of ActiveRecord::Reflection::AssociationReflection. This allows MongoMapper to be used with the
+        # association helpers in gems like simple_form and formtastic.
+        def reflect_on_association(name)
+          ActiveRecordAssociationAdapter.for_association(associations[name]) if associations[name]
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails/active_record_association_adapter.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Rails
+      class ActiveRecordAssociationAdapter
+        attr_reader :klass, :macro, :name, :options
+
+        def self.for_association(association)
+          macro = case association
+          when MongoMapper::Plugins::Associations::BelongsToAssociation
+            :belongs_to
+          when MongoMapper::Plugins::Associations::ManyAssociation
+            :has_many
+          when MongoMapper::Plugins::Associations::OneAssociation
+            :has_one
+          else
+            raise "no #{name} for association of type #{association.class}"
+          end
+
+          new(association, macro)
+        end
+
+        def initialize(association, macro)
+          @klass, @name = association.klass, association.name
+          # only include compatible options
+          @options = association.options.slice(:conditions, :order)
+
+          @macro = macro
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/safe.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Safe
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inherited(subclass)
+          super
+          subclass.safe if safe?
+        end
+
+        def safe
+          @safe = true
+        end
+
+        def safe?
+          @safe == true
+        end
+      end
+
+      def save_to_collection(options={})
+        options[:safe] = self.class.safe? unless options.key?(:safe)
+        super
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/sci.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Sci
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveSupport::DescendantsTracker
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          key :_type, String unless key?(:_type)
+          subclass.instance_variable_set("@single_collection_inherited", true)
+          subclass.set_collection_name(collection_name) unless subclass.embeddable?
+          super
+        end
+
+        def single_collection_inherited?
+          @single_collection_inherited == true
+        end
+
+        def query(options={})
+          super.tap do |query|
+            query[:_type] = {'$in' => [name] + descendants.map(&:name)} if single_collection_inherited?
+          end
+        end
+      end
+
+      def initialize(*args)
+        super
+        write_key :_type, self.class.name if self.class.key?(:_type)
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/scopes.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Scopes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_scopes
+      end
+
+      module ClassMethods
+        def scope(name, scope_options={})
+          scopes[name] = lambda do |*args|
+            result = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+            result = self.query(result) if result.is_a?(Hash)
+            self.query.merge(result)
+          end
+          singleton_class.send :define_method, name, &scopes[name]
+        end
+
+        def scopes
+          self._scopes || self._scopes = {}
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+require 'active_model/serializers/json'
+require 'active_model/serializers/xml'
+
+module MongoMapper
+  module Plugins
+    module Serialization
+      extend ActiveSupport::Concern
+
+      included do
+        include ::ActiveModel::Serializers::JSON
+        include ::ActiveModel::Serializers::Xml
+        self.include_root_in_json = false
+      end
+
+      def serializable_attributes
+        attributes.keys.map { |k| k.to_s } + ['id'] - ['_id']
+      end
+
+      def serializable_hash(options = nil)
+        options ||= {}
+
+        options[:only]   = Array.wrap(options[:only]).map { |k| k.to_s }
+        options[:except] = Array.wrap(options[:except]).map { |k| k.to_s }
+
+        attribute_names = serializable_attributes
+
+        if options[:only].any?
+          attribute_names &= options[:only]
+        elsif options[:except].any?
+          attribute_names -= options[:except]
+        end
+
+        attribute_names += Array.wrap(options[:methods]).map { |m| m.to_s }.select do |method|
+          respond_to?(method)
+        end
+
+        hash = attribute_names.sort.inject({}) do |hash, name|
+          value = send(name)
+          hash[name] = if value.is_a?(Array)
+            value.map {|v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
+          elsif value.respond_to?(:serializable_hash)
+            value.serializable_hash
+          else
+            value
+          end
+          hash
+        end
+
+        serializable_add_includes(options) do |association, records, opts|
+          hash[association.to_s] = records.is_a?(Array) ?
+            records.map { |r| r.serializable_hash(opts) } :
+            records.serializable_hash(opts)
+        end
+
+        hash
+      end
+
+      def to_xml(options = {}, &block)
+        XmlSerializer.new(self, options).serialize(&block)
+      end
+
+    private
+
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
+
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
+
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
+
+        associations.each do |association|
+          records = get_proxy(self.class.associations[association])
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
+          end
+        end
+
+        options[:include] = include_associations
+      end
+
+      module ClassMethods
+        def from_json(json)
+          self.new.from_json(json)
+        end
+
+        def from_xml(xml)
+          self.new.from_xml(xml)
+        end
+      end
+    end
+
+    # Override default Serializer to use #serializable_hash
+    class XmlSerializer < ::ActiveModel::Serializers::Xml::Serializer
+      def attributes_hash
+        @serializable.serializable_hash(options)
+      end
+
+      def serializable_methods
+        # Methods are already included in #serializable_hash
+        []
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Timestamps
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+
+      def update_timestamps
+        now = Time.now.utc
+        self[:created_at] = now if !persisted? && !created_at?
+        self[:updated_at] = now
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/touch.rb

@@ -0,0 +1,18 @@
+module MongoMapper
+  module Plugins
+    module Touch
+      extend ActiveSupport::Concern
+
+      def touch(key = :updated_at) 
+        raise ArgumentError, "Invalid key named #{key}" unless self.key_names.include?(key.to_s)
+        if self.class.embeddable?
+          self.write_attribute(key, Time.now.utc)
+          self._parent_document.touch
+        else
+          self.set(key => Time.now.utc)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Userstamps
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def userstamps!(options = {})
+          class_name = (options[:class_name] || options[:class] || 'User' ).to_s
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => class_name
+          belongs_to :updater, :class_name => class_name
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Validations
+      extend ActiveSupport::Concern
+
+      include ::ActiveModel::Validations
+      include ::ActiveModel::Validations::Callbacks
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      def save(options = {})
+        options.reverse_merge!(:validate => true)
+        !options[:validate] || valid? ? super : false
+      end
+
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+      end
+
+      class UniquenessValidator < ::ActiveModel::EachValidator
+        def initialize(options)
+          super(options.reverse_merge(:case_sensitive => true))
+        end
+
+        def setup(klass)
+          @klass = klass
+        end
+
+        def validate_each(record, attribute, value)
+          conditions = scope_conditions(record)
+
+          if options[:case_sensitive]
+            conditions[attribute] = value
+          else
+            conditions[attribute] = /^#{Regexp.escape(value.to_s)}$/i
+          end
+
+          # Make sure we're not including the current document in the query
+          conditions[:_id.ne] = record._id if record._id
+
+          if @klass.exists?(conditions)
+            record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+          end
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          Array(options[:scope] || []).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+      end
+
+      class AssociatedValidator < ::ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          if !Array.wrap(value).all? { |c| c.nil? || c.valid?(options[:context]) }
+            record.errors.add(attribute, :invalid, :message => options[:message], :value => value)
+          end
+        end
+      end
+
+    end
+  end
+end
+
+# Need to monkey patch ActiveModel for now since it uses the internal
+# _run_validation_callbacks, which is impossible to override due to the
+# way ActiveSupport::Callbacks is implemented.
+ActiveModel::Validations::Callbacks.class_eval do
+  def run_validations!
+    run_callbacks(:validation) { super }
+  end
+end