available as a global component.
58 | Vue.component('translate', Component)
59 |
60 | // An option to support translation with HTML content: `v-translate`.
61 | Vue.directive('translate', Directive)
62 |
63 | // Exposes global properties.
64 | Vue.$translations = options.translations
65 | // Exposes instance methods.
66 | Vue.prototype.$gettext = translate.gettext.bind(translate)
67 | Vue.prototype.$pgettext = translate.pgettext.bind(translate)
68 | Vue.prototype.$ngettext = translate.ngettext.bind(translate)
69 | Vue.prototype.$npgettext = translate.npgettext.bind(translate)
70 | Vue.prototype.$gettextInterpolate = interpolate.bind(interpolate)
71 |
72 | }
73 |
74 | export default GetTextPlugin
75 | export {translate}
76 |
--------------------------------------------------------------------------------
/src/interpolate.js:
--------------------------------------------------------------------------------
1 | import { _Vue } from './localVue'
2 |
3 | const EVALUATION_RE = /[[\].]{1,2}/g
4 |
5 | /* Interpolation RegExp.
6 | *
7 | * Because interpolation inside attributes are deprecated in Vue 2 we have to
8 | * use another set of delimiters to be able to use `translate-plural` etc.
9 | * We use %{ } delimiters.
10 | *
11 | * /
12 | * %\{ => Starting delimiter: `%{`
13 | * ( => Start capture
14 | * (?:.|\n) => Non-capturing group: any character or newline
15 | * +? => One or more times (ungreedy)
16 | * ) => End capture
17 | * \} => Ending delimiter: `}`
18 | * /g => Global: don't return after first match
19 | */
20 | const INTERPOLATION_RE = /%\{((?:.|\n)+?)\}/g
21 |
22 | const MUSTACHE_SYNTAX_RE = /\{\{((?:.|\n)+?)\}\}/g
23 |
24 | /**
25 | * Evaluate a piece of template string containing %{ } placeholders.
26 | * E.g.: 'Hi %{ user.name }' => 'Hi Bob'
27 | *
28 | * This is a vm.$interpolate alternative for Vue 2.
29 | * https://vuejs.org/v2/guide/migration.html#vm-interpolate-removed
30 | *
31 | * @param {String} msgid - The translation key containing %{ } placeholders
32 | * @param {Object} context - An object whose elements are put in their corresponding placeholders
33 | *
34 | * @return {String} The interpolated string
35 | */
36 | let interpolate = function (msgid, context = {}, disableHtmlEscaping = false) {
37 |
38 | if (_Vue && !_Vue.config.getTextPluginSilent && MUSTACHE_SYNTAX_RE.test(msgid)) {
39 | console.warn(`Mustache syntax cannot be used with vue-gettext. Please use "%{}" instead of "{{}}" in: ${msgid}`)
40 | }
41 |
42 | let result = msgid.replace(INTERPOLATION_RE, (match, token) => {
43 |
44 | const expression = token.trim()
45 | let evaluated
46 |
47 | let escapeHtmlMap = {
48 | '&': '&',
49 | '<': '<',
50 | '>': '>',
51 | '"': '"',
52 | '\'': ''',
53 | }
54 |
55 | // Avoid eval() by splitting `expression` and looping through its different properties if any, see #55.
56 | function getProps (obj, expression) {
57 | const arr = expression.split(EVALUATION_RE).filter(x => x)
58 | while (arr.length) {
59 | obj = obj[arr.shift()]
60 | }
61 | return obj
62 | }
63 |
64 | function evalInContext (expression) {
65 | try {
66 | evaluated = getProps(this, expression)
67 | } catch (e) {
68 | // Ignore errors, because this function may be called recursively later.
69 | }
70 | if (evaluated === undefined) {
71 | if (this.$parent) {
72 | // Recursively climb the $parent chain to allow evaluation inside nested components, see #23 and #24.
73 | return evalInContext.call(this.$parent, expression)
74 | } else {
75 | console.warn(`Cannot evaluate expression: ${expression}`)
76 | evaluated = expression
77 | }
78 | }
79 | let result = evaluated.toString()
80 | if (disableHtmlEscaping) {
81 | // Do not escape HTML, see #78.
82 | return result
83 | }
84 | // Escape HTML, see #78.
85 | return result.replace(/[&<>"']/g, function (m) { return escapeHtmlMap[m] })
86 | }
87 |
88 | return evalInContext.call(context, expression)
89 |
90 | })
91 |
92 | return result
93 |
94 | }
95 |
96 | // Store this values as function attributes for easy access elsewhere to bypass a Rollup
97 | // weak point with `export`:
98 | // https://github.com/rollup/rollup/blob/fca14d/src/utils/getExportMode.js#L27
99 | interpolate.INTERPOLATION_RE = INTERPOLATION_RE
100 | interpolate.INTERPOLATION_PREFIX = '%{'
101 |
102 | export default interpolate
103 |
--------------------------------------------------------------------------------
/src/localVue.js:
--------------------------------------------------------------------------------
1 | // Ensure to always use the same Vue instance throughout the plugin.
2 | //
3 | // This was previously done in `index.js` using both named and default exports.
4 | // However, this currently must be kept in a separate file because we are using
5 | // Rollup to build the dist files and it has a drawback when using named and
6 | // default exports together, see:
7 | // https://github.com/rollup/rollup/blob/fca14d/src/utils/getExportMode.js#L27
8 | // https://github.com/rollup/rollup/wiki/JavaScript-API#exports
9 | //
10 | // If we had kept named and default exports in `index.js`, a user would have to
11 | // do something like this to access the default export: GetTextPlugin['default']
12 |
13 | export let _Vue
14 |
15 | export function shareVueInstance (Vue) {
16 | _Vue = Vue
17 | }
18 |
--------------------------------------------------------------------------------
/src/looseEqual.js:
--------------------------------------------------------------------------------
1 | // Check if two values are loosely equal - that is,
2 | // if they are plain objects, do they have the same shape?
3 | // https://github.com/vuejs/vue/blob/v2.6.11/src/shared/util.js#L285
4 |
5 | export default function looseEqual (a, b) {
6 | if (a === b) return true
7 | const isObjectA = a !== null && typeof a === 'object'
8 | const isObjectB = b !== null && typeof b === 'object'
9 | if (isObjectA && isObjectB) {
10 | try {
11 | const isArrayA = Array.isArray(a)
12 | const isArrayB = Array.isArray(b)
13 | if (isArrayA && isArrayB) {
14 | return a.length === b.length && a.every((e, i) => {
15 | return looseEqual(e, b[i])
16 | })
17 | } else if (a instanceof Date && b instanceof Date) {
18 | return a.getTime() === b.getTime()
19 | } else if (!isArrayA && !isArrayB) {
20 | const keysA = Object.keys(a)
21 | const keysB = Object.keys(b)
22 | return keysA.length === keysB.length && keysA.every(key => {
23 | return looseEqual(a[key], b[key])
24 | })
25 | } else {
26 | return false
27 | }
28 | } catch (e) {
29 | return false
30 | }
31 | } else if (!isObjectA && !isObjectB) {
32 | return String(a) === String(b)
33 | } else {
34 | return false
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/src/object-assign-polyfill.js:
--------------------------------------------------------------------------------
1 | // Polyfill Object.assign for legacy browsers.
2 | // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
3 |
4 | if (typeof Object.assign !== 'function') {
5 | (function () {
6 | Object.assign = function (target) {
7 | 'use strict'
8 | var output
9 | var index
10 | var source
11 | var nextKey
12 | if (target === undefined || target === null) {
13 | throw new TypeError('Cannot convert undefined or null to object')
14 | }
15 | output = Object(target)
16 | for (index = 1; index < arguments.length; index++) {
17 | source = arguments[index]
18 | if (source !== undefined && source !== null) {
19 | for (nextKey in source) {
20 | if (source.hasOwnProperty(nextKey)) {
21 | output[nextKey] = source[nextKey]
22 | }
23 | }
24 | }
25 | }
26 | return output
27 | }
28 | }())
29 | }
30 |
--------------------------------------------------------------------------------
/src/override.js:
--------------------------------------------------------------------------------
1 | export default function (Vue, languageVm) {
2 |
3 | // Override the main init sequence. This is called for every instance.
4 | const init = Vue.prototype._init
5 | Vue.prototype._init = function (options = {}) {
6 | const root = options._parent || options.parent || this
7 | // Expose languageVm to every instance.
8 | this.$language = root.$language || languageVm
9 | init.call(this, options)
10 | }
11 |
12 | // Override the main destroy sequence to destroy all languageVm watchers.
13 | const destroy = Vue.prototype._destroy
14 | Vue.prototype._destroy = function () {
15 | this.$language = null
16 | destroy.apply(this, arguments)
17 | }
18 |
19 | }
20 |
--------------------------------------------------------------------------------
/src/plurals.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Plural Forms
3 | *
4 | * This is a list of the plural forms, as used by Gettext PO, that are appropriate to each language.
5 | * http://docs.translatehouse.org/projects/localization-guide/en/latest/l10n/pluralforms.html
6 | *
7 | * This is a replica of angular-gettext's plural.js
8 | * https://github.com/rubenv/angular-gettext/blob/master/src/plural.js
9 | */
10 | export default {
11 |
12 | getTranslationIndex: function (languageCode, n) {
13 |
14 | n = Number(n)
15 | n = typeof n === 'number' && isNaN(n) ? 1 : n // Fallback to singular.
16 |
17 | // Extract the ISO 639 language code. The ISO 639 standard defines
18 | // two-letter codes for many languages, and three-letter codes for
19 | // more rarely used languages.
20 | // https://www.gnu.org/software/gettext/manual/html_node/Language-Codes.html#Language-Codes
21 | if (languageCode.length > 2 && languageCode !== 'pt_BR') {
22 | languageCode = languageCode.split('_')[0]
23 | }
24 |
25 | switch (languageCode) {
26 | case 'ay': // Aymará
27 | case 'bo': // Tibetan
28 | case 'cgg': // Chiga
29 | case 'dz': // Dzongkha
30 | case 'fa': // Persian
31 | case 'id': // Indonesian
32 | case 'ja': // Japanese
33 | case 'jbo': // Lojban
34 | case 'ka': // Georgian
35 | case 'kk': // Kazakh
36 | case 'km': // Khmer
37 | case 'ko': // Korean
38 | case 'ky': // Kyrgyz
39 | case 'lo': // Lao
40 | case 'ms': // Malay
41 | case 'my': // Burmese
42 | case 'sah': // Yakut
43 | case 'su': // Sundanese
44 | case 'th': // Thai
45 | case 'tt': // Tatar
46 | case 'ug': // Uyghur
47 | case 'vi': // Vietnamese
48 | case 'wo': // Wolof
49 | case 'zh': // Chinese
50 | // 1 form
51 | return 0
52 | case 'is': // Icelandic
53 | // 2 forms
54 | return (n % 10 !== 1 || n % 100 === 11) ? 1 : 0
55 | case 'jv': // Javanese
56 | // 2 forms
57 | return n !== 0 ? 1 : 0
58 | case 'mk': // Macedonian
59 | // 2 forms
60 | return n === 1 || n % 10 === 1 ? 0 : 1
61 | case 'ach': // Acholi
62 | case 'ak': // Akan
63 | case 'am': // Amharic
64 | case 'arn': // Mapudungun
65 | case 'br': // Breton
66 | case 'fil': // Filipino
67 | case 'fr': // French
68 | case 'gun': // Gun
69 | case 'ln': // Lingala
70 | case 'mfe': // Mauritian Creole
71 | case 'mg': // Malagasy
72 | case 'mi': // Maori
73 | case 'oc': // Occitan
74 | case 'pt_BR': // Brazilian Portuguese
75 | case 'tg': // Tajik
76 | case 'ti': // Tigrinya
77 | case 'tr': // Turkish
78 | case 'uz': // Uzbek
79 | case 'wa': // Walloon
80 | /* eslint-disable */
81 | /* Disable "Duplicate case label" because there are 2 forms of Chinese plurals */
82 | case 'zh': // Chinese
83 | /* eslint-enable */
84 | // 2 forms
85 | return n > 1 ? 1 : 0
86 | case 'lv': // Latvian
87 | // 3 forms
88 | return (n % 10 === 1 && n % 100 !== 11 ? 0 : n !== 0 ? 1 : 2)
89 | case 'lt': // Lithuanian
90 | // 3 forms
91 | return (n % 10 === 1 && n % 100 !== 11 ? 0 : n % 10 >= 2 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2)
92 | case 'be': // Belarusian
93 | case 'bs': // Bosnian
94 | case 'hr': // Croatian
95 | case 'ru': // Russian
96 | case 'sr': // Serbian
97 | case 'uk': // Ukrainian
98 | // 3 forms
99 | return (
100 | n % 10 === 1 && n % 100 !== 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2)
101 | case 'mnk': // Mandinka
102 | // 3 forms
103 | return (n === 0 ? 0 : n === 1 ? 1 : 2)
104 | case 'ro': // Romanian
105 | // 3 forms
106 | return (n === 1 ? 0 : (n === 0 || (n % 100 > 0 && n % 100 < 20)) ? 1 : 2)
107 | case 'pl': // Polish
108 | // 3 forms
109 | return (n === 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2)
110 | case 'cs': // Czech
111 | case 'sk': // Slovak
112 | // 3 forms
113 | return (n === 1) ? 0 : (n >= 2 && n <= 4) ? 1 : 2
114 | case 'csb': // Kashubian
115 | // 3 forms
116 | return (n === 1) ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2
117 | case 'sl': // Slovenian
118 | // 4 forms
119 | return (n % 100 === 1 ? 0 : n % 100 === 2 ? 1 : n % 100 === 3 || n % 100 === 4 ? 2 : 3)
120 | case 'mt': // Maltese
121 | // 4 forms
122 | return (n === 1 ? 0 : n === 0 || (n % 100 > 1 && n % 100 < 11) ? 1 : (n % 100 > 10 && n % 100 < 20) ? 2 : 3)
123 | case 'gd': // Scottish Gaelic
124 | // 4 forms
125 | return (n === 1 || n === 11) ? 0 : (n === 2 || n === 12) ? 1 : (n > 2 && n < 20) ? 2 : 3
126 | case 'cy': // Welsh
127 | // 4 forms
128 | return (n === 1) ? 0 : (n === 2) ? 1 : (n !== 8 && n !== 11) ? 2 : 3
129 | case 'kw': // Cornish
130 | // 4 forms
131 | return (n === 1) ? 0 : (n === 2) ? 1 : (n === 3) ? 2 : 3
132 | case 'ga': // Irish
133 | // 5 forms
134 | return n === 1 ? 0 : n === 2 ? 1 : (n > 2 && n < 7) ? 2 : (n > 6 && n < 11) ? 3 : 4
135 | case 'ar': // Arabic
136 | // 6 forms
137 | return (n === 0 ? 0 : n === 1 ? 1 : n === 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5)
138 | default: // Everything else
139 | return n !== 1 ? 1 : 0
140 | }
141 | },
142 |
143 | }
144 |
--------------------------------------------------------------------------------
/src/translate.js:
--------------------------------------------------------------------------------
1 | import plurals from './plurals'
2 | import interpolate from './interpolate'
3 |
4 | const SPACING_RE = /\s{2,}/g
5 |
6 | // Default configuration if only the translation is passed.
7 | let _config = {
8 | language: '',
9 | getTextPluginSilent: false,
10 | getTextPluginMuteLanguages: [],
11 | silent: false,
12 | }
13 | let _translations = {}
14 |
15 | const translate = {
16 |
17 | /*
18 | * Get the translated string from the translation.json file generated by easygettext.
19 | *
20 | * @param {String} msgid - The translation key
21 | * @param {Number} n - The number to switch between singular and plural
22 | * @param {String} context - The translation key context
23 | * @param {String} defaultPlural - The default plural value (optional)
24 | * @param {String} language - The language ID (e.g. 'fr_FR' or 'en_US')
25 | *
26 | * @return {String} The translated string
27 | */
28 | getTranslation: function (msgid, n = 1, context = null, defaultPlural = null, language = _config.language) {
29 |
30 | if (!msgid) {
31 | return '' // Allow empty strings.
32 | }
33 |
34 | let silent = _config.getTextPluginSilent || (_config.getTextPluginMuteLanguages.indexOf(language) !== -1)
35 |
36 | // Default untranslated string, singular or plural.
37 | let untranslated = defaultPlural && plurals.getTranslationIndex(language, n) > 0 ? defaultPlural : msgid
38 |
39 | // `easygettext`'s `gettext-compile` generates a JSON version of a .po file based on its `Language` field.
40 | // But in this field, `ll_CC` combinations denoting a language’s main dialect are abbreviated as `ll`,
41 | // for example `de` is equivalent to `de_DE` (German as spoken in Germany).
42 | // See the `Language` section in https://www.gnu.org/software/gettext/manual/html_node/Header-Entry.html
43 | // So try `ll_CC` first, or the `ll` abbreviation which can be three-letter sometimes:
44 | // https://www.gnu.org/software/gettext/manual/html_node/Language-Codes.html#Language-Codes
45 | let translations = _translations[language] || _translations[language.split('_')[0]]
46 |
47 | if (!translations) {
48 | if (!silent) {
49 | console.warn(`No translations found for ${language}`)
50 | }
51 | return untranslated
52 | }
53 |
54 | // Currently easygettext trims entries since it needs to output consistent PO translation content
55 | // even if a web template designer added spaces between lines (which are ignored in HTML or jade,
56 | // but are significant in text). See #65.
57 | // Replicate the same behaviour here.
58 | msgid = msgid.trim()
59 |
60 | let translated = translations[msgid]
61 |
62 | // Sometimes `msgid` may not have the same number of spaces than its translation key.
63 | // This could happen because we use the private attribute `_renderChildren` to access the raw uninterpolated
64 | // string to translate in the `created` hook of `component.js`: spaces are not exactly the same between the
65 | // HTML and the content of `_renderChildren`, e.g. 6 spaces becomes 4 etc. See #15, #38.
66 | // In such cases, we need to compare the translation keys and `msgid` with the same number of spaces.
67 | if (!translated && SPACING_RE.test(msgid)) {
68 | Object.keys(translations).some(key => {
69 | if (key.replace(SPACING_RE, ' ') === msgid.replace(SPACING_RE, ' ')) {
70 | translated = translations[key]
71 | return translated
72 | }
73 | })
74 | }
75 |
76 | if (translated && context) {
77 | translated = translated[context]
78 | }
79 |
80 | if (!translated) {
81 | if (!silent) {
82 | let msg = `Untranslated ${language} key found: ${msgid}`
83 | if (context) {
84 | msg += ` (with context: ${context})`
85 | }
86 | console.warn(msg)
87 | }
88 | return untranslated
89 | }
90 |
91 | // Avoid a crash when a msgid exists with and without a context, see #32.
92 | if (!(translated instanceof Array) && translated.hasOwnProperty('')) {
93 | // As things currently stand, the void key means a void context for easygettext.
94 | translated = translated['']
95 | }
96 |
97 | if (typeof translated === 'string') {
98 | translated = [translated]
99 | }
100 |
101 | let translationIndex = plurals.getTranslationIndex(language, n)
102 |
103 | // Do not assume that the default value of n is 1 for the singular form of all languages.
104 | // E.g. Arabic, see #69.
105 | if (translated.length === 1 && n === 1) {
106 | translationIndex = 0
107 | }
108 |
109 | return translated[translationIndex]
110 |
111 | },
112 |
113 | /*
114 | * Returns a string of the translation of the message.
115 | * Also makes the string discoverable by gettext-extract.
116 | *
117 | * @param {String} msgid - The translation key
118 | * @param {String} language - The language ID (e.g. 'fr_FR' or 'en_US')
119 | *
120 | * @return {String} The translated string
121 | */
122 | 'gettext': function (msgid, language = _config.language) {
123 | return translate.getTranslation(msgid, 1, null, null, language)
124 | },
125 |
126 | /*
127 | * Returns a string of the translation for the given context.
128 | * Also makes the string discoverable by gettext-extract.
129 | *
130 | * @param {String} context - The context of the string to translate
131 | * @param {String} msgid - The translation key
132 | * @param {String} language - The language ID (e.g. 'fr_FR' or 'en_US')
133 | *
134 | * @return {String} The translated string
135 | */
136 | 'pgettext': function (context, msgid, language = _config.language) {
137 | return translate.getTranslation(msgid, 1, context, null, language)
138 | },
139 |
140 | /*
141 | * Returns a string of the translation of either the singular or plural,
142 | * based on the number.
143 | * Also makes the string discoverable by gettext-extract.
144 | *
145 | * @param {String} msgid - The translation key
146 | * @param {String} plural - The plural form of the translation key
147 | * @param {Number} n - The number to switch between singular and plural
148 | * @param {String} language - The language ID (e.g. 'fr_FR' or 'en_US')
149 | *
150 | * @return {String} The translated string
151 | */
152 | 'ngettext': function (msgid, plural, n, language = _config.language) {
153 | return translate.getTranslation(msgid, n, null, plural, language)
154 | },
155 |
156 | /*
157 | * Returns a string of the translation of either the singular or plural,
158 | * based on the number, for the given context.
159 | * Also makes the string discoverable by gettext-extract.
160 | *
161 | * @param {String} context - The context of the string to translate
162 | * @param {String} msgid - The translation key
163 | * @param {String} plural - The plural form of the translation key
164 | * @param {Number} n - The number to switch between singular and plural
165 | * @param {String} language - The language ID (e.g. 'fr_FR' or 'en_US')
166 | *
167 | * @return {String} The translated string
168 | */
169 | 'npgettext': function (context, msgid, plural, n, language = _config.language) {
170 | return translate.getTranslation(msgid, n, context, plural, language)
171 | },
172 |
173 | /*
174 | * Initialize local state for translations and configuration
175 | * so that it works without Vue.
176 | *
177 | * @param {Object} translations - translations.json
178 | * @param {Object} config - Vue.config
179 | *
180 | */
181 | initTranslations: function (translations, config) {
182 | if (translations && typeof translations === 'object') {
183 | _translations = translations
184 | }
185 | if (config && typeof config === 'object') {
186 | _config = config
187 | }
188 | },
189 |
190 | /**
191 | * Allows to use interpolation outside the Vue
192 | *
193 | * @example
194 | * import {translate} from 'vue-gettext';
195 | *
196 | * const {gettext, gettextInterpolate} = translate;
197 | *
198 | * let translated = gettext('%{ n } foos', n)
199 | * let interpolated = gettextInterpolate(translated, {n: 5})
200 | */
201 | gettextInterpolate: interpolate.bind(interpolate),
202 |
203 | }
204 |
205 | export default translate
206 |
--------------------------------------------------------------------------------
/src/uuid.js:
--------------------------------------------------------------------------------
1 | // UUID v4 generator (RFC4122 compliant).
2 | //
3 | // https://gist.github.com/jcxplorer/823878
4 |
5 | export default function uuid () {
6 |
7 | let uuid = ''
8 | let i
9 | let random
10 |
11 | for (i = 0; i < 32; i++) {
12 | random = Math.random() * 16 | 0
13 | if (i === 8 || i === 12 || i === 16 || i === 20) {
14 | uuid += '-'
15 | }
16 | uuid += (i === 12 ? 4 : (i === 16 ? (random & 3 | 8) : random)).toString(16)
17 | }
18 |
19 | return uuid
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
1 | // Require all test files (files that ends with .spec.js).
2 | const testsContext = require.context('./specs', true, /\.spec$/)
3 | testsContext.keys().forEach(testsContext)
4 |
--------------------------------------------------------------------------------
/test/specs/component.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import translations from './json/component.json'
5 | import uninstallPlugin from '../testUtils'
6 |
7 |
8 | describe('translate component tests', () => {
9 |
10 | beforeEach(function () {
11 | uninstallPlugin(Vue, GetTextPlugin)
12 | Vue.use(GetTextPlugin, {
13 | availableLanguages: {
14 | en_US: 'American English',
15 | fr_FR: 'Français',
16 | },
17 | defaultLanguage: 'en_US',
18 | translations: translations,
19 | })
20 | })
21 |
22 | it('works on empty strings', () => {
23 | let vm = new Vue({template: '
'}).$mount()
24 | expect(vm.$el.innerHTML.trim()).to.equal('')
25 | })
26 |
27 | it('returns an unchanged string when no translation is available for a language', () => {
28 | console.warn = sinon.spy(console, 'warn')
29 | let vm = new Vue({template: 'Unchanged string
'}).$mount()
30 | vm.$language.current = 'fr_BE'
31 | expect(vm.$el.innerHTML.trim()).to.equal('Unchanged string')
32 | expect(console.warn).calledOnce
33 | console.warn.restore()
34 | })
35 |
36 | it('returns an unchanged string when no translation key is available', () => {
37 | console.warn = sinon.spy(console, 'warn')
38 | let vm = new Vue({template: 'Untranslated string
'}).$mount()
39 | expect(vm.$el.innerHTML.trim()).to.equal('Untranslated string')
40 | expect(console.warn).calledOnce
41 | console.warn.restore()
42 | })
43 |
44 | it('translates known strings', () => {
45 | Vue.config.language = 'fr_FR'
46 | let vm = new Vue({template: 'Pending
'}).$mount()
47 | expect(vm.$el.innerHTML.trim()).to.equal('En cours')
48 | })
49 |
50 | it('translates multiline strings no matter the number of spaces', () => {
51 | Vue.config.language = 'fr_FR'
52 | let vm = new Vue({template: `
53 |
54 |
55 |
56 | A
57 |
58 |
59 | lot
60 |
61 |
62 |
63 |
64 | of
65 |
66 | lines
67 |
68 |
69 |
70 |
71 |
`}).$mount()
72 | expect(vm.$el.innerHTML.trim()).to.equal(`Plein de lignes
`)
73 | })
74 |
75 | it('renders translation in custom html tag', () => {
76 | Vue.config.language = 'fr_FR'
77 | let vm = new Vue({template: 'Pending
'}).$mount()
78 | expect(vm.$el.innerHTML.trim()).to.equal('En cours
')
79 | })
80 |
81 | it('translates known strings according to a given translation context', () => {
82 | Vue.config.language = 'en_US'
83 | let vm = new Vue({template: 'Answer
'}).$mount()
84 | expect(vm.$el.innerHTML.trim()).to.equal('Answer (verb)')
85 | vm = new Vue({template: 'Answer
'}).$mount()
86 | expect(vm.$el.innerHTML.trim()).to.equal('Answer (noun)')
87 | })
88 |
89 | it('allows interpolation', () => {
90 | Vue.config.language = 'fr_FR'
91 | let vm = new Vue({
92 | template: 'Hello %{ name }
',
93 | data: {name: 'John Doe'},
94 | }).$mount()
95 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John Doe')
96 | })
97 |
98 | it('allows interpolation with computed property', () => {
99 | Vue.config.language = 'fr_FR'
100 | let vm = new Vue({
101 | template: 'Hello %{ name }
',
102 | computed: {
103 | name () { return 'John Doe' },
104 | },
105 | }).$mount()
106 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John Doe')
107 | })
108 |
109 | it('allows custom params for interpolation', () => {
110 | Vue.config.language = 'fr_FR'
111 | let vm = new Vue({
112 | template: 'Hello %{ name }
',
113 | data: {
114 | someNewNameVar: 'John Doe',
115 | },
116 | }).$mount()
117 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John Doe')
118 | })
119 |
120 | it('allows interpolation within v-for with custom params', () => {
121 | Vue.config.language = 'fr_FR'
122 | let vm = new Vue({
123 | template: 'Hello %{ name }
',
124 | data: {
125 | names: ['John Doe', 'Chester'],
126 | },
127 | }).$mount()
128 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John DoeBonjour Chester')
129 | })
130 |
131 | it('translates plurals', () => {
132 | Vue.config.language = 'fr_FR'
133 | let vm = new Vue({
134 | template: `
135 | %{ count } car
136 |
`,
137 | data: {count: 2},
138 | }).$mount()
139 | expect(vm.$el.innerHTML.trim()).to.equal('2 véhicules')
140 | })
141 |
142 | it('translates plurals with computed property', () => {
143 | Vue.config.language = 'fr_FR'
144 | let vm = new Vue({
145 | template: `
146 | %{ count } car
147 |
`,
148 | computed: {
149 | count () { return 2 },
150 | },
151 | }).$mount()
152 | expect(vm.$el.innerHTML.trim()).to.equal('2 véhicules')
153 | })
154 |
155 | it('updates a plural translation after a data change', (done) => {
156 | Vue.config.language = 'fr_FR'
157 | let vm = new Vue({
158 | template: `
159 | %{ count } car
160 |
`,
161 | data: {count: 10},
162 | }).$mount()
163 | expect(vm.$el.innerHTML.trim()).to.equal('10 véhicules')
164 | vm.count = 8
165 | vm.$nextTick(function () {
166 | expect(vm.$el.innerHTML.trim()).to.equal('8 véhicules')
167 | done()
168 | })
169 | })
170 |
171 | it('updates a translation after a language change', (done) => {
172 | Vue.config.language = 'fr_FR'
173 | let vm = new Vue({template: 'Pending
'}).$mount()
174 | expect(vm.$el.innerHTML.trim()).to.equal('En cours')
175 | Vue.config.language = 'en_US'
176 | vm.$nextTick(function () {
177 | expect(vm.$el.innerHTML.trim()).to.equal('Pending')
178 | done()
179 | })
180 | })
181 |
182 | it('thrown errors displayed in the console if you forget to add a `translate-plural` attribute', () => {
183 | console.error = sinon.spy(console, 'error')
184 | new Vue({
185 | template: '%{ n } car',
186 | data: {n: 2},
187 | }).$mount()
188 | expect(console.error)
189 | .calledWith(sinon.match('`translate-n` and `translate-plural` attributes must be used together: %{ n } car.'))
190 | console.error.restore()
191 | })
192 |
193 | it('thrown errors displayed in the console if you forget to add a `translate-n` attribute', () => {
194 | console.error = sinon.spy(console, 'error')
195 | new Vue({
196 | template: '%{ n } car
',
197 | }).$mount()
198 | expect(console.error)
199 | .calledWith(sinon.match('`translate-n` and `translate-plural` attributes must be used together: %{ n } car.'))
200 | console.error.restore()
201 | })
202 |
203 | it('supports conditional rendering such as v-if, v-else-if, v-else', (done) => {
204 | Vue.config.language = 'en_US'
205 | Vue.config.autoAddKeyAttributes = true
206 | let vm = new Vue({
207 | template: `
208 | Pending
209 | Hello %{ name }
210 | `,
211 | data: {show: true, name: 'John Doe'},
212 | }).$mount()
213 | expect(vm.$el.innerHTML).to.equal('Pending')
214 | vm.show = false
215 | vm.$nextTick(function () {
216 | expect(vm.$el.innerHTML).to.equal('Hello John Doe')
217 | Vue.config.autoAddKeyAttributes = false
218 | done()
219 | })
220 | })
221 |
222 | })
223 |
224 | describe('translate component tests for interpolation', () => {
225 |
226 | beforeEach(function () {
227 | uninstallPlugin(Vue, GetTextPlugin)
228 | Vue.use(GetTextPlugin, {
229 | availableLanguages: {
230 | en_US: 'American English',
231 | fr_FR: 'Français',
232 | },
233 | defaultLanguage: 'en_US',
234 | translations: translations,
235 | })
236 | })
237 |
238 | it('goes up the parent chain of a nested component to evaluate `name`', (done) => {
239 | Vue.config.language = 'fr_FR'
240 | let vm = new Vue({
241 | template: `
`,
242 | data: {
243 | name: 'John Doe',
244 | },
245 | components: {
246 | 'inner-component': {
247 | template: `Hello %{ name }
`,
248 | },
249 | },
250 | }).$mount()
251 | vm.$nextTick(function () {
252 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John Doe
')
253 | done()
254 | })
255 | })
256 |
257 | it('goes up the parent chain of a nested component to evaluate `user.details.name`', (done) => {
258 | console.warn = sinon.spy(console, 'warn')
259 | Vue.config.language = 'fr_FR'
260 | let vm = new Vue({
261 | template: `
`,
262 | data: {
263 | user: {
264 | details: {
265 | name: 'Jane Doe',
266 | },
267 | },
268 | },
269 | components: {
270 | 'inner-component': {
271 | template: `Hello %{ user.details.name }
`,
272 | },
273 | },
274 | }).$mount()
275 | vm.$nextTick(function () {
276 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour Jane Doe
')
277 | expect(console.warn).notCalled
278 | console.warn.restore()
279 | done()
280 | })
281 | })
282 |
283 | it('goes up the parent chain of 2 nested components to evaluate `user.details.name`', (done) => {
284 | console.warn = sinon.spy(console, 'warn')
285 | Vue.config.language = 'fr_FR'
286 | let vm = new Vue({
287 | template: `
`,
288 | data: {
289 | user: {
290 | details: {
291 | name: 'Jane Doe',
292 | },
293 | },
294 | },
295 | components: {
296 | 'first-component': {
297 | template: `
`,
298 | components: {
299 | 'second-component': {
300 | template: `Hello %{ user.details.name }`,
301 | },
302 | },
303 | },
304 | },
305 | }).$mount()
306 | vm.$nextTick(function () {
307 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour Jane Doe
')
308 | expect(console.warn).notCalled
309 | console.warn.restore()
310 | done()
311 | })
312 | })
313 |
314 | })
315 |
--------------------------------------------------------------------------------
/test/specs/directive.arabic.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import translations from './json/directive.arabic.json'
5 | import uninstallPlugin from '../testUtils'
6 |
7 | // https://docs.transifex.com/formats/gettext
8 | // https://www.arabeyes.org/Plural_Forms
9 |
10 | describe('translate arabic directive tests', () => {
11 |
12 | beforeEach(function () {
13 | uninstallPlugin(Vue, GetTextPlugin)
14 | Vue.use(GetTextPlugin, {
15 | availableLanguages: {
16 | en_US: 'American English',
17 | ar: 'Arabic',
18 | },
19 | defaultLanguage: 'ar',
20 | translations: translations,
21 | })
22 | })
23 |
24 | it('translates singular', () => {
25 | let vm = new Vue({
26 | template: 'Orange
',
27 | data: {count: 1},
28 | }).$mount()
29 | expect(vm.$el.innerHTML).to.equal('البرتقالي')
30 | })
31 |
32 | it('translates plural form 0', () => {
33 | let vm = new Vue({
34 | template: '%{ count } day
',
35 | data: {count: 0},
36 | }).$mount()
37 | expect(vm.$el.innerHTML).to.equal('{ count }أقل من يوم')
38 | })
39 |
40 | it('translates plural form 1', () => {
41 | let vm = new Vue({
42 | template: '%{ count } day
',
43 | data: {count: 1},
44 | }).$mount()
45 | expect(vm.$el.innerHTML).to.equal('{ count }يوم واحد')
46 | })
47 |
48 | it('translates plural form 2', () => {
49 | let vm = new Vue({
50 | template: '%{ count } day
',
51 | data: {count: 2},
52 | }).$mount()
53 | expect(vm.$el.innerHTML).to.equal('{ count }يومان')
54 | })
55 |
56 | it('translates plural form 3', () => {
57 | let vm = new Vue({
58 | template: '%{ count } day
',
59 | data: {count: 9},
60 | }).$mount()
61 | expect(vm.$el.innerHTML).to.equal('{ count } أيام')
62 | })
63 |
64 | it('translates plural form 4', () => {
65 | let vm = new Vue({
66 | template: '%{ count } day
',
67 | data: {count: 11},
68 | }).$mount()
69 | expect(vm.$el.innerHTML).to.equal('{ count } يومًا')
70 | })
71 |
72 | it('translates plural form 5', () => {
73 | let vm = new Vue({
74 | template: '%{ count } day
',
75 | data: {count: 3000},
76 | }).$mount()
77 | expect(vm.$el.innerHTML).to.equal('{ count } يوم')
78 | })
79 |
80 | })
81 |
--------------------------------------------------------------------------------
/test/specs/directive.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import translations from './json/directive.json'
5 | import uninstallPlugin from '../testUtils'
6 |
7 |
8 | describe('translate directive tests', () => {
9 |
10 | beforeEach(function () {
11 | uninstallPlugin(Vue, GetTextPlugin)
12 | Vue.use(GetTextPlugin, {
13 | availableLanguages: {
14 | en_US: 'American English',
15 | fr_FR: 'Français',
16 | },
17 | defaultLanguage: 'en_US',
18 | translations: translations,
19 | })
20 | })
21 |
22 | it('works on empty strings', () => {
23 | let vm = new Vue({template: ''}).$mount()
24 | expect(vm.$el.innerHTML).to.equal('')
25 | })
26 |
27 | it('returns an unchanged string when no translation is available for a language', () => {
28 | console.warn = sinon.spy(console, 'warn')
29 | let vm = new Vue({template: 'Unchanged string
'}).$mount()
30 | vm.$language.current = 'fr_BE'
31 | expect(vm.$el.innerHTML).to.equal('Unchanged string')
32 | expect(console.warn).calledOnce
33 | console.warn.restore()
34 | })
35 |
36 | it('returns an unchanged string when no translation key is available', () => {
37 | console.warn = sinon.spy(console, 'warn')
38 | let vm = new Vue({template: 'Untranslated string
'}).$mount()
39 | expect(vm.$el.innerHTML).to.equal('Untranslated string')
40 | expect(console.warn).calledOnce
41 | console.warn.restore()
42 | })
43 |
44 | it('translates known strings', () => {
45 | Vue.config.language = 'fr_FR'
46 | let vm = new Vue({template: 'Pending
'}).$mount()
47 | expect(vm.$el.innerHTML).to.equal('En cours')
48 | })
49 |
50 | it('translates known strings when surrounded by one or more tabs and spaces', () => {
51 | Vue.config.language = 'fr_FR'
52 | let vm = new Vue({template: '\tPending\t\t \t\r\n\t\f\v
'}).$mount()
53 | expect(vm.$el.innerHTML).to.equal('En cours')
54 | })
55 |
56 | it('translates multiline strings as-is, preserving the original content', () => {
57 | Vue.config.language = 'fr_FR'
58 | let vm = new Vue({template: '\n\nA\n\n\nlot\n\n\nof\n\nlines
'}).$mount()
59 | expect(vm.$el.innerHTML).to.equal('Plein\n\n\nde\n\nlignes')
60 | })
61 |
62 | it('translates known strings according to a given translation context', () => {
63 | Vue.config.language = 'en_US'
64 | let vm = new Vue({template: 'Answer
'}).$mount()
65 | expect(vm.$el.innerHTML).to.equal('Answer (verb)')
66 | vm = new Vue({template: 'Answer
'}).$mount()
67 | expect(vm.$el.innerHTML).to.equal('Answer (noun)')
68 | })
69 |
70 | it('works with text content', () => {
71 | let vm = new Vue({template: 'This is sparta!
'}).$mount()
72 | expect(vm.$el.innerHTML).to.equal('This is sparta!')
73 | })
74 |
75 | it('works with HTML content', () => {
76 | let vm = new Vue({template: 'This is sparta!
'}).$mount()
77 | expect(vm.$el.innerHTML).to.equal('This is sparta!')
78 | })
79 |
80 | it('allows interpolation', () => {
81 | Vue.config.language = 'fr_FR'
82 | let vm = new Vue({
83 | template: 'Hello %{ name }
',
84 | data: {name: 'John Doe'},
85 | }).$mount()
86 | expect(vm.$el.innerHTML).to.equal('Bonjour John Doe')
87 | })
88 |
89 | it('escapes HTML in variables by default', () => {
90 | Vue.config.language = 'fr_FR'
91 | let vm = new Vue({
92 | template: 'Hello %{ openingTag }%{ name }%{ closingTag }
',
93 | data: {
94 | name: 'John Doe',
95 | openingTag: '',
96 | closingTag: '',
97 | },
98 | }).$mount()
99 | expect(vm.$el.innerHTML).to.equal('Bonjour <b>John Doe</b>')
100 | })
101 |
102 | it('forces HTML rendering in variables (with the `render-html` attribute set to `true`)', () => {
103 | Vue.config.language = 'fr_FR'
104 | let vm = new Vue({
105 | template: 'Hello %{ openingTag }%{ name }%{ closingTag }
',
106 | data: {
107 | name: 'John Doe',
108 | openingTag: '',
109 | closingTag: '',
110 | },
111 | }).$mount()
112 | expect(vm.$el.innerHTML).to.equal('Bonjour John Doe')
113 | })
114 |
115 | it('allows interpolation with computed property', () => {
116 | Vue.config.language = 'fr_FR'
117 | let vm = new Vue({
118 | template: 'Hello %{ name }
',
119 | computed: {
120 | name () { return 'John Doe' },
121 | },
122 | }).$mount()
123 | expect(vm.$el.innerHTML).to.equal('Bonjour John Doe')
124 | })
125 |
126 | it('allows custom params for interpolation', () => {
127 | Vue.config.language = 'fr_FR'
128 | let vm = new Vue({
129 | template: 'Hello %{ name }
',
130 | data: {
131 | someNewNameVar: 'John Doe',
132 | },
133 | }).$mount()
134 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour John Doe')
135 | })
136 |
137 | it('allows interpolation within v-for with custom params', () => {
138 | Vue.config.language = 'fr_FR'
139 | let names = ['John Doe', 'Chester']
140 | let vm = new Vue({
141 | template: 'Hello %{ name }
',
142 | data: {
143 | names,
144 | },
145 | }).$mount()
146 | let html = vm.$el.innerHTML.trim()
147 | let missedName = names.some((name) => {
148 | if (html.indexOf(name) === -1) {
149 | return true
150 | }
151 | })
152 | expect(missedName).to.equal(false)
153 | })
154 |
155 | it('logs a warning in the console if translate-params is used', () => {
156 | console.warn = sinon.spy(console, 'warn')
157 | Vue.config.language = 'fr_FR'
158 | let vm = new Vue({
159 | template: 'Hello %{ name }
',
160 | data: {
161 | someNewNameVar: 'John Doe',
162 | },
163 | }).$mount()
164 | expect(vm.$el.innerHTML.trim()).to.equal('Bonjour name')
165 | expect(console.warn).called
166 | console.warn.restore()
167 | })
168 |
169 | it('updates a translation after a data change', (done) => {
170 | Vue.config.language = 'fr_FR'
171 | let vm = new Vue({
172 | template: 'Hello %{ name }
',
173 | data: {name: 'John Doe'},
174 | }).$mount()
175 | expect(vm.$el.innerHTML).to.equal('Bonjour John Doe')
176 | vm.name = 'Kenny'
177 | vm.$nextTick(function () {
178 | expect(vm.$el.innerHTML).to.equal('Bonjour Kenny')
179 | done()
180 | })
181 | })
182 |
183 | it('logs an info in the console if an interpolation is required but an expression is not provided', () => {
184 | console.info = sinon.spy(console, 'info')
185 | Vue.config.language = 'fr_FR'
186 | let vm = new Vue({
187 | template: 'Hello %{ name }
',
188 | data: {name: 'John Doe'},
189 | }).$mount()
190 | expect(vm.$el.innerHTML).to.equal('Bonjour John Doe')
191 | expect(console.info).calledOnce
192 | console.info.restore()
193 | })
194 |
195 | it('translates plurals', () => {
196 | Vue.config.language = 'fr_FR'
197 | let vm = new Vue({
198 | template: '%{ count } car
',
199 | data: {count: 2},
200 | }).$mount()
201 | expect(vm.$el.innerHTML).to.equal('2 véhicules')
202 | })
203 |
204 | it('translates plurals with computed property', () => {
205 | Vue.config.language = 'fr_FR'
206 | let vm = new Vue({
207 | template: '%{ count } car
',
208 | computed: {
209 | count () { return 2 },
210 | },
211 | }).$mount()
212 | expect(vm.$el.innerHTML).to.equal('2 véhicules')
213 | })
214 |
215 | it('updates a plural translation after a data change', (done) => {
216 | Vue.config.language = 'fr_FR'
217 | let vm = new Vue({
218 | template: '%{ count } %{ brand } car
',
219 | data: {count: 1, brand: 'Toyota'},
220 | }).$mount()
221 | expect(vm.$el.innerHTML).to.equal('1 Toyota véhicule')
222 | vm.count = 8
223 | vm.$nextTick(function () {
224 | expect(vm.$el.innerHTML).to.equal('8 Toyota véhicules')
225 | done()
226 | })
227 | })
228 |
229 | it('updates a translation after a language change', (done) => {
230 | Vue.config.language = 'fr_FR'
231 | let vm = new Vue({template: 'Pending
'}).$mount()
232 | expect(vm.$el.innerHTML).to.equal('En cours')
233 | Vue.config.language = 'en_US'
234 | vm.$nextTick(function () {
235 | expect(vm.$el.innerHTML).to.equal('Pending')
236 | done()
237 | })
238 | })
239 |
240 | it('supports conditional rendering such as v-if, v-else-if, v-else', (done) => {
241 | Vue.config.language = 'en_US'
242 | Vue.config.autoAddKeyAttributes = true
243 | let vm = new Vue({
244 | template: `
245 | Pending
246 | Hello %{ name }
247 | `,
248 | data: {show: true, name: 'John Doe'},
249 | }).$mount()
250 | expect(vm.$el.innerHTML).to.equal('Pending')
251 | vm.show = false
252 | vm.$nextTick(function () {
253 | expect(vm.$el.innerHTML).to.equal('Hello John Doe')
254 | Vue.config.autoAddKeyAttributes = false
255 | done()
256 | })
257 | })
258 |
259 | it('does not trigger re-render of innerHTML when using expression with object and expression value was not changed', (done) => {
260 | let vm = new Vue({
261 | template: `
262 | Hello %{ name }
263 | `,
264 | data: {someCounter: 0},
265 | }).$mount()
266 | expect(vm.$el.innerHTML).to.equal('Hello test')
267 |
268 | let spy = sinon.spy(vm.$el, 'innerHTML', ['set'])
269 | vm.someCounter += 1
270 | vm.$nextTick(function () {
271 | vm.someCounter += 1
272 | vm.$nextTick(function () {
273 | expect(spy.set.callCount).to.equal(0)
274 | done()
275 | })
276 | })
277 | })
278 |
279 | it('re-render innerHTML when using expression and only if translation data was changed', (done) => {
280 | let vm = new Vue({
281 | template: `
282 | Hello %{ name.first }
283 | `,
284 | data: {someCounter: 0, varFromData: 'name'},
285 | }).$mount()
286 | expect(vm.$el.innerHTML).to.equal('Hello name')
287 |
288 | let spy = sinon.spy(vm.$el, 'innerHTML', ['set'])
289 | vm.varFromData = 'name'
290 | vm.someCounter += 1
291 | vm.$nextTick(function () {
292 | vm.varFromData = 'otherName'
293 | vm.someCounter += 1
294 | vm.$nextTick(function () {
295 | expect(vm.$el.innerHTML).to.equal('Hello otherName')
296 | expect(spy.set).calledOnce
297 | done()
298 | })
299 | })
300 | })
301 | })
302 |
--------------------------------------------------------------------------------
/test/specs/interpolate.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import interpolate from '../../src/interpolate'
5 | import translations from './json/translate.json'
6 | import uninstallPlugin from '../testUtils'
7 |
8 |
9 | describe('Interpolate tests', () => {
10 |
11 | beforeEach(function () {
12 | uninstallPlugin(Vue, GetTextPlugin)
13 | Vue.use(GetTextPlugin, {
14 | translations: translations,
15 | silent: true,
16 | })
17 | })
18 |
19 | it('without placeholders', () => {
20 | let msgid = 'Foo bar baz'
21 | let interpolated = interpolate(msgid)
22 | expect(interpolated).to.equal('Foo bar baz')
23 | })
24 |
25 | it('with a placeholder', () => {
26 | let msgid = 'Foo %{ placeholder } baz'
27 | let context = { placeholder: 'bar' }
28 | let interpolated = interpolate(msgid, context)
29 | expect(interpolated).to.equal('Foo bar baz')
30 | })
31 |
32 | it('with HTML in var (should be escaped)', () => {
33 | let msgid = 'Foo %{ placeholder } baz'
34 | let context = { placeholder: 'bar
' }
35 | let interpolated = interpolate(msgid, context)
36 | expect(interpolated).to.equal('Foo <p>bar</p> baz')
37 | })
38 |
39 | it('with HTML in var (should NOT be escaped)', () => {
40 | let msgid = 'Foo %{ placeholder } baz'
41 | let context = { placeholder: 'bar
' }
42 | let disableHtmlEscaping = true
43 | let interpolated = interpolate(msgid, context, disableHtmlEscaping)
44 | expect(interpolated).to.equal('Foo bar
baz')
45 | })
46 |
47 | it('with multiple spaces in the placeholder', () => {
48 | let msgid = 'Foo %{ placeholder } baz'
49 | let context = { placeholder: 'bar' }
50 | let interpolated = interpolate(msgid, context)
51 | expect(interpolated).to.equal('Foo bar baz')
52 | })
53 |
54 | it('with the same placeholder multiple times', () => {
55 | let msgid = 'Foo %{ placeholder } baz %{ placeholder } foo'
56 | let context = { placeholder: 'bar' }
57 | let interpolated = interpolate(msgid, context)
58 | expect(interpolated).to.equal('Foo bar baz bar foo')
59 | })
60 |
61 | it('with multiple placeholders', () => {
62 | let msgid = '%{foo}%{bar}%{baz}%{bar}%{foo}'
63 | let context = { foo: 1, bar: 2, baz: 3 }
64 | let interpolated = interpolate(msgid, context)
65 | expect(interpolated).to.equal('12321')
66 | })
67 |
68 | it('with new lines', () => {
69 | let msgid = '%{ \n \n\n\n\n foo} %{bar}!'
70 | let context = { foo: 'Hello', bar: 'world' }
71 | let interpolated = interpolate(msgid, context)
72 | expect(interpolated).to.equal('Hello world!')
73 | })
74 |
75 | it('with an object', () => {
76 | let msgid = 'Foo %{ foo.bar } baz'
77 | let context = {
78 | foo: {
79 | bar: 'baz',
80 | },
81 | }
82 | let interpolated = interpolate(msgid, context)
83 | expect(interpolated).to.equal('Foo baz baz')
84 | })
85 |
86 | it('with an array', () => {
87 | let msgid = 'Foo %{ foo[1] } baz'
88 | let context = {
89 | foo: [ 'bar', 'baz' ],
90 | }
91 | let interpolated = interpolate(msgid, context)
92 | expect(interpolated).to.equal('Foo baz baz')
93 | })
94 |
95 | it('with a multi level object', () => {
96 | let msgid = 'Foo %{ a.b.x } %{ a.c.y[1].title }'
97 | let context = {
98 | a: {
99 | b: {
100 | x: 'foo',
101 | },
102 | c: {
103 | y: [
104 | { title: 'bar' },
105 | { title: 'baz' },
106 | ],
107 | },
108 | },
109 | }
110 | let interpolated = interpolate(msgid, context)
111 | expect(interpolated).to.equal('Foo foo baz')
112 | })
113 |
114 | it('with a failing expression', () => {
115 | let msgid = 'Foo %{ alert("foobar") } baz'
116 | let context = {
117 | foo: 'bar',
118 | }
119 | console.warn = sinon.spy(console, 'warn')
120 | interpolate(msgid, context)
121 | expect(console.warn).calledOnce
122 | expect(console.warn).calledWith('Cannot evaluate expression: alert("foobar")')
123 | console.warn.restore()
124 | })
125 |
126 | it('should warn of the usage of mustache syntax', () => {
127 | let msgid = 'Foo {{ foo }} baz'
128 | let context = {
129 | foo: 'bar',
130 | }
131 | console.warn = sinon.spy(console, 'warn')
132 | interpolate(msgid, context)
133 | expect(console.warn).notCalled
134 | Vue.config.getTextPluginSilent = false
135 | interpolate(msgid, context)
136 | expect(console.warn).calledOnce
137 | console.warn.restore()
138 | })
139 |
140 | })
141 |
--------------------------------------------------------------------------------
/test/specs/json/component.json:
--------------------------------------------------------------------------------
1 | {
2 | "en_US": {
3 | "Answer": {
4 | "Noun": "Answer (noun)",
5 | "Verb": "Answer (verb)"
6 | },
7 | "Hello %{ name }": "Hello %{ name }",
8 | "Hello %{ user.details.name }": "Hello %{ user.details.name }",
9 | "Pending": "Pending",
10 | "%{ count } car": ["1 car", "%{ count } cars"],
11 | "A\n\n\n lot\n\n\n\n\n of\n\n lines": "A lot of lines"
12 | },
13 | "fr_FR": {
14 | "Answer": {
15 | "Noun": "Réponse (nom)",
16 | "Verb": "Réponse (verbe)"
17 | },
18 | "Hello %{ name }": "Bonjour %{ name }",
19 | "Hello %{ user.details.name }": "Bonjour %{ user.details.name }",
20 | "Pending": "En cours",
21 | "%{ count } car": ["1 véhicule", "%{ count } véhicules"],
22 | "A\n\n\n lot\n\n\n\n\n of\n\n lines": "Plein de lignes"
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/test/specs/json/directive.arabic.json:
--------------------------------------------------------------------------------
1 | {
2 | "ar": {
3 | "Orange": "البرتقالي",
4 | "%{ count } day": [
5 | "{ count }أقل من يوم",
6 | "{ count }يوم واحد",
7 | "{ count }يومان",
8 | "{ count } أيام",
9 | "{ count } يومًا",
10 | "{ count } يوم"
11 | ]
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/test/specs/json/directive.json:
--------------------------------------------------------------------------------
1 | {
2 | "en_US": {
3 | "Answer": {
4 | "Noun": "Answer (noun)",
5 | "Verb": "Answer (verb)"
6 | },
7 | "Hello %{ name }": "Hello %{ name }",
8 | "Hello %{ openingTag }%{ name }%{ closingTag }": "Hello %{ openingTag }%{ name }%{ closingTag }",
9 | "Pending": "Pending",
10 | "%{ count } car": ["1 car", "%{ count } cars"],
11 | "%{ count } %{ brand } car": ["1 %{ brand } car", "%{ count } %{ brand } cars"],
12 | "A\n\n\nlot\n\n\nof\n\nlines": "A\n\n\nlot\n\n\nof\n\nlines"
13 | },
14 | "fr_FR": {
15 | "Answer": {
16 | "Noun": "Réponse (nom)",
17 | "Verb": "Réponse (verbe)"
18 | },
19 | "Hello %{ openingTag }%{ name }%{ closingTag }": "Bonjour %{ openingTag }%{ name }%{ closingTag }",
20 | "Hello %{ name }": "Bonjour %{ name }",
21 | "Pending": "En cours",
22 | "%{ count } car": ["1 véhicule", "%{ count } véhicules"],
23 | "%{ count } %{ brand } car": ["1 %{ brand } véhicule", "%{ count } %{ brand } véhicules"],
24 | "A\n\n\nlot\n\n\nof\n\nlines": "Plein\n\n\nde\n\nlignes"
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/test/specs/json/plugin.config.json:
--------------------------------------------------------------------------------
1 | {
2 | "en_US": {
3 | "Foo": "Foo en_US"
4 | },
5 | "fr_FR": {
6 | "Foo": "Foo fr_FR"
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/test/specs/json/translate.json:
--------------------------------------------------------------------------------
1 | {
2 | "en_US": {
3 | "Answer": {
4 | "Noun": "Answer (noun)",
5 | "Verb": "Answer (verb)"
6 | },
7 | "Hello %{ name }": "Hello %{ name }",
8 | "May": "May",
9 | "Pending": "Pending",
10 | "%{ carCount } car": [
11 | "1 car",
12 | "%{ carCount } cars"
13 | ],
14 | "%{ carCount } car (noun)": {
15 | "Noun": [
16 | "%{ carCount } car (noun)",
17 | "%{ carCount } cars (noun)"
18 | ]
19 | },
20 | "%{ carCount } car (verb)": {
21 | "Verb": [
22 | "%{ carCount } car (verb)",
23 | "%{ carCount } cars (verb)"
24 | ]
25 | },
26 | "%{ carCount } car (multiple contexts)": {
27 | "": [
28 | "1 car",
29 | "%{ carCount } cars"
30 | ],
31 | "Context": [
32 | "1 car with context",
33 | "%{ carCount } cars with context"
34 | ]
35 | },
36 | "Object": {
37 | "": "Object",
38 | "Context": "Object with context"
39 | }
40 | },
41 | "fr": {
42 | "Answer": {
43 | "Noun": "Réponse (nom)",
44 | "Verb": "Réponse (verbe)"
45 | },
46 | "Hello %{ name }": "Bonjour %{ name }",
47 | "May": "Pourrait",
48 | "Pending": "En cours",
49 | "%{ carCount } car": [
50 | "1 véhicule",
51 | "%{ carCount } véhicules"
52 | ],
53 | "%{ carCount } car (noun)": {
54 | "Noun": [
55 | "%{ carCount } véhicule (nom)",
56 | "%{ carCount } véhicules (nom)"
57 | ]
58 | },
59 | "%{ carCount } car (verb)": {
60 | "Verb": [
61 | "%{ carCount } véhicule (verbe)",
62 | "%{ carCount } véhicules (verbe)"
63 | ]
64 | },
65 | "%{ carCount } car (multiple contexts)": {
66 | "": [
67 | "1 véhicule",
68 | "%{ carCount } véhicules"
69 | ],
70 | "Context": [
71 | "1 véhicule avec contexte",
72 | "%{ carCount } véhicules avec contexte"
73 | ]
74 | },
75 | "Object": {
76 | "": "Objet",
77 | "Context": "Objet avec contexte"
78 | }
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/test/specs/plugin.config.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import translate from '../../src/translate'
5 | import translations from './json/plugin.config.json'
6 | import uninstallPlugin from '../testUtils'
7 |
8 |
9 | describe('GetText plugin configuration tests', () => {
10 |
11 | beforeEach(function () {
12 | uninstallPlugin(Vue, GetTextPlugin)
13 | })
14 |
15 | it('raises an error when an unknown option is used', () => {
16 | expect(function () {
17 | Vue.use(GetTextPlugin, { unknownOption: null, translations: {} })
18 | }).to.throw('unknownOption is an invalid option for the translate plugin.')
19 | })
20 |
21 | it('raises an error when there are no translations', () => {
22 | expect(function () {
23 | Vue.use(GetTextPlugin, {})
24 | }).to.throw('No translations available.')
25 | })
26 |
27 | it('allows to add a mixin to languageVm', () => {
28 | Vue.use(GetTextPlugin, {
29 | availableLanguages: {
30 | en_GB: 'English',
31 | fr_FR: 'Français',
32 | },
33 | defaultLanguage: 'fr_FR',
34 | translations: {},
35 | languageVmMixin: {
36 | computed: {
37 | currentKebabCase: function () {
38 | return this.current.toLowerCase().replace('_', '-')
39 | },
40 | },
41 | },
42 | })
43 | let vm = new Vue({template: 'Foo
'}).$mount()
44 | expect(vm.$language.currentKebabCase).to.equal('fr-fr')
45 | vm.$language.current = 'en_GB'
46 | expect(vm.$language.currentKebabCase).to.equal('en-gb')
47 | })
48 |
49 | })
50 |
51 | describe('GetText plugin `silent` option tests', () => {
52 |
53 | beforeEach(function () {
54 | uninstallPlugin(Vue, GetTextPlugin)
55 | })
56 |
57 | it('warnings are ON for a missing language when `silent` is false', () => {
58 | console.warn = sinon.spy(console, 'warn')
59 | Vue.use(GetTextPlugin, {
60 | translations: translations,
61 | silent: false,
62 | })
63 | Vue.config.language = 'pt_BR'
64 | expect(translations.hasOwnProperty('pt_BR')).to.be.false
65 | let vm = new Vue({template: 'Bar
'}).$mount()
66 | expect(vm.$el.innerHTML.trim()).to.equal('Bar')
67 | expect(console.warn).calledOnce
68 | expect(console.warn.calledWith('No translations found for pt_BR')).to.be.true
69 | console.warn.restore()
70 | })
71 |
72 | it('warnings are OFF for a missing language when `silent` is true', () => {
73 | console.warn = sinon.spy(console, 'warn')
74 | Vue.use(GetTextPlugin, {
75 | translations: translations,
76 | silent: true,
77 | })
78 | Vue.config.language = 'pt_BR'
79 | expect(translations.hasOwnProperty('pt_BR')).to.be.false
80 | let vm = new Vue({template: 'Bar
'}).$mount()
81 | expect(vm.$el.innerHTML.trim()).to.equal('Bar')
82 | expect(console.warn).notCalled
83 | console.warn.restore()
84 | })
85 |
86 | it('warnings are ON for a missing translation key when `silent` is false', () => {
87 | console.warn = sinon.spy(console, 'warn')
88 | Vue.use(GetTextPlugin, {
89 | translations: translations,
90 | silent: false,
91 | })
92 | Vue.config.language = 'fr_FR'
93 | let vm = new Vue({template: 'Bar
'}).$mount()
94 | expect(translations.fr_FR.hasOwnProperty('Bar')).to.be.false
95 | expect(vm.$el.innerHTML.trim()).to.equal('Bar')
96 | expect(console.warn).calledOnce
97 | expect(console.warn.calledWith('Untranslated fr_FR key found: Bar')).to.be.true
98 | console.warn.restore()
99 | })
100 |
101 | it('warnings are OFF for a missing translation key when `silent` is true', () => {
102 | console.warn = sinon.spy(console, 'warn')
103 | Vue.use(GetTextPlugin, {
104 | translations: translations,
105 | silent: true,
106 | })
107 | Vue.config.language = 'fr_FR'
108 | let vm = new Vue({template: 'Bar
'}).$mount()
109 | expect(translations.fr_FR.hasOwnProperty('Bar')).to.be.false
110 | expect(vm.$el.innerHTML.trim()).to.equal('Bar')
111 | expect(console.warn).notCalled
112 | console.warn.restore()
113 | })
114 |
115 | })
116 |
117 | describe('GetText plugin `muteLanguages` option tests', () => {
118 |
119 | beforeEach(function () {
120 | uninstallPlugin(Vue, GetTextPlugin)
121 | Vue.use(GetTextPlugin, {
122 | availableLanguages: {
123 | en_US: 'American English',
124 | fr_FR: 'Français',
125 | },
126 | defaultLanguage: 'fr_FR',
127 | muteLanguages: [],
128 | silent: false,
129 | translations: translations,
130 | })
131 | })
132 |
133 | it('warnings are ON for all languages', () => {
134 | console.warn = sinon.spy(console, 'warn')
135 | translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
136 | expect(console.warn).calledWith('Untranslated fr_FR key found: Untranslated key')
137 | translate.getTranslation('Untranslated key', null, null, null, 'en_US')
138 | expect(console.warn).calledWith('Untranslated en_US key found: Untranslated key')
139 | console.warn.restore()
140 | })
141 |
142 | it('warnings are OFF for fr_FR', () => {
143 | console.warn = sinon.spy(console, 'warn')
144 | Vue.config.getTextPluginMuteLanguages = ['fr_FR']
145 | translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
146 | expect(console.warn).notCalled
147 | translate.getTranslation('Untranslated key', null, null, null, 'en_US')
148 | expect(console.warn).calledWith('Untranslated en_US key found: Untranslated key')
149 | console.warn.restore()
150 | })
151 |
152 | it('warnings are OFF for en_US', () => {
153 | console.warn = sinon.spy(console, 'warn')
154 | Vue.config.getTextPluginMuteLanguages = ['en_US']
155 | translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
156 | expect(console.warn).calledWith('Untranslated fr_FR key found: Untranslated key')
157 | translate.getTranslation('Untranslated key', null, null, null, 'en_US')
158 | expect(console.warn).notCalled
159 | console.warn.restore()
160 | })
161 |
162 | it('warnings are OFF for en_US and fr_FR', () => {
163 | console.warn = sinon.spy(console, 'warn')
164 | Vue.config.getTextPluginMuteLanguages = ['fr_FR', 'en_US']
165 | translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
166 | expect(console.warn).notCalled
167 | translate.getTranslation('Untranslated key', null, null, null, 'en_US')
168 | expect(console.warn).notCalled
169 | console.warn.restore()
170 | })
171 |
172 | })
173 |
--------------------------------------------------------------------------------
/test/specs/plurals.spec.js:
--------------------------------------------------------------------------------
1 | import plurals from '../../src/plurals'
2 |
3 |
4 | describe('Translate plurals tests', () => {
5 |
6 | it('plural form of singular english is 0', function () {
7 | expect(plurals.getTranslationIndex('en', 1)).to.equal(0)
8 | })
9 |
10 | it('plural form of plural english is 1', function () {
11 | expect(plurals.getTranslationIndex('en', 2)).to.equal(1)
12 | })
13 |
14 | it('plural form of Infinity in english is 1', function () {
15 | expect(plurals.getTranslationIndex('en', Infinity)).to.equal(1)
16 | })
17 |
18 | it('plural form of zero in english is 1', function () {
19 | expect(plurals.getTranslationIndex('en', 0)).to.equal(1)
20 | })
21 |
22 | it('plural form of singular dutch is 0', function () {
23 | expect(plurals.getTranslationIndex('nl', 1)).to.equal(0)
24 | })
25 |
26 | it('plural form of plural dutch is 1', function () {
27 | expect(plurals.getTranslationIndex('nl', 2)).to.equal(1)
28 | })
29 |
30 | it('plural form of zero in dutch is 1', function () {
31 | expect(plurals.getTranslationIndex('nl', 0)).to.equal(1)
32 | })
33 |
34 | it('plural form of singular french is 0', function () {
35 | expect(plurals.getTranslationIndex('fr', 1)).to.equal(0)
36 | })
37 |
38 | it('plural form of plural french is 1', function () {
39 | expect(plurals.getTranslationIndex('fr', 2)).to.equal(1)
40 | })
41 |
42 | it('plural form of zero in french is 0', function () {
43 | expect(plurals.getTranslationIndex('fr', 0)).to.equal(0)
44 | })
45 |
46 | it('plural form of 27 in arabic is 4', function () {
47 | expect(plurals.getTranslationIndex('ar', 27)).to.equal(4)
48 | })
49 |
50 | it('plural form of 23 in kashubian is 1', function () {
51 | expect(plurals.getTranslationIndex('csb', 23)).to.equal(1)
52 | })
53 |
54 | })
55 |
--------------------------------------------------------------------------------
/test/specs/translate.spec.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 |
3 | import GetTextPlugin from '../../src/'
4 | import translate from '../../src/translate'
5 | import translations from './json/translate.json'
6 | import uninstallPlugin from '../testUtils'
7 |
8 |
9 | describe('Translate tests', () => {
10 |
11 | beforeEach(function () {
12 | uninstallPlugin(Vue, GetTextPlugin)
13 | Vue.use(GetTextPlugin, {
14 | availableLanguages: {
15 | en_US: 'American English',
16 | fr_FR: 'Français',
17 | },
18 | defaultLanguage: 'en_US',
19 | translations: translations,
20 | })
21 | })
22 |
23 | let translated
24 |
25 | it('tests the getTranslation() method', () => {
26 |
27 | translated = translate.getTranslation('', 1, null, 'fr_FR')
28 | expect(translated).to.equal('')
29 |
30 | translated = translate.getTranslation('Unexisting language', null, null, null, 'be_FR')
31 | expect(translated).to.equal('Unexisting language')
32 |
33 | translated = translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
34 | expect(translated).to.equal('Untranslated key')
35 |
36 | translated = translate.getTranslation('Pending', 1, null, null, 'fr_FR')
37 | expect(translated).to.equal('En cours')
38 |
39 | translated = translate.getTranslation('%{ carCount } car', 2, null, null, 'fr_FR')
40 | expect(translated).to.equal('%{ carCount } véhicules')
41 |
42 | translated = translate.getTranslation('Answer', 1, 'Verb', null, 'fr_FR')
43 | expect(translated).to.equal('Réponse (verbe)')
44 |
45 | translated = translate.getTranslation('Answer', 1, 'Noun', null, 'fr_FR')
46 | expect(translated).to.equal('Réponse (nom)')
47 |
48 | translated = translate.getTranslation('Pending', 1, null, null, 'en_US')
49 | expect(translated).to.equal('Pending')
50 |
51 | // If no translation exists, display the default singular form (if n < 2).
52 | translated = translate.getTranslation('Untranslated %{ n } item', 0, null, 'Untranslated %{ n } items', 'fr_FR')
53 | expect(translated).to.equal('Untranslated %{ n } item')
54 |
55 | // If no translation exists, display the default plural form (if n > 1).
56 | translated = translate.getTranslation('Untranslated %{ n } item', 10, null, 'Untranslated %{ n } items', 'fr_FR')
57 | expect(translated).to.equal('Untranslated %{ n } items')
58 |
59 | // Test that it works when a msgid exists with and without a context, see #32.
60 | translated = translate.getTranslation('Object', null, null, null, 'fr_FR')
61 | expect(translated).to.equal('Objet')
62 | translated = translate.getTranslation('Object', null, 'Context', null, 'fr_FR')
63 | expect(translated).to.equal('Objet avec contexte')
64 |
65 | // Ensure that pluralization is right in English when there are no English translations.
66 | translated = translate.getTranslation('Untranslated %{ n } item', 0, null, 'Untranslated %{ n } items', 'en_US')
67 | expect(translated).to.equal('Untranslated %{ n } items')
68 | translated = translate.getTranslation('Untranslated %{ n } item', 1, null, 'Untranslated %{ n } items', 'en_US')
69 | expect(translated).to.equal('Untranslated %{ n } item')
70 | translated = translate.getTranslation('Untranslated %{ n } item', 2, null, 'Untranslated %{ n } items', 'en_US')
71 | expect(translated).to.equal('Untranslated %{ n } items')
72 |
73 | // Test plural message with multiple contexts (default context and 'Context'')
74 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 1, null, null, 'en_US')
75 | expect(translated).to.equal('1 car')
76 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 2, null, null, 'en_US')
77 | expect(translated).to.equal('%{ carCount } cars')
78 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 1, 'Context', null, 'en_US')
79 | expect(translated).to.equal('1 car with context')
80 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 2, 'Context', null, 'en_US')
81 | expect(translated).to.equal('%{ carCount } cars with context')
82 |
83 | })
84 |
85 | it('tests the gettext() method', () => {
86 |
87 | let undetectableGettext = translate.gettext.bind(translate) // Hide from gettext-extract.
88 |
89 | Vue.config.language = 'fr_FR'
90 | expect(undetectableGettext('Pending')).to.equal('En cours')
91 |
92 | Vue.config.language = 'en_US'
93 | expect(undetectableGettext('Pending')).to.equal('Pending')
94 |
95 | expect(undetectableGettext('Pending', 'fr_FR')).to.equal('En cours')
96 | })
97 |
98 | it('tests the pgettext() method', () => {
99 |
100 | let undetectablePgettext = translate.pgettext.bind(translate) // Hide from gettext-extract.
101 |
102 | Vue.config.language = 'fr_FR'
103 | expect(undetectablePgettext('Noun', 'Answer')).to.equal('Réponse (nom)')
104 |
105 | Vue.config.language = 'en_US'
106 | expect(undetectablePgettext('Noun', 'Answer')).to.equal('Answer (noun)')
107 |
108 | expect(undetectablePgettext('Noun', 'Answer', 'fr_FR')).to.equal('Réponse (nom)')
109 | })
110 |
111 | it('tests the ngettext() method', () => {
112 |
113 | let undetectableNgettext = translate.ngettext.bind(translate) // Hide from gettext-extract.
114 |
115 | Vue.config.language = 'fr_FR'
116 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2)).to.equal('%{ carCount } véhicules')
117 |
118 | Vue.config.language = 'en_US'
119 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2)).to.equal('%{ carCount } cars')
120 |
121 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2, 'fr_FR')).to.equal('%{ carCount } véhicules')
122 |
123 | // If no translation exists, display the default singular form (if n < 2).
124 | Vue.config.language = 'fr_FR'
125 | expect(undetectableNgettext('Untranslated %{ n } item', 'Untranslated %{ n } items', -1))
126 | .to.equal('Untranslated %{ n } item')
127 |
128 | // If no translation exists, display the default plural form (if n > 1).
129 | Vue.config.language = 'fr_FR'
130 | expect(undetectableNgettext('Untranslated %{ n } item', 'Untranslated %{ n } items', 2))
131 | .to.equal('Untranslated %{ n } items')
132 |
133 | })
134 |
135 | it('tests the npgettext() method', () => {
136 |
137 | let undetectableNpgettext = translate.npgettext.bind(translate) // Hide from gettext-extract
138 |
139 | Vue.config.language = 'fr_FR'
140 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 2))
141 | .to.equal('%{ carCount } véhicules (nom)')
142 |
143 | Vue.config.language = 'en_US'
144 | expect(undetectableNpgettext('Verb', '%{ carCount } car (verb)', '%{ carCount } cars (verb)', 2))
145 | .to.equal('%{ carCount } cars (verb)')
146 |
147 | Vue.config.language = 'fr_FR'
148 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 1))
149 | .to.equal('%{ carCount } véhicule (nom)')
150 |
151 | Vue.config.language = 'en_US'
152 | expect(undetectableNpgettext('Verb', '%{ carCount } car (verb)', '%{ carCount } cars (verb)', 1))
153 | .to.equal('%{ carCount } car (verb)')
154 |
155 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 2, 'fr_FR'))
156 | .to.equal('%{ carCount } véhicules (nom)')
157 |
158 | // If no translation exists, display the default singular form (if n < 2).
159 | Vue.config.language = 'fr_FR'
160 | expect(undetectableNpgettext('Noun', 'Untranslated %{ n } item (noun)', 'Untranslated %{ n } items (noun)', 1))
161 | .to.equal('Untranslated %{ n } item (noun)')
162 |
163 | // If no translation exists, display the default plural form (if n > 1).
164 | Vue.config.language = 'fr_FR'
165 | expect(undetectableNpgettext('Noun', 'Untranslated %{ n } item (noun)', 'Untranslated %{ n } items (noun)', 2))
166 | .to.equal('Untranslated %{ n } items (noun)')
167 |
168 | })
169 |
170 | it('works when a msgid exists with and without a context, but the one with the context has not been translated', () => {
171 |
172 | expect(Vue.config.silent).to.equal(false)
173 | console.warn = sinon.spy(console, 'warn')
174 |
175 | translated = translate.getTranslation('May', null, null, null, 'fr_FR')
176 | expect(translated).to.equal('Pourrait')
177 |
178 | translated = translate.getTranslation('May', null, 'Month name', null, 'fr_FR')
179 | expect(translated).to.equal('May')
180 |
181 | expect(console.warn).calledOnce
182 | expect(console.warn).calledWith('Untranslated fr_FR key found: May (with context: Month name)')
183 |
184 | console.warn.restore()
185 |
186 | })
187 |
188 | })
189 |
190 | describe('Translate tests without Vue', () => {
191 | let config
192 |
193 | beforeEach(function () {
194 | config = {
195 | language: 'en_US',
196 | getTextPluginSilent: false,
197 | getTextPluginMuteLanguages: [],
198 | silent: false,
199 | }
200 | translate.initTranslations(translations, config)
201 | })
202 |
203 | let translated
204 |
205 | it('tests the getTranslation() method', () => {
206 |
207 | translated = translate.getTranslation('', 1, null, 'fr_FR')
208 | expect(translated).to.equal('')
209 |
210 | translated = translate.getTranslation('Unexisting language', null, null, null, 'be_FR')
211 | expect(translated).to.equal('Unexisting language')
212 |
213 | translated = translate.getTranslation('Untranslated key', null, null, null, 'fr_FR')
214 | expect(translated).to.equal('Untranslated key')
215 |
216 | translated = translate.getTranslation('Pending', 1, null, null, 'fr_FR')
217 | expect(translated).to.equal('En cours')
218 |
219 | translated = translate.getTranslation('%{ carCount } car', 2, null, null, 'fr_FR')
220 | expect(translated).to.equal('%{ carCount } véhicules')
221 |
222 | translated = translate.getTranslation('Answer', 1, 'Verb', null, 'fr_FR')
223 | expect(translated).to.equal('Réponse (verbe)')
224 |
225 | translated = translate.getTranslation('Answer', 1, 'Noun', null, 'fr_FR')
226 | expect(translated).to.equal('Réponse (nom)')
227 |
228 | translated = translate.getTranslation('Pending', 1, null, null, 'en_US')
229 | expect(translated).to.equal('Pending')
230 |
231 | // If no translation exists, display the default singular form (if n < 2).
232 | translated = translate.getTranslation('Untranslated %{ n } item', 0, null, 'Untranslated %{ n } items', 'fr_FR')
233 | expect(translated).to.equal('Untranslated %{ n } item')
234 |
235 | // If no translation exists, display the default plural form (if n > 1).
236 | translated = translate.getTranslation('Untranslated %{ n } item', 10, null, 'Untranslated %{ n } items', 'fr_FR')
237 | expect(translated).to.equal('Untranslated %{ n } items')
238 |
239 | // Test that it works when a msgid exists with and without a context, see #32.
240 | translated = translate.getTranslation('Object', null, null, null, 'fr_FR')
241 | expect(translated).to.equal('Objet')
242 | translated = translate.getTranslation('Object', null, 'Context', null, 'fr_FR')
243 | expect(translated).to.equal('Objet avec contexte')
244 |
245 | // Ensure that pluralization is right in English when there are no English translations.
246 | translated = translate.getTranslation('Untranslated %{ n } item', 0, null, 'Untranslated %{ n } items', 'en_US')
247 | expect(translated).to.equal('Untranslated %{ n } items')
248 | translated = translate.getTranslation('Untranslated %{ n } item', 1, null, 'Untranslated %{ n } items', 'en_US')
249 | expect(translated).to.equal('Untranslated %{ n } item')
250 | translated = translate.getTranslation('Untranslated %{ n } item', 2, null, 'Untranslated %{ n } items', 'en_US')
251 | expect(translated).to.equal('Untranslated %{ n } items')
252 |
253 | // Test plural message with multiple contexts (default context and 'Context'')
254 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 1, null, null, 'en_US')
255 | expect(translated).to.equal('1 car')
256 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 2, null, null, 'en_US')
257 | expect(translated).to.equal('%{ carCount } cars')
258 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 1, 'Context', null, 'en_US')
259 | expect(translated).to.equal('1 car with context')
260 | translated = translate.getTranslation('%{ carCount } car (multiple contexts)', 2, 'Context', null, 'en_US')
261 | expect(translated).to.equal('%{ carCount } cars with context')
262 |
263 | })
264 |
265 | it('tests the gettext() method', () => {
266 |
267 | let undetectableGettext = translate.gettext.bind(translate) // Hide from gettext-extract.
268 |
269 | config.language = 'fr_FR'
270 | expect(undetectableGettext('Pending')).to.equal('En cours')
271 |
272 | config.language = 'en_US'
273 | expect(undetectableGettext('Pending')).to.equal('Pending')
274 |
275 | expect(undetectableGettext('Pending', 'fr_FR')).to.equal('En cours')
276 | })
277 |
278 | it('tests the pgettext() method', () => {
279 |
280 | let undetectablePgettext = translate.pgettext.bind(translate) // Hide from gettext-extract.
281 |
282 | config.language = 'fr_FR'
283 | expect(undetectablePgettext('Noun', 'Answer')).to.equal('Réponse (nom)')
284 |
285 | config.language = 'en_US'
286 | expect(undetectablePgettext('Noun', 'Answer')).to.equal('Answer (noun)')
287 |
288 | expect(undetectablePgettext('Noun', 'Answer', 'fr_FR')).to.equal('Réponse (nom)')
289 | })
290 |
291 | it('tests the ngettext() method', () => {
292 |
293 | let undetectableNgettext = translate.ngettext.bind(translate) // Hide from gettext-extract.
294 |
295 | config.language = 'fr_FR'
296 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2)).to.equal('%{ carCount } véhicules')
297 |
298 | config.language = 'en_US'
299 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2)).to.equal('%{ carCount } cars')
300 |
301 | expect(undetectableNgettext('%{ carCount } car', '%{ carCount } cars', 2, 'fr_FR')).to.equal('%{ carCount } véhicules')
302 |
303 | // If no translation exists, display the default singular form (if n < 2).
304 | config.language = 'fr_FR'
305 | expect(undetectableNgettext('Untranslated %{ n } item', 'Untranslated %{ n } items', -1))
306 | .to.equal('Untranslated %{ n } item')
307 |
308 | // If no translation exists, display the default plural form (if n > 1).
309 | config.language = 'fr_FR'
310 | expect(undetectableNgettext('Untranslated %{ n } item', 'Untranslated %{ n } items', 2))
311 | .to.equal('Untranslated %{ n } items')
312 |
313 | })
314 |
315 | it('tests the npgettext() method', () => {
316 |
317 | let undetectableNpgettext = translate.npgettext.bind(translate) // Hide from gettext-extract
318 |
319 | config.language = 'fr_FR'
320 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 2))
321 | .to.equal('%{ carCount } véhicules (nom)')
322 |
323 | config.language = 'en_US'
324 | expect(undetectableNpgettext('Verb', '%{ carCount } car (verb)', '%{ carCount } cars (verb)', 2))
325 | .to.equal('%{ carCount } cars (verb)')
326 |
327 | config.language = 'fr_FR'
328 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 1))
329 | .to.equal('%{ carCount } véhicule (nom)')
330 |
331 | config.language = 'en_US'
332 | expect(undetectableNpgettext('Verb', '%{ carCount } car (verb)', '%{ carCount } cars (verb)', 1))
333 | .to.equal('%{ carCount } car (verb)')
334 |
335 | expect(undetectableNpgettext('Noun', '%{ carCount } car (noun)', '%{ carCount } cars (noun)', 1, 'fr_FR'))
336 | .to.equal('%{ carCount } véhicule (nom)')
337 |
338 | // If no translation exists, display the default singular form (if n < 2).
339 | config.language = 'fr_FR'
340 | expect(undetectableNpgettext('Noun', 'Untranslated %{ n } item (noun)', 'Untranslated %{ n } items (noun)', 1))
341 | .to.equal('Untranslated %{ n } item (noun)')
342 |
343 | // If no translation exists, display the default plural form (if n > 1).
344 | config.language = 'fr_FR'
345 | expect(undetectableNpgettext('Noun', 'Untranslated %{ n } item (noun)', 'Untranslated %{ n } items (noun)', 2))
346 | .to.equal('Untranslated %{ n } items (noun)')
347 |
348 | })
349 |
350 | it('works when a msgid exists with and without a context, but the one with the context has not been translated', () => {
351 |
352 | expect(config.silent).to.equal(false)
353 | console.warn = sinon.spy(console, 'warn')
354 |
355 | translated = translate.getTranslation('May', null, null, null, 'fr_FR')
356 | expect(translated).to.equal('Pourrait')
357 |
358 | translated = translate.getTranslation('May', null, 'Month name', null, 'fr_FR')
359 | expect(translated).to.equal('May')
360 |
361 | expect(console.warn).calledOnce
362 | expect(console.warn).calledWith('Untranslated fr_FR key found: May (with context: Month name)')
363 |
364 | console.warn.restore()
365 |
366 | })
367 |
368 | })
369 |
--------------------------------------------------------------------------------
/test/testUtils.js:
--------------------------------------------------------------------------------
1 | // Provide a way to uninstall the GetTextPlugin between each unit test.
2 |
3 | let uninstallPlugin = function (Vue, Plugin) {
4 | if (Vue.hasOwnProperty('_installedPlugins')) {
5 | // The way to do this has changed over time, see:
6 | // https://github.com/vuejs/vue/commit/049f31#diff-df137982016aef85f3594216a4c9a295
7 | Vue._installedPlugins = []
8 | } else {
9 | // Could also be `._installed` for some Vue versions
10 | // https://github.com/vuejs/vue/commit/b4dd0b#diff-df137982016aef85f3594216a4c9a295
11 | Plugin.installed = false
12 | }
13 | }
14 |
15 | export default uninstallPlugin
16 |
--------------------------------------------------------------------------------
/types/index.d.ts:
--------------------------------------------------------------------------------
1 | import VueGettext from './vue-gettext';
2 |
3 | export default VueGettext;
4 |
5 | export * from './vue';
6 | export * from './vue-gettext';
7 |
--------------------------------------------------------------------------------
/types/vue-gettext.d.ts:
--------------------------------------------------------------------------------
1 | import Vue, { ComponentOptions, VueConstructor} from 'vue';
2 |
3 | interface IVueGettextOptions {
4 | availableLanguages: {
5 | [key: string]: string;
6 | };
7 | defaultLanguage: string;
8 | languageVmMixin: ComponentOptions | typeof Vue;
9 | muteLanguages: string[];
10 | silent: boolean;
11 | translations: object;
12 | }
13 |
14 | export class VueGettext {
15 | constructor(Vue: VueConstructor, options?: IVueGettextOptions);
16 | }
17 |
18 | export function install(vue: typeof Vue): void;
19 |
20 | declare const _default: {
21 | VueGettext: typeof VueGettext,
22 | install: typeof install,
23 | };
24 |
25 | export default _default;
26 |
--------------------------------------------------------------------------------
/types/vue.d.ts:
--------------------------------------------------------------------------------
1 | import Vue, { VueConfiguration } from 'vue/types/vue';
2 |
3 | declare module 'vue/types/vue' {
4 | interface ILanguageComponent extends Vue {
5 | available: {
6 | [key: string]: string;
7 | };
8 | current: string;
9 | }
10 |
11 | interface Vue {
12 | $translations: object;
13 | $language: ILanguageComponent;
14 | $gettext: (msgid: string) => string;
15 | $pgettext: (context: string, msgid: string) => string;
16 | $ngettext: (msgid: string, plural: string, n: number) => string;
17 | $npgettext: (context: string, msgid: string, plural: string, n: number) => string;
18 | $gettextInterpolate: (msgid: string, context: object, disableHtmlEscaping?: boolean) => string;
19 | }
20 |
21 | interface VueConfiguration {
22 | language: string;
23 | }
24 | }
25 |
--------------------------------------------------------------------------------