crnixon-mongomapper 0.2.0

data/lib/mongomapper/associations/proxy.rb

@@ -0,0 +1,60 @@
+module MongoMapper
+  module Associations
+    class Proxy
+      attr_reader :owner, :association
+
+      instance_methods.each do |m|
+        undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|^object_id$)/
+      end
+
+      def initialize(owner, association)
+        @owner= owner
+        @association = association
+
+        reset
+      end
+
+      def respond_to?(*methods)
+        (load_target && @target.respond_to?(*methods))
+      end
+
+      def reset
+        @target = nil
+      end
+
+      def reload_target
+        reset
+        load_target
+        self
+      end
+
+      def send(method, *args)
+        load_target
+        @target.send(method, *args)
+      end
+
+      def replace(v)
+        raise NotImplementedError
+      end
+
+      protected
+      def method_missing(method, *args)
+        if load_target
+          if block_given?
+            @target.send(method, *args)  { |*block_args| yield(*block_args) }
+          else
+            @target.send(method, *args)
+          end
+        end
+      end
+
+      def load_target
+        @target ||= find_target
+      end
+
+      def find_target
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/mongomapper/callbacks.rb

@@ -0,0 +1,106 @@
+module MongoMapper
+  module Callbacks    
+    def self.included(model) #:nodoc:
+      model.class_eval do
+        extend Observable
+        include ActiveSupport::Callbacks
+        
+        define_callbacks *%w(
+          before_save after_save before_create after_create before_update after_update before_validation
+          after_validation before_validation_on_create after_validation_on_create before_validation_on_update
+          after_validation_on_update before_destroy after_destroy
+        )
+        
+        [:create_or_update, :valid?, :create, :update, :destroy].each do |method|
+          alias_method_chain method, :callbacks
+        end
+      end
+    end
+
+    def before_save() end
+
+    def after_save()  end
+    def create_or_update_with_callbacks #:nodoc:
+      return false if callback(:before_save) == false
+      if result = create_or_update_without_callbacks
+        callback(:after_save)
+      end
+      result
+    end
+    private :create_or_update_with_callbacks
+
+    def before_create() end
+
+    def after_create() end
+    def create_with_callbacks #:nodoc:
+      return false if callback(:before_create) == false
+      result = create_without_callbacks
+      callback(:after_create)
+      result
+    end
+    private :create_with_callbacks
+
+    def before_update() end
+
+    def after_update() end
+
+    def update_with_callbacks(*args) #:nodoc:
+      return false if callback(:before_update) == false
+      result = update_without_callbacks(*args)
+      callback(:after_update)
+      result
+    end
+    private :update_with_callbacks
+
+    def before_validation() end
+
+    def after_validation() end
+
+    def before_validation_on_create() end
+
+    def after_validation_on_create()  end
+
+    def before_validation_on_update() end
+
+    def after_validation_on_update()  end
+
+    def valid_with_callbacks? #:nodoc:
+      return false if callback(:before_validation) == false
+      result = new? ? callback(:before_validation_on_create) : callback(:before_validation_on_update)
+      return false if false == result
+      
+      result = valid_without_callbacks?
+      callback(:after_validation)
+      
+      new? ? callback(:after_validation_on_create) : callback(:after_validation_on_update)
+      return result
+    end
+
+    def before_destroy() end
+
+    def after_destroy()  end
+    def destroy_with_callbacks #:nodoc:
+      return false if callback(:before_destroy) == false
+      result = destroy_without_callbacks
+      callback(:after_destroy)
+      result
+    end
+
+    private
+      def callback(method)
+        result = run_callbacks(method) { |result, object| false == result }
+        
+        if result != false && respond_to_without_attributes?(method)
+          result = send(method)
+        end
+        
+        notify(method)
+        return result
+      end
+      
+      def notify(method) #:nodoc:
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
+  end
+end

data/lib/mongomapper/document.rb

@@ -0,0 +1,262 @@
+require 'set'
+
+module MongoMapper
+  module Document
+    def self.included(model)
+      model.class_eval do
+        include EmbeddedDocument
+        include InstanceMethods
+        include Observing
+        include Callbacks
+        include SaveWithValidation
+        include RailsCompatibility
+        extend ClassMethods
+
+        key :_id, String
+        key :created_at, Time
+        key :updated_at, Time
+      end
+
+      descendants << model
+    end
+
+    def self.descendants
+      @descendants ||= Set.new
+    end
+ 
+    module ClassMethods
+      def find(*args)
+        options = args.extract_options!
+
+        case args.first
+          when :first then find_first(options)
+          when :last  then find_last(options)
+          when :all   then find_every(options)
+          else             find_from_ids(args)
+        end
+      end
+
+      def first(options={})
+        find_first(options)
+      end
+
+      def last(options={})
+        find_last(options)
+      end
+
+      def all(options={})
+        find_every(options)
+      end
+
+      def find_by_id(id)
+        if doc = collection.find_first({:_id => id})
+          new(doc)
+        end
+      end
+
+      # TODO: remove the rescuing when ruby driver works correctly
+      def count(conditions={})
+        collection.count(FinderOptions.to_mongo_criteria(conditions))
+      end
+
+      def create(*docs)
+        instances = []
+        docs.flatten.each do |attrs|
+          doc = new(attrs); doc.save
+          instances << doc
+        end
+        instances.size == 1 ? instances[0] : instances
+      end
+
+      # For updating single document
+      #   Person.update(1, {:foo => 'bar'})
+      #
+      # For updating multiple documents at once:
+      #   Person.update({'1' => {:foo => 'bar'}, '2' => {:baz => 'wick'}})
+      def update(*args)
+        updating_multiple = args.length == 1
+        if updating_multiple
+          update_multiple(args[0])
+        else
+          id, attributes = args
+          update_single(id, attributes)
+        end
+      end
+
+      def delete(*ids)
+        collection.remove(:_id => {'$in' => ids.flatten})
+      end
+
+      def delete_all(conditions={})
+        collection.remove(FinderOptions.to_mongo_criteria(conditions))
+      end
+
+      def destroy(*ids)
+        find_some(ids.flatten).each(&:destroy)
+      end
+
+      def destroy_all(conditions={})
+        find(:all, :conditions => conditions).each(&:destroy)
+      end
+
+      def connection(mongo_connection=nil)
+        if mongo_connection.nil?
+          @connection ||= MongoMapper.connection
+        else
+          @connection = mongo_connection
+        end
+        @connection
+      end
+
+      def database(name=nil)
+        if name.nil?
+          @database ||= MongoMapper.database
+        else
+          @database = connection.db(name)
+        end
+        @database
+      end
+
+      def collection(name=nil)
+        if name.nil?
+          @collection ||= database.collection(self.to_s.demodulize.tableize)
+        else
+          @collection = database.collection(name)
+        end
+        @collection
+      end
+
+      def validates_uniqueness_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesUniquenessOf)
+      end
+      
+      def validates_exclusion_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesExclusionOf)
+      end
+
+      def validates_inclusion_of(*args)
+        add_validations(args, MongoMapper::Validations::ValidatesInclusionOf)
+      end
+
+    private
+      def find_every(options)
+        criteria, options = FinderOptions.new(options).to_a
+        collection.find(criteria, options).to_a.map { |doc| new(doc) }
+      end
+
+      def find_first(options)
+        find_every(options.merge(:limit => 1, :order => 'created_at')).first
+      end
+
+      def find_last(options)
+        find_every(options.merge(:limit => 1, :order => 'created_at desc')).first
+      end
+
+      def find_some(ids)
+        documents = find_every(:conditions => {'_id' => ids})
+        if ids.size == documents.size
+          documents
+        else
+          raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+        end
+      end
+
+      def find_from_ids(*ids)
+        ids = ids.flatten.compact.uniq
+
+        case ids.size
+          when 0
+            raise(DocumentNotFound, "Couldn't find without an ID")
+          when 1
+            find_by_id(ids[0]) || raise(DocumentNotFound, "Document with id of #{ids[0]} does not exist in collection named #{collection.name}")
+          else
+            find_some(ids)
+        end
+      end
+
+      def update_single(id, attrs)
+        if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+          raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+        end
+
+        find(id).update_attributes(attrs)
+      end
+
+      def update_multiple(docs)
+        unless docs.is_a?(Hash)
+          raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+        end
+        instances = []
+        docs.each_pair { |id, attrs| instances << update(id, attrs) }
+        instances
+      end
+    end
+
+    module InstanceMethods
+      def collection
+        self.class.collection
+      end
+
+      def new?
+        read_attribute('_id').blank? || self.class.find_by_id(id).blank?
+      end
+
+      def save
+        create_or_update
+      end
+      
+      def save!
+        create_or_update || raise(DocumentNotValid.new(self))
+      end
+
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+        self
+      end
+
+      def destroy
+        collection.remove(:_id => id) unless new?
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && id == other.id
+      end
+ 
+      def id
+        read_attribute('_id')
+      end
+
+    private
+      def create_or_update
+        result = new? ? create : update
+        result != false
+      end
+      
+      def create
+        write_attribute('_id', generate_id) if read_attribute('_id').blank?
+        update_timestamps
+        save_to_collection
+      end
+
+      def update
+        update_timestamps
+        save_to_collection
+      end
+
+      def save_to_collection
+        collection.save(attributes.merge!(embedded_association_attributes))
+      end
+
+      def update_timestamps
+        write_attribute('created_at', Time.now.utc) if new?
+        write_attribute('updated_at', Time.now.utc)
+      end
+
+      def generate_id
+        XGen::Mongo::Driver::ObjectID.new
+      end
+    end
+  end # Document
+end # MongoMapper

data/lib/mongomapper/embedded_document.rb

@@ -0,0 +1,226 @@
+require 'observer'
+
+module MongoMapper
+  module EmbeddedDocument
+    class NotImplemented < StandardError; end
+
+    def self.included(model)
+      model.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+
+        extend Associations::ClassMethods
+        include Associations::InstanceMethods
+
+        include Validatable
+        include Serialization
+      end
+    end
+
+    module ClassMethods
+      def keys
+        @keys ||= HashWithIndifferentAccess.new
+      end
+
+      def key(name, type, options={})
+        key = Key.new(name, type, options)
+        keys[key.name] = key
+        apply_validations_for(key)
+        create_indexes_for(key)
+        key
+      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
+
+    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?
+          initialize_associations(attrs)
+          self.attributes = attrs
+        end
+      end
+
+      def attributes=(attrs)
+        return if attrs.blank?
+        attrs.each_pair do |key_name, value|
+          if writer?(key_name)
+            write_attribute(key_name, value)
+          else
+            writer_method ="#{key_name}="
+            self.send(writer_method, value) if respond_to?(writer_method)
+          end
+        end
+      end
+
+      def attributes
+        self.class.keys.inject(HashWithIndifferentAccess.new) do |attributes, key_hash|
+          name, key = key_hash
+          value = value_for_key(key)
+          attributes[name] = value unless value.nil?
+          attributes
+        end
+      end
+
+      def reader?(name)
+        defined_key_names.include?(name.to_s)
+      end
+
+      def writer?(name)
+        name = name.to_s
+        name = name.chop if name.ends_with?('=')
+        reader?(name)
+      end
+
+      def before_typecast_reader?(name)
+        name.to_s.match(/^(.*)_before_typecast$/) && reader?($1)
+      end
+
+      def [](name)
+        read_attribute(name)
+      end
+
+      def []=(name, value)
+        write_attribute(name, value)
+      end
+
+      def method_missing(method, *args, &block)
+        attribute = method.to_s
+
+        if reader?(attribute)
+          read_attribute(attribute)
+        elsif writer?(attribute)
+          write_attribute(attribute.chop, args[0])
+        elsif before_typecast_reader?(attribute)
+          read_attribute_before_typecast(attribute.gsub(/_before_typecast$/, ''))
+        else
+          super
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && attributes == other.attributes
+      end
+
+      def inspect
+        attributes_as_nice_string = defined_key_names.collect do |name|
+          "#{name}: #{read_attribute(name)}"
+        end.join(", ")
+        "#<#{self.class} #{attributes_as_nice_string}>"
+      end
+
+      alias :respond_to_without_attributes? :respond_to?
+
+      def respond_to?(method, include_private=false)
+        return true if reader?(method) || writer?(method) || before_typecast_reader?(method)
+        super
+      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)
+        defined_key(name).get(instance_variable_get("@#{name}"))
+      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}", defined_key(name).set(value)
+      end
+
+      def defined_key(name)
+        self.class.keys[name]
+      end
+
+      def defined_key_names
+        self.class.keys.keys
+      end
+
+      def only_defined_keys(hash={})
+        defined_key_names = defined_key_names()
+        hash.delete_if { |k, v| !defined_key_names.include?(k.to_s) }
+      end
+      
+      def embedded_association_attributes
+        attributes = HashWithIndifferentAccess.new
+        self.class.associations.each_pair do |name, association|
+          if association.type == :many && association.klass.embeddable?
+            vals = instance_variable_get(association.ivar)
+            attributes[name] = vals.collect { |item| item.attributes } if vals
+          end
+        end
+        attributes
+      end
+
+      def initialize_associations(attrs={})
+        self.class.associations.each_pair do |name, association|
+          if collection = attrs.delete(name)
+            __send__("#{association.name}=", collection)
+          end
+        end
+      end
+    end
+  end
+end