Improve matcher repr output for clearer diagnostics

Use repr-style formatting for value-like matchers so string values are quoted
consistently in diagnostics and nested matcher output.

Also make Matches report only explicitly requested regex flags and render
patterns via repr. Add matcher_repr_test.py with coverage for the updated
repr behavior.

Author: kaste

mockito/matchers.py

@@ -137,15 +137,15 @@ def matches(self, arg):
             return True
 
     def __repr__(self):
-        return "<Any: %s>" % self.wanted_type
+        return "<Any: %r>" % self.wanted_type
 
 
 class ValueMatcher(Matcher):
     def __init__(self, value):
         self.value = value
 
     def __repr__(self):
-        return "<%s: %s>" % (self.__class__.__name__, self.value)
+        return "<%s: %r>" % (self.__class__.__name__, self.value)
 
 
 class Eq(ValueMatcher):
@@ -236,24 +236,24 @@ def matches(self, arg):
         return self.sub and len(self.sub) > 0 and arg.find(self.sub) > -1
 
     def __repr__(self):
-        return "<Contains: '%s'>" % self.sub
+        return "<Contains: %r>" % self.sub
 
 
 class Matches(Matcher):
     def __init__(self, regex, flags=0):
         self.regex = re.compile(regex, flags)
+        self.flags = flags
 
     def matches(self, arg):
         if not isinstance(arg, str):
             return
         return self.regex.match(arg) is not None
 
     def __repr__(self):
-        if self.regex.flags:
-            return "<Matches: %s flags=%d>" % (self.regex.pattern,
-                                               self.regex.flags)
+        if self.flags:
+            return "<Matches: %r flags=%d>" % (self.regex.pattern, self.flags)
         else:
-            return "<Matches: %s>" % self.regex.pattern
+            return "<Matches: %r>" % self.regex.pattern
 
 
 class ArgumentCaptor(Matcher, Capturing):

tests/matcher_repr_test.py

@@ -0,0 +1,28 @@
+import re
+
+from mockito import and_, any as any_, contains, eq, gt, matches, not_, or_
+
+
+def test_value_matchers_use_repr_for_string_values():
+    assert repr(eq("foo")) == "<Eq: 'foo'>"
+
+
+def test_composed_matchers_include_quoted_nested_values():
+    assert repr(not_(eq("foo"))) == "<Not: <Eq: 'foo'>>"
+    assert repr(and_(eq("foo"), gt(1))) == "<And: [<Eq: 'foo'>, <Gt: 1>]>"
+    assert repr(or_(eq("foo"), gt(1))) == "<Or: [<Eq: 'foo'>, <Gt: 1>]>"
+
+
+def test_any_repr_quotes_non_type_values():
+    assert repr(any_("foo")) == "<Any: 'foo'>"
+
+
+def test_contains_repr_uses_safe_quoted_substring():
+    assert repr(contains("a'b")) == "<Contains: \"a'b\">"
+
+
+def test_matches_repr_shows_only_explicit_flags():
+    assert repr(matches("f..")) == "<Matches: 'f..'>"
+    assert repr(matches("f..", re.IGNORECASE)) == (
+        f"<Matches: 'f..' flags={int(re.IGNORECASE)}>"
+    )