mongomodel 0.1.6 → 0.2.0

data/lib/mongomodel/document/validations/uniqueness.rb

@@ -55,19 +55,21 @@ module MongoModel
           end
           
           validates_each(attr_names, configuration) do |record, attr_name, value|
+            unique_scope = scoped
+            
             if configuration[:case_sensitive] || !value.is_a?(String)
-              conditions = { attr_name => value }
+              unique_scope = unique_scope.where(attr_name => value)
             else
-              conditions = { "_lowercase_#{attr_name}" => value.downcase }
+              unique_scope = unique_scope.where("_lowercase_#{attr_name}" => value.downcase)
             end
             
             Array(configuration[:scope]).each do |scope|
-              conditions[scope] = record.send(scope)
+              unique_scope = unique_scope.where(scope => record.send(scope))
             end
             
-            conditions.merge!(:id.ne => record.id) unless record.new_record?
+            unique_scope = unique_scope.where(:id.ne => record.id) unless record.new_record?
             
-            if exists?(conditions)
+            if unique_scope.any?
               record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
             end
           end

data/lib/mongomodel/support/dynamic_finder.rb

@@ -0,0 +1,68 @@
+module MongoModel
+  class DynamicFinder
+    def initialize(scope, attribute_names, finder=:first, bang=false)
+      @scope, @attribute_names, @finder, @bang = scope, attribute_names, finder, bang
+    end
+    
+    def execute(*args)
+      options = args.extract_options!
+      conditions = build_conditions(args)
+      
+      result = @scope.where(conditions).send(instantiator? ? :first : @finder)
+      
+      if result.nil?
+        if bang?
+          raise DocumentNotFound, "Couldn't find #{@scope.klass.to_s} with #{conditions.inspect}"
+        elsif instantiator?
+          return @scope.send(@finder, conditions)
+        end
+      end
+      
+      result
+    end
+    
+    def bang?
+      @bang
+    end
+    
+    def instantiator?
+      @finder == :new || @finder == :create
+    end
+    
+    def self.match(scope, 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| scope.klass.properties.include?(n.to_sym) }
+        new(scope, 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

data/lib/mongomodel/support/mongo_operator.rb

@@ -0,0 +1,29 @@
+module MongoModel
+  class MongoOperator
+    attr_reader :field, :operator
+    
+    def initialize(field, operator)
+      @field, @operator = field, operator
+    end
+    
+    def to_mongo_selector(value)
+      { "$#{operator}" => value }
+    end
+    
+    def inspect
+      "#{field.inspect}.#{operator}"
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && field == other.field && operator == other.operator
+    end
+    
+    def hash
+      field.hash ^ operator.hash
+    end
+    
+    def eql?(other)
+      self == other
+    end
+  end
+end

data/lib/mongomodel/support/mongo_options.rb

@@ -75,105 +75,4 @@ module MongoModel
       end
     end
   end
-  
-  class MongoOrder
-    attr_reader :clauses
-    
-    def initialize(*clauses)
-      @clauses = clauses
-    end
-    
-    def to_s
-      clauses.map { |c| c.to_s }.join(', ')
-    end
-    
-    def to_sort(model)
-      clauses.map { |c| c.to_sort(model.properties[c.field]) }
-    end
-    
-    def ==(other)
-      other.is_a?(self.class) && clauses == other.clauses
-    end
-    
-    def reverse
-      self.class.new(*clauses.map { |c| c.reverse })
-    end
-    
-    def self.parse(order)
-      case order
-      when MongoOrder
-        order
-      when Clause
-        new(order)
-      when Symbol
-        new(Clause.new(order))
-      when String
-        new(*order.split(',').map { |c| Clause.parse(c) })
-      when Array
-        new(*order.map { |c| Clause.parse(c) })
-      end
-    end
-    
-    class Clause
-      attr_reader :field, :order
-      
-      def initialize(field, order=:ascending)
-        @field, @order = field.to_sym, order.to_sym
-      end
-      
-      def to_s
-        "#{field} #{order}"
-      end
-      
-      def to_sort(property)
-        [property ? property.as : field.to_s, order]
-      end
-      
-      def reverse
-        self.class.new(field, order == :ascending ? :descending : :ascending)
-      end
-      
-      def ==(other)
-        other.is_a?(self.class) && field == other.field && order == other.order
-      end
-      
-      def self.parse(clause)
-        case clause
-        when Clause
-          clause
-        when String, Symbol
-          field, order = clause.to_s.strip.split(/ /)
-          new(field, order =~ /^desc/i ? :descending : :ascending)
-        end
-      end
-    end
-  end
-  
-  class MongoOperator
-    attr_reader :field, :operator
-    
-    def initialize(field, operator)
-      @field, @operator = field, operator
-    end
-    
-    def to_mongo_selector(value)
-      { "$#{operator}" => value }
-    end
-    
-    def inspect
-      "#{field.inspect}.#{operator}"
-    end
-    
-    def ==(other)
-      other.is_a?(self.class) && field == other.field && operator == other.operator
-    end
-    
-    def hash
-      field.hash ^ operator.hash
-    end
-    
-    def eql?(other)
-      self == other
-    end
-  end
 end

data/lib/mongomodel/support/mongo_order.rb

@@ -0,0 +1,78 @@
+module MongoModel
+  class MongoOrder
+    attr_reader :clauses
+    
+    def initialize(*clauses)
+      @clauses = clauses
+    end
+    
+    def to_a
+      clauses
+    end
+    
+    def to_s
+      clauses.map { |c| c.to_s }.join(', ')
+    end
+    
+    def to_sort(model)
+      clauses.map { |c| c.to_sort(model.properties[c.field]) }
+    end
+    
+    def ==(other)
+      other.is_a?(self.class) && clauses == other.clauses
+    end
+    
+    def reverse
+      self.class.new(*clauses.map { |c| c.reverse })
+    end
+    
+    def self.parse(order)
+      case order
+      when MongoOrder
+        order
+      when Clause
+        new(order)
+      when Symbol
+        new(Clause.new(order))
+      when String
+        new(*order.split(',').map { |c| Clause.parse(c) })
+      when Array
+        new(*order.map { |c| Clause.parse(c) })
+      end
+    end
+    
+    class Clause
+      attr_reader :field, :order
+      
+      def initialize(field, order=:ascending)
+        @field, @order = field.to_sym, order.to_sym
+      end
+      
+      def to_s
+        "#{field} #{order}"
+      end
+      
+      def to_sort(property)
+        [property ? property.as : field.to_s, order]
+      end
+      
+      def reverse
+        self.class.new(field, order == :ascending ? :descending : :ascending)
+      end
+      
+      def ==(other)
+        other.is_a?(self.class) && field == other.field && order == other.order
+      end
+      
+      def self.parse(clause)
+        case clause
+        when Clause
+          clause
+        when String, Symbol
+          field, order = clause.to_s.strip.split(/ /)
+          new(field, order =~ /^desc/i ? :descending : :ascending)
+        end
+      end
+    end
+  end
+end

data/lib/mongomodel/support/scope.rb

@@ -0,0 +1,186 @@
+require 'active_support/core_ext/module/delegation'
+
+module MongoModel
+  class Scope
+    MULTI_VALUE_METHODS = [ :select, :order, :where ]
+    SINGLE_VALUE_METHODS = [ :limit, :offset, :from ]
+    
+    autoload :SpawnMethods,   'mongomodel/support/scope/spawn_methods'
+    autoload :QueryMethods,   'mongomodel/support/scope/query_methods'
+    autoload :FinderMethods,  'mongomodel/support/scope/finder_methods'
+    autoload :DynamicFinders, 'mongomodel/support/scope/dynamic_finders'
+    
+    include DynamicFinders, FinderMethods, QueryMethods, SpawnMethods
+    
+    delegate :inspect, :to => :to_a
+    
+    attr_reader :klass
+    
+    def initialize(klass)
+      super
+      
+      @klass = klass
+      
+      @loaded = false
+      @documents = []
+    end
+    
+    def initialize_copy(other)
+      reset
+    end
+    
+    def build(*args, &block)
+      new(*args, &block)
+    end
+    
+    def to_a
+      return @documents if loaded?
+      
+      @documents = _find_and_instantiate
+      @loaded = true
+      
+      @documents
+    end
+    
+    def size
+      loaded? ? @documents.size : count
+    end
+    
+    def empty?
+      loaded? ? @documents.empty? : count.zero?
+    end
+    
+    def any?(&block)
+      if block_given?
+        to_a.any?(&block)
+      else
+        !empty?
+      end
+    end
+    
+    def count
+      _find.count
+    end
+    
+    def destroy_all
+      to_a.each { |doc| doc.destroy }
+      reset
+    end
+    
+    def destroy(*ids)
+      where(ids_to_conditions(ids)).destroy_all
+      reset
+    end
+    
+    def delete_all
+      selector = MongoOptions.new(klass, :conditions => finder_conditions).selector
+      collection.remove(selector)
+      reset
+    end
+    
+    def delete(*ids)
+      where(ids_to_conditions(ids)).delete_all
+      reset
+    end
+    
+    def loaded?
+      @loaded
+    end
+    
+    def reload
+      reset
+      to_a
+      self
+    end
+    
+    def reset
+      @loaded = nil
+      @documents = []
+      self
+    end
+    
+    def ==(other)
+      case other
+      when Scope
+        klass == other.klass &&
+          collection == other.collection &&
+          finder_options == other.finder_options
+      when Array
+        to_a == other.to_a
+      end
+    end
+    
+    def collection
+      from_value || klass.collection
+    end
+    
+    def finder_options
+      @finder_options ||= begin
+        result = {}
+        
+        result[:conditions] = finder_conditions if where_values.any?
+        result[:select]     = select_values     if select_values.any?
+        result[:order]      = order_values      if order_values.any?
+        result[:limit]      = limit_value       if limit_value.present?
+        result[:offset]     = offset_value      if offset_value.present?
+        
+        result
+      end
+    end
+    
+    def options_for_create
+      @options_for_create ||= begin
+        result = {}
+      
+        finder_conditions.each do |k, v|
+          result[k] = v unless k.is_a?(MongoModel::MongoOperator)
+        end
+      
+        result
+      end
+    end
+  
+  protected
+    def method_missing(method, *args, &block)
+      if Array.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif klass.scopes[method]
+        merge(klass.send(method, *args, &block))
+      elsif klass.respond_to?(method)
+        with_scope { klass.send(method, *args, &block) }
+      else
+        super
+      end
+    end
+  
+  private
+    def _find
+      klass.ensure_indexes! unless klass.indexes_initialized?
+      
+      selector, options = MongoOptions.new(klass, finder_options).to_a
+      collection.find(selector, options)
+    end
+    
+    def _find_and_instantiate
+      _find.to_a.map { |doc| klass.from_mongo(doc) }
+    end
+    
+    def finder_conditions
+      where_values.inject({}) { |conditions, v| conditions.merge(v) }
+    end
+    
+    def with_scope(&block)
+      klass.send(:with_scope, self, &block)
+    end
+    
+    def ids_to_conditions(ids)
+      ids.flatten!
+      
+      if ids.size == 1
+        { :id => ids.first.to_s }
+      else
+        { :id.in => ids.map { |id| id.to_s } }
+      end
+    end
+  end
+end