honkster-mongo_mapper 0.8.4

data/lib/mongo_mapper/plugins/sci.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Sci
+      module ClassMethods
+        def inherited(subclass)
+          key :_type, String unless key?(:_type)
+          subclass.instance_variable_set("@single_collection_inherited", true)
+          subclass.set_collection_name(collection_name) unless subclass.embeddable?
+          super
+        end
+
+        def single_collection_inherited?
+          @single_collection_inherited == true
+        end
+
+        def query(options={})
+          super.tap do |query|
+            query[:_type] = name if single_collection_inherited?
+          end
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*args)
+          super
+          write_key :_type, self.class.name if self.class.key?(:_type)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/scopes.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Scopes
+      module ClassMethods
+        def scope(name, scope_options={})
+          scopes[name] = lambda do |*args|
+            result = scope_options.is_a?(Proc) ? scope_options.call(*args) : scope_options
+            result = self.query(result) if result.is_a?(Hash)
+            self.query.merge(result)
+          end
+          singleton_class.send :define_method, name, &scopes[name]
+        end
+
+        def scopes
+          read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/serialization.rb

@@ -0,0 +1,76 @@
+# encoding: UTF-8
+require 'active_support/json'
+
+module MongoMapper
+  module Plugins
+    module Serialization
+      def self.configure(model)
+        model.class_eval { cattr_accessor :include_root_in_json, :instance_writer => true }
+      end
+
+      module InstanceMethods
+        def as_json options={}
+          options ||= {}
+          unless options[:only]
+            methods = [options.delete(:methods)].flatten.compact
+            methods << :id
+            options[:methods] = methods.uniq
+          end
+
+          except = [options.delete(:except)].flatten.compact
+          except << :_id
+          options[:except] = except
+
+          # Direct rip from Rails 3 ActiveModel Serialization (#serializable_hash)
+          hash = begin
+            options[:only]   = Array.wrap(options[:only]).map { |n| n.to_s }
+            options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+
+            attribute_names = attributes.keys.sort
+            if options[:only].any?
+              attribute_names &= options[:only]
+            elsif options[:except].any?
+              attribute_names -= options[:except]
+            end
+
+            method_names = Array.wrap(options[:methods]).inject([]) do |methods, name|
+              methods << name if respond_to?(name.to_s)
+              methods
+            end
+
+            (attribute_names + method_names).inject({}) { |hash, name|
+              hash[name] = send(name)
+              hash
+            }
+          end
+          # End rip
+
+          options.delete(:only) if options[:only].nil? or options[:only].empty?
+
+          hash.each do |key, value|
+            if value.is_a?(Array)
+              hash[key] = value.map do |item|
+                item.respond_to?(:as_json) ? item.as_json(options) : item
+              end
+            elsif value.is_a? BSON::ObjectId
+              hash[key] = value.to_s
+            elsif value.respond_to?(:as_json)
+              hash[key] = value.as_json(options)
+            end
+          end
+
+          # Replicate Rails 3 naming - and also bin anytihng after : for use in our dynamic classes from unit tests
+          hash = { ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self.class.name)).gsub(/:.*/,'') => hash } if include_root_in_json
+          hash
+        end
+      end
+
+      module ClassMethods
+        def from_json(json)
+          self.new(ActiveSupport::JSON.decode(json))
+        end
+      end
+
+    end
+  end
+end

data/lib/mongo_mapper/plugins/timestamps.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Timestamps
+      module ClassMethods
+        def timestamps!
+          key :created_at, Time
+          key :updated_at, Time
+          class_eval { before_save :update_timestamps }
+        end
+      end
+
+      module InstanceMethods
+        def update_timestamps
+          now = Time.now.utc
+          self[:created_at] = now if new? && !created_at?
+          self[:updated_at] = now
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/userstamps.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Userstamps
+      module ClassMethods
+        def userstamps!
+          key :creator_id, ObjectId
+          key :updater_id, ObjectId
+          belongs_to :creator, :class_name => 'User'
+          belongs_to :updater, :class_name => 'User'
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/validations.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+module MongoMapper
+  module Plugins
+    module Validations
+      def self.configure(model)
+        model.class_eval do
+          include Validatable
+          extend Validations::DocumentMacros
+        end
+      end
+
+      module DocumentMacros
+        def validates_uniqueness_of(*args)
+          add_validations(args, Validations::ValidatesUniquenessOf)
+        end
+      end
+
+      class ValidatesUniquenessOf < Validatable::ValidationBase
+        option :scope, :case_sensitive
+        default :case_sensitive => true
+
+        def valid?(instance)
+          value = instance[attribute]
+          return allow_nil if value.nil? and not allow_nil.nil?
+          return allow_blank if value.blank? and not allow_blank.nil?
+          base_conditions = case_sensitive ? {self.attribute => value} : {}
+          doc = instance.class.first(base_conditions.merge(scope_conditions(instance)).merge(where_conditions(instance)))
+          doc.nil? || instance._id == doc._id
+        end
+
+        def message(instance)
+          super || "has already been taken"
+        end
+
+        def scope_conditions(instance)
+          return {} unless scope
+          Array(scope).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+
+        def where_conditions(instance)
+          conditions = {}
+          conditions[attribute] = /^#{Regexp.escape(instance[attribute].to_s)}$/i unless case_sensitive
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/support/descendant_appends.rb

@@ -0,0 +1,45 @@
+# encoding: UTF-8
+require 'set'
+
+module MongoMapper
+  module Support
+    module DescendantAppends
+      def included(model)
+        extra_extensions.each { |extension| model.extend(extension) }
+        extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
+        descendants << model
+      end
+
+      # @api public
+      def descendants
+        @descendants ||= Set.new
+      end
+
+      # @api public
+      def append_extensions(*extensions)
+        extra_extensions.concat(extensions)
+        descendants.each do |model|
+          extensions.each { |extension| model.extend(extension) }
+        end
+      end
+
+      # @api public
+      def append_inclusions(*inclusions)
+        extra_inclusions.concat(inclusions)
+        descendants.each do |model|
+          inclusions.each { |inclusion| model.send(:include, inclusion) }
+        end
+      end
+
+      # @api private
+      def extra_extensions
+        @extra_extensions ||= []
+      end
+
+      # @api private
+      def extra_inclusions
+        @extra_inclusions ||= []
+      end
+    end
+  end
+end

data/lib/mongo_mapper/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module MongoMapper
+  Version = '0.8.4'
+end

data/rails/init.rb

@@ -0,0 +1,19 @@
+# See http://groups.google.com/group/mongomapper/browse_thread/thread/68f62e8eda43b43a/4841dba76938290c
+#
+# This is only for development mode. You will still want to clear the identity map before each request in production.
+# See examples/identity_map for more on this.
+#
+# to_prepare is called before each request in development mode and the first request in production.
+Rails.configuration.to_prepare do
+  if Rails.configuration.cache_classes
+    MongoMapper::Plugins::IdentityMap.clear
+  else
+    # Rails reloading was making descendants fill up and leak memory, these make sure they get cleared
+    MongoMapper::Document.descendants.each {|m| m.descendants.clear if m.respond_to?(:descendants) }
+    MongoMapper::Document.descendants.clear
+    MongoMapper::EmbeddedDocument.descendants.each {|m| m.descendants.clear if m.respond_to?(:descendants) }
+    MongoMapper::EmbeddedDocument.descendants.clear
+    MongoMapper::Plugins::IdentityMap.clear
+    MongoMapper::Plugins::IdentityMap.models.clear
+  end
+end

data/test/_NOTE_ON_TESTING

@@ -0,0 +1 @@
+I am doing my best to keep unit and functional tests separate. As I see them, functional tests hit the database and should never care about internals. Unit tests do not hit the database.

data/test/functional/associations/test_belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+require 'models'
+
+class BelongsToPolymorphicProxyTest < Test::Unit::TestCase
+  def setup
+    Status.collection.remove
+    Project.collection.remove
+  end
+
+  should "default to nil" do
+    status = Status.new
+    status.target.nil?.should be_true
+    status.target.inspect.should == "nil"
+  end
+
+  should "have boolean presence method" do
+    status = Status.new
+    status.target?.should be_false
+
+    status.target = Project.new(:name => 'mongomapper')
+    status.target?.should be_true
+  end
+
+  should "be able to replace the association" do
+    status = Status.new(:name => 'Foo!')
+    project = Project.new(:name => "mongomapper")
+    status.target = project
+    status.save.should be_true
+
+    status = status.reload
+    status.target.nil?.should be_false
+    status.target_id.should == project._id
+    status.target_type.should == "Project"
+    status.target.name.should == "mongomapper"
+  end
+
+  should "unset the association" do
+    status = Status.new(:name => 'Foo!')
+    project = Project.new(:name => "mongomapper")
+    status.target = project
+    status.save.should be_true
+
+    status = status.reload
+    status.target = nil
+    status.target_type.nil?.should be_true
+    status.target_id.nil?.should be_true
+    status.target.nil?.should be_true
+  end
+
+  context "association id set but document not found" do
+    setup do
+      @status = Status.new(:name => 'Foo!')
+      project = Project.new(:name => "mongomapper")
+      @status.target = project
+      @status.save.should be_true
+      project.destroy
+    end
+
+    should "return nil instead of raising error" do
+      @status.target.nil?.should be_true
+    end
+  end
+end

data/test/functional/associations/test_belongs_to_proxy.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+require 'models'
+
+class BelongsToProxyTest < Test::Unit::TestCase
+  def setup
+    @post_class = Doc()
+    @comment_class = Doc do
+      key :post_id, String
+    end
+
+    @comment_class.belongs_to :post, :class => @post_class
+  end
+
+  should "default to nil" do
+    @comment_class.new.post.nil?.should be_true
+  end
+
+  should "have boolean presence method" do
+    comment = @comment_class.new(:name => 'Foo!')
+    comment.post?.should be_false
+
+    comment.post = @post_class.new(:name => 'mongomapper')
+    comment.post?.should be_true
+  end
+
+  should "be able to replace the association" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.save.should be_true
+
+    comment = comment.reload
+    comment.post.should == post
+    comment.post.nil?.should be_false
+  end
+
+  should "unset the association" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.save.should be_true
+
+    comment = comment.reload
+    comment.post = nil
+    comment.post.nil?.should be_true
+  end
+
+  should "return nil if id set but document not found" do
+    id = BSON::ObjectId.new
+    @comment_class.new(:name => 'Foo', :post_id => id).post.nil?.should be_true
+  end
+
+  context ":dependent" do
+    setup do
+      # FIXME: make use of already defined models
+      class ::Property
+        include MongoMapper::Document
+      end
+      Property.collection.remove
+
+      class ::Thing
+        include MongoMapper::Document
+        key :name, String
+      end
+      Thing.collection.remove
+    end
+
+    teardown do
+      Object.send :remove_const, 'Property' if defined?(::Property)
+      Object.send :remove_const, 'Thing' if defined?(::Thing)
+    end
+
+    context "=> destroy" do
+      setup do
+        Property.key :thing_id, ObjectId
+        Property.belongs_to :thing, :dependent => :destroy
+        Thing.many :properties
+
+        @thing = Thing.create(:name => "Tree")
+        @property1 = Property.create
+        @property2 = Property.create
+        @property3 = Property.create
+        @thing.properties << @property1
+        @thing.properties << @property2
+        @thing.properties << @property3
+      end
+
+      should "not execute on a belongs_to association" do
+        Thing.count.should == 1
+        @property1.destroy
+        Thing.count.should == 1
+      end
+    end
+  end
+end