def test_tp_tool_update(po_directory, tp0, templates):
new_lang = LanguageDBFactory()
tp0_tool = TPTool(tp0.project)
new_tp = tp0.project.translationproject_set.create(
language=new_lang)
# this will clone stores/directories as new_tp is empty
tp0_tool.update_from_tp(tp0, new_tp)
_test_tp_match(tp0, new_tp)
tp0_tool.update_from_tp(tp0, new_tp)
tp0.stores.first().delete()
tp0.stores.first().units.first().delete()
unit = tp0.stores.first().units.first()
unit.source = multistring(["NEW TARGET", "NEW TARGETS"])
unit.target = "NEW TARGET"
unit.context = "something-else"
unit.save()
newunit = unit.__class__()
newunit.source = multistring(["OTHER NEW TARGET", "OTHER NEW TARGETS"])
newunit.target = "OTHER NEW TARGET"
newunit.context = "something-else-again"
unit.store.addunit(newunit)
tp0_tool.update_from_tp(tp0, new_tp)
_test_tp_match(tp0, new_tp)
# doing another update does nothing
tp0_tool.update_from_tp(tp0, new_tp)
_test_tp_match(tp0, new_tp)
def gettarget(self):
"""Returns the unescaped msgstr"""
if isinstance(self.msgstr, dict):
multi = multistring(map(unquotefrompo, self.msgstr.values()), self._encoding)
else:
multi = multistring(unquotefrompo(self.msgstr), self._encoding)
return multi
def settarget(self, text, lang='xx', append=False):
self._rich_target = None
if self.target == text:
return
if not self.hasplural():
super(PoXliffUnit, self).settarget(text, lang, append)
return
if not isinstance(text, multistring):
text = multistring(text)
source = self.source
sourcel = len(source.strings)
targetl = len(text.strings)
if sourcel < targetl:
sources = source.strings + [source.strings[-1]] * (targetl - sourcel)
targets = text.strings
id = self.getid()
self.source = multistring(sources)
self.setid(id)
elif targetl < sourcel:
targets = text.strings + [""] * (sourcel - targetl)
else:
targets = text.strings
for i in range(len(self.units)):
self.units[i].target = targets[i]
def test_unit_lifecycle_update_state_reviewed_by(store0, system, member2):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = FUZZY
unit.save(user=system)
# force the unit to be refrozen
unit = unit.__class__.objects.get(id=unit.id)
unit.state = TRANSLATED
unit.save(reviewed_by=member2)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (
sub_state_update.submitter
== unit.change.reviewed_by
== member2)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
def test_plurals(self):
store = self.StoreClass()
store.parse(JSON_I18NEXT)
# Remove plurals
store.units[2].target = 'Ahoj'
store.units[3].target = 'Nazdar'
out = BytesIO()
store.serialize(out)
assert out.getvalue() == JSON_I18NEXT_PLURAL
# Bring back plurals
store.units[2].target = multistring([
"the singular",
"the plural",
])
store.units[3].target = multistring([
"the plural form 0",
"the plural form 1",
"the plural form 2",
"the plural form 3",
"the plural form 4",
"the plural form 5"
])
out = BytesIO()
store.serialize(out)
assert out.getvalue() == JSON_I18NEXT
def to_python(self, value):
if not value:
return multistring("", encoding="UTF-8")
elif isinstance(value, multistring):
return value
elif isinstance(value, basestring):
return multistring(value.split(SEPERATOR), encoding="UTF-8")
elif isinstance(value, dict):
return multistring([val for key, val in sorted(value.items())], encoding="UTF-8")
else:
return multistring(value, encoding="UTF-8")
def to_pypo(unit):
pounit = pypo.pounit(
source=multistring(unit.msgid) if unit.hasplural() else (unit.msgid[0] if len(unit.msgid) else "")
)
pounit.target = multistring(unit.msgstr) if unit.hasplural() else unit.msgstr[0]
if unit.comments:
ps = poparser.ParseState(cStringIO.StringIO(unit.comments.encode("utf8")), pypo.pounit, encoding="utf-8")
poparser.parse_comments(ps, pounit)
return pounit
def test_prevmsgid_parse(self):
"""checks that prevmsgid (i.e. #|) is parsed and saved correctly"""
posource = r'''msgid ""
msgstr ""
"PO-Revision-Date: 2006-02-09 23:33+0200\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8-bit\n"
#, fuzzy
#| msgid "trea"
msgid "tree"
msgstr "boom"
#| msgid "trea"
#| msgid_plural "treas"
msgid "tree"
msgid_plural "trees"
msgstr[0] "boom"
msgstr[1] "bome"
#| msgctxt "context 1"
#| msgid "tast"
msgctxt "context 1a"
msgid "test"
msgstr "toets"
#| msgctxt "context 2"
#| msgid "tast"
#| msgid_plural "tasts"
msgctxt "context 2a"
msgid "test"
msgid_plural "tests"
msgstr[0] "toet"
msgstr[1] "toetse"
'''
pofile = self.poparse(posource)
assert pofile.units[1].prev_msgctxt == []
assert pofile.units[1].prev_source == multistring([u"trea"])
assert pofile.units[2].prev_msgctxt == []
assert pofile.units[2].prev_source == multistring([u"trea", u"treas"])
assert pofile.units[3].prev_msgctxt == [u'"context 1"']
assert pofile.units[3].prev_source == multistring([u"tast"])
assert pofile.units[4].prev_msgctxt == [u'"context 2"']
assert pofile.units[4].prev_source == multistring([u"tast", u"tasts"])
assert str(pofile) == posource
def to_python(value):
"""Reconstruct a multistring from the database string representation."""
if not value:
return multistring("", encoding="UTF-8")
elif isinstance(value, multistring):
return value
elif isinstance(value, basestring):
return parse_multistring(value)
elif isinstance(value, dict):
return multistring([val for __, val in sorted(value.items())],
encoding="UTF-8")
else:
return multistring(value, encoding="UTF-8")
def parse(self, input):
"""parses the given file or file source string"""
if hasattr(input, 'name'):
self.filename = input.name
elif not getattr(self, 'filename', ''):
self.filename = ''
if hasattr(input, "read"):
mosrc = input.read()
input.close()
input = mosrc
little, = struct.unpack("<L", input[:4])
big, = struct.unpack(">L", input[:4])
if little == MO_MAGIC_NUMBER:
endian = "<"
elif big == MO_MAGIC_NUMBER:
endian = ">"
else:
raise ValueError("This is not an MO file")
magic, version_maj, version_min, lenkeys, startkey, \
startvalue, sizehash, offsethash = struct.unpack("%sLHHiiiii" % endian,
input[:(7 * 4)])
if version_maj >= 1:
raise base.ParseError("""Unable to process version %d.%d MO files""" % (version_maj, version_min))
for i in range(lenkeys):
nextkey = startkey + (i * 2 * 4)
nextvalue = startvalue + (i * 2 * 4)
klength, koffset = struct.unpack("%sii" % endian,
input[nextkey:nextkey + (2 * 4)])
vlength, voffset = struct.unpack("%sii" % endian,
input[nextvalue:nextvalue + (2 * 4)])
source = input[koffset:koffset + klength]
context = None
if b"\x04" in source:
context, source = source.split(b"\x04")
# Still need to handle KDE comments
if source == "":
charset = re.search(b"charset=([^\\s]+)",
input[voffset:voffset + vlength])
if charset:
self.encoding = charset.group(1)
source = multistring([s.decode(self.encoding)
for s in source.split(b"\0")])
target = multistring([s.decode(self.encoding)
for s in input[voffset:voffset + vlength].split(b"\0")])
newunit = mounit(source)
newunit.target = target
if context is not None:
newunit.msgctxt.append(context)
self.addunit(newunit)
def parse(self, input):
"""parses the given file or file source string"""
if hasattr(input, 'name'):
self.filename = input.name
elif not getattr(self, 'filename', ''):
self.filename = ''
if hasattr(input, "read"):
mosrc = input.read()
input.close()
input = mosrc
little, = struct.unpack("<L", input[:4])
big, = struct.unpack(">L", input[:4])
if little == MO_MAGIC_NUMBER:
endian = "<"
elif big == MO_MAGIC_NUMBER:
endian = ">"
else:
raise ValueError("This is not an MO file")
magic, version, lenkeys, startkey, \
startvalue, sizehash, offsethash = struct.unpack("%sLiiiiii" % endian,
input[:(7 * 4)])
if version > 1:
raise ValueError("Unable to process MO files with versions > 1. \
This is a %d version MO file" % version)
for i in range(lenkeys):
nextkey = startkey + (i * 2 * 4)
nextvalue = startvalue + (i * 2 * 4)
klength, koffset = struct.unpack("%sii" % endian,
input[nextkey:nextkey + (2 * 4)])
vlength, voffset = struct.unpack("%sii" % endian,
input[nextvalue:nextvalue + (2 * 4)])
source = input[koffset:koffset + klength]
context = None
if "\x04" in source:
context, source = source.split("\x04")
# Still need to handle KDE comments
source = multistring(source.split("\0"), encoding=self._encoding)
if source == "":
charset = re.search("charset=([^\\s]+)",
input[voffset:voffset + vlength])
if charset:
self._encoding = po.encodingToUse(charset.group(1))
target = multistring(input[voffset:voffset + vlength].split("\0"),
encoding=self._encoding)
newunit = mounit(source)
newunit.settarget(target)
if context is not None:
newunit.msgctxt.append(context)
self.addunit(newunit)
def getsource(self):
# TODO: support <byte>. See bug 528.
sourcenode = self._getsourcenode()
if self.hasplural():
return multistring([sourcenode.text])
else:
return data.forceunicode(sourcenode.text)
def getsource(self):
if not self.hasplural():
return super(PoXliffUnit, self).getsource()
else:
strings = []
strings.extend([unit.source for unit in self.units])
return multistring(strings)
def addplural(self, source, target, filename, createifmissing=False):
"""This method should now be unnecessary, but is left for reference"""
assert isinstance(source, multistring)
if not isinstance(target, multistring):
target = multistring(target)
sourcel = len(source.strings)
targetl = len(target.strings)
if sourcel < targetl:
sources = source.strings + [source.strings[-1]] * targetl - sourcel
targets = target.strings
else:
sources = source.strings
targets = target.strings
self._messagenum += 1
pluralnum = 0
group = self.creategroup(filename, True, restype="x-gettext-plural")
for (src, tgt) in zip(sources, targets):
unit = self.UnitClass(src)
unit.target = tgt
unit.setid("%d[%d]" % (self._messagenum, pluralnum))
pluralnum += 1
group.append(unit.xmlelement)
self.units.append(unit)
if pluralnum < sourcel:
for string in sources[pluralnum:]:
unit = self.UnitClass(src)
unit.xmlelement.set("translate", "no")
unit.setid("%d[%d]" % (self._messagenum, pluralnum))
pluralnum += 1
group.append(unit.xmlelement)
self.units.append(unit)
return self.units[-pluralnum]
def test_submit_unit_plural(client, unit_plural, request_users, settings):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
url = '/xhr/units/%d/' % unit_plural.id
original_target = unit_plural.target
target = [
"%s" % unit_plural.target.strings[0],
"%s changed" % unit_plural.target.strings[1]
]
response = client.post(
url,
{'target_f_0': target[0],
'target_f_1': target[1],
'is_fuzzy': "0"},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
unit = Unit.objects.get(id=unit_plural.id)
if check_permission('translate', response.wsgi_request):
assert response.status_code == 200
assert unit.target == multistring(target)
else:
assert response.status_code == 403
assert unit.target == original_target
with pytest.raises(UnitChange.DoesNotExist):
unit.change
def test_unit_lifecycle_unmute_qc(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
qc = QualityCheck(
unit=unit,
name="foo-check",
message="Check foo!",
category="Footile")
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc()
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(submitter=member)
with pytest.raises(KeyError):
unit_lifecycle.sub_unmute_qc(quality_check=qc)
sub_unmute_qc = unit_lifecycle.sub_unmute_qc(
quality_check=qc, submitter=member)
assert sub_unmute_qc.unit == unit
assert sub_unmute_qc.translation_project == store0.translation_project
assert sub_unmute_qc.revision == unit.revision
assert sub_unmute_qc.type == SubmissionTypes.WEB
assert sub_unmute_qc.field == SubmissionFields.CHECK
assert sub_unmute_qc.new_value == UNMUTED
assert sub_unmute_qc.old_value == MUTED
assert not sub_unmute_qc.pk
def test_plural_escape_message_with_newline(self):
mString = multistring(['one message\nwith newline', 'other message\nwith newline'])
xml = ('<plurals name="teststring">\n'
' <item quantity="one">one message\n\\nwith newline</item>'
'<item quantity="other">other message\n\\nwith newline</item>'
'</plurals>\n')
self.__check_escape(mString, xml, 'en')
def test_add_suggestion(client, request_users, settings):
"""Tests translation can be applied after suggestion is accepted."""
settings.POOTLE_CAPTCHA_ENABLED = False
user = request_users["user"]
if user.username != "nobody":
client.login(
username=user.username,
password=request_users["password"])
unit = Unit.objects.all().first()
url = '/xhr/units/%d/suggestions' % unit.id
target = "%s TEST SUGGESTION" % unit.source
response = client.post(
url,
{
'target_f_0': target,
},
HTTP_X_REQUESTED_WITH='XMLHttpRequest'
)
assert response.status_code == 200
changed = Unit.objects.get(id=unit.id)
suggestion = changed.get_suggestions().order_by('id').last()
assert suggestion.target == multistring(target)
with pytest.raises(UnitChange.DoesNotExist):
unit.change
def test_plural_parse_message_with_newline(self):
mString = multistring(['one message\nwith newline', 'other message\nwith newline'])
xml = ('<plurals name="Test String">\n\t'
'<item quantity="one">one message\\nwith newline</item>\n\t'
'<item quantity="other">other message\\nwith newline</item>\n\n'
'</plurals>\n\n')
self.__check_parse(mString, xml)
def handle_plurals(self, plurals):
if len(plurals) == 1:
return self.string_filter(plurals[0])
else:
return multistring(
[self.string_filter(plural) for plural in plurals]
)
def set_target(self, target):
"""Set translation unit target."""
if 'target' in self.__dict__:
del self.__dict__['target']
if isinstance(target, list):
target = multistring(target)
self.unit.target = target
def gettarget(self):
if self.hasplural():
plurals = []
nplural = 0
plural = gpo.po_message_msgstr_plural(self._gpo_message, nplural)
while plural:
plurals.append(plural.decode(self.CPO_ENC))
nplural += 1
plural = gpo.po_message_msgstr_plural(self._gpo_message, nplural)
if plurals:
multi = multistring(plurals, encoding=self.CPO_ENC)
else:
multi = multistring(u"")
else:
multi = (gpo.po_message_msgstr(self._gpo_message) or "").decode(self.CPO_ENC)
return multi
def test_plural_invalid_lang(self):
mString = multistring(['one message', 'other message'])
xml = ('<plurals name="Test String">\n\t'
'<item quantity="one">one message</item>\n\t'
'<item quantity="other">other message</item>\n'
'</plurals>\n\n')
self.__check_escape(mString, xml, 'invalid')
def clean_target_f(self):
value = self.cleaned_data["target_f"]
if self.instance.target.strings != multistring(value or [u""]):
self.instance._target_updated = True
self.updated_fields.append((SubmissionFields.TARGET, to_db(self.instance.target), to_db(value)))
return value
def _unit_post_merge_pounit(input_unit, input_store, output_store, template_store):
"""PO format specific plural string initializtion logic."""
#FIXME: do we want to do that for poxliff also?
if input_unit.hasplural() and len(input_unit.target) == 0:
# untranslated plural unit; Let's ensure that we have the correct number of plural forms:
nplurals, plural = output_store.getheaderplural()
if nplurals and nplurals.isdigit() and nplurals != '2':
input_unit.target = multistring([""]*int(nplurals))
def set_target(self, target):
"""Set translation unit target."""
if isinstance(target, list):
target = multistring(target)
self.unit.target = target
# Propagate to value so that is_translated works correctly
if self.is_unit_key_value(self.unit):
self.unit.value = self.unit.translation
def _get_source_vars(self, msgid, msgid_plural):
multi = multistring(unquotefrompo(msgid), self._encoding)
if self.hasplural():
pluralform = unquotefrompo(msgid_plural)
if isinstance(pluralform, str):
pluralform = pluralform.decode(self._encoding)
multi.strings.append(pluralform)
return multi
def clean_target_f(self):
value = self.cleaned_data['target_f']
if self.instance.target.strings != multistring(value or [u'']):
self.instance._target_updated = True
self.updated_fields.append(("pootle_store.Unit.target", to_db(self.instance.target), to_db(value)))
return value
def test_plural_reduction(self):
"""checks that reducing the number of plurals supplied works"""
unit = self.UnitClass("Tree")
unit.msgid_plural = ["Trees"]
assert isinstance(unit.source, multistring)
assert unit.source.strings == ["Tree", "Trees"]
unit.target = multistring(["Boom", "Bome", "Baie Bome"])
assert isinstance(unit.source, multistring)
assert unit.target.strings == ["Boom", "Bome", "Baie Bome"]
unit.target = multistring(["Boom", "Bome"])
assert unit.target.strings == ["Boom", "Bome"]
unit.target = "Boom"
# FIXME: currently assigning the target to the same as the first string won't change anything
# we need to verify that this is the desired behaviour...
assert unit.target.strings[0] == "Boom"
unit.target = "Een Boom"
assert unit.target.strings == ["Een Boom"]
def gettarget(self, lang=None):
if (self.xmlelement.tag == "plurals"):
target = []
for entry in self.xmlelement.iterchildren():
target.append(self.get_xml_text_value(entry))
return multistring(target)
else:
return self.get_xml_text_value(self.xmlelement)
def test_plural_invalid_lang(self):
mString = multistring(["one message", "other message"])
xml = (
'<plurals name="teststring">\n'
' <item quantity="one">one message</item>'
'<item quantity="other">other message</item>'
"</plurals>\n"
)
self.__check_escape(mString, xml, "invalid")
def rich_to_multistring(cls, elem_list):
"""Convert a "rich" string tree to a ``multistring``:
>>> from translate.storage.placeables.interfaces import X
>>> rich = [StringElem(['foo', X(id='xxx', sub=[' ']), 'bar'])]
>>> TranslationUnit.rich_to_multistring(rich)
multistring('foo bar')
"""
return multistring([str(elem) for elem in elem_list])
def test_unit_lifecycle_create(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.index = store0.max_index() + 1
unit.save()
source = unit.unit_source.get()
assert source.created_by == get_system_user()
assert source.created_with == SubmissionTypes.SYSTEM
def gettarget(self):
if self.hasplural():
strings = [unit.target for unit in self.units]
if strings:
return multistring(strings)
else:
return None
else:
return super(PoXliffUnit, self).gettarget()
def gettarget(self, lang=None):
if self.hasplural():
strings = [data.forceunicode(unit.target) for unit in self.units]
if strings:
return multistring(strings)
else:
return None
else:
return super().gettarget(lang)
def clean_target_f(self):
value = self.cleaned_data['target_f']
if self.instance.target != multistring(value or [u'']):
self._updated_fields.append(
(SubmissionFields.TARGET, to_db(self.instance.target),
to_db(value)))
return value
def test_new_plural(self):
EXPECTED = b"""{
"simple": "the singular",
"simple_plural": "the plural",
"complex_0": "the plural form 0",
"complex_1": "the plural form 1",
"complex_2": "the plural form 2",
"complex_3": "the plural form 3",
"complex_4": "the plural form 4",
"complex_5": "the plural form 5"
}
"""
store = self.StoreClass()
unit = self.StoreClass.UnitClass(
multistring(
[
"the singular",
"the plural",
]
),
"simple",
)
store.addunit(unit)
unit = self.StoreClass.UnitClass(
multistring(
[
"the plural form 0",
"the plural form 1",
"the plural form 2",
"the plural form 3",
"the plural form 4",
"the plural form 5",
]
),
"complex",
)
store.addunit(unit)
out = BytesIO()
store.serialize(out)
assert out.getvalue() == EXPECTED
def gettarget(self):
targetnode = self._gettargetnode()
if targetnode is None:
etree.SubElement(self.xmlelement, self.namespaced("translation"))
return None
if self.hasplural():
numerus_nodes = targetnode.findall(self.namespaced("numerusform"))
return multistring([node.text or u"" for node in numerus_nodes])
else:
return data.forceunicode(targetnode.text) or u""
def test_unit_lifecycle_update_state(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.state = TRANSLATED
unit.reviewed_by = member
unit.save(user=member)
sub_state_update = lifecycle.get(Unit)(unit).sub_state_update()
assert isinstance(sub_state_update, Submission)
assert sub_state_update.unit == unit
assert sub_state_update.translation_project == store0.translation_project
assert sub_state_update.revision == unit.revision
assert (sub_state_update.submitter == unit.change.submitted_by == member)
assert sub_state_update.type == SubmissionTypes.SYSTEM
assert sub_state_update.field == SubmissionFields.STATE
assert sub_state_update.new_value == unit.state
assert sub_state_update.old_value == unit._frozen.state
assert not sub_state_update.pk
def create_unit(self, key: str, source: Union[str, List[str]]):
if isinstance(source, list):
unit = self.construct_unit(source[0])
source = multistring(source)
else:
unit = self.construct_unit(source)
unit.setid(key)
unit.source = self.create_unit_key(key, source)
unit.target = source
return unit
def convertstrings(self, input):
if isinstance(input, multistring):
strings = input.strings
elif isinstance(input, list):
strings = input
else:
return self.convertstring(input)
for index, string in enumerate(strings):
strings[index] = re.sub(r'%(\d)\$s', lambda x: "{%d}" % (int(x.group(1)) - 1), string)
return multistring(strings)
def add_unit(self, unit):
if unit.is_plural():
output = self.storage.UnitClass(
multistring(unit.get_source_plurals()))
output.target = multistring(unit.get_target_plurals())
else:
output = self.storage.UnitClass(unit.source)
output.target = unit.target
output.context = unit.context
for location in unit.location.split():
if location:
output.addlocation(location)
output.addnote(unit.comment)
if hasattr(output, 'settypecomment'):
for flag in unit.flags.split(','):
output.settypecomment(flag)
if unit.fuzzy:
output.markfuzzy(True)
self.storage.addunit(output)
def update_unit_target(self, unit_data, updated_text):
if unit_data.unit.hasplural():
plurals = unit_data.unit.gettarget().strings
if (unit_data.plural < len(plurals)):
plurals[unit_data.plural] = updated_text
else:
plurals.append(updated_text)
unit_data.unit.settarget(multistring(plurals))
else:
unit_data.unit.settarget(updated_text)
def _parse_dict(self, data, prev):
# Does this look like a plural?
if data and all(x in cldr_plural_categories for x in data.keys()):
# Ensure we have correct plurals ordering.
values = [data[item] for item in cldr_plural_categories if item in data]
yield (prev, multistring(values))
return
# Handle normal dict
yield from super()._parse_dict(data, prev)
def test_unit_lifecycle_instance(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
unit_lifecycle = lifecycle.get(Unit)(unit)
assert isinstance(unit_lifecycle, UnitLifecycle)
assert unit_lifecycle.original == unit._frozen
assert unit_lifecycle.unit == unit
assert unit_lifecycle.submission_model == unit.submission_set.model
def test_plurals(self):
store = self.StoreClass()
store.parse(JSON_GOI18N)
assert len(store.units) == 2
assert store.units[0].target == multistring(
["{{.count}} tag", "{{.count}} tags"])
assert store.units[1].target == "Table"
assert bytes(store).decode() == JSON_GOI18N.decode()
def test_unit_lifecycle_create(store0):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.save()
source = unit.unit_source.get()
assert source.created_by == get_system_user()
assert source.created_with == SubmissionTypes.SYSTEM
with pytest.raises(UnitChange.DoesNotExist):
unit.change
def source(self, source):
self._rich_source = None
source = data.forceunicode(source or u"")
source = source or u""
if isinstance(source, multistring):
self._source = source
elif isinstance(source, six.text_type):
self._source = source
else: # If it is unicode, list or dict.
self._source = multistring(source)
def _unit_post_merge_pounit(input_unit, input_store, output_store,
template_store):
"""PO format specific plural string initializtion logic."""
#FIXME: do we want to do that for poxliff also?
if input_unit.hasplural() and len(input_unit.target) == 0:
# untranslated plural unit; Let's ensure that we have the correct
# number of plural forms:
nplurals, plural = output_store.getheaderplural()
if nplurals and nplurals.isdigit() and nplurals != '2':
input_unit.target = multistring([""] * int(nplurals))
def test_unit_lifecycle_update_comment(store0, member):
unit = store0.UnitClass()
unit.store = store0
unit.source_f = multistring("Foo")
unit.target_f = multistring("Bar")
unit.translator_comment = "SOME COMMENT"
unit.save(user=member)
sub_comment_update = lifecycle.get(Unit)(unit).sub_comment_update()
assert isinstance(sub_comment_update, Submission)
assert sub_comment_update.unit == unit
assert sub_comment_update.translation_project == store0.translation_project
assert sub_comment_update.revision == unit.revision
assert sub_comment_update.submitter == member
assert sub_comment_update.type == SubmissionTypes.SYSTEM
assert sub_comment_update.field == SubmissionFields.COMMENT
assert sub_comment_update.new_value == unit.translator_comment
assert sub_comment_update.old_value == (unit._frozen.translator_comment
or "")
assert not sub_comment_update.pk
def to_python(self, value):
if not value:
return multistring("", encoding="UTF-8")
elif isinstance(value, multistring):
return value
elif isinstance(value, basestring):
strings = value.split(SEPERATOR)
if strings[-1] == PLURAL_PLACEHOLDER:
strings = strings[:-1]
plural = True
else:
plural = len(strings) > 1
ms = multistring(strings, encoding="UTF-8")
ms.plural = plural
return ms
elif isinstance(value, dict):
return multistring([val for key, val in sorted(value.items())],
encoding="UTF-8")
else:
return multistring(value, encoding="UTF-8")
def test_plural_parse_message_with_newline(self):
mString = multistring(
["one message\nwith newline", "other message\nwith newline"]
)
xml = (
'<plurals name="teststring">\n'
' <item quantity="one">one message\\nwith newline</item>\n'
' <item quantity="other">other message\\nwith newline</item>\n'
"</plurals>\n"
)
self.__check_parse(mString, xml)
def test_plurals(self):
phpsource = r"""<?php
return [
'welcome' => 'Welcome to our application',
'apples' => 'There is one apple|There are many apples',
];
"""
phpfile = self.phpparse(phpsource)
assert len(phpfile.units) == 2
phpunit = phpfile.units[0]
assert phpunit.name == "return[]->'welcome'"
assert phpunit.source == "Welcome to our application"
phpunit = phpfile.units[1]
assert phpunit.name == "return[]->'apples'"
assert phpunit.source == multistring(
["There is one apple", "There are many apples"]
)
assert bytes(phpfile).decode() == phpsource
phpunit.source = multistring(["There is an apple", "There are many apples"])
assert bytes(phpfile).decode() == phpsource.replace("one apple", "an apple")
def fix_errata(self, terms):
replaced = False
newstrings = []
for string in self.target_strings:
newstring = self.replace(string, terms)
if string != newstring:
string = newstring
replaced = True
newstrings.append(string)
if replaced:
self.settarget(multistring(newstrings))
def test_plural_parse_message_with_comments(self):
mString = multistring(["one message", "other message"])
xml = (
'<plurals name="teststring">\n'
" <!-- comment of one string -->\n"
' <item quantity="one">one message</item>\n'
" <!-- comment of other string -->\n"
' <item quantity="other">other message</item>\n'
"</plurals>\n"
)
self.__check_parse(mString, xml)
def to_python(value):
"""Reconstruct a multistring from the database string representation."""
if not value:
return multistring("", encoding="UTF-8")
elif isinstance(value, multistring):
return value
elif isinstance(value, basestring):
strings = value.split(SEPARATOR)
if strings[-1] == PLURAL_PLACEHOLDER:
strings = strings[:-1]
plural = True
else:
plural = len(strings) > 1
ms = multistring(strings, encoding="UTF-8")
ms.plural = plural
return ms
elif isinstance(value, dict):
return multistring([val for key, val in sorted(value.items())], encoding="UTF-8")
else:
return multistring(value, encoding="UTF-8")
def setsource(self, source):
self._rich_source = None
# assert isinstance(source, unicode)
source = data.forceunicode(source or u"")
source = source or u""
if isinstance(source, multistring):
self._source = source
elif isinstance(source, unicode):
self._source = source
else:
#unicode, list, dict
self._source = multistring(source)
def test_increase(self):
"""checks that if the target language has more plural form the generated properties file is correct """
propsource = 'test_me=I can code!\ntest_me[one]=I can code single!'
propfile = self.propparse(propsource, "gwt", None, "en",
"ar") # All plural forms
assert len(propfile.units) == 1
propunit = propfile.units[0]
assert isinstance(propunit.target, multistring)
assert propunit.target.strings == ['', '', '', '', '', '']
assert b'test_me=I can code!\ntest_me[none]=\ntest_me[one]=I can code single!\n' + \
b'test_me[two]=\ntest_me[few]=\ntest_me[many]=\n' == propfile.__bytes__()
propunit.target = {
'other': 'other',
'one': 'one',
'zero': 'zero',
'few': 'few',
'two': 'two',
'many': 'many'
}
assert isinstance(propunit.target, multistring)
assert propunit.target.strings == [
'zero', 'one', 'two', 'few', 'many', 'other'
]
assert b'test_me=other\ntest_me[none]=zero\ntest_me[one]=one\n' + \
b'test_me[two]=two\ntest_me[few]=few\ntest_me[many]=many\n' == propfile.__bytes__()
propunit.target = multistring(
['zero', 'one', 'two', 'few', 'many', 'other'])
assert isinstance(propunit.target, multistring)
assert propunit.target.strings == [
'zero', 'one', 'two', 'few', 'many', 'other'
]
assert b'test_me=other\ntest_me[none]=zero\ntest_me[one]=one\n' + \
b'test_me[two]=two\ntest_me[few]=few\ntest_me[many]=many\n' == propfile.__bytes__()
propunit.target = ['zero', 'one', 'two', 'few', 'many', 'other']
assert isinstance(propunit.target, multistring)
assert propunit.target.strings == [
'zero', 'one', 'two', 'few', 'many', 'other'
]
assert b'test_me=other\ntest_me[none]=zero\ntest_me[one]=one\n' + \
b'test_me[two]=two\ntest_me[few]=few\ntest_me[many]=many\n' == propfile.__bytes__()
propunit.source = ['zero', 'one', 'two', 'few', 'many', 'other']
assert isinstance(propunit.target, multistring)
assert propunit.target.strings == [
'zero', 'one', 'two', 'few', 'many', 'other'
]
assert b'test_me=other\ntest_me[none]=zero\ntest_me[one]=one\n' + \
b'test_me[two]=two\ntest_me[few]=few\ntest_me[many]=many\n' == propfile.__bytes__()
def save_unit(self):
user = self.request_user
target = multistring(self.cleaned_data["target_f"] or [u''])
if target != self.unit.target:
self.unit.target = self.cleaned_data["target_f"]
if self.unit.target:
if self.cleaned_data["is_fuzzy"]:
self.unit.state = FUZZY
else:
self.unit.state = TRANSLATED
else:
self.unit.state = UNTRANSLATED
self.unit.save(user=user, changed_with=SubmissionTypes.WEB)
def test_rich_get(self):
"""Basic test for converting from multistrings to StringElem trees."""
target_mstr = multistring([u'tėst', u'<b>string</b>'])
unit = self.UnitClass(multistring([u'a', u'b']))
unit.rich_parsers = general.parsers
unit.target = target_mstr
elems = unit.rich_target
if unit.hasplural():
assert len(elems) == 2
assert len(elems[0].sub) == 1
assert len(elems[1].sub) == 3
assert unicode(elems[0]) == target_mstr.strings[0]
assert unicode(elems[1]) == target_mstr.strings[1]
assert unicode(elems[1].sub[0]) == u'<b>'
assert unicode(elems[1].sub[1]) == u'string'
assert unicode(elems[1].sub[2]) == u'</b>'
else:
assert len(elems[0].sub) == 1
assert unicode(elems[0]) == target_mstr.strings[0]