Fix unicode issue on 2.7

Author: Daniel Neuhäuser

CHANGELOG.rst

@@ -6,6 +6,8 @@ Version 0.2.1
 
 - Fix issue with named groups.
 - Nicer `TypeError`\s, if pattern types are unequal.
+- Fix issues with byte instead of unicode strings being returned on Python
+  2.7.
 
 Version 0.2.0
 =============

oore.py

@@ -69,7 +69,7 @@ def __add__(self, other):
                     ).encode('latin1')
                 )
             else:
-                return r('(?:{})(?:{})'.format(self.pattern, other.pattern))
+                return r(u'(?:{})(?:{})'.format(self.pattern, other.pattern))
         return NotImplemented
 
     def __or__(self, other):
@@ -89,7 +89,7 @@ def __or__(self, other):
                     ).encode('latin1')
                 )
             else:
-                return r('(?:{})|(?:{})'.format(self.pattern, other.pattern))
+                return r(u'(?:{})|(?:{})'.format(self.pattern, other.pattern))
         return NotImplemented
 
     def __getitem__(self, index):
@@ -102,7 +102,7 @@ def __getitem__(self, index):
                     ).encode('latin1')
                 )
             else:
-                return r('(?:{}){{{}}}'.format(self.pattern, index))
+                return r(u'(?:{}){{{}}}'.format(self.pattern, index))
         elif isinstance(index, tuple) and len(index) == 2:
             if (
                 isinstance(index[0], int) and isinstance(index[1], int) and
@@ -116,7 +116,7 @@ def __getitem__(self, index):
                         ).encode('latin1')
                     )
                 else:
-                    return r('(?:{}){{{},{}}}'.format(self.pattern, *index))
+                    return r(u'(?:{}){{{},{}}}'.format(self.pattern, *index))
             elif (
                 isinstance(index[0], int) and index[1] is Ellipsis
             ):
@@ -128,7 +128,7 @@ def __getitem__(self, index):
                             ).encode('latin1')
                         )
                     else:
-                        return r('(?:{})*'.format(self.pattern))
+                        return r(u'(?:{})*'.format(self.pattern))
                 elif index[0] == 1:
                     if isinstance(self.pattern, bytes):
                         return r(
@@ -137,7 +137,7 @@ def __getitem__(self, index):
                             ).encode('latin1')
                         )
                     else:
-                        return r('(?:{})+'.format(self.pattern))
+                        return r(u'(?:{})+'.format(self.pattern))
                 else:
                     if isinstance(self.pattern, bytes):
                         return r(
@@ -148,7 +148,7 @@ def __getitem__(self, index):
                         )
                     else:
                         return r(
-                            '(?:{pattern}){{{n}}}(?:{pattern})*'.format(
+                            u'(?:{pattern}){{{n}}}(?:{pattern})*'.format(
                                 pattern=self.pattern, n=index[0]
                             )
                         )

test_oore.py

@@ -7,23 +7,32 @@
     :license: BSD, see LICENSE.rst for details
 """
 import re
+import sys
 
 from oore import r
 
 from pytest import raises
 
 
+if sys.version_info[0] == 2:
+    text_type = unicode
+else:
+    text_type = str
+
+
 def test_add_text():
     foo = r(u'foo')
     bar = r(u'bar')
     foobar = foo + bar
+    assert isinstance(foobar.pattern, text_type)
     assert foobar.match(u'foobar')
 
 
 def test_add_bytes():
     foo = r(b'foo')
     bar = r(b'bar')
     foobar = foo + bar
+    assert isinstance(foobar.pattern, bytes)
     assert foobar.match(b'foobar')
 
 
@@ -60,53 +69,61 @@ def test_or_mixed():
 def test_repeat_text():
     foo = r(u'foo')
     foo_3 = foo[3]
+    assert isinstance(foo_3.pattern, text_type)
     assert foo_3.match(u'foo' * 3)
 
 
 def test_repeat_bytes():
     foo = r(b'foo')
     foo_3 = foo[3]
+    assert isinstance(foo_3.pattern, bytes)
     assert foo_3.match(b'foo' * 3)
 
 
 def test_repeat_from_to_text():
     foo = r(u'foo')
     foo_2_to_4 = foo[2, 4]
+    assert isinstance(foo_2_to_4.pattern, text_type)
     for i in range(2, 5):
         assert foo_2_to_4.match(u'foo' * i)
 
 
 def test_repeat_from_to_bytes():
     foo = r(b'foo')
     foo_2_to_4 = foo[2, 4]
+    assert isinstance(foo_2_to_4.pattern, bytes)
     for i in range(2, 5):
         assert foo_2_to_4.match(b'foo' * i)
 
 
 def test_repeat_zero_or_more_text():
     foo = r(u'foo')
     foo_zero_or_more = foo[0, ...]
+    assert isinstance(foo_zero_or_more.pattern, text_type)
     for i in range(10):
         assert foo_zero_or_more.match(u'foo' * i)
 
 
 def test_repeat_zero_or_more_bytes():
     foo = r(b'foo')
     foo_zero_or_more = foo[0, ...]
+    assert isinstance(foo_zero_or_more.pattern, bytes)
     for i in range(10):
         assert foo_zero_or_more.match(b'foo' * i)
 
 
 def test_repeat_one_or_more_text():
     foo = r(u'foo')
     foo_one_or_more = foo[1, ...]
+    assert isinstance(foo_one_or_more.pattern, text_type)
     for i in range(1, 10):
         assert foo_one_or_more.match(u'foo' * i)
 
 
 def test_repeat_one_or_more_bytes():
     foo = r(b'foo')
     foo_one_or_more = foo[1, ...]
+    assert isinstance(foo_one_or_more.pattern, bytes)
     for i in range(1, 10):
         assert foo_one_or_more.match(b'foo' * i)
 
@@ -115,6 +132,7 @@ def test_repeat_n_or_more_text():
     foo = r(u'foo')
     for n in range(2, 5):
         foo_n_or_more = foo[n, ...]
+        assert isinstance(foo_n_or_more.pattern, text_type)
         for i in range(n, 10):
             assert foo_n_or_more.match(u'foo' * i)
 
@@ -123,6 +141,7 @@ def test_repeat_n_or_more_bytes():
     foo = r(b'foo')
     for n in range(2, 5):
         foo_n_or_more = foo[n, ...]
+        assert isinstance(foo_n_or_more.pattern, bytes)
         for i in range(n, 10):
             assert foo_n_or_more.match(b'foo' * i)
 
@@ -134,6 +153,7 @@ def test_check_r_argument_is_valid_regexp():
 
 def test_numbered_groups_text():
     foo = r(u'foo').grouped()
+    assert isinstance(foo.pattern, text_type)
     bar = r(u'bar')
     foobar = foo + bar
     match = foobar.match(u'foobar')
@@ -142,6 +162,7 @@ def test_numbered_groups_text():
 
 def test_numbered_groups_bytes():
     foo = r(b'foo').grouped()
+    assert isinstance(foo.pattern, bytes)
     bar = r(b'bar')
     foobar = foo + bar
     match = foobar.match(b'foobar')
@@ -150,6 +171,7 @@ def test_numbered_groups_bytes():
 
 def test_named_groups_text():
     foo = r(u'foo').grouped('group')
+    assert isinstance(foo.pattern, text_type)
     bar = r(u'bar')
     foobar = foo + bar
     match = foobar.match(u'foobar')
@@ -158,6 +180,7 @@ def test_named_groups_text():
 
 def test_named_groups_bytes():
     foo = r(b'foo').grouped('group')
+    assert isinstance(foo.pattern, bytes)
     bar = r(b'bar')
     foobar = foo + bar
     match = foobar.match(b'foobar')