jnunemaker-mongomapper 0.1.2 → 0.2.0

data/lib/mongomapper/finder_options.rb

@@ -2,6 +2,33 @@ module MongoMapper
   class FinderOptions
     attr_reader :options
     
+    def self.to_mongo_criteria(conditions)
+      conditions = conditions.dup
+      criteria = {}
+      conditions.each_pair do |field, value|
+        case value
+          when Array
+            criteria[field] = {'$in' => value}
+          when Hash
+            criteria[field] = to_mongo_criteria(value)
+          else
+            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   => 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
@@ -9,11 +36,11 @@ module MongoMapper
     end
     
     def criteria
-      convert_conditions(@conditions.dup)
+      self.class.to_mongo_criteria(@conditions)
     end
     
     def options
-      convert_options(@options.dup)
+      self.class.to_mongo_options(@options)
     end
     
     def to_a
@@ -21,46 +48,21 @@ module MongoMapper
     end
     
     private
-      def convert_conditions(conditions)
-        criteria = {}
-        conditions.each_pair do |field, value|
-          case value
-            when Array
-              criteria[field] = {'$in' => value}
-            when Hash
-              criteria[field] = convert_conditions(value)
-            else
-              criteria[field] = value
-          end
-        end
-        
-        criteria
-      end
-      
-      def convert_options(options)
-        {
-          :fields => convert_fields(options.delete(:fields) || options.delete(:select)),
-          :offset => (options.delete(:offset) || 0).to_i,
-          :limit  => (options.delete(:limit) || 0).to_i,
-          :sort   => convert_sort(options.delete(:order))
-        }
-      end
-      
-      def convert_fields(fields)
+      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 convert_sort(sort)
+    
+      def self.to_mongo_sort(sort)
         return if sort.blank?
         pieces = sort.split(',')
-        pairs  = pieces.map { |s| convert_sort_piece(s) }
-        
+        pairs  = pieces.map { |s| to_mongo_sort_piece(s) }
+      
         hash = OrderedHash.new
         pairs.each do |pair|
           field, sort_direction = pair
@@ -68,8 +70,8 @@ module MongoMapper
         end
         hash.symbolize_keys
       end
-      
-      def convert_sort_piece(str)
+    
+      def self.to_mongo_sort_piece(str)
         field, direction = str.strip.split(' ')
         direction ||= 'ASC'
         direction = direction.upcase == 'ASC' ? 1 : -1

data/lib/mongomapper/key.rb

@@ -1,34 +1,35 @@
 class Boolean; end
+class Ref; end
 
 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]
-    
+    NativeTypes = [String, Float, Time, Integer, Boolean, Array, Hash, Ref]
+
     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 = 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
@@ -39,7 +40,7 @@ module MongoMapper
         value
       end
     end
-    
+
     private
       def typecast(value)
         return HashWithIndifferentAccess.new(value) if value.is_a?(Hash) && type == Hash
@@ -73,7 +74,7 @@ module MongoMapper
           value
         end
       end
-      
+
       def typecast_embedded_document(value)
         value.is_a?(type) ? value : type.new(value)
       end

data/lib/mongomapper/observing.rb

@@ -0,0 +1,90 @@
+require 'observer'
+require 'singleton'
+require 'set'
+
+module MongoMapper
+  module Observing #:nodoc:
+    def self.included(model)
+      model.class_eval do
+        extend Observable
+        extend ClassMethods
+      end      
+    end
+
+    module ClassMethods
+      def observers=(*observers)
+        @observers = observers.flatten
+      end
+
+      def observers
+        @observers ||= []
+      end
+
+      def instantiate_observers
+        return if @observers.blank?
+        @observers.each do |observer|
+          if observer.respond_to?(:to_sym) # Symbol or String
+            observer.to_s.camelize.constantize.instance
+          elsif observer.respond_to?(:instance)
+            observer.instance
+          else
+            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
+          end
+        end
+      end
+
+      protected
+        def inherited(subclass)
+          super
+          changed
+          notify_observers :observed_class_inherited, subclass
+        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 + observed_subclasses).each { |klass| add_observer! klass }
+    end
+
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    def observed_class_inherited(subclass) #:nodoc:
+      self.class.observe(observed_classes + [subclass])
+      add_observer!(subclass)
+    end
+
+    protected
+      def observed_classes
+        Set.new([self.class.observed_class].compact.flatten)
+      end
+      
+      def observed_subclasses
+        observed_classes.sum([]) { |klass| klass.send(:subclasses) }
+      end
+      
+      def add_observer!(klass)
+        klass.add_observer(self)
+      end
+  end
+end

data/lib/mongomapper/rails_compatibility.rb

@@ -5,14 +5,17 @@ module MongoMapper
         alias_method :new_record?, :new?
         extend ClassMethods
       end
+      class << model
+        alias_method :has_many, :many
+      end
     end
-    
+
     module ClassMethods
       def column_names
         keys.keys
       end
     end
-    
+
     def to_param
       id
     end

data/lib/mongomapper/save_with_validation.rb

@@ -2,48 +2,18 @@ module MongoMapper
   module SaveWithValidation
     def self.included(base)
       base.class_eval do
-        alias_method_chain :valid?, :callbacks
         alias_method_chain :save, :validation
-        
-        define_callbacks  :before_validation_on_create,   :before_validation_on_update,
-                          :before_validation,             :after_validation,
-                          :validate, :validate_on_create, :validate_on_update
+        alias_method_chain :save!, :validation
       end
     end
     
-    def save!
-      save_with_validation || raise(DocumentNotValid.new(self))
-    end
-    
     private
-      def save_with_validation        
-        if valid?
-          save_without_validation
-        else
-          false
-        end
+      def save_with_validation
+        valid? ? save_without_validation : false
       end
-    
-      def valid_with_callbacks?
-        run_callbacks(:before_validation)
-        
-        if new?
-          run_callbacks(:before_validation_on_create)
-        else
-          run_callbacks(:before_validation_on_update)
-        end
-        
-        run_callbacks(:validate)
-        
-        if new?
-          run_callbacks(:validate_on_create)
-        else
-          run_callbacks(:validate_on_update)
-        end
-        
-        is_valid = valid_without_callbacks?
-        run_callbacks(:after_validation) if is_valid
-        is_valid 
+      
+      def save_with_validation!
+        valid? ? save_without_validation! : raise(DocumentNotValid.new(self))
       end
   end  
 end

data/lib/mongomapper/validations.rb

@@ -0,0 +1,47 @@
+module MongoMapper
+  module Validations
+    class ValidatesUniquenessOf < Validatable::ValidationBase
+      def valid?(instance)
+        # TODO: scope
+        doc = instance.class.find(:first, :conditions => {self.attribute => instance[attribute]}, :limit => 1)
+        doc.nil? || instance.id == doc.id
+      end
+
+      def message(instance)
+        super || "has already been taken"
+      end
+    end
+    
+    class ValidatesExclusionOf < Validatable::ValidationBase
+      required_option :within
+      
+      def valid?(instance)
+        value = instance[attribute]
+        return true if allow_nil && value.nil?
+        return true if allow_blank && value.blank?
+        
+        !within.include?(instance[attribute])
+      end
+      
+      def message(instance)
+        super || "is reserved"
+      end
+    end
+
+    class ValidatesInclusionOf < Validatable::ValidationBase
+      required_option :within
+      
+      def valid?(instance)
+        value = instance[attribute]
+        return true if allow_nil && value.nil?
+        return true if allow_blank && value.blank?
+        
+        within.include?(value)
+      end
+      
+      def message(instance)
+        super || "is not in the list"
+      end
+    end
+  end
+end

data/mongomapper.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongomapper}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John Nunemaker"]
-  s.date = %q{2009-07-03}
+  s.date = %q{2009-07-07}
   s.email = %q{nunemaker@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -20,14 +20,25 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/mongomapper.rb",
+     "lib/mongomapper/associations.rb",
+     "lib/mongomapper/associations/array_proxy.rb",
+     "lib/mongomapper/associations/base.rb",
+     "lib/mongomapper/associations/belongs_to_proxy.rb",
+     "lib/mongomapper/associations/has_many_embedded_proxy.rb",
+     "lib/mongomapper/associations/has_many_proxy.rb",
+     "lib/mongomapper/associations/polymorphic_belongs_to_proxy.rb",
+     "lib/mongomapper/associations/proxy.rb",
+     "lib/mongomapper/callbacks.rb",
      "lib/mongomapper/document.rb",
      "lib/mongomapper/embedded_document.rb",
      "lib/mongomapper/finder_options.rb",
      "lib/mongomapper/key.rb",
+     "lib/mongomapper/observing.rb",
      "lib/mongomapper/rails_compatibility.rb",
      "lib/mongomapper/save_with_validation.rb",
      "lib/mongomapper/serialization.rb",
      "lib/mongomapper/serializers/json_serializer.rb",
+     "lib/mongomapper/validations.rb",
      "mongomapper.gemspec",
      "test/serializers/test_json_serializer.rb",
      "test/test_associations.rb",
@@ -38,6 +49,7 @@ Gem::Specification.new do |s|
      "test/test_helper.rb",
      "test/test_key.rb",
      "test/test_mongomapper.rb",
+     "test/test_observing.rb",
      "test/test_rails_compatibility.rb",
      "test/test_serializations.rb",
      "test/test_validations.rb"
@@ -59,6 +71,7 @@ Gem::Specification.new do |s|
      "test/test_helper.rb",
      "test/test_key.rb",
      "test/test_mongomapper.rb",
+     "test/test_observing.rb",
      "test/test_rails_compatibility.rb",
      "test/test_serializations.rb",
      "test/test_validations.rb"
@@ -71,20 +84,20 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 0"])
       s.add_runtime_dependency(%q<mongodb-mongo>, ["= 0.9"])
-      s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.7.0"])
+      s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.7.1"])
       s.add_development_dependency(%q<mocha>, ["= 0.9.4"])
       s.add_development_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
     else
       s.add_dependency(%q<activesupport>, [">= 0"])
       s.add_dependency(%q<mongodb-mongo>, ["= 0.9"])
-      s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.0"])
+      s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.1"])
       s.add_dependency(%q<mocha>, ["= 0.9.4"])
       s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 0"])
     s.add_dependency(%q<mongodb-mongo>, ["= 0.9"])
-    s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.0"])
+    s.add_dependency(%q<jnunemaker-validatable>, ["= 1.7.1"])
     s.add_dependency(%q<mocha>, ["= 0.9.4"])
     s.add_dependency(%q<jnunemaker-matchy>, ["= 0.4.0"])
   end