#13867

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

6 existing lines in 1 file now uncovered.

691 of 823 relevant lines covered (83.96%)

35.66 hits per line

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

93.48

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

i18next / i18next / #13867

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