~launchpad-pqm/launchpad/devel

Translation message helper functions

====================================

For rendering translations in the TranslationMessageView a number of

helper functions exist. The following sections cover them in detail.

contract_rosetta_escapes

------------------------

    >>> from lp.translations.browser.browser_helpers import (

    ...     contract_rosetta_escapes)

Normal strings get passed through unmodified.

    >>> contract_rosetta_escapes('foo')

    'foo'

    >>> contract_rosetta_escapes('foo\\nbar')

    'foo\\nbar'

The string '[tab]' gets converted to a tab character.

    >>> contract_rosetta_escapes('foo[tab]bar')

    'foo\tbar'

The string '\[tab]' gets converted to a literal '[tab]'.

    >>> contract_rosetta_escapes('foo\\[tab]bar')

    'foo[tab]bar'

The string '\\[tab]' gets converted to a literal '\[tab]'.

    >>> contract_rosetta_escapes('foo\\\\[tab]bar')

    'foo\\[tab]bar'

And so on...

    >>> contract_rosetta_escapes('foo\\\\\\[tab]bar')

    'foo\\\\[tab]bar'

Similarly, string '[nbsp]' gets converted to no-break space character.

    >>> contract_rosetta_escapes('foo[nbsp]bar')

    u'foo\xa0bar'

The string '\[nbsp]' gets converted to a literal '[nbsp]'.

    >>> contract_rosetta_escapes('foo\\[nbsp]bar')

    'foo[nbsp]bar'

Similarly, string '[nnbsp]' gets converted to narrow no-break space

character.

    >>> contract_rosetta_escapes('foo[nnbsp]bar')

    u'foo\u202fbar'

The string '\[nnbsp]' gets converted to a literal '[nnbsp]'.

    >>> contract_rosetta_escapes('foo\\[nnbsp]bar')

    'foo[nnbsp]bar'

expand_rosetta_escapes

----------------------

    >>> from lp.translations.browser.browser_helpers import (

    ...     expand_rosetta_escapes)

Normal strings get passed through unmodified.

    >>> expand_rosetta_escapes(u'foo')

    u'foo'

    >>> expand_rosetta_escapes(u'foo\\nbar')

    u'foo\\nbar'

Tabs get converted to a special constant TranslationConstants.TAB_CHAR

which renders as below:

    >>> expand_rosetta_escapes(u'foo\tbar')

    u'foo<code>[tab]</code>bar'

Literal occurrences of u'[tab]' get escaped to a special constant

TranslationConstants.TAB_CHAR_ESCAPED which renders them as below:

    >>> expand_rosetta_escapes(u'foo[tab]bar')

    u'foo<code>\\[tab]</code>bar'

Escaped ocurrences themselves get escaped.

    >>> expand_rosetta_escapes(u'foo\\[tab]bar')

    u'foo\\<code>\\[tab]</code>bar'

And so on...

    >>> expand_rosetta_escapes(u'foo\\\\[tab]bar')

    u'foo\\\\<code>\\[tab]</code>bar'

Similarly, no-break spaces get converted to a special constant

TranslationConstants.NO_BREAK_SPACE_CHAR which renders as below:

    >>> expand_rosetta_escapes(u'foo\u00a0bar')

    u'foo<code>[nbsp]</code>bar'

Literal occurrences of u'[nbsp]' get escaped to a special constant

TranslationConstants.NO_BREAK_SPACE_CHAR_ESCAPED which renders them

as below:

    >>> expand_rosetta_escapes(u'foo[nbsp]bar')

    u'foo<code>\\[nbsp]</code>bar'

Similarly, narrow no-break spaces get converted to a special constant

TranslationConstants.NARROW_NO_BREAK_SPACE_CHAR which renders as below:

    >>> expand_rosetta_escapes(u'foo\u202fbar')

    u'foo<code>[nnbsp]</code>bar'

Literal occurrences of u'[nnbsp]' get escaped to a special constant

TranslationConstants.NARROW_NO_BREAK_SPACE_CHAR_ESCAPED which renders them

as below:

    >>> expand_rosetta_escapes(u'foo[nnbsp]bar')

    u'foo<code>\\[nnbsp]</code>bar'

parse_cformat_string

--------------------

    >>> from lp.translations.browser.browser_helpers import (

    ...     parse_cformat_string)

    >>> parse_cformat_string('')

    []

    >>> parse_cformat_string('foo')

    [('string', 'foo')]

    >>> parse_cformat_string('blah %d blah')

    [('string', 'blah '), ('interpolation', '%d'), ('string', ' blah')]

    >>> parse_cformat_string('%sfoo%%bar%s')

    [('interpolation', '%s'), ('string', 'foo%%bar'), ('interpolation', '%s')]

    >>> parse_cformat_string('%')

    Traceback (most recent call last):

    ...

    UnrecognisedCFormatString: %

text_to_html

------------

    >>> from lp.translations.browser.browser_helpers import (

    ...     text_to_html)

First, do no harm.

    >>> text_to_html(u'foo bar', [], '<sp>')

    u'foo bar'

Test replacement of leading and trailing spaces.

    >>> text_to_html(u' foo bar', [], '<sp>')

    u'<sp>foo bar'

    >>> text_to_html(u'foo bar ', [], '<sp>')

    u'foo bar<sp>'

    >>> text_to_html(u'  foo bar  ', [], '<sp>')

    u'<sp><sp>foo bar<sp><sp>'

Test replacement of newlines.

    >>> text_to_html(u'foo\nbar', [], newline='<cr>')

    u'foo<cr>bar'

And both together.

    >>> text_to_html(u'foo \nbar', [], '<sp>', '<cr>')

    u'foo<sp><cr>bar'

Test treatment of tabs.

    >>> text_to_html(u'foo\tbar', [])

    u'foo<code>[tab]</code>bar'

Test valid C format strings are formatted.

    >>> text_to_html(u'foo %d bar', ['c-format'])

    u'foo <code>%d</code> bar'

If we get None, we return None.

    >>> text_to_html(None, []) is None

    True

Test bad format strings are caught and passed through.

    >>> text = u'foo %z bar'

    >>> parse_cformat_string(text)

    Traceback (most recent call last):

    ...

    UnrecognisedCFormatString: foo %z bar

    >>> text_to_html(text, ['c-format']) == text

    True

If we get '\r\n' as the new line mark, we should remove '\r':

    >>> text_to_html(u'foo\r\nbar', [])

    u'foo<img alt="" src="/@@/translation-newline" /><br/>\nbar'

And '\r' should be also handled:

    >>> text_to_html(u'foo\rbar', [])

    u'foo<img alt="" src="/@@/translation-newline" /><br/>\nbar'

convert_newlines_to_web_form

----------------------------

    >>> from lp.translations.browser.browser_helpers import (

    ...     convert_newlines_to_web_form)

    >>> convert_newlines_to_web_form(u'foo')

    u'foo'

    >>> convert_newlines_to_web_form(u'foo\n')

    u'foo\r\n'

    >>> convert_newlines_to_web_form(u'foo\nbar\n\nbaz')

    u'foo\r\nbar\r\n\r\nbaz'

    >>> convert_newlines_to_web_form(u'foo\r\nbar')

    u'foo\r\nbar'

    >>> convert_newlines_to_web_form(u'foo\rbar')

    u'foo\r\nbar'

count_lines

-----------

    >>> from lp.translations.browser.browser_helpers import count_lines

    >>> count_lines("foo")

    1

    >>> count_lines(

    ...     "123456789abc123456789abc123456789abc1234566789abc123456789abc")

    2

    >>> count_lines(

    ...     "123456789a123456789a123456789a1234566789a123456789")

    1

    >>> count_lines("a\nb")

    2

    >>> count_lines("a\nb\n")

    3

    >>> count_lines("a\nb\nc")

    3

    >>> count_lines(

    ...     "123456789abc123456789abc123456789abc123456789abc\n"

    ...     "1234566789a123456789a")

    2

    >>> count_lines(

    ...     "123456789abc123456789abc123456789abc123456789abc123456789abc"

    ...     "123456\n789a123456789a123456789a")

    3

    >>> count_lines(

    ...     "123456789abc123456789abc123456789abc123456789abc123456789abc"

    ...     "123456789abc\n1234566789a123456789a123456789a")

    3

    >>> count_lines("foo bar\n")

    2