Remove Danger.dangerouslyRenderMarkup as it is dead code (#7185)

This commit is contained in:
Dan Abramov authored and GitHub committed 2016-07-05 03:25:06 +01:00
1 parent 24dfb56113
commit 7d0801e1a0
2 files changed
-228

No files matched your search

-127
View File
@@ -16,137 +16,10 @@ var ExecutionEnvironment = require('ExecutionEnvironment');
var createNodesFromMarkup = require('createNodesFromMarkup');
var emptyFunction = require('emptyFunction');
var getMarkupWrap = require('getMarkupWrap');
var invariant = require('invariant');
var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/;
var RESULT_INDEX_ATTR = 'data-danger-index';
/**
* Extracts the `nodeName` from a string of markup.
*
* NOTE: Extracting the `nodeName` does not require a regular expression match
* because we make assumptions about React-generated markup (i.e. there are no
* spaces surrounding the opening tag and there is at least one attribute).
*
* @param {string} markup String of markup.
* @return {string} Node name of the supplied markup.
* @see http://jsperf.com/extract-nodename
*/
function getNodeName(markup) {
return markup.substring(1, markup.indexOf(' '));
}
var Danger = {
/**
* Renders markup into an array of nodes. The markup is expected to render
* into a list of root nodes. Also, the length of `resultList` and
* `markupList` should be the same.
*
* @param {array<string>} markupList List of markup strings to render.
* @return {array<DOMElement>} List of rendered nodes.
* @internal
*/
dangerouslyRenderMarkup: function(markupList) {
invariant(
ExecutionEnvironment.canUseDOM,
'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +
'thread. Make sure `window` and `document` are available globally ' +
'before requiring React when unit testing or use ' +
'ReactDOMServer.renderToString for server rendering.'
);
var nodeName;
var markupByNodeName = {};
// Group markup by `nodeName` if a wrap is necessary, else by '*'.
for (var i = 0; i < markupList.length; i++) {
invariant(
markupList[i],
'dangerouslyRenderMarkup(...): Missing markup.'
);
nodeName = getNodeName(markupList[i]);
nodeName = getMarkupWrap(nodeName) ? nodeName : '*';
markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];
markupByNodeName[nodeName][i] = markupList[i];
}
var resultList = [];
var resultListAssignmentCount = 0;
for (nodeName in markupByNodeName) {
if (!markupByNodeName.hasOwnProperty(nodeName)) {
continue;
}
var markupListByNodeName = markupByNodeName[nodeName];
// This for-in loop skips the holes of the sparse array. The order of
// iteration should follow the order of assignment, which happens to match
// numerical index order, but we don't rely on that.
var resultIndex;
for (resultIndex in markupListByNodeName) {
if (markupListByNodeName.hasOwnProperty(resultIndex)) {
var markup = markupListByNodeName[resultIndex];
// Push the requested markup with an additional RESULT_INDEX_ATTR
// attribute. If the markup does not start with a < character, it
// will be discarded below (with an appropriate console.error).
markupListByNodeName[resultIndex] = markup.replace(
OPEN_TAG_NAME_EXP,
// This index will be parsed back out below.
'$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" '
);
}
}
// Render each group of markup with similar wrapping `nodeName`.
var renderNodes = createNodesFromMarkup(
markupListByNodeName.join(''),
emptyFunction // Do nothing special with <script> tags.
);
for (var j = 0; j < renderNodes.length; ++j) {
var renderNode = renderNodes[j];
if (renderNode.hasAttribute &&
renderNode.hasAttribute(RESULT_INDEX_ATTR)) {
resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);
renderNode.removeAttribute(RESULT_INDEX_ATTR);
invariant(
!resultList.hasOwnProperty(resultIndex),
'Danger: Assigning to an already-occupied result index.'
);
resultList[resultIndex] = renderNode;
// This should match resultList.length and markupList.length when
// we're done.
resultListAssignmentCount += 1;
} else if (__DEV__) {
console.error(
'Danger: Discarding unexpected node:',
renderNode
);
}
}
}
// Although resultList was populated out of order, it should now be a dense
// array.
invariant(
resultListAssignmentCount === resultList.length,
'Danger: Did not assign to every index of resultList.'
);
invariant(
resultList.length === markupList.length,
'Danger: Expected markup to render %s nodes, but rendered %s.',
markupList.length,
resultList.length
);
return resultList;
},
/**
* Replaces a node with a string of markup at its current position within its
* parent. The markup must render into a single root node.
@@ -1,101 +0,0 @@
/**
* Copyright 2013-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @emails react-core
*/
'use strict';
describe('Danger', function() {
describe('dangerouslyRenderMarkup', function() {
var Danger;
beforeEach(function() {
jest.resetModuleRegistry();
Danger = require('Danger');
});
it('should render markup', function() {
var markup = '<div data-reactid=".rX"></div>';
var output = Danger.dangerouslyRenderMarkup([markup])[0];
expect(output.nodeName).toBe('DIV');
});
it('should render markup with props', function() {
var markup = '<div class="foo" data-reactid=".rX"></div>';
var output = Danger.dangerouslyRenderMarkup([markup])[0];
expect(output.nodeName).toBe('DIV');
expect(output.className).toBe('foo');
});
it('should render wrapped markup', function() {
var markup = '<th data-reactid=".rX"></th>';
var output = Danger.dangerouslyRenderMarkup([markup])[0];
expect(output.nodeName).toBe('TH');
});
it('should render lists of markup with similar `nodeName`', function() {
var renderedMarkup = Danger.dangerouslyRenderMarkup(
['<p id="A">1</p>', '<p id="B">2</p>', '<p id="C">3</p>']
);
expect(renderedMarkup.length).toBe(3);
expect(renderedMarkup[0].nodeName).toBe('P');
expect(renderedMarkup[1].nodeName).toBe('P');
expect(renderedMarkup[2].nodeName).toBe('P');
expect(renderedMarkup[0].innerHTML).toBe('1');
expect(renderedMarkup[1].innerHTML).toBe('2');
expect(renderedMarkup[2].innerHTML).toBe('3');
});
it('should render lists of markup with different `nodeName`', function() {
var renderedMarkup = Danger.dangerouslyRenderMarkup(
['<p id="A">1</p>', '<td id="B">2</td>', '<p id="C">3</p>']
);
expect(renderedMarkup.length).toBe(3);
expect(renderedMarkup[0].nodeName).toBe('P');
expect(renderedMarkup[1].nodeName).toBe('TD');
expect(renderedMarkup[2].nodeName).toBe('P');
expect(renderedMarkup[0].innerHTML).toBe('1');
expect(renderedMarkup[1].innerHTML).toBe('2');
expect(renderedMarkup[2].innerHTML).toBe('3');
});
it('should throw when rendering invalid markup', function() {
expect(function() {
Danger.dangerouslyRenderMarkup(['']);
}).toThrowError(
'dangerouslyRenderMarkup(...): Missing markup.'
);
spyOn(console, 'error');
var renderedMarkup = Danger.dangerouslyRenderMarkup(['<p></p><p></p>']);
var args = console.error.calls.argsFor(0);
expect(renderedMarkup.length).toBe(1);
expect(renderedMarkup[0].nodeName).toBe('P');
expect(console.error.calls.count()).toBe(1);
expect(args.length).toBe(2);
expect(args[0]).toBe('Danger: Discarding unexpected node:');
expect(args[1].nodeName).toBe('P');
});
});
});