mongodb-mongo_record 0.1.3 → 0.2

data/lib/mongo_record/base.rb

@@ -24,7 +24,7 @@ require 'mongo_record/sql'
 class String
   # Convert this String to an ObjectID.
   def to_oid
-    XGen::Mongo::Driver::ObjectID.from_string(self)
+    XGen::Mongo::Driver::ObjectID.legal?(self) ? XGen::Mongo::Driver::ObjectID.from_string(self) : self
   end
 end
 
@@ -248,6 +248,12 @@ module MongoRecord
       # This expression is run by the database server against each record
       # found after the :conditions are run.
       #
+      # This expression is run by the database server against each record
+      # found after the :conditions are run.
+      #
+      # <code>:criteria</code> - A hash field to pass in MongoDB conditional operators
+      # in a hash format.  [$gt, $lt, $gte, $lte, $in, ect.]
+      #
       # Examples for find by id:
       #   Person.find("48e5307114f4abdf00dfeb86")     # returns the object for this ID
       #   Person.find(["a_hex_id", "another_hex_id"]) # returns a Cursor over these two objects
@@ -272,6 +278,7 @@ module MongoRecord
       #
       # Mongo-specific example:
       #   Person.find(:all, :where => "this.address.city == 'New York' || this.age = 42")
+      #   Person.find(:all, :criteria => {"followers_count"=>{"$gte"=>410}})
       #
       # As a side note, the :order, :limit, and :offset options are passed
       # on to the Cursor (after the :order option is rewritten to be a
@@ -279,17 +286,57 @@ module MongoRecord
       #   Person.find(:all, :offset => 10, :limit => 10, :order => :created_on)
       # is the same as
       #   Person.find(:all).skip(10).limit(10).sort({:created_on => 1})
-      def find(*args)
-        options = extract_options_from_args!(args)
+      #
+      
+    
+      def find(*args)        
+        options = extract_options_from_args!(args)        
+        options.symbolize_keys!
         case args.first
         when :first
           find_initial(options)
         when :all
           find_every(options)
+        when :last
+          find_last(options)
         else
           find_from_ids(args, options)
         end
       end
+      
+      # Yields each record that was found by the find +options+. The find is
+      # performed by find.
+      #
+      # Example:
+      #
+      #   Person.find_each(:conditions => "age > 21") do |person|
+      #     person.party_all_night!
+      #   end
+
+      def find_each(*args)        
+        options = extract_options_from_args!(args)        
+        options.symbolize_keys!
+        find_every(options).each do |record|
+          yield record 
+        end
+        self
+      end
+      
+      def all(*args)
+        options = extract_options_from_args!(args)
+        find_every(options)
+      end
+          
+      def first(*args)
+#        args = ([:first]<<args).flatten
+        options = extract_options_from_args!(args)
+        find_initial(options)
+      end
+
+      def last(*args)
+        options = extract_options_from_args!(args)
+        find_last(options)
+      end
 
       # Returns all records matching mql. Not yet implemented.
       def find_by_mql(mql)    # :nodoc:
@@ -299,7 +346,7 @@ module MongoRecord
 
       # Returns the number of matching records.
       def count(options={})
-        criteria = criteria_from(options[:conditions]).merge!(where_func(options[:where]))
+        criteria = criteria_from(options[:conditions],options[:criteria]).merge!(where_func(options[:where]))
         begin
           collection.count(criteria)
         rescue => ex
@@ -314,6 +361,11 @@ module MongoRecord
         end
       end
 
+      def sum(column)
+        x = self.find(:all, :select=>column)   
+        x.map {|p1| p1.followers_count}.compact.sum
+      end
+      
       # Deletes the record with the given id from the collection.
       def delete(id)
         collection.remove({:_id => id})
@@ -407,22 +459,38 @@ module MongoRecord
         args.last.is_a?(Hash) ? args.pop : {}
       end
 
+      # def find_initial(options)
+      #   criteria = criteria_from(options[:conditions]).merge!(where_func(options[:where]))
+      #   fields = fields_from(options[:select])
+      #   row = collection.find_first(criteria, :fields => fields)
+      #   (row.nil? || row['_id'] == nil) ? nil : self.new(row)
+      # end
+      
       def find_initial(options)
-        criteria = criteria_from(options[:conditions]).merge!(where_func(options[:where]))
-        fields = fields_from(options[:select])
-        row = collection.find_first(criteria, :fields => fields)
-        (row.nil? || row['_id'] == nil) ? nil : self.new(row)
+        options[:limit] = 1
+        options[:order] = 'created_at asc'
+        row = find_every(options)
+        row.to_a[0]
       end
 
-      def find_every(options)
-        criteria = criteria_from(options[:conditions]).merge!(where_func(options[:where]))
+      def find_last(options)
+        options[:limit] = 1
+        options[:order] = 'created_at desc'
+        row = find_every(options)
+        row.to_a[0]
+      end
 
+      def find_every(options)
+        options.symbolize_keys!
+        criteria = criteria_from(options[:conditions], options[:criteria]).merge!(where_func(options[:where]))
+                
         find_options = {}
         find_options[:fields] = fields_from(options[:select]) if options[:select]
         find_options[:limit] = options[:limit].to_i if options[:limit]
         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
@@ -434,7 +502,8 @@ module MongoRecord
         ids = ids.to_a.flatten.compact.uniq
         raise RecordNotFound, "Couldn't find #{name} without an ID" unless ids.length > 0
 
-        criteria = criteria_from(options[:conditions]).merge!(where_func(options[:where]))
+        criteria = criteria_from(options[:conditions], options[:criteria]).merge!(where_func(options[:where]))
+        criteria.merge!(options[:criteria]) unless options[:criteria].nil?
         criteria[:_id] = ids_clause(ids)
         fields = fields_from(options[:select])
 
@@ -446,6 +515,8 @@ module MongoRecord
           find_options = {}
           find_options[:fields] = fields if fields
           find_options[:sort] = sort_by_from(options[:order]) if options[:order]
+          find_options[:limit] = options[:limit].to_i if options[:limit]
+          find_options[:offset] = options[:offset].to_i if options[:offset]
 
           cursor = collection.find(criteria, find_options)
 
@@ -456,7 +527,13 @@ module MongoRecord
       end
 
       def ids_clause(ids)
-        ids.length == 1 ? ids[0].to_oid : {'$in' => ids.collect{|id| id.to_oid}}
+        #ids.length == 1 ? ids[0].to_oid : {'$in' => ids.collect{|id| id.to_oid}}
+        
+        if ids.length == 1 
+          ids[0].is_a?(String) ? ids[0].to_oid : ids[0]
+        else 
+          {'$in' => ids.collect{|id| id.is_a?(String) ? id.to_oid : id}}
+        end
       end
 
       # Returns true if all field_names are in @field_names.
@@ -490,17 +567,20 @@ module MongoRecord
       #   ["name='%s' and group_id='%s'", "foo'bar", 4]  returns  {:name => 'foo''bar', :group_id => 4}
       #   "name='foo''bar' and group_id='4'" returns {:name => 'foo''bar', :group_id => 4}
       #   { :name => "foo'bar", :group_id => 4 }  returns the hash, modified for Mongo
-      def criteria_from(condition) # :nodoc:
+      def criteria_from(condition, criteria={}) # :nodoc:
         case condition
         when Array
-          criteria_from_array(condition)
+          opts = criteria_from_array(condition)
         when String
-          criteria_from_string(condition)
+          opts = criteria_from_string(condition)
         when Hash
-          criteria_from_hash(condition)
+          opts = criteria_from_hash(condition)
         else
-          {}
-        end
+          opts = {}
+        end        
+        opts ||= {}
+        criteria ||= {}
+        opts.merge!(criteria)
       end
 
       # Substitutes values at the end of an array into the string at its
@@ -529,11 +609,11 @@ module MongoRecord
         condition.each { |k,v|
           h[k] = case v
                  when Array
-                   {'$in' => k == 'id' || k == '_id' ? v.collect{ |val| val.to_oid} : v} # if id, can't pass in string; must be ObjectID
+                   {'$in' => v}
                  when Range
                    {'$gte' => v.first, '$lte' => v.last}
                  else
-                   k == 'id' || k == '_id' ? v.to_oid : v
+                   v
                  end
         }
         h
@@ -691,7 +771,7 @@ module MongoRecord
 
     # Save self and returns true if the save was successful, false if not.
     def save
-      create_or_update
+      create_or_update      
     end
 
     # Save self and returns true if the save was successful and raises
@@ -702,23 +782,31 @@ module MongoRecord
 
     # Return true if this object is new---that is, does not yet have an id.
     def new_record?
-      @_id == nil
+      @_id.nil? || self.class.collection.find_first("_id" => @_id).nil?
     end
 
     # Convert this object to a Mongo value suitable for saving to the
     # database.
     def to_mongo_value
       h = {}
-      self.class.mongo_ivar_names.each {|iv| h[iv] = instance_variable_get("@#{iv}").to_mongo_value }
+#      self.class.mongo_ivar_names.each {|iv| h[iv] = instance_variable_get("@#{iv}").to_mongo_value }
+      mongo_values = self.instance_values
+      # If the "_id" value is not set but an "id" value is, set "_id" equal to "id"
+      if mongo_values["_id"].nil? && !mongo_values["id"].nil?
+        mongo_values["_id"] = mongo_values["id"]
+      end
+      key_names = mongo_values.keys + self.class.subobjects.keys + self.class.arrays.keys
+      key_names.each {|key| h[key] = instance_variable_get("@#{key}").to_mongo_value }
       h
     end
 
     # Save self to the database and set the id.
     def create
-      set_create_times
+      create_date = self.instance_variable_defined?("@created_at") ? self.created_at : nil
+      set_create_times(create_date)
       with_id = self.class.collection.insert(to_mongo_value)
       @_id = with_id['_id'] || with_id[:_id]
-      self
+      with_id
     end
 
     # Save self to the database. Return +false+ if there was an error,
@@ -729,7 +817,7 @@ module MongoRecord
       if self.class.collection.db.error?
         return false
       end
-      self
+      self      
     end
 
     # Remove self from the database and set @_id to nil. If self has no
@@ -748,6 +836,24 @@ module MongoRecord
       freeze
     end
 
+    def [](attr_name)
+      self.send(attr_name)
+    end
+    
+    def []=(attr_name, value)
+      self.class.field(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)
+        return self.send(sym)
+      else
+        super
+      end
+    end
+   
     #--
     # ================================================================
     # These methods exist so we can plug in ActiveRecord validation, etc.
@@ -760,7 +866,7 @@ module MongoRecord
     # made with this method doesn't get subjected to validation checks.
     # Hence, attributes can be updated even if the full object isn't valid.
     def update_attribute(name, value)
-      send(name.to_s + '=', value)
+      self[name] = value
       save
     end
 
@@ -768,8 +874,9 @@ module MongoRecord
     # record. If the object is invalid, the saving will fail and false will
     # be returned.
     def update_attributes(attributes)
-      self.attributes = attributes
-      save
+      attributes.each do |name, value|
+        update_attribute(name, value)
+      end
     end
 
     # Updates an object just like Base.update_attributes but calls save!
@@ -784,6 +891,17 @@ module MongoRecord
 
     # ================================================================
 
+    def set_create_times(t=nil)
+      t ||= Time.now
+      t = Time.parse(t) if t.is_a?(String)
+      self["created_at"] = t
+      self["created_on"] = Time.local(t.year, t.month, t.day)
+      self.class.subobjects.keys.each { |iv|
+        val = instance_variable_get("@#{iv}")
+        val.send(:set_create_times, t) if val
+      }
+    end
+
     private
 
     def create_or_update
@@ -805,32 +923,10 @@ module MongoRecord
       end
     end
 
-    def set_create_times(t=nil)
-      t ||= Time.now
-      self.class.field_names.each { |iv|
-        case iv
-        when :created_at
-          instance_variable_set("@#{iv}", t)
-        when :created_on
-          instance_variable_set("@#{iv}", Time.local(t.year, t.month, t.day))
-        end
-      }
-      self.class.subobjects.keys.each { |iv|
-        val = instance_variable_get("@#{iv}")
-        val.send(:set_create_times, t) if val
-      }
-    end
-
     def set_update_times(t=nil)
       t ||= Time.now
-      self.class.field_names.each { |iv|
-        case iv
-        when :updated_at
-          instance_variable_set("@#{iv}", t)
-        when :updated_on
-          instance_variable_set("@#{iv}", Time.local(t.year, t.month, t.day))
-        end
-      }
+      self["updated_at"] = t
+      self["updated_on"] = Time.local(t.year, t.month, t.day)
       self.class.subobjects.keys.each { |iv|
         val = instance_variable_get("@#{iv}")
         val.send(:set_update_times, t) if val

data/lib/mongo_record/convert.rb

@@ -24,6 +24,15 @@ class Object
   def to_mongo_value
     self
   end
+  
+  # From Rails
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+  
 end
 
 class Array
@@ -42,4 +51,16 @@ class Hash
     self.each {|k,v| h[k] = v.to_mongo_value}
     h
   end
+
+  # Same symbolize_keys method used in Rails
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
 end

data/mongo-activerecord-ruby.gemspec

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

data/tests/test_mongo.rb

@@ -23,7 +23,7 @@ require File.join(File.dirname(__FILE__), 'class_in_module')
 
 class Track < MongoRecord::Base
   collection_name :tracks
-  fields :artist, :album, :song, :track
+  fields :artist, :album, :song, :track, :created_at
   def to_s
     # Uses both accessor methods and ivars themselves
     "artist: #{artist}, album: #{album}, song: #@song, track: #{@track ? @track.to_i : nil}"
@@ -39,6 +39,11 @@ class Rubytest < MongoRecord::Base
   end
 end
 
+# Class without any fields defined to test inserting custom attributes
+class Playlist < MongoRecord::Base
+  collection_name :playlists
+end
+
 class MongoTest < Test::Unit::TestCase
 
   @@host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
@@ -47,6 +52,7 @@ class MongoTest < Test::Unit::TestCase
   @@students = @@db.collection('students')
   @@courses = @@db.collection('courses')
   @@tracks = @@db.collection('tracks')
+  @@playlists = @@db.collection('playlists')
 
   def setup
     super
@@ -55,6 +61,7 @@ class MongoTest < Test::Unit::TestCase
     @@students.clear
     @@courses.clear
     @@tracks.clear
+    @@playlists.clear
 
     # Manually insert data without using MongoRecord::Base
     @@tracks.insert({:_id => XGen::Mongo::Driver::ObjectID.new, :artist => 'Thomas Dolby', :album => 'Aliens Ate My Buick', :song => 'The Ability to Swing'})
@@ -80,6 +87,7 @@ class MongoTest < Test::Unit::TestCase
     @@students.clear
     @@courses.clear
     @@tracks.clear
+    @@playlists.clear
     super
   end
 
@@ -131,6 +139,13 @@ class MongoTest < Test::Unit::TestCase
     assert_equal(@mayor_str, Track.find_by_id(@mayor_id).to_s)
   end
 
+  def test_find_by_custom_id
+    @@tracks.insert({:_id => 25, :artist => 'Mike D', :album => 'Awesome Blossom', :song => 'Hello World', :track => 5})
+    assert_equal("artist: Mike D, album: Awesome Blossom, song: Hello World, track: 5",
+                 Track.find_by_id(25).to_s)
+
+  end
+
   def test_find_by_song
     assert_equal("artist: Thomas Dolby, album: Aliens Ate My Buick, song: Budapest by Blimp, track: ", Track.find_by_song('Budapest by Blimp').to_s)
   end
@@ -149,7 +164,7 @@ class MongoTest < Test::Unit::TestCase
   def test_find_all
     assert_all_songs Track.find(:all).inject('') { |str, t| str + t.to_s }
   end
-
+  
   def test_find_using_hash
     str = Track.find(:all, :conditions => {:album => 'Aliens Ate My Buick'}).inject('') { |str, t| str + t.to_s }
     assert_match(/song: The Ability to Swing/, str)
@@ -207,6 +222,7 @@ class MongoTest < Test::Unit::TestCase
     x = Track.new(:artist => 'Level 42', :album => 'Standing In The Light', :song => 'Micro-Kid', :track => 1)
     assert_nil(x.id)
     assert x.save, "x.save returned false; expected true"
+    x = Track.last
     assert_not_nil(x.id)
     z = Track.find(x.id)
     assert_equal(x.to_s, z.to_s)
@@ -233,16 +249,16 @@ class MongoTest < Test::Unit::TestCase
 
   def test_raise_error_if_bogus_id
     Track.find("bogus_id")
-    fail 'expected "invalid ObjectID" exception'
+    fail 'expected "find Track with ID=bogus_id" exception'
   rescue => ex
-    assert_match /illegal ObjectID format/, ex.to_s
+    assert_match /find Track with ID=bogus_id/, ex.to_s
   end
 
   def test_raise_error_if_first_and_bogus_id_in_hash
     Track.find(:first, :conditions => {:_id => "bogus_id"})
-    fail 'expected "invalid ObjectID" exception'
+    fail 'expected "find Track with ID=bogus_id" exception'
   rescue => ex
-    assert_match /invalid ObjectID/, ex.to_s
+    assert_match /find Track with ID=bogus_id/, ex.to_s
   end
 
   def test_find_options
@@ -621,6 +637,13 @@ class MongoTest < Test::Unit::TestCase
       assert_match /undefined method \`foobar\' for Track:Class/, ex.to_s
     end
   end
+  
+  def test_adding_custom_attributes
+    s = Student.new(:silly_name => 'Yowza!')
+    s.save
+    s = Student.last
+    assert_equal s.silly_name, 'Yowza!'
+  end
 
   def assert_all_songs(str)
     assert_match(/song: The Ability to Swing/, str)
@@ -630,5 +653,76 @@ class MongoTest < Test::Unit::TestCase
     assert_match(/song: The Mayor Of Simpleton/, str)
     assert_match(/song: King For A Day/, str)
   end
+  
+  
+  #################  
+  
+  
+  def test_find_all_alias
+    assert_all_songs Track.all.inject('') { |str, t| str + t.to_s }
+  end  
+  
+  def test_find_first_alias
+    t = Track.first
+    assert t.kind_of?(Track)
+    str = t.to_s
+    assert_match(/artist: [^,]+,/, str, "did not find non-empty artist name")
+  end
+  
+  def test_find_last
+    c = Course.new(:name=>"History")
+    c.save
+    assert_equal Course.last.name, "History"
+  end
+
+  def test_new_and_save_custom_attributes
+    x = Playlist.new(:artist => 'Level 42', :album => 'Standing In The Light', :song => 'Micro-Kid', :track => 1)
+    assert_nil(x.id)
+    x.save
+    x = Playlist.last
+    assert_not_nil(x.id)
+    assert_equal(x.artist, "Level 42")
+    assert_not_nil(x.created_at)
+    assert_not_nil(x.created_on)
+  end
+
+  def test_update_for_custom_attributes
+    p = Playlist.create(:artist => "The Beatles", :song => "Jailhouse Rock")
+    count = Playlist.count
+    p = Playlist.last
+    assert_equal(p.artist, "The Beatles")
+    p.artist = "Elvis"
+    p.save
+    assert_not_nil(p.updated_at)
+    assert_not_nil(p.updated_on)
+    assert_equal(count, Playlist.count)
+  end
+
+  
+  def test_update_attributes
+    opts = {:artist => 'Bon Jovi', :album => 'Slippery When Wet', :song => 'Livin On A Prayer'}
+    track = Track.new
+    track.update_attributes(opts)
+    t = Track.find_by_artist("Bon Jovi")
+    assert_equal(t.album, "Slippery When Wet")
+  end
+  
+  def test_update_attributes_for_custom_attributes
+    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")
+    assert_equal(p.year, 1986)
+  end
+  
+  def test_custom_id
+    track = Track.new
+    track.id = 123
+    track.artist = "Nickleback"
+    track.song = "Rockstar"
+    track.save
+    p = Track.find(123)
+    assert_equal p.artist, "Nickleback"
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongodb-mongo_record
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: "0.2"
 platform: ruby
 authors: 
 - Jim Menard