mongo_record 0.4.3 → 0.4.4

data/README.rdoc

@@ -83,3 +83,13 @@ Jim Mulholland, jim at squeejee dot com
 
 Clinton R. Nixon, crnixon at gmail dot com
 * Ability to define and query indexes from models
+
+Nate Wiger, http://github.com/nateware
+* Optimization to first and last to close cursor and avoid expensive to_a
+* Implemented Model.update_all leveraging Mongo collection.update
+* Scoped dynamic finders to each instance, so rows with varying attributes work
+* Added row.attributes helper to enable use of ActiveRecord::Callbacks if desired
+
+
+
+

data/lib/mongo_record/base.rb

@@ -18,6 +18,7 @@ require 'mongo/types/code'
 require 'mongo/cursor'
 require 'mongo_record/convert'
 require 'mongo_record/sql'
+#require 'active_support/core_ext' # symbolize_keys!
 
 class String
   # Convert this String to an ObjectID.
@@ -110,6 +111,7 @@ module MongoRecord
         subclass.instance_variable_set("@field_names", []) # array of scalars names (symbols)
         subclass.instance_variable_set("@subobjects", {}) # key = name (symbol), value = class
         subclass.instance_variable_set("@arrays", {})     # key = name (symbol), value = class
+        subclass.field(:_id, :_ns)
       end
 
       # Call this method to set the Mongo collection name for this class.
@@ -117,7 +119,6 @@ module MongoRecord
       # lower_case_with_underscores.
       def collection_name(coll_name)
         @coll_name = coll_name
-        field(:_id, :_ns)
       end
 
       # Creates one or more collection fields. Each field will be saved to
@@ -130,6 +131,7 @@ module MongoRecord
           field = field.to_sym
           unless @field_names.include?(field)
             ivar_name = "@" + field.to_s
+            # this is better than lambda because it's only eval'ed once
             define_method(field, lambda { instance_variable_get(ivar_name) })
             define_method("#{field}=".to_sym, lambda { |val| instance_variable_set(ivar_name, val) })
             define_method("#{field}?".to_sym, lambda {
@@ -162,7 +164,7 @@ module MongoRecord
         end
 
         fields = fields.map do |field|
-          field = field.respond_to?(:[]) ? field : [field, :asc]
+          field = field.is_a?(Array) ? field : [field, :asc]
           field[1] = (field[1] == :desc) ? Mongo::DESCENDING : Mongo::ASCENDING
           field
         end
@@ -395,7 +397,7 @@ module MongoRecord
       end
 
       def sum(column)
-        x = self.find(:all, :select=>column)
+        x = all(:select => column)
         x.map {|p1| p1[column.to_sym]}.compact.inject(0) { |s,v| s += v }
       end
 
@@ -410,17 +412,24 @@ module MongoRecord
         id.is_a?(Array) ? id.each { |oid| destroy(oid) } : find(id).destroy
       end
 
-      # Not yet implemented.
-      def update_all(updates, conditions = nil)
-        # TODO
-        raise "not yet implemented"
+      # This updates all records matching the specified criteria.  It leverages the
+      # db.update call from the Mongo core API to guarantee atomicity.  You can
+      # specify either a hash for simplicity, or full Mongo API operators to the
+      # update part of the method call:
+      #
+      # Person.update_all({:name => 'Bob'}, {:name => 'Fred'})
+      # Person.update_all({'$set' => {:name => 'Bob'}, '$inc' => {:age => 1}}, {:name => 'Fred'})
+      def update_all(updates, conditions = nil, options = {})
+        all(:conditions => conditions).each do |row|
+          collection.update(criteria_from(conditions).merge(:_id => row.id.to_oid), update_fields_from(updates), options)
+        end
       end
 
       # Destroy all objects that match +conditions+. Warning: if
       # +conditions+ is +nil+, all records in the collection will be
       # destroyed.
       def destroy_all(conditions = nil)
-        find(:all, :conditions => conditions).each { |object| object.destroy }
+        all(:conditions => conditions).each { |object| object.destroy }
       end
 
       # Deletes all records that match +condition+, which can be a
@@ -451,13 +460,13 @@ module MongoRecord
       # Example of updating multiple records:
       #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy"} }
       #   Person.update(people.keys, people.values)
-      def update(id, attributes)
+      def update(id, attrib)
         if id.is_a?(Array)
           i = -1
-          id.collect { |id| i += 1; update(id, attributes[i]) }
+          id.collect { |id| i += 1; update(id, attrib[i]) }
         else
           object = find(id)
-          object.update_attributes(attributes)
+          object.update_attributes(attrib)
           object
         end
       end
@@ -502,15 +511,21 @@ module MongoRecord
       def find_initial(options)
         options[:limit] = 1
         options[:order] = 'created_at asc'
-        row = find_every(options)
-        row.to_a[0]
+        find_one(options)
       end
 
       def find_last(options)
         options[:limit] = 1
         options[:order] = 'created_at desc'
-        row = find_every(options)
-        row.to_a[0]
+        find_one(options)
+      end
+
+      def find_one(options)
+        one = nil
+        cursor = find_every(options)
+        one = cursor.detect {|c| c}
+        cursor.close
+        one
       end
 
       def find_every(options)
@@ -523,7 +538,6 @@ module MongoRecord
         find_options[:offset] = options[:offset].to_i if options[:offset]
         find_options[:sort] = sort_by_from(options[:order]) if options[:order]
 
-
         cursor = collection.find(criteria, find_options)
 
         # Override cursor.next_object so it returns a new instance of this class
@@ -735,6 +749,26 @@ module MongoRecord
         end
       end
 
+      # Turns {:key => 'Value'} in update_all into the appropriate '$set' operator
+      def update_fields_from(arg)
+        raise "Update spec for #{self.name}.update_all must be a hash" unless arg.is_a?(Hash)
+        updates = {}
+        arg.each do |key,val|
+          case val
+          when Hash
+            # Assume something like $inc => {:num => 1}
+            updates[key] = val
+          when Array, Range
+            raise "Array/range not supported in value of update spec"
+          else
+            # Assume a simple value, so change to $set
+            updates['$set'] ||= {}
+            updates['$set'][key] = val
+          end
+        end
+        updates
+      end
+
       # Overwrite the default class equality method to provide support for association proxies.
       def ===(object)
         object.is_a?(self)
@@ -767,9 +801,20 @@ module MongoRecord
         iv = "@#{iv}"
         instance_variable_set(iv, []) unless instance_variable_defined?(iv)
       }
+
+      # Create accessors for any per-row dynamic fields we got from our schemaless store
+      self.instance_values.keys.each do |key|
+        next if respond_to?(key.to_sym)  # exists
+        define_instance_accessors(key)
+      end
+      
       yield self if block_given?
     end
 
+    def attributes
+      self.instance_values.inject({}){|h,iv| h[iv.first] = iv.last; h}
+    end
+
     # Set the id of this object. Normally not called by user code.
     def id=(val); @_id = (val == '' ? nil : val); end
 
@@ -882,13 +927,13 @@ module MongoRecord
     end
 
     def []=(attr_name, value)
-      self.class.field(attr_name)
+      define_instance_accessors(attr_name)
       self.send(attr_name.to_s + '=', value)
     end
 
     def method_missing(sym, *args)
       if self.instance_variables.include?("@#{sym}")
-        self.class.field(sym)
+        define_instance_accessors(sym)
         return self.send(sym)
       else
         super
@@ -927,6 +972,9 @@ module MongoRecord
       save!
     end
 
+    def valid?; true; end
+    alias_method :respond_to_without_attributes?, :respond_to?
+    
     # Does nothing.
     def attributes_from_column_definition; end
 
@@ -943,6 +991,15 @@ module MongoRecord
       }
     end
 
+    #--
+    # ================================================================
+    # "Dirty" attribute tracking, adapted from ActiveRecord. This is
+    # a big performance boost, plus it avoids issues if two people
+    # are updating a record concurrently.
+    # ================================================================
+    #++
+
+
     private
 
     def create_or_update
@@ -982,6 +1039,28 @@ module MongoRecord
       }
     end
 
+    # Per-object accessors, since row-to-row attributes can change
+    # Use instance_eval so that they don't bleed over to other objects that lack the fields
+    def define_instance_accessors(*fields)
+      fields = Array(fields)
+      fields.each do |field|
+        ivar_name = "@" + field.to_s
+        instance_eval <<-EndAccessors
+          def #{field}
+            instance_variable_get('#{ivar_name}')
+          end
+          def #{field}=(val)
+            old = instance_variable_get('#{ivar_name}')
+            instance_variable_set('#{ivar_name}', val)
+            instance_variable_set('#{ivar_name}', val)
+          end
+          def #{field}?
+            val = instance_variable_get('#{ivar_name}')
+            val != nil && (!val.kind_of?(String) || val != '')
+          end
+        EndAccessors
+      end
+    end
   end
 
 end

data/mongo-activerecord-ruby.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'mongo_record'
-  s.version = '0.4.3'
+  s.version = '0.4.4'
   s.platform = Gem::Platform::RUBY
   s.summary = 'ActiveRecord-like models for the MongoDB'
   s.description = 'MongoRecord is an ActiveRecord-like framework for MongoDB. For more information about Mongo, see http://www.mongodb.org.'

data/tests/test_mongo.rb

@@ -59,10 +59,10 @@ class MongoTest < Test::Unit::TestCase
     super
     MongoRecord::Base.connection = @@db
 
-    @@students.clear
-    @@courses.clear
-    @@tracks.clear
-    @@playlists.clear
+    @@students.remove
+    @@courses.remove
+    @@tracks.remove
+    @@playlists.remove
 
     # Manually insert data without using MongoRecord::Base
     @@tracks.insert({:_id => Mongo::ObjectID.new, :artist => 'Thomas Dolby', :album => 'Aliens Ate My Buick', :song => 'The Ability to Swing'})
@@ -85,10 +85,10 @@ class MongoTest < Test::Unit::TestCase
   end
 
   def teardown
-    @@students.clear
-    @@courses.clear
-    @@tracks.clear
-    @@playlists.clear
+    @@students.remove
+    @@courses.remove
+    @@tracks.remove
+    @@playlists.remove
     super
   end
 
@@ -98,6 +98,11 @@ class MongoTest < Test::Unit::TestCase
       assert t.instance_variable_defined?("@#{iv}")
     }
   end
+  
+  def test_new_record_set_correctly
+    t = Track.new(:_id => 12345, :artist => 'Alice In Chains')
+    assert_equal true, t.new_record?
+  end
 
   def test_method_generation
     x = Track.new({:artist => 1, :album => 2})
@@ -124,6 +129,94 @@ class MongoTest < Test::Unit::TestCase
     assert_nil(x.track)
   end
 
+  def test_dynamic_methods_in_new
+    x = Track.new({:foo => 1, :bar => 2})
+    y = Track.new({:artist => 3, :song => 4})
+
+    assert x.respond_to?(:_id)
+    assert x.respond_to?(:artist)
+    assert x.respond_to?(:album)
+    assert x.respond_to?(:song)
+    assert x.respond_to?(:track)
+    assert x.respond_to?(:_id=)
+    assert x.respond_to?(:artist=)
+    assert x.respond_to?(:album=)
+    assert x.respond_to?(:song=)
+    assert x.respond_to?(:track=)
+    assert x.respond_to?(:_id?)
+    assert x.respond_to?(:artist?)
+    assert x.respond_to?(:album?)
+    assert x.respond_to?(:song?)
+    assert x.respond_to?(:track?)
+    
+    # dynamic fields
+    assert x.respond_to?(:foo)
+    assert x.respond_to?(:bar)
+    assert x.respond_to?(:foo=)
+    assert x.respond_to?(:bar=)
+    assert x.respond_to?(:foo?)
+    assert x.respond_to?(:bar?)
+    
+    # make sure accessors only per-object
+    assert !y.respond_to?(:foo)
+    assert !y.respond_to?(:bar)
+    assert !y.respond_to?(:foo=)
+    assert !y.respond_to?(:bar=)
+    assert !y.respond_to?(:foo?)
+    assert !y.respond_to?(:bar?)
+
+    assert_equal(1, x.foo)
+    assert_equal(2, x.bar)
+    assert_nil(x.song)
+    assert_nil(x.track)
+    assert_equal(3, y.artist)
+    assert_equal(4, y.song)
+  end
+
+  def test_dynamic_methods_in_find
+    @@tracks.insert({:_id => 909, :artist => 'Faith No More', :album => 'Album Of The Year', :song => 'Stripsearch', :track => 2,
+                     :vocals => 'Mike Patton', :drums => 'Mike Bordin', :producers => ['Roli Mosimann', 'Billy Gould']})
+    x = Track.find_by_id(909)
+
+    # defined
+    assert x.respond_to?(:_id)
+    assert x.respond_to?(:artist)
+    assert x.respond_to?(:album)
+    assert x.respond_to?(:song)
+    assert x.respond_to?(:track)
+    assert x.respond_to?(:_id=)
+    assert x.respond_to?(:artist=)
+    assert x.respond_to?(:album=)
+    assert x.respond_to?(:song=)
+    assert x.respond_to?(:track=)
+    assert x.respond_to?(:_id?)
+    assert x.respond_to?(:artist?)
+    assert x.respond_to?(:album?)
+    assert x.respond_to?(:song?)
+    assert x.respond_to?(:track?)
+    
+    # dynamic fields
+    assert x.respond_to?(:vocals)
+    assert x.respond_to?(:drums)
+    assert x.respond_to?(:producers)
+    assert x.respond_to?(:vocals=)
+    assert x.respond_to?(:drums=)
+    assert x.respond_to?(:producers=)
+    assert x.respond_to?(:vocals?)
+    assert x.respond_to?(:drums?)
+    assert x.respond_to?(:producers?)
+
+    assert_equal 'Faith No More', x.artist
+    assert_equal 'Album Of The Year', x.album
+    assert_equal 'Stripsearch', x.song
+    assert_equal 2, x.track
+    assert_equal 'Mike Patton', x.vocals
+    assert_equal 'Mike Bordin', x.drums
+    assert_equal ['Roli Mosimann', 'Billy Gould'], x.producers
+    
+    x.destroy
+  end
+  
   def test_initialize_block
     track = Track.new { |t|
       t.artist = "Me'Shell Ndegeocello"
@@ -293,6 +386,27 @@ class MongoTest < Test::Unit::TestCase
     assert_no_match(/song: The Mayor Of Simpleton/, Track.find(:all).inject('') { |str, t| str + t.to_s })
   end
 
+  def test_update_all
+    Track.update_all({:track => 919}, {:artist => 'XTC'})
+    Track.all.each{|r| assert_equal(919, r.track) if r.artist == 'XTC' }
+
+    # Should fail (can't $inc/$set) - remove this test once Mongo 1.2 is out
+    error = nil
+    begin
+      Track.update_all({:song => 'Just Drums'}, {}, :safe => true)
+    rescue Mongo::OperationFailure => error
+    end
+    assert_instance_of Mongo::OperationFailure, error 
+
+    @@tracks.drop_index 'song_-1'  # otherwise update_all $set fails
+    Track.update_all({:song => 'Just Drums'}, {}, :safe => true)
+
+    assert_no_match(/song: Budapest by Blimp/, Track.all.inject('') { |str, t| str + t.to_s })
+
+    assert_equal 6, Track.count
+    Track.index [:song, :desc], true  # reindex
+  end
+
   def test_delete_all
     Track.delete_all({:artist => 'XTC'})
     assert_no_match(/artist: XTC/, Track.find(:all).inject('') { |str, t| str + t.to_s })
@@ -635,7 +749,7 @@ class MongoTest < Test::Unit::TestCase
       # Make sure collection exists
       coll = alt_db.collection('students')
       coll.insert('name' => 'foo')
-      coll.clear
+      coll.remove
 
       assert_equal 0, coll.count()
       s = Student.new(:name => 'Spongebob Squarepants', :address => @spongebob_addr)
@@ -730,7 +844,30 @@ class MongoTest < Test::Unit::TestCase
     opts = {:artist => 'The Outfield', :album => 'Play Deep', :song => 'Your Love', :year => 1986}
     playlist = Playlist.new
     playlist.update_attributes(opts)
-    p = Playlist.find_by_artist("The Outfield")
+
+    # We *want* the following to fail, because otherwise MongoRecord is buggy in the following
+    # situation:
+    #
+    #    Rails/Sinatra/etc server instance #1 does: playlist.custom_field = 'foo'
+    #    Rails/Sinatra/etc instance #2 attempts to do: Playlist.find_by_custom_field
+    #
+    # This will fail because, in previous versions of MongoRecord, the instance would callback
+    # into class.field(), the changing the class definition, then use this modified definition to
+    # determine whether dynamic finders work.
+    #
+    # The biggest issue is you'll never catch this in dev, since everything is a single instance
+    # in memory.  It will manifest as mysterious "undefined method" production bugs.  As such, we *must*
+    # restrict dynamic accessors to only modifying the instance for each row, or else they corrupt
+    # the class.  This means find_by_whatever only works for fields defined via fields()
+    error = nil
+    begin
+      p = Playlist.find_by_artist("The Outfield")
+    rescue NoMethodError => error
+    end
+    assert_instance_of NoMethodError, error
+
+    # This should work though
+    p = Playlist.first(:conditions => {:artist => 'The Outfield'})
     assert_equal(p.year, 1986)
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_record
 version: !ruby/object:Gem::Version 
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors: 
 - Jim Menard
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-08 00:00:00 -04:00
+date: 2009-12-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency