djsun-mongomapper 0.3.1

data/lib/mongomapper/embedded_document.rb

@@ -0,0 +1,237 @@
+require 'observer'
+
+module MongoMapper
+  module EmbeddedDocument    
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+        
+        extend Associations::ClassMethods
+        include Associations::InstanceMethods
+        
+        include RailsCompatibility::EmbeddedDocument
+        include Validatable
+        include Serialization
+        
+        key :_id, MongoID
+      end
+    end
+    
+    module ClassMethods
+      def inherited(subclass)
+        unless subclass.embeddable?
+          subclass.collection(self.collection.name)
+        end
+        
+        (@subclasses ||= []) << subclass
+      end
+      
+      def subclasses
+        @subclasses
+      end
+      
+      def keys
+        @keys ||= if parent = parent_model
+          parent.keys.dup
+        else
+          HashWithIndifferentAccess.new
+        end
+      end
+      
+      def key(name, type, options={})        
+        key = Key.new(name, type, options)
+        keys[key.name] = key
+        
+        create_accessors_for(key)
+        add_to_subclasses(name, type, options)
+        apply_validations_for(key)
+        create_indexes_for(key)
+        
+        key
+      end
+      
+      def create_accessors_for(key)
+        define_method(key.name) do
+          read_attribute(key.name)
+        end
+        
+        define_method("#{key.name}_before_typecast") do
+          read_attribute_before_typecast(key.name)
+        end
+        
+        define_method("#{key.name}=") do |value|
+          write_attribute(key.name, value)
+        end
+        
+        define_method("#{key.name}?") do
+          read_attribute(key.name).present?
+        end
+      end
+      
+      def add_to_subclasses(name, type, options)
+        return if subclasses.blank?
+        
+        subclasses.each do |subclass|
+          subclass.key name, type, options
+        end
+      end
+      
+      def ensure_index(name_or_array, options={})
+        keys_to_index = if name_or_array.is_a?(Array)
+          name_or_array.map { |pair| [pair[0], pair[1]] }
+        else
+          name_or_array
+        end
+        
+        collection.create_index(keys_to_index, options.delete(:unique))
+      end
+      
+      def embeddable?
+        !self.ancestors.include?(Document)
+      end
+      
+      def parent_model
+        if parent = ancestors[1]
+          parent if parent.ancestors.include?(EmbeddedDocument)
+        end
+      end
+      
+    private
+      def create_indexes_for(key)
+        ensure_index key.name if key.options[:index]
+      end
+      
+      def apply_validations_for(key)
+        attribute = key.name.to_sym
+        
+        if key.options[:required]
+          validates_presence_of(attribute)
+        end
+        
+        if key.options[:unique]
+          validates_uniqueness_of(attribute)
+        end
+        
+        if key.options[:numeric]
+          number_options = key.type == Integer ? {:only_integer => true} : {}
+          validates_numericality_of(attribute, number_options)
+        end
+        
+        if key.options[:format]
+          validates_format_of(attribute, :with => key.options[:format])
+        end
+        
+        if key.options[:length]
+          length_options = case key.options[:length]
+          when Integer
+            {:minimum => 0, :maximum => key.options[:length]}
+          when Range
+            {:within => key.options[:length]}
+          when Hash
+            key.options[:length]
+          end
+          validates_length_of(attribute, length_options)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      def initialize(attrs={})
+        unless attrs.nil?
+          self.class.associations.each_pair do |name, association|
+            if collection = attrs.delete(name)
+              send("#{association.name}=", collection)
+            end
+          end
+          
+          self.attributes = attrs
+        end
+        
+        if self.class.embeddable? && read_attribute(:_id).blank?
+          write_attribute :_id, XGen::Mongo::Driver::ObjectID.new
+        end
+      end
+      
+      def attributes=(attrs)
+        return if attrs.blank?
+        attrs.each_pair do |method, value|
+          self.send("#{method}=", value)
+        end
+      end
+      
+      def attributes
+        returning HashWithIndifferentAccess.new do |attributes|
+          self.class.keys.each_pair do |name, key|
+            value = value_for_key(key)
+            attributes[name] = value unless value.nil?
+          end
+          
+          attributes.merge!(embedded_association_attributes)
+        end
+      end
+      
+      def [](name)
+        read_attribute(name)
+      end
+      
+      def []=(name, value)
+        write_attribute(name, value)
+      end
+      
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
+      
+      def id
+        self._id.to_s
+      end
+      
+      def id=(value)
+        self._id = value
+      end
+      
+      def inspect
+        attributes_as_nice_string = self.class.keys.keys.collect do |name|
+          "#{name}: #{read_attribute(name)}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+      
+      private
+        def value_for_key(key)
+          if key.native?
+            read_attribute(key.name)
+          else
+            embedded_document = read_attribute(key.name)
+            embedded_document && embedded_document.attributes
+          end
+        end
+      
+        def read_attribute(name)
+          val = self.class.keys[name].get(instance_variable_get("@#{name}"))
+          instance_variable_set "@#{name}", val
+        end
+      
+        def read_attribute_before_typecast(name)
+          instance_variable_get("@#{name}_before_typecast")
+        end
+      
+        def write_attribute(name, value)
+          instance_variable_set "@#{name}_before_typecast", value
+          instance_variable_set "@#{name}", self.class.keys[name].set(value)
+        end
+      
+        def embedded_association_attributes
+          returning HashWithIndifferentAccess.new do |attrs|
+            self.class.associations.each_pair do |name, association|
+              next unless association.embeddable?
+              next unless documents = instance_variable_get(association.ivar)
+            
+              attrs[name] = documents.collect { |doc| doc.attributes }
+            end
+          end
+        end
+    end # InstanceMethods
+  end # EmbeddedDocument
+end # MongoMapper

data/lib/mongomapper/finder_options.rb

@@ -0,0 +1,96 @@
+module MongoMapper
+  class FinderOptions
+    attr_reader :options
+    
+    def self.to_mongo_criteria(conditions, parent_key=nil)
+      criteria = {}
+      conditions.each_pair do |field, value|
+        case value
+          when Array
+            operator_present = field.to_s =~ /^\$/
+            
+            dealing_with_ids =  field.to_s == '_id' || 
+                                (parent_key && parent_key.to_s == '_id')
+            
+            criteria[field] = if dealing_with_ids
+                                ids = value.map { |id| MongoID.mm_typecast(id) }
+                                operator_present ? ids : {'$in' => ids}
+                              elsif operator_present
+                                value
+                              else
+                                {'$in' => value}
+                              end
+          when Hash
+            criteria[field] = to_mongo_criteria(value, field)
+          else
+            if field.to_s == '_id'
+              value = MongoID.mm_typecast(value)
+            end
+            
+            criteria[field] = value
+        end
+      end
+      
+      criteria
+    end
+        
+    def self.to_mongo_options(options)
+      options = options.dup
+      {
+        :fields => to_mongo_fields(options.delete(:fields) || options.delete(:select)),
+        :offset => (options.delete(:offset) || 0).to_i,
+        :limit  => (options.delete(:limit) || 0).to_i,
+        :sort   => options.delete(:sort) || to_mongo_sort(options.delete(:order))
+      }
+    end
+    
+    def initialize(options)
+      raise ArgumentError, "FinderOptions must be a hash" unless options.is_a?(Hash)
+      @options = options.symbolize_keys
+      @conditions = @options.delete(:conditions) || {}
+    end
+    
+    def criteria
+      self.class.to_mongo_criteria(@conditions)
+    end
+    
+    def options
+      self.class.to_mongo_options(@options)
+    end
+    
+    def to_a
+      [criteria, options]
+    end
+    
+    private
+      def self.to_mongo_fields(fields)
+        return if fields.blank?
+      
+        if fields.is_a?(String)
+          fields.split(',').map { |field| field.strip }
+        else
+          fields.flatten.compact
+        end
+      end
+    
+      def self.to_mongo_sort(sort)
+        return if sort.blank?
+        pieces = sort.split(',')
+        pairs  = pieces.map { |s| to_mongo_sort_piece(s) }
+      
+        hash = OrderedHash.new
+        pairs.each do |pair|
+          field, sort_direction = pair
+          hash[field] = sort_direction
+        end
+        hash.symbolize_keys
+      end
+    
+      def self.to_mongo_sort_piece(str)
+        field, direction = str.strip.split(' ')
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [field, direction]
+      end
+  end
+end

data/lib/mongomapper/key.rb

@@ -0,0 +1,80 @@
+module MongoMapper
+  class Key
+    # DateTime and Date are currently not supported by mongo's bson so just use Time
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash, MongoID]
+
+    attr_accessor :name, :type, :options, :default_value
+
+    def initialize(name, type, options={})
+      @name, @type = name.to_s, type
+      self.options = (options || {}).symbolize_keys
+      self.default_value = self.options.delete(:default)
+    end
+
+    def ==(other)
+      @name == other.name && @type == other.type
+    end
+
+    def set(value)
+      typecast(value)
+    end
+
+    def native?
+      @native ||= NativeTypes.include?(type)
+    end
+
+    def embedded_document?
+      type.ancestors.include?(EmbeddedDocument) && !type.ancestors.include?(Document)
+    end
+
+    def get(value)
+      return default_value if value.nil? && !default_value.nil?
+      if type == Array
+        value || []
+      elsif type == Hash
+        HashWithIndifferentAccess.new(value || {})
+      else
+        value
+      end
+    end
+
+    private
+      def typecast(value)
+        return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
+        return value if value.kind_of?(type) || value.nil?
+        begin
+          if    type == String    then value.to_s
+          elsif type == Float     then value.to_f
+          elsif type == Array     then value.to_a
+          elsif type == Time      then Time.parse(value.to_s)
+          elsif type == MongoID   then MongoID.mm_typecast(value)
+          #elsif type == Date      then Date.parse(value.to_s)
+          elsif type == Boolean   then Boolean.mm_typecast(value)
+          elsif type == Integer
+            # ganked from datamapper
+            value_to_i = value.to_i
+            if value_to_i == 0 && value != '0'
+              value_to_s = value.to_s
+              begin
+                Integer(value_to_s =~ /^(\d+)/ ? $1 : value_to_s)
+              rescue ArgumentError
+                nil
+              end
+            else
+              value_to_i
+            end
+          elsif embedded_document?
+            typecast_embedded_document(value)
+          else
+            value
+          end
+        rescue
+          value
+        end
+      end
+
+      def typecast_embedded_document(value)
+        value.is_a?(type) ? value : type.new(value)
+      end
+  end
+end

data/lib/mongomapper/observing.rb

@@ -0,0 +1,50 @@
+require 'observer'
+require 'singleton'
+require 'set'
+
+module MongoMapper
+  module Observing #:nodoc:
+    def self.included(model)
+      model.class_eval do
+        extend Observable
+      end      
+    end
+  end
+
+  class Observer
+    include Singleton
+
+    class << self
+      def observe(*models)
+        models.flatten!
+        models.collect! { |model| model.is_a?(Symbol) ? model.to_s.camelize.constantize : model }
+        define_method(:observed_classes) { Set.new(models) }
+      end
+
+      def observed_class
+        if observed_class_name = name[/(.*)Observer/, 1]
+          observed_class_name.constantize
+        else
+          nil
+        end
+      end
+    end
+
+    def initialize
+      Set.new(observed_classes).each { |klass| add_observer! klass }
+    end
+
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    protected
+      def observed_classes
+        Set.new([self.class.observed_class].compact.flatten)
+      end
+      
+      def add_observer!(klass)
+        klass.add_observer(self)
+      end
+  end
+end