def convert_to_html(self, line):
"""Convert style tags to html"""
chunks = tag_split_re.split(line)
if len(chunks) == 1:
# optimization in case there are no markup tags in the text at all
return html_escape(self.smartquotes(line), False)
result = []
close_tags_stack = []
chunks.append("</>") # add a reset-all-styles sentinel
for chunk in chunks:
html_tags = style_tags_html.get(chunk)
if html_tags:
chunk = html_tags[0]
close_tags_stack.append(html_tags[1])
elif chunk == "</>":
while close_tags_stack:
result.append(close_tags_stack.pop())
continue
elif chunk == "<clear>":
self.html_special.append("clear")
elif chunk:
if chunk.startswith("</"):
chunk = "<" + chunk[2:]
html_tags = style_tags_html.get(chunk)
if html_tags:
chunk = html_tags[1]
if close_tags_stack:
close_tags_stack.pop()
else:
# normal text (not a tag)
chunk = html_escape(self.smartquotes(chunk), False)
result.append(chunk)
return "".join(result)
def export_links(links, output_file):
print(BOOKMARK_HEADER, file=output_file)
for l in links:
parms = {
'url': html_escape(l['long_url']),
'title': html_escape(l.get('title', None) or ''),
'add_timestamp': l['created_at'],
'tags': '',
'private': '1' if l['private'] else '0',
'description': html_escape(l.get('text', '')),
}
if 'shares' in l and not parms['description']:
share_links = [SHARE_TEMPLATE.format(**{k: html_escape(v) if isinstance(v, str) else v
for k, v in i.items()})
for i in l['shares'] if i['share_type'] != 'email']
if len(share_links) > 1:
parms['description'] = '<ul><li>%s</li></ul>' % '</li><li>'.join(share_links)
else:
parms['description'] = '<br>'.join(share_links)
print(BOOKMARK_TEMPLATE.format(**parms),
file=output_file)
print(BOOKMARK_FOOTER, file=output_file)
def convert_to_html(self, line):
"""Convert style tags to html"""
chunks = tag_split_re.split(line)
if len(chunks) == 1:
# optimization in case there are no markup tags in the text at all
return html_escape(self.smartquotes(line), False)
result = []
close_tags_stack = []
chunks.append("</>") # add a reset-all-styles sentinel
for chunk in chunks:
html_tags = style_tags_html.get(chunk)
if html_tags:
chunk = html_tags[0]
close_tags_stack.append(html_tags[1])
elif chunk == "</>":
while close_tags_stack:
result.append(close_tags_stack.pop())
continue
elif chunk == "<clear>":
self.html_special.append("clear")
elif chunk:
if chunk.startswith("</"):
chunk = "<" + chunk[2:]
html_tags = style_tags_html.get(chunk)
if html_tags:
chunk = html_tags[1]
if close_tags_stack:
close_tags_stack.pop()
else:
# normal text (not a tag)
chunk = html_escape(self.smartquotes(chunk), False)
result.append(chunk)
return "".join(result)
def get_backend_icon(self):
is_perfect = (
self.backend_status is not None
) and self.backend_status.startswith("1 -")
is_good = (self.backend_status is not None) and (
self.backend_status.startswith("0 -")
or self.backend_status.startswith("1 -")
)
is_provisioning = (
self.backend_status is None
or self.backend_status == "Provisioning in progress"
or self.backend_status == ""
)
# returns (icon_name, tooltip)
if (
(self.enacted is not None)
and (self.enacted >= self.updated and is_good)
or is_perfect
):
return ("success", "successfully enacted")
else:
if is_good or is_provisioning:
return (
"clock",
"Pending sync, last_status = "
+ html_escape(self.backend_status, quote=True),
)
else:
return ("error", html_escape(self.backend_status, quote=True))
def send_to_stage(push):
assert push.state in ('accepting', 'onstage')
checkedin_requests = query.push_requests(push, state='checkedin')
if checkedin_requests:
if push.state != 'onstage':
push.state = 'onstage'
push.put()
for request in checkedin_requests:
request.state = 'onstage'
if request.no_testing:
set_request_tested(request, bust_caches=False)
else:
owner_email = request.owner.email()
send_mail(
to=[owner_email, config.mail_to],
subject='Re: ' + request.subject,
body='Please check your changes on stage.\n' + config.url(push.uri))
im_fields = dict(
pushmaster_email=html_escape(push.owner.email()),
pushmaster_name=html_escape(push.owner.nickname()),
request_subject=html_escape(request.subject),
uri=html_escape(config.url(push.uri)),
)
send_im(owner_email, '<a href="mailto:%(pushmaster_email)s">%(pushmaster_name)s</a> requests that you check your changes on stage for <a href="%(uri)s">%(request_subject)s</a>.' % im_fields)
request.put()
push.bust_requests_cache()
return push
def reject_request(request, rejector, reason=None):
push = request.push
request.push = None
request.state = 'rejected'
if reason:
request.reject_reason = reason
request.put()
query.bust_request_caches()
if push is not None:
push.bust_requests_cache()
im_fields = dict(
rejector_email=html_escape(rejector.email()),
rejector_name=html_escape(rejector.nickname()),
request_subject=html_escape(request.subject),
uri=html_escape(config.url(request.uri)),
reason=html_escape(reason),
)
send_im(request.owner.email(), '<a href="mailto:%(rejector_email)s">%(rejector_name)s</a> rejected your request <a href="%(uri)s">%(request_subject)s</a>: %(reason)s' % im_fields)
send_mail(
to=[request.owner.email(), config.mail_to],
subject='Re: ' + request.subject,
body="""This request was rejected.\n\n%s\n\n%s""" % (reason, config.url(request.uri)),
)
return request
def get_backend_icon(self):
# returns (icon_name, tooltip)
if (self.enacted is not None) and self.enacted >= self.updated or self.backend_status.startswith("1 -"):
return ("success", "successfully enacted")
else:
if ((self.backend_status is not None) and self.backend_status.startswith("0 -")) or self.backend_status == "Provisioning in progress" or self.backend_status=="":
return ("clock", html_escape(self.backend_status, quote=True))
else:
return ("error", html_escape(self.backend_status, quote=True))
def to_escaped_dict(self):
ret = {}
for k, v in self.to_dict().items():
if v is None:
ret[k] = ''
continue
try:
ret[k] = html_escape(v, True)
except Exception as e:
ret[k] = html_escape(repr(v), True)
return ret
def to_escaped_dict(self):
ret = {}
for k, v in self.to_dict().items():
if v is None:
ret[k] = ''
continue
try:
ret[k] = html_escape(v, True)
except Exception as e:
ret[k] = html_escape(repr(v), True)
return ret
def get_backend_icon(self):
is_good = (self.backend_status is not None) and (self.backend_status.startswith("0 -") or self.backend_status.startswith("1 -"))
is_provisioning = self.backend_status is None or self.backend_status == "Provisioning in progress" or self.backend_status==""
# returns (icon_name, tooltip)
if (self.enacted is not None) and self.enacted >= self.updated and is_good:
return ("success", "successfully enacted")
else:
if is_good or is_provisioning:
return ("clock", "Pending sync, last_status = " + html_escape(self.backend_status, quote=True))
else:
return ("error", html_escape(self.backend_status, quote=True))
def filterName(name, encode=True):
if name is not None:
if encode is True:
name = html_escape(name.replace('\xc2\x86', '').replace('\xc2\x87', ''), quote=True)
else:
name = name.replace('\xc2\x86', '').replace('\xc2\x87', '')
return name
def wsgi_handle_input(self, environ, parameters, start_response):
session = environ["wsgi.session"]
conn = session.get("player_connection")
if not conn:
return self.wsgi_internal_server_error(start_response,
"not logged in")
cmd = parameters.get("cmd", "")
if cmd and "autocomplete" in parameters:
suggestions = conn.io.tab_complete(cmd, self.driver)
if suggestions:
conn.io.html_to_browser.append(
"<br><p><em>Suggestions:</em></p>")
conn.io.html_to_browser.append("<p class='txt-monospaced'>" +
" ".join(suggestions) +
"</p>")
else:
conn.io.html_to_browser.append("<p>No matching commands.</p>")
else:
cmd = html_escape(cmd, False)
if cmd:
if conn.io.dont_echo_next_cmd:
conn.io.dont_echo_next_cmd = False
else:
conn.io.html_to_browser.append(
"<span class='txt-userinput'>%s</span>" % cmd)
conn.player.store_input_line(cmd)
start_response('200 OK', [('Content-Type', 'text/plain')])
return []
def convertDesc(val, encode=True):
if val is not None:
if encode is True:
return html_escape(unicode(val, 'utf_8', errors='ignore').encode('utf_8', 'ignore'), quote=True).replace(u'\x8a', '\n')
else:
return unicode(val, 'utf_8', errors='ignore').encode('utf_8', 'ignore')
return val
def filterName(name, encode=True):
if name is not None:
if encode is True:
name = html_escape(name.replace('\xc2\x86', '').replace('\xc2\x87', ''), quote=True)
else:
name = name.replace('\xc2\x86', '').replace('\xc2\x87', '')
return name
def test_escape_html_nosub2(self):
substart = "<sub>"
subend = "</sub>"
teststring = "<escape & skip sub tags>"
resstring = xml_util.escape_html_nosub(substart + teststring + subend)
goalstring = substart + html_escape(teststring) + subend
self.assertTrue(resstring == goalstring, "{0}\nshould be\n{1}".format(resstring, goalstring))
def convertDesc(val, encode=True):
if val is not None:
if encode is True:
return html_escape(unicode(val, 'utf_8', errors='ignore').encode('utf_8', 'ignore'), quote=True).replace(u'\x8a', '\n')
else:
return unicode(val, 'utf_8', errors='ignore').encode('utf_8', 'ignore')
return val
def handle_data(self, data):
"""Process collected character data."""
if not self._open_omitted_tags:
# stack empty -> not in omit mode
line = html_escape(data)
print(line.decode('utf-8')
if PY2 and isinstance(line, bytes) else line,
end='')
def test_escape_html_nosub2(self):
substart = "<sub>"
subend = "</sub>"
teststring = "<escape & skip sub tags>"
resstring = xml_util.escape_html_nosub(substart + teststring + subend)
goalstring = substart + html_escape(teststring) + subend
self.assertTrue(resstring == goalstring, \
"{0}\nshould be\n{1}".format(resstring,goalstring))
def __call__(self, req):
req.add_sub(
'syncclient',
'</body>',
('<script src="%s"></script>'
% (html_escape(self.syncclient))),
replace=False)
return self.static_app
def append_match(item, words):
text = item.rendered
text = tag_strip.sub(' ', text)
sentences = []
def matcher(match):
return '<b>%s</b>' % match.group()
if regex:
for each in regex.finditer(text):
sentence = text[max(each.start() - 35, 0): each.end() + 40]
sentence = regex_ext.sub(matcher, sentence)
sentence = sentence.strip()
if each.start() > 0 and not sentence[0].isupper():
sentence = '...%s' % sentence
if each.end() < len(text):
sentence = '%s...' % sentence
sentences.append(sentence.strip())
if len(sentences) > 3:
break
if isinstance(item, BlogItem):
title = html_escape(item.title)
if regex_ext:
title = regex_ext.sub(matcher, title)
date = item.pub_date
type_ = 'blog'
else:
if not item.blogitem:
item.correct_blogitem_parent()
title = (
"Comment on <em>%s</em>" % html_escape(item.blogitem.title)
)
date = item.add_date
type_ = 'comment'
documents.append({
'title': title,
'summary': '<br>'.join(sentences),
'date': date,
'url': item.get_absolute_url(),
'type': type_,
})
def format_tokens_row(tokens, tuple_offset):
token_cell_template = '<td bgcolor="{color}">{token}<br><small>{prob}</small></td>'
cells = []
for t in tokens:
log_prob = -t[tuple_offset + 1]
cells.append(token_cell_template.format(token=html_escape(t[tuple_offset], quote=True),
prob=format_number(np.exp(log_prob), 0),
color=web_color(color_log_prob(log_prob))))
return ''.join(cells)
def append_match(item, words):
text = item.rendered
text = tag_strip.sub(' ', text)
sentences = []
def matcher(match):
return '<b>%s</b>' % match.group()
if regex:
for each in regex.finditer(text):
sentence = text[max(each.start() - 35, 0):each.end() + 40]
sentence = regex_ext.sub(matcher, sentence)
sentence = sentence.strip()
if each.start() > 0 and not sentence[0].isupper():
sentence = '...%s' % sentence
if each.end() < len(text):
sentence = '%s...' % sentence
sentences.append(sentence.strip())
if len(sentences) > 3:
break
if isinstance(item, BlogItem):
title = html_escape(item.title)
if regex_ext:
title = regex_ext.sub(matcher, title)
date = item.pub_date
type_ = 'blog'
else:
if not item.blogitem:
item.correct_blogitem_parent()
title = ("Comment on <em>%s</em>" %
html_escape(item.blogitem.title))
date = item.add_date
type_ = 'comment'
documents.append({
'title': title,
'summary': '<br>'.join(sentences),
'date': date,
'url': item.get_absolute_url(),
'type': type_,
})
def output_sitemap(crawl):
print dedent('''
<?xml version="1.0" encoding="utf-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
''').strip()
for page in crawl:
print ' <url><loc>%s</loc></url>' % html_escape(page.url or page.canonical_url)
print '</urlset>'
def html_colors(qstr='', limit=None):
qstr = html_escape(qfont_decode(qstr, glyph_translation=True))
qstr = qstr.replace('^^', '^')
if limit is not None and limit > 0:
qstr = limit_printable_characters(qstr, limit)
html = _dec_colors.sub(lambda match: _dec_spans[int(match.group(1))], qstr)
html = _hex_colors.sub(hex_repl, html)
return html + "</span>" * len(_all_colors.findall(qstr))
def html_colors(qstr='', limit=None):
qstr = html_escape(qfont_decode(qstr, glyph_translation=True))
qstr = qstr.replace('^^', '^')
if limit is not None and limit > 0:
qstr = limit_printable_characters(qstr, limit)
html = _dec_colors.sub(lambda match: _dec_spans[int(match.group(1))], qstr)
html = _hex_colors.sub(hex_repl, html)
return html + "</span>" * len(_all_colors.findall(qstr))
def __init__(self, name=None, dest_file=None):
assert(name is not None)
assert(dest_file is not None)
self.name = name
self.html_id = self.tag2html_id(name)
self.html_name = html_escape(name)
self.dest_file = dest_file
self.html_dest_file = "%s.html" % splitext(dest_file)[0]
self.link_text = self.link_for_tag(self.html_name, self.html_id, self.html_dest_file) #
self.local_link_text = self.link_for_local_tag(self.html_name, self.html_id, self.html_dest_file) #
self.ref_text = self.ref_for_tag(self.html_id)
def menuRenderItems(self, vals):
cnt = 0
for item in self.items:
if hasattr(item, 'id'): cnt = item.id()
print '<option label="%s" id="%s" value="%s" name="%s"' % \
(item, cnt, cnt, html_escape(str(item), 1)),
if item in vals: print "selected",
print ">", item, '</option>'
cnt = cnt+1
pass
return
def format_value(value, suppress_colors=False):
if isinstance(value, (list, tuple)) and len(value) == 3 and isinstance(value[0], Number):
color = web_color(value)
if suppress_colors:
value = NotPresent()
else:
value = [int(c) for c in value]
else:
color = '#fff'
value_repr = html_escape(repr(value).decode('unicode_escape').encode('utf-8'), quote=True)
return '<td bgcolor="{color}">{value}</td>'.format(color=color, value=value_repr)
def menuRenderItems(self, vals):
cnt = 0
for item in self.items:
if hasattr(item, 'id'): cnt = item.id()
print '<option label="%s" id="%s" value="%s" name="%s"' % \
(item, cnt, cnt, html_escape(str(item), 1)),
if item in vals: print "selected",
print ">", item, '</option>'
cnt = cnt + 1
pass
return
def apply(self):
source, boundary, end = self.source, self.boundary, self.end
if self.start is not None:
res_list = []
start = self.start
if boundary != start:
res_list.append(source[boundary : start])
url = source[start : end]
if not self.has_text:
# strip pieces that may not belong to URL
while True:
last_of_url = url[-1]
if last_of_url == ")" and "(" not in url or last_of_url in ".,;:?!\"'":
# last ")" is not a part of URL unless there's an "(" earlier in it;
# common punctuation is usually not a part of URL
end -= 1
url = source[start : end]
else:
break
if self.has_text:
after_end = end + 1 # including the space
# cut out the link text
maybe_quote = source[after_end : after_end+1]
if maybe_quote == '"':
text_frags, start = QuoteWrapper(source, after_end).apply()
else:
# skip to next space
hit = self.SPACE_RE.search(source, after_end+1)
if hit:
start = hit.start()
else:
start = len(source) # had no space till EOL
text_frags = applyQueue(source[after_end : start])
else:
text_frags = [url]
start = end
proto_pos = url.find("://")
if proto_pos > 0:
proto = self.PROTO_CLASS_MAP.get(url[:proto_pos], self.PROTO_CLASS_MAP.get("*", None))
else:
proto = None
if any(bad_char in url for bad_char in '<>"'): # being defensive
url = html_escape(url, True)
res_list.extend(('<a href="', url, '"'))
if proto:
res_list.extend((' class="', proto, '"'))
res_list.append('>')
res_list.extend(text_frags)
res_list.append("</a>")
else:
# no start
start = boundary
res_list = []
return (res_list, start)
def buttonItems(self, selected_values, type):
id = self.id
buttons = []
cnt=0
for item in self.items:
s = html_escape(str(item), 1)
b = Input(s, id=id, name=id, value=cnt, type=type, label=s)
if s in selected_values: b.props['checked']=None
cnt=cnt+1
buttons.append(b)
pass
return buttons
def render(self, val=None):
opts = ' disabled' if (self.oneTime) else ''
if val == None: val = self.value() or ''
val = html_escape(val.strip(), 1)
if opts: print '<input type=hidden id="%s" name="%s" value="%s">' % (self.id, self.id, val)
if self.rows > 1:
print "<textarea id='%s' name='%s' rows=%d cols=%d%s>%s</textarea>" % \
(self.id, self.id, self.rows, self.cols, opts, val),
else:
print '<input type=%s id="%s" name="%s" size=%d maxlength=%d value="%s" %s>' % \
('text' if self.rows==1 else 'password',
self.id, self.id, self.cols, self.maxlen, val, opts)
def buttonItems(self, selected_values, type):
id = self.id
buttons = []
cnt = 0
for item in self.items:
s = html_escape(str(item), 1)
b = Input(s, id=id, name=id, value=cnt, type=type, label=s)
if s in selected_values: b.props['checked'] = None
cnt = cnt + 1
buttons.append(b)
pass
return buttons
def write(self, data, escape=True):
if not escape:
self.body.write(str(data))
elif hasattr(data, 'xml') and callable(data.xml):
self.body.write(data.xml())
else:
# make it a string
if not isinstance(data, (str, unicodeT)):
data = str(data)
elif isinstance(data, unicodeT):
data = data.encode('utf8', 'xmlcharrefreplace')
data = html_escape(data, True).replace("'", "'")
self.body.write(data)
def hyphenate(text, dic):
"""Hyphenate a `text` using `dic`tionary for display in browser."""
# HTML escape needs to be done *after* the hyphenation, otherwise the
# entities are hyphenated. Thus there is a two step process:
# 1. Hyphenate with a special marker
# 2. replace marker with the actual entity
if dic is None:
hyphenated = text
else:
words = text.split(u' ')
hyphenated = u' '.join(
[dic.inserted(word, SOFT_HYPHEN) for word in words])
escaped = html_escape(hyphenated)
return escaped.replace(SOFT_HYPHEN, SOFT_HYPHEN_HTML)
def send_error_msgtxt(self, code, message, headers=None):
"text will be in a <pre> bloc"
if headers is None:
headers = {}
if isinstance(message, (list, tuple)):
message = ''.join(message)
elif isinstance(message, dict):
message = repr(message)
self.send_error_explain(code,
''.join(("<pre>\n", html_escape(message, True), "</pre>\n")), # pylint: disable=deprecated-method
headers,
"text/html")
def buttonRenderItems(self, vals, type):
cnt = 0
print self.header
for item in self.items:
if cnt % self.columns == 0: print '<tr>'
print '<td align=right>'
print '<input type=%s id=%s name=%s value="%s" label="%s"' % \
(type, self.id, self.id, cnt, html_escape(str(item),1))
if item in vals:
print "checked",
print "></td><td align=left><font face=sans-serif size=-1>", item, "</font></td><td> </td>"
cnt = cnt + 1
print self.footer
return
def render(self, val=None):
opts = ' disabled' if (self.oneTime) else ''
if val == None: val = self.value() or ''
val = html_escape(val.strip(), 1)
if opts:
print '<input type=hidden id="%s" name="%s" value="%s">' % (
self.id, self.id, val)
if self.rows > 1:
print "<textarea id='%s' name='%s' rows=%d cols=%d%s>%s</textarea>" % \
(self.id, self.id, self.rows, self.cols, opts, val),
else:
print '<input type=%s id="%s" name="%s" size=%d maxlength=%d value="%s" %s>' % \
('text' if self.rows==1 else 'password',
self.id, self.id, self.cols, self.maxlen, val, opts)
def buttonRenderItems(self, vals, type):
cnt = 0
print self.header
for item in self.items:
if cnt % self.columns == 0: print '<tr>'
print '<td align=right>'
print '<input type=%s id=%s name=%s value="%s" label="%s"' % \
(type, self.id, self.id, cnt, html_escape(str(item),1))
if item in vals:
print "checked",
print "></td><td align=left><font face=sans-serif size=-1>", item, "</font></td><td> </td>"
cnt = cnt + 1
print self.footer
return
def escaped_with_field_highlighted(form_html, field_name):
"""
Return escaped HTML source code suitable for displaying;
fields with name==field_name are highlighted.
"""
form = load_html(form_html)
for elem in form.xpath('.//*[@name="{}"]'.format(field_name)):
add_text_before(elem, '__START__')
add_text_after(elem, '__END__')
text = html_tostring(form)
text = html_escape(text).replace(
'__START__', '<span style="font-size:large;color:#000">').replace(
'__END__', '</span>')
return text
def build_search_page(
verse_list="",
verses="",
strongs_morph="",
context=0,
min_range="Genesis",
max_range="Revelation",
verse_ref="Genesis 1:1",
devotional_date="today",
search_terms="",
):
""" Build the search page and return a dictionary.
"""
drop_list = [
{"name": "context_dropdown", "id": "dcontext", "href": "#", "label": "Context", "value": context},
{
"name": "range_dropdown",
"id": "drange",
"href": "#",
"label": "Range",
"min_range": min_range,
"max_range": max_range,
},
{"name": "lookup_dropdown", "id": "dlookup", "href": "#", "label": "Reference", "reference": verse_ref},
{
"name": "devotional_dropdown",
"id": "ddevotional",
"href": "#",
"label": "Devotional",
"date": devotional_date,
},
]
dropdowns = "\n".join([template(i["name"], **i) for i in drop_list])
return template(
"biblesearch",
verse_list=verse_list,
verses=verses,
strongs_morph=strongs_morph,
dropdowns=dropdowns,
search_terms=html_escape(search_terms),
)
def do_get(self):
log_name = self.get_argument('log_name')
with open(os.path.join(config.GlobalSettings.LOGFILES_DIR, log_name), 'rt') as fp:
lines = []
for line in (html_escape(l) for l in fp.readlines()):
if ' [W] ' in line:
css_class = 'log-warn'
elif ' [E] ' in line:
css_class = 'log-error'
elif ' [C] ' in line:
css_class = 'log-critical'
elif ' [I] ' in line:
css_class = 'log-info'
else:
css_class = 'log-addit'
lines.append("<span class='%s'>%s</span>" % (css_class, line))
reply = {'lines' : '<br>'.join(lines)}
self.finish(reply)
def convert_json_node(self, json_input):
"""
Dispatch JSON input according to the outermost type and process it
to generate the super awesome HTML format.
We try to adhere to duck typing such that users can just pass all kinds
of funky objects to json2html that *behave* like dicts and lists and other
basic JSON types.
"""
if type(json_input) in text_types:
if self.escape:
return html_escape(text(json_input))
else:
return text(json_input)
if hasattr(json_input, 'items'):
return self.convert_object(json_input)
if hasattr(json_input, '__iter__') and hasattr(json_input, '__getitem__'):
return self.convert_list(json_input)
return text(json_input)
def do_get(self):
log_name = self.get_argument('log_name')
with open(os.path.join(config.GlobalSettings.LOGFILES_DIR, log_name),
'rt') as fp:
lines = []
for line in (html_escape(l) for l in fp.readlines()):
if ' [W] ' in line:
css_class = 'log-warn'
elif ' [E] ' in line:
css_class = 'log-error'
elif ' [C] ' in line:
css_class = 'log-critical'
elif ' [I] ' in line:
css_class = 'log-info'
else:
css_class = 'log-addit'
lines.append("<span class='%s'>%s</span>" % (css_class, line))
reply = {'lines': '<br>'.join(lines)}
self.finish(reply)
def wsgi_handle_about(self, environ, parameters, start_response):
# about page
if "license" in parameters:
return self.wsgi_handle_license(environ, parameters, start_response)
start_response("200 OK", [('Content-Type', 'text/html; charset=utf-8')])
resource = vfs.internal_resources["web/about_mud.html"]
player_table = ["<br><p><em>Connected players:</em></p><pre>"]
for name, conn in self.driver.all_players.items():
player_table.append(html_escape("Name: %s connection: %s" % (name, conn.io)))
player_table.append("</pre>")
player_table = "\n".join(player_table)
txt = resource.data.format(tale_version=tale_version_str,
story_version=self.driver.config.version,
story_name=self.driver.config.name,
uptime="%d:%02d:%02d" % self.driver.uptime,
starttime=self.driver.server_started,
num_players=len(self.driver.all_players),
player_table=player_table)
return [txt.encode("utf-8")]
def safe_str(x):
try:
# For Python2, it can be int, long, float
if IS_PY2:
if isinstance(x, (int, long, float)):
x = str(x)
else:
# For Python3, it can be int, float
if isinstance(x, (int, float)):
x = str(x)
x = x.encode('ascii', 'xmlcharrefreplace') if hasattr(x,
'encode') else x
if not IS_PY2:
x = x.decode('utf-8')
except Exception:
pass
return html_escape(x, False)
def handle_starttag(self, tag, attrs):
"""Process the starting of a new element."""
if tag in self.omit_tags:
_logger.debug('omitting: "%s"', tag)
self._open_omitted_tags.append(tag)
if not self._open_omitted_tags:
# stack empty -> not in omit mode
if '@' in tag:
# email address in angular brackets
print('<%s>' % tag, end='')
return
if (tag == 'li') and (self._open_tags[-1] == 'li'):
_logger.debug(
'opened "li" without closing previous "li", adding closing tag'
)
self.handle_endtag('li')
attributes = []
for attr_name, attr_value in attrs:
if attr_name in self.omit_attrs:
_logger.debug('omitting "%s" attribute of "%s"', attr_name,
tag)
continue
if attr_value is None:
_logger.debug(
'no value for "%s" attribute of "%s", adding empty value',
attr_name, tag)
attr_value = ''
markup = '%(name)s="%(value)s"' % {
'name': attr_name,
'value': html_escape(attr_value, quote=True)
}
attributes.append(markup)
line = '<%(tag)s%(attrs)s%(slash)s>' % {
'tag': tag,
'attrs':
(' ' + ' '.join(attributes)) if len(attributes) > 0 else '',
'slash': ' /' if tag in self.SELF_CLOSING_TAGS else ''
}
print(line, end='')
if tag not in self.SELF_CLOSING_TAGS:
self._open_tags.append(tag)
def write( self, value ):
""" Writes the arbitrary Python value ``value`` as HTML to the internal
buffers. """
self.stack.append( value )
if hasattr( value, '__html__' ): value.__html__( self )
elif isinstance( value, basestring ):
unesc = value if isinstance(value, unicode) \
else value.decode(self.encoding)
self.current.append(html_escape(unesc, True))
elif isinstance( value, Iterable ):
for item in value: self.write( item )
elif isinstance( value, Callable ): self.write( value() )
else: self.current.append(unicode(value))
self.stack.pop()
return self
def gensmileys():
current_protocol = None
for l in SMILEYS_INDEX.split("\n"):
l = l.strip()
if not l:
continue
if l.startswith("#"):
continue
if l.startswith("["):
proto_name = l.strip("[]").lower()
if proto_name == "xmpp":
current_protocol = yobotproto.YOBOT_JABBER
elif proto_name == "aim":
current_protocol = yobotproto.YOBOT_AIM
elif proto_name == "msn":
current_protocol = yobotproto.YOBOT_MSN
elif proto_name == "yahoo":
current_protocol = yobotproto.YOBOT_YAHOO
elif proto_name == "default":
current_protocol = DEFAULT_SCHEME
else:
current_protocol = UNUSED
continue
if not current_protocol:
continue
items = l.split()
name, emotes = items[0], items[1:]
for emote in emotes:
htmled = html_escape(emote)
htmlescaped.resourcetable[(htmled, current_protocol)] = name
htmlescaped.addsmiley(current_protocol, htmled)
plain.resourcetable[(emote, current_protocol)] = name
plain.addsmiley(current_protocol, emote)
for o in (plain, htmlescaped):
for k, v in o.allsmileys.items():
o.regexp[k] = re.compile("(%s)" % ("|".join([re.escape(s) for s in sorted(v,key=len, reverse=True)])))
def post(self):
if not self.handle_authentication():
return
backendformeditorfile = "backend_form_editor.html"
table = self.get_argument("table")
response = {"table": table}
self.dbi.execute(
"PRAGMA TABLE_INFO({0});".format(table))
tableschema = [(x[1], x[2]) for x in self.dbi.fetchall()]
self.dbi.execute("SELECT rowid,* FROM {0};".format(table))
tablerows = self.dbi.fetchall()
escapefunction = lambda x: html_escape("%s" % x)
tablerows = [map(escapefunction, x) for x in tablerows]
renderedtemplate = self.render_string(
backendformeditorfile,
schema=tableschema,
rows=tablerows,
table=table)
response["table"] = table
response["editortemplate"] = renderedtemplate
self.write(response)
def wsgi_handle_about(self, environ, parameters, start_response):
# about page
if "license" in parameters:
return self.wsgi_handle_license(environ, parameters,
start_response)
start_response("200 OK",
[('Content-Type', 'text/html; charset=utf-8')])
resource = vfs.internal_resources["web/about_mud.html"]
player_table = []
for name, conn in self.driver.all_players.items():
player_table.append(
html_escape("Name: %s connection: %s" % (name, conn.io)))
player_table.append("</pre>")
player_table = "\n".join(player_table)
txt = resource.data.format(tale_version=tale_version_str,
story_version=self.driver.config.version,
story_name=self.driver.config.name,
uptime="%d:%02d:%02d" % self.driver.uptime,
starttime=self.driver.server_started,
num_players=len(self.driver.all_players),
player_table=player_table)
return [txt.encode("utf-8")]
def wsgi_handle_input(self, environ, parameters, start_response):
session = environ["wsgi.session"]
conn = session.get("player_connection")
if not conn:
return self.wsgi_internal_server_error(start_response, "not logged in")
cmd = parameters.get("cmd", "")
if cmd and "autocomplete" in parameters:
suggestions = conn.io.tab_complete(cmd, self.driver)
if suggestions:
conn.io.html_to_browser.append("<br><p><em>Suggestions:</em></p>")
conn.io.html_to_browser.append("<p class='txt-monospaced'>" + " ".join(suggestions) + "</p>")
else:
conn.io.html_to_browser.append("<p>No matching commands.</p>")
else:
cmd = html_escape(cmd, False)
if cmd:
if conn.io.dont_echo_next_cmd:
conn.io.dont_echo_next_cmd = False
else:
conn.io.html_to_browser.append("<span class='txt-userinput'>%s</span>" % cmd)
conn.player.store_input_line(cmd)
start_response("200 OK", [("Content-Type", "text/plain")])
return []
def do_sub(m):
c = m.groupdict()
if c["htmlchars"]:
return html_escape(c["htmlchars"], quote=False)
if c["lineend"]:
return "<br>"
elif c["space"]:
t = m.group().replace("\t", u" " * tabstop)
t = t.replace(" ", " ")
return t
elif c["space"] == "\t":
return " " * tabstop
else:
url = m.group("protocol")
if url.startswith(" "):
prefix = " "
url = url[1:]
else:
prefix = ""
last = m.groups()[-1]
if last in ["\n", "\r", "\r\n"]:
last = "<br>"
return u'{0}<a href="{1}">{2}</a>{3}'.format(
prefix, url, url, last)
def handle_starttag(self, tag, attrs):
"""Process the starting of a new element."""
if tag in self.omit_tags:
_logger.debug('omitting: "%s"', tag)
self._open_omitted_tags.append(tag)
if not self._open_omitted_tags:
# stack empty -> not in omit mode
if '@' in tag:
# email address in angular brackets
print('<%s>' % tag, end='')
return
if (tag == 'li') and (self._open_tags[-1] == 'li'):
_logger.debug('opened "li" without closing previous "li", adding closing tag')
self.handle_endtag('li')
attributes = []
for attr_name, attr_value in attrs:
if attr_name in self.omit_attrs:
_logger.debug('omitting "%s" attribute of "%s"', attr_name, tag)
continue
if attr_value is None:
_logger.debug('no value for "%s" attribute of "%s", adding empty value',
attr_name, tag)
attr_value = ''
markup = '%(name)s="%(value)s"' % {
'name': attr_name,
'value': html_escape(attr_value, quote=True)
}
attributes.append(markup)
line = '<%(tag)s%(attrs)s%(slash)s>' % {
'tag': tag,
'attrs': (' ' + ' '.join(attributes)) if len(attributes) > 0 else '',
'slash': ' /' if tag in self.SELF_CLOSING_TAGS else ''
}
print(line, end='')
if tag not in self.SELF_CLOSING_TAGS:
self._open_tags.append(tag)
def math(self, text):
return '$%s$' % html_escape(text)
def test_escape_html_nosub(self):
teststring = "<tag1> ampersand here: & </tag1>"
resstring = self.patent._escape_html_nosub(teststring)
goalstring = html_escape(teststring)
self.assertTrue(resstring == goalstring, \
"{0}\nshould be\n{1}".format(resstring,goalstring))
def escape_html(self, text):
return html_escape(text)
def _(wr, s):
wr.current.append(html_escape(s, True).encode(wr.encoding, "strict"))
