def _get_page_operations(self, source_env, local_env):
operations = {}
# Open source and destination wikis
source_wiki_system = WikiSystem(source_env)
dest_wiki_system = WikiSystem(local_env)
# Extract wiki pages from both wikis
local_pages = []
for page in dest_wiki_system.get_pages():
local_pages.append(page)
source_pages = []
for page in source_wiki_system.get_pages():
source_pages.append(page)
operations[page] = 'create'
# Create operations list
for page in local_pages:
if page in source_pages:
operations[page] = 'update'
# Do not update pages with identical contents
for page, operation in operations.items():
local_page = WikiPage(self.env, page)
source_page = WikiPage(source_env, page)
if local_page.text == source_page.text:
del operations[page]
return operations
def test_wiki_load_pages_from_dir(self):
name1 = 'PageOne'
name2 = 'PageTwo'
path1 = os.path.join(self.tempdir, name1)
path2 = os.path.join(self.tempdir, name2)
content1 = random_paragraph()
content2 = random_paragraph()
with open(path1, 'w') as f:
f.write(content1)
with open(path2, 'w') as f:
f.write(content2)
os.mkdir(os.path.join(self.tempdir, 'subdir'))
rv, output = self.execute('load', self.tempdir)
page1 = WikiPage(self.env, name1)
page2 = WikiPage(self.env, name2)
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'name1': name1,
'name2': name2,
'path1': path1,
'path2': path2,
})
self.assertEqual(content1, page1.text)
self.assertEqual(content2, page2.text)
self.assertEqual(1, page1.version)
self.assertEqual(1, page2.version)
def wiki_setup(tc):
wiki1 = WikiPage(tc.env)
wiki1.name = 'TestPage'
wiki1.text = '--'
wiki1.save('joe', 'normal WikiPageNames', '::1', 42)
wiki2 = WikiPage(tc.env)
wiki2.name = 'Space 1 23'
wiki2.text = '--'
wiki2.save('joe', 'not a WikiPageNames', '::1', 42)
wiki3 = WikiPage(tc.env)
wiki3.name = u"C'est l'\xe9t\xe9"
wiki3.text = '--'
wiki3.save('joe', 'unicode WikiPageNames', '::1', 42)
imt = WikiPage(tc.env)
imt.name = u"InterMapTxt"
imt.text = """
This is the InterMapTxt
----
{{{
MeatBall http://www.usemod.com/cgi-bin/mb.pl? # $1 in MeatBall...
tsvn tsvn:
complex http://server/$1/page/$2?format=txt # resource $2 in $1
}}}
----
{{{
nolink http://noweb
}}}
"""
imt.save('joe', 'test InterWiki links', '::1', 42)
def expand_macro(self, formatter, name, content):
if not content:
return ''
args, kwargs = parse_args(content)
if len(args) > 1:
return system_message("Number of args can't be greater than 1")
if args[0] == 'author':
page = WikiPage(self.env, formatter.context.resource, 1)
text = page.author
elif args[0] == 'version':
page = WikiPage(self.env, formatter.context.resource)
text = str(page.version)
elif args[0] == 'changed_by':
page = WikiPage(self.env, formatter.context.resource)
text = page.author
elif args[0] == 'comment':
page = WikiPage(self.env, formatter.context.resource)
text = page.comment
elif args[0] == 'changed_ts':
page = WikiPage(self.env, formatter.context.resource)
text = format_datetime(page.time)
else:
return system_message("Unkwown argument %s" % args[0])
return format_to_oneliner(self.env, formatter.context, text)
def test_wiki_replace(self):
name1 = random_unique_camel()
name2 = random_unique_camel()
path1 = os.path.join(self.tempdir, name1)
path2 = os.path.join(self.tempdir, name2)
content1 = random_paragraph()
content2 = random_paragraph()
self._insert_page(name1)
self._insert_page(name2)
with open(path1, 'w') as f:
f.write(content1)
with open(path2, 'w') as f:
f.write(content2)
rv, output = self.execute('replace', path1, path2)
page1 = WikiPage(self.env, name1)
page2 = WikiPage(self.env, name2)
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'name1': name1,
'name2': name2,
'path1': path1,
'path2': path2,
})
self.assertIn(('INFO', '%s imported from %s' % (name1, path1)),
self.env.log_messages)
self.assertIn(('INFO', '%s imported from %s' % (name2, path2)),
self.env.log_messages)
self.assertEqual(content1, page1.text)
self.assertEqual(content2, page2.text)
self.assertEqual(1, page1.version)
self.assertEqual(1, page2.version)
def test_delete_page(self):
page = WikiPage(self.env)
page.name = 'SandBox'
page.text = 'Contents for SandBox'
page.save('trac', 'create page')
mod = WikiModule(self.env)
req = MockRequest(self.env,
path_info='/wiki/SandBox',
method='GET',
args={
'action': 'delete',
'version': '1'
})
self.assertTrue(mod.match_request(req))
resp = mod.process_request(req)
self.assertEqual(2, len(resp))
self.assertIn('Are you sure you want to completely delete this page?',
self._render_template(req, resp[0], resp[1]))
req = MockRequest(self.env,
path_info='/wiki/SandBox',
method='POST',
args={'action': 'delete'})
self.assertTrue(mod.match_request(req))
self.assertRaises(RequestDone, mod.process_request, req)
self.assertIn('The page SandBox has been deleted.',
req.chrome.get('notices'))
self.assertEqual(False, WikiPage(self.env, 'SandBox').exists)
def test_wiki_replace_pages_from_dir(self):
names = self._insert_pages(2)
path1 = os.path.join(self.tempdir, names[0])
path2 = os.path.join(self.tempdir, names[1])
content1 = random_paragraph()
content2 = random_paragraph()
with open(path1, 'w') as f:
f.write(content1)
with open(path2, 'w') as f:
f.write(content2)
os.mkdir(os.path.join(self.tempdir, 'subdir'))
rv, output = self.execute('replace', self.tempdir)
page1 = WikiPage(self.env, names[0])
page2 = WikiPage(self.env, names[1])
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'name1': names[0],
'name2': names[1],
'path1': path1,
'path2': path2,
})
self.assertEqual(content1, page1.text)
self.assertEqual(content2, page2.text)
self.assertEqual(1, page1.version)
self.assertEqual(1, page2.version)
def main():
names = sorted(name
for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
env = EnvironmentStub()
load_components(env)
with env.db_transaction:
for name in names:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://trac.edgewall.org/'),
perm=MockPerm(),
chrome={})
for name in sys.argv[1:]:
name = os.path.basename(name)
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource, absurls=True)
rst = wiki2rest(env, context, wiki)
sys.stdout.write(rst)
def main():
options, args = parse_args()
names = sorted(name
for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
if args:
args = sorted(set(names) & set(map(os.path.basename, args)))
else:
args = names
if options.download:
download_default_pages(args, options.prefix)
env = EnvironmentStub()
load_components(env)
with env.db_transaction:
for name in names:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://localhost/'),
perm=MockPerm())
for name in args:
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource)
out = DummyIO()
DefaultWikiChecker(env, context, name).format(wiki.text, out)
def main():
all_pages = sorted(
name for name in resource_listdir('trac.wiki', 'default-pages')
if not name.startswith('.'))
args = parse_args(all_pages)
if args.pages:
pages = sorted(args.pages)
else:
pages = all_pages
if args.download:
download_default_pages(pages, args.prefix, args.strict)
env = EnvironmentStub(disable=['trac.mimeview.pygments.*'])
load_components(env)
with env.db_transaction:
for name in all_pages:
wiki = WikiPage(env, name)
wiki.text = resource_string('trac.wiki', 'default-pages/' +
name).decode('utf-8')
if wiki.text:
wiki.save('trac', '')
else:
printout('%s: Skipped empty page' % name)
req = Mock(href=Href('/'),
abs_href=Href('http://localhost/'),
perm=MockPerm())
for name in pages:
wiki = WikiPage(env, name)
if not wiki.exists:
continue
context = web_context(req, wiki.resource)
out = DummyIO()
DefaultWikiChecker(env, context, name).format(wiki.text, out)
def _get_problems(self, silent):
res = u""
resargs = u""
respages = u""
base_pages = []
for page in sorted(WikiSystem(self.env).get_pages()):
for line in WikiPage(self.env, page).text.replace('\r',
'').split(u'\n'):
regres = self.macro_re.search(line)
if regres != None:
(prefix, base_page_name,
lang_code) = self._get_page_info(page)
basename = self._get_translated_page(prefix, \
base_page_name, self.base_lang)
if not basename in base_pages:
base_pages.append(basename)
resargs += self._check_args(page, regres.group(1),
lang_code)
if self.languages.get(lang_code, None) == None:
respages += "||[[wiki:/%s]]||Translated page language code unknown||\n" % page
base_pages.sort()
for base_page in base_pages:
(prefix, page, lang_code) = self._get_page_info(base_page)
translations = self._get_translations(prefix, page)
basever = 0
if not self.base_lang in translations:
respages += "||[[wiki:/%s]]||Base language is missing for translated pages||\n" % base_page
else:
basever = WikiPage(self.env, base_page).version
for translation in translations:
transpage = self._get_translated_page(prefix, page,
translation)
regres = self.macro_re.search(
WikiPage(self.env, transpage).text)
if regres != None:
argstr = regres.group(1)
if argstr != None and len(argstr) > 0:
args, kw = parse_args(argstr)
try:
rev = int(kw[u'revision'])
if rev != 0 and rev > basever:
respages += "||[[wiki:/%s]]||Revision %s is higher than base revision %s||\n" \
% (transpage, rev, basever)
except:
pass
else:
respages += "||[[wiki:/%s]]||Translated page misses macro 'TranslatedPages'||\n" % transpage
if len(resargs):
res += u"=== Errors in supplied arguments ===\n||= Page =||= Arguments =||= Issue =||\n" + resargs
if len(respages):
res += u"=== Errors in page structure ===\n||= Page =||= Issue =||\n" + respages
if not len(res):
if (silent):
return u" "
res = u'none\n'
return u"== Problem pages ==\n" + res
def process_request(self, req):
action = req.args.get('action', 'view')
pagename = req.args.get('page', 'WikiStart')
version = req.args.get('version')
db = self.env.get_db_cnx()
page = WikiPage(self.env, pagename, version, db)
##########
# readonly hack. if user created page originally, user can edit readonly
# page.readonly = 0 allows wiki.css to show edit buttons
if page.readonly == 1 and action == 'view' and not req.perm.has_permission('WIKI_ADMIN'):
cursor = db.cursor()
#cursor.execute("SELECT * FROM wiki WHERE author=%s AND name=%s ORDER BY version ASC LIMIT 1", (req.authname,pagename) )
cursor.execute("SELECT * FROM wiki WHERE author=%s AND name=%s AND version=1", (req.authname,pagename) )
if cursor.fetchone():
page.readonly = 0
##########
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(self.env.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(self.env.href.wiki(page.name, version=page.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:
if req.args.get('format') == 'txt':
req.send_response(200)
req.send_header('Content-Type', 'text/plain;charset=utf-8')
req.end_headers()
req.write(page.text)
return
self._render_view(req, db, page)
req.hdf['wiki.action'] = action
req.hdf['wiki.page_name'] = page.name
req.hdf['wiki.current_href'] = self.env.href.wiki(page.name)
return 'wiki.cs', None
def _insert_templates(self):
page = WikiPage(self.env)
page.name = 'PageTemplates/TheTemplate'
page.text = 'The template below /PageTemplates'
page.save('trac', 'create page')
page = WikiPage(self.env)
page.name = 'TheTemplate'
page.text = 'The template below /'
page.save('trac', 'create page')
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 test_import_page_readonly(self):
page = WikiPage(self.env, 'ReadOnlyPage')
self.assertEqual(5, page.version)
self.assertEqual(1, page.readonly)
self.assertNotEqual(self.page_text, page.text)
self._import_page(self.filename, 'ReadOnlyPage')
page = WikiPage(self.env, 'ReadOnlyPage')
self.assertEqual(6, page.version)
self.assertEqual(1, page.readonly)
self.assertEqual(self.page_text, page.text)
def test_import_page_not_readonly(self):
page = WikiPage(self.env, 'WritablePage')
self.assertEqual(3, page.version)
self.assertEqual(0, page.readonly)
self.assertNotEqual(self.page_text, page.text)
self._import_page(self.filename, 'WritablePage')
page = WikiPage(self.env, 'WritablePage')
self.assertEqual(4, page.version)
self.assertEqual(0, page.readonly)
self.assertEqual(self.page_text, page.text)
def Main(opts):
""" Cross your fingers and pray """
env = Environment(opts.envpath)
from tractags.api import TagSystem
tlist = opts.tags or split_tags(
env.config.get('blog', 'default_tag', 'blog'))
tags = TagSystem(env)
req = Mock(perm=MockPerm())
blog = tags.query(req, ' '.join(tlist + ['realm:wiki']))
cnx = env.get_db_cnx()
for resource, page_tags in list(blog):
try:
page = WikiPage(env, version=1, name=resource.id)
_, publish_time, author, _, _ = page.get_history().next()
if opts.deleteonly:
page.delete()
continue
categories = ' '.join([t for t in page_tags if t not in tlist])
page = WikiPage(env, name=resource.id)
for version, version_time, version_author, version_comment, \
_ in page.get_history():
# Currently the basename of the post url is used due to
# http://trac-hacks.org/ticket/2956
#name = resource.id.replace('/', '_')
name = resource.id
# extract title from text:
fulltext = page.text
match = _title_split_match(fulltext)
if match:
title = match.group(1)
fulltext = match.group(2)
else:
title = name
body = fulltext
print "Adding post %s, v%s: %s" % (name, version, title)
insert_blog_post(cnx, name, version, title, body, publish_time,
version_time, version_comment, version_author,
author, categories)
reparent_blog_attachments(env, resource.id, name)
continue
cnx.commit()
if opts.delete:
page.delete()
continue
except:
env.log.debug("Error loading wiki page %s" % resource.id,
exc_info=True)
print "Failed to add post %s, v%s: %s" % (name, version, title)
cnx.rollback()
cnx.close()
return 1
cnx.close()
return 0
def _do_rename(self, req, page):
if page.readonly:
req.perm(page.resource).require('WIKI_ADMIN')
else:
req.perm(page.resource).require('WIKI_RENAME')
if 'cancel' in req.args:
req.redirect(get_resource_url(self.env, page.resource, req.href))
old_name, old_version = page.name, page.version
new_name = req.args.get('new_name', '')
new_name = re.sub(r'/{2,}', '/', new_name.strip('/'))
redirect = req.args.get('redirect')
# verify input parameters
warn = None
if not new_name:
warn = _("A new name is mandatory for a rename.")
elif not validate_page_name(new_name):
warn = _("The new name is invalid (a name which is separated "
"with slashes cannot be '.' or '..').")
elif new_name == old_name:
warn = _("The new name must be different from the old name.")
elif WikiPage(self.env, new_name).exists:
warn = _("The page %(name)s already exists.", name=new_name)
if warn:
add_warning(req, warn)
return self._render_confirm_rename(req, page, new_name)
with self.env.db_transaction as db:
page.rename(new_name)
if redirect:
redirection = WikiPage(self.env, old_name, db=db)
redirection.text = _('See [wiki:"%(name)s"].', name=new_name)
author = get_reporter_id(req)
comment = u'[wiki:"%s@%d" %s] \u2192 [wiki:"%s"].' % (
new_name, old_version, old_name, new_name)
redirection.save(author, comment, req.remote_addr)
add_notice(
req,
_("The page %(old_name)s has been renamed to "
"%(new_name)s.",
old_name=old_name,
new_name=new_name))
if redirect:
add_notice(
req,
_(
"The page %(old_name)s has been recreated "
"with a redirect to %(new_name)s.",
old_name=old_name,
new_name=new_name))
req.redirect(req.href.wiki(old_name if redirect else new_name))
def wiki_setup(tc):
tc.env.config.set('wiki', 'render_unsafe_content', True) # for #9712
now = datetime.now(utc)
wiki0 = WikiPage(tc.env)
wiki0.name = 'Main/Sub'
wiki0.text = '--'
wiki0.save('joe', 'subpage', '::1', now)
wiki1 = WikiPage(tc.env)
wiki1.name = 'TestPage'
wiki1.text = '--'
wiki1.save('joe', 'normal WikiPageNames', '::1', now)
wiki2 = WikiPage(tc.env)
wiki2.name = 'Space 1 23'
wiki2.text = '--'
wiki2.save('joe', 'not a WikiPageNames', '::1', now)
wiki3 = WikiPage(tc.env)
wiki3.name = u"C'est l'\xe9t\xe9"
wiki3.text = '--'
wiki3.save('joe', 'unicode WikiPageNames', '::1', now)
imt = WikiPage(tc.env)
imt.name = u"InterMapTxt"
imt.text = """
This is the InterMapTxt
----
{{{
MeatBall http://www.usemod.com/cgi-bin/mb.pl? # $1 in MeatBall...
tsvn tsvn:
complex http://server/$1/page/$2?format=txt # resource $2 in $1
}}}
----
{{{
nolink http://noweb
}}}
"""
imt.save('joe', 'test InterWiki links', '::1', now)
w = WikiPage(tc.env)
w.name = 'FirstLevel'
w.text = '--'
w.save('joe', 'first level of hierarchy', '::1', now)
w = WikiPage(tc.env)
w.name = 'FirstLevel/SecondLevel'
w.text = '--'
w.save('joe', 'second level of hierarchy', '::1', now)
w = WikiPage(tc.env)
w.name = 'FirstLevel/SecondLevel/ThirdLevel'
w.text = '--'
w.save('joe', 'third level of hierarchy', '::1', now)
w = WikiPage(tc.env)
w.name = 'FirstLevel/SecondLevel/OtherThirdLevel'
w.text = '--'
w.save('joe', 'other third level of hierarchy', '::1', now)
def test_wiki_list(self):
name1 = self._insert_page('PageOne')
name2 = self._insert_page('PageTwo')
self._change_page(name2)
rv, output = self.execute('list')
self.assertEqual(0, rv, output)
fmt = lambda m: format_datetime(m, console_datetime_format)
self.assertExpectedResult(output, {
'page1_modified': fmt(WikiPage(self.env, name1).time),
'page2_modified': fmt(WikiPage(self.env, name2).time),
})
def test_import_page_uptodate(self):
page = WikiPage(self.env, 'WritablePage')
self.assertEqual(3, page.version)
self.assertEqual(0, page.readonly)
create_file(self.filename, page.text)
page_text = page.text
self._import_page(self.filename, 'WritablePage')
page = WikiPage(self.env, 'WritablePage')
self.assertEqual(3, page.version)
self.assertEqual(0, page.readonly)
self.assertEqual(page_text, page.text)
def process_request(self, req):
action = req.args.get('action', 'view')
pagename = req.args.get('page', 'WikiStart')
version = req.args.get('version')
db = self.env.get_db_cnx()
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(self.env.href.wiki(page.name))
elif int(version) != latest_version:
print 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(
self.env.href.wiki(page.name,
version=page.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:
if req.args.get('format') == 'txt':
req.send_response(200)
req.send_header('Content-Type', 'text/plain;charset=utf-8')
req.end_headers()
req.write(page.text)
return
self._render_view(req, db, page)
req.hdf['wiki.action'] = action
req.hdf['wiki.page_name'] = escape(page.name)
req.hdf['wiki.current_href'] = escape(self.env.href.wiki(page.name))
return 'wiki.cs', None
def test_wiki_import_page_up_to_date(self):
name = self._insert_page()
import_path = os.path.join(self.tempdir, name)
self._write_file(import_path, WikiPage(self.env, name).text)
rv, output = self.execute('import', name, import_path)
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'tempdir': self.tempdir,
'name': name,
})
self.assertIn(('INFO', '%s is already up to date' % name),
self.env.log_messages)
self.assertEqual(1, WikiPage(self.env, name).version)
def setUp(self):
self.env = EnvironmentStub(enable=[AutoWikify])
self.req = Mock(
authname='anonymous', perm=MockPerm(), tz=None, args={},
href=Href('/'), abs_href=Href('http://www.example.com/'))
self.autowikify = AutoWikify(self.env)
for name in (u'autowikify', u'あいうName', u'Nameあいう',
u'かきくけこ'):
page = WikiPage(self.env, name)
page.text = name
page.save('admin', '', '::1')
self.context = Context.from_request(self.req, WikiPage(self.env, name))
def test_wiki_rename(self):
name1 = self._insert_page()
name2 = random_unique_camel()
rv, output = self.execute('rename', name1, name2)
self.assertEqual(0, rv, output)
self.assertExpectedResult(output, {
'name1': name1,
'name2': name2,
})
self.assertIn(('INFO', 'Renamed page %s to %s' % (name1, name2)),
self.env.log_messages)
self.assertFalse(WikiPage(self.env, name1).exists)
self.assertTrue(WikiPage(self.env, name2).exists)
def test_wiki_rename_new_page_exists(self):
names = self._insert_pages(['PageOne', 'PageTwo'])
page1_content = WikiPage(self.env, names[0]).text
page2_content = WikiPage(self.env, names[1]).text
rv, output = self.execute('rename', *names)
self.assertEqual(2, rv, output)
self.assertExpectedResult(output)
page1 = WikiPage(self.env, names[0])
page2 = WikiPage(self.env, names[1])
self.assertTrue(page1.exists)
self.assertTrue(page2.exists)
self.assertEqual(page1_content, page1.text)
self.assertEqual(page2_content, page2.text)
def _controller_import(self, req, cat, page, component):
""" Performs import. """
# Data to be passed to view
data = {'operations': {}}
# User selected pages
selected_pages = req.args.get('wikiimport_selected_pages')
# User has selected some pages
if selected_pages:
# Choose between preconfigured and raw instance
if req.args.get('wikiimport_instance_path'):
data['instance_path'] = req.args.get(
'wikiimport_instance_path')
source_env = Environment(data['instance_path'])
instance_identifier = data['instance_path']
else:
data['instance_id'] = req.args.get('wikiimport_instance_id')
source_env = self._get_instance_env(data['instance_id'])
instance_identifier = data['instance_id']
# Get operations to be performed
data['operations'] = self._get_page_operations(
source_env, self.env)
# This is required in order to display pages list alphabetically
data['sorted_pages'] = data['operations'].keys()
data['sorted_pages'].sort()
# Discard operation for pages that were unchecked on the preview page
for page in data['sorted_pages']:
if page not in selected_pages:
del data['operations'][page]
# Update local wiki
for page, operation in data['operations'].items():
source_page = WikiPage(source_env, page)
local_page = WikiPage(self.env, page)
local_page.text = source_page.text
local_page.save(
get_reporter_id(req, 'author'),
'Importing pages from "%s" using [http://trac-hacks.org/wiki/WikiImportPlugin WikiImport plugin].'
% instance_identifier, req.remote_addr)
# Add stylesheet to view
add_stylesheet(req, 'wikiimport/css/wikiimport.css')
return 'admin_wikiimport_import.html', data
def test_import_page_new(self):
self._import_page(self.filename, 'NewPage')
page = WikiPage(self.env, 'NewPage')
self.assertEqual('NewPage', page.name)
self.assertEqual(1, page.version)
self.assertEqual(self.page_text, page.text)
self.assertEqual(0, page.readonly)
def setUp(self):
wiki = WikiPage(self.env)
wiki.name = 'WikiStart'
wiki.text = '--'
wiki.save('joe', 'Entry page', '::1', datetime.now(utc))
if self._setup:
self._setup(self)
def add_pages(tc, names):
for name in names:
now = datetime_now(utc)
w = WikiPage(tc.env)
w.name = name
w.text = '--'
w.save('joe', 'the page ' + name, now)
