├── .gitignore
├── assets
├── yui.jar
├── compiler.jar
├── jasmine-1.0.1
│ ├── MIT.LICENSE
│ ├── jasmine.css
│ ├── jasmine-html.js
│ └── jasmine.js
└── slickspec
│ └── helpers.js
├── HEADER
├── tests
├── mocks
│ ├── template-quirks.php
│ ├── template-html5.php
│ ├── template-strict.php
│ ├── template-transitional.php
│ ├── template-transitional-ie7.php
│ └── template-chromeframe.php
├── index.html
├── setup.js
└── specs.js
├── src
├── uSelector.min.js
├── uSelectorPseudoClasses.js
└── uSelector.js
├── dist
└── uSelector.js
├── Makefile
└── README.md
/.gitignore:
--------------------------------------------------------------------------------
1 | *.swp
2 | *.swo
3 |
--------------------------------------------------------------------------------
/assets/yui.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fabiomcosta/micro-selector/HEAD/assets/yui.jar
--------------------------------------------------------------------------------
/assets/compiler.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fabiomcosta/micro-selector/HEAD/assets/compiler.jar
--------------------------------------------------------------------------------
/HEADER:
--------------------------------------------------------------------------------
1 | /* author: Fabio Miranda Costa | github: fabiomcosta | twitter: @fabiomiranda | license: MIT-style license */
2 |
--------------------------------------------------------------------------------
/tests/mocks/template-quirks.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template html with no doctype
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/mocks/template-html5.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template xhtml as html
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/mocks/template-strict.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template xhtml as xhtml
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/mocks/template-transitional.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template html
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/mocks/template-transitional-ie7.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template xhtml as html
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/mocks/template-chromeframe.php:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | template xhtml as html
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/tests/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Jasmine Test Runner
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
--------------------------------------------------------------------------------
/tests/setup.js:
--------------------------------------------------------------------------------
1 | (function(global){
2 |
3 | var Mock = SlickSpec.Mock;
4 | var Browser = SlickSpec.Browser;
5 |
6 | var registerSpecs = function(){
7 | new Mock(/html/i, microSpecs);
8 | };
9 |
10 | var createMocks = function(){
11 | Mock.CreateTemplate('Generic HTML4 (strict)', 'mocks/template-strict.php');
12 | Mock.CreateTemplate('Generic HTML4 (transitional)', 'mocks/template-transitional.php');
13 | Mock.CreateTemplate('Generic HTML4 (quirks)', 'mocks/template-quirks.php');
14 | Mock.CreateTemplate('Generic HTML4 (chromeframe)', 'mocks/template-chromeframe.php');
15 | Mock.CreateTemplate('Generic HTML5', 'mocks/template-html5.php');
16 |
17 | if (Browser.ie && Browser.version >= 8){
18 | Mock.CreateTemplate('Generic HTML4 (IE8 as IE7)', 'mocks/template-transitional-ie7.php');
19 | }
20 | };
21 |
22 | global.onload = function(){
23 | createMocks();
24 | registerSpecs();
25 | };
26 |
27 | global.runnerOnLoad = function(){
28 | jasmine.getEnv().addReporter(new jasmine.TrivialReporter());
29 | jasmine.getEnv().execute();
30 | };
31 |
32 | })(this);
33 |
--------------------------------------------------------------------------------
/assets/jasmine-1.0.1/MIT.LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2008-2010 Pivotal Labs
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining
4 | a copy of this software and associated documentation files (the
5 | "Software"), to deal in the Software without restriction, including
6 | without limitation the rights to use, copy, modify, merge, publish,
7 | distribute, sublicense, and/or sell copies of the Software, and to
8 | permit persons to whom the Software is furnished to do so, subject to
9 | the following conditions:
10 |
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 |
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 |
--------------------------------------------------------------------------------
/src/uSelector.min.js:
--------------------------------------------------------------------------------
1 | (function(h,k){function t(b){for(var c=0,a;a=b[c++];)u(a)&&f.push(a)}function p(b){for(var c=0,a;a=b[c++];)f.push(a)}function q(b){f=r.call(b,0)}function v(d,c,a){c?"#"==c?b.id=a:"."==c?b.a?b.a.push(a):b.a=[a]:":"==c&&(b.b?b.b.push(a):b.b=[a]):b.tag=a.toUpperCase();return""}function u(d){if(b.tag){var c=d.nodeName.toUpperCase();if("*"==b.tag){if("@">c)return!1}else if(c!=b.tag)return!1}if(b.id&&d.getAttribute("id")!=b.id)return!1;if(l=b.a)for(var a=" "+d.className+" ",c=l.length;c--;)if(0>a.indexOf(" "+
2 | l[c]+" "))return!1;if(m=b.b)for(c=m.length;c--;)if(a=s[m[c]],!a||!a.call(g,d))return!1;return!0}function g(d,c,a){f=a||[];e=c||g.c;if(w)try{return q(e.querySelectorAll(d)),f}catch(h){}n=e.ownerDocument||e;d=d.replace(x,"");for(b={};d=d.replace(/([#.:])?([^#.:]*)/,v););d=(c=b.id)&&b.tag||b.a||b.b||!c&&(b.a||b.b)?t:p;if(c){if((a=c=n.getElementById(c))&&!(a=n===e))a:{a=c;do if(a===e){a=!0;break a}while(a=a.parentNode);a=!1}a&&d([c])}else d(e.getElementsByTagName(b.tag||"*"));return f}var f,b,l,m,s={},
3 | e,n,x=/^\s+|\s+$/g,w=!!k.querySelectorAll,r=Array.prototype.slice;try{r.call(k.documentElement.childNodes,0)}catch(y){q=p}g.pseudos=s;g.context=k;h.uSelector=g;h.$u||(h.$u=g)})(this,document);
4 |
--------------------------------------------------------------------------------
/dist/uSelector.js:
--------------------------------------------------------------------------------
1 | /* author: Fabio Miranda Costa | github: fabiomcosta | twitter: @fabiomiranda | license: MIT-style license */
2 | (function(h,i){var f,c,j,k,m={},e,l,q=/^\s+|\s+$/g,r=!!i.querySelectorAll,g=function(d,b,a){f=a||[];e=b||g.context;if(r)try{n(e.querySelectorAll(d));return f}catch(v){}l=e.ownerDocument||e;d=d.replace(q,"");for(c={};d=d.replace(/([#.:])?([^#.:]*)/,s););d=(b=c.id)&&c.tag||c.classes||c.pseudos||!b&&(c.classes||c.pseudos)?t:o;if(b){if(a=b=l.getElementById(b))if(!(a=l===e))a:{a=b;do if(a===e){a=true;break a}while(a=a.parentNode);a=false}a&&d([b])}else d(e.getElementsByTagName(c.tag||"*"));return f},u=
3 | function(d){if(c.tag){var b=d.nodeName.toUpperCase();if(c.tag=="*"){if(b<"@")return false}else if(b!=c.tag)return false}if(c.id&&d.getAttribute("id")!=c.id)return false;if(j=c.classes){var a=" "+d.className+" ";for(b=j.length;b--;)if(a.indexOf(" "+j[b]+" ")<0)return false}if(k=c.pseudos)for(b=k.length;b--;){a=m[k[b]];if(!(a&&a.call(g,d)))return false}return true},s=function(d,b,a){if(b)if(b=="#")c.id=a;else if(b==".")if(c.classes)c.classes.push(a);else c.classes=[a];else{if(b==":")if(c.pseudos)c.pseudos.push(a);
4 | else c.pseudos=[a]}else c.tag=a.toUpperCase();return""},p=Array.prototype.slice,n=function(d){f=p.call(d,0)},o=function(d){for(var b=0,a;a=d[b++];)f.push(a)};try{p.call(i.documentElement.childNodes,0)}catch(w){n=o}var t=function(d){for(var b=0,a;a=d[b++];)u(a)&&f.push(a)};g.pseudos=m;g.context=i;h.uSelector=g;h.$u||(h.$u=g)})(this,document);
5 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | MODULE_NAME = uSelector
2 | UNCOMPRESSED = dist/${MODULE_NAME}.uncompressed.js
3 | CORE = src/uSelector.js
4 | ALL_MODULES = \
5 | $(CORE) \
6 | src/uSelectorPseudoClasses.js
7 |
8 | build: compress
9 | @echo "Removing unnecessary files..."
10 | @cd dist;\
11 | rm $$(ls | egrep -v $$(ls -S | tail -1));\
12 | mv * ${MODULE_NAME}.js;\
13 | echo "Adding comment header to compressed file";\
14 | cat ../HEADER ${MODULE_NAME}.js > __tmp__ && cat __tmp__ > ${MODULE_NAME}.js && rm -rf __tmp__;\
15 | echo "Resulting file has `ls -lh *.js | tail -1 | awk '{ print $$5 }'`.";\
16 | gzip -c ${MODULE_NAME}.js > ${MODULE_NAME}.js.gzip;\
17 | echo "Resulting file gzipped has `ls -lh *.gzip | tail -1 | awk '{ print $$5 }'`.";\
18 | rm -rf *.gzip
19 |
20 | compress:
21 | @rm -rf dist
22 | @mkdir -p dist
23 | @\
24 | if [ "$(all)" ]; then\
25 | MODULES="$(ALL_MODULES)";\
26 | else\
27 | MODULES="$(CORE)";\
28 | fi;\
29 | cat $$MODULES > ${UNCOMPRESSED}
30 | @echo "Compressing with google compiler..."
31 | @java -jar assets/compiler.jar --jscomp_warning undefinedVars --charset utf8 --compilation_level SIMPLE_OPTIMIZATIONS --js ${UNCOMPRESSED} --js_output_file dist/${MODULE_NAME}.cc.js
32 | @echo "Compressing with yui compressor..."
33 | @java -jar assets/yui.jar ${UNCOMPRESSED} -o dist/${MODULE_NAME}.yui.js --charset=utf8
34 | @echo "Compressing with uglify..."
35 | @uglifyjs --unsafe ${UNCOMPRESSED} > dist/${MODULE_NAME}.ugly.js
36 |
37 | test:
38 | @open tests/index.html
39 |
40 |
--------------------------------------------------------------------------------
/src/uSelectorPseudoClasses.js:
--------------------------------------------------------------------------------
1 | (function(){
2 |
3 | var pseudos = {
4 | empty: function(node){
5 | var child = node.firstChild;
6 | return !(child && child.nodeType == 1) && !(node.innerText || node.textContent || '').length;
7 | },
8 | 'first-child': function(node){
9 | while ((node = node.previousSibling)) if (node.nodeType == 1) return false;
10 | return true;
11 | },
12 | 'last-child': function(node){
13 | while ((node = node.nextSibling)) if (node.nodeType == 1) return false;
14 | return true;
15 | },
16 | 'only-child': function(node){
17 | return this.pseudos['first-child'](node) && this.pseudos['last-child'](node);
18 | },
19 | 'first-of-type': function(node){
20 | var nodeName = node.nodeName;
21 | while ((node = node.previousSibling)) if (node.nodeName == nodeName) return false;
22 | return true;
23 | },
24 | 'last-of-type': function(node){
25 | var nodeName = node.nodeName;
26 | while ((node = node.nextSibling)) if (node.nodeName == nodeName) return false;
27 | return true;
28 | },
29 | 'only-of-type': function(node){
30 | return this.pseudos['first-of-type'](node) && this.pseudos['last-of-type'](node);
31 | },
32 | disabled: function(node){
33 | return node.disabled;
34 | },
35 | checked: function(node){
36 | return node.checked || node.selected;
37 | },
38 | selected: function(node){
39 | return node.selected;
40 | }
41 | };
42 |
43 | for (var pseudo in pseudos){
44 | $u.pseudos[pseudo] = pseudos[pseudo];
45 | }
46 |
47 | })();
48 |
49 |
50 |
--------------------------------------------------------------------------------
/assets/jasmine-1.0.1/jasmine.css:
--------------------------------------------------------------------------------
1 | body {
2 | font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
3 | }
4 |
5 |
6 | .jasmine_reporter a:visited, .jasmine_reporter a {
7 | color: #303;
8 | }
9 |
10 | .jasmine_reporter a:hover, .jasmine_reporter a:active {
11 | color: blue;
12 | }
13 |
14 | .run_spec {
15 | float:right;
16 | padding-right: 5px;
17 | font-size: .8em;
18 | text-decoration: none;
19 | }
20 |
21 | .jasmine_reporter {
22 | margin: 0 5px;
23 | }
24 |
25 | .banner {
26 | color: #303;
27 | background-color: #fef;
28 | padding: 5px;
29 | }
30 |
31 | .logo {
32 | float: left;
33 | font-size: 1.1em;
34 | padding-left: 5px;
35 | }
36 |
37 | .logo .version {
38 | font-size: .6em;
39 | padding-left: 1em;
40 | }
41 |
42 | .runner.running {
43 | background-color: yellow;
44 | }
45 |
46 |
47 | .options {
48 | text-align: right;
49 | font-size: .8em;
50 | }
51 |
52 |
53 |
54 |
55 | .suite {
56 | border: 1px outset gray;
57 | margin: 5px 0;
58 | padding-left: 1em;
59 | }
60 |
61 | .suite .suite {
62 | margin: 5px;
63 | }
64 |
65 | .suite.passed {
66 | background-color: #dfd;
67 | }
68 |
69 | .suite.failed {
70 | background-color: #fdd;
71 | }
72 |
73 | .spec {
74 | margin: 5px;
75 | padding-left: 1em;
76 | clear: both;
77 | }
78 |
79 | .spec.failed, .spec.passed, .spec.skipped {
80 | padding-bottom: 5px;
81 | border: 1px solid gray;
82 | }
83 |
84 | .spec.failed {
85 | background-color: #fbb;
86 | border-color: red;
87 | }
88 |
89 | .spec.passed {
90 | background-color: #bfb;
91 | border-color: green;
92 | }
93 |
94 | .spec.skipped {
95 | background-color: #bbb;
96 | }
97 |
98 | .messages {
99 | border-left: 1px dashed gray;
100 | padding-left: 1em;
101 | padding-right: 1em;
102 | }
103 |
104 | .passed {
105 | background-color: #cfc;
106 | display: none;
107 | }
108 |
109 | .failed {
110 | background-color: #fbb;
111 | }
112 |
113 | .skipped {
114 | color: #777;
115 | background-color: #eee;
116 | display: none;
117 | }
118 |
119 |
120 | /*.resultMessage {*/
121 | /*white-space: pre;*/
122 | /*}*/
123 |
124 | .resultMessage span.result {
125 | display: block;
126 | line-height: 2em;
127 | color: black;
128 | }
129 |
130 | .resultMessage .mismatch {
131 | color: black;
132 | }
133 |
134 | .stackTrace {
135 | white-space: pre;
136 | font-size: .8em;
137 | margin-left: 10px;
138 | max-height: 5em;
139 | overflow: auto;
140 | border: 1px inset red;
141 | padding: 1em;
142 | background: #eef;
143 | }
144 |
145 | .finished-at {
146 | padding-left: 1em;
147 | font-size: .6em;
148 | }
149 |
150 | .show-passed .passed,
151 | .show-skipped .skipped {
152 | display: block;
153 | }
154 |
155 |
156 | #jasmine_content {
157 | position:fixed;
158 | right: 100%;
159 | }
160 |
161 | .runner {
162 | border: 1px solid gray;
163 | display: block;
164 | margin: 5px 0;
165 | padding: 2px 0 2px 10px;
166 | }
167 |
--------------------------------------------------------------------------------
/tests/specs.js:
--------------------------------------------------------------------------------
1 | var microSpecs = function(context){
2 |
3 | describe('Micro Selector', function() {
4 |
5 | var $u = uSelector;
6 | $u.context = context.document;
7 |
8 | beforeEach(function(){
9 | this.addMatchers({
10 | toFind: function(n){
11 | var found = $u(this.actual).length;
12 | this.message = function() {
13 | return [
14 | "Expected " + this.actual + " to find " + n + " but found " + found,
15 | "Expected " + this.actual + " not to find " + n
16 | ];
17 | };
18 | return found == n;
19 | }
20 | });
21 | });
22 |
23 | it('should select elements by id', function(){
24 | expect('#title').toFind(1);
25 | expect('#other').toFind(0);
26 | expect('#divid').toFind(1);
27 | expect('#divid2').toFind(1);
28 | expect($u('#divid', $u('#divid2')[0]).length).toEqual(0);
29 | });
30 |
31 | it('should select elements by tagName', function(){
32 | var h2Collection = $u('h2');
33 | expect(h2Collection instanceof Array).toEqual(true);
34 | expect(h2Collection.length).toEqual(19);
35 | expect('ul').toFind(22);
36 | expect($u('div', $u('#divid')[0]).length).toEqual(4);
37 | });
38 |
39 | it('should select elements by className', function(){
40 | var classVcardCollection = $u('.vcard');
41 | expect(classVcardCollection instanceof Array).toEqual(true);
42 | expect(classVcardCollection.length).toEqual(5);
43 | expect('.pattern').toFind(40);
44 | expect('.example').toFind(43);
45 | expect($u('.inner', $u('.wrapper')[0]).length).toEqual(1);
46 | });
47 |
48 | it('should select elements by tagName and id', function(){
49 | expect('h1#title').toFind(1);
50 | expect('div#title').toFind(0);
51 | });
52 |
53 | it('should select elements by tagName and className', function(){
54 | expect('div.wrapper').toFind(4);
55 | expect('b.wrapper').toFind(1);
56 | });
57 |
58 | it('should select elements with untrimed selectors', function(){
59 | expect(' #title ').toFind(1);
60 | expect(' ul ').toFind(22);
61 | expect(' .example ').toFind(43);
62 | expect(' h1#title ').toFind(1);
63 | expect(' abbr.some#abbr-id.classes.here').toFind(1);
64 | });
65 |
66 | it('should select elements with the added pseudo classes', function(){
67 | $u.pseudos['contains-cheese'] = function(node){
68 | return node.innerHTML.indexOf('cheese') > -1;
69 | };
70 | expect('div:contains-cheese').toFind(1);
71 | expect('div:non-existent-pseudo').toFind(0);
72 | });
73 |
74 | describe('Extra pseudo classes contained on the uSelectorPseudoClasses', function(){
75 |
76 | it('should find elements by the defined pseudo-classes', function(){
77 | expect('a:empty').toFind(30);
78 |
79 | expect('p:first-child').toFind(54);
80 | expect('p:last-child').toFind(19);
81 | expect('p:only-child').toFind(3);
82 |
83 | expect('p:first-of-type').toFind(57);
84 | expect('p:last-of-type').toFind(57);
85 | expect('p:only-of-type').toFind(15);
86 |
87 | expect(':disabled').toFind(0);
88 | expect(':checked').toFind(0);
89 | expect(':selected').toFind(0);
90 | });
91 |
92 | });
93 |
94 | });
95 |
96 | };
97 |
--------------------------------------------------------------------------------
/src/uSelector.js:
--------------------------------------------------------------------------------
1 | /**
2 | * author: Fabio Miranda Costa
3 | * github: fabiomcosta
4 | * twitter: @fabiomiranda
5 | * license: MIT-style license
6 | */
7 |
8 | (function(global, document){
9 |
10 | var elements,
11 | parsed,
12 | parsedClasses,
13 | parsedPseudos,
14 | pseudos = {},
15 | context,
16 | currentDocument,
17 | reTrim = /^\s+|\s+$/g;
18 |
19 | var supports_querySelectorAll = !!document.querySelectorAll;
20 |
21 | var $u = function(selector, _context, append){
22 | elements = append || [];
23 | context = _context || $u.context;
24 | if (supports_querySelectorAll){
25 | try{
26 | arrayFrom(context.querySelectorAll(selector));
27 | return elements;
28 | } catch (e){}
29 | }
30 |
31 | currentDocument = context.ownerDocument || context;
32 | parse(selector.replace(reTrim, ''));
33 | find();
34 |
35 | return elements;
36 | };
37 |
38 | var matchSelector = function(node){
39 | if (parsed.tag){
40 | var nodeName = node.nodeName.toUpperCase();
41 | if (parsed.tag == '*'){
42 | if (nodeName < '@') return false; // Fix for comment nodes and closed nodes
43 | } else {
44 | if (nodeName != parsed.tag) return false;
45 | }
46 | }
47 |
48 | if (parsed.id && node.getAttribute('id') != parsed.id){
49 | return false;
50 | }
51 |
52 | if ((parsedClasses = parsed.classes)){
53 | var className = (' ' + node.className + ' ');
54 | for (var i = parsedClasses.length; i--;){
55 | if (className.indexOf(' ' + parsedClasses[i] + ' ') < 0) return false;
56 | }
57 | }
58 |
59 | if ((parsedPseudos = parsed.pseudos)){
60 | for (var i = parsedPseudos.length; i--;){
61 | var pseudoClass = pseudos[parsedPseudos[i]];
62 | if (!(pseudoClass && pseudoClass.call($u, node))) return false;
63 | }
64 | }
65 |
66 | return true;
67 | };
68 |
69 | var find = function(){
70 |
71 | var parsedId = parsed.id,
72 | merge = ((parsedId && parsed.tag || parsed.classes || parsed.pseudos)
73 | || (!parsedId && (parsed.classes || parsed.pseudos))) ?
74 | arrayFilterAndMerge : arrayMerge;
75 |
76 | if (parsedId){
77 |
78 | var el = currentDocument.getElementById(parsedId);
79 | if (el && (currentDocument === context || contains(el))){
80 | merge([el]);
81 | }
82 |
83 | } else {
84 |
85 | merge(context.getElementsByTagName(parsed.tag || '*'));
86 |
87 | }
88 |
89 | };
90 |
91 | var parse = function(selector){
92 | parsed = {};
93 | while ((selector = selector.replace(/([#.:])?([^#.:]*)/, parser))){};
94 | };
95 |
96 | var parser = function(all, simbol, name){
97 | if (!simbol){
98 | parsed.tag = name.toUpperCase();
99 | } else if (simbol == '#'){
100 | parsed.id = name;
101 | } else if (simbol == '.'){
102 | if (parsed.classes){
103 | parsed.classes.push(name);
104 | } else {
105 | parsed.classes = [name];
106 | }
107 | } else if (simbol == ':'){
108 | if (parsed.pseudos){
109 | parsed.pseudos.push(name);
110 | } else {
111 | parsed.pseudos = [name];
112 | }
113 | }
114 | return '';
115 | };
116 |
117 | var slice = Array.prototype.slice;
118 | var arrayFrom = function(collection){
119 | elements = slice.call(collection, 0);
120 | };
121 | var arrayMerge = function(collection){
122 | for (var i = 0, node; node = collection[i++];){
123 | elements.push(node);
124 | }
125 | };
126 | try {
127 | slice.call(document.documentElement.childNodes, 0);
128 | } catch(e) {
129 | arrayFrom = arrayMerge;
130 | }
131 |
132 | var arrayFilterAndMerge = function(found){
133 | for (var i = 0, node; node = found[i++];){
134 | if (matchSelector(node)) elements.push(node);
135 | }
136 | };
137 |
138 | var contains = function(node){
139 | do {
140 | if (node === context) return true;
141 | } while ((node = node.parentNode));
142 | return false;
143 | };
144 |
145 | $u['pseudos'] = pseudos;
146 | $u['context'] = document;
147 | global['uSelector'] = $u;
148 | if (!global['$u']) global['$u'] = $u;
149 |
150 | })(this, document);
151 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | uSelector
2 | =========
3 | A micro, super fast, scope limited, javascript selector engine to be used anywhere
4 | ----------------------------------------------------------------------------------
5 |
6 | uSelector (micro selector), is a node selector for HTML documents that uses css expressions to select nodes.
7 | It's based on [Slick](https://github.com/mootools/slick), the selector used on the [Mootools](http://mootools.net) javascript framework.
8 |
9 | ### Supported selectors
10 | * tag
11 | * id
12 | * class
13 | * custom pseudo-classes
14 |
15 | ### Unsupported selectors
16 | * combinators (ex: "div span", "div > span")
17 | * multiple expressions (expressions with comma, ex: "div, span")
18 | * attribute (ex: "a[title='title']")
19 |
20 | ### Suported with the uSelectorPseudoClasses module
21 | * :empty
22 | * :first-child
23 | * :last-child
24 | * :only-child
25 | * :first-of-type
26 | * :last-of-type
27 | * :only-of-type
28 | * :disabled
29 | * :checked
30 | * :selected
31 |
32 | note: To build with these pseudo-selectors included do `make build all=true`
33 |
34 | Browser Support
35 | ---------------
36 |
37 |  |  |  |  | 
38 | --- | --- | --- | --- | --- |
39 | IE 6+ ✔ | Latest ✔ | Latest ✔ | Latest ✔ | Latest ✔ |
40 |
41 | How to use
42 | ----------
43 |
44 | `$u('your-selector')` -> returns an array of nodes that match the selector
45 |
46 | Create your own pseudo-class
47 | --------------------------------
48 |
49 | $u.pseudo['your-custom-pseudo'] = function(node){
50 | return boolean;
51 | };
52 |
53 | It should return true if the passed node fits the behavior of your pseudo. see the ["src/uSelectorPseudoClasses.js"](https://github.com/fabiomcosta/micro-selector/blob/master/src/uSelectorPseudoClasses.js)
54 |
55 | Examples
56 | --------
57 |
58 |
59 |
text
60 |
strong-text
61 |
62 |
jasmine.undefined instead of undefined, since undefined is just
17 | * a plain old variable and may be redefined by somebody else.
18 | *
19 | * @private
20 | */
21 | jasmine.undefined = jasmine.___undefined___;
22 |
23 | /**
24 | * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
25 | *
26 | */
27 | jasmine.DEFAULT_UPDATE_INTERVAL = 250;
28 |
29 | /**
30 | * Default timeout interval in milliseconds for waitsFor() blocks.
31 | */
32 | jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
33 |
34 | jasmine.getGlobal = function() {
35 | function getGlobal() {
36 | return this;
37 | }
38 |
39 | return getGlobal();
40 | };
41 |
42 | /**
43 | * Allows for bound functions to be compared. Internal use only.
44 | *
45 | * @ignore
46 | * @private
47 | * @param base {Object} bound 'this' for the function
48 | * @param name {Function} function to find
49 | */
50 | jasmine.bindOriginal_ = function(base, name) {
51 | var original = base[name];
52 | if (original.apply) {
53 | return function() {
54 | return original.apply(base, arguments);
55 | };
56 | } else {
57 | // IE support
58 | return jasmine.getGlobal()[name];
59 | }
60 | };
61 |
62 | jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout');
63 | jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout');
64 | jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval');
65 | jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval');
66 |
67 | jasmine.MessageResult = function(values) {
68 | this.type = 'log';
69 | this.values = values;
70 | this.trace = new Error(); // todo: test better
71 | };
72 |
73 | jasmine.MessageResult.prototype.toString = function() {
74 | var text = "";
75 | for(var i = 0; i < this.values.length; i++) {
76 | if (i > 0) text += " ";
77 | if (jasmine.isString_(this.values[i])) {
78 | text += this.values[i];
79 | } else {
80 | text += jasmine.pp(this.values[i]);
81 | }
82 | }
83 | return text;
84 | };
85 |
86 | jasmine.ExpectationResult = function(params) {
87 | this.type = 'expect';
88 | this.matcherName = params.matcherName;
89 | this.passed_ = params.passed;
90 | this.expected = params.expected;
91 | this.actual = params.actual;
92 |
93 | this.message = this.passed_ ? 'Passed.' : params.message;
94 | this.trace = this.passed_ ? '' : new Error(this.message);
95 | };
96 |
97 | jasmine.ExpectationResult.prototype.toString = function () {
98 | return this.message;
99 | };
100 |
101 | jasmine.ExpectationResult.prototype.passed = function () {
102 | return this.passed_;
103 | };
104 |
105 | /**
106 | * Getter for the Jasmine environment. Ensures one gets created
107 | */
108 | jasmine.getEnv = function() {
109 | return jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env();
110 | };
111 |
112 | /**
113 | * @ignore
114 | * @private
115 | * @param value
116 | * @returns {Boolean}
117 | */
118 | jasmine.isArray_ = function(value) {
119 | return jasmine.isA_("Array", value);
120 | };
121 |
122 | /**
123 | * @ignore
124 | * @private
125 | * @param value
126 | * @returns {Boolean}
127 | */
128 | jasmine.isString_ = function(value) {
129 | return jasmine.isA_("String", value);
130 | };
131 |
132 | /**
133 | * @ignore
134 | * @private
135 | * @param value
136 | * @returns {Boolean}
137 | */
138 | jasmine.isNumber_ = function(value) {
139 | return jasmine.isA_("Number", value);
140 | };
141 |
142 | /**
143 | * @ignore
144 | * @private
145 | * @param {String} typeName
146 | * @param value
147 | * @returns {Boolean}
148 | */
149 | jasmine.isA_ = function(typeName, value) {
150 | return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
151 | };
152 |
153 | /**
154 | * Pretty printer for expecations. Takes any object and turns it into a human-readable string.
155 | *
156 | * @param value {Object} an object to be outputted
157 | * @returns {String}
158 | */
159 | jasmine.pp = function(value) {
160 | var stringPrettyPrinter = new jasmine.StringPrettyPrinter();
161 | stringPrettyPrinter.format(value);
162 | return stringPrettyPrinter.string;
163 | };
164 |
165 | /**
166 | * Returns true if the object is a DOM Node.
167 | *
168 | * @param {Object} obj object to check
169 | * @returns {Boolean}
170 | */
171 | jasmine.isDomNode = function(obj) {
172 | return obj['nodeType'] > 0;
173 | };
174 |
175 | /**
176 | * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter.
177 | *
178 | * @example
179 | * // don't care about which function is passed in, as long as it's a function
180 | * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function));
181 | *
182 | * @param {Class} clazz
183 | * @returns matchable object of the type clazz
184 | */
185 | jasmine.any = function(clazz) {
186 | return new jasmine.Matchers.Any(clazz);
187 | };
188 |
189 | /**
190 | * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks.
191 | *
192 | * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine
193 | * expectation syntax. Spies can be checked if they were called or not and what the calling params were.
194 | *
195 | * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs).
196 | *
197 | * Spies are torn down at the end of every spec.
198 | *
199 | * Note: Do not call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj.
200 | *
201 | * @example
202 | * // a stub
203 | * var myStub = jasmine.createSpy('myStub'); // can be used anywhere
204 | *
205 | * // spy example
206 | * var foo = {
207 | * not: function(bool) { return !bool; }
208 | * }
209 | *
210 | * // actual foo.not will not be called, execution stops
211 | * spyOn(foo, 'not');
212 |
213 | // foo.not spied upon, execution will continue to implementation
214 | * spyOn(foo, 'not').andCallThrough();
215 | *
216 | * // fake example
217 | * var foo = {
218 | * not: function(bool) { return !bool; }
219 | * }
220 | *
221 | * // foo.not(val) will return val
222 | * spyOn(foo, 'not').andCallFake(function(value) {return value;});
223 | *
224 | * // mock example
225 | * foo.not(7 == 7);
226 | * expect(foo.not).toHaveBeenCalled();
227 | * expect(foo.not).toHaveBeenCalledWith(true);
228 | *
229 | * @constructor
230 | * @see spyOn, jasmine.createSpy, jasmine.createSpyObj
231 | * @param {String} name
232 | */
233 | jasmine.Spy = function(name) {
234 | /**
235 | * The name of the spy, if provided.
236 | */
237 | this.identity = name || 'unknown';
238 | /**
239 | * Is this Object a spy?
240 | */
241 | this.isSpy = true;
242 | /**
243 | * The actual function this spy stubs.
244 | */
245 | this.plan = function() {
246 | };
247 | /**
248 | * Tracking of the most recent call to the spy.
249 | * @example
250 | * var mySpy = jasmine.createSpy('foo');
251 | * mySpy(1, 2);
252 | * mySpy.mostRecentCall.args = [1, 2];
253 | */
254 | this.mostRecentCall = {};
255 |
256 | /**
257 | * Holds arguments for each call to the spy, indexed by call count
258 | * @example
259 | * var mySpy = jasmine.createSpy('foo');
260 | * mySpy(1, 2);
261 | * mySpy(7, 8);
262 | * mySpy.mostRecentCall.args = [7, 8];
263 | * mySpy.argsForCall[0] = [1, 2];
264 | * mySpy.argsForCall[1] = [7, 8];
265 | */
266 | this.argsForCall = [];
267 | this.calls = [];
268 | };
269 |
270 | /**
271 | * Tells a spy to call through to the actual implemenatation.
272 | *
273 | * @example
274 | * var foo = {
275 | * bar: function() { // do some stuff }
276 | * }
277 | *
278 | * // defining a spy on an existing property: foo.bar
279 | * spyOn(foo, 'bar').andCallThrough();
280 | */
281 | jasmine.Spy.prototype.andCallThrough = function() {
282 | this.plan = this.originalValue;
283 | return this;
284 | };
285 |
286 | /**
287 | * For setting the return value of a spy.
288 | *
289 | * @example
290 | * // defining a spy from scratch: foo() returns 'baz'
291 | * var foo = jasmine.createSpy('spy on foo').andReturn('baz');
292 | *
293 | * // defining a spy on an existing property: foo.bar() returns 'baz'
294 | * spyOn(foo, 'bar').andReturn('baz');
295 | *
296 | * @param {Object} value
297 | */
298 | jasmine.Spy.prototype.andReturn = function(value) {
299 | this.plan = function() {
300 | return value;
301 | };
302 | return this;
303 | };
304 |
305 | /**
306 | * For throwing an exception when a spy is called.
307 | *
308 | * @example
309 | * // defining a spy from scratch: foo() throws an exception w/ message 'ouch'
310 | * var foo = jasmine.createSpy('spy on foo').andThrow('baz');
311 | *
312 | * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch'
313 | * spyOn(foo, 'bar').andThrow('baz');
314 | *
315 | * @param {String} exceptionMsg
316 | */
317 | jasmine.Spy.prototype.andThrow = function(exceptionMsg) {
318 | this.plan = function() {
319 | throw exceptionMsg;
320 | };
321 | return this;
322 | };
323 |
324 | /**
325 | * Calls an alternate implementation when a spy is called.
326 | *
327 | * @example
328 | * var baz = function() {
329 | * // do some stuff, return something
330 | * }
331 | * // defining a spy from scratch: foo() calls the function baz
332 | * var foo = jasmine.createSpy('spy on foo').andCall(baz);
333 | *
334 | * // defining a spy on an existing property: foo.bar() calls an anonymnous function
335 | * spyOn(foo, 'bar').andCall(function() { return 'baz';} );
336 | *
337 | * @param {Function} fakeFunc
338 | */
339 | jasmine.Spy.prototype.andCallFake = function(fakeFunc) {
340 | this.plan = fakeFunc;
341 | return this;
342 | };
343 |
344 | /**
345 | * Resets all of a spy's the tracking variables so that it can be used again.
346 | *
347 | * @example
348 | * spyOn(foo, 'bar');
349 | *
350 | * foo.bar();
351 | *
352 | * expect(foo.bar.callCount).toEqual(1);
353 | *
354 | * foo.bar.reset();
355 | *
356 | * expect(foo.bar.callCount).toEqual(0);
357 | */
358 | jasmine.Spy.prototype.reset = function() {
359 | this.wasCalled = false;
360 | this.callCount = 0;
361 | this.argsForCall = [];
362 | this.calls = [];
363 | this.mostRecentCall = {};
364 | };
365 |
366 | jasmine.createSpy = function(name) {
367 |
368 | var spyObj = function() {
369 | spyObj.wasCalled = true;
370 | spyObj.callCount++;
371 | var args = jasmine.util.argsToArray(arguments);
372 | spyObj.mostRecentCall.object = this;
373 | spyObj.mostRecentCall.args = args;
374 | spyObj.argsForCall.push(args);
375 | spyObj.calls.push({object: this, args: args});
376 | return spyObj.plan.apply(this, arguments);
377 | };
378 |
379 | var spy = new jasmine.Spy(name);
380 |
381 | for (var prop in spy) {
382 | spyObj[prop] = spy[prop];
383 | }
384 |
385 | spyObj.reset();
386 |
387 | return spyObj;
388 | };
389 |
390 | /**
391 | * Determines whether an object is a spy.
392 | *
393 | * @param {jasmine.Spy|Object} putativeSpy
394 | * @returns {Boolean}
395 | */
396 | jasmine.isSpy = function(putativeSpy) {
397 | return putativeSpy && putativeSpy.isSpy;
398 | };
399 |
400 | /**
401 | * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something
402 | * large in one call.
403 | *
404 | * @param {String} baseName name of spy class
405 | * @param {Array} methodNames array of names of methods to make spies
406 | */
407 | jasmine.createSpyObj = function(baseName, methodNames) {
408 | if (!jasmine.isArray_(methodNames) || methodNames.length == 0) {
409 | throw new Error('createSpyObj requires a non-empty array of method names to create spies for');
410 | }
411 | var obj = {};
412 | for (var i = 0; i < methodNames.length; i++) {
413 | obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]);
414 | }
415 | return obj;
416 | };
417 |
418 | /**
419 | * All parameters are pretty-printed and concatenated together, then written to the current spec's output.
420 | *
421 | * Be careful not to leave calls to jasmine.log in production code.
422 | */
423 | jasmine.log = function() {
424 | var spec = jasmine.getEnv().currentSpec;
425 | spec.log.apply(spec, arguments);
426 | };
427 |
428 | /**
429 | * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy.
430 | *
431 | * @example
432 | * // spy example
433 | * var foo = {
434 | * not: function(bool) { return !bool; }
435 | * }
436 | * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops
437 | *
438 | * @see jasmine.createSpy
439 | * @param obj
440 | * @param methodName
441 | * @returns a Jasmine spy that can be chained with all spy methods
442 | */
443 | var spyOn = function(obj, methodName) {
444 | return jasmine.getEnv().currentSpec.spyOn(obj, methodName);
445 | };
446 |
447 | /**
448 | * Creates a Jasmine spec that will be added to the current suite.
449 | *
450 | * // TODO: pending tests
451 | *
452 | * @example
453 | * it('should be true', function() {
454 | * expect(true).toEqual(true);
455 | * });
456 | *
457 | * @param {String} desc description of this specification
458 | * @param {Function} func defines the preconditions and expectations of the spec
459 | */
460 | var it = function(desc, func) {
461 | return jasmine.getEnv().it(desc, func);
462 | };
463 |
464 | /**
465 | * Creates a disabled Jasmine spec.
466 | *
467 | * A convenience method that allows existing specs to be disabled temporarily during development.
468 | *
469 | * @param {String} desc description of this specification
470 | * @param {Function} func defines the preconditions and expectations of the spec
471 | */
472 | var xit = function(desc, func) {
473 | return jasmine.getEnv().xit(desc, func);
474 | };
475 |
476 | /**
477 | * Starts a chain for a Jasmine expectation.
478 | *
479 | * It is passed an Object that is the actual value and should chain to one of the many
480 | * jasmine.Matchers functions.
481 | *
482 | * @param {Object} actual Actual value to test against and expected value
483 | */
484 | var expect = function(actual) {
485 | return jasmine.getEnv().currentSpec.expect(actual);
486 | };
487 |
488 | /**
489 | * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs.
490 | *
491 | * @param {Function} func Function that defines part of a jasmine spec.
492 | */
493 | var runs = function(func) {
494 | jasmine.getEnv().currentSpec.runs(func);
495 | };
496 |
497 | /**
498 | * Waits a fixed time period before moving to the next block.
499 | *
500 | * @deprecated Use waitsFor() instead
501 | * @param {Number} timeout milliseconds to wait
502 | */
503 | var waits = function(timeout) {
504 | jasmine.getEnv().currentSpec.waits(timeout);
505 | };
506 |
507 | /**
508 | * Waits for the latchFunction to return true before proceeding to the next block.
509 | *
510 | * @param {Function} latchFunction
511 | * @param {String} optional_timeoutMessage
512 | * @param {Number} optional_timeout
513 | */
514 | var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
515 | jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
516 | };
517 |
518 | /**
519 | * A function that is called before each spec in a suite.
520 | *
521 | * Used for spec setup, including validating assumptions.
522 | *
523 | * @param {Function} beforeEachFunction
524 | */
525 | var beforeEach = function(beforeEachFunction) {
526 | jasmine.getEnv().beforeEach(beforeEachFunction);
527 | };
528 |
529 | /**
530 | * A function that is called after each spec in a suite.
531 | *
532 | * Used for restoring any state that is hijacked during spec execution.
533 | *
534 | * @param {Function} afterEachFunction
535 | */
536 | var afterEach = function(afterEachFunction) {
537 | jasmine.getEnv().afterEach(afterEachFunction);
538 | };
539 |
540 | /**
541 | * Defines a suite of specifications.
542 | *
543 | * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared
544 | * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization
545 | * of setup in some tests.
546 | *
547 | * @example
548 | * // TODO: a simple suite
549 | *
550 | * // TODO: a simple suite with a nested describe block
551 | *
552 | * @param {String} description A string, usually the class under test.
553 | * @param {Function} specDefinitions function that defines several specs.
554 | */
555 | var describe = function(description, specDefinitions) {
556 | return jasmine.getEnv().describe(description, specDefinitions);
557 | };
558 |
559 | /**
560 | * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development.
561 | *
562 | * @param {String} description A string, usually the class under test.
563 | * @param {Function} specDefinitions function that defines several specs.
564 | */
565 | var xdescribe = function(description, specDefinitions) {
566 | return jasmine.getEnv().xdescribe(description, specDefinitions);
567 | };
568 |
569 |
570 | // Provide the XMLHttpRequest class for IE 5.x-6.x:
571 | jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() {
572 | try {
573 | return new ActiveXObject("Msxml2.XMLHTTP.6.0");
574 | } catch(e) {
575 | }
576 | try {
577 | return new ActiveXObject("Msxml2.XMLHTTP.3.0");
578 | } catch(e) {
579 | }
580 | try {
581 | return new ActiveXObject("Msxml2.XMLHTTP");
582 | } catch(e) {
583 | }
584 | try {
585 | return new ActiveXObject("Microsoft.XMLHTTP");
586 | } catch(e) {
587 | }
588 | throw new Error("This browser does not support XMLHttpRequest.");
589 | } : XMLHttpRequest;
590 | /**
591 | * @namespace
592 | */
593 | jasmine.util = {};
594 |
595 | /**
596 | * Declare that a child class inherit it's prototype from the parent class.
597 | *
598 | * @private
599 | * @param {Function} childClass
600 | * @param {Function} parentClass
601 | */
602 | jasmine.util.inherit = function(childClass, parentClass) {
603 | /**
604 | * @private
605 | */
606 | var subclass = function() {
607 | };
608 | subclass.prototype = parentClass.prototype;
609 | childClass.prototype = new subclass;
610 | };
611 |
612 | jasmine.util.formatException = function(e) {
613 | var lineNumber;
614 | if (e.line) {
615 | lineNumber = e.line;
616 | }
617 | else if (e.lineNumber) {
618 | lineNumber = e.lineNumber;
619 | }
620 |
621 | var file;
622 |
623 | if (e.sourceURL) {
624 | file = e.sourceURL;
625 | }
626 | else if (e.fileName) {
627 | file = e.fileName;
628 | }
629 |
630 | var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString();
631 |
632 | if (file && lineNumber) {
633 | message += ' in ' + file + ' (line ' + lineNumber + ')';
634 | }
635 |
636 | return message;
637 | };
638 |
639 | jasmine.util.htmlEscape = function(str) {
640 | if (!str) return str;
641 | return str.replace(/&/g, '&')
642 | .replace(//g, '>');
644 | };
645 |
646 | jasmine.util.argsToArray = function(args) {
647 | var arrayOfArgs = [];
648 | for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]);
649 | return arrayOfArgs;
650 | };
651 |
652 | jasmine.util.extend = function(destination, source) {
653 | for (var property in source) destination[property] = source[property];
654 | return destination;
655 | };
656 |
657 | /**
658 | * Environment for Jasmine
659 | *
660 | * @constructor
661 | */
662 | jasmine.Env = function() {
663 | this.currentSpec = null;
664 | this.currentSuite = null;
665 | this.currentRunner_ = new jasmine.Runner(this);
666 |
667 | this.reporter = new jasmine.MultiReporter();
668 |
669 | this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL;
670 | this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL;
671 | this.lastUpdate = 0;
672 | this.specFilter = function() {
673 | return true;
674 | };
675 |
676 | this.nextSpecId_ = 0;
677 | this.nextSuiteId_ = 0;
678 | this.equalityTesters_ = [];
679 |
680 | // wrap matchers
681 | this.matchersClass = function() {
682 | jasmine.Matchers.apply(this, arguments);
683 | };
684 | jasmine.util.inherit(this.matchersClass, jasmine.Matchers);
685 |
686 | jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass);
687 | };
688 |
689 |
690 | jasmine.Env.prototype.setTimeout = jasmine.setTimeout;
691 | jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout;
692 | jasmine.Env.prototype.setInterval = jasmine.setInterval;
693 | jasmine.Env.prototype.clearInterval = jasmine.clearInterval;
694 |
695 | /**
696 | * @returns an object containing jasmine version build info, if set.
697 | */
698 | jasmine.Env.prototype.version = function () {
699 | if (jasmine.version_) {
700 | return jasmine.version_;
701 | } else {
702 | throw new Error('Version not set');
703 | }
704 | };
705 |
706 | /**
707 | * @returns string containing jasmine version build info, if set.
708 | */
709 | jasmine.Env.prototype.versionString = function() {
710 | if (jasmine.version_) {
711 | var version = this.version();
712 | return version.major + "." + version.minor + "." + version.build + " revision " + version.revision;
713 | } else {
714 | return "version unknown";
715 | }
716 | };
717 |
718 | /**
719 | * @returns a sequential integer starting at 0
720 | */
721 | jasmine.Env.prototype.nextSpecId = function () {
722 | return this.nextSpecId_++;
723 | };
724 |
725 | /**
726 | * @returns a sequential integer starting at 0
727 | */
728 | jasmine.Env.prototype.nextSuiteId = function () {
729 | return this.nextSuiteId_++;
730 | };
731 |
732 | /**
733 | * Register a reporter to receive status updates from Jasmine.
734 | * @param {jasmine.Reporter} reporter An object which will receive status updates.
735 | */
736 | jasmine.Env.prototype.addReporter = function(reporter) {
737 | this.reporter.addReporter(reporter);
738 | };
739 |
740 | jasmine.Env.prototype.execute = function() {
741 | this.currentRunner_.execute();
742 | };
743 |
744 | jasmine.Env.prototype.describe = function(description, specDefinitions) {
745 | var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite);
746 |
747 | var parentSuite = this.currentSuite;
748 | if (parentSuite) {
749 | parentSuite.add(suite);
750 | } else {
751 | this.currentRunner_.add(suite);
752 | }
753 |
754 | this.currentSuite = suite;
755 |
756 | var declarationError = null;
757 | try {
758 | specDefinitions.call(suite);
759 | } catch(e) {
760 | declarationError = e;
761 | }
762 |
763 | this.currentSuite = parentSuite;
764 |
765 | if (declarationError) {
766 | this.it("encountered a declaration exception", function() {
767 | throw declarationError;
768 | });
769 | }
770 |
771 | return suite;
772 | };
773 |
774 | jasmine.Env.prototype.beforeEach = function(beforeEachFunction) {
775 | if (this.currentSuite) {
776 | this.currentSuite.beforeEach(beforeEachFunction);
777 | } else {
778 | this.currentRunner_.beforeEach(beforeEachFunction);
779 | }
780 | };
781 |
782 | jasmine.Env.prototype.currentRunner = function () {
783 | return this.currentRunner_;
784 | };
785 |
786 | jasmine.Env.prototype.afterEach = function(afterEachFunction) {
787 | if (this.currentSuite) {
788 | this.currentSuite.afterEach(afterEachFunction);
789 | } else {
790 | this.currentRunner_.afterEach(afterEachFunction);
791 | }
792 |
793 | };
794 |
795 | jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) {
796 | return {
797 | execute: function() {
798 | }
799 | };
800 | };
801 |
802 | jasmine.Env.prototype.it = function(description, func) {
803 | var spec = new jasmine.Spec(this, this.currentSuite, description);
804 | this.currentSuite.add(spec);
805 | this.currentSpec = spec;
806 |
807 | if (func) {
808 | spec.runs(func);
809 | }
810 |
811 | return spec;
812 | };
813 |
814 | jasmine.Env.prototype.xit = function(desc, func) {
815 | return {
816 | id: this.nextSpecId(),
817 | runs: function() {
818 | }
819 | };
820 | };
821 |
822 | jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) {
823 | if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) {
824 | return true;
825 | }
826 |
827 | a.__Jasmine_been_here_before__ = b;
828 | b.__Jasmine_been_here_before__ = a;
829 |
830 | var hasKey = function(obj, keyName) {
831 | return obj != null && obj[keyName] !== jasmine.undefined;
832 | };
833 |
834 | for (var property in b) {
835 | if (!hasKey(a, property) && hasKey(b, property)) {
836 | mismatchKeys.push("expected has key '" + property + "', but missing from actual.");
837 | }
838 | }
839 | for (property in a) {
840 | if (!hasKey(b, property) && hasKey(a, property)) {
841 | mismatchKeys.push("expected missing key '" + property + "', but present in actual.");
842 | }
843 | }
844 | for (property in b) {
845 | if (property == '__Jasmine_been_here_before__') continue;
846 | if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) {
847 | mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual.");
848 | }
849 | }
850 |
851 | if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) {
852 | mismatchValues.push("arrays were not the same length");
853 | }
854 |
855 | delete a.__Jasmine_been_here_before__;
856 | delete b.__Jasmine_been_here_before__;
857 | return (mismatchKeys.length == 0 && mismatchValues.length == 0);
858 | };
859 |
860 | jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) {
861 | mismatchKeys = mismatchKeys || [];
862 | mismatchValues = mismatchValues || [];
863 |
864 | for (var i = 0; i < this.equalityTesters_.length; i++) {
865 | var equalityTester = this.equalityTesters_[i];
866 | var result = equalityTester(a, b, this, mismatchKeys, mismatchValues);
867 | if (result !== jasmine.undefined) return result;
868 | }
869 |
870 | if (a === b) return true;
871 |
872 | if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) {
873 | return (a == jasmine.undefined && b == jasmine.undefined);
874 | }
875 |
876 | if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) {
877 | return a === b;
878 | }
879 |
880 | if (a instanceof Date && b instanceof Date) {
881 | return a.getTime() == b.getTime();
882 | }
883 |
884 | if (a instanceof jasmine.Matchers.Any) {
885 | return a.matches(b);
886 | }
887 |
888 | if (b instanceof jasmine.Matchers.Any) {
889 | return b.matches(a);
890 | }
891 |
892 | if (jasmine.isString_(a) && jasmine.isString_(b)) {
893 | return (a == b);
894 | }
895 |
896 | if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) {
897 | return (a == b);
898 | }
899 |
900 | if (typeof a === "object" && typeof b === "object") {
901 | return this.compareObjects_(a, b, mismatchKeys, mismatchValues);
902 | }
903 |
904 | //Straight check
905 | return (a === b);
906 | };
907 |
908 | jasmine.Env.prototype.contains_ = function(haystack, needle) {
909 | if (jasmine.isArray_(haystack)) {
910 | for (var i = 0; i < haystack.length; i++) {
911 | if (this.equals_(haystack[i], needle)) return true;
912 | }
913 | return false;
914 | }
915 | return haystack.indexOf(needle) >= 0;
916 | };
917 |
918 | jasmine.Env.prototype.addEqualityTester = function(equalityTester) {
919 | this.equalityTesters_.push(equalityTester);
920 | };
921 | /** No-op base class for Jasmine reporters.
922 | *
923 | * @constructor
924 | */
925 | jasmine.Reporter = function() {
926 | };
927 |
928 | //noinspection JSUnusedLocalSymbols
929 | jasmine.Reporter.prototype.reportRunnerStarting = function(runner) {
930 | };
931 |
932 | //noinspection JSUnusedLocalSymbols
933 | jasmine.Reporter.prototype.reportRunnerResults = function(runner) {
934 | };
935 |
936 | //noinspection JSUnusedLocalSymbols
937 | jasmine.Reporter.prototype.reportSuiteResults = function(suite) {
938 | };
939 |
940 | //noinspection JSUnusedLocalSymbols
941 | jasmine.Reporter.prototype.reportSpecStarting = function(spec) {
942 | };
943 |
944 | //noinspection JSUnusedLocalSymbols
945 | jasmine.Reporter.prototype.reportSpecResults = function(spec) {
946 | };
947 |
948 | //noinspection JSUnusedLocalSymbols
949 | jasmine.Reporter.prototype.log = function(str) {
950 | };
951 |
952 | /**
953 | * Blocks are functions with executable code that make up a spec.
954 | *
955 | * @constructor
956 | * @param {jasmine.Env} env
957 | * @param {Function} func
958 | * @param {jasmine.Spec} spec
959 | */
960 | jasmine.Block = function(env, func, spec) {
961 | this.env = env;
962 | this.func = func;
963 | this.spec = spec;
964 | };
965 |
966 | jasmine.Block.prototype.execute = function(onComplete) {
967 | try {
968 | this.func.apply(this.spec);
969 | } catch (e) {
970 | this.spec.fail(e);
971 | }
972 | onComplete();
973 | };
974 | /** JavaScript API reporter.
975 | *
976 | * @constructor
977 | */
978 | jasmine.JsApiReporter = function() {
979 | this.started = false;
980 | this.finished = false;
981 | this.suites_ = [];
982 | this.results_ = {};
983 | };
984 |
985 | jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) {
986 | this.started = true;
987 | var suites = runner.topLevelSuites();
988 | for (var i = 0; i < suites.length; i++) {
989 | var suite = suites[i];
990 | this.suites_.push(this.summarize_(suite));
991 | }
992 | };
993 |
994 | jasmine.JsApiReporter.prototype.suites = function() {
995 | return this.suites_;
996 | };
997 |
998 | jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) {
999 | var isSuite = suiteOrSpec instanceof jasmine.Suite;
1000 | var summary = {
1001 | id: suiteOrSpec.id,
1002 | name: suiteOrSpec.description,
1003 | type: isSuite ? 'suite' : 'spec',
1004 | children: []
1005 | };
1006 |
1007 | if (isSuite) {
1008 | var children = suiteOrSpec.children();
1009 | for (var i = 0; i < children.length; i++) {
1010 | summary.children.push(this.summarize_(children[i]));
1011 | }
1012 | }
1013 | return summary;
1014 | };
1015 |
1016 | jasmine.JsApiReporter.prototype.results = function() {
1017 | return this.results_;
1018 | };
1019 |
1020 | jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) {
1021 | return this.results_[specId];
1022 | };
1023 |
1024 | //noinspection JSUnusedLocalSymbols
1025 | jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) {
1026 | this.finished = true;
1027 | };
1028 |
1029 | //noinspection JSUnusedLocalSymbols
1030 | jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) {
1031 | };
1032 |
1033 | //noinspection JSUnusedLocalSymbols
1034 | jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) {
1035 | this.results_[spec.id] = {
1036 | messages: spec.results().getItems(),
1037 | result: spec.results().failedCount > 0 ? "failed" : "passed"
1038 | };
1039 | };
1040 |
1041 | //noinspection JSUnusedLocalSymbols
1042 | jasmine.JsApiReporter.prototype.log = function(str) {
1043 | };
1044 |
1045 | jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){
1046 | var results = {};
1047 | for (var i = 0; i < specIds.length; i++) {
1048 | var specId = specIds[i];
1049 | results[specId] = this.summarizeResult_(this.results_[specId]);
1050 | }
1051 | return results;
1052 | };
1053 |
1054 | jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){
1055 | var summaryMessages = [];
1056 | var messagesLength = result.messages.length;
1057 | for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) {
1058 | var resultMessage = result.messages[messageIndex];
1059 | summaryMessages.push({
1060 | text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined,
1061 | passed: resultMessage.passed ? resultMessage.passed() : true,
1062 | type: resultMessage.type,
1063 | message: resultMessage.message,
1064 | trace: {
1065 | stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined
1066 | }
1067 | });
1068 | }
1069 |
1070 | return {
1071 | result : result.result,
1072 | messages : summaryMessages
1073 | };
1074 | };
1075 |
1076 | /**
1077 | * @constructor
1078 | * @param {jasmine.Env} env
1079 | * @param actual
1080 | * @param {jasmine.Spec} spec
1081 | */
1082 | jasmine.Matchers = function(env, actual, spec, opt_isNot) {
1083 | this.env = env;
1084 | this.actual = actual;
1085 | this.spec = spec;
1086 | this.isNot = opt_isNot || false;
1087 | this.reportWasCalled_ = false;
1088 | };
1089 |
1090 | // todo: @deprecated as of Jasmine 0.11, remove soon [xw]
1091 | jasmine.Matchers.pp = function(str) {
1092 | throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!");
1093 | };
1094 |
1095 | // todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw]
1096 | jasmine.Matchers.prototype.report = function(result, failing_message, details) {
1097 | throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs");
1098 | };
1099 |
1100 | jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) {
1101 | for (var methodName in prototype) {
1102 | if (methodName == 'report') continue;
1103 | var orig = prototype[methodName];
1104 | matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig);
1105 | }
1106 | };
1107 |
1108 | jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) {
1109 | return function() {
1110 | var matcherArgs = jasmine.util.argsToArray(arguments);
1111 | var result = matcherFunction.apply(this, arguments);
1112 |
1113 | if (this.isNot) {
1114 | result = !result;
1115 | }
1116 |
1117 | if (this.reportWasCalled_) return result;
1118 |
1119 | var message;
1120 | if (!result) {
1121 | if (this.message) {
1122 | message = this.message.apply(this, arguments);
1123 | if (jasmine.isArray_(message)) {
1124 | message = message[this.isNot ? 1 : 0];
1125 | }
1126 | } else {
1127 | var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
1128 | message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate;
1129 | if (matcherArgs.length > 0) {
1130 | for (var i = 0; i < matcherArgs.length; i++) {
1131 | if (i > 0) message += ",";
1132 | message += " " + jasmine.pp(matcherArgs[i]);
1133 | }
1134 | }
1135 | message += ".";
1136 | }
1137 | }
1138 | var expectationResult = new jasmine.ExpectationResult({
1139 | matcherName: matcherName,
1140 | passed: result,
1141 | expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0],
1142 | actual: this.actual,
1143 | message: message
1144 | });
1145 | this.spec.addMatcherResult(expectationResult);
1146 | return jasmine.undefined;
1147 | };
1148 | };
1149 |
1150 |
1151 |
1152 |
1153 | /**
1154 | * toBe: compares the actual to the expected using ===
1155 | * @param expected
1156 | */
1157 | jasmine.Matchers.prototype.toBe = function(expected) {
1158 | return this.actual === expected;
1159 | };
1160 |
1161 | /**
1162 | * toNotBe: compares the actual to the expected using !==
1163 | * @param expected
1164 | * @deprecated as of 1.0. Use not.toBe() instead.
1165 | */
1166 | jasmine.Matchers.prototype.toNotBe = function(expected) {
1167 | return this.actual !== expected;
1168 | };
1169 |
1170 | /**
1171 | * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc.
1172 | *
1173 | * @param expected
1174 | */
1175 | jasmine.Matchers.prototype.toEqual = function(expected) {
1176 | return this.env.equals_(this.actual, expected);
1177 | };
1178 |
1179 | /**
1180 | * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual
1181 | * @param expected
1182 | * @deprecated as of 1.0. Use not.toNotEqual() instead.
1183 | */
1184 | jasmine.Matchers.prototype.toNotEqual = function(expected) {
1185 | return !this.env.equals_(this.actual, expected);
1186 | };
1187 |
1188 | /**
1189 | * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes
1190 | * a pattern or a String.
1191 | *
1192 | * @param expected
1193 | */
1194 | jasmine.Matchers.prototype.toMatch = function(expected) {
1195 | return new RegExp(expected).test(this.actual);
1196 | };
1197 |
1198 | /**
1199 | * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch
1200 | * @param expected
1201 | * @deprecated as of 1.0. Use not.toMatch() instead.
1202 | */
1203 | jasmine.Matchers.prototype.toNotMatch = function(expected) {
1204 | return !(new RegExp(expected).test(this.actual));
1205 | };
1206 |
1207 | /**
1208 | * Matcher that compares the actual to jasmine.undefined.
1209 | */
1210 | jasmine.Matchers.prototype.toBeDefined = function() {
1211 | return (this.actual !== jasmine.undefined);
1212 | };
1213 |
1214 | /**
1215 | * Matcher that compares the actual to jasmine.undefined.
1216 | */
1217 | jasmine.Matchers.prototype.toBeUndefined = function() {
1218 | return (this.actual === jasmine.undefined);
1219 | };
1220 |
1221 | /**
1222 | * Matcher that compares the actual to null.
1223 | */
1224 | jasmine.Matchers.prototype.toBeNull = function() {
1225 | return (this.actual === null);
1226 | };
1227 |
1228 | /**
1229 | * Matcher that boolean not-nots the actual.
1230 | */
1231 | jasmine.Matchers.prototype.toBeTruthy = function() {
1232 | return !!this.actual;
1233 | };
1234 |
1235 |
1236 | /**
1237 | * Matcher that boolean nots the actual.
1238 | */
1239 | jasmine.Matchers.prototype.toBeFalsy = function() {
1240 | return !this.actual;
1241 | };
1242 |
1243 |
1244 | /**
1245 | * Matcher that checks to see if the actual, a Jasmine spy, was called.
1246 | */
1247 | jasmine.Matchers.prototype.toHaveBeenCalled = function() {
1248 | if (arguments.length > 0) {
1249 | throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith');
1250 | }
1251 |
1252 | if (!jasmine.isSpy(this.actual)) {
1253 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1254 | }
1255 |
1256 | this.message = function() {
1257 | return [
1258 | "Expected spy " + this.actual.identity + " to have been called.",
1259 | "Expected spy " + this.actual.identity + " not to have been called."
1260 | ];
1261 | };
1262 |
1263 | return this.actual.wasCalled;
1264 | };
1265 |
1266 | /** @deprecated Use expect(xxx).toHaveBeenCalled() instead */
1267 | jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled;
1268 |
1269 | /**
1270 | * Matcher that checks to see if the actual, a Jasmine spy, was not called.
1271 | *
1272 | * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead
1273 | */
1274 | jasmine.Matchers.prototype.wasNotCalled = function() {
1275 | if (arguments.length > 0) {
1276 | throw new Error('wasNotCalled does not take arguments');
1277 | }
1278 |
1279 | if (!jasmine.isSpy(this.actual)) {
1280 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1281 | }
1282 |
1283 | this.message = function() {
1284 | return [
1285 | "Expected spy " + this.actual.identity + " to not have been called.",
1286 | "Expected spy " + this.actual.identity + " to have been called."
1287 | ];
1288 | };
1289 |
1290 | return !this.actual.wasCalled;
1291 | };
1292 |
1293 | /**
1294 | * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters.
1295 | *
1296 | * @example
1297 | *
1298 | */
1299 | jasmine.Matchers.prototype.toHaveBeenCalledWith = function() {
1300 | var expectedArgs = jasmine.util.argsToArray(arguments);
1301 | if (!jasmine.isSpy(this.actual)) {
1302 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1303 | }
1304 | this.message = function() {
1305 | if (this.actual.callCount == 0) {
1306 | // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw]
1307 | return [
1308 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.",
1309 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was."
1310 | ];
1311 | } else {
1312 | return [
1313 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall),
1314 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall)
1315 | ];
1316 | }
1317 | };
1318 |
1319 | return this.env.contains_(this.actual.argsForCall, expectedArgs);
1320 | };
1321 |
1322 | /** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */
1323 | jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith;
1324 |
1325 | /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */
1326 | jasmine.Matchers.prototype.wasNotCalledWith = function() {
1327 | var expectedArgs = jasmine.util.argsToArray(arguments);
1328 | if (!jasmine.isSpy(this.actual)) {
1329 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.');
1330 | }
1331 |
1332 | this.message = function() {
1333 | return [
1334 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was",
1335 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was"
1336 | ]
1337 | };
1338 |
1339 | return !this.env.contains_(this.actual.argsForCall, expectedArgs);
1340 | };
1341 |
1342 | /**
1343 | * Matcher that checks that the expected item is an element in the actual Array.
1344 | *
1345 | * @param {Object} expected
1346 | */
1347 | jasmine.Matchers.prototype.toContain = function(expected) {
1348 | return this.env.contains_(this.actual, expected);
1349 | };
1350 |
1351 | /**
1352 | * Matcher that checks that the expected item is NOT an element in the actual Array.
1353 | *
1354 | * @param {Object} expected
1355 | * @deprecated as of 1.0. Use not.toNotContain() instead.
1356 | */
1357 | jasmine.Matchers.prototype.toNotContain = function(expected) {
1358 | return !this.env.contains_(this.actual, expected);
1359 | };
1360 |
1361 | jasmine.Matchers.prototype.toBeLessThan = function(expected) {
1362 | return this.actual < expected;
1363 | };
1364 |
1365 | jasmine.Matchers.prototype.toBeGreaterThan = function(expected) {
1366 | return this.actual > expected;
1367 | };
1368 |
1369 | /**
1370 | * Matcher that checks that the expected exception was thrown by the actual.
1371 | *
1372 | * @param {String} expected
1373 | */
1374 | jasmine.Matchers.prototype.toThrow = function(expected) {
1375 | var result = false;
1376 | var exception;
1377 | if (typeof this.actual != 'function') {
1378 | throw new Error('Actual is not a function');
1379 | }
1380 | try {
1381 | this.actual();
1382 | } catch (e) {
1383 | exception = e;
1384 | }
1385 | if (exception) {
1386 | result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected));
1387 | }
1388 |
1389 | var not = this.isNot ? "not " : "";
1390 |
1391 | this.message = function() {
1392 | if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) {
1393 | return ["Expected function " + not + "to throw", expected ? expected.message || expected : " an exception", ", but it threw", exception.message || exception].join(' ');
1394 | } else {
1395 | return "Expected function to throw an exception.";
1396 | }
1397 | };
1398 |
1399 | return result;
1400 | };
1401 |
1402 | jasmine.Matchers.Any = function(expectedClass) {
1403 | this.expectedClass = expectedClass;
1404 | };
1405 |
1406 | jasmine.Matchers.Any.prototype.matches = function(other) {
1407 | if (this.expectedClass == String) {
1408 | return typeof other == 'string' || other instanceof String;
1409 | }
1410 |
1411 | if (this.expectedClass == Number) {
1412 | return typeof other == 'number' || other instanceof Number;
1413 | }
1414 |
1415 | if (this.expectedClass == Function) {
1416 | return typeof other == 'function' || other instanceof Function;
1417 | }
1418 |
1419 | if (this.expectedClass == Object) {
1420 | return typeof other == 'object';
1421 | }
1422 |
1423 | return other instanceof this.expectedClass;
1424 | };
1425 |
1426 | jasmine.Matchers.Any.prototype.toString = function() {
1427 | return '';
1428 | };
1429 |
1430 | /**
1431 | * @constructor
1432 | */
1433 | jasmine.MultiReporter = function() {
1434 | this.subReporters_ = [];
1435 | };
1436 | jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter);
1437 |
1438 | jasmine.MultiReporter.prototype.addReporter = function(reporter) {
1439 | this.subReporters_.push(reporter);
1440 | };
1441 |
1442 | (function() {
1443 | var functionNames = [
1444 | "reportRunnerStarting",
1445 | "reportRunnerResults",
1446 | "reportSuiteResults",
1447 | "reportSpecStarting",
1448 | "reportSpecResults",
1449 | "log"
1450 | ];
1451 | for (var i = 0; i < functionNames.length; i++) {
1452 | var functionName = functionNames[i];
1453 | jasmine.MultiReporter.prototype[functionName] = (function(functionName) {
1454 | return function() {
1455 | for (var j = 0; j < this.subReporters_.length; j++) {
1456 | var subReporter = this.subReporters_[j];
1457 | if (subReporter[functionName]) {
1458 | subReporter[functionName].apply(subReporter, arguments);
1459 | }
1460 | }
1461 | };
1462 | })(functionName);
1463 | }
1464 | })();
1465 | /**
1466 | * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults
1467 | *
1468 | * @constructor
1469 | */
1470 | jasmine.NestedResults = function() {
1471 | /**
1472 | * The total count of results
1473 | */
1474 | this.totalCount = 0;
1475 | /**
1476 | * Number of passed results
1477 | */
1478 | this.passedCount = 0;
1479 | /**
1480 | * Number of failed results
1481 | */
1482 | this.failedCount = 0;
1483 | /**
1484 | * Was this suite/spec skipped?
1485 | */
1486 | this.skipped = false;
1487 | /**
1488 | * @ignore
1489 | */
1490 | this.items_ = [];
1491 | };
1492 |
1493 | /**
1494 | * Roll up the result counts.
1495 | *
1496 | * @param result
1497 | */
1498 | jasmine.NestedResults.prototype.rollupCounts = function(result) {
1499 | this.totalCount += result.totalCount;
1500 | this.passedCount += result.passedCount;
1501 | this.failedCount += result.failedCount;
1502 | };
1503 |
1504 | /**
1505 | * Adds a log message.
1506 | * @param values Array of message parts which will be concatenated later.
1507 | */
1508 | jasmine.NestedResults.prototype.log = function(values) {
1509 | this.items_.push(new jasmine.MessageResult(values));
1510 | };
1511 |
1512 | /**
1513 | * Getter for the results: message & results.
1514 | */
1515 | jasmine.NestedResults.prototype.getItems = function() {
1516 | return this.items_;
1517 | };
1518 |
1519 | /**
1520 | * Adds a result, tracking counts (total, passed, & failed)
1521 | * @param {jasmine.ExpectationResult|jasmine.NestedResults} result
1522 | */
1523 | jasmine.NestedResults.prototype.addResult = function(result) {
1524 | if (result.type != 'log') {
1525 | if (result.items_) {
1526 | this.rollupCounts(result);
1527 | } else {
1528 | this.totalCount++;
1529 | if (result.passed()) {
1530 | this.passedCount++;
1531 | } else {
1532 | this.failedCount++;
1533 | }
1534 | }
1535 | }
1536 | this.items_.push(result);
1537 | };
1538 |
1539 | /**
1540 | * @returns {Boolean} True if everything below passed
1541 | */
1542 | jasmine.NestedResults.prototype.passed = function() {
1543 | return this.passedCount === this.totalCount;
1544 | };
1545 | /**
1546 | * Base class for pretty printing for expectation results.
1547 | */
1548 | jasmine.PrettyPrinter = function() {
1549 | this.ppNestLevel_ = 0;
1550 | };
1551 |
1552 | /**
1553 | * Formats a value in a nice, human-readable string.
1554 | *
1555 | * @param value
1556 | */
1557 | jasmine.PrettyPrinter.prototype.format = function(value) {
1558 | if (this.ppNestLevel_ > 40) {
1559 | throw new Error('jasmine.PrettyPrinter: format() nested too deeply!');
1560 | }
1561 |
1562 | this.ppNestLevel_++;
1563 | try {
1564 | if (value === jasmine.undefined) {
1565 | this.emitScalar('undefined');
1566 | } else if (value === null) {
1567 | this.emitScalar('null');
1568 | } else if (value === jasmine.getGlobal()) {
1569 | this.emitScalar('');
1570 | } else if (value instanceof jasmine.Matchers.Any) {
1571 | this.emitScalar(value.toString());
1572 | } else if (typeof value === 'string') {
1573 | this.emitString(value);
1574 | } else if (jasmine.isSpy(value)) {
1575 | this.emitScalar("spy on " + value.identity);
1576 | } else if (value instanceof RegExp) {
1577 | this.emitScalar(value.toString());
1578 | } else if (typeof value === 'function') {
1579 | this.emitScalar('Function');
1580 | } else if (typeof value.nodeType === 'number') {
1581 | this.emitScalar('HTMLNode');
1582 | } else if (value instanceof Date) {
1583 | this.emitScalar('Date(' + value + ')');
1584 | } else if (value.__Jasmine_been_here_before__) {
1585 | this.emitScalar('');
1586 | } else if (jasmine.isArray_(value) || typeof value == 'object') {
1587 | value.__Jasmine_been_here_before__ = true;
1588 | if (jasmine.isArray_(value)) {
1589 | this.emitArray(value);
1590 | } else {
1591 | this.emitObject(value);
1592 | }
1593 | delete value.__Jasmine_been_here_before__;
1594 | } else {
1595 | this.emitScalar(value.toString());
1596 | }
1597 | } finally {
1598 | this.ppNestLevel_--;
1599 | }
1600 | };
1601 |
1602 | jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) {
1603 | for (var property in obj) {
1604 | if (property == '__Jasmine_been_here_before__') continue;
1605 | fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) != null) : false);
1606 | }
1607 | };
1608 |
1609 | jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_;
1610 | jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_;
1611 | jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_;
1612 | jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_;
1613 |
1614 | jasmine.StringPrettyPrinter = function() {
1615 | jasmine.PrettyPrinter.call(this);
1616 |
1617 | this.string = '';
1618 | };
1619 | jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter);
1620 |
1621 | jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) {
1622 | this.append(value);
1623 | };
1624 |
1625 | jasmine.StringPrettyPrinter.prototype.emitString = function(value) {
1626 | this.append("'" + value + "'");
1627 | };
1628 |
1629 | jasmine.StringPrettyPrinter.prototype.emitArray = function(array) {
1630 | this.append('[ ');
1631 | for (var i = 0; i < array.length; i++) {
1632 | if (i > 0) {
1633 | this.append(', ');
1634 | }
1635 | this.format(array[i]);
1636 | }
1637 | this.append(' ]');
1638 | };
1639 |
1640 | jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) {
1641 | var self = this;
1642 | this.append('{ ');
1643 | var first = true;
1644 |
1645 | this.iterateObject(obj, function(property, isGetter) {
1646 | if (first) {
1647 | first = false;
1648 | } else {
1649 | self.append(', ');
1650 | }
1651 |
1652 | self.append(property);
1653 | self.append(' : ');
1654 | if (isGetter) {
1655 | self.append('');
1656 | } else {
1657 | self.format(obj[property]);
1658 | }
1659 | });
1660 |
1661 | this.append(' }');
1662 | };
1663 |
1664 | jasmine.StringPrettyPrinter.prototype.append = function(value) {
1665 | this.string += value;
1666 | };
1667 | jasmine.Queue = function(env) {
1668 | this.env = env;
1669 | this.blocks = [];
1670 | this.running = false;
1671 | this.index = 0;
1672 | this.offset = 0;
1673 | this.abort = false;
1674 | };
1675 |
1676 | jasmine.Queue.prototype.addBefore = function(block) {
1677 | this.blocks.unshift(block);
1678 | };
1679 |
1680 | jasmine.Queue.prototype.add = function(block) {
1681 | this.blocks.push(block);
1682 | };
1683 |
1684 | jasmine.Queue.prototype.insertNext = function(block) {
1685 | this.blocks.splice((this.index + this.offset + 1), 0, block);
1686 | this.offset++;
1687 | };
1688 |
1689 | jasmine.Queue.prototype.start = function(onComplete) {
1690 | this.running = true;
1691 | this.onComplete = onComplete;
1692 | this.next_();
1693 | };
1694 |
1695 | jasmine.Queue.prototype.isRunning = function() {
1696 | return this.running;
1697 | };
1698 |
1699 | jasmine.Queue.LOOP_DONT_RECURSE = true;
1700 |
1701 | jasmine.Queue.prototype.next_ = function() {
1702 | var self = this;
1703 | var goAgain = true;
1704 |
1705 | while (goAgain) {
1706 | goAgain = false;
1707 |
1708 | if (self.index < self.blocks.length && !this.abort) {
1709 | var calledSynchronously = true;
1710 | var completedSynchronously = false;
1711 |
1712 | var onComplete = function () {
1713 | if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) {
1714 | completedSynchronously = true;
1715 | return;
1716 | }
1717 |
1718 | if (self.blocks[self.index].abort) {
1719 | self.abort = true;
1720 | }
1721 |
1722 | self.offset = 0;
1723 | self.index++;
1724 |
1725 | var now = new Date().getTime();
1726 | if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) {
1727 | self.env.lastUpdate = now;
1728 | self.env.setTimeout(function() {
1729 | self.next_();
1730 | }, 0);
1731 | } else {
1732 | if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) {
1733 | goAgain = true;
1734 | } else {
1735 | self.next_();
1736 | }
1737 | }
1738 | };
1739 | self.blocks[self.index].execute(onComplete);
1740 |
1741 | calledSynchronously = false;
1742 | if (completedSynchronously) {
1743 | onComplete();
1744 | }
1745 |
1746 | } else {
1747 | self.running = false;
1748 | if (self.onComplete) {
1749 | self.onComplete();
1750 | }
1751 | }
1752 | }
1753 | };
1754 |
1755 | jasmine.Queue.prototype.results = function() {
1756 | var results = new jasmine.NestedResults();
1757 | for (var i = 0; i < this.blocks.length; i++) {
1758 | if (this.blocks[i].results) {
1759 | results.addResult(this.blocks[i].results());
1760 | }
1761 | }
1762 | return results;
1763 | };
1764 |
1765 |
1766 | /**
1767 | * Runner
1768 | *
1769 | * @constructor
1770 | * @param {jasmine.Env} env
1771 | */
1772 | jasmine.Runner = function(env) {
1773 | var self = this;
1774 | self.env = env;
1775 | self.queue = new jasmine.Queue(env);
1776 | self.before_ = [];
1777 | self.after_ = [];
1778 | self.suites_ = [];
1779 | };
1780 |
1781 | jasmine.Runner.prototype.execute = function() {
1782 | var self = this;
1783 | if (self.env.reporter.reportRunnerStarting) {
1784 | self.env.reporter.reportRunnerStarting(this);
1785 | }
1786 | self.queue.start(function () {
1787 | self.finishCallback();
1788 | });
1789 | };
1790 |
1791 | jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) {
1792 | beforeEachFunction.typeName = 'beforeEach';
1793 | this.before_.splice(0,0,beforeEachFunction);
1794 | };
1795 |
1796 | jasmine.Runner.prototype.afterEach = function(afterEachFunction) {
1797 | afterEachFunction.typeName = 'afterEach';
1798 | this.after_.splice(0,0,afterEachFunction);
1799 | };
1800 |
1801 |
1802 | jasmine.Runner.prototype.finishCallback = function() {
1803 | this.env.reporter.reportRunnerResults(this);
1804 | };
1805 |
1806 | jasmine.Runner.prototype.addSuite = function(suite) {
1807 | this.suites_.push(suite);
1808 | };
1809 |
1810 | jasmine.Runner.prototype.add = function(block) {
1811 | if (block instanceof jasmine.Suite) {
1812 | this.addSuite(block);
1813 | }
1814 | this.queue.add(block);
1815 | };
1816 |
1817 | jasmine.Runner.prototype.specs = function () {
1818 | var suites = this.suites();
1819 | var specs = [];
1820 | for (var i = 0; i < suites.length; i++) {
1821 | specs = specs.concat(suites[i].specs());
1822 | }
1823 | return specs;
1824 | };
1825 |
1826 | jasmine.Runner.prototype.suites = function() {
1827 | return this.suites_;
1828 | };
1829 |
1830 | jasmine.Runner.prototype.topLevelSuites = function() {
1831 | var topLevelSuites = [];
1832 | for (var i = 0; i < this.suites_.length; i++) {
1833 | if (!this.suites_[i].parentSuite) {
1834 | topLevelSuites.push(this.suites_[i]);
1835 | }
1836 | }
1837 | return topLevelSuites;
1838 | };
1839 |
1840 | jasmine.Runner.prototype.results = function() {
1841 | return this.queue.results();
1842 | };
1843 | /**
1844 | * Internal representation of a Jasmine specification, or test.
1845 | *
1846 | * @constructor
1847 | * @param {jasmine.Env} env
1848 | * @param {jasmine.Suite} suite
1849 | * @param {String} description
1850 | */
1851 | jasmine.Spec = function(env, suite, description) {
1852 | if (!env) {
1853 | throw new Error('jasmine.Env() required');
1854 | }
1855 | if (!suite) {
1856 | throw new Error('jasmine.Suite() required');
1857 | }
1858 | var spec = this;
1859 | spec.id = env.nextSpecId ? env.nextSpecId() : null;
1860 | spec.env = env;
1861 | spec.suite = suite;
1862 | spec.description = description;
1863 | spec.queue = new jasmine.Queue(env);
1864 |
1865 | spec.afterCallbacks = [];
1866 | spec.spies_ = [];
1867 |
1868 | spec.results_ = new jasmine.NestedResults();
1869 | spec.results_.description = description;
1870 | spec.matchersClass = null;
1871 | };
1872 |
1873 | jasmine.Spec.prototype.getFullName = function() {
1874 | return this.suite.getFullName() + ' ' + this.description + '.';
1875 | };
1876 |
1877 |
1878 | jasmine.Spec.prototype.results = function() {
1879 | return this.results_;
1880 | };
1881 |
1882 | /**
1883 | * All parameters are pretty-printed and concatenated together, then written to the spec's output.
1884 | *
1885 | * Be careful not to leave calls to jasmine.log in production code.
1886 | */
1887 | jasmine.Spec.prototype.log = function() {
1888 | return this.results_.log(arguments);
1889 | };
1890 |
1891 | jasmine.Spec.prototype.runs = function (func) {
1892 | var block = new jasmine.Block(this.env, func, this);
1893 | this.addToQueue(block);
1894 | return this;
1895 | };
1896 |
1897 | jasmine.Spec.prototype.addToQueue = function (block) {
1898 | if (this.queue.isRunning()) {
1899 | this.queue.insertNext(block);
1900 | } else {
1901 | this.queue.add(block);
1902 | }
1903 | };
1904 |
1905 | /**
1906 | * @param {jasmine.ExpectationResult} result
1907 | */
1908 | jasmine.Spec.prototype.addMatcherResult = function(result) {
1909 | this.results_.addResult(result);
1910 | };
1911 |
1912 | jasmine.Spec.prototype.expect = function(actual) {
1913 | var positive = new (this.getMatchersClass_())(this.env, actual, this);
1914 | positive.not = new (this.getMatchersClass_())(this.env, actual, this, true);
1915 | return positive;
1916 | };
1917 |
1918 | /**
1919 | * Waits a fixed time period before moving to the next block.
1920 | *
1921 | * @deprecated Use waitsFor() instead
1922 | * @param {Number} timeout milliseconds to wait
1923 | */
1924 | jasmine.Spec.prototype.waits = function(timeout) {
1925 | var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
1926 | this.addToQueue(waitsFunc);
1927 | return this;
1928 | };
1929 |
1930 | /**
1931 | * Waits for the latchFunction to return true before proceeding to the next block.
1932 | *
1933 | * @param {Function} latchFunction
1934 | * @param {String} optional_timeoutMessage
1935 | * @param {Number} optional_timeout
1936 | */
1937 | jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
1938 | var latchFunction_ = null;
1939 | var optional_timeoutMessage_ = null;
1940 | var optional_timeout_ = null;
1941 |
1942 | for (var i = 0; i < arguments.length; i++) {
1943 | var arg = arguments[i];
1944 | switch (typeof arg) {
1945 | case 'function':
1946 | latchFunction_ = arg;
1947 | break;
1948 | case 'string':
1949 | optional_timeoutMessage_ = arg;
1950 | break;
1951 | case 'number':
1952 | optional_timeout_ = arg;
1953 | break;
1954 | }
1955 | }
1956 |
1957 | var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
1958 | this.addToQueue(waitsForFunc);
1959 | return this;
1960 | };
1961 |
1962 | jasmine.Spec.prototype.fail = function (e) {
1963 | var expectationResult = new jasmine.ExpectationResult({
1964 | passed: false,
1965 | message: e ? jasmine.util.formatException(e) : 'Exception'
1966 | });
1967 | this.results_.addResult(expectationResult);
1968 | };
1969 |
1970 | jasmine.Spec.prototype.getMatchersClass_ = function() {
1971 | return this.matchersClass || this.env.matchersClass;
1972 | };
1973 |
1974 | jasmine.Spec.prototype.addMatchers = function(matchersPrototype) {
1975 | var parent = this.getMatchersClass_();
1976 | var newMatchersClass = function() {
1977 | parent.apply(this, arguments);
1978 | };
1979 | jasmine.util.inherit(newMatchersClass, parent);
1980 | jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass);
1981 | this.matchersClass = newMatchersClass;
1982 | };
1983 |
1984 | jasmine.Spec.prototype.finishCallback = function() {
1985 | this.env.reporter.reportSpecResults(this);
1986 | };
1987 |
1988 | jasmine.Spec.prototype.finish = function(onComplete) {
1989 | this.removeAllSpies();
1990 | this.finishCallback();
1991 | if (onComplete) {
1992 | onComplete();
1993 | }
1994 | };
1995 |
1996 | jasmine.Spec.prototype.after = function(doAfter) {
1997 | if (this.queue.isRunning()) {
1998 | this.queue.add(new jasmine.Block(this.env, doAfter, this));
1999 | } else {
2000 | this.afterCallbacks.unshift(doAfter);
2001 | }
2002 | };
2003 |
2004 | jasmine.Spec.prototype.execute = function(onComplete) {
2005 | var spec = this;
2006 | if (!spec.env.specFilter(spec)) {
2007 | spec.results_.skipped = true;
2008 | spec.finish(onComplete);
2009 | return;
2010 | }
2011 |
2012 | this.env.reporter.reportSpecStarting(this);
2013 |
2014 | spec.env.currentSpec = spec;
2015 |
2016 | spec.addBeforesAndAftersToQueue();
2017 |
2018 | spec.queue.start(function () {
2019 | spec.finish(onComplete);
2020 | });
2021 | };
2022 |
2023 | jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() {
2024 | var runner = this.env.currentRunner();
2025 | var i;
2026 |
2027 | for (var suite = this.suite; suite; suite = suite.parentSuite) {
2028 | for (i = 0; i < suite.before_.length; i++) {
2029 | this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this));
2030 | }
2031 | }
2032 | for (i = 0; i < runner.before_.length; i++) {
2033 | this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this));
2034 | }
2035 | for (i = 0; i < this.afterCallbacks.length; i++) {
2036 | this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this));
2037 | }
2038 | for (suite = this.suite; suite; suite = suite.parentSuite) {
2039 | for (i = 0; i < suite.after_.length; i++) {
2040 | this.queue.add(new jasmine.Block(this.env, suite.after_[i], this));
2041 | }
2042 | }
2043 | for (i = 0; i < runner.after_.length; i++) {
2044 | this.queue.add(new jasmine.Block(this.env, runner.after_[i], this));
2045 | }
2046 | };
2047 |
2048 | jasmine.Spec.prototype.explodes = function() {
2049 | throw 'explodes function should not have been called';
2050 | };
2051 |
2052 | jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) {
2053 | if (obj == jasmine.undefined) {
2054 | throw "spyOn could not find an object to spy upon for " + methodName + "()";
2055 | }
2056 |
2057 | if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) {
2058 | throw methodName + '() method does not exist';
2059 | }
2060 |
2061 | if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) {
2062 | throw new Error(methodName + ' has already been spied upon');
2063 | }
2064 |
2065 | var spyObj = jasmine.createSpy(methodName);
2066 |
2067 | this.spies_.push(spyObj);
2068 | spyObj.baseObj = obj;
2069 | spyObj.methodName = methodName;
2070 | spyObj.originalValue = obj[methodName];
2071 |
2072 | obj[methodName] = spyObj;
2073 |
2074 | return spyObj;
2075 | };
2076 |
2077 | jasmine.Spec.prototype.removeAllSpies = function() {
2078 | for (var i = 0; i < this.spies_.length; i++) {
2079 | var spy = this.spies_[i];
2080 | spy.baseObj[spy.methodName] = spy.originalValue;
2081 | }
2082 | this.spies_ = [];
2083 | };
2084 |
2085 | /**
2086 | * Internal representation of a Jasmine suite.
2087 | *
2088 | * @constructor
2089 | * @param {jasmine.Env} env
2090 | * @param {String} description
2091 | * @param {Function} specDefinitions
2092 | * @param {jasmine.Suite} parentSuite
2093 | */
2094 | jasmine.Suite = function(env, description, specDefinitions, parentSuite) {
2095 | var self = this;
2096 | self.id = env.nextSuiteId ? env.nextSuiteId() : null;
2097 | self.description = description;
2098 | self.queue = new jasmine.Queue(env);
2099 | self.parentSuite = parentSuite;
2100 | self.env = env;
2101 | self.before_ = [];
2102 | self.after_ = [];
2103 | self.children_ = [];
2104 | self.suites_ = [];
2105 | self.specs_ = [];
2106 | };
2107 |
2108 | jasmine.Suite.prototype.getFullName = function() {
2109 | var fullName = this.description;
2110 | for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
2111 | fullName = parentSuite.description + ' ' + fullName;
2112 | }
2113 | return fullName;
2114 | };
2115 |
2116 | jasmine.Suite.prototype.finish = function(onComplete) {
2117 | this.env.reporter.reportSuiteResults(this);
2118 | this.finished = true;
2119 | if (typeof(onComplete) == 'function') {
2120 | onComplete();
2121 | }
2122 | };
2123 |
2124 | jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) {
2125 | beforeEachFunction.typeName = 'beforeEach';
2126 | this.before_.unshift(beforeEachFunction);
2127 | };
2128 |
2129 | jasmine.Suite.prototype.afterEach = function(afterEachFunction) {
2130 | afterEachFunction.typeName = 'afterEach';
2131 | this.after_.unshift(afterEachFunction);
2132 | };
2133 |
2134 | jasmine.Suite.prototype.results = function() {
2135 | return this.queue.results();
2136 | };
2137 |
2138 | jasmine.Suite.prototype.add = function(suiteOrSpec) {
2139 | this.children_.push(suiteOrSpec);
2140 | if (suiteOrSpec instanceof jasmine.Suite) {
2141 | this.suites_.push(suiteOrSpec);
2142 | this.env.currentRunner().addSuite(suiteOrSpec);
2143 | } else {
2144 | this.specs_.push(suiteOrSpec);
2145 | }
2146 | this.queue.add(suiteOrSpec);
2147 | };
2148 |
2149 | jasmine.Suite.prototype.specs = function() {
2150 | return this.specs_;
2151 | };
2152 |
2153 | jasmine.Suite.prototype.suites = function() {
2154 | return this.suites_;
2155 | };
2156 |
2157 | jasmine.Suite.prototype.children = function() {
2158 | return this.children_;
2159 | };
2160 |
2161 | jasmine.Suite.prototype.execute = function(onComplete) {
2162 | var self = this;
2163 | this.queue.start(function () {
2164 | self.finish(onComplete);
2165 | });
2166 | };
2167 | jasmine.WaitsBlock = function(env, timeout, spec) {
2168 | this.timeout = timeout;
2169 | jasmine.Block.call(this, env, null, spec);
2170 | };
2171 |
2172 | jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block);
2173 |
2174 | jasmine.WaitsBlock.prototype.execute = function (onComplete) {
2175 | this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...');
2176 | this.env.setTimeout(function () {
2177 | onComplete();
2178 | }, this.timeout);
2179 | };
2180 | /**
2181 | * A block which waits for some condition to become true, with timeout.
2182 | *
2183 | * @constructor
2184 | * @extends jasmine.Block
2185 | * @param {jasmine.Env} env The Jasmine environment.
2186 | * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
2187 | * @param {Function} latchFunction A function which returns true when the desired condition has been met.
2188 | * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
2189 | * @param {jasmine.Spec} spec The Jasmine spec.
2190 | */
2191 | jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
2192 | this.timeout = timeout || env.defaultTimeoutInterval;
2193 | this.latchFunction = latchFunction;
2194 | this.message = message;
2195 | this.totalTimeSpentWaitingForLatch = 0;
2196 | jasmine.Block.call(this, env, null, spec);
2197 | };
2198 | jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
2199 |
2200 | jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
2201 |
2202 | jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
2203 | this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
2204 | var latchFunctionResult;
2205 | try {
2206 | latchFunctionResult = this.latchFunction.apply(this.spec);
2207 | } catch (e) {
2208 | this.spec.fail(e);
2209 | onComplete();
2210 | return;
2211 | }
2212 |
2213 | if (latchFunctionResult) {
2214 | onComplete();
2215 | } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
2216 | var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
2217 | this.spec.fail({
2218 | name: 'timeout',
2219 | message: message
2220 | });
2221 |
2222 | this.abort = true;
2223 | onComplete();
2224 | } else {
2225 | this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
2226 | var self = this;
2227 | this.env.setTimeout(function() {
2228 | self.execute(onComplete);
2229 | }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
2230 | }
2231 | };
2232 | // Mock setTimeout, clearTimeout
2233 | // Contributed by Pivotal Computer Systems, www.pivotalsf.com
2234 |
2235 | jasmine.FakeTimer = function() {
2236 | this.reset();
2237 |
2238 | var self = this;
2239 | self.setTimeout = function(funcToCall, millis) {
2240 | self.timeoutsMade++;
2241 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false);
2242 | return self.timeoutsMade;
2243 | };
2244 |
2245 | self.setInterval = function(funcToCall, millis) {
2246 | self.timeoutsMade++;
2247 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true);
2248 | return self.timeoutsMade;
2249 | };
2250 |
2251 | self.clearTimeout = function(timeoutKey) {
2252 | self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2253 | };
2254 |
2255 | self.clearInterval = function(timeoutKey) {
2256 | self.scheduledFunctions[timeoutKey] = jasmine.undefined;
2257 | };
2258 |
2259 | };
2260 |
2261 | jasmine.FakeTimer.prototype.reset = function() {
2262 | this.timeoutsMade = 0;
2263 | this.scheduledFunctions = {};
2264 | this.nowMillis = 0;
2265 | };
2266 |
2267 | jasmine.FakeTimer.prototype.tick = function(millis) {
2268 | var oldMillis = this.nowMillis;
2269 | var newMillis = oldMillis + millis;
2270 | this.runFunctionsWithinRange(oldMillis, newMillis);
2271 | this.nowMillis = newMillis;
2272 | };
2273 |
2274 | jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) {
2275 | var scheduledFunc;
2276 | var funcsToRun = [];
2277 | for (var timeoutKey in this.scheduledFunctions) {
2278 | scheduledFunc = this.scheduledFunctions[timeoutKey];
2279 | if (scheduledFunc != jasmine.undefined &&
2280 | scheduledFunc.runAtMillis >= oldMillis &&
2281 | scheduledFunc.runAtMillis <= nowMillis) {
2282 | funcsToRun.push(scheduledFunc);
2283 | this.scheduledFunctions[timeoutKey] = jasmine.undefined;
2284 | }
2285 | }
2286 |
2287 | if (funcsToRun.length > 0) {
2288 | funcsToRun.sort(function(a, b) {
2289 | return a.runAtMillis - b.runAtMillis;
2290 | });
2291 | for (var i = 0; i < funcsToRun.length; ++i) {
2292 | try {
2293 | var funcToRun = funcsToRun[i];
2294 | this.nowMillis = funcToRun.runAtMillis;
2295 | funcToRun.funcToCall();
2296 | if (funcToRun.recurring) {
2297 | this.scheduleFunction(funcToRun.timeoutKey,
2298 | funcToRun.funcToCall,
2299 | funcToRun.millis,
2300 | true);
2301 | }
2302 | } catch(e) {
2303 | }
2304 | }
2305 | this.runFunctionsWithinRange(oldMillis, nowMillis);
2306 | }
2307 | };
2308 |
2309 | jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) {
2310 | this.scheduledFunctions[timeoutKey] = {
2311 | runAtMillis: this.nowMillis + millis,
2312 | funcToCall: funcToCall,
2313 | recurring: recurring,
2314 | timeoutKey: timeoutKey,
2315 | millis: millis
2316 | };
2317 | };
2318 |
2319 | /**
2320 | * @namespace
2321 | */
2322 | jasmine.Clock = {
2323 | defaultFakeTimer: new jasmine.FakeTimer(),
2324 |
2325 | reset: function() {
2326 | jasmine.Clock.assertInstalled();
2327 | jasmine.Clock.defaultFakeTimer.reset();
2328 | },
2329 |
2330 | tick: function(millis) {
2331 | jasmine.Clock.assertInstalled();
2332 | jasmine.Clock.defaultFakeTimer.tick(millis);
2333 | },
2334 |
2335 | runFunctionsWithinRange: function(oldMillis, nowMillis) {
2336 | jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis);
2337 | },
2338 |
2339 | scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
2340 | jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring);
2341 | },
2342 |
2343 | useMock: function() {
2344 | if (!jasmine.Clock.isInstalled()) {
2345 | var spec = jasmine.getEnv().currentSpec;
2346 | spec.after(jasmine.Clock.uninstallMock);
2347 |
2348 | jasmine.Clock.installMock();
2349 | }
2350 | },
2351 |
2352 | installMock: function() {
2353 | jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer;
2354 | },
2355 |
2356 | uninstallMock: function() {
2357 | jasmine.Clock.assertInstalled();
2358 | jasmine.Clock.installed = jasmine.Clock.real;
2359 | },
2360 |
2361 | real: {
2362 | setTimeout: jasmine.getGlobal().setTimeout,
2363 | clearTimeout: jasmine.getGlobal().clearTimeout,
2364 | setInterval: jasmine.getGlobal().setInterval,
2365 | clearInterval: jasmine.getGlobal().clearInterval
2366 | },
2367 |
2368 | assertInstalled: function() {
2369 | if (!jasmine.Clock.isInstalled()) {
2370 | throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
2371 | }
2372 | },
2373 |
2374 | isInstalled: function() {
2375 | return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer;
2376 | },
2377 |
2378 | installed: null
2379 | };
2380 | jasmine.Clock.installed = jasmine.Clock.real;
2381 |
2382 | //else for IE support
2383 | jasmine.getGlobal().setTimeout = function(funcToCall, millis) {
2384 | if (jasmine.Clock.installed.setTimeout.apply) {
2385 | return jasmine.Clock.installed.setTimeout.apply(this, arguments);
2386 | } else {
2387 | return jasmine.Clock.installed.setTimeout(funcToCall, millis);
2388 | }
2389 | };
2390 |
2391 | jasmine.getGlobal().setInterval = function(funcToCall, millis) {
2392 | if (jasmine.Clock.installed.setInterval.apply) {
2393 | return jasmine.Clock.installed.setInterval.apply(this, arguments);
2394 | } else {
2395 | return jasmine.Clock.installed.setInterval(funcToCall, millis);
2396 | }
2397 | };
2398 |
2399 | jasmine.getGlobal().clearTimeout = function(timeoutKey) {
2400 | if (jasmine.Clock.installed.clearTimeout.apply) {
2401 | return jasmine.Clock.installed.clearTimeout.apply(this, arguments);
2402 | } else {
2403 | return jasmine.Clock.installed.clearTimeout(timeoutKey);
2404 | }
2405 | };
2406 |
2407 | jasmine.getGlobal().clearInterval = function(timeoutKey) {
2408 | if (jasmine.Clock.installed.clearTimeout.apply) {
2409 | return jasmine.Clock.installed.clearInterval.apply(this, arguments);
2410 | } else {
2411 | return jasmine.Clock.installed.clearInterval(timeoutKey);
2412 | }
2413 | };
2414 |
2415 |
2416 | jasmine.version_= {
2417 | "major": 1,
2418 | "minor": 0,
2419 | "build": 1,
2420 | "revision": 1286311016
2421 | };
2422 |
--------------------------------------------------------------------------------