def render(self, req):
"""Render the data."""
context = Context.from_request(req)
mimeview = Mimeview(self.env)
return mimeview.render(context,
self.mimetype,
self.data,
annotations=['lineno'])
def setUp(self):
self.env = EnvironmentStub()
self.ticket_module = TicketModule(self.env)
self.mimeview = Mimeview(self.env)
self.req = Mock(hdf=HDFWrapper(['./templates']),
base_path='/trac.cgi',
path_info='',
href=Href('/trac.cgi'))
def setUp(self):
self.env = EnvironmentStub()
self.env.config.set(
'trac', 'templates_dir',
os.path.join(os.path.dirname(self.env.path), 'templates'))
self.ticket_module = TicketModule(self.env)
self.mimeview = Mimeview(self.env)
self.req = MockRequest(self.env, authname='anonymous')
def get_quality_ratio(self, mimetype):
# Extend default MIME type to mode mappings with configured ones
if not self._types:
self._types = {}
self._types.update(types)
self._types.update(
Mimeview(self.env).configured_modes_mapping('silvercity'))
return self._types.get(mimetype, (None, 0))[1]
def setUp(self):
self.env = EnvironmentStub(enable=[Chrome, LineNumberAnnotator,
PygmentsRenderer])
self.pygments = Mimeview(self.env).renderers[0]
self.req = MockRequest(self.env)
self.context = web_context(self.req)
pygments_html = open(os.path.join(os.path.split(__file__)[0],
'pygments.html'))
self.pygments_html = Stream(list(HTMLParser(pygments_html, encoding='utf-8')))
def setUp(self):
env = EnvironmentStub(enable=[Chrome, PatchRenderer])
req = MockRequest(env)
self.context = web_context(req)
self.patch = Mimeview(env).renderers[0]
patch_html = open(
os.path.join(os.path.split(__file__)[0], 'patch.html'))
self.patch_html = Stream(list(HTMLParser(patch_html,
encoding='utf-8')))
def process_request(self, req):
# req.args为一个字典:有'action'时返回action的值,没有时返回default值
action = req.args.get('action', 'view')
pagename = req.args.get('page', 'ZhWikiStart')
version = req.args.get('version')
if pagename.endswith('/'):
req.redirect(req.href.wiki(pagename.strip('/')))
db = self.env.get_db_cnx()
# 使用Page对象,不用使用数据库相关东西
page = WikiPage(self.env, pagename, version, db)
add_stylesheet(req, 'common/css/wiki.css')
if req.method == 'POST':
if action == 'edit':
latest_version = WikiPage(self.env, pagename, None, db).version
if req.args.has_key('cancel'):
req.redirect(req.href.wiki(page.name))
elif int(version) != latest_version:
action = 'collision'
self._render_editor(req, db, page)
elif req.args.has_key('preview'):
action = 'preview'
self._render_editor(req, db, page, preview=True)
else:
self._do_save(req, db, page)
elif action == 'delete':
self._do_delete(req, db, page)
elif action == 'diff':
get_diff_options(req)
req.redirect(
req.href.wiki(page.name,
version=page.version,
old_version=req.args.get('old_version'),
action='diff'))
elif action == 'delete':
self._render_confirm(req, db, page)
elif action == 'edit':
self._render_editor(req, db, page)
elif action == 'diff':
self._render_diff(req, db, page)
elif action == 'history':
self._render_history(req, db, page)
else:
req.perm.assert_permission('WIKI_VIEW')
format = req.args.get('format')
if format:
Mimeview(self.env).send_converted(req, 'text/x-trac-wiki',
page.text, format, page.name)
self._render_view(req, db, page)
req.hdf['wiki.action'] = action
req.hdf['wiki.current_href'] = req.href.wiki(page.name)
return 'wiki.cs', None
def get_search_results(self, req, query, filters):
if 'docs' not in filters:
return
if not req.perm.has_permission('WIKI_VIEW'):
return
root = self.config.get('docs', 'root', '')
repos = self.env.get_repository(req.authname)
node = repos.get_node(root, None)
if not isinstance(query, list):
results = []
for term in re.split('(".*?")|(\'.*?\')|(\s+)', query):
if term != None and term.strip() != '':
if term[0] == term[-1] == "'" or term[0] == term[-1] == '"':
term = term[1:-1]
results.append(term)
query = results
query = [q.lower() for q in query]
patterns = []
for q in query:
q = re.sub('\s+', '\s+', q)
p = re.compile(q, re.IGNORECASE | re.MULTILINE)
patterns.append(p)
to_unicode = Mimeview(self.env).to_unicode
def walk(node):
if node.path.endswith('.txt') or node.path.endswith('.rst'):
yield node
if node.kind == Node.DIRECTORY:
for subnode in node.get_entries():
for result in walk(subnode):
yield result
for node in walk(node):
matched = 1
content_length = node.get_content_length()
if content_length > (1024 * 1024):
continue
content = node.get_content()
if not content:
continue
content = to_unicode(content.read(), node.get_content_type())
for p in patterns:
if p.search(content) is None:
matched = 0
break
if matched:
change = repos.get_changeset(node.rev)
path = node.path[len(root)+1:]
yield (self.env.href.docs(path),
path, change.date, change.author,
shorten_result(content.replace('\n', ' '), query))
def _render_view(self, req, db, page):
page_name = self._set_title(req, page, '')
if page.name == 'WikiStart':
req.hdf['title'] = ''
version = req.args.get('version')
if version:
# Ask web spiders to not index old versions
req.hdf['html.norobots'] = 1
# Add registered converters
for conversion in Mimeview(
self.env).get_supported_conversions('text/x-trac-wiki'):
conversion_href = req.href.wiki(page.name,
version=version,
format=conversion[0])
add_link(req, 'alternate', conversion_href, conversion[1],
conversion[3])
latest_page = WikiPage(self.env, page.name)
req.hdf['wiki'] = {
'exists': page.exists,
'version': page.version,
'latest_version': latest_page.version,
'readonly': page.readonly
}
if page.exists:
req.hdf['wiki'] = {
'page_html':
wiki_to_html(page.text, self.env, req),
'history_href':
req.href.wiki(page.name, action='history'),
'last_change_href':
req.href.wiki(page.name, action='diff', version=page.version)
}
if version:
req.hdf['wiki'] = {
'comment_html':
wiki_to_oneliner(page.comment or '--', self.env, db),
'author':
page.author,
'age':
pretty_timedelta(page.time)
}
else:
if not req.perm.has_permission('WIKI_CREATE'):
raise HTTPNotFound('Page %s not found', page.name)
req.hdf['wiki.page_html'] = html.P('Describe "%s" here' %
page_name)
# Show attachments
req.hdf['wiki.attachments'] = attachments_to_hdf(
self.env, req, db, 'wiki', page.name)
if req.perm.has_permission('WIKI_MODIFY'):
attach_href = req.href.attachment('wiki', page.name)
req.hdf['wiki.attach_href'] = attach_href
def setUp(self):
self.env = EnvironmentStub(enable=[Chrome, PygmentsRenderer])
self.pygments = Mimeview(self.env).renderers[0]
self.req = Mock(base_path='', chrome={}, args={},
abs_href=Href('/'), href=Href('/'),
session={}, perm=None, authname=None, tz=None)
self.context = web_context(self.req)
pygments_html = open(os.path.join(os.path.split(__file__)[0],
'pygments.html'))
self.pygments_html = Stream(list(HTMLParser(pygments_html, encoding='utf-8')))
def test_python_hello_mimeview(self):
"""
Simple Python highlighting with Pygments (through Mimeview.render)
"""
result = Mimeview(self.env).render(self.context, 'text/x-python', """
def hello():
return "Hello World!"
""")
self.assertTrue(result)
self._test('python_hello_mimeview', result)
def count_by_author_top(self, num=5):
sql = 'SELECT C.creatorID, CD.firstName, CD.lastName ' \
+ 'FROM creators C NATURAL JOIN creatorData CD ' \
+ 'WHERE C.creatorID IN (SELECT creatorID FROM (' \
+ 'SELECT creatorID, count(itemID) AS cnum FROM itemCreators IC ' \
+ 'WHERE 1 GROUP BY creatorID ORDER BY cnum DESC) ' \
+ 'WHERE 1 LIMIT '+ str(5) +')'
c = self.db.cursor()
c.execute(sql)
to_unicode = Mimeview(self.env).to_unicode
return [[to_unicode(j) for j in i] for i in c]
def setUp(self):
self.env = EnvironmentStub()
self.env.config.set('trac', 'templates_dir',
os.path.join(os.path.dirname(self.env.path),
'templates'))
self.ticket_module = TicketModule(self.env)
self.mimeview = Mimeview(self.env)
self.req = Mock(base_path='/trac.cgi', path_info='',
href=Href('/trac.cgi'), chrome={'logo': {}},
abs_href=Href('http://example.org/trac.cgi'),
environ={}, perm=[], authname='-', args={}, tz=None,
locale='', session=None, form_token=None)
def process_combinewiki(self, req, format, title, pages):
# Dump all pages to HTML files
files = [self._page_to_file(req, p) for p in pages]
titlefile = self._page_to_file(req, title, self.TITLE_HTML % title)
# File to write PDF to
pfile, pfilename = mkstemp('tracpdf')
os.close(pfile)
# Render
os.environ["HTMLDOC_NOCGI"] = 'yes'
codepage = Mimeview(self.env).default_charset
htmldoc_format = {'pdf': 'pdf14', 'ps': 'ps3'}[format]
htmldoc_args = {
'book': None,
'format': htmldoc_format,
'left': '1.5cm',
'right': '1.5cm',
'top': '1.5cm',
'bottom': '1.5cm',
'charset': codepage.replace('iso-', ''),
'title': None,
'titlefile': titlefile
}
htmldoc_args.update(dict(self.env.config.options('pagetopdf')))
htmldoc_args.update(dict(self.env.config.options('combinewiki')))
args_string = ' '.join([
'--%s %s' % (arg, value or '')
for arg, value in htmldoc_args.iteritems()
])
cmd_string = 'htmldoc %s %s -f %s' % (args_string, ' '.join(files),
pfilename)
self.log.info('CombineWikiModule: Running %r', cmd_string)
os.system(cmd_string)
out = open(pfilename, 'rb').read()
# Clean up
os.unlink(pfilename)
for f in files:
os.unlink(f)
os.unlink(titlefile)
# Send the output
req.send_response(200)
req.send_header('Content-Type', {
'pdf': 'application/pdf',
'ps': 'application/postscript'
}[format])
req.send_header('Content-Length', len(out))
req.end_headers()
req.write(out)
raise RequestDone
def test_extra_mimetypes(self):
"""
The text/x-ini mimetype is normally not known by Trac, but
Pygments supports it.
"""
mimeview = Mimeview(self.env)
self.assertEqual('text/x-ini; charset=utf-8',
mimeview.get_mimetype('file.ini'))
self.assertEqual('text/x-ini; charset=utf-8',
mimeview.get_mimetype('file.cfg'))
self.assertEqual('text/x-ini; charset=utf-8',
mimeview.get_mimetype('file.text/x-ini'))
def get_items_attachments(self, iids):
if not iids:
return []
sql = 'SELECT sourceItemID, itemID, mimeType, path'
sql += ', (SELECT key FROM items I WHERE IA.itemID = I.itemID) AS key'
sql += ' FROM itemAttachments IA WHERE sourceItemID in ('
sql += ', '.join([str(x) for x in iids])
sql += ')'
sql += ' AND IA.itemID NOT IN (SELECT itemID FROM deletedItems)'
c = self.db.cursor()
c.execute(sql)
to_unicode = Mimeview(self.env).to_unicode
return [[to_unicode(j) for j in i] for i in c]
def _test_convert_content(self, expected, content, iterable):
mimeview = Mimeview(self.env)
output = mimeview.convert_content(MockRequest(self.env),
self.in_mimetype,
content, 'text', iterable=iterable)
if iterable:
self.assertNotIn(type(output[0]), (str, unicode))
self.assertEqual(expected, ''.join(output[0]))
else:
self.assertEqual(type(expected), type(output[0]))
self.assertEqual(expected, output[0])
self.assertEqual('text/plain', output[1])
self.assertEqual('txt', output[2])
def _test_render(self, stuff, type="string"):
env = EnvironmentStub(enable=[PHPRenderer])
m = Mimeview(env)
r = m.renderers[0]
if type == "string":
s = stuff
elif type == "file":
s = StringIO(stuff)
else:
raise NotImplementedException(
"Pass either type=file or type=string")
result = list(r.render(None, None, s))
return result
def test_python_hello_mimeview(self):
"""
Simple Python highlighting with Pygments (through Mimeview.render)
"""
result = Mimeview(self.env).render(self.context, 'text/x-python', """
def hello():
return "Hello World!"
""")
self.assertTrue(result)
if pygments_version < parse_version('2.1'):
self._test('python_hello_mimeview', result)
else:
self._test('python_hello_mimeview_pygments_2.1plus', result)
def _init_types(self):
if self._types is None:
self._types = {}
self._languages = {}
if have_pygments:
for name, aliases, _, mimetypes in get_all_lexers():
for mimetype in mimetypes:
self._types[mimetype] = (aliases[0],
self.QUALITY_RATIO)
for alias in aliases:
self._languages[alias] = name
self._types.update(
Mimeview(self.env).configured_modes_mapping('pygments'))
def setUp(self):
env = EnvironmentStub(enable=[Chrome, PatchRenderer])
req = MockRequest(env)
self.context = web_context(req)
self.patch = Mimeview(env).renderers[0]
html_file = os.path.join(os.path.dirname(__file__), 'patch.data')
self.patch_html = {}
testcase = []
with open(html_file, 'rb') as f:
for line in f.readlines():
if line.startswith('#'):
self.patch_html[line[1:].strip()] = testcase = []
else:
testcase.append(line.rstrip())
def test_plain_text_content(self):
"""Render simple plain text content."""
mimeview = Mimeview(self.env)
req = MockRequest(self.env)
context = RenderingContext(Resource('wiki', 'readme.txt'))
context.req = req
content = io.BytesIO("""\
Some text.
""")
rendered = mimeview.render(context, 'text/plain', content)
self.assertEqual('<div class="code"><pre>Some text.\n</pre></div>',
str(rendered))
def get_item_all_fields_values(self, iids):
if not iids:
return []
sql = 'SELECT itemID, fieldID, value'
sql += ',\n (SELECT itemTypeID FROM items I NATURAL JOIN itemTypesCombined ITC WHERE ID.itemID = I.itemID) AS itemTypeID'
sql += ',\n (SELECT orderIndex FROM itemTypeFieldsCombined ITFC WHERE ITFC.fieldID = ID.fieldID) AS orderIndex'
sql += ',\n (SELECT fieldName FROM fieldsCombined FC WHERE FC.fieldID = ID.fieldID) AS fieldName'
sql += '\n FROM itemData ID NATURAL JOIN itemDataValues WHERE itemID = ' + str(
iids)
sql += '\n ORDER BY orderIndex'
c = self.db.cursor()
c.execute(sql)
to_unicode = Mimeview(self.env).to_unicode
return [[to_unicode(j) for j in i] for i in c]
def get_titlepage(self, template_path, title, subject, version, date):
hfile, hfilename = mkstemp('wikitopdf')
codepage = Mimeview(self.env).default_charset
file_page = open(template_path, 'r')
string_page = file_page.read()
string_page = string_page.replace('#TITLE#', title)
string_page = string_page.replace('#SUBJECT#', subject)
string_page = string_page.replace('#VERSAO#', version)
string_page = string_page.replace('#DATA#', date)
os.write(hfile, string_page)
os.close(hfile)
return hfilename
def render(self, req, mimetype, content, filename=None, rev=None):
from trac.web.clearsilver import HDFWrapper
content = content_to_unicode(self.env, content, mimetype)
d = self._diff_to_hdf(content.splitlines(),
Mimeview(self.env).tab_width)
if not d:
raise TracError, u'Contenu diff unifié invalide'
hdf = HDFWrapper(loadpaths=[self.env.get_templates_dir(),
self.config.get('trac', 'templates_dir')])
hdf['diff.files'] = d
add_stylesheet(req, 'common/css/diff.css')
return hdf.render(hdf.parse(self.diff_cs))
def _init_types(self):
self._types = {}
for lexname, aliases, _, mimetypes in get_all_lexers():
name = aliases[0] if aliases else lexname
for mimetype in mimetypes:
self._types[mimetype] = (name, self.QUALITY_RATIO)
# Pygments < 1.4 doesn't know application/javascript
if 'application/javascript' not in self._types:
js_entry = self._types.get('text/javascript')
if js_entry:
self._types['application/javascript'] = js_entry
self._types.update(
Mimeview(self.env).configured_modes_mapping('pygments'))
def get_quality_ratio(self, mimetype):
if pygments is None:
return 0
# Extend default MIME type to mode mappings with configured ones
if self._types is None:
self._types = {}
for modname, _, aliases, _, mimetypes in _iter_lexerinfo():
for mimetype in mimetypes:
self._types[mimetype] = (aliases[0], self.QUALITY_RATIO)
self._types.update(
Mimeview(self.env).configured_modes_mapping('pygments'))
try:
return self._types[mimetype][1]
except KeyError:
return 0
def setUp(self):
self.env = EnvironmentStub(enable=[Chrome, LineNumberAnnotator,
PygmentsRenderer])
self.pygments = Mimeview(self.env).renderers[0]
self.req = MockRequest(self.env)
self.context = web_context(self.req)
self.pygments_html = {}
testcase = []
html_file = os.path.join(os.path.dirname(__file__), 'pygments.data')
with open(html_file, 'rb') as f:
for line in f.readlines():
if line.startswith('#'):
self.pygments_html[line[1:].strip()] = testcase = []
else:
testcase.append(unicode(line.rstrip(), 'utf-8'))
def render(self, context, mimetype, content, filename=None, rev=None):
req = context.req
content = content_to_unicode(self.env, content, mimetype)
changes = self._diff_to_hdf(content.splitlines(),
Mimeview(self.env).tab_width)
if not changes or not any(c['diffs'] for c in changes):
self.log.debug("Invalid unified diff content: %.40r... (%d "
"characters)", content, len(content))
return
data = {'diff': {'style': 'inline'}, 'no_id': True,
'changes': changes, 'longcol': 'File', 'shortcol': ''}
add_script(req, 'common/js/diff.js')
add_stylesheet(req, 'common/css/diff.css')
return Chrome(self.env).render_fragment(req, 'diff_div.html', data)
def _test_send_converted(self, expected, content, use_chunked_encoding):
self.env.config.set('trac', 'use_chunked_encoding',
'true' if use_chunked_encoding else 'false')
mimeview = Mimeview(self.env)
req = MockRequest(self.env)
self.assertRaises(RequestDone, mimeview.send_converted, req,
self.in_mimetype, content, 'text')
result = req.response_sent.getvalue()
if use_chunked_encoding:
self.assertNotIn('Content-Length', req.headers_sent)
else:
self.assertIn('Content-Length', req.headers_sent)
self.assertEqual(str(len(expected)),
req.headers_sent['Content-Length'])
self.assertEqual('text/plain', req.headers_sent['Content-Type'])
self.assertEqual(set(expected), set(result))
self.assertEqual(expected, result)
