mongomodel 0.1.6 → 0.2.0

data/README.md

@@ -11,6 +11,10 @@ MongoModel is distributed as a gem. Install with:
 
     gem install mongomodel
 
+For performance, you should probably also install the BSON C extensions:
+
+    gem install bson_ext
+
 
 Sample Usage
 ============
@@ -30,5 +34,7 @@ Sample Usage
       validates_presence_of :title, :body
       
       belongs_to :author, :class => User
+      
+      scope :published, where(:published_at.ne => nil)
     end
     

data/bin/console

@@ -31,15 +31,15 @@ IRB.conf[:MAIN_CONTEXT] = irb.context
 examples = <<-EXAMPLES
   
   class Article < MongoModel::Document
-    property :title, String
+    property :title, String, :required => true
     property :published, Boolean, :default => false
     
     timestamps!
     
-    default_scope :order => :title.asc
+    default_scope order(:title.asc)
     
-    named_scope :published, :conditions => { :published => true }
-    named_scope :latest, lambda { |num| { :limit => num, :order => 'created_at DESC' } }
+    scope :published, where(:published => true)
+    scope :latest, lambda { |num| order(:created_at.desc).limit(num) }
   end
   
 EXAMPLES

data/lib/mongomodel.rb

@@ -29,10 +29,12 @@ module MongoModel
   autoload :ActiveModelCompatibility, 'mongomodel/concerns/activemodel'
   
   autoload :MongoOptions,     'mongomodel/support/mongo_options'
-  autoload :MongoOrder,       'mongomodel/support/mongo_options'
-  autoload :MongoOperator,    'mongomodel/support/mongo_options'
+  autoload :MongoOrder,       'mongomodel/support/mongo_order'
+  autoload :MongoOperator,    'mongomodel/support/mongo_operator'
+  autoload :Scope,            'mongomodel/support/scope'
   autoload :Types,            'mongomodel/support/types'
   autoload :Configuration,    'mongomodel/support/configuration'
+  autoload :DynamicFinder,    'mongomodel/support/dynamic_finder'
   
   autoload :Collection,       'mongomodel/support/collection'
   
@@ -66,11 +68,9 @@ module MongoModel
   module DocumentExtensions
     autoload :Persistence,       'mongomodel/document/persistence'
     autoload :OptimisticLocking, 'mongomodel/document/optimistic_locking'
-    autoload :Finders,           'mongomodel/document/finders'
     autoload :DynamicFinders,    'mongomodel/document/dynamic_finders'
     autoload :Indexes,           'mongomodel/document/indexes'
     autoload :Scopes,            'mongomodel/document/scopes'
-    autoload :Scope,             'mongomodel/document/scopes'
     autoload :Validations,       'mongomodel/document/validations'
     autoload :Callbacks,         'mongomodel/document/callbacks'
   end

data/lib/mongomodel/concerns/associations/base/definition.rb

@@ -38,6 +38,10 @@ module MongoModel
           options[:polymorphic]
         end
         
+        def scope
+          klass.scoped.apply_finder_options(scope_options)
+        end
+        
         def scope_options
           options.slice(:conditions, :select, :offset, :limit, :order)
         end

data/lib/mongomodel/concerns/associations/has_many_by_foreign_key.rb

@@ -23,17 +23,17 @@ module MongoModel
         delegate :foreign_key, :inverse_of, :to => :definition
         
         def find_target
-          send_to_klass_with_scope(:all) + new_documents
+          scoped + new_documents
         end
         
         def build(*args, &block)
-          doc = klass.new(*args, &block)
+          doc = scoped.new(*args, &block)
           new_documents << doc
           doc
         end
         
         def create(*args, &block)
-          klass.create(*args) do |doc|
+          scoped.create(*args) do |doc|
             if doc.respond_to?("#{inverse_of}=")
               doc.send("#{inverse_of}=", instance)
             else
@@ -45,7 +45,7 @@ module MongoModel
         end
         
         def create!(*args, &block)
-          klass.create!(*args) do |doc|
+          scoped.create!(*args) do |doc|
             if doc.respond_to?("#{inverse_of}=")
               doc.send("#{inverse_of}=", instance)
             else
@@ -82,17 +82,8 @@ module MongoModel
           doc.save(false) unless doc.new_record?
         end
         
-        def send_to_klass_with_scope(*args, &block)
-          scope_options = definition.scope_options
-          fk_conditions = { foreign_key => instance.id }
-          
-          klass.instance_eval do
-            with_scope(:find => { :conditions => fk_conditions }) do
-              with_scope(:find => scope_options) do
-                send(*args, &block)
-              end
-            end
-          end
+        def scoped
+          definition.scope.where(foreign_key => instance.id)
         end
       
       protected
@@ -183,7 +174,7 @@ module MongoModel
           if target.respond_to?(method_id) && !OVERRIDE_METHODS.include?(method_id.to_sym)
             super(method_id, *args, &block)
           else
-            association.send_to_klass_with_scope(method_id, *args, &block)
+            association.scoped.send(method_id, *args, &block)
           end
         end
       end

data/lib/mongomodel/concerns/associations/has_many_by_ids.rb

@@ -29,27 +29,21 @@ module MongoModel
         end
         
         def find_target
-          ids.any? ? Array(klass.find(*(ids - new_document_ids))) + new_documents : []
+          ids.any? ? Array.wrap(definition.scope.find(ids - new_document_ids)) + new_documents : []
         end
         
         def build(*args, &block)
-          doc = klass.new(*args, &block)
+          doc = scoped.new(*args, &block)
           new_documents << doc
           doc
         end
         
         def create(*args, &block)
-          klass.create(*args, &block)
+          scoped.create(*args, &block)
         end
         
-        def send_to_klass_with_scope(*args, &block)
-          scope_ids = ids
-          
-          klass.instance_eval do
-            with_scope(:find => { :conditions => { :id.in => scope_ids } }) do
-              send(*args, &block)
-            end
-          end
+        def scoped
+          definition.scope.where(:id.in => ids)
         end
         
       protected
@@ -166,7 +160,7 @@ module MongoModel
           if target.respond_to?(method_id) && !OVERRIDE_METHODS.include?(method_id.to_sym)
             super(method_id, *args, &block)
           else
-            association.send_to_klass_with_scope(method_id, *args, &block)
+            association.scoped.send(method_id, *args, &block)
           end
         end
       end

data/lib/mongomodel/concerns/attributes.rb

@@ -4,13 +4,7 @@ module MongoModel
   module Attributes
     extend ActiveSupport::Concern
     
-    included do
-      alias_method_chain :initialize, :attributes
-    end
-    
-    def initialize_with_attributes(attrs={})
-      initialize_without_attributes
-      
+    def initialize(attrs={})
       self.attributes = attrs
       yield self if block_given?
     end

data/lib/mongomodel/document.rb

@@ -7,7 +7,6 @@ module MongoModel
     include DocumentExtensions::Persistence
     include DocumentExtensions::OptimisticLocking
     
-    extend  DocumentExtensions::Finders
     extend  DocumentExtensions::DynamicFinders
     include DocumentExtensions::Indexes
     

data/lib/mongomodel/document/dynamic_finders.rb

@@ -2,7 +2,7 @@ module MongoModel
   module DocumentExtensions
     module DynamicFinders
       def respond_to?(method_id, include_private = false)
-        if DynamicFinder.match(self, method_id)
+        if DynamicFinder.match(scoped, method_id)
           true
         else
           super
@@ -10,79 +10,12 @@ module MongoModel
       end
       
       def method_missing(method_id, *args, &block)
-        if finder = DynamicFinder.match(self, method_id)
+        if finder = DynamicFinder.match(scoped, method_id)
           finder.execute(*args)
         else
           super
         end
       end
     end
-    
-    class DynamicFinder
-      def initialize(model, attribute_names, finder=:first, bang=false)
-        @model, @attribute_names, @finder, @bang = model, attribute_names, finder, bang
-      end
-      
-      def execute(*args)
-        options = args.extract_options!
-        conditions = build_conditions(args)
-        
-        result = @model.send(instantiator? ? :first : @finder, options.deep_merge(:conditions => conditions))
-        
-        if result.nil?
-          if bang?
-            raise DocumentNotFound, "Couldn't find #{@model.to_s} with #{conditions.inspect}"
-          elsif instantiator?
-            return @model.send(@finder, conditions)
-          end
-        end
-        
-        result
-      end
-      
-      def bang?
-        @bang
-      end
-      
-      def instantiator?
-        @finder == :new || @finder == :create
-      end
-      
-      def self.match(model, method)
-        finder = :first
-        bang = false
-        
-        case method.to_s
-        when /^find_(all_by|last_by|by)_([_a-zA-Z]\w*)$/
-          finder = :last if $1 == 'last_by'
-          finder = :all if $1 == 'all_by'
-          names = $2
-        when /^find_by_([_a-zA-Z]\w*)\!$/
-          bang = true
-          names = $1
-        when /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/
-          finder = ($1 == 'initialize' ? :new : :create)
-          names = $2
-        else
-          return nil
-        end
-        
-        names = names.split('_and_')
-        if names.all? { |n| model.properties.include?(n.to_sym) }
-          new(model, names, finder, bang)
-        end
-      end
-    
-    private
-      def build_conditions(args)
-        result = {}
-        
-        @attribute_names.zip(args) do |attribute, value|
-          result[attribute.to_sym] = value
-        end
-        
-        result
-      end
-    end
   end
 end

data/lib/mongomodel/document/indexes.rb

@@ -38,12 +38,6 @@ module MongoModel
 
           @_indexes_initialized = true
         end
-
-      private
-        def _find(*)
-          ensure_indexes! unless indexes_initialized?
-          super
-        end
       end
     end
   end

data/lib/mongomodel/document/persistence.rb

@@ -19,7 +19,7 @@ module MongoModel
       end
       
       def delete
-        self.class.delete(id)
+        self.class.unscoped.delete(id)
         set_destroyed(true)
         freeze
       end
@@ -65,14 +65,6 @@ module MongoModel
           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)
@@ -102,18 +94,6 @@ module MongoModel
         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

data/lib/mongomodel/document/scopes.rb

@@ -1,161 +1,85 @@
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/kernel/singleton_class'
-
 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 }
+      delegate :current_scope, :to => "self.class"
+      
+      def initialize(*)
+        self.attributes = current_scope.options_for_create
+        super
       end
-    
+      
       module ClassMethods
-      protected
-        #
-        def named_scope(name, options={})
-          named_scopes[name] = options
+        delegate :find, :first, :last, :all, :exists?, :count, :to => :scoped
+        delegate :delete, :delete_all, :destroy, :destroy_all, :to => :scoped
+        delegate :select, :order, :where, :limit, :offset, :from, :to => :scoped
         
-          singleton_class.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)
+        def unscoped
+          @unscoped ||= MongoModel::Scope.new(self)
         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))
+        def scoped
+          current_scope.clone
         end
-      
-        def count_with_scope(conditions={})
-          scope_conditions = current_scope.options_for(:find)[:conditions] || {}
         
-          count_without_scope(scope_conditions.deep_merge(conditions))
+        def scopes
+          read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
         end
-      
-        def named_scopes
-          read_inheritable_attribute(:named_scopes) || write_inheritable_attribute(:named_scopes, {})
+        
+        def scope(name, scope)
+          name = name.to_sym
+          
+          if !scopes[name] && respond_to?(name, true)
+            logger.warn "Creating scope :#{name}. " \
+                        "Overwriting existing method #{self.name}.#{name}."
+          end
+          
+          scopes[name] = lambda do |*args|
+            scope.is_a?(Proc) ? scope.call(*args) : scope
+          end
+          
+          singleton_class.class_eval do
+            define_method(name) do |*args|
+              scopes[name].call(*args)
+            end
+          end
         end
-      
-        def scope(name)
-          Scope.new(self, named_scopes[name]) if named_scopes[name]
+        
+        def default_scope(scope)
+          reset_current_scopes
+          previous_scope = default_scoping.last || unscoped
+          default_scoping << previous_scope.merge(scope)
         end
       
-        def scopes
-          Thread.current[:"#{self}_scopes"] ||= [ default_scope.dup ]
+      protected
+        def with_scope(scope, &block)
+          current_scopes << current_scope.merge(scope)
+          
+          begin
+            yield
+          ensure
+            current_scopes.pop
+          end
         end
-    
+        
+      private
         def current_scope
-          scopes.last
+          current_scopes.last || unscoped
         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 }
+        
+        def current_scopes
+          Thread.current[:"#{self}_scopes"] ||= default_scoping.dup
         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))
+        
+        def reset_current_scopes
+          Thread.current[:"#{self}_scopes"] = nil
         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) }
+        
+        def default_scoping
+          read_inheritable_attribute(:default_scoping) || write_inheritable_attribute(:default_scoping, [])
         end
       end
-    
-      def scope_type
-        exclusive? ? :with_exclusive_scope : :with_scope
-      end
     end
   end
 end