markdown-it / markdown-it / 583

pending completion

Build # 583

Build Type

Pull #276

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/markdown-it/markdown-it/commit/1ea9be8d5">fence renderer: fix concat of class array

Before:

  &lt;pre c=&quot;l&quot;&gt;&lt;code&gt;...

Now:

  &lt;pre class=&quot;someClass language-python&gt;&lt;code&gt;...

Bug introduced in </a><a class="double-link" href="https://github.com/markdown-it/markdown-it/commit/b7c868b64">b7c868b64</a>

Pull Request Pull Request #276: fence renderer: fix concat of class array

Run Details

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

2038 of 2040 relevant lines covered (99.9%)

1594.45 hits per line

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

98.99

/lib/renderer.js

/**
 * class Renderer
 *
 * Generates HTML from parsed token stream. Each instance has independent
 * copy of rules. Those can be rewritten with ease. Also, you can add new
 * rules if you create plugin and adds new token types.
 **/
'use strict';


var assign          = require('./common/utils').assign;
var unescapeAll     = require('./common/utils').unescapeAll;
var escapeHtml      = require('./common/utils').escapeHtml;


////////////////////////////////////////////////////////////////////////////////

var default_rules = {};


default_rules.code_inline = function (tokens, idx, options, env, slf) {
  var token = tokens[idx],
      attrs = slf.renderAttrs(token);

  return  '<code' + (attrs ? ' ' + attrs : '') + '>' +
          escapeHtml(tokens[idx].content) +
          '</code>';
};


default_rules.code_block = function (tokens, idx, options, env, slf) {
  var token = tokens[idx],
      attrs = slf.renderAttrs(token);

  return  '<pre' + (attrs ? ' ' + attrs : '') + '><code>' +
          escapeHtml(tokens[idx].content) +
          '</code></pre>\n';
};


default_rules.fence = function (tokens, idx, options, env, slf) {
  var token = tokens[idx],
      info = token.info ? unescapeAll(token.info).trim() : '',
      langName = '',
      highlighted, i, tmpAttrs, tmpToken;

  if (info) {
    langName = info.split(/\s+/g)[0];
  }

  if (options.highlight) {
    highlighted = options.highlight(token.content, langName) || escapeHtml(token.content);
  } else {
    highlighted = escapeHtml(token.content);
  }

  if (highlighted.indexOf('<pre') === 0) {
    return highlighted + '\n';
  }

  // If language exists, inject class gently, without mudofying original token.
  // May be, one day we will add .clone() for token and simplify this part, but
  // now we prefer to keep things local.
  if (info) {
    i        = token.attrIndex('class');
    tmpAttrs = token.attrs ? token.attrs.slice() : [];

    if (i < 0) {
      tmpAttrs.push([ 'class', options.langPrefix + langName ]);
    } else {
      tmpAttrs[i][1] += ' ' + options.langPrefix + langName;
    }

    // Fake token just to render attributes
    tmpToken = {
      attrs: tmpAttrs
    };

    return  '<pre><code' + slf.renderAttrs(tmpToken) + '>'
          + highlighted
          + '</code></pre>\n';
  }


  return  '<pre><code' + slf.renderAttrs(token) + '>'
        + highlighted
        + '</code></pre>\n';
};


default_rules.image = function (tokens, idx, options, env, slf) {
  var token = tokens[idx];

  // "alt" attr MUST be set, even if empty. Because it's mandatory and
  // should be placed on proper position for tests.
  //
  // Replace content with actual value

  token.attrs[token.attrIndex('alt')][1] =
    slf.renderInlineAsText(token.children, options, env);

  return slf.renderToken(tokens, idx, options);
};


default_rules.hardbreak = function (tokens, idx, options /*, env */) {
  return options.xhtmlOut ? '<br />\n' : '<br>\n';
};
default_rules.softbreak = function (tokens, idx, options /*, env */) {
  return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n';
};


default_rules.text = function (tokens, idx /*, options, env */) {
  return escapeHtml(tokens[idx].content);
};


default_rules.html_block = function (tokens, idx /*, options, env */) {
  return tokens[idx].content;
};
default_rules.html_inline = function (tokens, idx /*, options, env */) {
  return tokens[idx].content;
};


/**
 * new Renderer()
 *
 * Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
 **/
function Renderer() {

  /**
   * Renderer#rules -> Object
   *
   * Contains render rules for tokens. Can be updated and extended.
   *
   * ##### Example
   *
   * ```javascript
   * var md = require('markdown-it')();
   *
   * md.renderer.rules.strong_open  = function () { return '<b>'; };
   * md.renderer.rules.strong_close = function () { return '</b>'; };
   *
   * var result = md.renderInline(...);
   * ```
   *
   * Each rule is called as independed static function with fixed signature:
   *
   * ```javascript
   * function my_token_render(tokens, idx, options, env, renderer) {
   *   // ...
   *   return renderedHTML;
   * }
   * ```
   *
   * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
   * for more details and examples.
   **/
  this.rules = assign({}, default_rules);
}


/**
 * Renderer.renderAttrs(token) -> String
 *
 * Render token attributes to string.
 **/
Renderer.prototype.renderAttrs = function renderAttrs(token) {
  var i, l, result;

  if (!token.attrs) { return ''; }

  result = '';

  for (i = 0, l = token.attrs.length; i < l; i++) {
    result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';
  }

  return result;
};


/**
 * Renderer.renderToken(tokens, idx, options) -> String
 * - tokens (Array): list of tokens
 * - idx (Numbed): token index to render
 * - options (Object): params of parser instance
 *
 * Default token renderer. Can be overriden by custom function
 * in [[Renderer#rules]].
 **/
Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {
  var nextToken,
      result = '',
      needLf = false,
      token = tokens[idx];

  // Tight list paragraphs
  if (token.hidden) {
    return '';
  }

  // Insert a newline between hidden paragraph and subsequent opening
  // block-level tag.
  //
  // For example, here we should insert a newline before blockquote:
  //  - a
  //    >
  //
  if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {
    result += '\n';
  }

  // Add token name, e.g. `<img`
  result += (token.nesting === -1 ? '</' : '<') + token.tag;

  // Encode attributes, e.g. `<img src="foo"`
  result += this.renderAttrs(token);

  // Add a slash for self-closing tags, e.g. `<img src="foo" /`
  if (token.nesting === 0 && options.xhtmlOut) {
    result += ' /';
  }

  // Check if we need to add a newline after this tag
  if (token.block) {
    needLf = true;

    if (token.nesting === 1) {
      if (idx + 1 < tokens.length) {
        nextToken = tokens[idx + 1];

        if (nextToken.type === 'inline' || nextToken.hidden) {
          // Block-level tag containing an inline tag.
          //
          needLf = false;

        } else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {
          // Opening tag + closing tag of the same type. E.g. `<li></li>`.
          //
          needLf = false;
        }
      }
    }
  }

  result += needLf ? '>\n' : '>';

  return result;
};


/**
 * Renderer.renderInline(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * The same as [[Renderer.render]], but for single token of `inline` type.
 **/
Renderer.prototype.renderInline = function (tokens, options, env) {
  var type,
      result = '',
      rules = this.rules;

  for (var i = 0, len = tokens.length; i < len; i++) {
    type = tokens[i].type;

    if (typeof rules[type] !== 'undefined') {
      result += rules[type](tokens, i, options, env, this);
    } else {
      result += this.renderToken(tokens, i, options);
    }
  }

  return result;
};


/** internal
 * Renderer.renderInlineAsText(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * Special kludge for image `alt` attributes to conform CommonMark spec.
 * Don't try to use it! Spec requires to show `alt` content with stripped markup,
 * instead of simple escaping.
 **/
Renderer.prototype.renderInlineAsText = function (tokens, options, env) {
  var result = '';

  for (var i = 0, len = tokens.length; i < len; i++) {
    if (tokens[i].type === 'text') {
      result += tokens[i].content;
    } else if (tokens[i].type === 'image') {
      result += this.renderInlineAsText(tokens[i].children, options, env);
    }
  }

  return result;
};


/**
 * Renderer.render(tokens, options, env) -> String
 * - tokens (Array): list on block tokens to renter
 * - options (Object): params of parser instance
 * - env (Object): additional data from parsed input (references, for example)
 *
 * Takes token stream and generates HTML. Probably, you will never need to call
 * this method directly.
 **/
Renderer.prototype.render = function (tokens, options, env) {
  var i, len, type,
      result = '',
      rules = this.rules;

  for (i = 0, len = tokens.length; i < len; i++) {
    type = tokens[i].type;

    if (type === 'inline') {
      result += this.renderInline(tokens[i].children, options, env);
    } else if (typeof rules[type] !== 'undefined') {
      result += rules[tokens[i].type](tokens, i, options, env, this);
    } else {
      result += this.renderToken(tokens, i, options, env);
    }
  }

  return result;
};

module.exports = Renderer;

1	/**
2	* class Renderer
3	*
4	* Generates HTML from parsed token stream. Each instance has independent
5	* copy of rules. Those can be rewritten with ease. Also, you can add new
6	* rules if you create plugin and adds new token types.
7	**/
8	'use strict';
9
10
11	var assign = require('./common/utils').assign;	4✔
12	var unescapeAll = require('./common/utils').unescapeAll;	4✔
13	var escapeHtml = require('./common/utils').escapeHtml;	4✔
14
15
16	////////////////////////////////////////////////////////////////////////////////
17
18	var default_rules = {};	4✔
19
20
21	default_rules.code_inline = function (tokens, idx, options, env, slf) {	4✔
22	var token = tokens[idx],	108✔
23	attrs = slf.renderAttrs(token);
24
25	return '<code' + (attrs ? ' ' + attrs : '') + '>' +	108✔
26	escapeHtml(tokens[idx].content) +
27	'</code>';
28	};
29
30
31	default_rules.code_block = function (tokens, idx, options, env, slf) {	4✔
32	var token = tokens[idx],	220✔
33	attrs = slf.renderAttrs(token);
34
35	return '<pre' + (attrs ? ' ' + attrs : '') + '><code>' +	220✔
36	escapeHtml(tokens[idx].content) +
37	'</code></pre>\n';
38	};
39
40
41	default_rules.fence = function (tokens, idx, options, env, slf) {	4✔
42	var token = tokens[idx],	184✔
43	info = token.info ? unescapeAll(token.info).trim() : '',
44	langName = '',
45	highlighted, i, tmpAttrs, tmpToken;
46
47	if (info) {	184✔
48	langName = info.split(/\s+/g)[0];	32✔
49	}
50
51	if (options.highlight) {	184✔
52	highlighted = options.highlight(token.content, langName) \|\| escapeHtml(token.content);	8✔
53	} else {
54	highlighted = escapeHtml(token.content);	176✔
55	}
56
57	if (highlighted.indexOf('<pre') === 0) {	184✔
58	return highlighted + '\n';	4✔
59	}
60
61	// If language exists, inject class gently, without mudofying original token.
62	// May be, one day we will add .clone() for token and simplify this part, but
63	// now we prefer to keep things local.
64	if (info) {	180✔
65	i = token.attrIndex('class');	32✔
66	tmpAttrs = token.attrs ? token.attrs.slice() : [];	32✔
67
68	if (i < 0) {	32✔
69	tmpAttrs.push([ 'class', options.langPrefix + langName ]);	32✔
70	} else {
71	tmpAttrs[i][1] += ' ' + options.langPrefix + langName;	×
72	}
73
74	// Fake token just to render attributes
75	tmpToken = {	32✔
76	attrs: tmpAttrs
77	};
78
79	return '<pre><code' + slf.renderAttrs(tmpToken) + '>'	32✔
80	+ highlighted
81	+ '</code></pre>\n';
82	}
83
84
85	return '<pre><code' + slf.renderAttrs(token) + '>'	148✔
86	+ highlighted
87	+ '</code></pre>\n';
88	};
89
90
91	default_rules.image = function (tokens, idx, options, env, slf) {	4✔
92	var token = tokens[idx];	116✔
93
94	// "alt" attr MUST be set, even if empty. Because it's mandatory and
95	// should be placed on proper position for tests.
96	//
97	// Replace content with actual value
98
99	token.attrs[token.attrIndex('alt')][1] =	116✔
100	slf.renderInlineAsText(token.children, options, env);
101
102	return slf.renderToken(tokens, idx, options);	116✔
103	};
104
105
106	default_rules.hardbreak = function (tokens, idx, options /, env /) {	4✔
107	return options.xhtmlOut ? '<br />\n' : '<br>\n';	44✔
108	};
109	default_rules.softbreak = function (tokens, idx, options /, env /) {	4✔
110	return options.breaks ? (options.xhtmlOut ? '<br />\n' : '<br>\n') : '\n';	396✔
111	};
112
113
114	default_rules.text = function (tokens, idx /, options, env /) {	4✔
115	return escapeHtml(tokens[idx].content);	5,004✔
116	};
117
118
119	default_rules.html_block = function (tokens, idx /, options, env /) {	4✔
120	return tokens[idx].content;	212✔
121	};
122	default_rules.html_inline = function (tokens, idx /, options, env /) {	4✔
123	return tokens[idx].content;	128✔
124	};
125
126
127	/**
128	* new Renderer()
129	*
130	* Creates new [[Renderer]] instance and fill [[Renderer#rules]] with defaults.
131	**/
132	function Renderer() {	4✔
133
134	/**
135	* Renderer#rules -> Object
136	*
137	* Contains render rules for tokens. Can be updated and extended.
138	*
139	* ##### Example
140	*
141	* ```javascript
142	* var md = require('markdown-it')();
143	*
144	* md.renderer.rules.strong_open = function () { return '<b>'; };
145	* md.renderer.rules.strong_close = function () { return '</b>'; };
146	*
147	* var result = md.renderInline(...);
148	* ```
149	*
150	* Each rule is called as independed static function with fixed signature:
151	*
152	* ```javascript
153	* function my_token_render(tokens, idx, options, env, renderer) {
154	* // ...
155	* return renderedHTML;
156	* }
157	* ```
158	*
159	* See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js)
160	* for more details and examples.
161	**/
162	this.rules = assign({}, default_rules);	132✔
163	}
164
165
166	/**
167	* Renderer.renderAttrs(token) -> String
168	*
169	* Render token attributes to string.
170	**/
171	Renderer.prototype.renderAttrs = function renderAttrs(token) {	4✔
172	var i, l, result;	14,032✔
173
174	if (!token.attrs) { return ''; }	14,032✔
175
176	result = '';	952✔
177
178	for (i = 0, l = token.attrs.length; i < l; i++) {	952✔
179	result += ' ' + escapeHtml(token.attrs[i][0]) + '="' + escapeHtml(token.attrs[i][1]) + '"';	1,268✔
180	}
181
182	return result;	952✔
183	};
184
185
186	/**
187	* Renderer.renderToken(tokens, idx, options) -> String
188	* - tokens (Array): list of tokens
189	* - idx (Numbed): token index to render
190	* - options (Object): params of parser instance
191	*
192	* Default token renderer. Can be overriden by custom function
193	* in [[Renderer#rules]].
194	**/
195	Renderer.prototype.renderToken = function renderToken(tokens, idx, options) {	4✔
196	var nextToken,	14,276✔
197	result = '',
198	needLf = false,
199	token = tokens[idx];
200
201	// Tight list paragraphs
202	if (token.hidden) {	14,276✔
203	return '';	752✔
204	}
205
206	// Insert a newline between hidden paragraph and subsequent opening
207	// block-level tag.
208	//
209	// For example, here we should insert a newline before blockquote:
210	// - a
211	// >
212	//
213	if (token.block && token.nesting !== -1 && idx && tokens[idx - 1].hidden) {	13,524✔
214	result += '\n';	36✔
215	}
216
217	// Add token name, e.g. `<img`
218	result += (token.nesting === -1 ? '</' : '<') + token.tag;	13,524✔
219
220	// Encode attributes, e.g. `<img src="foo"`
221	result += this.renderAttrs(token);	13,524✔
222
223	// Add a slash for self-closing tags, e.g. `<img src="foo" /`
224	if (token.nesting === 0 && options.xhtmlOut) {	13,524✔
225	result += ' /';	224✔
226	}
227
228	// Check if we need to add a newline after this tag
229	if (token.block) {	13,524✔
230	needLf = true;	10,544✔
231
232	if (token.nesting === 1) {	10,544✔
233	if (idx + 1 < tokens.length) {	5,204✔
234	nextToken = tokens[idx + 1];	5,204✔
235
236	if (nextToken.type === 'inline' \|\| nextToken.hidden) {	5,204✔
237	// Block-level tag containing an inline tag.
238	//
239	needLf = false;	3,868✔
240
241	} else if (nextToken.nesting === -1 && nextToken.tag === token.tag) {	1,336✔
242	// Opening tag + closing tag of the same type. E.g. `<li></li>`.
243	//
244	needLf = false;	52✔
245	}
246	}
247	}
248	}
249
250	result += needLf ? '>\n' : '>';	13,524✔
251
252	return result;	13,524✔
253	};
254
255
256	/**
257	* Renderer.renderInline(tokens, options, env) -> String
258	* - tokens (Array): list on block tokens to renter
259	* - options (Object): params of parser instance
260	* - env (Object): additional data from parsed input (references, for example)
261	*
262	* The same as [[Renderer.render]], but for single token of `inline` type.
263	**/
264	Renderer.prototype.renderInline = function (tokens, options, env) {	4✔
265	var type,	3,896✔
266	result = '',
267	rules = this.rules;
268
269	for (var i = 0, len = tokens.length; i < len; i++) {	3,896✔
270	type = tokens[i].type;	8,668✔
271
272	if (typeof rules[type] !== 'undefined') {	8,668✔
273	result += rules[type](tokens, i, options, env, this);	5,804✔
274	} else {
275	result += this.renderToken(tokens, i, options);	2,864✔
276	}
277	}
278
279	return result;	3,896✔
280	};
281
282
283	/** internal
284	* Renderer.renderInlineAsText(tokens, options, env) -> String
285	* - tokens (Array): list on block tokens to renter
286	* - options (Object): params of parser instance
287	* - env (Object): additional data from parsed input (references, for example)
288	*
289	* Special kludge for image `alt` attributes to conform CommonMark spec.
290	* Don't try to use it! Spec requires to show `alt` content with stripped markup,
291	* instead of simple escaping.
292	**/
293	Renderer.prototype.renderInlineAsText = function (tokens, options, env) {	4✔
294	var result = '';	120✔
295
296	for (var i = 0, len = tokens.length; i < len; i++) {	120✔
297	if (tokens[i].type === 'text') {	236✔
298	result += tokens[i].content;	152✔
299	} else if (tokens[i].type === 'image') {	84✔
300	result += this.renderInlineAsText(tokens[i].children, options, env);	4✔
301	}
302	}
303
304	return result;	120✔
305	};
306
307
308	/**
309	* Renderer.render(tokens, options, env) -> String
310	* - tokens (Array): list on block tokens to renter
311	* - options (Object): params of parser instance
312	* - env (Object): additional data from parsed input (references, for example)
313	*
314	* Takes token stream and generates HTML. Probably, you will never need to call
315	* this method directly.
316	**/
317	Renderer.prototype.render = function (tokens, options, env) {	4✔
318	var i, len, type,	3,164✔
319	result = '',
320	rules = this.rules;
321
322	for (i = 0, len = tokens.length; i < len; i++) {	3,164✔
323	type = tokens[i].type;	15,816✔
324
325	if (type === 'inline') {	15,816✔
326	result += this.renderInline(tokens[i].children, options, env);	3,896✔
327	} else if (typeof rules[type] !== 'undefined') {	11,920✔
328	result += rules[tokens[i].type](tokens, i, options, env, this);	624✔
329	} else {
330	result += this.renderToken(tokens, i, options, env);	11,296✔
331	}
332	}
333
334	return result;	3,164✔
335	};
336
337	module.exports = Renderer;	4✔

markdown-it / markdown-it / 583

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