rename addToSet -> add_to_set

Author: eguven

docs/index.rst

@@ -96,7 +96,7 @@ $addToSet
 
 MongoDB ``$addToSet`` update modifier is very useful. nanomongo implements it.
 
-:meth:`~.document.BaseDocument.addToSet()` will do the `add-to-field-if-doesnt-exist`
+:meth:`~.document.BaseDocument.add_to_set()` will do the `add-to-field-if-doesnt-exist`
 on your document instance and record the change to be applied later when
 :meth:`~.document.BaseDocument.save()` is called.
 
@@ -114,11 +114,11 @@ on your document instance and record the change to be applied later when
     doc = NewDoc.find_one({'_id': doc_id})
     # {'_id': ObjectId('...'), 'dict_field': {'foo': []}, 'list_field': [42]}
 
-    doc.addToSet('list_field', 1337)
-    doc.addToSet('dict_field.foo', 'like a boss')
+    doc.add_to_set('list_field', 1337)
+    doc.add_to_set('dict_field.foo', 'like a boss')
     doc.save()
 
-Both of the above ``addToSet`` are applied to the ``NewDoc`` instance like MongoDB does it eg.
+Both of the above ``add_to_set`` calls are applied to the ``NewDoc`` instance like MongoDB does it eg.
 
   - create list field with new value if it doesn't exist
   - add new value to list field if it's missing (append)
@@ -133,7 +133,7 @@ When save is called, the following is called::
 
 Undefined fields or field type mismatch raises :class:`~.errors.ValidationError`::
 
-    doc.addToSet('dict_field.foo', 'like a boss')
+    doc.add_to_set('dict_field.foo', 'like a boss')
     ValidationError: Cannot apply $addToSet modifier to non-array: dict_field=<class 'dict'>
 
 QuerySpec check
@@ -189,7 +189,7 @@ register the document class with a ``motor.MotorClient``.
     # and now some async motor queries (using @gen.engine)
     doc_id = yield motor.Op(MyDoc(foo=42).insert)
     doc = yield motor.Op(MyDoc.find_one, {'foo': 42})
-    doc.addToSet('bar', 1337)
+    doc.add_to_set('bar', 1337)
     yield motor.Op(doc.save)
 
 **Note** however that pymongo vs motor behaviour is not necessarily identical.

examples/example.py

@@ -45,7 +45,7 @@ def follow(self, *categories):
         assert categories, 'categories expected'
         for category in categories:
             assert (category and isinstance(category, six.text_type)), 'category not str or emtpy'
-            self.addToSet('following', category)
+            self.add_to_set('following', category)
         self.save()
 
     def get_entries(self, **kwargs):
@@ -100,7 +100,7 @@ def add_comment(self, text, author):
         assert (author and isinstance(author, User)), 'second argument not an instance of User'
         doc = {'text': text, 'author': author.name, 'created': datetime.utcnow()}
         # TODO: push is more appropriate in this situation, add when implemented
-        self.addToSet('comments', doc)
+        self.add_to_set('comments', doc)
         # we could have also done self.comments = self.comments + [doc]
         self.save()
         return text

nanomongo/document.py

@@ -431,7 +431,7 @@ def save(self, **kwargs):
         self.reset_diff()
         return update_result
 
-    def addToSet(self, field, value):
+    def add_to_set(self, field, value):
         """
         Explicitly defined ``$addToSet`` functionality. This sets/updates the field value accordingly
         and records the change to be saved with :meth:`~save()`.
@@ -440,15 +440,14 @@ def addToSet(self, field, value):
             # MongoDB style dot notation can be used to add to lists
             # in embedded documents
             doc = Doc(foo=[], bar={})
-            doc.addToSet('foo', new_value)
+            doc.add_to_set('foo', new_value)
 
         Contrary to how ``$set`` ing the same value has no effect under __setitem__ (see
-        ``.util.RecordingDict.__setitem__()``), when the new value is equal to the current;
-        ``addToSet()`` explicitly records the change so it will be sent to the
-        database when :meth:`~save()` is called.
+        ``.util.RecordingDict.__setitem__()``) when the new value is equal to the current, this
+        explicitly records the change so it will be sent to the database when :meth:`~save()` is called.
         """
-        # TODO: rename to add_to_set
-        # TODO: doc.addToSet('bar.sub_field', new_value) doesn't actually work
+
+        # TODO: doc.add_to_set('bar.sub_field', new_value) doesn't actually work
         def top_level_add(self, field, value):
             """add the value to field. appending if the list exists and
             does not contain the value; create new list otherwise.

nanomongo/util.py

@@ -151,7 +151,7 @@ def get_sub_diff(self):
     def check_can_update(self, modifier, field_name):
         """Check if given `modifier` `field_name` combination can be
         added. MongoDB does not allow field duplication with update
-        modifiers. This is to be used with methods :meth:`~.document.BaseDocument.addToSet()` ...
+        modifiers. This is to be used with methods :meth:`~.document.BaseDocument.add_to_set()` ...
         """
         for mod, updates in self.__nanodiff__.items():
             if mod == modifier:

test/test_document.py

@@ -294,8 +294,8 @@ class Doc(BaseDocument):
         self.assertRaises(ValidationError, d.save)
 
     @unittest.skipUnless(PYMONGO_CLIENT, 'pymongo not installed or connection refused')
-    def test_partial_update_addToSet(self):
-        """Pymongo: addToSet functionality with `save`"""
+    def test_partial_update_add_to_set(self):
+        """Pymongo: $addToSet functionality with `save`"""
 
         class Doc(BaseDocument):
             dot_notation = True
@@ -304,28 +304,28 @@ class Doc(BaseDocument):
             moo = Field(six.text_type)
         Doc.register(client=PYMONGO_CLIENT, db=TEST_DBNAME)
 
-        self.assertRaises(ValidationError, Doc().addToSet, *('$fail', 42))
-        self.assertRaises(ValidationError, Doc().addToSet, *('bar.$1', 42))
+        self.assertRaises(ValidationError, Doc().add_to_set, *('$fail', 42))
+        self.assertRaises(ValidationError, Doc().add_to_set, *('bar.$1', 42))
         # use dict.__setitem__ to bypass RecordingDict cast at self.__setitem__
         d = Doc()
         dict.__setitem__(d, 'bar', {})
         self.assertEqual(dict, type(d.bar))  # not RecordingDict
-        self.assertRaises(ValidationError, d.addToSet, *('bar.1', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('bar.1', 42))
         d = Doc(foo=['foo_1', 'foo_2'], bar={'1': 'bar_1', '2': []}, moo=six.u('moo val'))
         d.insert()
-        self.assertRaises(ValidationError, d.addToSet, *('moo', 42))
-        self.assertRaises(ValidationError, d.addToSet, *('moo.not_dict', 42))
-        self.assertRaises(ValidationError, d.addToSet, *('undefined.field', 42))
-        self.assertRaises(UnsupportedOperation, d.addToSet, *('bar.a.b', 42))
-        d.addToSet('foo', 'foo_1')
+        self.assertRaises(ValidationError, d.add_to_set, *('moo', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('moo.not_dict', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('undefined.field', 42))
+        self.assertRaises(UnsupportedOperation, d.add_to_set, *('bar.a.b', 42))
+        d.add_to_set('foo', 'foo_1')
         d.moo = six.u('new moo')
-        d.addToSet('foo', 'foo_3')
-        d.addToSet('foo', 'foo_1')
-        d.addToSet('bar.2', 'L33t')
-        d.addToSet('bar.3', 'new_1')
-        d.addToSet('bar.3', 'new_1')
-        d.addToSet('bar.3', 'new_2')
-        self.assertRaises(ValidationError, d.addToSet, *('bar.1', 1))
+        d.add_to_set('foo', 'foo_3')
+        d.add_to_set('foo', 'foo_1')
+        d.add_to_set('bar.2', 'L33t')
+        d.add_to_set('bar.3', 'new_1')
+        d.add_to_set('bar.3', 'new_1')
+        d.add_to_set('bar.3', 'new_2')
+        self.assertRaises(ValidationError, d.add_to_set, *('bar.1', 1))
         topdiff = {'$set': {'moo': 'new moo'}, '$unset': {},
                    '$addToSet': {'foo': {'$each': ['foo_1', 'foo_3']}}}
         subdiff = {'$set': {}, '$unset': {},
@@ -337,20 +337,20 @@ class Doc(BaseDocument):
         d.save()
         d_db = Doc.find_one()
         self.assertTrue(d_copy == d == d_db)
-        # check against field duplication at addToSet
+        # check against field duplication at $addToSet
         d = Doc()
         d.foo = [42]  # set -- top-level $addToSet will clash
         self.assertEqual([42], d.__nanodiff__['$set']['foo'])
-        self.assertRaises(ValidationError, d.addToSet, *('foo', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('foo', 42))
         del d.foo  # unset -- top-level $addToSet will clash
-        self.assertRaises(ValidationError, d.addToSet, *('foo', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('foo', 42))
         d = Doc(bar={})
         d.bar['1'] = [42]  # deep-level set -- dotted $addToSet will clash
-        self.assertRaises(ValidationError, d.addToSet, *('bar.1', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('bar.1', 42))
         d = Doc()
         d.bar = {'1': [42]}  # dict set on top-level -- dotted $addToSet will clash
         self.assertEqual({'bar': {'1': [42]}}, d.__nanodiff__['$set'])
-        self.assertRaises(ValidationError, d.addToSet, *('bar.1', 42))
+        self.assertRaises(ValidationError, d.add_to_set, *('bar.1', 42))
 
         class Doc2(BaseDocument):
             dot_notation = True
@@ -359,8 +359,8 @@ class Doc2(BaseDocument):
         Doc2.register(client=PYMONGO_CLIENT, db=TEST_DBNAME)
         dd = Doc2()
         dd.insert()
-        # addToSet on unset field
-        dd.addToSet('optional.sub', 42)
+        # $addToSet on unset field
+        dd.add_to_set('optional.sub', 42)
         self.assertEqual([42], dd.optional['sub'])
         self.assertEqual({'sub': {'$each': [42]}}, dd.optional.__nanodiff__['$addToSet'])
         dd.save()