Docserver: Properly implement the Cron logic for ContentProvider and TemplateDataSource so that the…

third_party/handlebar/handlebar.py

 # Copyright 2012 Benjamin Kalman
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #     http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 257 matching lines @@
     self.text.Append(text)
 
   def GetResult(self):
     return RenderResult(self.text.ToString(), self._errors);
 
 class _Identifier(object):
   '''An identifier of the form 'foo', 'foo.bar.baz', 'foo-bar.baz', etc.
   '''
   _VALID_ID_MATCHER = re.compile(r'^[a-zA-Z0-9@_/-]+$')
 
-  def __init__(self, name, line, column):
+  def __init__(self, name, line, column, title=None):
     self.name = name
     self.line = line
     self.column = column
+    self._title = title
     if name == '':
       raise ParseException('Empty identifier %s' % self.GetDescription())
     for part in name.split('.'):
       if not _Identifier._VALID_ID_MATCHER.match(part):
         raise ParseException('Invalid identifier %s' % self.GetDescription())
 
   def GetDescription(self):
-    return '\'%s\' at line %s column %s' % (self.name, self.line, self.column)
+    desc = '\'%s\' at line %s column %s' % (self.name, self.line, self.column)
+    if self._title is not None:
+      desc = '%s: %s' % (self._title, desc)
+    return desc
 
   def CreateResolutionErrorMessage(self, name, stack=None):
     message = _StringBuilder()
     message.Append('Failed to resolve %s in %s\n' % (self.GetDescription(),
                                                      name))
     if stack is not None:
       for entry in reversed(stack.entries):
         message.Append('  included as %s in %s\n' % (entry.id_.GetDescription(),
                                                      entry.name))
     return message.ToString().strip()
@@ skipping 733 matching lines @@
         line, column = tokens.next_line, (tokens.next_column + 1)
         name = tokens.AdvanceToNextWhitespace()
         clazz = _UnescapedVariableNode
         if name.startswith('*'):
           clazz = _JsonNode
         elif name.startswith('+'):
           clazz = _PartialNode.Inline
         if clazz is not _UnescapedVariableNode:
           name = name[1:]
           column += 1
-        inline_node = clazz(_Identifier(name, line, column))
+        inline_node = clazz(_Identifier(name, line, column, title=self._name))
         if isinstance(inline_node, _PartialNode):
           inline_node.SetArguments(self._ParsePartialNodeArgs(tokens))
           if bind_to is not None:
             inline_node.PassThroughArgument(bind_to)
         tokens.SkipWhitespace()
         tokens.AdvanceOver(_Token.INLINE_END_SECTION)
         return [next_token.clazz(bind_to, id_, inline_node)]
       # Block syntax.
       tokens.AdvanceOver(_Token.CLOSE_MUSTACHE)
       section = self._ParseSection(tokens)
@@ skipping 61 matching lines @@
         args[key] = {inner_id: inner_args}
       else:
         args[key] = self._NextIdentifier(tokens)
     return args or None
 
   def _NextIdentifier(self, tokens):
     tokens.SkipWhitespace()
     column_start = tokens.next_column + 1
     id_ = _Identifier(tokens.AdvanceOverNextString(excluded=' \n\r\t:()'),
                       tokens.next_line,
-                      column_start)
+                      column_start,
+                      title=self._name)
     tokens.SkipWhitespace()
     return id_
 
   def Render(self, *user_contexts):
     '''Renders this template given a variable number of contexts to read out
     values from (such as those appearing in {{foo}}).
     '''
     internal_context = _InternalContext()
     contexts = list(user_contexts)
     contexts.append({
@@ skipping 13 matching lines @@
     return self.source == other.source and self._name == other._name
 
   def __ne__(self, other):
     return not (self == other)
 
   def __repr__(self):
     return str('%s(%s)' % (type(self).__name__, self._top_node))
 
   def __str__(self):
     return repr(self)