#11410

Committed 18 Aug 2017 09:06AM UTC coverage: 83.851% (-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.

675 of 805 relevant lines covered (83.85%)

34.36 hits per line

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

94.59

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

i18next / i18next / #11410

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