Simplified Renderer class: Renderer now uses new Loader class.

2 files changed, 46 insertions, 92 deletions

diff --git a/tests/test_loader.py b/tests/test_loader.py
index 5e02058..1836466 100644
--- a/tests/test_loader.py
+++ b/tests/test_loader.py
@@ -10,40 +10,39 @@ import sys
 import unittest
 
 from .common import AssertStringMixin
-# TODO: remove this alias.
-from pystache.loader import Loader as Reader
+from pystache.loader import Loader
 
 
 DATA_DIR = 'tests/data'
 
 
-class ReaderTestCase(unittest.TestCase, AssertStringMixin):
+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 = Reader()
+        reader = Loader()
         self.assertEquals(reader.decode_errors, 'strict')
 
-        reader = Reader(decode_errors='replace')
+        reader = Loader(decode_errors='replace')
         self.assertEquals(reader.decode_errors, 'replace')
 
     def test_init__encoding(self):
         # Test the default value.
-        reader = Reader()
+        reader = Loader()
         self.assertEquals(reader.encoding, sys.getdefaultencoding())
 
-        reader = Reader(encoding='foo')
+        reader = Loader(encoding='foo')
         self.assertEquals(reader.encoding, 'foo')
 
     def test_init__extension(self):
         # Test the default value.
-        reader = Reader()
+        reader = Loader()
         self.assertEquals(reader.extension, 'mustache')
 
-        reader = Reader(extension='foo')
+        reader = Loader(extension='foo')
         self.assertEquals(reader.extension, 'foo')
 
     def test_unicode__basic__input_str(self):
@@ -51,7 +50,7 @@ class ReaderTestCase(unittest.TestCase, AssertStringMixin):
         Test unicode(): default arguments with str input.
 
         """
-        reader = Reader()
+        reader = Loader()
         actual = reader.unicode("foo")
 
         self.assertString(actual, u"foo")
@@ -61,7 +60,7 @@ class ReaderTestCase(unittest.TestCase, AssertStringMixin):
         Test unicode(): default arguments with unicode input.
 
         """
-        reader = Reader()
+        reader = Loader()
         actual = reader.unicode(u"foo")
 
         self.assertString(actual, u"foo")
@@ -76,7 +75,7 @@ class ReaderTestCase(unittest.TestCase, AssertStringMixin):
 
         s = UnicodeSubclass(u"foo")
 
-        reader = Reader()
+        reader = Loader()
         actual = reader.unicode(s)
 
         self.assertString(actual, u"foo")
@@ -86,7 +85,7 @@ class ReaderTestCase(unittest.TestCase, AssertStringMixin):
         Test unicode(): encoding attribute.
 
         """
-        reader = Reader()
+        reader = Loader()
 
         non_ascii = u'é'.encode('utf-8')
 
@@ -100,65 +99,63 @@ class ReaderTestCase(unittest.TestCase, AssertStringMixin):
         Test unicode(): encoding argument.
 
         """
-        reader = Reader()
+        reader = Loader()
 
         non_ascii = u'é'.encode('utf-8')
 
         self.assertRaises(UnicodeDecodeError, reader.unicode, non_ascii)
 
-        self.assertEquals(reader.unicode(non_ascii, encoding='utf-8'), u'é')
+        actual = reader.unicode(non_ascii, encoding='utf-8')
+        self.assertEquals(actual, u'é')
 
     def test_read(self):
         """
         Test read().
 
         """
-        reader = Reader()
+        reader = Loader()
         path = self._get_path('ascii.mustache')
-        self.assertEquals(reader.read(path), 'ascii: abc')
-
-    def test_read__returns_unicode(self):
-        """
-        Test that read() returns unicode strings.
-
-        """
-        reader = Reader()
-        path = self._get_path('ascii.mustache')
-        contents = reader.read(path)
-        self.assertEqual(type(contents), unicode)
+        actual = reader.read(path)
+        self.assertString(actual, u'ascii: abc')
 
     def test_read__encoding__attribute(self):
         """
         Test read(): encoding attribute respected.
 
         """
-        reader = Reader()
+        reader = Loader()
         path = self._get_path('non_ascii.mustache')
 
         self.assertRaises(UnicodeDecodeError, reader.read, path)
+
         reader.encoding = 'utf-8'
-        self.assertEquals(reader.read(path), u'non-ascii: é')
+        actual = reader.read(path)
+        self.assertString(actual, u'non-ascii: é')
 
     def test_read__encoding__argument(self):
         """
         Test read(): encoding argument respected.
 
         """
-        reader = Reader()
+        reader = Loader()
         path = self._get_path('non_ascii.mustache')
 
         self.assertRaises(UnicodeDecodeError, reader.read, path)
-        self.assertEquals(reader.read(path, encoding='utf-8'), u'non-ascii: é')
+
+        actual = reader.read(path, encoding='utf-8')
+        self.assertString(actual, u'non-ascii: é')
 
     def test_get__decode_errors(self):
         """
         Test get(): decode_errors attribute.
 
         """
-        reader = Reader()
+        reader = Loader()
         path = self._get_path('non_ascii.mustache')
 
         self.assertRaises(UnicodeDecodeError, reader.read, path)
-        reader.decode_errors = 'replace'
-        self.assertEquals(reader.read(path), u'non-ascii: \ufffd\ufffd')
+
+        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 7a9b7cf..5c702d3 100644
--- a/tests/test_renderer.py
+++ b/tests/test_renderer.py
@@ -12,7 +12,7 @@ import unittest
 
 from examples.simple import Simple
 from pystache.renderer import Renderer
-from pystache.locator import Locator
+from pystache.loader import Loader
 
 from .common import get_data_path
 from .data.views import SayHello
@@ -182,76 +182,33 @@ class RendererTestCase(unittest.TestCase):
         # U+FFFD is the official Unicode replacement character.
         self.assertEquals(renderer.unicode(s), u'd\ufffd\ufffdf')
 
-    ## Test the read() method.
+    ## Test the _make_loader() method.
 
-    def _read(self, renderer, filename):
-        path = get_data_path(filename)
-        return renderer.read(path)
-
-    def test_read(self):
-        renderer = Renderer()
-        actual = self._read(renderer, 'ascii.mustache')
-        self.assertEquals(actual, 'ascii: abc')
-
-    def test_read__returns_unicode(self):
-        renderer = Renderer()
-        actual = self._read(renderer, 'ascii.mustache')
-        self.assertEquals(type(actual), unicode)
-
-    def test_read__file_encoding(self):
-        filename = 'non_ascii.mustache'
-
-        renderer = Renderer()
-        renderer.file_encoding = 'ascii'
-
-        self.assertRaises(UnicodeDecodeError, self._read, renderer, filename)
-        renderer.file_encoding = 'utf-8'
-        actual = self._read(renderer, filename)
-        self.assertEquals(actual, u'non-ascii: é')
-
-    def test_read__decode_errors(self):
-        filename = 'non_ascii.mustache'
-        renderer = Renderer()
-
-        self.assertRaises(UnicodeDecodeError, self._read, renderer, filename)
-        renderer.decode_errors = 'ignore'
-        actual = self._read(renderer, filename)
-        self.assertEquals(actual, 'non-ascii: ')
-
-    ## Test the make_locator() method.
-
-    def test_make_locator__return_type(self):
+    def test__make_loader__return_type(self):
         """
-        Test that make_locator() returns a Locator.
+        Test that _make_loader() returns a Loader.
 
         """
         renderer = Renderer()
-        locator = renderer.make_locator()
+        loader = renderer._make_loader()
 
-        self.assertEquals(type(locator), Locator)
+        self.assertEquals(type(loader), Loader)
 
-    def test_make_locator__file_extension(self):
+    def test__make_loader__attributes(self):
         """
-        Test that make_locator() respects the file_extension attribute.
+        Test that _make_locator() sets all attributes correctly..
 
         """
         renderer = Renderer()
-        renderer.file_extension = 'foo'
-
-        locator = renderer.make_locator()
-
-        self.assertEquals(locator.template_extension, 'foo')
-
-    # This test is a sanity check.  Strictly speaking, it shouldn't
-    # be necessary based on our tests above.
-    def test_make_locator__default(self):
-        renderer = Renderer()
-        actual = renderer.make_locator()
+        renderer.decode_errors = 'dec'
+        renderer.file_encoding = 'enc'
+        renderer.file_extension = 'ext'
 
-        expected = Locator()
+        loader = renderer._make_loader()
 
-        self.assertEquals(type(actual), type(expected))
-        self.assertEquals(actual.template_extension, expected.template_extension)
+        self.assertEquals(loader.decode_errors, 'dec')
+        self.assertEquals(loader.encoding, 'enc')
+        self.assertEquals(loader.extension, 'ext')
 
     ## Test the render() method.