mongo_mapper-rails3 0.7.0.1 → 0.7.2

data/lib/mongo_mapper/plugins/logger.rb

@@ -1,19 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Logger
-      extend ActiveSupport::Concern
-      
-      module ClassMethods
-        def logger
-          MongoMapper.logger
-        end
-      end
-
-      module InstanceMethods
-        def logger
-          self.class.logger
-        end
-      end
-    end
-  end
-end

data/lib/mongo_mapper/plugins/pagination.rb

@@ -1,26 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Pagination
-      extend ActiveSupport::Concern
-      
-      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

@@ -1,72 +0,0 @@
-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

@@ -1,46 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Protected
-      extend ActiveSupport::Concern
-      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

@@ -1,46 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Rails
-      extend ActiveSupport::Concern
-      module InstanceMethods
-        def to_param
-          id.to_s
-        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
-          self.name.demodulize.titleize
-        end
-      end
-    end
-  end
-end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -1,50 +0,0 @@
-require 'active_support/json'
-
-module MongoMapper
-  module Plugins
-    module Serialization
-      extend ActiveSupport::Concern
-      
-      included do
-        include ActiveModel::Serializers::JSON
-        # Re-include this here otherwise we get run over by ActiveModel serialization
-        include SerializableHash
-        extend FromJson
-      end
-
-      module SerializableHash
-        def serializable_hash 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
-
-          hash = super(options)
-          hash.each do |key, value|
-            if value.is_a?(Array)
-              hash[key] = value.map do |item|
-                item.respond_to?(:serializable_hash) ? item.serializable_hash(options) : item
-              end
-            elsif value.respond_to?(:serializable_hash)
-              hash[key] = value.serializable_hash(options)
-            end
-          end
-        end
-      end
-
-      module FromJson
-        def from_json(json)
-          self.attributes = ActiveSupport::JSON.decode(json)
-          self
-        end
-      end
-
-    end
-  end
-end

data/lib/mongo_mapper/plugins/validations.rb

@@ -1,88 +0,0 @@
-module MongoMapper
-  module Plugins
-    module Validations
-      extend ActiveSupport::Concern
-      included do
-        include ::ActiveModel::Validations
-        extend FixValidationKeyNames
-        extend LifecycleValidationMethods
-      end
-      
-      module DocumentMacros
-        def validates_uniqueness_of(attrs, ops={})
-          # add_validations(args, MongoMapper::Plugins::Validations::ValidatesUniquenessOf)
-          validates_with ValidatesUniquenessOf, {:attributes => attrs}.merge(ops)
-        end
-        
-        
-      end
-      
-      module FixValidationKeyNames
-        def validates_inclusion_of(*args,&b)
-          if args.last.kind_of?(Hash)
-            args.last[:in] ||= args.last[:within]
-          end
-          super(*args,&b)
-        end
-        def validates_exclusion_of(*args,&b)
-          if args.last.kind_of?(Hash)
-            args.last[:in] ||= args.last[:within]
-          end
-          super(*args,&b)
-        end
-      end
-      
-      module LifecycleValidationMethods
-        def validate_on_create(name)
-          validate(name, :on => :create)
-        end
-        def validate_on_update(name)
-          validate(name, :on => :update)
-        end
-      end
-
-      class ValidatesUniquenessOf < ActiveModel::EachValidator
-        attr_accessor :scope, :allow_blank, :allow_nil, :attributes, :case_sensitive
-        def case_sensitive
-          @case_sensitive.nil? ? true : @case_sensitive
-        end
-        
-        def initialize(ops)
-          ops.each { |k,v| send("#{k}=",v) }
-        end
-        
-        def validate(record)
-          [attributes].flatten.each do |attribute|
-            record.errors.add(*message(record,attribute)) unless valid?(record,attribute)
-          end
-        end
-      
-        def valid?(instance,attribute)
-          value = instance[attribute]
-          return true if allow_blank && value.blank?
-          return true if allow_nil && value.nil?
-          base_conditions = case_sensitive ? {attribute => value} : {}
-          doc = instance.class.first(base_conditions.merge(scope_conditions(instance)).merge(where_conditions(instance,attribute)))
-          doc.nil? || instance._id == doc._id
-        end
-      
-        def message(instance,attribute)
-          [attribute,"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, attribute)
-          conditions = {}
-          conditions[attribute] = /#{instance[attribute].to_s}/i unless case_sensitive
-          conditions
-        end
-      end
-    end
-  end
-end

data/lib/mongo_mapper/query.rb

@@ -1,130 +0,0 @@
-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
-        [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