mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
ef711586dd
Allow the template to import .py files from its own directory. This is useful for reusing support code across .gyb files. Swift SVN r19495
839 lines
26 KiB
Python
Executable File
839 lines
26 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# GYB: Generate Your Boilerplate (improved names welcome; at least
|
|
# this one's short). See -h output for instructions
|
|
|
|
import re
|
|
from cStringIO import StringIO
|
|
import tokenize
|
|
import textwrap
|
|
from bisect import bisect
|
|
import os
|
|
|
|
def getLineStarts(s):
|
|
"""Return a list containing the start index of each line in s.
|
|
|
|
The list also contains a sentinel index for the end of the string,
|
|
so there will be one more element in the list than there are lines
|
|
in the string
|
|
"""
|
|
starts = [0]
|
|
|
|
for line in s.split('\n'):
|
|
starts.append(starts[-1] + len(line)+1)
|
|
|
|
starts[-1] -= 1
|
|
return starts
|
|
|
|
def stripTrailingNL(s):
|
|
"""If s ends with a newline, drop it; else return s intact"""
|
|
return s[:-1] if s.endswith('\n') else s
|
|
|
|
def splitLines(s):
|
|
"""Split s into a list of lines, each of which has a trailing newline
|
|
|
|
If the lines are later concatenated, the result is s, possibly
|
|
with a single appended newline.
|
|
"""
|
|
return [ l + '\n' for l in s.split('\n') ]
|
|
|
|
# text on a line up to the first '$$', '${', or '%%'
|
|
literalText = r'(?: [^$\n@] | \$(?![${]) | @(?!@) )*'
|
|
|
|
# The part of an '@end' line that follows the '@' sign
|
|
atEndLine = r'[\ \t]* end [\ \t]* (?: \# .* )? $'
|
|
|
|
## Note: Where "# Absorb" appears below, the regexp attempts to eat up
|
|
## through the end of ${...} and %{...}% constructs. In reality we
|
|
## handle this with the Python tokenizer, which avoids mis-detections
|
|
## due to nesting, comments and strings. This extra absorption in the
|
|
## regexp facilitates testing the regexp on its own, by preventing the
|
|
## interior of some of these constructs from being treated as literal
|
|
## text.
|
|
tokenizeRE = re.compile(
|
|
r'''
|
|
# %-lines and %{...}-blocks
|
|
# \n? # absorb one preceding newline
|
|
^
|
|
(?:
|
|
(?P<atLines>
|
|
(?P<_indent> [\ \t]* % (?! [{%] ) [\ \t]* ) (?! [\ \t] | '''+atEndLine+r''' ) .*
|
|
( \n (?P=_indent) (?! '''+atEndLine+r''' ) .* ) *
|
|
)
|
|
| (?P<atEndLine> [\ \t]* % [ \t]* '''+atEndLine+r''' )
|
|
| [\ \t]* (?P<atBlockOpen> %\{ )
|
|
(?: [^}]| \} (?!%) )* \}% # Absorb
|
|
)
|
|
\n? # absorb one trailing newline
|
|
|
|
# Substitutions
|
|
| (?P<substitutionOpen> \$\{ )
|
|
[^}]* \} # Absorb
|
|
|
|
# %% and $$ are literal % and $ respectively
|
|
| (?P<symbol>[$%]) (?P=symbol)
|
|
|
|
# Literal text
|
|
| (?P<literal> '''+literalText+r'''
|
|
(?:
|
|
# newline that doesn't precede space+%
|
|
(?: \n (?! [\ \t]* %[^%] ) )
|
|
'''+literalText+r'''
|
|
)*
|
|
\n?
|
|
)
|
|
'''
|
|
, re.VERBOSE|re.MULTILINE)
|
|
|
|
atBlockClose = re.compile('\}%[ \t]*\n?')
|
|
|
|
def tokenPosToIndex(tokenPos, start, lineStarts):
|
|
"""Translate a tokenize (line, column) pair into an absolute
|
|
position in source text given the position where we started
|
|
tokenizing and a list that maps lines onto their starting
|
|
character indexes.
|
|
"""
|
|
relativeTokenLinePlus1, tokenCol = tokenPos
|
|
|
|
# line number where we started tokenizing
|
|
startLineNum = bisect(lineStarts, start) - 1
|
|
|
|
# line number of the token in the whole text
|
|
absTokenLine = relativeTokenLinePlus1 - 1 + startLineNum
|
|
|
|
# if found in the first line, adjust the end column to account
|
|
# for the extra text
|
|
if relativeTokenLinePlus1 == 1:
|
|
tokenCol += start - lineStarts[startLineNum]
|
|
|
|
# Sometimes tokenizer errors report a line beyond the last one
|
|
if absTokenLine >= len(lineStarts):
|
|
return lineStarts[-1]
|
|
|
|
return lineStarts[absTokenLine] + tokenCol
|
|
|
|
def tokenizePythonToUnmatchedCloseCurly(sourceText, start, lineStarts):
|
|
"""Apply Python's tokenize to sourceText starting at index start
|
|
while matching open and close curly braces. When an unmatched
|
|
close curly brace is found, return its index. If not found,
|
|
return len(sourceText). If there's a tokenization error, return
|
|
the position of the error.
|
|
"""
|
|
stream = StringIO(sourceText)
|
|
stream.seek( start )
|
|
nesting = 0
|
|
|
|
try:
|
|
for kind, text, tokenStart, tokenEnd, lineText \
|
|
in tokenize.generate_tokens(stream.readline):
|
|
|
|
if text == '{':
|
|
nesting += 1
|
|
elif text == '}':
|
|
nesting -= 1
|
|
if nesting < 0:
|
|
return tokenPosToIndex(tokenStart, start, lineStarts)
|
|
|
|
except tokenize.TokenError, (message, errorPos):
|
|
return tokenPosToIndex(errorPos, start, lineStarts)
|
|
|
|
return len(sourceText)
|
|
|
|
def tokenizeTemplate(templateText):
|
|
r"""Given the text of a template, returns an iterator over
|
|
(tokenType,token,match) tuples.
|
|
|
|
**Note**: this is template syntax tokenization, not Python
|
|
tokenization.
|
|
|
|
When a non-literal token is matched, a client may call
|
|
iter.send(pos) on the iterator to reset the position in
|
|
templateText at which scanning will resume.
|
|
|
|
This function provides a base level of tokenization which is
|
|
then refined by ParseContext.tokenGenerator.
|
|
|
|
>>> for kind, text, _ in tokenizeTemplate('''
|
|
... This is $some$ literal stuff containing a ${substitution}
|
|
... followed by a %{...} block:
|
|
... %{
|
|
... # Python code
|
|
... }%
|
|
... and here $${are} some %-lines:
|
|
... % x = 1
|
|
... % y = 2
|
|
... % if z == 3:
|
|
... % print '${hello}'
|
|
... % end
|
|
... % for x in zz:
|
|
... % print x
|
|
... % # different indentation
|
|
... % twice
|
|
... and some lines that literally start with %
|
|
... %% first line
|
|
... %% second line
|
|
... '''):
|
|
... print (kind, text.strip().split('\n',1)[0])
|
|
('literal', 'This is $some$ literal stuff containing a')
|
|
('substitutionOpen', '${')
|
|
('literal', 'followed by a %{...} block:')
|
|
('atBlockOpen', '%{')
|
|
('literal', 'and here ${are} some %-lines:')
|
|
('atLines', '% x = 1')
|
|
('atEndLine', '% end')
|
|
('atLines', '% for x in zz:')
|
|
('atLines', '% # different indentation')
|
|
('atLines', '% twice')
|
|
('literal', 'and some lines that literally start with %')
|
|
"""
|
|
pos = 0
|
|
end = len(templateText)
|
|
|
|
savedLiteral = []
|
|
literalFirstMatch = None
|
|
|
|
while pos < end:
|
|
m = tokenizeRE.match(templateText, pos, end)
|
|
|
|
# pull out the one matched key (ignoring internal patterns starting with _)
|
|
((kind, text), ) = (
|
|
(kind,text) for (kind,text) in m.groupdict().items()
|
|
if text is not None and kind[0] != '_')
|
|
|
|
if kind in ('literal', 'symbol'):
|
|
if len(savedLiteral) == 0:
|
|
literalFirstMatch = m
|
|
savedLiteral.append(text) # literals and symbols get batched together
|
|
pos = None
|
|
else:
|
|
# found a non-literal. First yield any literal we've accumulated
|
|
if savedLiteral != []:
|
|
yield 'literal', ''.join(savedLiteral), literalFirstMatch
|
|
savedLiteral = []
|
|
|
|
# Then yield the thing we found. If we get a reply, it's
|
|
# the place to resume tokenizing
|
|
pos = yield kind, text, m
|
|
|
|
# If we were not sent a new position by our client, resume
|
|
# tokenizing at the end of this match.
|
|
if pos is None:
|
|
pos = m.end(0)
|
|
else:
|
|
yield # Client is not yet ready to process next token
|
|
|
|
if savedLiteral != []:
|
|
yield 'literal', ''.join(savedLiteral), literalFirstMatch
|
|
|
|
def splitAtLines(sourceLines):
|
|
r"""Return a list of lines at which to split the incoming source
|
|
|
|
These positions represent the beginnings of python blocks that
|
|
will require a matching %end construct if they are to be closed.
|
|
|
|
>>> src = splitLines('''\
|
|
... if x:
|
|
... print x
|
|
... if y: # trailing comment
|
|
... print z
|
|
... if z: # another comment\
|
|
... ''')
|
|
>>> s = splitAtLines(src)
|
|
>>> len(s)
|
|
2
|
|
>>> src[s[0]]
|
|
' print z\n'
|
|
>>> s[1] - len(src)
|
|
0
|
|
|
|
>>> src = splitLines('''\
|
|
... if x:
|
|
... if y: print 1
|
|
... if z:
|
|
... print 2
|
|
... pass\
|
|
... ''')
|
|
>>> s = splitAtLines(src)
|
|
>>> len(s)
|
|
1
|
|
>>> src[s[0]]
|
|
' if y: print 1\n'
|
|
"""
|
|
lastTokenText,lastTokenKind = None,None
|
|
unmatchedIndents = []
|
|
|
|
try:
|
|
for tokenKind, tokenText, tokenStart, (tokenEndLine, tokenEndCol), lineText \
|
|
in tokenize.generate_tokens(sourceLines.__iter__().next):
|
|
|
|
if tokenKind in (tokenize.COMMENT, tokenize.ENDMARKER):
|
|
continue
|
|
|
|
if tokenText == '\n' and lastTokenText == ':':
|
|
unmatchedIndents.append(tokenEndLine)
|
|
elif lastTokenKind == tokenize.DEDENT:
|
|
unmatchedIndents.pop()
|
|
|
|
lastTokenText,lastTokenKind = tokenText,tokenKind
|
|
|
|
except tokenize.TokenError, (message, errorPos):
|
|
return [] # Let the later compile() call report the error
|
|
|
|
if lastTokenText == ':':
|
|
unmatchedIndents.append(len(sourceLines))
|
|
|
|
return unmatchedIndents
|
|
|
|
def codeStartsWithDedentKeyword(sourceLines):
|
|
r"""Return True iff the incoming Python sourceLines begin with "else",
|
|
"elif", "except", or "finally".
|
|
|
|
Initial comments and whitespace are ignored.
|
|
|
|
>>> codeStartsWithDedentKeyword(splitLines('if x in y: pass'))
|
|
False
|
|
>>> codeStartsWithDedentKeyword(splitLines('except ifSomethingElseHappens:'))
|
|
True
|
|
>>> codeStartsWithDedentKeyword(splitLines('\n# this is a comment\nelse: # yes'))
|
|
True
|
|
"""
|
|
tokenText = None
|
|
for tokenKind, tokenText, _, _, _ \
|
|
in tokenize.generate_tokens(sourceLines.__iter__().next):
|
|
|
|
if tokenKind != tokenize.COMMENT and tokenText.strip() != '':
|
|
break
|
|
|
|
return tokenText in ('else', 'elif', 'except', 'finally')
|
|
|
|
class ParseContext:
|
|
"""State carried through a parse of a template"""
|
|
filename = ''
|
|
template = ''
|
|
lineStarts = []
|
|
codeStartLine = -1
|
|
codeText = None
|
|
tokens = None # The rest of the tokens
|
|
closeBlock = False
|
|
|
|
def __init__(self, filename, template = None):
|
|
self.filename = os.path.abspath(filename)
|
|
self.template = template or open(filename).read()
|
|
self.lineStarts = getLineStarts(self.template)
|
|
self.tokens = self.tokenGenerator(tokenizeTemplate(self.template))
|
|
self.nextToken()
|
|
|
|
def posToLine(self, pos):
|
|
return bisect(self.lineStarts, pos) - 1
|
|
|
|
def tokenGenerator(self, baseTokens):
|
|
r""" Given an iterator over (kind, text, match) triples (see
|
|
tokenizeTemplate above), return a refined iterator over
|
|
tokenKinds.
|
|
|
|
Among other adjustments to the elements found by baseTokens,
|
|
this refined iterator tokenizes python code embedded in
|
|
template text to help determine its true extent. The
|
|
expression "baseTokens.send(pos)" is used to reset the index at
|
|
which baseTokens resumes scanning the underlying text.
|
|
|
|
>>> ctx = ParseContext('dummy', '''
|
|
... %for x in y:
|
|
... % print x
|
|
... % end
|
|
... ''')
|
|
>>> ctx.tokenKind
|
|
'literal'
|
|
>>> ctx.tokenText
|
|
'\n'
|
|
>>> ctx.nextToken()
|
|
'atLinesOpen'
|
|
>>> ctx.codeText
|
|
'for x in y:\n'
|
|
>>> ctx.nextToken()
|
|
'atLines'
|
|
>>> ctx.codeText
|
|
' print x\n'
|
|
>>> ctx.nextToken()
|
|
'atEndLine'
|
|
"""
|
|
for self.tokenKind, self.tokenText, self.tokenMatch in baseTokens:
|
|
kind = self.tokenKind
|
|
self.codeText = None
|
|
|
|
# Do we need to close the current block?
|
|
self.closeBlock = kind == 'atEndLine'
|
|
|
|
if kind.endswith('Open'): # %{...}% and ${...} constructs
|
|
|
|
# Tokenize text that follows as Python up to an unmatched '}'
|
|
codeStart = self.tokenMatch.end(kind)
|
|
self.codeStartLine = self.posToLine(codeStart)
|
|
|
|
closePos = tokenizePythonToUnmatchedCloseCurly(
|
|
self.template, codeStart, self.lineStarts)
|
|
self.codeText = self.template[codeStart:closePos]
|
|
yield kind
|
|
|
|
if (kind == 'atBlockOpen'):
|
|
# Absorb any '}% <optional-comment> \n'
|
|
m2 = atBlockClose.match(self.template, closePos)
|
|
assert m2, "Invalid block closure" # FIXME: need proper error handling here.
|
|
nextPos = m2.end(0)
|
|
else:
|
|
assert kind == 'substitutionOpen'
|
|
nextPos = closePos + 1 # skip past the closing '}'
|
|
|
|
# Resume tokenizing after the end of the code.
|
|
baseTokens.send(nextPos)
|
|
|
|
elif kind == 'atLines':
|
|
|
|
self.codeStartLine = self.posToLine(self.tokenMatch.start('atLines'))
|
|
codeStartPos = self.tokenMatch.end('_indent')
|
|
indentation = self.tokenMatch.group('_indent')
|
|
|
|
# Strip off the leading indentation and %-sign
|
|
sourceLines = re.split(
|
|
'^' + re.escape(indentation),
|
|
self.tokenMatch.group('atLines')+'\n',
|
|
flags=re.MULTILINE)[1:]
|
|
|
|
if codeStartsWithDedentKeyword(sourceLines):
|
|
self.closeBlock = True
|
|
|
|
lastSplit = 0
|
|
for line in splitAtLines(sourceLines):
|
|
self.tokenKind = 'atLinesOpen'
|
|
self.codeText = ''.join(sourceLines[lastSplit:line])
|
|
yield self.tokenKind
|
|
lastSplit = line
|
|
self.codeStartLine += line - lastSplit
|
|
|
|
self.codeText = ''.join(sourceLines[lastSplit:])
|
|
if self.codeText:
|
|
self.tokenKind = 'atLines'
|
|
yield self.tokenKind
|
|
else:
|
|
yield self.tokenKind
|
|
|
|
|
|
def nextToken(self):
|
|
"""Move to the the next token"""
|
|
for kind in self.tokens:
|
|
# print '<<%s>>' % kind
|
|
# print self.codeText or self.tokenText
|
|
# print '========'
|
|
return self.tokenKind
|
|
|
|
self.tokenKind = None
|
|
|
|
class ExecutionContext:
|
|
"""State we pass around during execution of a template"""
|
|
def __init__(self, lineDirective='// ###line', **localBindings):
|
|
self.localBindings = localBindings
|
|
self.lineDirective = lineDirective
|
|
self.localBindings['__context__'] = self
|
|
self.resultText = []
|
|
self.lastFileLine = None
|
|
|
|
def appendText(self, text, file, line):
|
|
# see if we need to inject a line marker
|
|
if self.lineDirective:
|
|
if (file,line) != self.lastFileLine and (
|
|
len(self.resultText) == 0
|
|
or self.resultText[-1].endswith('\n')):
|
|
self.resultText.append(
|
|
'%s %d "%s"\n' % (self.lineDirective, line + 1, file)
|
|
)
|
|
self.resultText.append(text)
|
|
self.lastFileLine = (file, line + text.count('\n'))
|
|
|
|
class ASTNode(object):
|
|
"""Abstract base class for template AST nodes"""
|
|
def __init__(self):
|
|
raise NotImplemented
|
|
|
|
def execute(self, context):
|
|
raise NotImplemented
|
|
|
|
def __str__(self, indent = ''):
|
|
raise NotImplemented
|
|
|
|
def formatChildren(self, indent):
|
|
if not self.children:
|
|
return ' []'
|
|
|
|
return '\n'.join(
|
|
['', indent + '[']
|
|
+ [ x.__str__(indent + 4*' ') for x in self.children ]
|
|
+ [indent + ']'])
|
|
|
|
|
|
class Block(ASTNode):
|
|
"""A sequence of other AST nodes, to be executed in order"""
|
|
children = []
|
|
|
|
def __init__(self, context):
|
|
self.children = []
|
|
|
|
while context.tokenKind and not context.closeBlock:
|
|
if context.tokenKind == 'literal':
|
|
Node = Literal
|
|
else:
|
|
Node = Code
|
|
self.children.append(Node(context))
|
|
|
|
def execute(self, context):
|
|
for x in self.children:
|
|
x.execute(context)
|
|
|
|
def __str__(self, indent = ''):
|
|
return indent + 'Block:' + self.formatChildren(indent)
|
|
|
|
class Literal(ASTNode):
|
|
"""An AST node that generates literal text"""
|
|
def __init__(self, context):
|
|
self.text = context.tokenText
|
|
startPosition = context.tokenMatch.start(context.tokenKind)
|
|
self.startLineNumber = context.posToLine(startPosition)
|
|
self.filename = context.filename
|
|
context.nextToken()
|
|
|
|
def execute(self, context):
|
|
context.appendText(self.text, self.filename, self.startLineNumber)
|
|
|
|
def __str__(self, indent = ''):
|
|
return '\n'.join(
|
|
[indent + x for x in [ 'Literal:'] + stripTrailingNL(self.text).split('\n')])
|
|
|
|
class Code(ASTNode):
|
|
"""An AST node that is evaluated as Python"""
|
|
code = None
|
|
children = ()
|
|
kind = None
|
|
|
|
def __init__(self, context):
|
|
|
|
source = ''
|
|
sourceLineCount = 0
|
|
|
|
def accumulateCode():
|
|
s = source + (context.codeStartLine - sourceLineCount) * '\n' \
|
|
+ textwrap.dedent(context.codeText)
|
|
lineCount = context.codeStartLine + context.codeText.count('\n')
|
|
context.nextToken()
|
|
return s, lineCount
|
|
|
|
evalExec = 'exec'
|
|
if context.tokenKind.startswith('substitution'):
|
|
evalExec = 'eval'
|
|
source, sourceLineCount = accumulateCode()
|
|
source = '('+source.strip()+')'
|
|
|
|
while context.tokenKind == 'atLinesOpen':
|
|
source, sourceLineCount = accumulateCode()
|
|
source += ' __children__[%d].execute(__context__)\n' % len(self.children)
|
|
sourceLineCount += 1
|
|
|
|
self.children += (Block(context),)
|
|
|
|
if context.tokenKind == 'atLines':
|
|
source, sourceLineCount = accumulateCode()
|
|
|
|
# Only handle a substitution as part of this code block if
|
|
# we don't already have some %-lines.
|
|
elif context.tokenKind == 'atBlockOpen':
|
|
|
|
# Opening ${...} and %{...}% constructs
|
|
source, sourceLineCount = accumulateCode()
|
|
|
|
self.filename = context.filename
|
|
self.startLineNumber = context.codeStartLine
|
|
self.code = compile(source, context.filename, evalExec)
|
|
self.source = source
|
|
|
|
if context.tokenKind == 'atEndLine':
|
|
context.nextToken()
|
|
|
|
def execute(self, context):
|
|
# Save __children__ from the local bindings
|
|
saveChildren = context.localBindings.get('__children__')
|
|
# Execute the code with our __children__ in scope
|
|
context.localBindings['__children__'] = self.children
|
|
result = eval(self.code, context.localBindings)
|
|
assert context.localBindings['__children__'] is self.children
|
|
# Restore the bindings
|
|
context.localBindings['__children__'] = saveChildren
|
|
|
|
# If we got a result, the code was an expression, so append
|
|
# its value
|
|
if result is not None and result != '':
|
|
context.appendText(str(result), self.filename, self.startLineNumber)
|
|
|
|
def __str__(self, indent = ''):
|
|
sourceLines = re.sub(r'^\n', '', stripTrailingNL(self.source), flags=re.MULTILINE).split('\n')
|
|
if len(sourceLines) == 1:
|
|
s = indent + 'Code: {' + sourceLines[0] + '}'
|
|
else:
|
|
s = indent + 'Code:\n' + indent + '{\n' + '\n'.join(
|
|
indent + 4*' ' + l for l in sourceLines
|
|
) + '\n' + indent + '}'
|
|
return s + self.formatChildren(indent)
|
|
|
|
def parseTemplate(filename, text = None):
|
|
r"""Return an AST corresponding to the given template file.
|
|
|
|
If text is supplied, it is assumed to be the contents of the file,
|
|
as a string.
|
|
|
|
>>> print parseTemplate('dummy.file', text='''%
|
|
... %for x in y:
|
|
... % print y
|
|
... ''')
|
|
Block:
|
|
[
|
|
Code:
|
|
{
|
|
for x in y:
|
|
__children__[0].execute(__context__)
|
|
}
|
|
[
|
|
Block:
|
|
[
|
|
Code: {print y} []
|
|
]
|
|
]
|
|
]
|
|
|
|
>>> print parseTemplate('dummy.file', text='''%
|
|
... %if x:
|
|
... % print y
|
|
... AAAA
|
|
... %else:
|
|
... BBBB
|
|
... ''')
|
|
Block:
|
|
[
|
|
Code:
|
|
{
|
|
if x:
|
|
__children__[0].execute(__context__)
|
|
else:
|
|
__children__[1].execute(__context__)
|
|
}
|
|
[
|
|
Block:
|
|
[
|
|
Code: {print y} []
|
|
Literal:
|
|
AAAA
|
|
]
|
|
Block:
|
|
[
|
|
Literal:
|
|
BBBB
|
|
]
|
|
]
|
|
]
|
|
|
|
>>> print parseTemplate('dummy.file', text='''%
|
|
... %if x:
|
|
... % print y
|
|
... AAAA
|
|
... %# This is a comment
|
|
... %else:
|
|
... BBBB
|
|
... ''')
|
|
Block:
|
|
[
|
|
Code:
|
|
{
|
|
if x:
|
|
__children__[0].execute(__context__)
|
|
# This is a comment
|
|
else:
|
|
__children__[1].execute(__context__)
|
|
}
|
|
[
|
|
Block:
|
|
[
|
|
Code: {print y} []
|
|
Literal:
|
|
AAAA
|
|
]
|
|
Block:
|
|
[
|
|
Literal:
|
|
BBBB
|
|
]
|
|
]
|
|
]
|
|
|
|
>>> print parseTemplate('dummy.file', text='''\
|
|
... %for x in y:
|
|
... AAAA
|
|
... %if x:
|
|
... BBBB
|
|
... %end
|
|
... CCCC
|
|
... ''')
|
|
Block:
|
|
[
|
|
Code:
|
|
{
|
|
for x in y:
|
|
__children__[0].execute(__context__)
|
|
}
|
|
[
|
|
Block:
|
|
[
|
|
Literal:
|
|
AAAA
|
|
Code:
|
|
{
|
|
if x:
|
|
__children__[0].execute(__context__)
|
|
}
|
|
[
|
|
Block:
|
|
[
|
|
Literal:
|
|
BBBB
|
|
]
|
|
]
|
|
Literal:
|
|
CCCC
|
|
]
|
|
]
|
|
]
|
|
"""
|
|
return Block(ParseContext(filename, text))
|
|
|
|
def executeTemplate(ast, lineDirective='', **localBindings):
|
|
r"""Return the text generated by executing the given template AST.
|
|
|
|
Keyword arguments become local variable bindings in the execution context
|
|
|
|
>>> ast = parseTemplate('/dummy.file', text=
|
|
... '''Nothing
|
|
... % if x:
|
|
... % for i in range(3):
|
|
... ${i}
|
|
... % end
|
|
... % else:
|
|
... THIS SHOULD NOT APPEAR IN THE OUTPUT
|
|
... ''')
|
|
>>> print executeTemplate(ast, lineDirective='//#line', x=1),
|
|
//#line 1 "/dummy.file"
|
|
Nothing
|
|
//#line 4 "/dummy.file"
|
|
0
|
|
//#line 4 "/dummy.file"
|
|
1
|
|
//#line 4 "/dummy.file"
|
|
2
|
|
"""
|
|
executionContext = ExecutionContext(lineDirective=lineDirective, **localBindings)
|
|
ast.execute(executionContext)
|
|
return ''.join(executionContext.resultText)
|
|
|
|
def main():
|
|
import argparse, sys
|
|
|
|
parser = argparse.ArgumentParser(
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
description='Generate Your Boilerplate!', epilog='''
|
|
A GYB template consists of the following elements:
|
|
|
|
- Literal text which is inserted directly into the output
|
|
|
|
- %% or $$ in literal text, which insert literal '%' and '$'
|
|
symbols respectively.
|
|
|
|
- Substitutions of the form ${<python-expression>}. The Python
|
|
expression is converted to a string and the result is inserted
|
|
into the output.
|
|
|
|
- Python code delimited by %{...}%. Typically used to inject
|
|
definitions (functions, classes, variable bindings) into the
|
|
evaluation context of the template. Common indentation is
|
|
stripped, so you can add as much indentation to the beginning
|
|
of this code as you like
|
|
|
|
- Lines beginning with optional whitespace followed by a single
|
|
'%' and Python code. %-lines allow you to nest other
|
|
constructs inside them. To close a level of nesting, use the
|
|
"%end" construct.
|
|
|
|
- Lines beginning with optional whitespace and followed by a
|
|
single '%' and the token "end", which close open constructs in
|
|
%-lines.
|
|
|
|
Example template:
|
|
|
|
- Hello -
|
|
%{
|
|
x = 42
|
|
def succ(a):
|
|
return a+1
|
|
}%
|
|
|
|
I can assure you that ${x} < ${succ(x)}
|
|
|
|
% if int(y) > 7:
|
|
% for i in range(3):
|
|
y is greater than seven!
|
|
% end
|
|
% else:
|
|
y is less than or equal to seven
|
|
% end
|
|
|
|
- The End. -
|
|
|
|
When run with "gyb -Dy=9", the output is
|
|
|
|
- Hello -
|
|
|
|
I can assure you that 42 < 43
|
|
|
|
y is greater than seven!
|
|
y is greater than seven!
|
|
y is greater than seven!
|
|
|
|
- The End. -
|
|
'''
|
|
)
|
|
parser.add_argument('-D', action='append', dest='defines', metavar='NAME=VALUE',
|
|
default=[],
|
|
help='''Bindings to be set in the template's execution context'''
|
|
)
|
|
|
|
parser.add_argument('file', type=argparse.FileType(), help='Path to GYB template file (defaults to stdin)', nargs='?', default=sys.stdin)
|
|
parser.add_argument('-o', dest='target', type=argparse.FileType('w'), help='Output file (defaults to stdout)', default=sys.stdout)
|
|
parser.add_argument('--test', action='store_true', default=False, help='Run a self-test')
|
|
parser.add_argument('--verbose-test', action='store_true', default=False, help='Run a verbose self-test')
|
|
parser.add_argument('--dump', action='store_true', default=False, help='Dump the parsed template to stdout')
|
|
parser.add_argument('--line-directive', default='// ###line', help='Line directive prefix; empty => no line markers')
|
|
|
|
|
|
args = parser.parse_args(sys.argv[1:])
|
|
|
|
if args.test or args.verbose_test:
|
|
import doctest
|
|
if doctest.testmod(verbose=args.verbose_test).failed:
|
|
exit(1)
|
|
|
|
bindings = dict( x.split('=', 1) for x in args.defines )
|
|
ast = parseTemplate(args.file.name, args.file.read())
|
|
if args.dump:
|
|
print ast
|
|
|
|
# Allow the template to import .py files from its own directory
|
|
sys.path = [os.path.split(args.file.name)[0] or '.'] + sys.path
|
|
|
|
args.target.write(executeTemplate(ast, args.line_directive, **bindings))
|
|
|
|
if __name__ == '__main__':
|
|
main()
|
|
|