Remove Danger.dangerouslyRenderMarkup as it is dead code (#7185)
Dan Abramov committed
Jul 5, 2016 at 03:25 UTC
7d0801e1a085ef7c52b0cc0212404335fa75c717
2 files changed
-228
src/renderers/dom/shared/Danger.js
-127
@@ -16,137 +16,10 @@ var ExecutionEnvironment = require('ExecutionEnvironment');
16
17
var createNodesFromMarkup = require('createNodesFromMarkup');
18
var emptyFunction = require('emptyFunction');
19
-var getMarkupWrap = require('getMarkupWrap');
19
var invariant = require('invariant');
20
22
-var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/;
23
-var RESULT_INDEX_ATTR = 'data-danger-index';
24
-
25
-/**
26
- * Extracts the `nodeName` from a string of markup.
27
- *
28
- * NOTE: Extracting the `nodeName` does not require a regular expression match
29
- * because we make assumptions about React-generated markup (i.e. there are no
30
- * spaces surrounding the opening tag and there is at least one attribute).
31
- *
32
- * @param {string} markup String of markup.
33
- * @return {string} Node name of the supplied markup.
34
- * @see http://jsperf.com/extract-nodename
35
- */
36
-function getNodeName(markup) {
37
- return markup.substring(1, markup.indexOf(' '));
38
-}
39
-
21
var Danger = {
22
42
- /**
43
- * Renders markup into an array of nodes. The markup is expected to render
44
- * into a list of root nodes. Also, the length of `resultList` and
45
- * `markupList` should be the same.
46
- *
47
- * @param {array<string>} markupList List of markup strings to render.
48
- * @return {array<DOMElement>} List of rendered nodes.
49
- * @internal
50
- */
51
- dangerouslyRenderMarkup: function(markupList) {
52
- invariant(
53
- ExecutionEnvironment.canUseDOM,
54
- 'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +
55
- 'thread. Make sure `window` and `document` are available globally ' +
56
- 'before requiring React when unit testing or use ' +
57
- 'ReactDOMServer.renderToString for server rendering.'
58
- );
59
- var nodeName;
60
- var markupByNodeName = {};
61
- // Group markup by `nodeName` if a wrap is necessary, else by '*'.
62
- for (var i = 0; i < markupList.length; i++) {
63
- invariant(
64
- markupList[i],
65
- 'dangerouslyRenderMarkup(...): Missing markup.'
66
- );
67
- nodeName = getNodeName(markupList[i]);
68
- nodeName = getMarkupWrap(nodeName) ? nodeName : '*';
69
- markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];
70
- markupByNodeName[nodeName][i] = markupList[i];
71
- }
72
- var resultList = [];
73
- var resultListAssignmentCount = 0;
74
- for (nodeName in markupByNodeName) {
75
- if (!markupByNodeName.hasOwnProperty(nodeName)) {
76
- continue;
77
- }
78
- var markupListByNodeName = markupByNodeName[nodeName];
79
-
80
- // This for-in loop skips the holes of the sparse array. The order of
81
- // iteration should follow the order of assignment, which happens to match
82
- // numerical index order, but we don't rely on that.
83
- var resultIndex;
84
- for (resultIndex in markupListByNodeName) {
85
- if (markupListByNodeName.hasOwnProperty(resultIndex)) {
86
- var markup = markupListByNodeName[resultIndex];
87
-
88
- // Push the requested markup with an additional RESULT_INDEX_ATTR
89
- // attribute. If the markup does not start with a < character, it
90
- // will be discarded below (with an appropriate console.error).
91
- markupListByNodeName[resultIndex] = markup.replace(
92
- OPEN_TAG_NAME_EXP,
93
- // This index will be parsed back out below.
94
- '$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" '
95
- );
96
- }
97
- }
98
-
99
- // Render each group of markup with similar wrapping `nodeName`.
100
- var renderNodes = createNodesFromMarkup(
101
- markupListByNodeName.join(''),
102
- emptyFunction // Do nothing special with <script> tags.
103
- );
104
-
105
- for (var j = 0; j < renderNodes.length; ++j) {
106
- var renderNode = renderNodes[j];
107
- if (renderNode.hasAttribute &&
108
- renderNode.hasAttribute(RESULT_INDEX_ATTR)) {
109
-
110
- resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);
111
- renderNode.removeAttribute(RESULT_INDEX_ATTR);
112
-
113
- invariant(
114
- !resultList.hasOwnProperty(resultIndex),
115
- 'Danger: Assigning to an already-occupied result index.'
116
- );
117
-
118
- resultList[resultIndex] = renderNode;
119
-
120
- // This should match resultList.length and markupList.length when
121
- // we're done.
122
- resultListAssignmentCount += 1;
123
-
124
- } else if (__DEV__) {
125
- console.error(
126
- 'Danger: Discarding unexpected node:',
127
- renderNode
128
- );
129
- }
130
- }
131
- }
132
-
133
- // Although resultList was populated out of order, it should now be a dense
134
- // array.
135
- invariant(
136
- resultListAssignmentCount === resultList.length,
137
- 'Danger: Did not assign to every index of resultList.'
138
- );
139
-
140
- invariant(
141
- resultList.length === markupList.length,
142
- 'Danger: Expected markup to render %s nodes, but rendered %s.',
143
- markupList.length,
144
- resultList.length
145
- );
146
-
147
- return resultList;
148
- },
149
-
23
/**
24
* Replaces a node with a string of markup at its current position within its
25
* parent. The markup must render into a single root node.
src/renderers/dom/shared/__tests__/Danger-test.js
deleted
-101
@@ -1,101 +0,0 @@
1
-/**
2
- * Copyright 2013-present, Facebook, Inc.
3
- * All rights reserved.
4
- *
5
- * This source code is licensed under the BSD-style license found in the
6
- * LICENSE file in the root directory of this source tree. An additional grant
7
- * of patent rights can be found in the PATENTS file in the same directory.
8
- *
9
- * @emails react-core
10
- */
11
-
12
-'use strict';
13
-
14
-describe('Danger', function() {
15
-
16
- describe('dangerouslyRenderMarkup', function() {
17
- var Danger;
18
-
19
- beforeEach(function() {
20
- jest.resetModuleRegistry();
21
- Danger = require('Danger');
22
- });
23
-
24
- it('should render markup', function() {
25
- var markup = '<div data-reactid=".rX"></div>';
26
- var output = Danger.dangerouslyRenderMarkup([markup])[0];
27
-
28
- expect(output.nodeName).toBe('DIV');
29
- });
30
-
31
- it('should render markup with props', function() {
32
- var markup = '<div class="foo" data-reactid=".rX"></div>';
33
- var output = Danger.dangerouslyRenderMarkup([markup])[0];
34
-
35
- expect(output.nodeName).toBe('DIV');
36
- expect(output.className).toBe('foo');
37
- });
38
-
39
- it('should render wrapped markup', function() {
40
- var markup = '<th data-reactid=".rX"></th>';
41
- var output = Danger.dangerouslyRenderMarkup([markup])[0];
42
-
43
- expect(output.nodeName).toBe('TH');
44
- });
45
-
46
- it('should render lists of markup with similar `nodeName`', function() {
47
- var renderedMarkup = Danger.dangerouslyRenderMarkup(
48
- ['<p id="A">1</p>', '<p id="B">2</p>', '<p id="C">3</p>']
49
- );
50
-
51
- expect(renderedMarkup.length).toBe(3);
52
-
53
- expect(renderedMarkup[0].nodeName).toBe('P');
54
- expect(renderedMarkup[1].nodeName).toBe('P');
55
- expect(renderedMarkup[2].nodeName).toBe('P');
56
-
57
- expect(renderedMarkup[0].innerHTML).toBe('1');
58
- expect(renderedMarkup[1].innerHTML).toBe('2');
59
- expect(renderedMarkup[2].innerHTML).toBe('3');
60
- });
61
-
62
- it('should render lists of markup with different `nodeName`', function() {
63
- var renderedMarkup = Danger.dangerouslyRenderMarkup(
64
- ['<p id="A">1</p>', '<td id="B">2</td>', '<p id="C">3</p>']
65
- );
66
-
67
- expect(renderedMarkup.length).toBe(3);
68
-
69
- expect(renderedMarkup[0].nodeName).toBe('P');
70
- expect(renderedMarkup[1].nodeName).toBe('TD');
71
- expect(renderedMarkup[2].nodeName).toBe('P');
72
-
73
- expect(renderedMarkup[0].innerHTML).toBe('1');
74
- expect(renderedMarkup[1].innerHTML).toBe('2');
75
- expect(renderedMarkup[2].innerHTML).toBe('3');
76
- });
77
-
78
- it('should throw when rendering invalid markup', function() {
79
- expect(function() {
80
- Danger.dangerouslyRenderMarkup(['']);
81
- }).toThrowError(
82
- 'dangerouslyRenderMarkup(...): Missing markup.'
83
- );
84
-
85
- spyOn(console, 'error');
86
-
87
- var renderedMarkup = Danger.dangerouslyRenderMarkup(['<p></p><p></p>']);
88
- var args = console.error.calls.argsFor(0);
89
-
90
- expect(renderedMarkup.length).toBe(1);
91
- expect(renderedMarkup[0].nodeName).toBe('P');
92
-
93
- expect(console.error.calls.count()).toBe(1);
94
-
95
- expect(args.length).toBe(2);
96
- expect(args[0]).toBe('Danger: Discarding unexpected node:');
97
- expect(args[1].nodeName).toBe('P');
98
- });
99
- });
100
-
101
-});