pwnash-mongo_mapper 0.7.5 → 0.7.6

data/lib/mongo_mapper/plugins/serialization.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'active_support/json'
 
 module MongoMapper

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Timestamps

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Userstamps

data/lib/mongo_mapper/plugins/validations.rb

@@ -1,8 +1,12 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Validations
       def self.configure(model)
-        model.class_eval { include Validatable }
+        model.class_eval do
+          include Validatable
+          extend Plugins::Validations::DocumentMacros
+        end
       end
 
       module DocumentMacros

data/lib/mongo_mapper/query.rb

@@ -1,143 +1,76 @@
+# encoding: UTF-8
+require 'forwardable'
 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]
+    extend Forwardable
 
-    attr_reader :model
+    attr_reader    :query, :model
+    def_delegators :query, :count, :fields?, :simple?, :to_hash, :[], :[]=
 
-    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
+    def initialize(model)
+      @model = model
+      @query = Plucky::Query.new(model.collection).object_ids(model.object_id_keys)
     end
 
-    def criteria
-      to_criteria(@conditions)
+    def initialize_copy(source)
+      super
+      @query = @query.clone
     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}
+    def all(opts={})
+      spawn.update(opts).all.map { |doc| load(doc) }
     end
 
-    def to_a
-      [criteria, options]
+    def first(opts={})
+      load(spawn.update(opts).first)
     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)
-            case value
-              when String
-                value = ObjectId.to_mongo(value)
-              when Array
-                value.map! { |id| ObjectId.to_mongo(id) }
-            end
-          end
-
-          if symbol_operator?(key)
-            key, value = normalized_key(key.field), {"$#{key.operator}" => value}
-          end
-
-          criteria[key] = normalized_value(criteria, key, value)
-        end
+    def last(opts={})
+      load(spawn.update(opts).last)
+    end
 
-        criteria
-      end
+    def spawn
+      query.clone
+    end
 
-      def to_fields(keys)
-        return keys if keys.is_a?(Hash)
-        return nil  if keys.blank?
+    def update(*args)
+      query.update(*args)
+      self
+    end
 
-        if keys.respond_to?(:flatten, :compact)
-          keys.flatten.compact
-        else
-          keys.split(',').map { |key| key.strip }
-        end
-      end
+    def where(*args)
+      query.where(*args)
+      self
+    end
 
-      def to_order(key, direction=nil)
-        [normalized_key(key).to_s, normalized_direction(direction)]
-      end
+    def fields(*args)
+      query.fields(*args)
+      self
+    end
 
-      def normalized_key(key)
-        key.to_s == 'id' ? :_id : key
-      end
+    def limit(*args)
+      query.limit(*args)
+      self
+    end
 
-      # TODO: this is getting heavy enough to move to a class
-      def normalized_value(criteria, key, value)
-        case value
-          when Array, Set
-            modifier?(key) ? value.to_a : {'$in' => value.to_a}
-          when Hash
-            if criteria[key].kind_of?(Hash)
-              criteria[key].dup.merge(to_criteria(value, key))
-            else
-              to_criteria(value, key)
-            end
-          when Time
-            value.utc
-          else
-            value
-        end
-      end
+    def skip(*args)
+      query.skip(*args)
+      self
+    end
 
-      def normalized_direction(direction)
-        direction ||= 'asc'
-        direction.downcase == 'asc' ? Mongo::ASCENDING : Mongo::DESCENDING
-      end
+    def sort(*args)
+      query.sort(*args)
+      self
+    end
 
-      def normalized_sort(sort)
-        return if sort.blank?
+    def reverse
+      query.reverse
+      self
+    end
 
-        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
+    private
+      def load(doc)
+        model.load(doc)
       end
   end
-end
+end

data/lib/mongo_mapper/support.rb

@@ -1,218 +1,7 @@
-class Array
-  def self.to_mongo(value)
-    value = value.respond_to?(:lines) ? value.lines : value
-    value.to_a
-  end
-
-  def self.from_mongo(value)
-    value || []
-  end
-end
-
-class Binary
-  def self.to_mongo(value)
-    if value.is_a?(BSON::Binary)
-      value
-    else
-      value.nil? ? nil : BSON::Binary.new(value)
-    end
-  end
-
-  def self.from_mongo(value)
-    value
-  end
-end
-
-class Boolean
-  BOOLEAN_MAPPING = {
-    true => true, 'true' => true, 'TRUE' => true, 'True' => true, 't' => true, 'T' => true, '1' => true, 1 => true, 1.0 => true,
-    false => false, 'false' => false, 'FALSE' => false, 'False' => false, 'f' => false, 'F' => false, '0' => false, 0 => false, 0.0 => false, nil => nil
-  }
-
-  def self.to_mongo(value)
-    if value.is_a?(Boolean)
-      value
-    else
-      BOOLEAN_MAPPING[value]
-    end
-  end
-
-  def self.from_mongo(value)
-    !!value
-  end
-end
-
-class Date
-  def self.to_mongo(value)
-    if value.nil? || value == ''
-      nil
-    else
-      date = value.is_a?(Date) || value.is_a?(Time) ? value : Date.parse(value.to_s)
-      Time.utc(date.year, date.month, date.day)
-    end
-  rescue
-    nil
-  end
-
-  def self.from_mongo(value)
-    value.to_date if value.present?
-  end
-end
-
-class Float
-  def self.to_mongo(value)
-    value.nil? ? nil : value.to_f
-  end
-end
-
-class Hash
-  def self.from_mongo(value)
-    HashWithIndifferentAccess.new(value || {})
-  end
-
-  def to_mongo
-    self
-  end
-end
-
-class Integer
-  def self.to_mongo(value)
-    value_to_i = value.to_i
-    if value_to_i == 0 && value != value_to_i
-      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
-    else
-      value_to_i
-    end
-  end
-end
-
-class NilClass
-  def to_mongo(value)
-    value
-  end
-
-  def from_mongo(value)
-    value
-  end
-end
-
-class Object
-  # The hidden singleton lurks behind everyone
-  def metaclass
-    class << self; self end
-  end
-
-  def meta_eval(&blk)
-    metaclass.instance_eval(&blk)
-  end
-
-  # Adds methods to a metaclass
-  def meta_def(name, &blk)
-    meta_eval { define_method(name, &blk) }
-  end
-
-  # Defines an instance method within a class
-  def class_def(name, &blk)
-    class_eval { define_method(name, &blk) }
-  end
-
-  def self.to_mongo(value)
-    value
-  end
-
-  def self.from_mongo(value)
-    value
-  end
-end
-
-class ObjectId
-  def self.to_mongo(value)
-    if value.blank?
-      nil
-    elsif value.is_a?(BSON::ObjectID)
-      value
-    else
-      BSON::ObjectID.from_string(value.to_s)
-    end
-  end
-
-  def self.from_mongo(value)
-    value
-  end
-end
-
-class Set
-  def self.to_mongo(value)
-    value.to_a
-  end
-
-  def self.from_mongo(value)
-    Set.new(value || [])
-  end
-end
-
-class String
-  def self.to_mongo(value)
-    value.nil? ? nil : value.to_s
-  end
-
-  def self.from_mongo(value)
-    value.nil? ? nil : value.to_s
-  end
-end
-
-class SymbolOperator
-  attr_reader :field, :operator
-
-  def initialize(field, operator, options={})
-    @field, @operator = field, operator
-  end unless method_defined?(:initialize)
-end
-
-class Symbol
-  %w(gt lt gte lte ne in nin mod all size where exists asc desc).each do |operator|
-    define_method(operator) do
-      SymbolOperator.new(self, operator)
-    end unless method_defined?(operator)
-  end
-end
-
-class Time
-  def self.to_mongo(value)
-    if value.nil? || value == ''
-      nil
-    else
-      time_class = Time.try(:zone).present? ? Time.zone : Time
-      time = value.is_a?(Time) ? value : time_class.parse(value.to_s)
-      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
-      at(time.to_i).utc if time
-    end
-  end
-
-  def self.from_mongo(value)
-    if Time.try(:zone).present? && value.present?
-      value.in_time_zone(Time.zone)
-    else
-      value
-    end
-  end
-end
-
-class BSON::ObjectID
-  alias_method :original_to_json, :to_json
-
-  def as_json(options=nil)
-    to_s
-  end
-
-  def to_json(options = nil)
-    as_json.to_json
-  end
-end
-
+# encoding: UTF-8
+# All the core extensions now live in extensions.rb.
 module MongoMapper
   module Support
     autoload :DescendantAppends, 'mongo_mapper/support/descendant_appends'
-    autoload :Find,              'mongo_mapper/support/find'
   end
 end

data/lib/mongo_mapper/support/descendant_appends.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Support
     module DescendantAppends
@@ -14,9 +15,7 @@ module MongoMapper
 
       # @api public
       def append_extensions(*extensions)
-        extra_extensions.concat extensions
-
-        # Add the extension to existing descendants
+        extra_extensions.concat(extensions)
         descendants.each do |model|
           extensions.each { |extension| model.extend(extension) }
         end
@@ -24,9 +23,7 @@ module MongoMapper
 
       # @api public
       def append_inclusions(*inclusions)
-        extra_inclusions.concat inclusions
-
-        # Add the inclusion to existing descendants
+        extra_inclusions.concat(inclusions)
         descendants.each do |model|
           inclusions.each { |inclusion| model.send(:include, inclusion) }
         end