def testMemorySafety(self):
# This is meant to be run with ASAN and checks that
# certain use-after-frees are not present.
cgi = neo_cgi.CGI()
hdf = cgi.hdf
del cgi
hdf.getValue("x", "y")
del hdf
cgi = neo_cgi.CGI()
cs = cgi.cs()
del cgi
cs.parseStr("x")
del cs
hdf = neo_util.HDF()
hdf.setValue("y.z", "1")
child = hdf.getChild("y")
del hdf
child.getValue("x", "y")
del child
hdf = neo_util.HDF()
cs = neo_cs.CS(hdf)
del hdf
cs.parseStr("x")
del cs
def execute(macro, args):
request = macro.request
content = []
page_name = macro.formatter.page.page_name
# get args
include_page_name = ''
if args is not None:
(include_page_name, _, hdf_text) = args.partition(',')
include_page_name = wikiutil.AbsPageName(page_name, include_page_name)
include_page = Page(request, include_page_name)
if include_page is None:
return ''
if not request.user.may.read(include_page_name):
return ''
cstemplate = include_page.getPageText()
pagename = macro.formatter.page.page_name
hdf = neo_util.HDF()
hdf.readString(hdf_text)
hdf.setValue("Config.WhiteSpaceStrip ", "0")
cs = neo_cs.CS(hdf)
cs.parseStr(cstemplate)
body = cs.render()
body = wikiutil.renderText(request, WikiParser, body)
return body
def _render(f, template_file, environ, start_response, *args, **kwds):
# call our original function with original args
try:
results = f(environ, start_response)
template_name, ext = template_file.split(".")
contenttype = "text/html"
if len(ext) > 1 and (ext[1] in extensions):
contenttype = extensions[ext[1]]
hdf = neo_util.HDF()
_set(hdf, '', results)
hdf.setValue('style', stylesheet_uri)
# shove the results into the template
clearsilver = neo_cs.CS(hdf)
clearsilver.parseFile(os.path.join('templates', template_name + '.cs'))
# XXX where is our error handling?
start_response("200 OK", [('Content-Type', contenttype)])
return [clearsilver.render()]
except DataNotFound:
start_response("404 Not Found", [('Content-Type', 'text/plain')])
return ['404 Error, Content not found']
except HTTP303, e:
url = str(e.value)
if not url.startswith(('http', '/')):
url = request_uri(environ) + url
start_response("302 Found", [('Location', url)])
return ['Redirect to url']
def error(self, ecode, reason=None):
import httpResponses
message = httpResponses.gHTTPResponses[ecode]
template = httpResponses.errorMessage_Default
if ecode == 404:
template = httpResponses.errorMessage_404
hdf = neo_util.HDF()
hdf.setValue("code", str(ecode))
if message: hdf.setValue("message", message)
if reason: hdf.setValue("reason", reason)
for key, val in self.context.environ.items():
hdf.setValue("environ." + key, str(val))
self.context.stdout.write("Content-Type: text/html\r\n")
self.context.setStatus(None, ecode)
self.context.stdout.write("Status: %s\r\n" % ecode)
self.context.stdout.write("\r\n")
cs = neo_cs.CS(hdf)
cs.parseStr(template)
page = cs.render()
self.context.stdout.write(page)
warn("Error", message, reason)
def eval_cs(hdf,a_cs_string):
cs = neo_cs.CS(hdf)
try:
cs.parseStr(a_cs_string)
return cs.render()
except:
return "Error in CS tags: %s" % neo_cgi.htmlEscape(repr(a_cs_string))
def render(self, template, form_token=None):
"""Render the HDF using the given template.
The template parameter can be either an already parse neo_cs.CS
object, or a string. In the latter case it is interpreted as name of the
template file.
"""
if isinstance(template, basestring):
filename = template
try:
import neo_cs
except ImportError:
raise TracError("You're using a plugin which requires "
"the Clearsilver template engine and "
"Clearsilver is not installed. "
"Either disable that plugin or install "
"Clearsilver.")
template = neo_cs.CS(self.hdf)
template.parseFile(filename)
if form_token:
from cStringIO import StringIO
out = StringIO()
injector = FormTokenInjector(form_token, out)
injector.feed(template.render())
return out.getvalue()
else:
return template.render()
def redirectUri(self, redirectTo):
ncgi = self.ncgi
if ncgi.hdf.getIntValue("Cookie.debug", 0) == 1:
ncgi.hdf.setValue("CGI.REDIRECT_TO", redirectTo)
# ncgi.display("dbg/redirect.cs")
cs = neo_cs.CS(ncgi.hdf)
self['Content-Type'] = "text/html"
template = """
Redirect
<br><br>
<a href="<?cs var:CGI.REDIRECT_TO ?>"><?cs var:CGI.REDIRECT_TO ?></a>
"""
cs.parseStr(template)
page = cs.render()
self.push(page)
self.push("<PRE>\n")
self.push(neo_cgi.htmlEscape(ncgi.hdf.dump()) + "\n")
self.push("</PRE>\n")
raise DisplayDone()
self.context.setStatus(self, 302)
self.ncgi.redirectUri(redirectTo)
raise Redirected("redirected To: %s" % redirectTo)
def GenreateCode(self):
items = urllib2.unquote(request.params['hdf']).split(';')
# .split(';')
hdf = neo_util.HDF()
print items
for item in items:
print item
v = item.split('=')
if (len(v) == 2):
hdf.setValue(v[0], v[1])
cs = neo_cs.CS(hdf)
cs.parseFile("./feedtpladmin/public/feed-java-code.cs"
) # parse a file from disk
gen_code = cs.render()
url_path = '/FeedBuilder_' + request.params[
'stype'] + '_' + request.params['version'] + '.java'
f = open("./feedtpladmin/public" + url_path, "w")
f.write(gen_code)
f.close()
return url_path
def format(self, formatter):
# print "format"
# format is also called for each !# command. its called after __init__
# is called. this is where parsers do most of their work.
# they write their results into the Httprequest object
# which is usually stored from __init__ in self.request.
# print "formatter",dir(formatter)
# formatter is a special object in MoinMoin that
# is supposed to help people who write extensions to have
# sort of a uniform looking thing going on.
# see http://moinmoin.wikiwikiweb.de/ApplyingFormatters?highlight=%28formatter%29
# but formatter is not documented well. you have to look at
# moinmoin/formatter/base.py. And if you do, you will see that half of
# the methods raise a 'not implemented' error.
# formatter is also being refactored alot so dont get used to it.
# if all else fails just use formatter.rawHTML which will
# screw up XML output but at least it will work.
page_name = formatter.page.page_name
cs_template_page = wikiutil.AbsPageName(page_name,
self.kw["format_args"])
cs_template = Page(self.request, cs_template_page).getPageText()
hdf = neo_util.HDF()
hdf.readString(self.raw)
hdf.setValue("Config.WhiteSpaceStrip", "0")
cs = neo_cs.CS(hdf)
cs.parseStr(cs_template)
body = cs.render()
body = wikiutil.renderText(self.request, WikiParser, body)
self.request.write(formatter.rawHTML(body))
def testCsRenderStrip(self):
hdf = neo_util.HDF()
cs = neo_cs.CS(hdf)
hdf.setValue("Foo.Bar", "1")
cs.parseStr("This is my file <?cs var:Foo.Bar ?> ")
assert cs.render() == 'This is my file 1 '
hdf.setValue("ClearSilver.WhiteSpaceStrip", "1")
assert cs.render() == 'This is my file 1 '
def parse(self, string):
"""Parse the given string as template text, and returns a neo_cs.CS
object.
"""
import neo_cs
cs = neo_cs.CS(self.hdf)
cs.parseStr(string)
return cs
def __init__(self, env, msg_template):
self.env = env
self.db = env.get_db_cnx()
self.hdf = neo_util.HDF()
core.populate_hdf(self.hdf, env, self.db, None)
tmpl = os.path.join(env.get_config('general', 'templates_dir'),
msg_template)
self.cs = neo_cs.CS(self.hdf)
self.cs.parseFile(tmpl)
def ValidateTemplate(self):
tpl = request.params['tpl']
hdf = neo_util.HDF() # create an HDF dataset
cs = neo_cs.CS(hdf)
try:
cs.parseStr(urllib2.unquote(str(tpl)))
cs.render()
except neo_util.ParseError, e:
return "错误:", str(e)
def render():
hdf = neo_util.HDF()
hdf.setValue('hdf.loadpaths.0', dirname)
hdf.setValue('title', escape('Just a test'))
hdf.setValue('user', escape('joe'))
for num in range(1, 15):
hdf.setValue('items.%d' % (num - 1), escape('Number %d' % num))
cs = neo_cs.CS(hdf)
cs.parseFile('template.cs')
return cs.render()
def render():
hdf = neo_util.HDF()
hdf.setValue("hdf.loadpaths.0", dirname)
hdf.setValue("title", escape("Just a test"))
hdf.setValue("user", escape("joe"))
for num in range(1, 15):
hdf.setValue("items.%d" % (num - 1), escape("Number %d" % num))
cs = neo_cs.CS(hdf)
cs.parseFile("template.cs")
return cs.render()
def ValidateTemplate(self):
stype = int(request.params['stype'])
tpl = request.params['tpl']
if stype <= 0 or not tpl:
return '请求参数错误'
hdf = neo_util.HDF() # create an HDF dataset
cs = neo_cs.CS(hdf)
try:
cs.parseStr(urllib2.unquote(str(tpl)))
cs.render()
except neo_util.ParseError, e:
return "错误:", str(e)
def render(self, template):
"""Render the HDF using the given template.
The template parameter can be either an already parse neo_cs.CS
object, or a string. In the latter case it is interpreted as name of the
template file.
"""
if isinstance(template, (str, unicode)):
filename = template
import neo_cs
template = neo_cs.CS(self.hdf)
template.parseFile(filename)
return template.render()
def test_clearsilver():
"""ClearSilver"""
hdf = neo_util.HDF()
for i, row in enumerate(table):
for j, c in enumerate(row.values()):
hdf.setValue("rows.%d.cell.%d" % (i, j), cgi.escape(str(c)))
cs = neo_cs.CS(hdf)
cs.parseStr("""
<table><?cs
each:row=rows
?><tr><?cs each:c=row.cell
?><td><?cs var:c ?></td><?cs /each
?></tr><?cs /each?>
</table>""")
cs.render()
def execute(macro, args):
request = macro.request
content = []
page_name = macro.formatter.page.page_name
# get args
include_page_name = ''
if args is not None:
include_page_name = args
include_page_name = wikiutil.AbsPageName(page_name, include_page_name)
include_page = Page(request, include_page_name)
if include_page is None:
return ''
if not request.user.may.read(include_page_name):
return ''
cstemplate = include_page.getPageText()
pagename = macro.formatter.page.page_name
kv_page = Page(request, pagename)
kv_body = kv_page.get_body()
hdf = neo_util.HDF()
for line in kv_body.split("\n"):
if line.startswith("##"):
line = line[2:].strip()
parts = line.split("=", 1)
if len(parts) == 2:
val = parts[1].strip()
#val = parts[1].strip().encode('utf-8') # swh
hdf.setValue(parts[0].strip(), val)
hdf.setValue("Config.WhiteSpaceStrip ", "0")
cs = neo_cs.CS(hdf)
cs.parseStr(cstemplate)
body = cs.render()
body = wikiutil.renderText(request, WikiParser, body)
open("/tmp/out.html", "w").write(body)
return body
def render(self, template, form_token=None):
"""Render the HDF using the given template.
The template parameter can be either an already parse neo_cs.CS
object, or a string. In the latter case it is interpreted as name of the
template file.
"""
if isinstance(template, basestring):
filename = template
import neo_cs
template = neo_cs.CS(self.hdf)
template.parseFile(filename)
if form_token:
from cStringIO import StringIO
out = StringIO()
injector = FormTokenInjector(form_token, out)
injector.feed(template.render())
return out.getvalue()
else:
return template.render()
def display(self, cs, content_type='text/html', response=200):
import neo_cgi
# The following line is needed so that ClearSilver can be loaded when
# we are being run in multiple interpreters under mod_python
neo_cgi.update()
import neo_cs
import neo_util
if type(cs) == type(''):
filename = cs
cs = neo_cs.CS(self.hdf)
cs.parseFile(filename)
data = cs.render()
self.send_response(response)
self.send_header('Cache-control', 'no-cache')
self.send_header('Expires', 'Fri, 01 Jan 1999 00:00:00 GMT')
self.send_header('Content-Type', content_type + ';charset=utf-8')
self.send_header('Content-Length', len(data))
cookies = self.outcookie.output(header='')
for cookie in cookies.splitlines():
self.send_header('Set-Cookie', cookie.strip())
self.end_headers()
if self.command != 'HEAD':
self.write(data)
import neo_cgi
import neo_util
import neo_cs
hdf = neo_util.HDF()
hdf.setValue("hdf.loadpaths.0", ".")
hdf.readFile("units.hdf")
hdf.readFile("slots.hdf")
cs = neo_cs.CS(hdf)
cs.parseFile("dhcpd.conf.cst")
print cs.render()
def display(self):
cs = neo_cs.CS(self.req.hdf)
cs.parseStr(self.about_cs)
self.req.display(cs)
