def update_file_from_version_control(self, store):
from pootle.scripts import hooks
store.sync(update_translation=True)
try:
hooks.hook(self.project.code, "preupdate", store.file.name)
except:
pass
# Keep a copy of working files in memory before updating
oldstats = store.getquickstats()
working_copy = store.file.store
try:
logging.debug(u"Updating %s from version control", store.file.name)
from pootle_misc import versioncontrol
versioncontrol.update_file(store.file.name)
store.file._delete_store_cache()
store.file._update_store_cache()
except Exception, e:
# Something wrong, file potentially modified, bail out
# and replace with working copy
logging.error(
u"Near fatal catastrophe, exception %s while updating "
"%s from version control", e, store.file.name)
working_copy.save()
raise VersionControlError
def initialize(self):
try:
from pootle.scripts import hooks
hooks.hook(self.project.code, "initialize", self.real_path,
self.language.code)
except Exception:
logging.exception(u"Failed to initialize (%s)", self.language.code)
def update_file_from_version_control(self, store):
from pootle.scripts import hooks
store.sync(update_translation=True)
try:
hooks.hook(self.project.code, "preupdate", store.file.name)
except:
pass
# Keep a copy of working files in memory before updating
oldstats = store.getquickstats()
working_copy = store.file.store
try:
logging.debug(u"Updating %s from version control", store.file.name)
from pootle_misc import versioncontrol
versioncontrol.update_file(store.file.name)
store.file._delete_store_cache()
store.file._update_store_cache()
except Exception, e:
# Something wrong, file potentially modified, bail out
# and replace with working copy
logging.error(u"Near fatal catastrophe, exception %s while "
u"updating %s from version control",
e, store.file.name)
working_copy.save()
raise VersionControlError
def initialize(self):
try:
from pootle.scripts import hooks
hooks.hook(self.project.code, "initialize", self.real_path,
self.language.code)
except Exception:
logging.exception(u"Failed to initialize (%s)", self.language.code)
def update_file_from_version_control(self, store):
try:
hooks.hook(self.project.code, "preupdate", store.file.path)
except:
pass
# keep a copy of working files in memory before updating
oldstats = store.getquickstats()
working_copy = store.file.store
try:
logging.debug(u"updating %s from version control", store.file.path)
versioncontrol.updatefile(store.file.path)
store.file._delete_store_cache()
store.update(update_structure=True,
update_translation=True,
conservative=False)
remotestats = store.getquickstats()
except Exception, e:
#something wrong, file potentially modified, bail out
#and replace with working copy
logging.error(
u"near fatal catastrophe, exception %s while updating %s from version control",
e, store.file.path)
working_copy.save()
raise VersionControlError
def initialize(self):
try:
hooks.hook(self.project.code, "initialize", self.real_path,
self.language.code)
except Exception, e:
logging.error(u"Failed to initialize (%s): %s", self.language.code,
e)
def update_file_from_version_control(self, store):
from pootle.scripts import hooks
store.sync(update_translation=True)
filetoupdate = store.file.name
try:
filetoupdate = hooks.hook(self.project.code, "preupdate",
store.file.name)
except:
pass
# Keep a copy of working files in memory before updating
oldstats = store.getquickstats()
working_copy = store.file.store
try:
logging.debug(u"Updating %s from version control", store.file.name)
from pootle_misc import versioncontrol
versioncontrol.update_file(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
except Exception as e:
# Something wrong, file potentially modified, bail out
# and replace with working copy
logging.error(u"Near fatal catastrophe, exception %s while "
u"updating %s from version control",
e, store.file.name)
working_copy.save()
raise VersionControlError
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
remotestats = store.getquickstats()
#FIXME: try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy, None, allownewstrings=False,
suggestions=True, notranslate=False,
obsoletemissing=False)
except Exception as e:
logging.error(u"Near fatal catastrophe, exception %s while merging "
u"%s with version control copy", e, store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True)
raise
newstats = store.getquickstats()
return oldstats, remotestats, newstats
def update_file_from_version_control(self, store):
from pootle.scripts import hooks
store.sync(update_translation=True)
filetoupdate = store.file.name
try:
filetoupdate = hooks.hook(self.project.code, "preupdate",
store.file.name)
except:
pass
# Keep a copy of working files in memory before updating
working_copy = store.file.store
try:
logging.debug(u"Updating %s from version control", store.file.name)
from pootle_misc import versioncontrol
versioncontrol.update_file(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
except Exception:
# Something wrong, file potentially modified, bail out
# and replace with working copy
logging.exception(
u"Near fatal catastrophe, while updating %s "
u"from version control", store.file.name)
working_copy.save()
raise VersionControlError
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
#FIXME: try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy,
None,
allownewstrings=False,
suggestions=True,
notranslate=False,
obsoletemissing=False)
except Exception:
logging.exception(
u"Near fatal catastrophe, while merging %s with "
u"version control copy", store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True)
raise
def commitpofile(self, request, store):
"""commits an individual PO file to version control"""
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to commit files here"))
store.sync(update_structure=True, update_translation=True, conservative=False)
stats = store.getquickstats()
author = request.user.username
message = stats_message("Commit from %s by user %s." % (settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting it (ie. Git).
if request.user.is_authenticated() and len(request.user.email):
author += " <%s>" % request.user.email
try:
filestocommit = hooks.hook(self.project.code, "precommit", store.file.path, author=author, message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just isn't a hook to
# import. That means we'll commit the original file.
filestocommit = [store.file.path]
success = True
try:
for file in filestocommit:
versioncontrol.commitfile(file, message=message, author=author)
request.user.message_set.create(message="Committed file: <em>%s</em>" % file)
except Exception, e:
logging.error("Failed to commit files: %s", e)
request.user.message_set.create(message="Failed to commit file: %s" % e)
success = False
def commitpofile(self, user, store):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False, update_translation=True, conservative=True)
stats = store.getquickstats()
author = user.username
message = stats_message("Commit from %s by user %s." % (settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code, "precommit", store.file.path, author=author, message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just isn't a hook to
# import. That means we'll commit the original file.
filestocommit = [store.file.path]
success = True
try:
from translate.storage import versioncontrol
for file in filestocommit:
versioncontrol.commitfile(file, message=message, author=author)
user.message_set.create(message="Committed file: <em>%s</em>" % file)
except Exception, e:
logging.error(u"Failed to commit files: %s", e)
user.message_set.create(message="Failed to commit file: %s" % e)
success = False
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False,
update_translation=True,
conservative=True)
stats = store.getquickstats()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file,
message=message,
author=author)
if request is not None:
msg = _(
"Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception, e:
logging.error(u"Failed to commit file: %s", e)
if request is not None:
msg = _(
"Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", {
'filename': filename,
'error': e,
})
messages.error(request, msg)
success = False
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
stats = self.getquickstats()
author = user.username
message = stats_message_raw("Commit from %s by user %s." %
(settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
if request is not None:
msg = _("Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception, e:
logging.error(u"Failed to commit: %s", e)
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False, update_translation=True,
conservative=True)
stats = store.getquickstats()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file, message=message, author=author)
if request is not None:
msg = _("Committed file <em>%(filename)s</em> to version "
"control",
{'filename': file})
messages.success(request, msg)
except Exception, e:
logging.error(u"Failed to commit file: %s", e)
if request is not None:
msg = _("Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s",
{
'filename': filename,
'error': e,
}
)
messages.error(request, msg)
success = False
def update_file_from_version_control(self, store):
try:
hooks.hook(self.project.code, "preupdate", store.file.path)
except:
pass
# keep a copy of working files in memory before updating
oldstats = store.getquickstats()
working_copy = store.file.store
try:
logging.debug("updating %s from version control", store.file.path)
versioncontrol.updatefile(store.file.path)
store.file._delete_store_cache()
store.update(update_structure=True, update_translation=True, conservative=False)
remotestats = store.getquickstats()
except Exception, e:
#something wrong, file potentially modified, bail out
#and replace with working copy
logging.error("near fatal catastrophe, exception %s while updating %s from version control", e, store.file.path)
working_copy.save()
raise VersionControlError
def commitpofile(self, request, store):
"""commits an individual PO file to version control"""
#FIXME: this is a view what is it doing here
if not check_permission("commit", request):
raise PermissionDenied(
_("You do not have rights to commit files here"))
store.sync(update_structure=False,
update_translation=True,
conservative=True)
stats = store.getquickstats()
author = request.user.username
message = stats_message(
"Commit from %s by user %s." % (settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting it (ie. Git).
if request.user.is_authenticated() and len(request.user.email):
author += " <%s>" % request.user.email
try:
filestocommit = hooks.hook(self.project.code,
"precommit",
store.file.path,
author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just isn't a hook to
# import. That means we'll commit the original file.
filestocommit = [store.file.path]
success = True
try:
for file in filestocommit:
versioncontrol.commitfile(file, message=message, author=author)
request.user.message_set.create(
message="Committed file: <em>%s</em>" % file)
except Exception, e:
logging.error(u"Failed to commit files: %s", e)
request.user.message_set.create(
message="Failed to commit file: %s" % e)
success = False
def commitpofile(self, user, store):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False,
update_translation=True,
conservative=True)
stats = store.getquickstats()
author = user.username
message = stats_message(
"Commit from %s by user %s." % (settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code,
"precommit",
store.file.path,
author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just isn't a hook to
# import. That means we'll commit the original file.
filestocommit = [store.file.path]
success = True
try:
from translate.storage import versioncontrol
for file in filestocommit:
versioncontrol.commitfile(file, message=message, author=author)
user.message_set.create(message="Committed file: <em>%s</em>" %
file)
except Exception, e:
logging.error(u"Failed to commit files: %s", e)
user.message_set.create(message="Failed to commit file: %s" % e)
success = False
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False, update_translation=True,
conservative=True)
total = store.get_total_wordcount()
translated = store.get_translated_wordcount()
fuzzy = store.get_fuzzy_wordcount()
author = user.username
siteconfig = load_site_config()
message = stats_message_raw("Commit from %s by user %s." % \
(siteconfig.get('TITLE'), author), total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file, message=message,
author=author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit file")
# FIXME: This belongs to views
if request is not None:
msg_params = {
'filename': filename,
'error': e,
}
msg = _("Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", msg_params)
messages.error(request, msg)
success = False
try:
hooks.hook(self.project.code, "postcommit", store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self, path_obj=store,
user=user, success=success)
return success
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
total = directory.get_total_wordcount()
translated = directory.get_translated_wordcount()
fuzzy = directory.get_fuzzy_wordcount()
author = user.username
siteconfig = load_site_config()
message = stats_message_raw("Commit from %s by user %s." %
(siteconfig.get('TITLE'), author),
total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(hooks.hook(self.project.code, "precommit",
store.file.name, author=author,
message=message)
)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
# FIXME: This belongs to views
if request is not None:
msg = _("Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit directory")
# FIXME: This belongs to views
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
for store in stores:
try:
hooks.hook(self.project.code, "postcommit", store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self, path_obj=directory,
user=user, success=success)
return success
def update_dir(self, request=None, directory=None):
"""Updates translation project's files from version control, retaining
uncommitted translations.
"""
remote_stats = {}
from pootle_misc import versioncontrol
try:
versioncontrol.update_dir(self.real_path)
except IOError as e:
logging.exception(u"Error during update of %s", self.real_path)
if request:
msg = _("Failed to update from version control: %(error)s",
{"error": e})
messages.error(request, msg)
return
all_files, new_files = self.scan_files()
new_file_set = set(new_files)
from pootle.scripts import hooks
# Go through all stores except any pootle-terminology.* ones
if directory.is_translationproject():
stores = self.stores.exclude(file="")
else:
stores = directory.stores.exclude(file="")
for store in stores.iterator():
if store in new_file_set:
continue
store.sync(update_translation=True)
filetoupdate = store.file.name
try:
filetoupdate = hooks.hook(self.project.code, "preupdate",
store.file.name)
except:
pass
# keep a copy of working files in memory before updating
working_copy = store.file.store
versioncontrol.copy_to_podir(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
try:
hooks.hook(self.project.code, "postupdate",
store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
#FIXME: Try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy, None, allownewstrings=False,
suggestions=True, notranslate=False,
obsoletemissing=False)
except Exception:
logging.exception(u"Near fatal catastrophe, while merging %s "
"with version control copy", store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True)
raise
if request:
msg = \
_(u'Updated project <em>%(project)s</em> from version control',
{'project': self.fullname})
messages.info(request, msg)
from pootle_app.models.signals import post_vc_update
post_vc_update.send(sender=self)
def update_against_templates(self, pootle_path=None):
"""Update translation project from templates."""
if self.is_template_project:
return
template_translation_project = self.project \
.get_template_translationproject()
if (template_translation_project is None or
template_translation_project == self):
return
monolingual = self.project.is_monolingual
if not monolingual:
self.sync()
from pootle_app.project_tree import (convert_template,
get_translated_name,
get_translated_name_gnu)
for store in template_translation_project.stores.iterator():
if self.file_style == 'gnu':
new_pootle_path, new_path = get_translated_name_gnu(self, store)
else:
new_pootle_path, new_path = get_translated_name(self, store)
if pootle_path is not None and new_pootle_path != pootle_path:
continue
try:
from pootle.scripts import hooks
relative_po_path = os.path.relpath(new_path,
settings.PODIRECTORY)
if not hooks.hook(self.project.code, "pretemplateupdate",
relative_po_path):
continue
except:
# Assume hook is not present.
pass
convert_template(self, store, new_pootle_path, new_path,
monolingual)
all_files, new_files = self.scan_files(vcs_sync=False)
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
if new_files and versioncontrol.hasversioning(project_path):
from pootle.scripts import hooks
siteconfig = load_site_config()
message = ("New files added from %s based on templates" %
siteconfig.get('TITLE'))
filestocommit = []
for new_file in new_files:
try:
hook_files = hooks.hook(self.project.code, "precommit",
new_file.file.name, author=None,
message=message)
filestocommit.extend(hook_files)
except ImportError:
# Failed to import the hook - we're going to assume there
# just isn't a hook to import. That means we'll commit the
# original file.
filestocommit.append(new_file.file.name)
success = True
try:
output = versioncontrol.add_files(project_path, filestocommit,
message)
except Exception:
logging.exception(u"Failed to add files")
success = False
for new_file in new_files:
try:
hooks.hook(self.project.code, "postcommit",
new_file.file.name, success=success)
except:
#FIXME: We should not hide the exception - makes
# development impossible
pass
if pootle_path is None:
from pootle_app.models.signals import post_template_update
post_template_update.send(sender=self)
def commit_file(self, user, store, request=None):
"""Commits an individual file to version control.
This does not do permission checking.
"""
store.sync(update_structure=False,
update_translation=True,
conservative=True)
total = store.get_total_wordcount()
translated = store.get_translated_wordcount()
fuzzy = store.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(get_site_title(), author), total, translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
from pootle.scripts import hooks
try:
filestocommit = hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message)
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit = [store.file.name]
success = True
try:
from pootle_misc import versioncontrol
for file in filestocommit:
versioncontrol.commit_file(file,
message=message,
author=author)
# FIXME: This belongs to views
if request is not None:
msg = _(
"Committed file <em>%(filename)s</em> to version "
"control", {'filename': file})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit file")
# FIXME: This belongs to views
if request is not None:
msg_params = {
'filename': filename,
'error': e,
}
msg = _(
"Failed to commit <em>%(filename)s</em> to version "
"control: %(error)s", msg_params)
messages.error(request, msg)
success = False
try:
hooks.hook(self.project.code,
"postcommit",
store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self,
path_obj=store,
user=user,
success=success)
return success
def update_against_templates(self, pootle_path=None):
"""Update translation project from templates."""
if self.is_template_project:
return
template_translation_project = self.project \
.get_template_translationproject()
if (template_translation_project is None
or template_translation_project == self):
return
monolingual = self.project.is_monolingual()
if not monolingual:
self.sync()
if pootle_path is None:
oldstats = self.getquickstats()
from pootle_app.project_tree import (convert_template,
get_translated_name,
get_translated_name_gnu)
for store in template_translation_project.stores.iterator():
if self.file_style == 'gnu':
new_pootle_path, new_path = get_translated_name_gnu(
self, store)
else:
new_pootle_path, new_path = get_translated_name(self, store)
if pootle_path is not None and new_pootle_path != pootle_path:
continue
relative_po_path = os.path.relpath(new_path, settings.PODIRECTORY)
try:
from pootle.scripts import hooks
if not hooks.hook(self.project.code, "pretemplateupdate",
relative_po_path):
continue
except:
# Assume hook is not present.
pass
convert_template(self, store, new_pootle_path, new_path,
monolingual)
all_files, new_files = self.scan_files(vcs_sync=False)
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
if new_files and versioncontrol.hasversioning(project_path):
from pootle.scripts import hooks
message = "New files added from %s based on templates" % \
(settings.TITLE)
filestocommit = []
for new_file in new_files:
try:
filestocommit.extend(
hooks.hook(self.project.code,
"precommit",
new_file.file.name,
author=None,
message=message))
except ImportError:
# Failed to import the hook - we're going to assume there
# just isn't a hook to import. That means we'll commit the
# original file.
filestocommit.append(new_file.file.name)
success = True
try:
output = versioncontrol.add_files(project_path, filestocommit,
message)
except Exception, e:
logging.error(u"Failed to add files: %s", e)
success = False
for new_file in new_files:
try:
hooks.hook(self.project.code,
"postcommit",
new_file.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes
# development impossible
pass
def update_project(self, request):
"""Updates project translation files from version control,
retaining uncommitted translations"""
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to update from "\
"version control here"))
old_stats = self.getquickstats()
remote_stats = {}
from pootle_misc import versioncontrol
versioncontrol.update_dir(self.real_path)
all_files, new_files = self.scan_files()
new_file_set = set(new_files)
from pootle.scripts import hooks
# Go through all stores except any pootle-terminology.* ones
for store in self.stores.exclude(file="").iterator():
if store in new_file_set:
# these won't have to be merged, since they are new
remotestats = store.getquickstats()
remote_stats = dictsum(remote_stats, remotestats)
continue
store.sync(update_translation=True)
try:
hooks.hook(self.project.code, "preupdate", store.file.name)
except:
pass
# keep a copy of working files in memory before updating
working_copy = store.file.store
store.file._delete_store_cache()
store.file._update_store_cache()
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True, \
conservative=False)
remotestats = store.getquickstats()
#FIXME: Try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy,
None,
allownewstrings=False,
suggestions=True,
notranslate=False,
obsoletemissing=False)
except Exception, e:
logging.error(
u"Near fatal catastrophe, exception %s while "
"merging %s with version control copy", e, store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True, \
conservative=False)
raise
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
remote_stats = dictsum(remote_stats, remotestats)
def initialize(self):
try:
hooks.hook(self.project.code, "initialize", self.real_path, self.language.code)
except Exception, e:
logging.error("Failed to initialize (%s): %s", self.language.code, e)
def update_project(self, request):
"""Updates project translation files from version control,
retaining uncommitted translations"""
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to update from "\
"version control here"))
old_stats = self.getquickstats()
remote_stats = {}
from pootle_misc import versioncontrol
versioncontrol.update_dir(self.real_path)
all_files, new_files = self.scan_files()
new_file_set = set(new_files)
from pootle.scripts import hooks
# Go through all stores except any pootle-terminology.* ones
for store in self.stores.exclude(file="").iterator():
if store in new_file_set:
# these won't have to be merged, since they are new
remotestats = store.getquickstats()
remote_stats = dictsum(remote_stats, remotestats)
continue
store.sync(update_translation=True)
try:
hooks.hook(self.project.code, "preupdate", store.file.name)
except:
pass
# keep a copy of working files in memory before updating
working_copy = store.file.store
store.file._delete_store_cache()
store.file._update_store_cache()
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True, \
conservative=False)
remotestats = store.getquickstats()
#FIXME: Try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy, None, allownewstrings=False,
suggestions=True, notranslate=False,
obsoletemissing=False)
except Exception, e:
logging.error(u"Near fatal catastrophe, exception %s while "
"merging %s with version control copy",
e, store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True, \
conservative=False)
raise
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
remote_stats = dictsum(remote_stats, remotestats)
# something wrong, file potentially modified, bail out
# and replace with working copy
logging.error(
"near fatal catastrophe, exception %s while updating %s from version control", e, store.file.path
)
working_copy.save()
raise VersionControlError
# FIXME: try to avoid merging if file was not updated
logging.debug("merging %s with version control update", store.file.path)
store.mergefile(
working_copy, None, allownewstrings=False, suggestions=True, notranslate=False, obsoletemissing=False
)
try:
hooks.hook(self.project.code, "postupdate", store.file.path)
except:
pass
newstats = store.getquickstats()
return oldstats, remotestats, newstats
def update_project(self, request):
"""updates project translation files from version control,
retaining uncommitted translations"""
if not check_permission("commit", request):
raise PermissionDenied(_("You do not have rights to update from version control here"))
old_stats = self.getquickstats()
remote_stats = {}
from pootle_misc import versioncontrol
versioncontrol.update_file(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
except Exception, e:
# Something wrong, file potentially modified, bail out
# and replace with working copy
logging.error(
u"Near fatal catastrophe, exception %s while "
u"updating %s from version control", e, store.file.name)
working_copy.save()
raise VersionControlError
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
remotestats = store.getquickstats()
#FIXME: try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy,
None,
allownewstrings=False,
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
total = directory.get_total_wordcount()
translated = directory.get_translated_wordcount()
fuzzy = directory.get_fuzzy_wordcount()
author = user.username
message = stats_message_raw(
"Commit from %s by user %s." % (get_site_title(), author), total,
translated, fuzzy)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(
hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message))
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(project_path, filestocommit, message,
author)
# FIXME: This belongs to views
if request is not None:
msg = _(
"Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception as e:
logging.exception(u"Failed to commit directory")
# FIXME: This belongs to views
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
for store in stores:
try:
hooks.hook(self.project.code,
"postcommit",
store.file.name,
success=success)
except:
#FIXME: We should not hide the exception - makes development
# impossible
pass
from pootle_app.models.signals import post_vc_commit
post_vc_commit.send(sender=self,
path_obj=directory,
user=user,
success=success)
return success
#FIXME: try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy, None, allownewstrings=False,
suggestions=True, notranslate=False,
obsoletemissing=False)
except Exception, e:
logging.error(u"Near fatal catastrophe, exception %s while merging "
u"%s with version control copy", e, store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True,
conservative=False)
raise
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
newstats = store.getquickstats()
return oldstats, remotestats, newstats
def update_dir(self, request=None, directory=None):
"""Updates translation project's files from version control, retaining
uncommitted translations.
"""
old_stats = self.getquickstats()
remote_stats = {}
from pootle_misc import versioncontrol
try:
e, store.file.path)
working_copy.save()
raise VersionControlError
#FIXME: try to avoid merging if file was not updated
logging.debug(u"merging %s with version control update",
store.file.path)
store.mergefile(working_copy,
None,
allownewstrings=False,
suggestions=True,
notranslate=False,
obsoletemissing=False)
try:
hooks.hook(self.project.code, "postupdate", store.file.path)
except:
pass
newstats = store.getquickstats()
return oldstats, remotestats, newstats
def update_project(self, request):
"""updates project translation files from version control,
retaining uncommitted translations"""
if not check_permission("commit", request):
raise PermissionDenied(
_("You do not have rights to update from version control here")
)
def update_dir(self, request=None, directory=None):
"""Updates translation project's files from version control, retaining
uncommitted translations.
"""
old_stats = self.getquickstats()
remote_stats = {}
from pootle_misc import versioncontrol
try:
versioncontrol.update_dir(self.real_path)
except IOError as e:
logging.error(u"Error during update of %(path)s:\n%(error)s", {
"path": self.real_path,
"error": e,
})
if request:
msg = _("Failed to update from version control: %(error)s",
{"error": e})
messages.error(request, msg)
return
all_files, new_files = self.scan_files()
new_file_set = set(new_files)
from pootle.scripts import hooks
# Go through all stores except any pootle-terminology.* ones
if directory.is_translationproject():
stores = self.stores.exclude(file="")
else:
stores = directory.stores.exclude(file="")
for store in stores.iterator():
if store in new_file_set:
# these won't have to be merged, since they are new
remotestats = store.getquickstats()
remote_stats = dictsum(remote_stats, remotestats)
continue
store.sync(update_translation=True)
filetoupdate = store.file.name
try:
filetoupdate = hooks.hook(self.project.code, "preupdate",
store.file.name)
except:
pass
# keep a copy of working files in memory before updating
working_copy = store.file.store
versioncontrol.copy_to_podir(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
remotestats = store.getquickstats()
#FIXME: Try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy,
None,
allownewstrings=False,
suggestions=True,
notranslate=False,
obsoletemissing=False)
except Exception as e:
logging.error(
u"Near fatal catastrophe, exception %s while "
"merging %s with version control copy", e, store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True)
raise
remote_stats = dictsum(remote_stats, remotestats)
new_stats = self.getquickstats()
if request:
msg = [
_(u'Updated project <em>%(project)s</em> from version control',
{'project': self.fullname}),
stats_message(_(u"Working copy"), old_stats),
stats_message(_(u"Remote copy"), remote_stats),
stats_message(_(u"Merged copy"), new_stats)
]
msg = u"<br/>".join([force_unicode(m) for m in msg])
messages.info(request, msg)
from pootle_app.models.signals import post_vc_update
post_vc_update.send(sender=self,
oldstats=old_stats,
remotestats=remote_stats,
newstats=new_stats)
def update_dir(self, request=None, directory=None):
"""Updates translation project's files from version control, retaining
uncommitted translations.
"""
remote_stats = {}
from pootle_misc import versioncontrol
try:
versioncontrol.update_dir(self.real_path)
except IOError as e:
logging.exception(u"Error during update of %s", self.real_path)
if request:
msg = _("Failed to update from version control: %(error)s",
{"error": e})
messages.error(request, msg)
return
all_files, new_files = self.scan_files()
new_file_set = set(new_files)
from pootle.scripts import hooks
# Go through all stores except any pootle-terminology.* ones
if directory.is_translationproject():
stores = self.stores.exclude(file="")
else:
stores = directory.stores.exclude(file="")
for store in stores.iterator():
if store in new_file_set:
continue
store.sync(update_translation=True)
filetoupdate = store.file.name
try:
filetoupdate = hooks.hook(self.project.code, "preupdate",
store.file.name)
except:
pass
# keep a copy of working files in memory before updating
working_copy = store.file.store
versioncontrol.copy_to_podir(filetoupdate)
store.file._delete_store_cache()
store.file._update_store_cache()
try:
hooks.hook(self.project.code, "postupdate", store.file.name)
except:
pass
try:
logging.debug(u"Parsing version control copy of %s into db",
store.file.name)
store.update(update_structure=True, update_translation=True)
#FIXME: Try to avoid merging if file was not updated
logging.debug(u"Merging %s with version control update",
store.file.name)
store.mergefile(working_copy,
None,
allownewstrings=False,
suggestions=True,
notranslate=False,
obsoletemissing=False)
except Exception:
logging.exception(
u"Near fatal catastrophe, while merging %s "
"with version control copy", store.file.name)
working_copy.save()
store.update(update_structure=True, update_translation=True)
raise
if request:
msg = \
_(u'Updated project <em>%(project)s</em> from version control',
{'project': self.fullname})
messages.info(request, msg)
from pootle_app.signals import post_vc_update
post_vc_update.send(sender=self)
def commit_dir(self, user, directory, request=None):
"""Commits files under a directory to version control.
This does not do permission checking.
"""
self.sync()
stats = self.getquickstats()
author = user.username
message = stats_message_raw("Commit from %s by user %s." % \
(settings.TITLE, author), stats)
# Try to append email as well, since some VCS does not allow omitting
# it (ie. Git).
if user.is_authenticated() and len(user.email):
author += " <%s>" % user.email
if directory.is_translationproject():
stores = list(self.stores.exclude(file=""))
else:
stores = list(directory.stores.exclude(file=""))
filestocommit = []
from pootle.scripts import hooks
for store in stores:
try:
filestocommit.extend(
hooks.hook(self.project.code,
"precommit",
store.file.name,
author=author,
message=message))
except ImportError:
# Failed to import the hook - we're going to assume there just
# isn't a hook to import. That means we'll commit the original
# file.
filestocommit.append(store.file.name)
success = True
try:
from pootle_misc import versioncontrol
project_path = self.project.get_real_path()
versioncontrol.add_files(
project_path,
filestocommit,
message,
author,
)
if request is not None:
msg = _(
"Committed all files under <em>%(path)s</em> to "
"version control", {'path': directory.pootle_path})
messages.success(request, msg)
except Exception, e:
logging.error(u"Failed to commit: %s", e)
if request is not None:
msg = _("Failed to commit to version control: %(error)s",
{'error': e})
messages.error(request, msg)
success = False
