def test_emailfield(self):
page = make_test_page(test_emailfield="*****@*****.**")
segments = extract_segments(page)
self.assertEqual(
segments, [StringSegmentValue("test_emailfield", "*****@*****.**")]
)
def test_urlfield(self):
page = make_test_page(test_urlfield="http://test-content.com/foo")
segments = extract_segments(page)
self.assertEqual(
segments,
[SegmentValue("test_urlfield", "http://test-content.com/foo")])
def ingest_messages(self, instance):
if instance.translation_key in self.seen_objects:
return
self.seen_objects.add(instance.translation_key)
segments = extract_segments(instance)
# Ingest segments for dependencies first
for segment in segments:
if isinstance(segment, RelatedObjectValue):
self.ingest_messages(segment.get_instance(self.source_locale))
text_segments = [
segment for segment in segments
if isinstance(segment, SegmentValue)
]
# Initialise translated segments by copying templates and related objects
translated_segments = [
segment for segment in segments
if isinstance(segment, (TemplateValue, RelatedObjectValue))
]
missing_segments = 0
for segment in text_segments:
if segment.text in self.translations:
translated_segments.append(
SegmentValue(
segment.path,
self.translations[segment.text],
order=segment.order,
))
else:
missing_segments += 1
if missing_segments:
raise MissingSegmentsException(instance, missing_segments)
translated_segments.sort(key=lambda segment: segment.order)
try:
translation = instance.get_translation(self.target_locale)
except instance.__class__.DoesNotExist:
translation = instance.copy_for_translation(self.target_locale)
ingest_segments(
instance,
translation,
self.source_locale,
self.target_locale,
translated_segments,
)
if isinstance(translation, Page):
translation.slug = slugify(translation.slug)
revision = translation.save_revision()
else:
translation.save()
return translation
def test_snippet(self):
test_snippet = TestSnippet.objects.create(field="Test content")
page = make_test_page(test_snippet=test_snippet)
segments = extract_segments(page)
self.assertEqual(
segments,
[RelatedObjectValue.from_instance("test_snippet", test_snippet)])
def test_richtextfield(self):
page = make_test_page(test_richtextfield=RICH_TEXT_TEST_INPUT)
segments = extract_segments(page)
self.assertEqual(
segments,
[segment.wrap("test_richtextfield") for segment in RICH_TEXT_TEST_OUTPUT],
)
def test_customfield(self):
page = make_test_page(test_customfield="Test content")
segments = extract_segments(page)
self.assertEqual(
segments,
[StringSegmentValue("test_customfield.foo", "Test content and some extra")],
)
def test_nonparentalchildobjects(self):
page = make_test_page()
page.save()
TestNonParentalChildObject.objects.create(page=page, field="Test content")
segments = extract_segments(page)
# No segments this time as we don't extract ManyToOneRel's that don't use ParentalKeys
self.assertEqual(segments, [])
def test_emailblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(str(block_id),
"test_emailblock",
"*****@*****.**")
segments = extract_segments(page)
self.assertEqual(
segments,
[SegmentValue(f"test_streamfield.{block_id}", "*****@*****.**")])
def test_blockquoteblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(str(block_id),
"test_blockquoteblock",
"Test content")
segments = extract_segments(page)
self.assertEqual(
segments,
[SegmentValue(f"test_streamfield.{block_id}", "Test content")])
def extract_messages(self, instance):
if instance.translation_key in self.seen_objects:
return
self.seen_objects.add(instance.translation_key)
for segment in extract_segments(instance):
if isinstance(segment, SegmentValue):
self.messages[segment.text].append(
(self.get_path(instance), segment.path))
elif isinstance(segment, RelatedObjectValue):
self.extract_messages(segment.get_instance(self.locale))
def prepare_source(source):
# Extract segments from source and save them into translation memory
segments = extract_segments(source.as_instance())
insert_segments(source, source.locale_id, segments)
# Recurse into any related objects
for segment in segments:
if not isinstance(segment, RelatedObjectSegmentValue):
continue
related_source, created = TranslationSource.from_instance(
segment.get_instance(source.locale))
prepare_source(related_source)
def prepare_revision(revision):
# Extract segments from revision and save them into translation memory
segments = extract_segments(revision.as_instance())
insert_segments(revision, revision.locale_id, segments)
# Recurse into any related objects
for segment in segments:
if not isinstance(segment, RelatedObjectValue):
continue
related_revision, created = TranslatableRevision.from_instance(
segment.get_instance(revision.locale))
prepare_revision(related_revision)
def test_urlblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(
str(block_id), "test_urlblock", "http://test-content.com/foo")
segments = extract_segments(page)
self.assertEqual(
segments,
[
SegmentValue(f"test_streamfield.{block_id}",
"http://test-content.com/foo")
],
)
def test_listblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(
str(block_id), "test_listblock", ["Test content", "Some more test content"]
)
segments = extract_segments(page)
self.assertEqual(
segments,
[
StringSegmentValue(f"test_streamfield.{block_id}", "Test content"),
StringSegmentValue(f"test_streamfield.{block_id}", "Some more test content"),
],
)
def test_rawhtmlblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(str(block_id),
"test_rawhtmlblock",
RICH_TEXT_TEST_INPUT)
segments = extract_segments(page)
self.assertEqual(
segments,
[
segment.wrap(f"test_streamfield.{block_id}")
for segment in RICH_TEXT_TEST_OUTPUT
],
)
def test_childobjects(self):
page = make_test_page()
page.test_childobjects.add(TestChildObject(field="Test content"))
page.save()
child_translation_key = TestChildObject.objects.get().translation_key
segments = extract_segments(page)
self.assertEqual(
segments,
[
SegmentValue(
f"test_childobjects.{child_translation_key}.field",
"Test content")
],
)
def test_nestedstreamblock(self):
block_id = uuid.uuid4()
nested_block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(
str(block_id),
"test_nestedstreamblock",
[{"id": str(nested_block_id), "type": "block_a", "value": "Test content"}],
)
segments = extract_segments(page)
self.assertEqual(
segments,
[
StringSegmentValue(
f"test_streamfield.{block_id}.{nested_block_id}", "Test content"
)
],
)
def test_customstructblock(self):
block_id = uuid.uuid4()
page = make_test_page_with_streamfield_block(
str(block_id),
"test_customstructblock",
{"field_a": "Test content", "field_b": "Some more test content"},
)
segments = extract_segments(page)
self.assertEqual(
segments,
[
StringSegmentValue(
f"test_streamfield.{block_id}.foo",
"Test content / Some more test content",
)
],
)
def test_slugfield(self):
page = make_test_page(test_slugfield="test-content")
segments = extract_segments(page)
self.assertEqual(segments,
[SegmentValue("test_slugfield", "test-content")])
def test_textfield(self):
page = make_test_page(test_textfield="Test content")
segments = extract_segments(page)
self.assertEqual(segments, [StringSegmentValue("test_textfield", "Test content")])
