Debian Codegraph @

closure-library/closure/goog/dom/pattern/repeat.js

raw
1 // Copyright 2007 The Closure Library Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS-IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 /**
16 * @fileoverview DOM pattern to match a tag and all of its children.
17 *
18 * @author [email protected] (Robby Walker)
19 */
20
21 goog.provide('goog.dom.pattern.Repeat');
22
23 goog.require('goog.dom.NodeType');
24 goog.require('goog.dom.pattern.AbstractPattern');
25 goog.require('goog.dom.pattern.MatchType');
26
27
28
29 /**
30 * Pattern object that matches a repetition of another pattern.
31 * @param {goog.dom.pattern.AbstractPattern} pattern The pattern to
32 * repetitively match.
33 * @param {number=} opt_minimum The minimum number of times to match. Defaults
34 * to 0.
35 * @param {number=} opt_maximum The maximum number of times to match. Defaults
36 * to unlimited.
37 * @constructor
38 * @extends {goog.dom.pattern.AbstractPattern}
39 * @final
40 */
41 goog.dom.pattern.Repeat = function(pattern, opt_minimum, opt_maximum) {
42 /**
43 * Pattern to repetitively match.
44 *
45 * @private {goog.dom.pattern.AbstractPattern}
46 */
47 this.pattern_ = pattern;
48
49 /**
50 * Minimum number of times to match the pattern.
51 *
52 * @private {number}
53 */
54 this.minimum_ = opt_minimum || 0;
55
56 /**
57 * Optional maximum number of times to match the pattern. A {@code null} value
58 * will be treated as infinity.
59 *
60 * @private {?number}
61 */
62 this.maximum_ = opt_maximum || null;
63
64 /**
65 * The matched nodes.
66 *
67 * @type {Array<Node>}
68 */
69 this.matches = [];
70
71 /**
72 * Number of times the pattern has matched.
73 *
74 * @type {number}
75 */
76 this.count = 0;
77
78 /**
79 * Whether the pattern has recently matched or failed to match and will need
80 * to be reset when starting a new round of matches.
81 *
82 * @private {boolean}
83 */
84 this.needsReset_ = false;
85 };
86 goog.inherits(goog.dom.pattern.Repeat, goog.dom.pattern.AbstractPattern);
87
88
89 /**
90 * Test whether the given token continues a repeated series of matches of the
91 * pattern given in the constructor.
92 *
93 * @param {Node} token Token to match against.
94 * @param {goog.dom.TagWalkType} type The type of token.
95 * @return {goog.dom.pattern.MatchType} <code>MATCH</code> if the pattern
96 * matches, <code>BACKTRACK_MATCH</code> if the pattern does not match
97 * but already had accumulated matches, <code>MATCHING</code> if the pattern
98 * starts a match, and <code>NO_MATCH</code> if the pattern does not match.
99 * @suppress {missingProperties} See the broken line below.
100 * @override
101 */
102 goog.dom.pattern.Repeat.prototype.matchToken = function(token, type) {
103 // Reset if we're starting a new match
104 if (this.needsReset_) {
105 this.reset();
106 }
107
108 // If the option is set, ignore any whitespace only text nodes
109 if (token.nodeType == goog.dom.NodeType.TEXT &&
110 token.nodeValue.match(/^\s+$/)) {
111 return goog.dom.pattern.MatchType.MATCHING;
112 }
113
114 switch (this.pattern_.matchToken(token, type)) {
115 case goog.dom.pattern.MatchType.MATCH:
116 // Record the first token we match.
117 if (this.count == 0) {
118 this.matchedNode = token;
119 }
120
121 // Mark the match
122 this.count++;
123
124 // Add to the list
125 this.matches.push(this.pattern_.matchedNode);
126
127 // Check if this match hits our maximum
128 if (this.maximum_ !== null && this.count == this.maximum_) {
129 this.needsReset_ = true;
130 return goog.dom.pattern.MatchType.MATCH;
131 } else {
132 return goog.dom.pattern.MatchType.MATCHING;
133 }
134
135 case goog.dom.pattern.MatchType.MATCHING:
136 // This can happen when our child pattern is a sequence or a repetition.
137 return goog.dom.pattern.MatchType.MATCHING;
138
139 case goog.dom.pattern.MatchType.BACKTRACK_MATCH:
140 // This happens if our child pattern is repetitive too.
141 // TODO(robbyw): Backtrack further if necessary.
142 this.count++;
143
144 // NOTE(nicksantos): This line of code is broken. this.patterns_ doesn't
145 // exist, and this.currentPosition_ doesn't exist. When this is fixed,
146 // remove the missingProperties suppression above.
147 if (this.currentPosition_ == this.patterns_.length) {
148 this.needsReset_ = true;
149 return goog.dom.pattern.MatchType.BACKTRACK_MATCH;
150 } else {
151 // Retry the same token on the next iteration of the child pattern.
152 return this.matchToken(token, type);
153 }
154
155 default:
156 this.needsReset_ = true;
157 if (this.count >= this.minimum_) {
158 return goog.dom.pattern.MatchType.BACKTRACK_MATCH;
159 } else {
160 return goog.dom.pattern.MatchType.NO_MATCH;
161 }
162 }
163 };
164
165
166 /**
167 * Reset any internal state this pattern keeps.
168 * @override
169 */
170 goog.dom.pattern.Repeat.prototype.reset = function() {
171 this.pattern_.reset();
172 this.count = 0;
173 this.needsReset_ = false;
174 this.matches.length = 0;
175 };