Merge lp:~corydodt/txgenshi/502823 into lp:txgenshi

[Cory Dodt]

[Cory Dodt (corydodt)]

Please review.

This branch uses lazy evaluation to fill in template values. I had to define my own Context subclass because of the rampant, evil use of **kwargs which prevents lazy evaluation from working, and the __init__ for that class is a copy/paste of the original Context, but the way the Genshi API is structured I didn't see any other solution.

[Duncan McGreggor (oubiwann)]

Sweeeeet.

/me continues to be super-stoked about your contributions :-) They make me want to do web-dev again ;-)

+1 for merge.

review: Approve

[Duncan McGreggor (oubiwann)]

Don't know if you use ohloh.net at all, but I just kodoed you for the work you've done here :-)

  https://www.ohloh.net/p/txgenshi/contributors/2060925024795272

[Cory Dodt (corydodt)]

That's cool, thanks! :-)

C

On Mon, Jan 11, 2010 at 9:39 AM, Duncan McGreggor <email address hidden>wrote:

> Don't know if you use ohloh.net at all, but I just kodoed you for the work
> you've done here :-)
>
> https://www.ohloh.net/p/txgenshi/contributors/2060925024795272
> --
> https://code.edge.launchpad.net/~corydodt/txgenshi/502823/+merge/17116
> You are the owner of lp:~corydodt/txgenshi/502823.
>

--
_____________________

[Cory Dodt (corydodt)]

One back at you for writing txGenshi in the first place. It's exciting to
have an alternative to Nevow templates usable inside Nevow. The templates
were the only thing I've never been satisfied with in that package.

C

On Mon, Jan 11, 2010 at 10:54 AM, Cory Dodt <email address hidden>wrote:

> That's cool, thanks! :-)
>
> C
>
>
> On Mon, Jan 11, 2010 at 9:39 AM, Duncan McGreggor <<email address hidden>
> >wrote:
>
> > Don't know if you use ohloh.net at all, but I just kodoed you for the
> work
> > you've done here :-)
> >
> > https://www.ohloh.net/p/txgenshi/contributors/2060925024795272
> > --
> > https://code.edge.launchpad.net/~corydodt/txgenshi/502823/+merge/17116
> > You are the owner of lp:~corydodt/txgenshi/502823.
> >
>
>
>
> --
> _____________________
>
> https://code.launchpad.net/~corydodt/txgenshi/502823/+merge/17116
> You are the owner of lp:~corydodt/txgenshi/502823.
>

--
_____________________

=== modified file 'demo/templates/genshimix.xhtml'
--- demo/templates/genshimix.xhtml	2010-01-07 18:29:05 +0000
+++ demo/templates/genshimix.xhtml	2010-01-11 01:04:10 +0000
@@ -115,6 +115,13 @@
         <b>foo</b>
       </div>
     </div>
+    <div genshi:choose="">
+      <h2>Genshi embedded functions</h2>
+      <div genshi:when="not defined('ninjaKitteh')"
+        genshi:with="dude=value_of('ninjaKitteh', username)">
+        <b>Ninja Kitteh is not defined, $dude</b>
+      </div>
+    </div>
     <div>
       <h2>Genshi XInclude</h2>
       <xi:include href="templates/genshiinclude.xhtml"></xi:include>

=== modified file 'txgenshi/loader.py'
--- txgenshi/loader.py	2010-01-07 18:54:19 +0000
+++ txgenshi/loader.py	2010-01-11 01:04:10 +0000
@@ -1,44 +1,99 @@
+"""
+Nevow-compatible loader implementation that evaluates its template against
+Genshi, using the Resource itself as the data source.
+
+- Any attribute defined in the Resource which uses genshifile or genshistr as
+  its loader will be available as a Genshi variable
+- Any attribute which is callable may be used as a variable without adding
+  parentheses to call it, and it will be called when it is evaluated.  Any
+  such variable MUST NOT take any required arguments.
+- Any variable used in a template is FROZEN (cached) the first time it is
+  used.  This means you should not expect any the evaluation of any Genshi
+  variable to change between accesses if it is used more than once in a
+  template.  The exception to this rule is callables, which will be called
+  each time they are accessed.
+"""
+
 from inspect import getmembers
+from collections import deque
 
-from nevow import rend
 from nevow import inevow
 from nevow.loaders import xmlstr
 
-from genshi.template import MarkupTemplate
-
-# get a list of attributes that the rend.Page object has
-rendPageAttrs = [x[0] for x in getmembers(rend.Page)]
-
-
-def getObjectData(obj):
-    data = {}
-    for attr, val in getmembers(obj):
-        assert isinstance(attr, basestring), "Member name is not a string!"
-        # skip non-public methods
-        if attr.startswith('_'):
-            continue
-        # skip custom Nevow methods
-        if attr.startswith('child_'):
-            continue
-        if attr.startswith('render_'):
-            continue
-        if attr.startswith('data_'):
-            continue
-        # skip nevow.rend.Page methods
-        if attr in rendPageAttrs:
-            continue
-        member = getattr(obj, attr)
-        if callable(member):
-            val = member()
-        try:
-            data[attr] = val
-        except Exception, err:              # pragma: nocover
-            import pdb;pdb.set_trace()      # pragma: nocover
-    return data
+from genshi.template import MarkupTemplate, Context
+
+
+class TxGenshiContext(Context):
+    """
+    Subclass Context to get rid of the awful **kwargs initializer, which
+    prevents us from specifying our own template variables flexibly.
+    """
+    def __init__(self, data):
+        self.frames = deque([data])
+        self.pop = self.frames.popleft
+        self.push = self.frames.appendleft
+        self._match_templates = []
+        self._choice_stack = []
+
+        # Helper functions for use in expressions
+        def defined(name):
+            """Return whether a variable with the specified name exists in the
+            expression scope."""
+            return name in self
+        def value_of(name, default=None):
+            """If a variable of the specified name is defined, return its value.
+            Otherwise, return the provided default value, or ``None``."""
+            return self.get(name, default)
+        data['defined'] = defined
+        data['value_of'] = value_of
+
+
+LAZY = object()
+
+
+class DataProxy(object):
+    """
+    Lazy retrieval of attributes.
+
+    When a template requests data from the object being proxied by this
+    object, compute the data and return it.
+    """
+    def __init__(self, o):
+        self._d = {}
+        self._orig_d = {}  # items that were members of the original object,
+                           # not generated later during template processing
+        for k, _ in getmembers(o):
+            self._d[k] = LAZY
+            self._orig_d[k] = 1
+        self.obj = o
+
+    def __setitem__(self, k, v):
+        self._d[k] = v
+
+    def __getitem__(self, k):
+        if k in self._d:
+            if self._d[k] is LAZY:
+                v = self._d[k] = getattr(self.obj, k)
+                self._d[k] = v
+            else:
+                v = self._d[k]
+        else:
+            raise KeyError(k)
+
+        if callable(v) and k in self._orig_d:
+            return v()
+        else:
+            return v
+
+    def __contains__(self, k):
+        return k in self._d
+
 
 def getGenshiString(template, data):
     tmpl = MarkupTemplate(template)
-    return tmpl.generate(**data).render('xhtml')
+    ctx = TxGenshiContext(data)
+    return tmpl.generate(ctx).render('xhtml')
+
 
 class genshistr(xmlstr):
 
@@ -58,7 +113,7 @@
         enable your own caching mechanism and not up-call to the parent class.
         """
         renderer = inevow.IRenderer(ctx)
-        data = getObjectData(renderer)
+        data = DataProxy(renderer)
         # save a copy of the original, unmolested template, complete with
         # Genshi markup
         orig = self.template
@@ -72,6 +127,7 @@
         self.template = orig
         return nevowRun
 
+
 class genshifile(xmlstr):
 
     def __init__(self, filename):
@@ -82,7 +138,7 @@
             self.orig = open(self._filename).read()
             #self._reallyLoad(self._filename, ctx, preprocessors)
         renderer = inevow.IRenderer(ctx)
-        data = getObjectData(renderer)
+        data = DataProxy(renderer)
         self.template = getGenshiString(self.orig, data)
         nevowRun = super(genshifile, self).load(ctx=ctx,
             preprocessors=preprocessors)

=== modified file 'txgenshi/test/example.py'
--- txgenshi/test/example.py	2010-01-07 19:15:43 +0000
+++ txgenshi/test/example.py	2010-01-11 01:04:10 +0000
@@ -7,16 +7,21 @@
 
 from nevow import rend
 
-from txgenshi.loader import genshifile
+from txgenshi.loader import genshifile, genshistr
+
 
 class Apple:
     color = "red"
 
+
+TEMPLATEFILE = sibpath(__file__, '../../demo/templates/genshimix.xhtml')
+
+
 class GenshiMixPage(rend.Page):
     """
     Example page with genshi templates demo
     """
-    docFactory = genshifile(sibpath(__file__, '../../demo/templates/genshimix.xhtml'))
+    docFactory = genshifile(TEMPLATEFILE)
     addSlash = True
 
     def __init__(self, username=None, *args, **kwds):
@@ -39,7 +44,7 @@
         return data.title()
 
     def data_username(self, ctx, data):
-        return u"Joe"
+        return self.username
 
     def date(self):
         """
@@ -49,9 +54,6 @@
 
     date = property(date)
 
-    def render_username(self, context, data):
-        """
-        It's Joe.
-        """
-        return self.username
 
+class GenshiMixPageStr(GenshiMixPage):
+    docFactory = genshistr(open(TEMPLATEFILE).read())

=== modified file 'txgenshi/test/test_example.py'
--- txgenshi/test/test_example.py	2010-01-07 18:57:51 +0000
+++ txgenshi/test/test_example.py	2010-01-11 01:04:10 +0000
@@ -17,9 +17,23 @@
         Templates generated with txGenshi work
         """
         r = example.GenshiMixPage()
-        s = r.renderSynchronously()
-        self.assertSubstring('<p>You are Joe and your stuff is here.</p>', s)
-        self.assertSubstring('<span>Your name is Joe</span>', s)
+        self._testItems(r, u'Joe')
+
+    def test_txGenshiExampleStr(self):
+        """
+        Same as the other test, but using genshistr instead
+        """
+        r = example.GenshiMixPageStr(u'Winston')
+        self._testItems(r, u'Winston')
+
+    def _testItems(self, resource, username):
+        """
+        Verify the rendered contents of the template
+        """
+        s = resource.renderSynchronously()
+        self.assertSubstring('<p>You are %s and your stuff is here.</p>' %
+                (username,), s)
+        self.assertSubstring('<span>Your name is %s</span>' % (username,), s)
         self.assertSubstring('<span>this is the value of the key</span>', s)
         self.assertSubstring('Apples are red', s)
         self.assertSubstring('<span>49 7 59</span>', s)
@@ -35,9 +49,12 @@
         self.assertTrue(re.search(r'<span>\s*Hello again, Dude\s*</span>', s))
         self.assertSubstring('<li class="odd">item 0</li>', s)
         self.assertSubstring('<li class="even">item 9</li>', s)
-        self.assertSubstring('<li>Joe</li>', s)
-        self.assertTrue(re.search(r'<h2>Genshi :replace</h2>\s*Joe\s*</ul>', s))
+        self.assertSubstring('<li>%s</li>' % (username,), s)
+        self.assertTrue(re.search(r'<h2>Genshi :replace</h2>\s*%s\s*</ul>' %
+            (username,), s))
         self.assertTrue(re.search(r'<h2>Genshi :strip</h2>\s*<b>foo</b>\s*</div>', s))
+        self.assertSubstring('<b>Ninja Kitteh is not defined, %s</b>' %
+                (username,), s)
 
     def test_xinclude(self):
         """

=== added file 'txgenshi/test/test_loader.py'
--- txgenshi/test/test_loader.py	1970-01-01 00:00:00 +0000
+++ txgenshi/test/test_loader.py	2010-01-11 01:04:10 +0000
@@ -0,0 +1,90 @@
+"""
+Test for miscellaneous features of loader.py not covered by template
+processing specifically
+"""
+from itertools import count
+
+from twisted.trial import unittest
+
+from txgenshi import loader
+
+class TxGenshiContextTest(unittest.TestCase):
+    """
+    TxGenshiContext is able to retrieve data
+    """
+    def setUp(self):
+        data = {'h':1, 'i': 2, 'j': 3}
+        self.ctx = loader.TxGenshiContext(data)
+
+    def test_access(self):
+        """
+        We can do a simple get when a TGC is initialized with a dict
+        """
+        self.assertEqual(self.ctx.get('h'), 1)
+        self.assertEqual(self.ctx.get('k'), None)
+        self.assertEqual(self.ctx.get('k', 99), 99)
+
+    def test_builtins(self):
+        """
+        The builtin functions defined and value_of work as advertised
+        """
+        self.assertEqual(self.ctx.get('defined')('h'), True)
+        self.assertEqual(self.ctx.get('value_of')('j'), 3)
+
+
+class Apple(object):
+    color = 'red'
+
+    def __init__(self):
+        self.counter = count(27)
+        self.x = 1
+
+    def eat(self):
+        return "yum"
+
+    @property
+    def peeled(self):
+        return 'peeled %s times' % (self.counter.next(),)
+
+
+class DataProxyTest(unittest.TestCase):
+    """
+    A DataProxy can stand in for a dict, and correctly does caching
+    """
+    def setUp(self):
+        self.apple = Apple()
+        self.dp = loader.DataProxy(self.apple)
+        self.dp['other'] = lambda: 17.6
+
+    def test_key(self):
+        """
+        We can reach normal keys
+        """
+        self.assertEqual(self.dp['x'], 1)
+        self.assertRaises(KeyError, lambda: self.dp['z'])
+        self.assertTrue('x' in self.dp)
+
+    def test_callable(self):
+        """
+        Callable attributes will be called
+        """
+        x = self.dp['eat']
+        self.assertEqual(x, 'yum')
+
+    def test_callableAddedKeys(self):
+        """
+        Test special casing for defined and value_of
+        """
+        x = self.dp['other']
+        self.assertEqual(x(), 17.6)
+
+    def test_caching(self):
+        """
+        Values are not frozen until accessed
+        """
+        # access the peel property a few times, which modifies it, to make
+        # sure we are not caching the value yet
+        self.apple.peeled; self.apple.peeled
+        self.assertEqual(self.dp['peeled'], 'peeled 30 times')
+        self.apple.peeled; self.apple.peeled
+        self.assertEqual(self.dp['peeled'], 'peeled 30 times')