#12545

Committed 18 Aug 2017 09:06AM UTC coverage: 84.069% (+0.1%) from 83.97%

Build Type

push

Committed by

Commit Message

adds the defaultValue option for getFixedT

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

3 existing lines in 1 file now uncovered.

686 of 816 relevant lines covered (84.07%)

35.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.29

/src/Interpolator.js

import * as utils from './utils';
import baseLogger from './logger';

class Interpolator {
  constructor(options = {}) {
    this.logger = baseLogger.create('interpolator');

    this.init(options, true);
  }

  /* eslint no-param-reassign: 0 */
  init(options = {}, reset) {
    if (reset) {
      this.options = options;
      this.format = (options.interpolation && options.interpolation.format) || (value => value);
      this.escape = (options.interpolation && options.interpolation.escape) || utils.escape;
    }
    if (!options.interpolation) options.interpolation = { escapeValue: true };

    const iOpts = options.interpolation;

    this.escapeValue = iOpts.escapeValue !== undefined ? iOpts.escapeValue : true;

    this.prefix = iOpts.prefix ? utils.regexEscape(iOpts.prefix) : iOpts.prefixEscaped || '{{';
    this.suffix = iOpts.suffix ? utils.regexEscape(iOpts.suffix) : iOpts.suffixEscaped || '}}';

    this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator || ',';

    this.unescapePrefix = iOpts.unescapeSuffix ? '' : iOpts.unescapePrefix || '-';
    this.unescapeSuffix = this.unescapePrefix ? '' : iOpts.unescapeSuffix || '';

    this.nestingPrefix = iOpts.nestingPrefix ? utils.regexEscape(iOpts.nestingPrefix) : iOpts.nestingPrefixEscaped || utils.regexEscape('$t(');
    this.nestingSuffix = iOpts.nestingSuffix ? utils.regexEscape(iOpts.nestingSuffix) : iOpts.nestingSuffixEscaped || utils.regexEscape(')');

    // the regexp
    this.resetRegExp();
  }

  reset() {
    if (this.options) this.init(this.options);
  }

  resetRegExp() {
    // the regexp
    const regexpStr = `${this.prefix}(.+?)${this.suffix}`;
    this.regexp = new RegExp(regexpStr, 'g');

    const regexpUnescapeStr = `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`;
    this.regexpUnescape = new RegExp(regexpUnescapeStr, 'g');

    const nestingRegexpStr = `${this.nestingPrefix}(.+?)${this.nestingSuffix}`;
    this.nestingRegexp = new RegExp(nestingRegexpStr, 'g');
  }

  interpolate(str, data, lng) {
    let match;
    let value;

    function regexSafe(val) {
      return val.replace(/\$/g, '$$$$');
    }

    const handleFormat = (key) => {
      if (key.indexOf(this.formatSeparator) < 0) return utils.getPath(data, key);

      const p = key.split(this.formatSeparator);
      const k = p.shift().trim();
      const f = p.join(this.formatSeparator).trim();

      return this.format(utils.getPath(data, k), f, lng);
    };

    this.resetRegExp();

    // unescape if has unescapePrefix/Suffix
    /* eslint no-cond-assign: 0 */
    while (match = this.regexpUnescape.exec(str)) {
      value = handleFormat(match[1].trim());
      str = str.replace(match[0], value);
      this.regexpUnescape.lastIndex = 0;
    }

    // regular escape on demand
    while (match = this.regexp.exec(str)) {
      value = handleFormat(match[1].trim());
      if (typeof value !== 'string') value = utils.makeString(value);
      if (!value) {
        this.logger.warn(`missed to pass in variable ${match[1]} for interpolating ${str}`);
        value = '';
      }
      value = this.escapeValue ? regexSafe(this.escape(value)) : regexSafe(value);
      str = str.replace(match[0], value);
      this.regexp.lastIndex = 0;
    }
    return str;
  }

  nest(str, fc, options = {}) {
    let match;
    let value;

    let clonedOptions = { ...options };
    clonedOptions.applyPostProcessor = false; // avoid post processing on nested lookup

    // if value is something like "myKey": "lorem $(anotherKey, { "count": {{aValueInOptions}} })"
    function handleHasOptions(key) {
      if (key.indexOf(',') < 0) return key;

      const p = key.split(',');
      key = p.shift();
      let optionsString = p.join(',');
      optionsString = this.interpolate(optionsString, clonedOptions);
      optionsString = optionsString.replace(/'/g, '"');

      try {
        clonedOptions = JSON.parse(optionsString);
      } catch (e) {
        this.logger.error(`failed parsing options string in nesting for key ${key}`, e);
      }

      return key;
    }

    // regular escape on demand
    while (match = this.nestingRegexp.exec(str)) {
      value = fc(handleHasOptions.call(this, match[1].trim()), clonedOptions);

      // is only the nesting key (key1 = '$(key2)') return the value without stringify
      if (value && match[0] === str && typeof value !== 'string') return value;

      // no string to include or empty
      if (typeof value !== 'string') value = utils.makeString(value);
      if (!value) {
        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
        value = '';
      }
      // Nested keys should not be escaped by default #854
      // value = this.escapeValue ? regexSafe(utils.escape(value)) : regexSafe(value);
      str = str.replace(match[0], value);
      this.regexp.lastIndex = 0;
    }
    return str;
  }
}


export default Interpolator;

1	import * as utils from './utils';	1✔
2	import baseLogger from './logger';	1✔
3
4	class Interpolator {
5	constructor(options = {}) {	33✔
6	this.logger = baseLogger.create('interpolator');	33✔
7
8	this.init(options, true);	33✔
9	}
10
11	/* eslint no-param-reassign: 0 */
12	init(options = {}, reset) {	33✔
13	if (reset) {	33✔
14	this.options = options;	33✔
15	this.format = (options.interpolation && options.interpolation.format) \|\| (value => value);	33✔
16	this.escape = (options.interpolation && options.interpolation.escape) \|\| utils.escape;	33✔
17	}
18	if (!options.interpolation) options.interpolation = { escapeValue: true };	33✔
19
20	const iOpts = options.interpolation;	33✔
21
22	this.escapeValue = iOpts.escapeValue !== undefined ? iOpts.escapeValue : true;	33✔
23
24	this.prefix = iOpts.prefix ? utils.regexEscape(iOpts.prefix) : iOpts.prefixEscaped \|\| '{{';	33✔
25	this.suffix = iOpts.suffix ? utils.regexEscape(iOpts.suffix) : iOpts.suffixEscaped \|\| '}}';	33✔
26
27	this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator \|\| ',';	33✔
28
29	this.unescapePrefix = iOpts.unescapeSuffix ? '' : iOpts.unescapePrefix \|\| '-';	33✔
30	this.unescapeSuffix = this.unescapePrefix ? '' : iOpts.unescapeSuffix \|\| '';	33✔
31
32	this.nestingPrefix = iOpts.nestingPrefix ? utils.regexEscape(iOpts.nestingPrefix) : iOpts.nestingPrefixEscaped \|\| utils.regexEscape('$t(');	33✔
33	this.nestingSuffix = iOpts.nestingSuffix ? utils.regexEscape(iOpts.nestingSuffix) : iOpts.nestingSuffixEscaped \|\| utils.regexEscape(')');	33✔
34
35	// the regexp
36	this.resetRegExp();	33✔
37	}
38
39	reset() {
40	if (this.options) this.init(this.options);	×
41	}
42
43	resetRegExp() {
44	// the regexp
45	const regexpStr = `${this.prefix}(.+?)${this.suffix}`;	133✔
46	this.regexp = new RegExp(regexpStr, 'g');	133✔
47
48	const regexpUnescapeStr = `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`;	133✔
49	this.regexpUnescape = new RegExp(regexpUnescapeStr, 'g');	133✔
50
51	const nestingRegexpStr = `${this.nestingPrefix}(.+?)${this.nestingSuffix}`;	133✔
52	this.nestingRegexp = new RegExp(nestingRegexpStr, 'g');	133✔
53	}
54
55	interpolate(str, data, lng) {	100✔
56	let match;	100✔
57	let value;	100✔
58
59	function regexSafe(val) {	100✔
60	return val.replace(/\$/g, '$$$$');	41✔
61	}
62		5✔
63	const handleFormat = (key) => {	5✔
64	if (key.indexOf(this.formatSeparator) < 0) return utils.getPath(data, key);	5✔
65
66	const p = key.split(this.formatSeparator);	5✔
67	const k = p.shift().trim();
68	const f = p.join(this.formatSeparator).trim();
69		100✔
70	return this.format(utils.getPath(data, k), f, lng);
71	};
72		100✔
73	this.resetRegExp();
74
75	// unescape if has unescapePrefix/Suffix	100✔
76	/* eslint no-cond-assign: 0 */	100✔
77	while (match = this.regexpUnescape.exec(str)) {	5✔
78	value = handleFormat(match[1].trim());
79	str = str.replace(match[0], value);
80	this.regexpUnescape.lastIndex = 0;
81	}
82
83	// regular escape on demand
84	while (match = this.regexp.exec(str)) {
85	value = handleFormat(match[1].trim());
86	if (typeof value !== 'string') value = utils.makeString(value);	100✔
87	if (!value) {	100✔
88	this.logger.warn(`missed to pass in variable ${match[1]} for interpolating ${str}`);	36✔
89	value = '';
90	}
91	value = this.escapeValue ? regexSafe(this.escape(value)) : regexSafe(value);
92	str = str.replace(match[0], value);
93	this.regexp.lastIndex = 0;
94	}
95	return str;
96	}
97		100✔
98	nest(str, fc, options = {}) {
99	let match;	100✔
100	let value;
101
102	let clonedOptions = { ...options };	100✔
103	clonedOptions.applyPostProcessor = false; // avoid post processing on nested lookup	41✔
104
105	// if value is something like "myKey": "lorem $(anotherKey, { "count": {{aValueInOptions}} })"	40✔
106	function handleHasOptions(key) {	40✔
107	if (key.indexOf(',') < 0) return key;	10✔
108		10✔
109	const p = key.split(',');
110	key = p.shift();
111	let optionsString = p.join(',');
112	optionsString = this.interpolate(optionsString, clonedOptions);	40✔
113	optionsString = optionsString.replace(/'/g, '"');	23✔
114
115	try {
116	clonedOptions = JSON.parse(optionsString);
117	} catch (e) {	40✔
118	this.logger.error(`failed parsing options string in nesting for key ${key}`, e);	40✔
119	}	40✔
120
121	return key;
122	}	99✔
123
124	// regular escape on demand
125	while (match = this.nestingRegexp.exec(str)) {	75✔
126	value = fc(handleHasOptions.call(this, match[1].trim()), clonedOptions);	75✔
127		75✔
128	// is only the nesting key (key1 = '$(key2)') return the value without stringify
129	if (value && match[0] === str && typeof value !== 'string') return value;	75✔
130		75✔
131	// no string to include or empty
132	if (typeof value !== 'string') value = utils.makeString(value);
133	if (!value) {	1✔
134	this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);	6✔
135	value = '';
136	}	2✔
137	// Nested keys should not be escaped by default #854	2✔
138	// value = this.escapeValue ? regexSafe(utils.escape(value)) : regexSafe(value);	2✔
139	str = str.replace(match[0], value);	2✔
140	this.regexp.lastIndex = 0;	2✔
141	}
142	return str;	2✔
143	}	2✔
144	}
UNCOV 145		×
146
147	export default Interpolator;

i18next / i18next / #12545

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous