Adds cache option to remap and use in research

There is a mismatch between the caching of transformed objects in the
`remap` function and the need for `research` to traverse all sub
trees. For most values this is inconsequential (like atomic ints,
etc.) but for small tuples (e.g. `("hello",)`) these get compiled as
the same value and return the same `id(...)`. In `remap` these get
cached and never get `enter` called on them and thus the hooks for
`research` to return the values never gets called.

In this fix an option to disable/enable the cache is introduced to the
`remap` function which simply disables using transformed values from
the cache. Then in the `research` function caching is turned off.

The existing `remap` behavior is maintained as caching by default is
turned on.

fixes: #393

Author: salotz

boltons/iterutils.py

@@ -1055,8 +1055,14 @@ def default_exit(path, key, old_parent, new_parent, new_items):
     return ret
 
 
-def remap(root, visit=default_visit, enter=default_enter, exit=default_exit,
-          **kwargs):
+def remap(
+        root,
+        visit=default_visit,
+        enter=default_enter,
+        exit=default_exit,
+        cache: bool = True,
+        **kwargs,
+):
     """The remap ("recursive map") function is used to traverse and
     transform nested structures. Lists, tuples, sets, and dictionaries
     are just a few of the data structures nested into heterogeneous
@@ -1130,6 +1136,10 @@ def remap(root, visit=default_visit, enter=default_enter, exit=default_exit,
             :class:`namedtuple`, must be recreated from scratch, but
             use the same type as the new parent passed back from the
             *enter* function.
+        cache (bool): Controls whether to cache transformed
+            objects. Uses object identity for the cache. For example
+            this is turned off for applications like `research` which
+            need to traverse all trees.
         reraise_visit (bool): A pragmatic convenience for the *visit*
             callable. When set to ``False``, remap ignores any errors
             raised by the *visit* callback. Items causing exceptions
@@ -1195,7 +1205,7 @@ def remap(root, visit=default_visit, enter=default_enter, exit=default_exit,
             registry[id_value] = value
             if not new_items_stack:
                 continue
-        elif id_value in registry:
+        elif cache and id_value in registry:
             value = registry[id_value]
         else:
             if trace_enter:
@@ -1388,7 +1398,7 @@ def _enter(path, key, value):
                 raise
         return enter(path, key, value)
 
-    remap(root, enter=_enter)
+    remap(root, enter=_enter, cache=False)
     return ret
 
 

tests/test_iterutils.py

@@ -395,6 +395,24 @@ def broken_query(p, k, v):
     # empty results with default, reraise=False
     assert research(root, broken_query) == []
 
+    # test that different branches with object identical values are
+    # still traversed and returned
+    literal_tree = {
+            "maybe" : ("hello",),
+            "another" : ("hello",),
+        }
+
+    assert id(literal_tree["maybe"]) == id(literal_tree["another"])
+    assert research(
+        root=literal_tree,
+    ) == [
+        ((None,), literal_tree),
+        (("maybe",), ("hello",)),
+        (("maybe", 0,), "hello"),
+        (("another",), ("hello",)),
+        (("another", 0,), "hello"),
+    ]
+
 
 def test_research_custom_enter():
     # see #368