Rip out 'Query.clone' method.

tseaver · tseaver · commit 2832ce5c3f10 · 2015-01-05T17:35:15.000-05:00
Also, remove other mentions of cloning queries on write.
diff --git a/gcloud/datastore/query.py b/gcloud/datastore/query.py
@@ -83,38 +83,6 @@ def __init__(self,
         self._order = list(order)
         self._group_by = list(group_by)
 
-    def clone(self, **kw):
-        """Create a new Query, copying self,
-
-        :type kw: dict, name->value.
-        :param kw: Replace properties in the copied query with those specified
-                   in ``kw``.
-
-        :rtype: :class:`gcloud.datastore.query.Query`
-        """
-        kind = kw.pop('kind', self._kind)
-        dataset = kw.pop('dataset', self._dataset)
-        namespace = kw.pop('namespace', self._namespace)
-        ancestor = kw.pop('ancestor', self._ancestor)
-        filters = kw.pop('filters', self._filters)
-        projection = kw.pop('projection', self._projection)
-        order = kw.pop('order', self._order)
-        group_by = kw.pop('group_by', self._group_by)
-
-        if kw:
-            raise TypeError("Unknown properties: %s" % ','.join(kw))
-
-        return self.__class__(
-            kind=kind,
-            dataset=dataset,
-            namespace=namespace,
-            ancestor=ancestor,
-            filters=filters,
-            projection=projection,
-            order=order,
-            group_by=group_by,
-            )
-
     @property
     def dataset(self):
         """Get the dataset for this Query.
@@ -161,8 +129,6 @@ def kind(self):
         """Get the Kind of the Query.
 
         :rtype: string or :class:`Query`
-        :returns: If `kind` is None, returns the kind. If a kind is provided,
-                  returns a clone of the :class:`Query` with that kind set.
         """
         return self._kind
 
@@ -221,26 +187,17 @@ def filters(self):
     def add_filter(self, property_name, operator, value):
         """Filter the query based on a property name, operator and a value.
 
-        This will return a clone of the current :class:`Query`
-        filtered by the expression and value provided.
-
         Expressions take the form of::
 
-          .filter('<property>', '<operator>', <value>)
+          .add_filter('<property>', '<operator>', <value>)
 
         where property is a property stored on the entity in the datastore
         and operator is one of ``OPERATORS``
         (ie, ``=``, ``<``, ``<=``, ``>``, ``>=``)::
 
           >>> query = Query('Person')
-          >>> filtered_query = query.filter('name', '=', 'James')
-          >>> filtered_query = query.filter('age', '>', 50)
-
-        Because each call to ``.filter()`` returns a cloned ``Query`` object
-        we are able to string these together::
-
-          >>> query = Query('Person').filter(
-          ...     'name', '=', 'James').filter('age', '>', 50)
+          >>> query.add_filter('name', '=', 'James')
+          >>> query.add_filter('age', '>', 50)
 
         :type property_name: string
         :param property_name: A property name.
diff --git a/gcloud/datastore/test_query.py b/gcloud/datastore/test_query.py
@@ -75,63 +75,6 @@ def test_ctor_explicit(self):
         self.assertEqual(query.order, ORDER)
         self.assertEqual(query.group_by, GROUP_BY)
 
-    def test_clone_wo_kw(self):
-        from gcloud.datastore.dataset import Dataset
-        _DATASET = 'DATASET'
-        _KIND = 'KIND'
-        _NAMESPACE = 'NAMESPACE'
-        dataset = Dataset(_DATASET)
-        query = self._makeOne(_KIND, dataset, _NAMESPACE)
-        clone = query.clone()
-        self.assertFalse(clone is query)
-        self.assertTrue(isinstance(clone, self._getTargetClass()))
-        self.assertTrue(clone.dataset is dataset)
-        self.assertEqual(clone.namespace, _NAMESPACE)
-        self.assertEqual(clone.kind, _KIND)
-
-    def test_clone_w_unknown_kw(self):
-        from gcloud.datastore.dataset import Dataset
-        _DATASET = 'DATASET'
-        _KIND = 'KIND'
-        _NAMESPACE = 'NAMESPACE'
-        dataset = Dataset(_DATASET)
-        query = self._makeOne(_KIND, dataset, _NAMESPACE)
-        self.assertRaises(TypeError, query.clone, nonesuch='Foo')
-
-    def test_clone_w_kw(self):
-        from gcloud.datastore.dataset import Dataset
-        from gcloud.datastore.key import Key
-        _DATASET = 'DATASET'
-        _KIND = 'KIND'
-        _NAMESPACE = 'NAMESPACE'
-        dataset = Dataset(_DATASET)
-        ancestor = Key('ANCESTOR', 123, dataset_id=_DATASET)
-        FILTERS = [('foo', '=', 'Qux'), ('bar', '<', 17)]
-        PROJECTION = ['foo', 'bar', 'baz']
-        ORDER = ['foo', 'bar']
-        GROUP_BY = ['foo']
-        query = self._makeOne(_KIND, dataset, _NAMESPACE)
-        clone = query.clone(
-            kind=_KIND,
-            dataset=dataset,
-            namespace=_NAMESPACE,
-            ancestor=ancestor,
-            filters=FILTERS,
-            projection=PROJECTION,
-            order=ORDER,
-            group_by=GROUP_BY,
-        )
-        self.assertFalse(clone is query)
-        self.assertTrue(isinstance(clone, self._getTargetClass()))
-        self.assertTrue(clone.dataset is dataset)
-        self.assertEqual(clone.namespace, _NAMESPACE)
-        self.assertEqual(clone.kind, _KIND)
-        self.assertEqual(clone.ancestor.path, ancestor.path)
-        self.assertEqual(clone.filters, FILTERS)
-        self.assertEqual(clone.projection, PROJECTION)
-        self.assertEqual(clone.order, ORDER)
-        self.assertEqual(clone.group_by, GROUP_BY)
-
     def test_dataset_setter_w_non_dataset(self):
         query = self._makeOne()
 
