Merge lp:~gz/brz/unlazy_reg into lp:brz

[Martin Packman]

Remove replacement of re.compile for lazy_regexp

Remove replacement of re.compile for lazy_regexp

On a typical invocation less than 10 regexp compilations are avoided
and most of those are in configobj. This is less than a millisecond
saving in general, which makes the complexity and other potential
issues with monkey patching probably not worth while.

Leave the LazyRegexp proxy object around which is used in various
places and generally harmless when expected.

[Jelmer Vernooij (jelmer)]

review: Approve

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/48/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/brz/job/brz-land/50/

=== modified file 'breezy/__init__.py'
--- breezy/__init__.py	2018-11-11 04:08:32 +0000
+++ breezy/__init__.py	2018-11-16 19:10:57 +0000
@@ -112,18 +112,6 @@
     return main_version + sub_string
 
 
-# lazy_regex import must be done after _format_version_tuple definition
-# to avoid "no attribute '_format_version_tuple'" error when using
-# deprecated_function in the lazy_regex module.
-if getattr(sys, '_brz_lazy_regex', False):
-    # The 'brz' executable sets _brz_lazy_regex.  We install the lazy regex
-    # hack as soon as possible so that as much of the standard library can
-    # benefit, including the 'string' module.
-    del sys._brz_lazy_regex
-    import breezy.lazy_regex
-    breezy.lazy_regex.install_lazy_compile()
-
-
 __version__ = _format_version_tuple(version_info)
 version_string = __version__
 

=== modified file 'breezy/lazy_regex.py'
--- breezy/lazy_regex.py	2018-11-16 18:59:44 +0000
+++ breezy/lazy_regex.py	2018-11-16 19:10:57 +0000
@@ -54,7 +54,7 @@
     __slots__ = ['_real_regex', '_regex_args', '_regex_kwargs',
                  ] + _regex_attributes_to_copy
 
-    def __init__(self, args=(), kwargs={}):
+    def __init__(self, args, kwargs):
         """Create a new proxy object, passing in the args to pass to re.compile
 
         :param args: The `*args` to pass to re.compile
@@ -74,7 +74,7 @@
     def _real_re_compile(self, *args, **kwargs):
         """Thunk over to the original re.compile"""
         try:
-            return _real_re_compile(*args, **kwargs)
+            return re.compile(*args, **kwargs)
         except re.error as e:
             # raise InvalidPattern instead of re.error as this gives a
             # cleaner message to the user.
@@ -111,40 +111,3 @@
     :return: a LazyRegex proxy object.
     """
     return LazyRegex(args, kwargs)
-
-
-def install_lazy_compile():
-    """Make lazy_compile the default compile mode for regex compilation.
-
-    This overrides re.compile with lazy_compile. To restore the original
-    functionality, call reset_compile().
-    """
-    re.compile = lazy_compile
-
-
-def reset_compile():
-    """Restore the original function to re.compile().
-
-    It is safe to call reset_compile() multiple times, it will always
-    restore re.compile() to the value that existed at import time.
-    Though the first call will reset back to the original (it doesn't
-    track nesting level)
-    """
-    re.compile = _real_re_compile
-
-
-_real_re_compile = re.compile
-if _real_re_compile is lazy_compile:
-    raise AssertionError(
-        "re.compile has already been overridden as lazy_compile, but this "
-        "would cause infinite recursion")
-
-
-# Some libraries calls re.finditer which fails it if receives a LazyRegex.
-if getattr(re, 'finditer', False):
-    def finditer_public(pattern, string, flags=0):
-        if isinstance(pattern, LazyRegex):
-            return pattern.finditer(string)
-        else:
-            return _real_re_compile(pattern, flags).finditer(string)
-    re.finditer = finditer_public

=== modified file 'breezy/log.py'
--- breezy/log.py	2018-11-16 18:33:17 +0000
+++ breezy/log.py	2018-11-16 19:10:57 +0000
@@ -65,6 +65,7 @@
     controldir,
     diff,
     foreign,
+    lazy_regex,
     revision as _mod_revision,
     )
 from breezy.i18n import gettext, ngettext
@@ -907,7 +908,8 @@
     """
     if not match:
         return log_rev_iterator
-    searchRE = [(k, [re.compile(x, re.IGNORECASE) for x in v])
+    # Use lazy_compile so mapping to InvalidPattern error occurs.
+    searchRE = [(k, [lazy_regex.lazy_compile(x, re.IGNORECASE) for x in v])
                 for k, v in match.items()]
     return _filter_re(searchRE, log_rev_iterator)
 
@@ -928,14 +930,14 @@
         }
     strings[''] = [item for inner_list in strings.values()
                    for item in inner_list]
-    for (k, v) in searchRE:
+    for k, v in searchRE:
         if k in strings and not _match_any_filter(strings[k], v):
             return False
     return True
 
 
 def _match_any_filter(strings, res):
-    return any(re.search(s) for re in res for s in strings)
+    return any(r.search(s) for r in res for s in strings)
 
 
 def _make_delta_filter(branch, generate_delta, search, log_rev_iterator,

=== modified file 'breezy/plugins/grep/grep.py'
--- breezy/plugins/grep/grep.py	2018-11-16 18:33:17 +0000
+++ breezy/plugins/grep/grep.py	2018-11-16 19:10:57 +0000
@@ -120,14 +120,11 @@
 
 
 def compile_pattern(pattern, flags=0):
-    patternc = None
     try:
-        # use python's re.compile as we need to catch re.error in case of bad pattern
-        lazy_regex.reset_compile()
-        patternc = re.compile(pattern, flags)
+        return re.compile(pattern, flags)
     except re.error as e:
         raise errors.BzrError("Invalid pattern: '%s'" % pattern)
-    return patternc
+    return None
 
 
 def is_fixed_string(s):

=== modified file 'breezy/tests/test_lazy_regex.py'
--- breezy/tests/test_lazy_regex.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/test_lazy_regex.py	2018-11-16 19:10:57 +0000
@@ -48,8 +48,7 @@
         return super(InstrumentedLazyRegex, self).__getattr__(attr)
 
     def _real_re_compile(self, *args, **kwargs):
-        self._actions.append(('_real_re_compile',
-                              args, kwargs))
+        self._actions.append(('_real_re_compile', args, kwargs))
         return super(InstrumentedLazyRegex, self)._real_re_compile(
             *args, **kwargs)
 
@@ -61,7 +60,7 @@
         actions = []
         InstrumentedLazyRegex.use_actions(actions)
 
-        pattern = InstrumentedLazyRegex(args=('foo',))
+        pattern = InstrumentedLazyRegex(args=('foo',), kwargs={})
         actions.append(('created regex', 'foo'))
         # This match call should compile the regex and go through __getattr__
         pattern.match('foo')
@@ -135,31 +134,5 @@
         lazy_pattern = lazy_regex.lazy_compile('[,;]+')
         pickled = pickle.dumps(lazy_pattern)
         unpickled_lazy_pattern = pickle.loads(pickled)
-        self.assertEqual(['x', 'y', 'z'],
-                         unpickled_lazy_pattern.split('x,y;z'))
-
-
-class TestInstallLazyCompile(tests.TestCase):
-    """Tests for lazy compiled regexps.
-
-    Other tests, and breezy in general, count on the lazy regexp compiler
-    being installed, and this is done by loading breezy.  So these tests
-    assume it is installed, and leave it installed when they're done.
-    """
-
-    def test_install(self):
-        # Don't count on it being present
-        lazy_regex.install_lazy_compile()
-        pattern = re.compile('foo')
-        self.assertIsInstance(pattern, lazy_regex.LazyRegex)
-
-    def test_reset(self):
-        lazy_regex.reset_compile()
-        self.addCleanup(lazy_regex.install_lazy_compile)
-        pattern = re.compile('foo')
-        self.assertFalse(isinstance(pattern, lazy_regex.LazyRegex),
-                         'lazy_regex.reset_compile() did not restore the original'
-                         ' compile() function %s' % (type(pattern),))
-        # but the returned object should still support regex operations
-        m = pattern.match('foo')
-        self.assertEqual('foo', m.group())
+        self.assertEqual(
+            ['x', 'y', 'z'], unpickled_lazy_pattern.split('x,y;z'))

=== modified file 'breezy/tests/test_source.py'
--- breezy/tests/test_source.py	2018-11-16 18:59:44 +0000
+++ breezy/tests/test_source.py	2018-11-16 19:10:57 +0000
@@ -325,11 +325,6 @@
             self.fail('\n\n'.join(problems))
 
     def test_flake8(self):
-        # Disable lazy_regex, since flake8 uses sre_compile which can't handle
-        # lazy_regex compile objects.
-        from .. import lazy_regex
-        lazy_regex.reset_compile()
-        self.addCleanup(lazy_regex.install_lazy_compile)
         self.requireFeature(features.flake8)
         # Older versions of flake8 don't support the 'paths'
         # variable

=== modified file 'brz'
--- brz	2018-03-24 15:16:49 +0000
+++ brz	2018-11-16 19:10:57 +0000
@@ -58,8 +58,6 @@
     sys._brz_default_fs_enc = "utf8"
 
 
-# instruct breezy/__init__.py to install lazy_regex
-sys._brz_lazy_regex = True
 try:
     import breezy
 except ImportError as e: