Refactored the Loader class to use the Renderer class's unicode.

As a result, it is no longer necessary to pass decode_errors to
the Loader class.

3 files changed, 88 insertions, 48 deletions

diff --git a/tests/test_custom_template.py b/tests/test_custom_template.py
index d46b5bf..eedf431 100644
--- a/tests/test_custom_template.py
+++ b/tests/test_custom_template.py
@@ -146,10 +146,11 @@ class CustomLoaderTests(unittest.TestCase, AssertIsMixin, AssertStringMixin):
     def test_init__defaults(self):
         custom = CustomLoader()
 
-        # Check the reader attribute.
+        # Check the loader attribute.
         loader = custom.loader
-        self.assertEquals(loader.decode_errors, 'strict')
-        self.assertEquals(loader.encoding, sys.getdefaultencoding())
+        self.assertEquals(loader.extension, 'mustache')
+        self.assertEquals(loader.file_encoding, sys.getdefaultencoding())
+        to_unicode = loader.to_unicode
 
         # Check search_dirs.
         self.assertEquals(custom.search_dirs, [])
diff --git a/tests/test_loader.py b/tests/test_loader.py
index 1836466..a285e68 100644
--- a/tests/test_loader.py
+++ b/tests/test_loader.py
@@ -10,40 +10,71 @@ import sys
 import unittest
 
 from .common import AssertStringMixin
+from pystache import defaults
 from pystache.loader import Loader
 
 
 DATA_DIR = 'tests/data'
 
 
-class LoaderTestCase(unittest.TestCase, AssertStringMixin):
-
-    def _get_path(self, filename):
-        return os.path.join(DATA_DIR, filename)
-
-    def test_init__decode_errors(self):
-        # Test the default value.
-        reader = Loader()
-        self.assertEquals(reader.decode_errors, 'strict')
-
-        reader = Loader(decode_errors='replace')
-        self.assertEquals(reader.decode_errors, 'replace')
-
-    def test_init__encoding(self):
-        # Test the default value.
-        reader = Loader()
-        self.assertEquals(reader.encoding, sys.getdefaultencoding())
-
-        reader = Loader(encoding='foo')
-        self.assertEquals(reader.encoding, 'foo')
+class LoaderTests(unittest.TestCase, AssertStringMixin):
 
     def test_init__extension(self):
+        loader = Loader(extension='foo')
+        self.assertEquals(loader.extension, 'foo')
+
+    def test_init__extension__default(self):
         # Test the default value.
-        reader = Loader()
-        self.assertEquals(reader.extension, 'mustache')
+        loader = Loader()
+        self.assertEquals(loader.extension, 'mustache')
+
+    def test_init__file_encoding(self):
+        loader = Loader(file_encoding='bar')
+        self.assertEquals(loader.file_encoding, 'bar')
+
+    def test_init__file_encoding__default(self):
+        file_encoding = defaults.FILE_ENCODING
+        try:
+            defaults.FILE_ENCODING = 'foo'
+            loader = Loader()
+            self.assertEquals(loader.file_encoding, 'foo')
+        finally:
+            defaults.FILE_ENCODING = file_encoding
+
+    def test_init__to_unicode(self):
+        to_unicode = lambda x: x
+        loader = Loader(to_unicode=to_unicode)
+        self.assertEquals(loader.to_unicode, to_unicode)
+
+    def test_init__to_unicode__default(self):
+        loader = Loader()
+        self.assertRaises(TypeError, loader.to_unicode, u"abc")
+
+        decode_errors = defaults.DECODE_ERRORS
+        string_encoding = defaults.STRING_ENCODING
+
+        nonascii = 'abcdé'
+
+        try:
+            defaults.DECODE_ERRORS = 'strict'
+            defaults.STRING_ENCODING = 'ascii'
+            loader = Loader()
+            self.assertRaises(UnicodeDecodeError, loader.to_unicode, nonascii)
+
+            defaults.DECODE_ERRORS = 'ignore'
+            loader = Loader()
+            self.assertString(loader.to_unicode(nonascii), u'abcd')
+
+            defaults.STRING_ENCODING = 'utf-8'
+            loader = Loader()
+            self.assertString(loader.to_unicode(nonascii), u'abcdé')
+
+        finally:
+            defaults.DECODE_ERRORS = decode_errors
+            defaults.STRING_ENCODING = string_encoding
 
-        reader = Loader(extension='foo')
-        self.assertEquals(reader.extension, 'foo')
+    def _get_path(self, filename):
+        return os.path.join(DATA_DIR, filename)
 
     def test_unicode__basic__input_str(self):
         """
@@ -80,19 +111,24 @@ class LoaderTestCase(unittest.TestCase, AssertStringMixin):
 
         self.assertString(actual, u"foo")
 
-    def test_unicode__encoding_attribute(self):
+    def test_unicode__to_unicode__attribute(self):
         """
         Test unicode(): encoding attribute.
 
         """
         reader = Loader()
 
-        non_ascii = u'é'.encode('utf-8')
+        non_ascii = u'abcdé'.encode('utf-8')
 
         self.assertRaises(UnicodeDecodeError, reader.unicode, non_ascii)
 
-        reader.encoding = 'utf-8'
-        self.assertEquals(reader.unicode(non_ascii), u"é")
+        def to_unicode(s, encoding=None):
+            if encoding is None:
+                encoding = 'utf-8'
+            return unicode(s, encoding)
+
+        reader.to_unicode = to_unicode
+        self.assertString(reader.unicode(non_ascii), u"abcdé")
 
     def test_unicode__encoding_argument(self):
         """
@@ -101,13 +137,14 @@ class LoaderTestCase(unittest.TestCase, AssertStringMixin):
         """
         reader = Loader()
 
-        non_ascii = u'é'.encode('utf-8')
+        non_ascii = u'abcdé'.encode('utf-8')
 
         self.assertRaises(UnicodeDecodeError, reader.unicode, non_ascii)
 
         actual = reader.unicode(non_ascii, encoding='utf-8')
-        self.assertEquals(actual, u'é')
+        self.assertString(actual, u'abcdé')
 
+    # TODO: check the read() unit tests.
     def test_read(self):
         """
         Test read().
@@ -118,18 +155,18 @@ class LoaderTestCase(unittest.TestCase, AssertStringMixin):
         actual = reader.read(path)
         self.assertString(actual, u'ascii: abc')
 
-    def test_read__encoding__attribute(self):
+    def test_read__file_encoding__attribute(self):
         """
-        Test read(): encoding attribute respected.
+        Test read(): file_encoding attribute respected.
 
         """
-        reader = Loader()
+        loader = Loader()
         path = self._get_path('non_ascii.mustache')
 
-        self.assertRaises(UnicodeDecodeError, reader.read, path)
+        self.assertRaises(UnicodeDecodeError, loader.read, path)
 
-        reader.encoding = 'utf-8'
-        actual = reader.read(path)
+        loader.file_encoding = 'utf-8'
+        actual = loader.read(path)
         self.assertString(actual, u'non-ascii: é')
 
     def test_read__encoding__argument(self):
@@ -145,9 +182,9 @@ class LoaderTestCase(unittest.TestCase, AssertStringMixin):
         actual = reader.read(path, encoding='utf-8')
         self.assertString(actual, u'non-ascii: é')
 
-    def test_get__decode_errors(self):
+    def test_reader__to_unicode__attribute(self):
         """
-        Test get(): decode_errors attribute.
+        Test read(): to_unicode attribute respected.
 
         """
         reader = Loader()
@@ -155,7 +192,7 @@ class LoaderTestCase(unittest.TestCase, AssertStringMixin):
 
         self.assertRaises(UnicodeDecodeError, reader.read, path)
 
-        reader.decode_errors = 'ignore'
-        actual = reader.read(path)
-        self.assertString(actual, u'non-ascii: ')
+        #reader.decode_errors = 'ignore'
+        #actual = reader.read(path)
+        #self.assertString(actual, u'non-ascii: ')
 
diff --git a/tests/test_renderer.py b/tests/test_renderer.py
index 5c702d3..49f3999 100644
--- a/tests/test_renderer.py
+++ b/tests/test_renderer.py
@@ -196,19 +196,21 @@ class RendererTestCase(unittest.TestCase):
 
     def test__make_loader__attributes(self):
         """
-        Test that _make_locator() sets all attributes correctly..
+        Test that _make_loader() sets all attributes correctly..
 
         """
+        unicode_ = lambda x: x
+
         renderer = Renderer()
-        renderer.decode_errors = 'dec'
         renderer.file_encoding = 'enc'
         renderer.file_extension = 'ext'
+        renderer.unicode = unicode_
 
         loader = renderer._make_loader()
 
-        self.assertEquals(loader.decode_errors, 'dec')
-        self.assertEquals(loader.encoding, 'enc')
         self.assertEquals(loader.extension, 'ext')
+        self.assertEquals(loader.file_encoding, 'enc')
+        self.assertEquals(loader.to_unicode, unicode_)
 
     ## Test the render() method.