Consistent __str__ usage. Also helps Py3 support.

pekkaklarck · pekkaklarck · commit 98fa0e2d163b · 2015-10-14T11:09:30.000+03:00
diff --git a/src/robot/conf/settings.py b/src/robot/conf/settings.py
@@ -21,7 +21,7 @@
 from robot.output import LOGGER, loggerhelper
 from robot.result.keywordremover import KeywordRemover
 from robot.result.flattenkeywordmatcher import validate_flatten_keyword
-from robot.utils import (abspath, escape, format_time, get_link_path,
+from robot.utils import (__str__, abspath, escape, format_time, get_link_path,
                          html_escape, is_list_like,
                          split_args_from_name_or_path)
 
@@ -307,6 +307,9 @@ def __unicode__(self):
         return '\n'.join('%s: %s' % (name, self._opts[name])
                          for name in sorted(self._opts))
 
+    def __str__(self):
+        return __str__(self)
+
     @property
     def output_directory(self):
         return self['OutputDir']
diff --git a/src/robot/model/itemlist.py b/src/robot/model/itemlist.py
@@ -12,6 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+from robot.utils import __str__
+
 
 class ItemList(object):
     __slots__ = ['_item_class', '_common_attrs', '_items']
@@ -81,5 +83,4 @@ def __len__(self):
     def __unicode__(self):
         return u'[%s]' % ', '.join(unicode(item) for item in self)
 
-    def __str__(self):
-        return unicode(self).encode('ASCII', 'replace')
+    __str__ = __str__
diff --git a/src/robot/model/message.py b/src/robot/model/message.py
@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import html_escape, setter
+from robot.utils import __str__, html_escape, setter
 
 from .itemlist import ItemList
 from .modelobject import ModelObject
@@ -58,6 +58,8 @@ def visit(self, visitor):
     def __unicode__(self):
         return self.message
 
+    __str__ = __str__
+
 
 class Messages(ItemList):
     __slots__ = []
diff --git a/src/robot/model/metadata.py b/src/robot/model/metadata.py
@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import NormalizedDict
+from robot.utils import NormalizedDict, __str__
 
 
 class Metadata(NormalizedDict):
@@ -23,5 +23,4 @@ def __init__(self, initial=None):
     def __unicode__(self):
         return u'{%s}' % ', '.join('%s: %s' % (k, self[k]) for k in self)
 
-    def __str__(self):
-        return unicode(self).encode('ASCII', 'replace')
+    __str__ = __str__
diff --git a/src/robot/model/modelobject.py b/src/robot/model/modelobject.py
@@ -12,7 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils.setter import SetterAwareType
+from robot.utils import SetterAwareType, __str__
 
 
 class ModelObject(object):
@@ -23,7 +23,7 @@ def __unicode__(self):
         return self.name
 
     def __str__(self):
-        return unicode(self).encode('ASCII', 'replace')
+        return __str__(self)
 
     def __repr__(self):
         return repr(str(self))
diff --git a/src/robot/model/tags.py b/src/robot/model/tags.py
@@ -12,7 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from robot.utils import Matcher, NormalizedDict, is_string, setter, unic
+from robot.utils import (Matcher, NormalizedDict, is_string, setter, unic,
+                         __str__)
 
 
 class Tags(object):
@@ -57,12 +58,12 @@ def __iter__(self):
     def __unicode__(self):
         return u'[%s]' % ', '.join(self)
 
+    def __str__(self):
+        return __str__(self)
+
     def __repr__(self):
         return repr(list(self))
 
-    def __str__(self):
-        return unicode(self).encode('UTF-8')
-
     def __getitem__(self, index):
         item = self._tags[index]
         return item if not isinstance(index, slice) else Tags(item)
@@ -111,9 +112,14 @@ def __init__(self, pattern):
     def match(self, tags):
         return self._matcher.match_any(tags)
 
+    # FIXME: Why only this class methods below??
+
     def __unicode__(self):
         return self._matcher.pattern
 
+    def __str__(self):
+        return __str__(self)
+
     def __nonzero__(self):
         return bool(self._matcher)
 
diff --git a/src/robot/utils/__init__.py b/src/robot/utils/__init__.py
@@ -47,8 +47,8 @@
 from .markupwriters import HtmlWriter, XmlWriter, NullMarkupWriter
 from .importer import Importer
 from .match import eq, Matcher, MultiMatcher
-from .misc import (isatty, getdoc, plural_or_not, printable_name,
-                   seq2str, seq2str2)
+from .misc import (getdoc, isatty, plural_or_not, printable_name, seq2str,
+                   seq2str2, __str__)
 from .normalizing import lower, normalize, NormalizedDict
 from .platform import (IRONPYTHON, JYTHON, PYTHON, UNIXY, WINDOWS,
                        RERAISED_EXCEPTIONS)
@@ -64,7 +64,7 @@
 from .robottypes import (is_bytes, is_dict_like, is_falsy, is_integer,
                          is_list_like, is_number, is_string, is_truthy,
                          is_unicode, type_name)
-from .setter import setter
+from .setter import setter, SetterAwareType
 from .text import (cut_long_message, format_assign_message,
                    pad_console_length, get_console_length, split_tags_from_doc,
                    split_args_from_name_or_path)
diff --git a/src/robot/utils/dotdict.py b/src/robot/utils/dotdict.py
@@ -42,7 +42,7 @@ def __eq__(self, other):
         return dict.__eq__(self, other)
 
     def __str__(self):
-        return '{%s}' % ', '.join('%r: %r' % item for item in self.iteritems())
+        return '{%s}' % ', '.join('%r: %r' % (key, self[key]) for key in self)
 
     # Must use original dict.__repr__ to allow customising PrettyPrinter.
     __repr__ = dict.__repr__
diff --git a/src/robot/utils/misc.py b/src/robot/utils/misc.py
@@ -107,6 +107,10 @@ def getdoc(item):
         return unic(doc)
 
 
+def __str__(instance):
+    return instance.__unicode__().encode('UTF-8')
+
+
 # On IronPython sys.stdxxx.isatty() always returns True
 if not IRONPYTHON:
 
diff --git a/src/robot/utils/normalizing.py b/src/robot/utils/normalizing.py
@@ -90,7 +90,7 @@ def __len__(self):
         return len(self._data)
 
     def __str__(self):
-        return str(dict(self.items()))
+        return '{%s}' % ', '.join('%r: %r' % (key, self[key]) for key in self)
 
     def __eq__(self, other):
         if not is_dict_like(other):
diff --git a/utest/model/test_keyword.py b/utest/model/test_keyword.py
@@ -84,7 +84,7 @@ def test_unicode(self):
     def test_str(self):
         assert_equal(str(self.empty), '')
         assert_equal(str(self.ascii), 'Kekkonen')
-        assert_equal(str(self.non_ascii), 'hyv? nimi')
+        assert_equal(str(self.non_ascii), u'hyv\xe4 nimi'.encode('UTF-8'))
 
 
 class TestKeywords(unittest.TestCase):
diff --git a/utest/model/test_message.py b/utest/model/test_message.py
@@ -35,7 +35,7 @@ def test_unicode(self):
     def test_str(self):
         assert_equal(str(self.empty), '')
         assert_equal(str(self.ascii), 'Kekkonen')
-        assert_equal(str(self.non_ascii), 'hyv? nimi')
+        assert_equal(str(self.non_ascii), u'hyv\xe4 nimi'.encode('UTF-8'))
 
     def test_slots(self):
         assert_raises(AttributeError, setattr, Message(), 'attr', 'value')
diff --git a/utest/model/test_metadata.py b/utest/model/test_metadata.py
@@ -18,7 +18,8 @@ def test_unicode(self):
     def test_str(self):
         assert_equal(str(Metadata()), '{}')
         d = {'a': 1, 'B': 'two', u'\xe4': u'nelj\xe4'}
-        assert_equal(str(Metadata(d)), '{a: 1, B: two, ?: nelj?}')
+        assert_equal(str(Metadata(d)),
+                     u'{a: 1, B: two, \xe4: nelj\xe4}'.encode('UTF-8'))
 
 
 if __name__ == '__main__':
diff --git a/utest/model/test_testcase.py b/utest/model/test_testcase.py
@@ -56,7 +56,7 @@ def test_unicode(self):
     def test_str(self):
         assert_equal(str(self.empty), '')
         assert_equal(str(self.ascii), 'Kekkonen')
-        assert_equal(str(self.non_ascii), 'hyv? nimi')
+        assert_equal(str(self.non_ascii), u'hyv\xe4 nimi'.encode('UTF-8'))
 
 
 class TestTestCases(unittest.TestCase):
diff --git a/utest/model/test_testsuite.py b/utest/model/test_testsuite.py
@@ -114,7 +114,7 @@ def test_unicode(self):
     def test_str(self):
         assert_equal(str(self.empty), '')
         assert_equal(str(self.ascii), 'Kekkonen')
-        assert_equal(str(self.non_ascii), 'hyv? nimi')
+        assert_equal(str(self.non_ascii), u'hyv\xe4 nimi'.encode('UTF-8'))
 
 
 if __name__ == '__main__':
diff --git a/utest/utils/test_normalizing.py b/utest/utils/test_normalizing.py
@@ -167,8 +167,14 @@ def test_copy(self):
         assert_equals(cd._data, {'a': 1, 'b': 2})
 
     def test_str(self):
-        nd = NormalizedDict({'a': 1, 'B': 1})
-        assert_true(str(nd) in ("{'a': 1, 'B': 1}", "{'B': 1, 'a': 1}"))
+        nd = NormalizedDict({'a': 1, 'B': 1, 'c': 3, 'd': 4, 'E': 5, 'F': 6})
+        expected = "{'a': 1, 'B': 1, 'c': 3, 'd': 4, 'E': 5, 'F': 6}"
+        assert_equals(str(nd), expected)
+        assert_equals(unicode(nd), expected)
+
+    def test_unicode(self):
+        nd = NormalizedDict({'a': u'\xe4', u'\xe4': 'a'})
+        assert_equals(unicode(nd), "{'a': u'\\xe4', u'\\xe4': 'a'}")
 
     def test_update(self):
         nd = NormalizedDict({'a': 1, 'b': 1, 'c': 1})
