Update template after it has been created and populated and stuff.
16 | It automatically updates all its instances with the new template.
18 | Try editing the template. Add "{id}" to the end and see what happens.
20 | That node and all of its children will be used as a new template for whatever key you add after it. EG: SubtleTemplate whatever_key
16 | .
7 | You can only use this stylesheet to run MooTools JSSpec Runner.
8 | */
9 |
10 | /* @group Reset */
11 |
12 | * {
13 | margin: 0;
14 | padding: 0;
15 | }
16 |
17 | ul {
18 | list-style: none;
19 | }
20 |
21 | /* @end */
22 |
23 | /* @group Base */
24 |
25 | html {
26 | overflow: hidden;
27 | }
28 |
29 | body {
30 | font: 11px/1.5 Lucida Grande, Helvetica, Arial, sans-serif;
31 | background: #F3F1F1;
32 | color: #41464D;
33 | }
34 |
35 | body, #container {
36 | width: 100%;
37 | height: 100%;
38 | overflow: hidden;
39 | }
40 |
41 | a {
42 | text-decoration:none;
43 | }
44 |
45 | #title {
46 | position: absolute;
47 | top: 0;
48 | left: 0;
49 | width: 100%;
50 | padding: 5px 0;
51 | background: #aaa;
52 | background: #41464D;
53 | color: #F3F1F1;
54 | height: 30px;
55 | }
56 |
57 | #list {
58 | position: absolute;
59 | width: 30%;
60 | overflow-y: auto;
61 | overflow-x: hidden;
62 | top: 40px;
63 | left: 0;
64 | bottom: 0;
65 | /* height: expression(document.body.clientHeight-40);*/
66 | }
67 |
68 | #log {
69 | position: absolute;
70 | top: 40px;
71 | right: 0;
72 | bottom: 0;
73 | overflow-y: auto;
74 | overflow-x: hidden;
75 | width: 70%;
76 | /* height: expression(document.body.clientHeight-40);*/
77 | }
78 |
79 | span.spc {
80 | display: block;
81 | height: 16px;
82 | }
83 |
84 | #log-wrapper, #list-wrapper {
85 | overflow: hidden;
86 | padding: 4px 4px 0;
87 | background: #fff;
88 | }
89 |
90 | #log-wrapper {
91 | margin: 16px 16px 0 8px;
92 | }
93 |
94 | #list-wrapper {
95 | margin: 16px 8px 0 16px;
96 | }
97 |
98 | .success a:link, .success a:visited {
99 | color: #657528;
100 | }
101 |
102 | .exception a:link, .exception a:visited {
103 | color: #B33F3F;
104 | }
105 |
106 | a:link, a:visited {
107 | color: #528CE0;
108 | }
109 |
110 | a:hover, a:active {
111 | color: #41464D !important;
112 | cursor: pointer !important;
113 | }
114 |
115 | #title h1 {
116 | font: 25px/1.1 Arial, sans-serif;
117 | font-weight: bolder;
118 | float: left;
119 | margin: 1px 0 2px 20px;
120 | text-shadow: 0 2px 2px rgba(0,0,0,0.4);
121 | }
122 |
123 | #title h1 span {
124 | color: #D2E0E6;
125 | }
126 |
127 | #title ul li {
128 | font-weight: bold;
129 | font-size: 12px;
130 | float: right;
131 | margin: 10px 5px 0;
132 | }
133 |
134 | #title ul {
135 | margin-right: 20px;
136 | }
137 |
138 | h2 {
139 | font-size: 14px;
140 | background: #D0C8C8;
141 | color: #8A7575;
142 | margin-bottom: 4px;
143 | padding: 2px 5px;
144 | }
145 |
146 | h2#runner {
147 | cursor: pointer;
148 | background-color: #CFE773;
149 | color: #657528;
150 | }
151 |
152 | h2#runner:hover {
153 | color: #41464D;
154 | }
155 |
156 | h2#runner.disabled {
157 | color: #fff;
158 | background: #C8CBD0;
159 | cursor: default;
160 | }
161 |
162 | br {
163 | display: none;
164 | }
165 |
166 | h3 {
167 | font-size: 12px;
168 | padding: 3px 5px 1px;
169 | }
170 |
171 | h4 {
172 | font-size: 11px;
173 | background: #C8CBD0;
174 | padding: 3px 5px 1px;
175 | margin-bottom: 4px;
176 | }
177 |
178 | h3, h4 {
179 | cursor: default;
180 | }
181 |
182 | #list h3 {
183 | background: #D2E0E6;
184 | color: #528CE0;
185 | margin-bottom: 4px;
186 | }
187 |
188 | #log h3 {
189 | background: #D0C8C8;
190 | color: #8A7575;
191 | margin-bottom: 4px;
192 | }
193 |
194 | #log li div {
195 | overflow: hidden;
196 | padding: 0 4px 4px;
197 | }
198 |
199 | p {
200 | color: #575d67;
201 | }
202 |
203 | p.uri {
204 | float: right;
205 | margin-top: -15px;
206 | font-size: 10px;
207 | }
208 |
209 | p.left, p.uri {
210 | font-family: Monaco, Courier New, monospace;
211 | }
212 |
213 | p#footer {
214 | text-align: right;
215 | padding: 10px 16px 0 0;
216 | }
217 |
218 | /* @end */
219 |
220 | /* @group Success/Failure Colors */
221 |
222 | #log .exception h3 {
223 | color: #B33F3F;
224 | background: #EE9A9A;
225 | }
226 |
227 | #log .exception h4 {
228 | color: #B33F3F;
229 | background: #eed8d8;
230 | cursor: pointer;
231 | }
232 |
233 | #log .success h3 {
234 | background-color: #CFE773;
235 | color: #657528;
236 | }
237 |
238 | #log .success h4 {
239 | background-color: #e2e5d2;
240 | color: #657528;
241 | cursor: default;
242 | }
243 |
244 | #log .stub h4 {
245 | background-color: #e5e5e1;
246 | color: #a1a87e;
247 | cursor: default;
248 | }
249 |
250 | #list .exception h3 {
251 | color: #B33F3F;
252 | background: #eed8d8;
253 | }
254 |
255 | #list .success h3 {
256 | background-color: #e2e5d2;
257 | color: #657528;
258 | }
259 |
260 | a.rerun {
261 | font-size: 11px;
262 | color: #fff !important;
263 | }
264 |
265 | /* @end */
266 |
267 | /* @group Code */
268 |
269 | .number_value {
270 | color: red;
271 | }
272 |
273 | .string_value {
274 | color: green;
275 | }
276 |
277 | .regexp_value {
278 | color: olive;
279 | }
280 |
281 | .boolean_value {
282 | color: red;
283 | }
284 |
285 | .dom_value {
286 | color: purple;
287 | }
288 |
289 | .undefined_value, .null_value {
290 | color: gray;
291 | }
292 |
293 | /* @end */
--------------------------------------------------------------------------------
/Demos/SubtleTemplate.html:
--------------------------------------------------------------------------------
1 |
3 |
4 |
5 |
6 | SubtleTemplate
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 | - {data1}
15 | - {data2}
16 | - {data3}
17 |
18 |
19 |
20 |
21 |
22 |
23 | | {data1} |
24 | {data2} |
25 | {data3} |
26 |
27 |
28 |
29 |
\
10 | - {data1}
\
11 | - {data2}
\
12 | - {data3}
\
13 |
'
14 | }).inject(demo);
15 |
16 | MyDiv = new SubtleTemplate(template);
17 |
18 |
19 | new Element('div',{
20 | id:'mydiv_with_attributes',
21 | html:''
26 | }).inject(demo);
27 |
28 | MyDiv_with_attributes = new SubtleTemplate($('mydiv_with_attributes'));
29 | }
30 |
31 | ,'after all': function(){
32 | template.destroy();
33 | demo.destroy();
34 | MyDiv_with_attributes=
35 | demo=
36 | MyDiv=
37 | null;
38 | }
39 |
40 | ,after: function(){
41 | demo.empty();
42 | }
43 |
44 | ,'should be created and injected and match the data': function(){
45 | var fred = new MyDiv({ data1:'fred' }).inject( demo );
46 | value_of( fred.element.get('text') ).should_match( 'fred' );
47 | }
48 |
49 | ,'should allow updating the data later': function(){
50 | var fred = new MyDiv({ data1:'fred' }).inject( demo );
51 | value_of( fred.element.get('text') ).should_match( 'fred' );
52 |
53 | fred.populate({ data1:'updated' });
54 | value_of( fred.element.get('text') ).should_match( 'updated' );
55 | }
56 |
57 | ,'should not break when you have spaces in your values': function(){
58 | // This is really to check for IE goofing up your html since it'll unquote attribute values in its view of the HTML, EG:
59 | // howdy
60 | // In IE becomes:
61 | // howdy
62 | // Then, setting the class to "something else altogether" would result in this:
63 | // howdy
64 |
65 | var fred = new MyDiv_with_attributes({ data1:'fred is my name' }).inject( demo );
66 | value_of( fred.element.getElement('input').get('value') ).should_be( 'fred is my name' );
67 |
68 | fred.populate({ data1:'derf is not my name' });
69 | value_of( fred.element.getElement('input').get('value') ).should_match( 'derf is not my name' );
70 | }
71 |
72 | ,'should allow you to update the html of the template and rebuild everything': function(){
73 |
74 | var fred = new MyDiv({ data1:'fred' }).inject( demo );
75 | value_of( fred.element.get('text') ).should_match( 'fred' );
76 |
77 | var fred1 = new MyDiv({ data1:'fred1' }).inject( demo );
78 | value_of( fred1.element.get('text') ).should_match( 'fred1' );
79 |
80 | MyDiv.updateTemplate(function(templateClassInstance){
81 | this.getElement('li').set('html','{data1}{data1}');
82 | });
83 | value_of( fred.element.get('text') ).should_match( 'fredfred' );
84 | value_of( fred1.element.get('text') ).should_match( 'fred1fred1' );
85 |
86 | }
87 |
88 | ,'should allow you to update the html to any random tag, even a new one': function(){
89 | var MyBlankDiv = new SubtleTemplate();
90 |
91 | var fred = new MyBlankDiv({ html:'fred' }).inject( demo );
92 | value_of( fred.element.get('text') ).should_match( 'fred' );
93 | value_of( fred.element.getElement('*') ).should_be(null);
94 |
95 | var fred1 = new MyBlankDiv({ html:'fred1' }).inject( demo );
96 | value_of( fred1.element.get('text') ).should_match( 'fred1' );
97 | value_of( fred1.element.getElement('*') ).should_be(null);
98 |
99 | fred.populate({
100 | data1:'fred'
101 | });
102 | fred1.populate({
103 | data1:'fred1'
104 | });
105 |
106 | MyBlankDiv.updateTemplate(function(templateClassInstance){
107 | return new Element('div',{html:'{data1}{data1}
'})
108 | });
109 | value_of( fred.element.getElement('*').get('tag') ).should_be( 'p' );
110 | value_of( fred.element.get('text') ).should_match( 'fredfred' );
111 |
112 | value_of( fred.element.getElement('*').get('tag') ).should_be( 'p' );
113 | value_of( fred1.element.get('text') ).should_match( 'fred1fred1' );
114 |
115 | }
116 |
117 | ,'should be able to implement stuff on the template': function(){
118 |
119 | var MySuperDiv = new SubtleTemplate();
120 |
121 | my_div = new MySuperDiv({});
122 |
123 | MySuperDiv.implement({
124 | something: 'something'
125 | });
126 |
127 | value_of( new MySuperDiv({}).something ).should_be( 'something' );
128 | value_of( my_div.something ).should_be( 'something' );
129 |
130 | }
131 |
132 | ,'should keep its class when used as a template': function(){
133 |
134 | var fred = new MyDiv({ data1:'fred' }).inject( demo );
135 | value_of( fred.element.get('text') ).should_match( 'fred' );
136 |
137 | value_of( template.get('class') ).should_be( 'super duper {extraclass}' )
138 | value_of( fred.element.get('class') ).should_be( 'super duper ' )
139 | }
140 |
141 | ,'should substitute class and id': function(){
142 |
143 | var fred = new MyDiv({ data1:'fred', extraclass:'myextraclass', html_id:'subtletemplate{id}', id:'flarm' }).inject( demo );
144 | value_of( fred.element.get('text') ).should_match( 'fred' );
145 |
146 | value_of( template.get('class') ).should_be( 'super duper {extraclass}' )
147 | value_of( fred.element.get('class') ).should_be( 'super duper myextraclass' )
148 |
149 | value_of( template.get('id') ).should_be( 'subtletemplate' )
150 | value_of( fred.element.get('id') ).should_be( 'subtletemplateflarm' )
151 |
152 | fred.populate({ data1:'fred2', extraclass:'myextraclass2', html_id:'subtletemplate{id}2', id:'flarm2' });
153 | value_of( fred.element.get('text') ).should_match( 'fred2' );
154 | value_of( fred.element.get('class') ).should_be( 'super duper myextraclass2' )
155 | value_of( fred.element.get('id') ).should_be( 'subtletemplateflarm22' )
156 | }
157 |
158 | ,"shouldn't use the original id attribute": function(){
159 |
160 | var fred = new MyDiv({ data1:'fred', extraclass:'myextraclass' }).inject( demo );
161 | value_of( fred.element.get('text') ).should_match( 'fred' );
162 |
163 | value_of( template.get('id') ).should_be( 'subtletemplate' )
164 | value_of( fred.element.get('id') ).should_not_be( 'subtletemplate' )
165 | }
166 | /*
167 | ,"should keep additional classes when repopulated": function(){
168 |
169 | // Start with class="one{one} two{two} three{three}"
170 | // data = {one:1,two:2,three:3}
171 | // populate
172 | // class should be "one1 two2 three3"
173 | // Add class "four4"
174 | // populate
175 | // class should be "one1 two2 three3 four4"
176 | // Change data to {one:4,two:5,three:6}
177 | // populate
178 | // class should be "one4 two5 three6 four4"
179 |
180 | }
181 | */
182 | ,"should bless an existing element if provided": function(){
183 |
184 | // Make a new normal html element
185 | var myExistingElement = new Element('div',{ html:'myExistingElement' });
186 | value_of( myExistingElement.get('html') ).should_be( 'myExistingElement' );
187 |
188 | // Blessing it should populate() just like creating a new one
189 | var fred = new MyDiv({ data1:'myExistingElement is populated!' }, { element:myExistingElement });
190 | value_of( myExistingElement.get('html') ).should_match( 'myExistingElement is populated!' );
191 |
192 | }
193 | ,"should create sub templates when children of the template element include an that match the subtemplate classname": function(){
194 | var DATA = {
195 | masterName:'masterName',
196 | children:[
197 | { childName:'childName1' },
198 | { childName:'childName2' },
199 | { childName:'childName3' }
200 | ]
201 | };
202 | var masterTemplateElement = new Element('div',{html:'{masterName} {childName}
'}).inject(demo);
203 | var MasterTemplate = new SubtleTemplate(masterTemplateElement);
204 | var myMasterTemplate = new MasterTemplate(DATA).inject(demo);
205 |
206 | value_of( demo.getElements('p').length ).should_be(3);
207 |
208 | DATA.children.push({ childName:'childName4' });
209 | myMasterTemplate.populate(DATA);
210 |
211 | value_of( demo.getElements('p').length ).should_be(4);
212 |
213 | delete DATA.children
214 | myMasterTemplate.populate(DATA);
215 |
216 | value_of( DATA.children ).should_be_undefined();
217 | value_of( demo.getElements('p').length ).should_be(0);
218 | }
219 | });
220 |
221 |
222 |
223 |
--------------------------------------------------------------------------------
/Specs/Assets/Scripts/JSSpec.js:
--------------------------------------------------------------------------------
1 | /**
2 | * JSSpec
3 | *
4 | * Copyright 2007 Alan Kang
5 | * - mailto:jania902@gmail.com
6 | * - http://jania.pe.kr
7 | *
8 | * http://jania.pe.kr/aw/moin.cgi/JSSpec
9 | *
10 | * Dependencies:
11 | * - diff_match_patch.js ( http://code.google.com/p/google-diff-match-patch )
12 | *
13 | * This library is free software; you can redistribute it and/or
14 | * modify it under the terms of the GNU Lesser General Public
15 | * License as published by the Free Software Foundation; either
16 | * version 2.1 of the License, or (at your option) any later version.
17 | *
18 | * This library is distributed in the hope that it will be useful,
19 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 | * Lesser General Public License for more details.
22 | *
23 | * You should have received a copy of the GNU Lesser General Public
24 | * License along with this library; if not, write to the Free Software
25 | * Foundation, Inc, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
26 | */
27 |
28 | /**
29 | * Namespace
30 | */
31 |
32 | var JSSpec = {
33 | specs: [],
34 |
35 | EMPTY_FUNCTION: function() {},
36 |
37 | Browser: {
38 | Trident: navigator.appName == "Microsoft Internet Explorer",
39 | Webkit: navigator.userAgent.indexOf('AppleWebKit/') > -1,
40 | Gecko: navigator.userAgent.indexOf('Gecko') > -1 && navigator.userAgent.indexOf('KHTML') == -1,
41 | Presto: navigator.appName == "Opera"
42 | }
43 | };
44 |
45 |
46 |
47 | /**
48 | * Executor
49 | */
50 | JSSpec.Executor = function(target, onSuccess, onException) {
51 | this.target = target;
52 | this.onSuccess = typeof onSuccess == 'function' ? onSuccess : JSSpec.EMPTY_FUNCTION;
53 | this.onException = typeof onException == 'function' ? onException : JSSpec.EMPTY_FUNCTION;
54 |
55 | if(JSSpec.Browser.Trident) {
56 | // Exception handler for Trident. It helps to collect exact line number where exception occured.
57 | window.onerror = function(message, fileName, lineNumber) {
58 | var self = window._curExecutor;
59 | var ex = {message:message, fileName:fileName, lineNumber:lineNumber};
60 |
61 | if(JSSpec._secondPass) {
62 | ex = self.mergeExceptions(JSSpec._assertionFailure, ex);
63 | delete JSSpec._secondPass;
64 | delete JSSpec._assertionFailure;
65 |
66 | ex.type = "failure";
67 | self.onException(self, ex);
68 | } else if(JSSpec._assertionFailure) {
69 | JSSpec._secondPass = true;
70 | self.run();
71 | } else {
72 | self.onException(self, ex);
73 | }
74 |
75 | return true;
76 | };
77 | }
78 | };
79 | JSSpec.Executor.prototype.mergeExceptions = function(assertionFailure, normalException) {
80 | var merged = {
81 | message:assertionFailure.message,
82 | fileName:normalException.fileName,
83 | lineNumber:normalException.lineNumber
84 | };
85 |
86 | return merged;
87 | };
88 |
89 | JSSpec.Executor.prototype.run = function() {
90 | var self = this;
91 | var target = this.target;
92 | var onSuccess = this.onSuccess;
93 | var onException = this.onException;
94 |
95 | window.setTimeout(
96 | function() {
97 | var result;
98 | if(JSSpec.Browser.Trident) {
99 | window._curExecutor = self;
100 |
101 | result = self.target();
102 | self.onSuccess(self, result);
103 | } else {
104 | try {
105 | result = self.target();
106 | self.onSuccess(self, result);
107 | } catch(ex) {
108 | if(JSSpec.Browser.Webkit) ex = {message:ex.message, fileName:ex.sourceURL, lineNumber:ex.line};
109 |
110 | if(JSSpec._secondPass) {
111 | ex = self.mergeExceptions(JSSpec._assertionFailure, ex);
112 | delete JSSpec._secondPass;
113 | delete JSSpec._assertionFailure;
114 |
115 | ex.type = "failure";
116 | self.onException(self, ex);
117 | } else if(JSSpec._assertionFailure) {
118 | JSSpec._secondPass = true;
119 | self.run();
120 | } else {
121 | self.onException(self, ex);
122 | }
123 | }
124 | }
125 | },
126 | 0
127 | );
128 | };
129 |
130 |
131 |
132 | /**
133 | * CompositeExecutor composites one or more executors and execute them sequencially.
134 | */
135 | JSSpec.CompositeExecutor = function(onSuccess, onException, continueOnException) {
136 | this.queue = [];
137 | this.onSuccess = typeof onSuccess == 'function' ? onSuccess : JSSpec.EMPTY_FUNCTION;
138 | this.onException = typeof onException == 'function' ? onException : JSSpec.EMPTY_FUNCTION;
139 | this.continueOnException = !!continueOnException;
140 | };
141 |
142 | JSSpec.CompositeExecutor.prototype.addFunction = function(func) {
143 | this.addExecutor(new JSSpec.Executor(func));
144 | };
145 |
146 | JSSpec.CompositeExecutor.prototype.addExecutor = function(executor) {
147 | var last = this.queue.length == 0 ? null : this.queue[this.queue.length - 1];
148 | if(last) {
149 | last.next = executor;
150 | }
151 |
152 | executor.parent = this;
153 | executor.onSuccessBackup = executor.onSuccess;
154 | executor.onSuccess = function(result) {
155 | this.onSuccessBackup(result);
156 | if(this.next) {
157 | this.next.run();
158 | } else {
159 | this.parent.onSuccess();
160 | }
161 | };
162 | executor.onExceptionBackup = executor.onException;
163 | executor.onException = function(executor, ex) {
164 | this.onExceptionBackup(executor, ex);
165 |
166 | if(this.parent.continueOnException) {
167 | if(this.next) {
168 | this.next.run();
169 | } else {
170 | this.parent.onSuccess();
171 | }
172 | } else {
173 | this.parent.onException(executor, ex);
174 | }
175 | };
176 |
177 | this.queue.push(executor);
178 | };
179 |
180 | JSSpec.CompositeExecutor.prototype.run = function() {
181 | if(this.queue.length > 0) {
182 | this.queue[0].run();
183 | }
184 | };
185 |
186 | /**
187 | * Spec is a set of Examples in a specific context
188 | */
189 | JSSpec.Spec = function(context, entries) {
190 | this.id = JSSpec.Spec.id++;
191 | this.context = context;
192 | this.url = location.href;
193 |
194 | this.filterEntriesByEmbeddedExpressions(entries);
195 | this.extractOutSpecialEntries(entries);
196 | this.examples = this.makeExamplesFromEntries(entries);
197 | this.examplesMap = this.makeMapFromExamples(this.examples);
198 | };
199 |
200 | JSSpec.Spec.id = 0;
201 | JSSpec.Spec.prototype.getExamples = function() {
202 | return this.examples;
203 | };
204 |
205 | JSSpec.Spec.prototype.hasException = function() {
206 | return this.getTotalFailures() > 0 || this.getTotalErrors() > 0;
207 | };
208 |
209 | JSSpec.Spec.prototype.getTotalFailures = function() {
210 | var examples = this.examples;
211 | var failures = 0;
212 | for(var i = 0; i < examples.length; i++) {
213 | if(examples[i].isFailure()) failures++;
214 | }
215 | return failures;
216 | };
217 |
218 | JSSpec.Spec.prototype.getTotalErrors = function() {
219 | var examples = this.examples;
220 | var errors = 0;
221 | for(var i = 0; i < examples.length; i++) {
222 | if(examples[i].isError()) errors++;
223 | }
224 | return errors;
225 | };
226 |
227 | JSSpec.Spec.prototype.filterEntriesByEmbeddedExpressions = function(entries) {
228 | var isTrue;
229 | for(name in entries) {
230 | var m = name.match(/\[\[(.+)\]\]/);
231 | if(m && m[1]) {
232 | eval("isTrue = (" + m[1] + ")");
233 | if(!isTrue) delete entries[name];
234 | }
235 | }
236 | };
237 |
238 | JSSpec.Spec.prototype.extractOutSpecialEntries = function(entries) {
239 | this.beforeEach = JSSpec.EMPTY_FUNCTION;
240 | this.beforeAll = JSSpec.EMPTY_FUNCTION;
241 | this.afterEach = JSSpec.EMPTY_FUNCTION;
242 | this.afterAll = JSSpec.EMPTY_FUNCTION;
243 |
244 | for(name in entries) {
245 | if(name == 'before' || name == 'before each' || name == 'before_each') {
246 | this.beforeEach = entries[name];
247 | } else if(name == 'before all' || name == 'before_all') {
248 | this.beforeAll = entries[name];
249 | } else if(name == 'after' || name == 'after each' || name == 'after_each') {
250 | this.afterEach = entries[name];
251 | } else if(name == 'after all' || name == 'after_all') {
252 | this.afterAll = entries[name];
253 | }
254 | }
255 |
256 | delete entries['before'];
257 | delete entries['before each'];
258 | delete entries['before_each'];
259 | delete entries['before all'];
260 | delete entries['before_all'];
261 | delete entries['after'];
262 | delete entries['after each'];
263 | delete entries['after_each'];
264 | delete entries['after all'];
265 | delete entries['after_all'];
266 | };
267 |
268 | JSSpec.Spec.prototype.makeExamplesFromEntries = function(entries) {
269 | var examples = [];
270 | for(name in entries) {
271 | examples.push(new JSSpec.Example(name, entries[name], this.beforeEach, this.afterEach));
272 | }
273 | return examples;
274 | };
275 |
276 | JSSpec.Spec.prototype.makeMapFromExamples = function(examples) {
277 | var map = {};
278 | for(var i = 0; i < examples.length; i++) {
279 | var example = examples[i];
280 | map[example.id] = examples[i];
281 | }
282 | return map;
283 | };
284 |
285 | JSSpec.Spec.prototype.getExampleById = function(id) {
286 | return this.examplesMap[id];
287 | };
288 |
289 | JSSpec.Spec.prototype.getExecutor = function() {
290 | var self = this;
291 | var onException = function(executor, ex) {
292 | self.exception = ex;
293 | };
294 |
295 | var composite = new JSSpec.CompositeExecutor();
296 | composite.addFunction(function() {JSSpec.log.onSpecStart(self);});
297 | composite.addExecutor(new JSSpec.Executor(this.beforeAll, null, function(exec, ex) {
298 | self.exception = ex;
299 | JSSpec.log.onSpecEnd(self);
300 | }));
301 |
302 | var exampleAndAfter = new JSSpec.CompositeExecutor(null,null,true);
303 | for(var i = 0; i < this.examples.length; i++) {
304 | exampleAndAfter.addExecutor(this.examples[i].getExecutor());
305 | }
306 | exampleAndAfter.addExecutor(new JSSpec.Executor(this.afterAll, null, onException));
307 | exampleAndAfter.addFunction(function() {JSSpec.log.onSpecEnd(self);});
308 | composite.addExecutor(exampleAndAfter);
309 |
310 | return composite;
311 | };
312 |
313 | /**
314 | * Example
315 | */
316 | JSSpec.Example = function(name, target, before, after) {
317 | this.id = JSSpec.Example.id++;
318 | this.name = name;
319 | this.target = target;
320 | this.before = before;
321 | this.after = after;
322 | };
323 |
324 | JSSpec.Example.id = 0;
325 | JSSpec.Example.prototype.isFailure = function() {
326 | return this.exception && this.exception.type == "failure";
327 | };
328 |
329 | JSSpec.Example.prototype.isError = function() {
330 | return this.exception && !this.exception.type;
331 | };
332 |
333 | JSSpec.Example.prototype.getExecutor = function() {
334 | var self = this;
335 | var onException = function(executor, ex) {
336 | self.exception = ex;
337 | };
338 |
339 | var composite = new JSSpec.CompositeExecutor();
340 | composite.addFunction(function() {JSSpec.log.onExampleStart(self);});
341 | composite.addExecutor(new JSSpec.Executor(this.before, null, function(exec, ex) {
342 | self.exception = ex;
343 | JSSpec.log.onExampleEnd(self);
344 | }));
345 |
346 | var targetAndAfter = new JSSpec.CompositeExecutor(null,null,true);
347 |
348 | targetAndAfter.addExecutor(new JSSpec.Executor(this.target, null, onException));
349 | targetAndAfter.addExecutor(new JSSpec.Executor(this.after, null, onException));
350 | targetAndAfter.addFunction(function() {JSSpec.log.onExampleEnd(self);});
351 |
352 | composite.addExecutor(targetAndAfter);
353 |
354 | return composite;
355 | };
356 |
357 | /**
358 | * Runner
359 | */
360 | JSSpec.Runner = function(specs, logger) {
361 | JSSpec.log = logger;
362 |
363 | this.totalExamples = 0;
364 | this.specs = [];
365 | this.specsMap = {};
366 | this.addAllSpecs(specs);
367 | };
368 |
369 | JSSpec.Runner.prototype.addAllSpecs = function(specs) {
370 | for(var i = 0; i < specs.length; i++) {
371 | this.addSpec(specs[i]);
372 | }
373 | };
374 |
375 | JSSpec.Runner.prototype.addSpec = function(spec) {
376 | this.specs.push(spec);
377 | this.specsMap[spec.id] = spec;
378 | this.totalExamples += spec.getExamples().length;
379 | };
380 |
381 | JSSpec.Runner.prototype.getSpecById = function(id) {
382 | return this.specsMap[id];
383 | };
384 |
385 | JSSpec.Runner.prototype.getSpecByContext = function(context) {
386 | for(var i = 0; i < this.specs.length; i++) {
387 | if(this.specs[i].context == context) return this.specs[i];
388 | }
389 | return null;
390 | };
391 |
392 | JSSpec.Runner.prototype.getSpecs = function() {
393 | return this.specs;
394 | };
395 |
396 | JSSpec.Runner.prototype.hasException = function() {
397 | return this.getTotalFailures() > 0 || this.getTotalErrors() > 0;
398 | };
399 |
400 | JSSpec.Runner.prototype.getTotalFailures = function() {
401 | var specs = this.specs;
402 | var failures = 0;
403 | for(var i = 0; i < specs.length; i++) {
404 | failures += specs[i].getTotalFailures();
405 | }
406 | return failures;
407 | };
408 |
409 | JSSpec.Runner.prototype.getTotalErrors = function() {
410 | var specs = this.specs;
411 | var errors = 0;
412 | for(var i = 0; i < specs.length; i++) {
413 | errors += specs[i].getTotalErrors();
414 | }
415 | return errors;
416 | };
417 |
418 |
419 | JSSpec.Runner.prototype.run = function() {
420 | JSSpec.log.onRunnerStart();
421 | var executor = new JSSpec.CompositeExecutor(function() {JSSpec.log.onRunnerEnd()},null,true);
422 | for(var i = 0; i < this.specs.length; i++) {
423 | executor.addExecutor(this.specs[i].getExecutor());
424 | }
425 | executor.run();
426 | };
427 |
428 |
429 | JSSpec.Runner.prototype.rerun = function(context) {
430 | JSSpec.runner = new JSSpec.Runner([this.getSpecByContext(context)], JSSpec.log);
431 | JSSpec.runner.run();
432 | };
433 |
434 | /**
435 | * Logger
436 | */
437 | JSSpec.Logger = function() {
438 | this.finishedExamples = 0;
439 | this.startedAt = null;
440 | };
441 |
442 | JSSpec.Logger.prototype.onRunnerStart = function() {
443 | this._title = document.title;
444 |
445 | this.startedAt = new Date();
446 | var container = document.getElementById('jsspec_container');
447 | if(container) {
448 | container.innerHTML = "";
449 | } else {
450 | container = document.createElement("DIV");
451 | container.id = "jsspec_container";
452 | document.body.appendChild(container);
453 | }
454 |
455 | var title = document.createElement("DIV");
456 | title.id = "title";
457 | title.innerHTML = [
458 | 'JSSpec
',
459 | '',
460 | JSSpec.options.rerun ? '- [X] ' + JSSpec.util.escapeTags(decodeURIComponent(JSSpec.options.rerun)) + '
' : '',
461 | ' - ' + JSSpec.runner.totalExamples + ' examples
',
462 | ' - 0 failures
',
463 | ' - 0 errors
',
464 | ' - 0% done
',
465 | ' - 0 secs
',
466 | '
',
467 | 'JSSpec homepage
',
468 | ].join("");
469 | container.appendChild(title);
470 |
471 | var list = document.createElement("DIV");
472 | list.id = "list";
473 | list.innerHTML = [
474 | 'List
',
475 | '',
476 | function() {
477 | var specs = JSSpec.runner.getSpecs();
478 | var sb = [];
479 | for(var i = 0; i < specs.length; i++) {
480 | var spec = specs[i];
481 | sb.push('');
482 | }
483 | return sb.join("");
484 | }(),
485 | '
'
486 | ].join("");
487 | container.appendChild(list);
488 |
489 | var log = document.createElement("DIV");
490 | log.id = "log";
491 | log.innerHTML = [
492 | 'Log
',
493 | '',
494 | function() {
495 | var specs = JSSpec.runner.getSpecs();
496 | var sb = [];
497 | for(var i = 0; i < specs.length; i++) {
498 | var spec = specs[i];
499 | sb.push(' - ');
500 | sb.push('
' + JSSpec.util.escapeTags(specs[i].context) + ' [rerun]
');
501 | sb.push(' ');
502 | for(var j = 0; j < spec.examples.length; j++) {
503 | var example = spec.examples[j];
504 | sb.push(' - ')
505 | sb.push('
' + JSSpec.util.escapeTags(example.name) + '
')
506 | sb.push(' ')
507 | }
508 | sb.push('
');
509 | sb.push(' ');
510 | }
511 | return sb.join("");
512 | }(),
513 | '
'
514 | ].join("");
515 |
516 | container.appendChild(log);
517 |
518 | // add event handler for toggling
519 | var specs = JSSpec.runner.getSpecs();
520 | var sb = [];
521 | for(var i = 0; i < specs.length; i++) {
522 | var spec = document.getElementById("spec_" + specs[i].id);
523 | var title = spec.getElementsByTagName("H3")[0];
524 | title.onclick = function(e) {
525 | var target = document.getElementById(this.parentNode.id + "_examples");
526 | target.style.display = target.style.display == "none" ? "block" : "none";
527 | return true;
528 | }
529 | }
530 | };
531 |
532 | JSSpec.Logger.prototype.onRunnerEnd = function() {
533 | if(JSSpec.runner.hasException()) {
534 | var times = 4;
535 | var title1 = "*" + this._title;
536 | var title2 = "*F" + JSSpec.runner.getTotalFailures() + " E" + JSSpec.runner.getTotalErrors() + "* " + this._title;
537 | } else {
538 | var times = 2;
539 | var title1 = this._title;
540 | var title2 = "Success";
541 | }
542 | this.blinkTitle(times,title1,title2);
543 | };
544 |
545 | JSSpec.Logger.prototype.blinkTitle = function(times, title1, title2) {
546 | var times = times * 2;
547 | var mode = true;
548 |
549 | var f = function() {
550 | if(times > 0) {
551 | document.title = mode ? title1 : title2;
552 | mode = !mode;
553 | times--;
554 | window.setTimeout(f, 500);
555 | } else {
556 | document.title = title1;
557 | }
558 | };
559 |
560 | f();
561 | };
562 |
563 | JSSpec.Logger.prototype.onSpecStart = function(spec) {
564 | var spec_list = document.getElementById("spec_" + spec.id + "_list");
565 | var spec_log = document.getElementById("spec_" + spec.id);
566 |
567 | spec_list.className = "ongoing";
568 | spec_log.className = "ongoing";
569 | };
570 |
571 | JSSpec.Logger.prototype.onSpecEnd = function(spec) {
572 | var spec_list = document.getElementById("spec_" + spec.id + "_list");
573 | var spec_log = document.getElementById("spec_" + spec.id);
574 | var examples = document.getElementById("spec_" + spec.id + "_examples");
575 | var className = spec.hasException() ? "exception" : "success";
576 |
577 | spec_list.className = className;
578 | spec_log.className = className;
579 |
580 | if(JSSpec.options.autocollapse && !spec.hasException()) examples.style.display = "none";
581 |
582 | if(spec.exception) {
583 | heading.appendChild(document.createTextNode(" - " + spec.exception.message));
584 | }
585 | };
586 |
587 | JSSpec.Logger.prototype.onExampleStart = function(example) {
588 | var li = document.getElementById("example_" + example.id);
589 | li.className = "ongoing";
590 | };
591 |
592 | JSSpec.Logger.prototype.onExampleEnd = function(example) {
593 | var li = document.getElementById("example_" + example.id);
594 | li.className = example.exception ? "exception" : "success";
595 |
596 | if(example.exception) {
597 | var div = document.createElement("DIV");
598 | div.innerHTML = example.exception.message + "
" + " at " + example.exception.fileName + ", line " + example.exception.lineNumber + "
";
599 | li.appendChild(div);
600 | }
601 |
602 | var title = document.getElementById("title");
603 | var runner = JSSpec.runner;
604 |
605 | title.className = runner.hasException() ? "exception" : "success";
606 |
607 | this.finishedExamples++;
608 | document.getElementById("total_failures").innerHTML = runner.getTotalFailures();
609 | document.getElementById("total_errors").innerHTML = runner.getTotalErrors();
610 | var progress = parseInt(this.finishedExamples / runner.totalExamples * 100);
611 | document.getElementById("progress").innerHTML = progress;
612 | document.getElementById("total_elapsed").innerHTML = (new Date().getTime() - this.startedAt.getTime()) / 1000;
613 |
614 | document.title = progress + "%: " + this._title;
615 | };
616 |
617 | /**
618 | * IncludeMatcher
619 | */
620 | JSSpec.IncludeMatcher = function(actual, expected, condition) {
621 | this.actual = actual;
622 | this.expected = expected;
623 | this.condition = condition;
624 | this.match = false;
625 | this.explaination = this.makeExplain();
626 | };
627 |
628 | JSSpec.IncludeMatcher.createInstance = function(actual, expected, condition) {
629 | return new JSSpec.IncludeMatcher(actual, expected, condition);
630 | };
631 |
632 | JSSpec.IncludeMatcher.prototype.matches = function() {
633 | return this.match;
634 | };
635 |
636 | JSSpec.IncludeMatcher.prototype.explain = function() {
637 | return this.explaination;
638 | };
639 |
640 | JSSpec.IncludeMatcher.prototype.makeExplain = function() {
641 | if(typeof this.actual.length == 'undefined') {
642 | return this.makeExplainForNotArray();
643 | } else {
644 | return this.makeExplainForArray();
645 | }
646 | };
647 |
648 | JSSpec.IncludeMatcher.prototype.makeExplainForNotArray = function() {
649 | if(this.condition) {
650 | this.match = !!this.actual[this.expected];
651 | } else {
652 | this.match = !this.actual[this.expected];
653 | }
654 |
655 | var sb = [];
656 | sb.push('actual value:
');
657 | sb.push('' + JSSpec.util.inspect(this.actual, false, this.expected) + '
');
658 | sb.push('should ' + (this.condition ? '' : 'not') + ' include:
');
659 | sb.push('' + JSSpec.util.inspect(this.expected) + '
');
660 | return sb.join("");
661 | }
662 | ;
663 | JSSpec.IncludeMatcher.prototype.makeExplainForArray = function() {
664 | var matches;
665 | if(this.condition) {
666 | for(var i = 0; i < this.actual.length; i++) {
667 | matches = JSSpec.EqualityMatcher.createInstance(this.expected, this.actual[i]).matches();
668 | if(matches) {
669 | this.match = true;
670 | break;
671 | }
672 | }
673 | } else {
674 | for(var i = 0; i < this.actual.length; i++) {
675 | matches = JSSpec.EqualityMatcher.createInstance(this.expected, this.actual[i]).matches();
676 | if(matches) {
677 | this.match = false;
678 | break;
679 | }
680 | }
681 | }
682 |
683 | if(this.match) return "";
684 |
685 | var sb = [];
686 | sb.push('actual value:
');
687 | sb.push('' + JSSpec.util.inspect(this.actual, false, this.condition ? null : i) + '
');
688 | sb.push('should ' + (this.condition ? '' : 'not') + ' include:
');
689 | sb.push('' + JSSpec.util.inspect(this.expected) + '
');
690 | return sb.join("");
691 | };
692 |
693 | /**
694 | * PropertyLengthMatcher
695 | */
696 | JSSpec.PropertyLengthMatcher = function(num, property, o, condition) {
697 | this.num = num;
698 | this.o = o;
699 | this.property = property;
700 | if((property == 'characters' || property == 'items') && typeof o.length != 'undefined') {
701 | this.property = 'length';
702 | }
703 |
704 | this.condition = condition;
705 | this.conditionMet = function(x) {
706 | if(condition == 'exactly') return x.length == num;
707 | if(condition == 'at least') return x.length >= num;
708 | if(condition == 'at most') return x.length <= num;
709 |
710 | throw "Unknown condition '" + condition + "'";
711 | };
712 | this.match = false;
713 | this.explaination = this.makeExplain();
714 | };
715 |
716 | JSSpec.PropertyLengthMatcher.prototype.makeExplain = function() {
717 | if(this.o._type == 'String' && this.property == 'length') {
718 | this.match = this.conditionMet(this.o);
719 | return this.match ? '' : this.makeExplainForString();
720 | } else if(typeof this.o.length != 'undefined' && this.property == "length") {
721 | this.match = this.conditionMet(this.o);
722 | return this.match ? '' : this.makeExplainForArray();
723 | } else if(typeof this.o[this.property] != 'undefined' && this.o[this.property] != null) {
724 | this.match = this.conditionMet(this.o[this.property]);
725 | return this.match ? '' : this.makeExplainForObject();
726 | } else if(typeof this.o[this.property] == 'undefined' || this.o[this.property] == null) {
727 | this.match = false;
728 | return this.makeExplainForNoProperty();
729 | }
730 |
731 | this.match = true;
732 | };
733 |
734 | JSSpec.PropertyLengthMatcher.prototype.makeExplainForString = function() {
735 | var sb = [];
736 |
737 | var exp = this.num == 0 ?
738 | 'be an empty string' :
739 | 'have ' + this.condition + ' ' + this.num + ' characters';
740 |
741 | sb.push('actual value has ' + this.o.length + ' characters:
');
742 | sb.push('' + JSSpec.util.inspect(this.o) + '
');
743 | sb.push('but it should ' + exp + '.
');
744 |
745 | return sb.join("");
746 | };
747 |
748 | JSSpec.PropertyLengthMatcher.prototype.makeExplainForArray = function() {
749 | var sb = [];
750 |
751 | var exp = this.num == 0 ?
752 | 'be an empty array' :
753 | 'have ' + this.condition + ' ' + this.num + ' items';
754 |
755 | sb.push('actual value has ' + this.o.length + ' items:
');
756 | sb.push('' + JSSpec.util.inspect(this.o) + '
');
757 | sb.push('but it should ' + exp + '.
');
758 |
759 | return sb.join("");
760 | };
761 |
762 | JSSpec.PropertyLengthMatcher.prototype.makeExplainForObject = function() {
763 | var sb = [];
764 |
765 | var exp = this.num == 0 ?
766 | 'be empty' :
767 | 'have ' + this.condition + ' ' + this.num + ' ' + this.property + '.';
768 |
769 | sb.push('actual value has ' + this.o[this.property].length + ' ' + this.property + ':
');
770 | sb.push('' + JSSpec.util.inspect(this.o, false, this.property) + '
');
771 | sb.push('but it should ' + exp + '.
');
772 |
773 | return sb.join("");
774 | };
775 |
776 | JSSpec.PropertyLengthMatcher.prototype.makeExplainForNoProperty = function() {
777 | var sb = [];
778 |
779 | sb.push('actual value:
');
780 | sb.push('' + JSSpec.util.inspect(this.o) + '
');
781 | sb.push('should have ' + this.condition + ' ' + this.num + ' ' + this.property + ' but there\'s no such property.
');
782 |
783 | return sb.join("");
784 | };
785 |
786 | JSSpec.PropertyLengthMatcher.prototype.matches = function() {
787 | return this.match;
788 | };
789 |
790 | JSSpec.PropertyLengthMatcher.prototype.explain = function() {
791 | return this.explaination;
792 | };
793 |
794 | JSSpec.PropertyLengthMatcher.createInstance = function(num, property, o, condition) {
795 | return new JSSpec.PropertyLengthMatcher(num, property, o, condition);
796 | };
797 |
798 | /**
799 | * EqualityMatcher
800 | */
801 | JSSpec.EqualityMatcher = {};
802 |
803 | JSSpec.EqualityMatcher.createInstance = function(expected, actual) {
804 | if(expected == null || actual == null) {
805 | return new JSSpec.NullEqualityMatcher(expected, actual);
806 | } else if(expected._type && expected._type == actual._type) {
807 | if(expected._type == "String") {
808 | return new JSSpec.StringEqualityMatcher(expected, actual);
809 | } else if(expected._type == "Date") {
810 | return new JSSpec.DateEqualityMatcher(expected, actual);
811 | } else if(expected._type == "Number") {
812 | return new JSSpec.NumberEqualityMatcher(expected, actual);
813 | } else if(expected._type == "Array") {
814 | return new JSSpec.ArrayEqualityMatcher(expected, actual);
815 | } else if(expected._type == "Boolean") {
816 | return new JSSpec.BooleanEqualityMatcher(expected, actual);
817 | }
818 | }
819 |
820 | return new JSSpec.ObjectEqualityMatcher(expected, actual);
821 | };
822 |
823 | JSSpec.EqualityMatcher.basicExplain = function(expected, actual, expectedDesc, actualDesc) {
824 | var sb = [];
825 |
826 | sb.push(actualDesc || 'actual value:
');
827 | sb.push('' + JSSpec.util.inspect(actual) + '
');
828 | sb.push(expectedDesc || 'should be:
');
829 | sb.push('' + JSSpec.util.inspect(expected) + '
');
830 |
831 | return sb.join("");
832 | };
833 |
834 | JSSpec.EqualityMatcher.diffExplain = function(expected, actual) {
835 | var sb = [];
836 |
837 | sb.push('diff:
');
838 | sb.push('');
839 |
840 | var dmp = new diff_match_patch();
841 | var diff = dmp.diff_main(expected, actual);
842 | dmp.diff_cleanupEfficiency(diff);
843 |
844 | sb.push(JSSpec.util.inspect(dmp.diff_prettyHtml(diff), true));
845 |
846 | sb.push('
');
847 |
848 | return sb.join("");
849 | };
850 |
851 | /**
852 | * BooleanEqualityMatcher
853 | */
854 | JSSpec.BooleanEqualityMatcher = function(expected, actual) {
855 | this.expected = expected;
856 | this.actual = actual;
857 | };
858 |
859 | JSSpec.BooleanEqualityMatcher.prototype.explain = function() {
860 | var sb = [];
861 |
862 | sb.push('actual value:
');
863 | sb.push('' + JSSpec.util.inspect(this.actual) + '
');
864 | sb.push('should be:
');
865 | sb.push('' + JSSpec.util.inspect(this.expected) + '
');
866 |
867 | return sb.join("");
868 | };
869 |
870 | JSSpec.BooleanEqualityMatcher.prototype.matches = function() {
871 | return this.expected == this.actual;
872 | };
873 |
874 | /**
875 | * NullEqualityMatcher
876 | */
877 | JSSpec.NullEqualityMatcher = function(expected, actual) {
878 | this.expected = expected;
879 | this.actual = actual;
880 | };
881 |
882 | JSSpec.NullEqualityMatcher.prototype.matches = function() {
883 | return this.expected == this.actual && typeof this.expected == typeof this.actual;
884 | };
885 |
886 | JSSpec.NullEqualityMatcher.prototype.explain = function() {
887 | return JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual);
888 | };
889 |
890 | JSSpec.DateEqualityMatcher = function(expected, actual) {
891 | this.expected = expected;
892 | this.actual = actual;
893 | };
894 |
895 | JSSpec.DateEqualityMatcher.prototype.matches = function() {
896 | return this.expected.getTime() == this.actual.getTime();
897 | };
898 |
899 | JSSpec.DateEqualityMatcher.prototype.explain = function() {
900 | var sb = [];
901 |
902 | sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual));
903 | sb.push(JSSpec.EqualityMatcher.diffExplain(this.expected.toString(), this.actual.toString()));
904 |
905 | return sb.join("");
906 | };
907 |
908 | /**
909 | * ObjectEqualityMatcher
910 | */
911 | JSSpec.ObjectEqualityMatcher = function(expected, actual) {
912 | this.expected = expected;
913 | this.actual = actual;
914 | this.match = this.expected == this.actual;
915 | this.explaination = this.makeExplain();
916 | };
917 |
918 | JSSpec.ObjectEqualityMatcher.prototype.matches = function() {return this.match};
919 |
920 | JSSpec.ObjectEqualityMatcher.prototype.explain = function() {return this.explaination};
921 |
922 | JSSpec.ObjectEqualityMatcher.prototype.makeExplain = function() {
923 | if(this.expected == this.actual) {
924 | this.match = true;
925 | return "";
926 | }
927 |
928 | if(JSSpec.util.isDomNode(this.expected)) {
929 | return this.makeExplainForDomNode();
930 | }
931 |
932 | var key, expectedHasItem, actualHasItem;
933 |
934 | for(key in this.expected) {
935 | expectedHasItem = this.expected[key] != null && typeof this.expected[key] != 'undefined';
936 | actualHasItem = this.actual[key] != null && typeof this.actual[key] != 'undefined';
937 | if(expectedHasItem && !actualHasItem) return this.makeExplainForMissingItem(key);
938 | }
939 | for(key in this.actual) {
940 | expectedHasItem = this.expected[key] != null && typeof this.expected[key] != 'undefined';
941 | actualHasItem = this.actual[key] != null && typeof this.actual[key] != 'undefined';
942 | if(actualHasItem && !expectedHasItem) return this.makeExplainForUnknownItem(key);
943 | }
944 |
945 | for(key in this.expected) {
946 | var matcher = JSSpec.EqualityMatcher.createInstance(this.expected[key], this.actual[key]);
947 | if(!matcher.matches()) return this.makeExplainForItemMismatch(key);
948 | }
949 |
950 | this.match = true;
951 | };
952 |
953 | JSSpec.ObjectEqualityMatcher.prototype.makeExplainForDomNode = function(key) {
954 | var sb = [];
955 |
956 | sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual));
957 |
958 | return sb.join("");
959 | };
960 |
961 | JSSpec.ObjectEqualityMatcher.prototype.makeExplainForMissingItem = function(key) {
962 | var sb = [];
963 |
964 | sb.push('actual value has no item named ' + JSSpec.util.inspect(key) + '
');
965 | sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
');
966 | sb.push('but it should have the item whose value is ' + JSSpec.util.inspect(this.expected[key]) + '
');
967 | sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
');
968 |
969 | return sb.join("");
970 | };
971 |
972 | JSSpec.ObjectEqualityMatcher.prototype.makeExplainForUnknownItem = function(key) {
973 | var sb = [];
974 |
975 | sb.push('actual value has item named ' + JSSpec.util.inspect(key) + '
');
976 | sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
');
977 | sb.push('but there should be no such item
');
978 | sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
');
979 |
980 | return sb.join("");
981 | };
982 |
983 | JSSpec.ObjectEqualityMatcher.prototype.makeExplainForItemMismatch = function(key) {
984 | var sb = [];
985 |
986 | sb.push('actual value has an item named ' + JSSpec.util.inspect(key) + ' whose value is ' + JSSpec.util.inspect(this.actual[key]) + '
');
987 | sb.push('' + JSSpec.util.inspect(this.actual, false, key) + '
');
988 | sb.push('but it\'s value should be ' + JSSpec.util.inspect(this.expected[key]) + '
');
989 | sb.push('' + JSSpec.util.inspect(this.expected, false, key) + '
');
990 |
991 | return sb.join("");
992 | };
993 |
994 |
995 |
996 |
997 | /**
998 | * ArrayEqualityMatcher
999 | */
1000 | JSSpec.ArrayEqualityMatcher = function(expected, actual) {
1001 | this.expected = expected;
1002 | this.actual = actual;
1003 | this.match = this.expected == this.actual;
1004 | this.explaination = this.makeExplain();
1005 | };
1006 |
1007 | JSSpec.ArrayEqualityMatcher.prototype.matches = function() {return this.match};
1008 |
1009 | JSSpec.ArrayEqualityMatcher.prototype.explain = function() {return this.explaination};
1010 |
1011 | JSSpec.ArrayEqualityMatcher.prototype.makeExplain = function() {
1012 | if(this.expected.length != this.actual.length) return this.makeExplainForLengthMismatch();
1013 |
1014 | for(var i = 0; i < this.expected.length; i++) {
1015 | var matcher = JSSpec.EqualityMatcher.createInstance(this.expected[i], this.actual[i]);
1016 | if(!matcher.matches()) return this.makeExplainForItemMismatch(i);
1017 | }
1018 |
1019 | this.match = true;
1020 | };
1021 |
1022 | JSSpec.ArrayEqualityMatcher.prototype.makeExplainForLengthMismatch = function() {
1023 | return JSSpec.EqualityMatcher.basicExplain(
1024 | this.expected,
1025 | this.actual,
1026 | 'but it should be ' + this.expected.length + '
',
1027 | 'actual value has ' + this.actual.length + ' items
'
1028 | );
1029 | };
1030 |
1031 | JSSpec.ArrayEqualityMatcher.prototype.makeExplainForItemMismatch = function(index) {
1032 | var postfix = ["th", "st", "nd", "rd", "th"][Math.min((index + 1) % 10,4)];
1033 |
1034 | var sb = [];
1035 |
1036 | sb.push('' + (index + 1) + postfix + ' item (index ' + index + ') of actual value is ' + JSSpec.util.inspect(this.actual[index]) + ':
');
1037 | sb.push('' + JSSpec.util.inspect(this.actual, false, index) + '
');
1038 | sb.push('but it should be ' + JSSpec.util.inspect(this.expected[index]) + ':
');
1039 | sb.push('' + JSSpec.util.inspect(this.expected, false, index) + '
');
1040 |
1041 | return sb.join("");
1042 | };
1043 |
1044 | /**
1045 | * NumberEqualityMatcher
1046 | */
1047 | JSSpec.NumberEqualityMatcher = function(expected, actual) {
1048 | this.expected = expected;
1049 | this.actual = actual;
1050 | };
1051 |
1052 | JSSpec.NumberEqualityMatcher.prototype.matches = function() {
1053 | if(this.expected == this.actual) return true;
1054 | };
1055 |
1056 | JSSpec.NumberEqualityMatcher.prototype.explain = function() {
1057 | return JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual);
1058 | };
1059 |
1060 | /**
1061 | * StringEqualityMatcher
1062 | */
1063 | JSSpec.StringEqualityMatcher = function(expected, actual) {
1064 | this.expected = expected;
1065 | this.actual = actual;
1066 | };
1067 |
1068 | JSSpec.StringEqualityMatcher.prototype.matches = function() {
1069 | if(this.expected == this.actual) return true;
1070 | };
1071 |
1072 | JSSpec.StringEqualityMatcher.prototype.explain = function() {
1073 | var sb = [];
1074 |
1075 | sb.push(JSSpec.EqualityMatcher.basicExplain(this.expected, this.actual));
1076 | sb.push(JSSpec.EqualityMatcher.diffExplain(this.expected, this.actual));
1077 | return sb.join("");
1078 | };
1079 |
1080 | /**
1081 | * PatternMatcher
1082 | */
1083 | JSSpec.PatternMatcher = function(actual, pattern, condition) {
1084 | this.actual = actual;
1085 | this.pattern = pattern;
1086 | this.condition = condition;
1087 | this.match = false;
1088 | this.explaination = this.makeExplain();
1089 | };
1090 |
1091 | JSSpec.PatternMatcher.createInstance = function(actual, pattern, condition) {
1092 | return new JSSpec.PatternMatcher(actual, pattern, condition);
1093 | };
1094 |
1095 | JSSpec.PatternMatcher.prototype.makeExplain = function() {
1096 | var sb;
1097 | if(this.actual == null || this.actual._type != 'String') {
1098 | sb = [];
1099 | sb.push('actual value:
');
1100 | sb.push('' + JSSpec.util.inspect(this.actual) + '
');
1101 | sb.push('should ' + (this.condition ? '' : 'not') + ' match with pattern:
');
1102 | sb.push('' + JSSpec.util.inspect(this.pattern) + '
');
1103 | sb.push('but pattern matching cannot be performed.
');
1104 | return sb.join("");
1105 | } else {
1106 | this.match = this.condition == !!this.actual.match(this.pattern);
1107 | if(this.match) return "";
1108 |
1109 | sb = [];
1110 | sb.push('actual value:
');
1111 | sb.push('' + JSSpec.util.inspect(this.actual) + '
');
1112 | sb.push('should ' + (this.condition ? '' : 'not') + ' match with pattern:
');
1113 | sb.push('' + JSSpec.util.inspect(this.pattern) + '
');
1114 | return sb.join("");
1115 | }
1116 | };
1117 |
1118 | JSSpec.PatternMatcher.prototype.matches = function() {
1119 | return this.match;
1120 | };
1121 |
1122 | JSSpec.PatternMatcher.prototype.explain = function() {
1123 | return this.explaination;
1124 | };
1125 |
1126 | /**
1127 | * Domain Specific Languages
1128 | */
1129 | JSSpec.DSL = {};
1130 |
1131 | JSSpec.DSL.forString = {
1132 | normalizeHtml: function() {
1133 | var html = this;
1134 |
1135 | // Uniformize quotation, turn tag names and attribute names into lower case
1136 | html = html.replace(/<(\/?)(\w+)([^>]*?)>/img, function(str, closingMark, tagName, attrs) {
1137 | var sortedAttrs = JSSpec.util.sortHtmlAttrs(JSSpec.util.correctHtmlAttrQuotation(attrs).toLowerCase())
1138 | return "<" + closingMark + tagName.toLowerCase() + sortedAttrs + ">"
1139 | });
1140 |
1141 | // validation self-closing tags
1142 | html = html.replace(/<(br|hr|img)([^>]*?)>/mg, function(str, tag, attrs) {
1143 | return "<" + tag + attrs + " />";
1144 | });
1145 |
1146 | // append semi-colon at the end of style value
1147 | html = html.replace(/style="(.*?)"/mg, function(str, styleStr) {
1148 | styleStr = JSSpec.util.sortStyleEntries(styleStr.strip()); // for Safari
1149 | if(styleStr.charAt(styleStr.length - 1) != ';') styleStr += ";"
1150 |
1151 | return 'style="' + styleStr + '"'
1152 | });
1153 |
1154 | // sort style entries
1155 |
1156 | // remove empty style attributes
1157 | html = html.replace(/ style=";"/mg, "");
1158 |
1159 | // remove new-lines
1160 | html = html.replace(/\r/mg, '');
1161 | html = html.replace(/\n/mg, '');
1162 |
1163 | return html;
1164 | }
1165 | };
1166 |
1167 |
1168 |
1169 | JSSpec.DSL.describe = function(context, entries) {
1170 | JSSpec.specs.push(new JSSpec.Spec(context, entries));
1171 | };
1172 |
1173 | JSSpec.DSL.value_of = function(target) {
1174 | if(JSSpec._secondPass) return {};
1175 |
1176 | var subject = new JSSpec.DSL.Subject(target);
1177 | return subject;
1178 | };
1179 |
1180 | JSSpec.DSL.Subject = function(target) {
1181 | this.target = target;
1182 | };
1183 |
1184 | JSSpec.DSL.Subject.prototype._type = 'Subject';
1185 |
1186 | JSSpec.DSL.Subject.prototype.should_fail = function(message) {
1187 | JSSpec._assertionFailure = {message:message};
1188 | throw JSSpec._assertionFailure;
1189 | };
1190 |
1191 | JSSpec.DSL.Subject.prototype.should_be = function(expected) {
1192 | var matcher = JSSpec.EqualityMatcher.createInstance(expected, this.target);
1193 | if(!matcher.matches()) {
1194 | JSSpec._assertionFailure = {message:matcher.explain()};
1195 | throw JSSpec._assertionFailure;
1196 | }
1197 | };
1198 |
1199 | JSSpec.DSL.Subject.prototype.should_not_be = function(expected) {
1200 | // TODO JSSpec.EqualityMatcher should support 'condition'
1201 | var matcher = JSSpec.EqualityMatcher.createInstance(expected, this.target);
1202 | if(matcher.matches()) {
1203 | JSSpec._assertionFailure = {message:"'" + this.target + "' should not be '" + expected + "'"};
1204 | throw JSSpec._assertionFailure;
1205 | }
1206 | };
1207 |
1208 | JSSpec.DSL.Subject.prototype.should_be_empty = function() {
1209 | this.should_have(0, this.getType() == 'String' ? 'characters' : 'items');
1210 | };
1211 |
1212 | JSSpec.DSL.Subject.prototype.should_not_be_empty = function() {
1213 | this.should_have_at_least(1, this.getType() == 'String' ? 'characters' : 'items');
1214 | };
1215 |
1216 | JSSpec.DSL.Subject.prototype.should_be_true = function() {
1217 | this.should_be(true);
1218 | };
1219 |
1220 | JSSpec.DSL.Subject.prototype.should_be_false = function() {
1221 | this.should_be(false);
1222 | };
1223 |
1224 | JSSpec.DSL.Subject.prototype.should_be_null = function() {
1225 | this.should_be(null);
1226 | };
1227 |
1228 | JSSpec.DSL.Subject.prototype.should_be_undefined = function() {
1229 | this.should_be(undefined);
1230 | };
1231 |
1232 | JSSpec.DSL.Subject.prototype.should_not_be_null = function() {
1233 | this.should_not_be(null);
1234 | };
1235 |
1236 | JSSpec.DSL.Subject.prototype.should_not_be_undefined = function() {
1237 | this.should_not_be(undefined);
1238 | };
1239 |
1240 | JSSpec.DSL.Subject.prototype._should_have = function(num, property, condition) {
1241 | var matcher = JSSpec.PropertyLengthMatcher.createInstance(num, property, this.target, condition);
1242 | if(!matcher.matches()) {
1243 | JSSpec._assertionFailure = {message:matcher.explain()};
1244 | throw JSSpec._assertionFailure;
1245 | }
1246 | };
1247 |
1248 | JSSpec.DSL.Subject.prototype.should_have = function(num, property) {
1249 | this._should_have(num, property, "exactly");
1250 | };
1251 |
1252 | JSSpec.DSL.Subject.prototype.should_have_exactly = function(num, property) {
1253 | this._should_have(num, property, "exactly");
1254 | };
1255 |
1256 | JSSpec.DSL.Subject.prototype.should_have_at_least = function(num, property) {
1257 | this._should_have(num, property, "at least");
1258 | };
1259 |
1260 | JSSpec.DSL.Subject.prototype.should_have_at_most = function(num, property) {
1261 | this._should_have(num, property, "at most");
1262 | };
1263 |
1264 | JSSpec.DSL.Subject.prototype.should_include = function(expected) {
1265 | var matcher = JSSpec.IncludeMatcher.createInstance(this.target, expected, true);
1266 | if(!matcher.matches()) {
1267 | JSSpec._assertionFailure = {message:matcher.explain()};
1268 | throw JSSpec._assertionFailure;
1269 | }
1270 | };
1271 |
1272 | JSSpec.DSL.Subject.prototype.should_not_include = function(expected) {
1273 | var matcher = JSSpec.IncludeMatcher.createInstance(this.target, expected, false);
1274 | if(!matcher.matches()) {
1275 | JSSpec._assertionFailure = {message:matcher.explain()};
1276 | throw JSSpec._assertionFailure;
1277 | }
1278 | };
1279 |
1280 | JSSpec.DSL.Subject.prototype.should_match = function(pattern) {
1281 | var matcher = JSSpec.PatternMatcher.createInstance(this.target, pattern, true);
1282 | if(!matcher.matches()) {
1283 | JSSpec._assertionFailure = {message:matcher.explain()};
1284 | throw JSSpec._assertionFailure;
1285 | }
1286 | }
1287 | JSSpec.DSL.Subject.prototype.should_not_match = function(pattern) {
1288 | var matcher = JSSpec.PatternMatcher.createInstance(this.target, pattern, false);
1289 | if(!matcher.matches()) {
1290 | JSSpec._assertionFailure = {message:matcher.explain()};
1291 | throw JSSpec._assertionFailure;
1292 | }
1293 | };
1294 |
1295 | JSSpec.DSL.Subject.prototype.getType = function() {
1296 | if(typeof this.target == 'undefined') {
1297 | return 'undefined';
1298 | } else if(this.target == null) {
1299 | return 'null';
1300 | } else if(this.target._type) {
1301 | return this.target._type;
1302 | } else if(JSSpec.util.isDomNode(this.target)) {
1303 | return 'DomNode';
1304 | } else {
1305 | return 'object';
1306 | }
1307 | };
1308 |
1309 | /**
1310 | * Utilities
1311 | */
1312 | JSSpec.util = {
1313 | escapeTags: function(string) {
1314 | return string.replace(//img, '>');
1315 | },
1316 | parseOptions: function(defaults) {
1317 | var options = defaults;
1318 |
1319 | var url = location.href;
1320 | var queryIndex = url.indexOf('?');
1321 | if(queryIndex == -1) return options;
1322 |
1323 | var query = url.substring(queryIndex + 1);
1324 | var pairs = query.split('&');
1325 | for(var i = 0; i < pairs.length; i++) {
1326 | var tokens = pairs[i].split('=');
1327 | options[tokens[0]] = tokens[1];
1328 | }
1329 |
1330 | return options;
1331 | },
1332 | correctHtmlAttrQuotation: function(html) {
1333 | html = html.replace(/(\w+)=['"]([^'"]+)['"]/mg,function (str, name, value) {return name + '=' + '"' + value + '"';});
1334 | html = html.replace(/(\w+)=([^ '"]+)/mg,function (str, name, value) {return name + '=' + '"' + value + '"';});
1335 | html = html.replace(/'/mg, '"');
1336 |
1337 | return html;
1338 | },
1339 | sortHtmlAttrs: function(html) {
1340 | var attrs = [];
1341 | html.replace(/((\w+)="[^"]+")/mg, function(str, matched) {
1342 | attrs.push(matched);
1343 | });
1344 | return attrs.length == 0 ? "" : " " + attrs.sort().join(" ");
1345 | },
1346 | sortStyleEntries: function(styleText) {
1347 | var entries = styleText.split(/; /);
1348 | return entries.sort().join("; ");
1349 | },
1350 | escapeHtml: function(str) {
1351 | if(!this._div) {
1352 | this._div = document.createElement("DIV");
1353 | this._text = document.createTextNode('');
1354 | this._div.appendChild(this._text);
1355 | }
1356 | this._text.data = str;
1357 | return this._div.innerHTML;
1358 | },
1359 | isDomNode: function(o) {
1360 | // TODO: make it more stricter
1361 | return (typeof o.nodeName == 'string') && (typeof o.nodeType == 'number');
1362 | },
1363 | inspectDomPath: function(o) {
1364 | var sb = [];
1365 | while(o && o.nodeName != '#document' && o.parent) {
1366 | var siblings = o.parentNode.childNodes;
1367 | for(var i = 0; i < siblings.length; i++) {
1368 | if(siblings[i] == o) {
1369 | sb.push(o.nodeName + (i == 0 ? '' : '[' + i + ']'));
1370 | break;
1371 | }
1372 | }
1373 | o = o.parentNode;
1374 | }
1375 | return sb.join(" > ");
1376 | },
1377 | inspectDomNode: function(o) {
1378 | if(o.nodeType == 1) {
1379 | var nodeName = o.nodeName.toLowerCase();
1380 | var sb = [];
1381 | sb.push('');
1382 | sb.push("<");
1383 | sb.push(nodeName);
1384 |
1385 | var attrs = o.attributes;
1386 | for(var i = 0; i < attrs.length; i++) {
1387 | if(
1388 | attrs[i].nodeValue &&
1389 | attrs[i].nodeName != 'contentEditable' &&
1390 | attrs[i].nodeName != 'style' &&
1391 | typeof attrs[i].nodeValue != 'function'
1392 | ) sb.push(' ' + attrs[i].nodeName.toLowerCase() + '="' + attrs[i].nodeValue + '"');
1393 | }
1394 | if(o.style && o.style.cssText) {
1395 | sb.push(' style="' + o.style.cssText + '"');
1396 | }
1397 | sb.push('>');
1398 | sb.push(JSSpec.util.escapeHtml(o.innerHTML));
1399 | sb.push('</' + nodeName + '>');
1400 | sb.push(' (' + JSSpec.util.inspectDomPath(o) + ')' );
1401 | sb.push('');
1402 | return sb.join("");
1403 | } else if(o.nodeType == 3) {
1404 | return '#text ' + o.nodeValue + '';
1405 | } else {
1406 | return 'UnknownDomNode';
1407 | }
1408 | },
1409 | inspect: function(o, dontEscape, emphasisKey) {
1410 | var sb, inspected;
1411 |
1412 | if(typeof o == 'undefined') return 'undefined';
1413 | if(o == null) return 'null';
1414 | if(o._type == 'String') return '"' + (dontEscape ? o : JSSpec.util.escapeHtml(o)) + '"';
1415 |
1416 | if(o._type == 'Date') {
1417 | return '"' + o.toString() + '"';
1418 | }
1419 |
1420 | if(o._type == 'Number') return '' + (dontEscape ? o : JSSpec.util.escapeHtml(o)) + '';
1421 |
1422 | if(o._type == 'Boolean') return '' + o + '';
1423 |
1424 | if(o._type == 'RegExp') return '' + JSSpec.util.escapeHtml(o.toString()) + '';
1425 |
1426 | if(JSSpec.util.isDomNode(o)) return JSSpec.util.inspectDomNode(o);
1427 |
1428 | if(o._type == 'Array' || typeof o.length != 'undefined') {
1429 | sb = [];
1430 | for(var i = 0; i < o.length; i++) {
1431 | inspected = JSSpec.util.inspect(o[i]);
1432 | sb.push(i == emphasisKey ? ('' + inspected + '') : inspected);
1433 | }
1434 | return '[' + sb.join(', ') + ']';
1435 | }
1436 |
1437 | // object
1438 | sb = [];
1439 | for(var key in o) {
1440 | if(key == 'should') continue;
1441 |
1442 | inspected = JSSpec.util.inspect(key) + ":" + JSSpec.util.inspect(o[key]);
1443 | sb.push(key == emphasisKey ? ('' + inspected + '') : inspected);
1444 | }
1445 | return '{' + sb.join(', ') + '}';
1446 | }
1447 | };
1448 |
1449 | describe = JSSpec.DSL.describe;
1450 | behavior_of = JSSpec.DSL.describe;
1451 | value_of = JSSpec.DSL.value_of;
1452 | expect = JSSpec.DSL.value_of; // @deprecated
1453 |
1454 | String.prototype._type = "String";
1455 | Number.prototype._type = "Number";
1456 | Date.prototype._type = "Date";
1457 | Array.prototype._type = "Array";
1458 | Boolean.prototype._type = "Boolean";
1459 | RegExp.prototype._type = "RegExp";
1460 |
1461 | var targets = [Array.prototype, Date.prototype, Number.prototype, String.prototype, Boolean.prototype, RegExp.prototype];
1462 |
1463 | String.prototype.normalizeHtml = JSSpec.DSL.forString.normalizeHtml;
1464 | String.prototype.asHtml = String.prototype.normalizeHtml; //@deprecated
1465 |
1466 |
1467 |
1468 | /**
1469 | * Main
1470 | */
1471 | JSSpec.defaultOptions = {
1472 | autorun: 1,
1473 | specIdBeginsWith: 0,
1474 | exampleIdBeginsWith: 0,
1475 | autocollapse: 1
1476 | };
1477 | JSSpec.options = JSSpec.util.parseOptions(JSSpec.defaultOptions);
1478 |
1479 | JSSpec.Spec.id = JSSpec.options.specIdBeginsWith;
1480 | JSSpec.Example.id = JSSpec.options.exampleIdBeginsWith;
1481 |
1482 |
1483 |
1484 | window.onload = function() {
1485 | if(JSSpec.specs.length > 0) {
1486 | if(!JSSpec.options.inSuite) {
1487 | JSSpec.runner = new JSSpec.Runner(JSSpec.specs, new JSSpec.Logger());
1488 | if(JSSpec.options.rerun) {
1489 | JSSpec.runner.rerun(decodeURIComponent(JSSpec.options.rerun));
1490 | } else {
1491 | JSSpec.runner.run();
1492 | }
1493 | } else {
1494 | // in suite, send all specs to parent
1495 | var parentWindow = window.frames.parent.window;
1496 | for(var i = 0; i < JSSpec.specs.length; i++) {
1497 | parentWindow.JSSpec.specs.push(JSSpec.specs[i]);
1498 | }
1499 | }
1500 | } else {
1501 | var links = document.getElementById('list').getElementsByTagName('A');
1502 | var frameContainer = document.createElement('DIV');
1503 | frameContainer.style.display = 'none';
1504 | document.body.appendChild(frameContainer);
1505 |
1506 | for(var i = 0; i < links.length; i++) {
1507 | var frame = document.createElement('IFRAME');
1508 | frame.src = links[i].href + '?inSuite=0&specIdBeginsWith=' + (i * 10000) + '&exampleIdBeginsWith=' + (i * 10000);
1509 | frameContainer.appendChild(frame);
1510 | }
1511 | }
1512 | }
--------------------------------------------------------------------------------
/Specs/Assets/Scripts/DiffMatchPatch.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Diff Match and Patch
3 | *
4 | * Copyright 2006 Google Inc.
5 | * http://code.google.com/p/google-diff-match-patch/
6 | *
7 | * Licensed under the Apache License, Version 2.0 (the "License");
8 | * you may not use this file except in compliance with the License.
9 | * You may obtain a copy of the License at
10 | *
11 | * http://www.apache.org/licenses/LICENSE-2.0
12 | *
13 | * Unless required by applicable law or agreed to in writing, software
14 | * distributed under the License is distributed on an "AS IS" BASIS,
15 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 | * See the License for the specific language governing permissions and
17 | * limitations under the License.
18 | */
19 |
20 | /**
21 | * @fileoverview Computes the difference between two texts to create a patch.
22 | * Applies the patch onto another text, allowing for errors.
23 | * @author fraser@google.com (Neil Fraser)
24 | */
25 |
26 | /**
27 | * Class containing the diff, match and patch methods.
28 | * @constructor
29 | */
30 | function diff_match_patch() {
31 |
32 | // Defaults.
33 | // Redefine these in your program to override the defaults.
34 |
35 | // Number of seconds to map a diff before giving up. (0 for infinity)
36 | this.Diff_Timeout = 1.0;
37 | // Cost of an empty edit operation in terms of edit characters.
38 | this.Diff_EditCost = 4;
39 | // The size beyond which the double-ended diff activates.
40 | // Double-ending is twice as fast, but less accurate.
41 | this.Diff_DualThreshold = 32;
42 | // Tweak the relative importance (0.0 = accuracy, 1.0 = proximity)
43 | this.Match_Balance = 0.5;
44 | // At what point is no match declared (0.0 = perfection, 1.0 = very loose)
45 | this.Match_Threshold = 0.5;
46 | // The min and max cutoffs used when computing text lengths.
47 | this.Match_MinLength = 100;
48 | this.Match_MaxLength = 1000;
49 | // Chunk size for context length.
50 | this.Patch_Margin = 4;
51 |
52 | /**
53 | * Compute the number of bits in an int.
54 | * The normal answer for JavaScript is 32.
55 | * @return {number} Max bits
56 | */
57 | function getMaxBits() {
58 | var maxbits = 0;
59 | var oldi = 1;
60 | var newi = 2;
61 | while (oldi != newi) {
62 | maxbits++;
63 | oldi = newi;
64 | newi = newi << 1;
65 | }
66 | return maxbits;
67 | }
68 | // How many bits in a number?
69 | this.Match_MaxBits = getMaxBits();
70 | }
71 |
72 |
73 | // DIFF FUNCTIONS
74 |
75 |
76 | /**
77 | * The data structure representing a diff is an array of tuples:
78 | * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
79 | * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
80 | */
81 | var DIFF_DELETE = -1;
82 | var DIFF_INSERT = 1;
83 | var DIFF_EQUAL = 0;
84 |
85 |
86 | /**
87 | * Find the differences between two texts. Simplifies the problem by stripping
88 | * any common prefix or suffix off the texts before diffing.
89 | * @param {string} text1 Old string to be diffed
90 | * @param {string} text2 New string to be diffed
91 | * @param {boolean} opt_checklines Optional speedup flag. If present and false,
92 | * then don't run a line-level diff first to identify the changed areas.
93 | * Defaults to true, which does a faster, slightly less optimal diff
94 | * @return {Array.>} Array of diff tuples
95 | */
96 | diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines) {
97 | // Check for equality (speedup)
98 | if (text1 == text2) {
99 | return [[DIFF_EQUAL, text1]];
100 | }
101 |
102 | if (typeof opt_checklines == 'undefined') {
103 | opt_checklines = true;
104 | }
105 | var checklines = opt_checklines;
106 |
107 | // Trim off common prefix (speedup)
108 | var commonlength = this.diff_commonPrefix(text1, text2);
109 | var commonprefix = text1.substring(0, commonlength);
110 | text1 = text1.substring(commonlength);
111 | text2 = text2.substring(commonlength);
112 |
113 | // Trim off common suffix (speedup)
114 | commonlength = this.diff_commonSuffix(text1, text2);
115 | var commonsuffix = text1.substring(text1.length - commonlength);
116 | text1 = text1.substring(0, text1.length - commonlength);
117 | text2 = text2.substring(0, text2.length - commonlength);
118 |
119 | // Compute the diff on the middle block
120 | var diffs = this.diff_compute(text1, text2, checklines);
121 |
122 | // Restore the prefix and suffix
123 | if (commonprefix) {
124 | diffs.unshift([DIFF_EQUAL, commonprefix]);
125 | }
126 | if (commonsuffix) {
127 | diffs.push([DIFF_EQUAL, commonsuffix]);
128 | }
129 | this.diff_cleanupMerge(diffs);
130 | return diffs;
131 | };
132 |
133 |
134 | /**
135 | * Find the differences between two texts. Assumes that the texts do not
136 | * have any common prefix or suffix.
137 | * @param {string} text1 Old string to be diffed
138 | * @param {string} text2 New string to be diffed
139 | * @param {boolean} checklines Speedup flag. If false, then don't run a
140 | * line-level diff first to identify the changed areas.
141 | * If true, then run a faster, slightly less optimal diff
142 | * @return {Array.>} Array of diff tuples
143 | * @private
144 | */
145 | diff_match_patch.prototype.diff_compute = function(text1, text2, checklines) {
146 | var diffs;
147 |
148 | if (!text1) {
149 | // Just add some text (speedup)
150 | return [[DIFF_INSERT, text2]];
151 | }
152 |
153 | if (!text2) {
154 | // Just delete some text (speedup)
155 | return [[DIFF_DELETE, text1]];
156 | }
157 |
158 | var longtext = text1.length > text2.length ? text1 : text2;
159 | var shorttext = text1.length > text2.length ? text2 : text1;
160 | var i = longtext.indexOf(shorttext);
161 | if (i != -1) {
162 | // Shorter text is inside the longer text (speedup)
163 | diffs = [[DIFF_INSERT, longtext.substring(0, i)],
164 | [DIFF_EQUAL, shorttext],
165 | [DIFF_INSERT, longtext.substring(i + shorttext.length)]];
166 | // Swap insertions for deletions if diff is reversed.
167 | if (text1.length > text2.length) {
168 | diffs[0][0] = diffs[2][0] = DIFF_DELETE;
169 | }
170 | return diffs;
171 | }
172 | longtext = shorttext = null; // Garbage collect
173 |
174 | // Check to see if the problem can be split in two.
175 | var hm = this.diff_halfMatch(text1, text2);
176 | if (hm) {
177 | // A half-match was found, sort out the return data.
178 | var text1_a = hm[0];
179 | var text1_b = hm[1];
180 | var text2_a = hm[2];
181 | var text2_b = hm[3];
182 | var mid_common = hm[4];
183 | // Send both pairs off for separate processing.
184 | var diffs_a = this.diff_main(text1_a, text2_a, checklines);
185 | var diffs_b = this.diff_main(text1_b, text2_b, checklines);
186 | // Merge the results.
187 | return diffs_a.concat([[DIFF_EQUAL, mid_common]], diffs_b);
188 | }
189 |
190 | // Perform a real diff.
191 | if (checklines && (text1.length < 100 || text2.length < 100)) {
192 | // Too trivial for the overhead.
193 | checklines = false;
194 | }
195 | var linearray;
196 | if (checklines) {
197 | // Scan the text on a line-by-line basis first.
198 | var a = this.diff_linesToChars(text1, text2);
199 | text1 = a[0];
200 | text2 = a[1];
201 | linearray = a[2];
202 | }
203 | diffs = this.diff_map(text1, text2);
204 | if (!diffs) {
205 | // No acceptable result.
206 | diffs = [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
207 | }
208 | if (checklines) {
209 | // Convert the diff back to original text.
210 | this.diff_charsToLines(diffs, linearray);
211 | // Eliminate freak matches (e.g. blank lines)
212 | this.diff_cleanupSemantic(diffs);
213 |
214 | // Rediff any replacement blocks, this time character-by-character.
215 | // Add a dummy entry at the end.
216 | diffs.push([DIFF_EQUAL, '']);
217 | var pointer = 0;
218 | var count_delete = 0;
219 | var count_insert = 0;
220 | var text_delete = '';
221 | var text_insert = '';
222 | while (pointer < diffs.length) {
223 | switch (diffs[pointer][0]) {
224 | case DIFF_INSERT:
225 | count_insert++;
226 | text_insert += diffs[pointer][1];
227 | break;
228 | case DIFF_DELETE:
229 | count_delete++;
230 | text_delete += diffs[pointer][1];
231 | break;
232 | case DIFF_EQUAL:
233 | // Upon reaching an equality, check for prior redundancies.
234 | if (count_delete >= 1 && count_insert >= 1) {
235 | // Delete the offending records and add the merged ones.
236 | var a = this.diff_main(text_delete, text_insert, false);
237 | diffs.splice(pointer - count_delete - count_insert,
238 | count_delete + count_insert);
239 | pointer = pointer - count_delete - count_insert;
240 | for (var j = a.length - 1; j >= 0; j--) {
241 | diffs.splice(pointer, 0, a[j]);
242 | }
243 | pointer = pointer + a.length;
244 | }
245 | count_insert = 0;
246 | count_delete = 0;
247 | text_delete = '';
248 | text_insert = '';
249 | break;
250 | }
251 | pointer++;
252 | }
253 | diffs.pop(); // Remove the dummy entry at the end.
254 | }
255 | return diffs;
256 | };
257 |
258 |
259 | /**
260 | * Split two texts into an array of strings. Reduce the texts to a string of
261 | * hashes where each Unicode character represents one line.
262 | * @param {string} text1 First string
263 | * @param {string} text2 Second string
264 | * @return {Array.>} Three element Array, containing the
265 | * encoded text1, the encoded text2 and the array of unique strings. The
266 | * zeroth element of the array of unique strings is intentionally blank.
267 | * @private
268 | */
269 | diff_match_patch.prototype.diff_linesToChars = function(text1, text2) {
270 | var lineArray = []; // e.g. lineArray[4] == 'Hello\n'
271 | var lineHash = {}; // e.g. lineHash['Hello\n'] == 4
272 |
273 | // '\x00' is a valid character, but various debuggers don't like it.
274 | // So we'll insert a junk entry to avoid generating a null character.
275 | lineArray[0] = '';
276 |
277 | /**
278 | * Split a text into an array of strings. Reduce the texts to a string of
279 | * hashes where each Unicode character represents one line.
280 | * Modifies linearray and linehash through being a closure.
281 | * @param {string} text String to encode
282 | * @return {string} Encoded string
283 | * @private
284 | */
285 | function diff_linesToCharsMunge(text) {
286 | var chars = '';
287 | // Walk the text, pulling out a substring for each line.
288 | // text.split('\n') would would temporarily double our memory footprint.
289 | // Modifying text would create many large strings to garbage collect.
290 | var lineStart = 0;
291 | var lineEnd = -1;
292 | // Keeping our own length variable is faster than looking it up.
293 | var lineArrayLength = lineArray.length;
294 | while (lineEnd < text.length - 1) {
295 | lineEnd = text.indexOf('\n', lineStart);
296 | if (lineEnd == -1) {
297 | lineEnd = text.length - 1;
298 | }
299 | var line = text.substring(lineStart, lineEnd + 1);
300 | lineStart = lineEnd + 1;
301 |
302 | if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :
303 | (lineHash[line] !== undefined)) {
304 | chars += String.fromCharCode(lineHash[line]);
305 | } else {
306 | chars += String.fromCharCode(lineArrayLength);
307 | lineHash[line] = lineArrayLength;
308 | lineArray[lineArrayLength++] = line;
309 | }
310 | }
311 | return chars;
312 | }
313 |
314 | var chars1 = diff_linesToCharsMunge(text1);
315 | var chars2 = diff_linesToCharsMunge(text2);
316 | return [chars1, chars2, lineArray];
317 | };
318 |
319 |
320 | /**
321 | * Rehydrate the text in a diff from a string of line hashes to real lines of
322 | * text.
323 | * @param {Array.>} diffs Array of diff tuples
324 | * @param {Array.} lineArray Array of unique strings
325 | * @private
326 | */
327 | diff_match_patch.prototype.diff_charsToLines = function(diffs, lineArray) {
328 | for (var x = 0; x < diffs.length; x++) {
329 | var chars = diffs[x][1];
330 | var text = [];
331 | for (var y = 0; y < chars.length; y++) {
332 | text[y] = lineArray[chars.charCodeAt(y)];
333 | }
334 | diffs[x][1] = text.join('');
335 | }
336 | };
337 |
338 |
339 | /**
340 | * Explore the intersection points between the two texts.
341 | * @param {string} text1 Old string to be diffed
342 | * @param {string} text2 New string to be diffed
343 | * @return {Array.>?} Array of diff tuples or null if no diff
344 | * available
345 | * @private
346 | */
347 | diff_match_patch.prototype.diff_map = function(text1, text2) {
348 | // Don't run for too long.
349 | var ms_end = (new Date()).getTime() + this.Diff_Timeout * 1000;
350 | var max_d = text1.length + text2.length - 1;
351 | var doubleEnd = this.Diff_DualThreshold * 2 < max_d;
352 | var v_map1 = [];
353 | var v_map2 = [];
354 | var v1 = {};
355 | var v2 = {};
356 | v1[1] = 0;
357 | v2[1] = 0;
358 | var x, y;
359 | var footstep; // Used to track overlapping paths.
360 | var footsteps = {};
361 | var done = false;
362 | // Safari 1.x doesn't have hasOwnProperty
363 | var hasOwnProperty = !!(footsteps.hasOwnProperty);
364 | // If the total number of characters is odd, then the front path will collide
365 | // with the reverse path.
366 | var front = (text1.length + text2.length) % 2;
367 | for (var d = 0; d < max_d; d++) {
368 | // Bail out if timeout reached.
369 | if (this.Diff_Timeout > 0 && (new Date()).getTime() > ms_end) {
370 | return null;
371 | }
372 |
373 | // Walk the front path one step.
374 | v_map1[d] = {};
375 | for (var k = -d; k <= d; k += 2) {
376 | if (k == -d || k != d && v1[k - 1] < v1[k + 1]) {
377 | x = v1[k + 1];
378 | } else {
379 | x = v1[k - 1] + 1;
380 | }
381 | y = x - k;
382 | if (doubleEnd) {
383 | footstep = x + ',' + y;
384 | if (front && (hasOwnProperty ? footsteps.hasOwnProperty(footstep) :
385 | (footsteps[footstep] !== undefined))) {
386 | done = true;
387 | }
388 | if (!front) {
389 | footsteps[footstep] = d;
390 | }
391 | }
392 | while (!done && x < text1.length && y < text2.length &&
393 | text1.charAt(x) == text2.charAt(y)) {
394 | x++;
395 | y++;
396 | if (doubleEnd) {
397 | footstep = x + ',' + y;
398 | if (front && (hasOwnProperty ? footsteps.hasOwnProperty(footstep) :
399 | (footsteps[footstep] !== undefined))) {
400 | done = true;
401 | }
402 | if (!front) {
403 | footsteps[footstep] = d;
404 | }
405 | }
406 | }
407 | v1[k] = x;
408 | v_map1[d][x + ',' + y] = true;
409 | if (x == text1.length && y == text2.length) {
410 | // Reached the end in single-path mode.
411 | return this.diff_path1(v_map1, text1, text2);
412 | } else if (done) {
413 | // Front path ran over reverse path.
414 | v_map2 = v_map2.slice(0, footsteps[footstep] + 1);
415 | var a = this.diff_path1(v_map1, text1.substring(0, x),
416 | text2.substring(0, y));
417 | return a.concat(this.diff_path2(v_map2, text1.substring(x),
418 | text2.substring(y)));
419 | }
420 | }
421 |
422 | if (doubleEnd) {
423 | // Walk the reverse path one step.
424 | v_map2[d] = {};
425 | for (var k = -d; k <= d; k += 2) {
426 | if (k == -d || k != d && v2[k - 1] < v2[k + 1]) {
427 | x = v2[k + 1];
428 | } else {
429 | x = v2[k - 1] + 1;
430 | }
431 | y = x - k;
432 | footstep = (text1.length - x) + ',' + (text2.length - y);
433 | if (!front && (hasOwnProperty ? footsteps.hasOwnProperty(footstep) :
434 | (footsteps[footstep] !== undefined))) {
435 | done = true;
436 | }
437 | if (front) {
438 | footsteps[footstep] = d;
439 | }
440 | while (!done && x < text1.length && y < text2.length &&
441 | text1.charAt(text1.length - x - 1) ==
442 | text2.charAt(text2.length - y - 1)) {
443 | x++;
444 | y++;
445 | footstep = (text1.length - x) + ',' + (text2.length - y);
446 | if (!front && (hasOwnProperty ? footsteps.hasOwnProperty(footstep) :
447 | (footsteps[footstep] !== undefined))) {
448 | done = true;
449 | }
450 | if (front) {
451 | footsteps[footstep] = d;
452 | }
453 | }
454 | v2[k] = x;
455 | v_map2[d][x + ',' + y] = true;
456 | if (done) {
457 | // Reverse path ran over front path.
458 | v_map1 = v_map1.slice(0, footsteps[footstep] + 1);
459 | var a = this.diff_path1(v_map1, text1.substring(0, text1.length - x),
460 | text2.substring(0, text2.length - y));
461 | return a.concat(this.diff_path2(v_map2,
462 | text1.substring(text1.length - x),
463 | text2.substring(text2.length - y)));
464 | }
465 | }
466 | }
467 | }
468 | // Number of diffs equals number of characters, no commonality at all.
469 | return null;
470 | };
471 |
472 |
473 | /**
474 | * Work from the middle back to the start to determine the path.
475 | * @param {Array.