numon 0.0.1

data/lib/mongo_mapper/plugins/pagination.rb

@@ -0,0 +1,24 @@
+module MongoMapper
+  module Plugins
+    module Pagination
+      module ClassMethods
+        def per_page
+          25
+        end
+
+        def paginate(options)
+          per_page      = options.delete(:per_page) || self.per_page
+          page          = options.delete(:page)
+          total_entries = count(options)
+          pagination    = Pagination::Proxy.new(total_entries, page, per_page)
+
+          options.update(:limit => pagination.limit, :skip => pagination.skip)
+          pagination.subject = find_many(options)
+          pagination
+        end
+      end
+    end
+  end
+end
+
+require 'mongo_mapper/plugins/pagination/proxy'

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

@@ -0,0 +1,72 @@
+module MongoMapper
+  module Plugins
+    module Pagination
+      class Proxy
+        instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|respond_to\?|proxy_|^object_id$)/ }
+                
+        attr_accessor :subject
+        attr_reader :total_entries, :per_page, :current_page
+        alias limit per_page
+
+        def initialize(total_entries, current_page, per_page=nil)
+          @total_entries    = total_entries.to_i
+          self.per_page     = per_page
+          self.current_page = current_page
+        end
+
+        def total_pages
+          (total_entries / per_page.to_f).ceil
+        end
+
+        def out_of_bounds?
+          current_page > total_pages
+        end
+
+        def previous_page
+          current_page > 1 ? (current_page - 1) : nil
+        end
+
+        def next_page
+          current_page < total_pages ? (current_page + 1) : nil
+        end
+
+        def skip
+          (current_page - 1) * per_page
+        end
+        alias offset skip # for will paginate support
+
+        def send(method, *args, &block)
+          if respond_to?(method)
+            super
+          else
+            subject.send(method, *args, &block)
+          end
+        end
+
+        def ===(other)
+          other === subject
+        end
+
+        def method_missing(name, *args, &block)
+          @subject.send(name, *args, &block)
+        end
+        
+        def respond_to?(name, *args, &block)
+          super || @subject.respond_to?(name, *args, &block)
+        end
+        
+        private
+          def per_page=(value)
+            value = 25 if value.blank?
+            @per_page = value.to_i
+          end
+
+          def current_page=(value)
+            value = value.to_i
+            value = 1 if value < 1
+            @current_page = value
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/protected.rb

@@ -0,0 +1,45 @@
+module MongoMapper
+  module Plugins
+    module Protected
+      module ClassMethods
+        def attr_protected(*attrs)
+          self.write_inheritable_attribute(:attr_protected, Set.new(attrs) + (protected_attributes || []))
+        end
+
+        def protected_attributes
+          self.read_inheritable_attribute(:attr_protected)
+        end
+
+        def key(*args)
+          key = super
+          attr_protected key.name.to_sym if key.options[:protected]
+          key
+        end
+      end
+
+      module InstanceMethods
+        def assign(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
+
+        def protected_attributes
+          self.class.protected_attributes
+        end
+
+        protected
+          def filter_protected_attrs(attrs)
+            return attrs if protected_attributes.blank?
+            attrs.dup.delete_if { |key, val| protected_attributes.include?(key.to_sym) }
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails.rb

@@ -0,0 +1,53 @@
+module MongoMapper
+  module Plugins
+    module Rails
+      def self.configure(model)
+        model.extend ActiveModel::Naming if defined?(ActiveModel)
+      end
+
+      module InstanceMethods
+        def to_param
+          id.to_s
+        end
+
+        def to_model
+          self
+        end
+
+        def new_record?
+          new?
+        end
+
+        def read_attribute(name)
+          self[name]
+        end
+
+        def read_attribute_before_typecast(name)
+          read_key_before_typecast(name)
+        end
+
+        def write_attribute(name, value)
+          self[name] = value
+        end
+      end
+
+      module ClassMethods
+        def has_one(*args)
+          one(*args)
+        end
+
+        def has_many(*args)
+          many(*args)
+        end
+
+        def column_names
+          keys.keys
+        end
+
+        def human_name
+          self.name.demodulize.titleize
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -0,0 +1,75 @@
+require 'active_support/json'
+
+module MongoMapper
+  module Plugins
+    module Serialization
+      def self.configure(model)
+        model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
+      end
+      
+      module InstanceMethods
+        def as_json options={}
+          options ||= {}
+          unless options[:only]
+            methods = [options.delete(:methods)].flatten.compact
+            methods << :id
+            options[:methods] = methods.uniq
+          end
+
+          except = [options.delete(:except)].flatten.compact
+          except << :_id
+          options[:except] = except
+
+          # Direct rip from Rails 3 ActiveModel Serialization (#serializable_hash)
+          hash = begin
+            options[:only]   = Array.wrap(options[:only]).map { |n| n.to_s }
+            options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+
+            attribute_names = attributes.keys.sort
+            if options[:only].any?
+              attribute_names &= options[:only]
+            elsif options[:except].any?
+              attribute_names -= options[:except]
+            end
+
+            method_names = Array.wrap(options[:methods]).inject([]) do |methods, name|
+              methods << name if respond_to?(name.to_s)
+              methods
+            end
+
+            (attribute_names + method_names).inject({}) { |hash, name|
+              hash[name] = send(name)
+              hash
+            }
+          end
+          # End rip
+          
+          options.delete(:only) if options[:only].nil? or options[:only].empty?
+
+          hash.each do |key, value|
+            if value.is_a?(Array)
+              hash[key] = value.map do |item|
+                item.respond_to?(:as_json) ? item.as_json(options) : item
+              end
+            elsif value.is_a? Mongo::ObjectID
+              hash[key] = value.to_s
+            elsif value.respond_to?(:as_json)
+              hash[key] = value.as_json(options)
+            end
+          end
+          
+          # Replicate Rails 3 naming - and also bin anytihng after : for use in our dynamic classes from unit tests
+          hash = { ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).gsub(/:.*/,'') => hash } if include_root_in_json
+          hash
+        end
+      end
+
+      module ClassMethods
+        def from_json(json)
+          self.new(ActiveSupport::JSON.decode(json))
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -0,0 +1,21 @@
+module MongoMapper
+  module Plugins
+    module Timestamps
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+      
+      module InstanceMethods
+        def update_timestamps
+          now = Time.now.utc
+          self[:created_at] = now if new? && !created_at?
+          self[:updated_at] = now
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -0,0 +1,14 @@
+module MongoMapper
+  module Plugins
+    module Userstamps
+      module ClassMethods
+        def userstamps!
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => 'User'
+          belongs_to :updater, :class_name => 'User'
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,46 @@
+module MongoMapper
+  module Plugins
+    module Validations
+      def self.configure(model)
+        model.class_eval { include Validatable }
+      end
+      
+      module DocumentMacros
+        def validates_uniqueness_of(*args)
+          add_validations(args, MongoMapper::Plugins::Validations::ValidatesUniquenessOf)
+        end
+      end
+      
+      class ValidatesUniquenessOf < Validatable::ValidationBase
+        option :scope, :case_sensitive
+        default :case_sensitive => true
+
+        def valid?(instance)
+          value = instance[attribute]
+          return true if allow_blank && value.blank?
+          return true if allow_nil && value.nil?
+          base_conditions = case_sensitive ? {self.attribute => value} : {}
+          doc = instance.class.first(base_conditions.merge(scope_conditions(instance)).merge(where_conditions(instance)))
+          doc.nil? || instance._id == doc._id
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          return {} unless scope
+          Array(scope).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+
+        def where_conditions(instance)
+          conditions = {}
+          conditions[attribute] = /#{instance[attribute].to_s}/i unless case_sensitive
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/query.rb

@@ -0,0 +1,130 @@
+module MongoMapper
+  # IMPORTANT
+  # This class is private to MongoMapper and should not be considered part of MongoMapper's public API.
+  #
+  class Query
+    OptionKeys = [:fields, :select, :skip, :offset, :limit, :sort, :order]
+
+    attr_reader :model
+
+    def initialize(model, options)
+      raise ArgumentError, "Options must be a hash" unless options.is_a?(Hash)
+      @model, @options, @conditions, @original_options = model, {}, {}, options
+      separate_options_and_conditions
+      add_sci_condition
+    end
+
+    def criteria
+      to_criteria(@conditions)
+    end
+
+    def options
+      fields = @options[:fields] || @options[:select]
+      skip   = @options[:skip]   || @options[:offset] || 0
+      limit  = @options[:limit]  || 0
+      sort   = @options[:sort]   || normalized_sort(@options[:order])
+
+      {:fields => to_fields(fields), :skip => skip.to_i, :limit => limit.to_i, :sort => sort}
+    end
+
+    def to_a
+      [criteria, options]
+    end
+
+    private
+      def separate_options_and_conditions
+        @original_options.each_pair do |key, value|
+          key = key.respond_to?(:to_sym) ? key.to_sym : key
+
+          if OptionKeys.include?(key)
+            @options[key] = value
+          elsif key == :conditions
+            @conditions.update(value)
+          else
+            @conditions[key] = value
+          end
+        end
+      end
+
+      # adds _type single collection inheritance scope for models that need it
+      def add_sci_condition
+        @conditions[:_type] = model.to_s if model.single_collection_inherited?
+      end
+
+      def modifier?(field)
+        field.to_s =~ /^\$/
+      end
+
+      def symbol_operator?(object)
+        object.respond_to?(:field, :operator)
+      end
+
+      def to_criteria(conditions, parent_key=nil)
+        criteria = {}
+
+        conditions.each_pair do |key, value|
+          key = normalized_key(key)
+
+          if model.object_id_key?(key) && value.is_a?(String)
+            value = Mongo::ObjectID.from_string(value)
+          end
+
+          if symbol_operator?(key)
+            value = {"$#{key.operator}" => value}
+            key = normalized_key(key.field)
+          end
+
+          criteria[key] = normalized_value(key, value)
+        end
+
+        criteria
+      end
+
+      def to_fields(fields)
+        return if fields.blank?
+
+        if fields.respond_to?(:flatten, :compact)
+          fields.flatten.compact
+        else
+          fields.split(',').map { |field| field.strip }
+        end
+      end
+
+      def to_order(field, direction=nil)
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [normalized_key(field).to_s, direction]
+      end
+
+      def normalized_key(field)
+        field.to_s == 'id' ? :_id : field
+      end
+
+      def normalized_value(field, value)
+        case value
+          when Array
+            modifier?(field) ? value : {'$in' => value}
+          when Hash
+            to_criteria(value, field)
+          when Time
+            value.utc
+          else
+            value
+        end
+      end
+
+      def normalized_sort(sort)
+        return if sort.blank?
+
+        if sort.respond_to?(:all?) && sort.all? { |s| symbol_operator?(s) }
+          sort.map { |s| to_order(s.field, s.operator) }
+        elsif symbol_operator?(sort)
+          [to_order(sort.field, sort.operator)]
+        else
+          sort.split(',').map do |str|
+            to_order(*str.strip.split(' '))
+          end
+        end
+      end
+  end
+end