mongomodel 0.1

data/lib/mongomodel/document/indexes.rb

@@ -0,0 +1,91 @@
+require 'active_support/core_ext/array/extract_options'
+
+module MongoModel
+  module DocumentExtensions
+    module Indexes
+      extend ActiveSupport::Concern
+      
+      included do
+        index :_type
+      end
+      
+      module ClassMethods
+        def property(name, *args, &block) #:nodoc:
+          property = super
+          index(name) if property.options[:index]
+          property
+        end
+        
+        def index(*args)
+          index = Index.new(*args)
+          indexes << index
+          @_indexes_initialized = false
+          index
+        end
+
+        def indexes
+          read_inheritable_attribute(:indexes) || write_inheritable_attribute(:indexes, [])
+        end
+
+        def indexes_initialized?
+          @_indexes_initialized == true
+        end
+
+        def ensure_indexes!
+          indexes.each do |index|
+            collection.create_index(*index.to_args)
+          end
+
+          @_indexes_initialized = true
+        end
+
+      private
+        def _find(*)
+          ensure_indexes! unless indexes_initialized?
+          super
+        end
+      end
+    end
+  end
+  
+  class Index
+    def initialize(*keys)
+      options = keys.extract_options!
+      @unique = options.delete(:unique)
+      
+      keys.each do |key|
+        self.keys[key.to_sym] = :ascending
+      end
+      
+      options.each do |key, order|
+        self.keys[key.to_sym] = order
+      end
+    end
+    
+    def keys
+      @keys ||= OrderedHash.new
+    end
+    
+    def unique?
+      @unique
+    end
+    
+    def to_args
+      args = []
+      
+      if keys.size == 1 && keys.all? { |k, o| o == :ascending }
+        args << keys.keys.first
+      else
+        args << keys.map { |k, o| [k, o == :ascending ? 1 : -1] }.sort_by { |k| k.first.to_s }
+      end
+        
+      args << true if unique?
+      
+      args
+    end
+    
+    def ==(other)
+      other.is_a?(Index) && to_args == other.to_args
+    end
+  end
+end

data/lib/mongomodel/document/optimistic_locking.rb

@@ -0,0 +1,48 @@
+module MongoModel
+  module DocumentExtensions
+    module OptimisticLocking
+      extend ActiveSupport::Concern
+      
+      module ClassMethods
+        def locking_enabled?
+          properties.include?(:_lock_version)
+        end
+        
+        def lock_optimistically=(value)
+          if value == true
+            property :_lock_version, Integer, :default => 0, :internal => true, :protected => true
+            before_save :increment_lock_version, :if => :locking_enabled?
+          else
+            properties.delete(:_lock_version)
+          end
+        end
+      end
+      
+      def locking_enabled?
+        self.class.locking_enabled?
+      end
+    
+    private
+      def increment_lock_version
+        self._lock_version += 1
+      end
+      
+      def save_to_collection
+        if locking_enabled? && _lock_version > 1
+          begin
+            collection.update({ '_id' => id, '_lock_version' => _lock_version-1 }, to_mongo)
+            success = database.last_status['updatedExisting']
+            
+            self._lock_version -= 1 unless success
+            
+            success
+          rescue Mongo::OperationFailure => e
+            false
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/document/persistence.rb

@@ -0,0 +1,143 @@
+module MongoModel
+  module DocumentExtensions
+    module Persistence
+      extend ActiveSupport::Concern
+      
+      included do
+        undef_method :id if method_defined?(:id)
+        property :id, String, :as => '_id', :default => lambda { ::Mongo::ObjectID.new.to_s }
+        
+        class_inheritable_writer :collection_name
+      end
+      
+      def save
+        create_or_update
+      end
+
+      def save!
+        create_or_update || raise(DocumentNotSaved)
+      end
+      
+      def delete
+        self.class.delete(id)
+        set_destroyed(true)
+        freeze
+      end
+      
+      def destroy
+        delete
+      end
+      
+      # Updates all the attributes from the passed-in Hash and saves the document.
+      # If the object is invalid, the saving will fail and false will be returned.
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+      
+      # Updates a single attribute and saves the document without going through the normal validation procedure.
+      # This is especially useful for boolean flags on existing documents.
+      def update_attribute(name, value)
+        send("#{name}=", value)
+        save(false)
+      end
+      
+      def collection
+        self.class.collection
+      end
+      
+      def database
+        self.class.database
+      end
+      
+      module ClassMethods
+        def create(attributes={}, &block)
+          if attributes.is_a?(Array)
+            attributes.map { |attrs| create(attrs, &block) }
+          else
+            instance = new(attributes, &block)
+            instance.save
+            instance
+          end
+        end
+
+        def delete(id_or_conditions)
+          collection.remove(MongoOptions.new(self, :conditions => id_to_conditions(id_or_conditions)).selector)
+        end
+
+        def destroy(id_or_conditions)
+          find(:all, :conditions => id_to_conditions(id_or_conditions)).each { |instance| instance.destroy }
+        end
+        
+        def from_mongo(document)
+          instance = super
+          instance.send(:instantiate, document)
+          instance
+        end
+        
+        def collection_name
+          if superclass.abstract_class?
+            read_inheritable_attribute(:collection_name) || name.tableize.gsub(/\//, '.')
+          else
+            superclass.collection_name
+          end
+        end
+
+        def collection
+          @_collection ||= database.collection(collection_name)
+        end
+        
+        def database
+          MongoModel.database
+        end
+        
+        def save_safely?
+          @save_safely
+        end
+        
+        def save_safely=(val)
+          @save_safely = val
+        end
+        
+      private
+        def id_to_conditions(id_or_conditions)
+          case id_or_conditions
+          when String
+            { :id => id_or_conditions }
+          when Array
+            { :id.in => id_or_conditions }
+          else
+            id_or_conditions
+          end
+        end
+      end
+    
+    private
+      def create_or_update
+        result = new_record? ? create : update
+        result != false
+      end
+
+      def create
+        save_to_collection
+      end
+
+      def update
+        save_to_collection
+      end
+
+      def save_to_collection
+        collection.save(to_mongo, :safe => self.class.save_safely?)
+        set_new_record(false)
+        true
+      rescue Mongo::OperationFailure => e
+        false
+      end
+
+      def instantiate(document)
+        attributes.from_mongo!(document)
+        set_new_record(false)
+      end
+    end
+  end
+end

data/lib/mongomodel/document/scopes.rb

@@ -0,0 +1,161 @@
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/object/metaclass'
+
+module MongoModel
+  module DocumentExtensions
+    module Scopes
+      extend ActiveSupport::Concern
+    
+      included do
+        class << self
+          [:find, :count].each do |method|
+            alias_method_chain method, :scope
+          end
+        end
+      
+        named_scope :scoped, lambda { |scope| scope }
+      end
+    
+      module ClassMethods
+      protected
+        #
+        def named_scope(name, options={})
+          named_scopes[name] = options
+        
+          metaclass.instance_eval do
+            define_method(name) do |*args|
+              scope(name).apply(*args)
+            end
+          end
+        end
+    
+        #
+        def default_scope(options={})
+          if options.empty?
+            read_inheritable_attribute(:default_scope) || write_inheritable_attribute(:default_scope, Scope.new(self))
+          else
+            write_inheritable_attribute(:default_scope, default_scope.merge(:find => options))
+          end
+        end
+      
+        #
+        def with_scope(options={}, &block)
+          push_scope(current_scope.merge(options), &block)
+        end
+      
+        #
+        def with_exclusive_scope(options={}, &block)
+          push_scope(Scope.new(self, options), &block)
+        end
+    
+      private
+        def push_scope(scope, &block)
+          scopes << scope
+          yield
+        ensure
+          scopes.pop
+        end
+    
+        def find_with_scope(*args)
+          options = args.extract_options!
+          options = current_scope.options_for(:find).deep_merge(options)
+        
+          find_without_scope(*(args << options))
+        end
+      
+        def count_with_scope(conditions={})
+          scope_conditions = current_scope.options_for(:find)[:conditions] || {}
+        
+          count_without_scope(scope_conditions.deep_merge(conditions))
+        end
+      
+        def named_scopes
+          read_inheritable_attribute(:named_scopes) || write_inheritable_attribute(:named_scopes, {})
+        end
+      
+        def scope(name)
+          Scope.new(self, named_scopes[name]) if named_scopes[name]
+        end
+      
+        def scopes
+          Thread.current[:"#{self}_scopes"] ||= [ default_scope.dup ]
+        end
+    
+        def current_scope
+          scopes.last
+        end
+      end
+    end
+  
+    class Scope
+      attr_reader :model, :options
+    
+      delegate :with_scope, :with_exclusive_scope, :scope, :to => :model
+      delegate :inspect, :to => :proxy_found
+    
+      def initialize(model, options={})
+        if options.is_a?(Proc) || options.has_key?(:find) || options.has_key?(:create)
+          @options = options
+        else
+          @exclusive = options.delete(:exclusive)
+          @options = { :find => options }
+        end
+      
+        @model = model
+      end
+    
+      def merge(scope)
+        raise ArgumentError, "Scope must be applied before it can be merged" unless options.is_a?(Hash)
+        options_to_merge = scope.is_a?(self.class) ? scope.options : scope
+        self.class.new(model, options.deep_merge(options_to_merge))
+      end
+    
+      def merge!(scope)
+        raise ArgumentError, "Scope must be applied before it can be merged" unless options.is_a?(Hash)
+        options_to_merge = scope.is_a?(self.class) ? scope.options : scope
+        options.deep_merge!(options_to_merge)
+        self
+      end
+    
+      def reload
+        @found = nil
+        self
+      end
+    
+      def apply(*args)
+        if options.is_a?(Hash)
+          reload
+        else
+          self.class.new(model, options.call(*args))
+        end
+      end
+    
+      def options_for(action=:find)
+        options[action] || {}
+      end
+    
+      def exclusive?
+        @exclusive == true
+      end
+    
+    protected
+      def proxy_found
+        @found ||= find(:all)
+      end
+    
+    private
+      def method_missing(method, *args, &block)
+        if scope = scope(method)
+          scope.exclusive? ? scope : merge(scope.apply(*args))
+        else
+          send(scope_type, options) { model.send(method, *args, &block) }
+        end
+      end
+    
+      def scope_type
+        exclusive? ? :with_exclusive_scope : :with_scope
+      end
+    end
+  end
+end

data/lib/mongomodel/document/validations.rb

@@ -0,0 +1,68 @@
+module MongoModel
+  module DocumentExtensions
+    module Validations
+      extend ActiveSupport::Concern
+      
+      included do
+        alias_method_chain :save, :validation
+        alias_method_chain :save!, :validation
+      end
+    
+      module ClassMethods
+        def property(name, *args, &block) #:nodoc:
+          property = super
+          
+          validates_uniqueness_of(name) if property.options[:unique]
+          
+          property
+        end
+        
+        # Creates an object just like Document.create but calls save! instead of save
+        # so an exception is raised if the document is invalid.
+        def create!(attributes={}, &block)
+          if attributes.is_a?(Array)
+            attributes.map { |attrs| create!(attrs, &block) }
+          else
+            object = new(attributes, &block)
+            object.save!
+            object
+          end
+        end
+      end
+    
+      # The validation process on save can be skipped by passing false. The regular Document#save method is
+      # replaced with this when the validations module is mixed in, which it is by default.
+      def save_with_validation(perform_validation = true)
+        if perform_validation && valid? || !perform_validation
+          begin
+            save_without_validation
+          rescue DocumentNotSaved
+            valid?
+            false
+          end
+        else
+          false
+        end
+      end
+    
+      # Attempts to save the document just like Document#save but will raise a DocumentInvalid exception
+      # instead of returning false if the document is not valid.
+      def save_with_validation!
+        if valid?
+          begin
+            save_without_validation!
+          rescue DocumentNotSaved => e
+            raise valid? ? e : DocumentInvalid.new(self)
+          end
+        else
+          raise DocumentInvalid.new(self)
+        end
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "mongomodel/document/validations/#{filename}"
+end