- ``` of tweets for you, and puts it in the DOM. This plugin comes with a static ```$.twitter``` which ```$.fn.twitter``` uses under the hood for doing twitter searches.
10 |
11 | ## Demo
12 | We've got a handy demo up at http://bl.ocks.org/1813727
13 |
14 | ## Getting Started
15 | Download "Cowboy" Ben Alman's [JavaScript Linkify - v0.3](https://raw.github.com/cowboy/javascript-linkify/master/ba-linkify.min.js).
16 |
17 | Download the [production version][min] or the [development version][max] of jQuery.twitter.
18 |
19 | [min]: https://raw.github.com/boazsender/jQuery-Twitter-Plugin/master/dist/jquery.twitter.min.js
20 | [max]: https://raw.github.com/boazsender/jQuery-Twitter-Plugin/master/dist/jquery.twitter.js
21 |
22 | In the browser:
23 |
24 | ```
25 |
26 |
27 |
28 |
33 |
36 | ```
37 |
38 | ## Examples
39 | You can see a pretty thorough overview of this plugins usage from [this Gist](http://bl.ocks.org/1813727).
40 |
41 | ### Simple Syntax:
42 | Passing in a string to the plugin simply performs a search with that string.
43 |
44 | ```
45 | $('selector').twitter('search terms');
46 | ```
47 |
48 | ### Verbose Syntax:
49 | There are lots of options, so you could do something more like:
50 |
51 | ```
52 | $('selector').twitter({
53 | // From this person
54 | from : 'BoazSender',
55 | // Include @replies?
56 | replies : false,
57 | // All of these words
58 | ands : 'jquery bocoup',
59 | // Any of these words
60 | ors : 'gangster javascript',
61 | // None of these words
62 | nots : 'dirty words',
63 | // don't include user avatars in the list.
64 | avatar : false
65 | });
66 | ```
67 |
68 | ## Documentation
69 | The jQuery Twitter Plugin provides two methods and a public default options object:
70 |
71 | ### Static Method
72 | $.twitter(options, callback)
73 |
74 | _**options**: the string or object used to configure the search_
75 |
76 | _**callback**: the function to run when the results come back from twitter. Three arguments are passed to this callback(tweets, query, exclusionsExp)_
77 |
78 | This method allows you to get twitter results and work with the JSON response. Fore example:
79 |
80 | ```
81 | $.twitter({from: 'BoazSender', replies : false}, function(tweets){
82 | console.log(tweets);
83 | });
84 | ```
85 |
86 | ### jQuery Collection Method
87 | $.fn.twitter(options, callback)
88 |
89 | _**options**: the string or object used to configure the search_
90 |
91 | _**callback**: the function to run when the results come back from twitter. One boolean is passed to this callback. True if tweets were injected, False if no tweets were returned_
92 |
93 | This method uses $.twitter() internally to go and get the tweets you ask for, and render them in a ```
- ``` within each element in the jQuery collection you call it on. For example:
94 |
95 | ```
96 | $('selector').twitter('search terms', function(tweets){
97 | if(tweets){
98 | console.log('Tweets have been added');
99 | }else{
100 | console.log('Zero tweets retruned, no tweets added to the page');
101 | }
102 | });
103 | ```
104 |
105 | ### Default Options Object
106 | $.twitter.options
107 |
108 | This is the publicly available object that $.twitter() and $.fn.twitter() use to configure twitter searches. You can override it at the beginning of your code to prevent yourself from repeating configurations unnecessarily. For example:
109 |
110 | ```
111 | // Default all twitter lists to exclude @replies and dirty words
112 | $.twitter.options.replies = false;
113 |
114 | // Set a whole bunch of defaults at once
115 |
116 | $.extend($.twitter.options, {
117 | replies : false,
118 | retweets : false,
119 | limit : 20,
120 | nots : 'dirty words'
121 | });
122 | ```
123 |
124 | ### Standard Twitter Search API options
125 | You can pass the following default Twitter Search API Parameters to $.fn.twitter() as properties of the options object:
126 |
127 | * **q**: Default query
128 | * **ands**: All of these words
129 | * **phrase**: This exact phrase
130 | * **ors**: Any of these words
131 | * **nots**: None of these word
132 | * **tag**: This hashtag
133 | * **lang**: Written in language
134 | * **from**: From this person
135 | * **to**: To this person
136 | * **ref**: Referencing this person
137 | * **near**: Near this place
138 | * **within**: Within this distance
139 | * **units**: Distance unit (miles or kilometers)
140 | * **since**: Since this date
141 | * **until**: Until this date
142 | * **tude**: Attitude: '?' or ':)' or ':('
143 | * **filter**: Containing**: 'links'
144 | * **include**: Include retweet?**: 'retweets'
145 | * **rpp**: Results per page
146 | * **include_entities**: Intelligently expand media, hyperlinks, @mentions, and hashtags
147 |
148 | ### Non Standard Options
149 | In addition to supporting the default Twitter Search API URL parameters, $.fn.twitter() also supports five of it's own options for filtering out mentions and retweets and for handling no results cases client side.
150 |
151 | * **limit**: Number of tweets to get. Maps to and supersedes rpp (results per page).
152 | * **exclusions**: Space delimited list of strings (eg: '_ s gr @b'). Use this to exclude tweets containing strings that are part of a word
153 | * **avatar**: Include user avatars? true by default. (Boolean)
154 | * **notFoundText**: Text to display if no results are found
155 | * **replies**: Include replies? (Boolean)
156 | * **retweets**: Include retweets (Boolean)
157 |
158 | ## Contributing
159 | To get started contributing to jQuery.twitter.js, install [grunt](https://github.com/cowboy/grunt) globally (```$ npm install grunt -g ```).
160 |
161 | This project generally follows [Idiomatic.js](https://github.com/rwldrn/idiomatic.js) from Rick Waldron, take care to maintain the existing coding style. Add *unit tests* and *written documentation* for any new or changed functionality, and make sure all your code passes this project's grunt. This project's [gruntfile](https://github.com/boazsender/jQuery-Twitter-Plugin/blob/master/grunt.js) was generated with ```$ grunt init:jquery```.
162 |
163 | Do not edit files in the "dist" directory as they are generated via grunt. You'll find source code in the "src" subdirectory. Work inside of the src directory, and use grunt to concat/min/test/lint the code before making a pull request. Running ```$ grunt watch``` from the root of this project will do this for you as you go.
164 |
165 | ## Release History
166 |
167 | * 2012/01/22 - v0.2.1 - Added callback support to .fn.twitter, upgrading to grunt v0.3.9 and QUnit v1.7.0pre
168 | * 2012/01/22 - v0.2.0 - Moved to grunt based project organization and concat/min/lint/test, started passing lint.
169 | * 2012/01/21 - v0.1.1 - Upgraded to jQuery 1.7.1, fixed classname bug, got rid of all globals.
170 | * 2011/08/11 - v0.1.0 - Initial release.
171 |
172 | ## License
173 | Copyright (c) 2012 Boaz Sender
174 | Licensed under the MIT, GPL licenses.
175 | http://code.bocoup.com/license/
176 |
177 | jQuery-Twitter depends on [JavaScript Linkify - v0.3](https://github.com/cowboy/javascript-linkify) ([code](https://raw.github.com/cowboy/javascript-linkify/master/ba-linkify.min.js)) from "Cowboy" Ben Alman.
178 |
179 | Some of jQuery-Twitter's regexps adapted from http://userscripts.org/scripts/review/7122
180 |
181 | This project is built with "Cowboy" Ben Alman's [Grunt](https://github.com/cowboy/grunt).
182 |
183 | ## Authors
184 |
185 | * [Boaz Sender](http://github.com/boazsender)
186 | * [Rick Waldron](http://github.com/rwldrn)
187 | * [Nick Cammarata](http://github.com/ncammarata)
188 | * [Irene Ros](http://github.com/iros)
189 | * [Tyom Semonov](https://github.com/tyom)
190 | * [Adam Sontag](http://github.com/ajpiano)
191 | * [Tyler Craft](http://github.com/tylercraft)
192 |
--------------------------------------------------------------------------------
/dist/jquery.twitter.js:
--------------------------------------------------------------------------------
1 | /*! jQuery Twitter Plugin - v0.3 - 2012-12-24
2 | * https://github.com/boazsender/jQuery-Twitter-Plugin
3 | * Copyright (c) 2012 Boaz Sender; Licensed MIT, GPL */
4 |
5 | var linkify = linkify || function() {};
6 | ;(function($, linkify) {
7 |
8 | var
9 | mention = function( str ) {
10 | return str.replace(/[@]+[a-z0\-9-_]+/ig, function( username ) {
11 | return username.link("http://twitter.com/"+ username.replace("@","") );
12 | });
13 | },
14 | hashtags = function( str ) {
15 | return str.replace(/[#]+[a-z0\-9-_]+/ig, function( tag ) {
16 | return tag.link("http://search.twitter.com/search?q="+tag.replace("#","%23"));
17 | });
18 | },
19 | entityExpanders = {
20 | // Simply expand media entities as though they were hyperlinks
21 | media: function( text, mediaEntity ) {
22 | return entityExpanders.urls(text, mediaEntity);
23 | },
24 | urls: function( text, urlEntity ) {
25 | return "" +
27 | urlEntity.display_url +
28 | "";
29 | },
30 | user_mentions: function( text, userEntity ) {
31 | return "@" + userEntity.screen_name +
33 | "";
34 | },
35 | hashtags: function( text, hashtagEntity ) {
36 | return "#" + hashtagEntity.text + "";
38 | }
39 | },
40 | expandEntities = function( tweet ) {
41 | var expanded = tweet.text;
42 | var allEnts = [];
43 |
44 | // To facilitate an in-place replacement, create a flat list of all
45 | // entities, sorted in descending order according to index in the tweet.
46 | $.each(tweet.entities, function(entityType, entities) {
47 | $.each(entities, function(_, entity) {
48 | entity.type = entityType;
49 | });
50 | allEnts = allEnts.concat(entities);
51 | });
52 | allEnts.sort(function(a, b) {
53 | return a.indices[0] < b.indices[0];
54 | });
55 |
56 | $.each(allEnts, function(_, entity) {
57 | // Check for expander first in order to prevent future entities from
58 | // breaking the plugin
59 | if (entityExpanders[entity.type]) {
60 | expanded = expanded.slice(0, entity.indices[0]) +
61 | entityExpanders[entity.type](expanded, entity) +
62 | expanded.slice(entity.indices[1]);
63 | }
64 | });
65 |
66 | return expanded;
67 | };
68 |
69 | $.twitter = function (options, callback) {
70 | // Fail if the options arg is not set
71 | if ( !options ) {
72 | return false;
73 | }
74 |
75 | // Set a temporary default query object
76 | var query,
77 | // Set up a string to be used later in the case that exclusions have been set
78 | exclusionsStr = "",
79 | // Set up a regex to be used later in the case that exclusions have been set
80 | exclusionsExp = new RegExp(false);
81 |
82 | // If options is a string use it as standalone query
83 | if ( typeof options === "string" ) {
84 | query = $.extend({}, $.twitter.opts, {
85 | q: options
86 | });
87 | // Else prepare the options object to be serialized
88 | } else {
89 | // If a limit is set, add it to the query object
90 | options.rpp = options.limit ? options.limit : options.rpp;
91 |
92 | // If no limit is set, make the limit the rpp
93 | options.limit = options.limit ? options.limit : options.rpp;
94 |
95 | // If there are exlusions, turn them into a regex string
96 | exclusionsStr = options.exclusions ? options.exclusions.replace(" ", "|") : false;
97 |
98 | // If there are exlusions, turn the regex string we just made into a RegExp
99 | exclusionsExp = exclusionsStr ? new RegExp( exclusionsStr ) : false;
100 |
101 | // Make a new object that is a merger of the options passed in with the default $.twitter.opts object
102 | // and assign it to the query variable
103 | query = $.extend({}, $.twitter.opts, options);
104 |
105 | // If there are exclusions, or replies or retweets are set to false, multiply the results to ask for from twitter by ten
106 | // We need to do this so that we have some meat to work with if the exclusions are common
107 | query.rpp = query.exclusions || !query.replies || !query.retweets ? (query.rpp * 10) : query.rpp;
108 |
109 | }
110 |
111 |
112 | // Call Twitter JSONP
113 | $.getJSON("http://search.twitter.com/search.json?callback=?", query, function(tweets){
114 | callback(tweets, query, exclusionsExp);
115 | });
116 | };
117 |
118 | $.fn.twitter = function( options, callback ) {
119 | // Fail gracefully if the options arg is not set
120 | // return the jQuery obj so that chaining does not break
121 | if ( !options ) {
122 | return this;
123 | }
124 |
125 | // Begin to iterate over the jQuery collection that the method was called on
126 | return this.each(function () {
127 | // Cache `this`
128 | var $this = $(this);
129 |
130 | $.twitter(options, function( tweets, query, exclusionsExp ) {
131 | //Create and cache a new UL
132 | var $tweets = $("
- "),
133 | // Create a counter variable to count up how many tweets we have rendered
134 | // unfortunately we have to do this, because exclusions, retweet booleans and replies booleans
135 | // are not supported by the Twitter Search API
136 | limitInt = 0,
137 | i;
138 |
139 | // If there are results to work with
140 | if ( tweets.results && tweets.results.length ) {
141 |
142 | // Iterate over returned tweets
143 | for ( i in tweets.results ) {
144 |
145 | // Cache tweet content
146 | var tweet = tweets.results[i],
147 | // Set a variable to determine weather replies are set to false, and if so, weather the tweet starts with a reply
148 | allowReply = !query.replies && tweet.to_user_id ? false : true,
149 | // Set a variable to determine weather retweets are set to false, and if so, weather the tweet starts with a retweet
150 | allowRetweet = !query.retweets && tweet.text.slice(0,2) === "RT" ? false : true;
151 |
152 | // Only proceed if allow reply is false
153 | if ( !allowReply ) {
154 | continue;
155 | }
156 |
157 | // Only proceed if allow retweet is false
158 | if ( !allowRetweet ) {
159 | continue;
160 | }
161 |
162 | // If exlusions set and none of the exlusions is found in the tweet then add it to the DOM
163 | if ( exclusionsExp && exclusionsExp.test(tweet.text) ) {
164 | continue;
165 | }
166 |
167 | // Create and cache new LI
168 | var $tweet = $("", {
169 | "class": "tweet"
170 | });
171 |
172 | // Make the avatar, and append it to the $tweet
173 | if ( query.avatar === true ) {
174 | $tweet.append($("", {
175 | href: "http://twitter.com/" + tweet.from_user,
176 | html: "
- "),
139 | // Create a counter variable to count up how many tweets we have rendered
140 | // unfortunately we have to do this, because exclusions, retweet booleans and replies booleans
141 | // are not supported by the Twitter Search API
142 | limitInt = 0,
143 | i;
144 |
145 | // If there are results to work with
146 | if ( tweets.results && tweets.results.length ) {
147 |
148 | // Iterate over returned tweets
149 | for ( i in tweets.results ) {
150 |
151 | // Cache tweet content
152 | var tweet = tweets.results[i],
153 | // Set a variable to determine weather replies are set to false, and if so, weather the tweet starts with a reply
154 | allowReply = !query.replies && tweet.to_user_id ? false : true,
155 | // Set a variable to determine weather retweets are set to false, and if so, weather the tweet starts with a retweet
156 | allowRetweet = !query.retweets && tweet.text.slice(0,2) === "RT" ? false : true;
157 |
158 | // Only proceed if allow reply is false
159 | if ( !allowReply ) {
160 | continue;
161 | }
162 |
163 | // Only proceed if allow retweet is false
164 | if ( !allowRetweet ) {
165 | continue;
166 | }
167 |
168 | // If exlusions set and none of the exlusions is found in the tweet then add it to the DOM
169 | if ( exclusionsExp && exclusionsExp.test(tweet.text) ) {
170 | continue;
171 | }
172 |
173 | // Create and cache new LI
174 | var $tweet = $("", {
175 | "class": "tweet"
176 | });
177 |
178 | // Make the avatar, and append it to the $tweet
179 | if ( query.avatar === true ) {
180 | $tweet.append($("", {
181 | href: "http://twitter.com/" + tweet.from_user,
182 | html: "
" + this.name; 120 | } 121 | 122 | if ( this.async ) { 123 | QUnit.stop(); 124 | } 125 | 126 | if ( config.notrycatch ) { 127 | this.callback.call( this.testEnvironment, QUnit.assert ); 128 | return; 129 | } 130 | 131 | try { 132 | this.callback.call( this.testEnvironment, QUnit.assert ); 133 | } catch( e ) { 134 | QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + ": " + e.message, extractStacktrace( e, 1 ) ); 135 | // else next test will carry the responsibility 136 | saveGlobal(); 137 | 138 | // Restart the tests if they're blocking 139 | if ( config.blocking ) { 140 | QUnit.start(); 141 | } 142 | } 143 | }, 144 | teardown: function() { 145 | config.current = this; 146 | if ( config.notrycatch ) { 147 | this.testEnvironment.teardown.call( this.testEnvironment ); 148 | return; 149 | } else { 150 | try { 151 | this.testEnvironment.teardown.call( this.testEnvironment ); 152 | } catch( e ) { 153 | QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + e.message, extractStacktrace( e, 1 ) ); 154 | } 155 | } 156 | checkPollution(); 157 | }, 158 | finish: function() { 159 | config.current = this; 160 | if ( this.expected != null && this.expected != this.assertions.length ) { 161 | QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack ); 162 | } else if ( this.expected == null && !this.assertions.length ) { 163 | QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack ); 164 | } 165 | 166 | var assertion, a, b, i, li, ol, 167 | test = this, 168 | good = 0, 169 | bad = 0, 170 | tests = id( "qunit-tests" ); 171 | 172 | config.stats.all += this.assertions.length; 173 | config.moduleStats.all += this.assertions.length; 174 | 175 | if ( tests ) { 176 | ol = document.createElement( "ol" ); 177 | 178 | for ( i = 0; i < this.assertions.length; i++ ) { 179 | assertion = this.assertions[i]; 180 | 181 | li = document.createElement( "li" ); 182 | li.className = assertion.result ? "pass" : "fail"; 183 | li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" ); 184 | ol.appendChild( li ); 185 | 186 | if ( assertion.result ) { 187 | good++; 188 | } else { 189 | bad++; 190 | config.stats.bad++; 191 | config.moduleStats.bad++; 192 | } 193 | } 194 | 195 | // store result when possible 196 | if ( QUnit.config.reorder && defined.sessionStorage ) { 197 | if ( bad ) { 198 | sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad ); 199 | } else { 200 | sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName ); 201 | } 202 | } 203 | 204 | if ( bad === 0 ) { 205 | ol.style.display = "none"; 206 | } 207 | 208 | // `b` initialized at top of scope 209 | b = document.createElement( "strong" ); 210 | b.innerHTML = this.name + " (" + bad + ", " + good + ", " + this.assertions.length + ")"; 211 | 212 | addEvent(b, "click", function() { 213 | var next = b.nextSibling.nextSibling, 214 | display = next.style.display; 215 | next.style.display = display === "none" ? "block" : "none"; 216 | }); 217 | 218 | addEvent(b, "dblclick", function( e ) { 219 | var target = e && e.target ? e.target : window.event.srcElement; 220 | if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) { 221 | target = target.parentNode; 222 | } 223 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) { 224 | window.location = QUnit.url({ testNumber: test.testNumber }); 225 | } 226 | }); 227 | 228 | // `li` initialized at top of scope 229 | li = id( this.id ); 230 | li.className = bad ? "fail" : "pass"; 231 | li.removeChild( li.firstChild ); 232 | a = li.firstChild; 233 | li.appendChild( b ); 234 | li.appendChild ( a ); 235 | li.appendChild( ol ); 236 | 237 | } else { 238 | for ( i = 0; i < this.assertions.length; i++ ) { 239 | if ( !this.assertions[i].result ) { 240 | bad++; 241 | config.stats.bad++; 242 | config.moduleStats.bad++; 243 | } 244 | } 245 | } 246 | 247 | runLoggingCallbacks( "testDone", QUnit, { 248 | name: this.testName, 249 | module: this.module, 250 | failed: bad, 251 | passed: this.assertions.length - bad, 252 | total: this.assertions.length 253 | }); 254 | 255 | QUnit.reset(); 256 | }, 257 | 258 | queue: function() { 259 | var bad, 260 | test = this; 261 | 262 | synchronize(function() { 263 | test.init(); 264 | }); 265 | function run() { 266 | // each of these can by async 267 | synchronize(function() { 268 | test.setup(); 269 | }); 270 | synchronize(function() { 271 | test.run(); 272 | }); 273 | synchronize(function() { 274 | test.teardown(); 275 | }); 276 | synchronize(function() { 277 | test.finish(); 278 | }); 279 | } 280 | 281 | // `bad` initialized at top of scope 282 | // defer when previous test run passed, if storage is available 283 | bad = QUnit.config.reorder && defined.sessionStorage && 284 | +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName ); 285 | 286 | if ( bad ) { 287 | run(); 288 | } else { 289 | synchronize( run, true ); 290 | } 291 | } 292 | }; 293 | 294 | // Root QUnit object. 295 | // `QUnit` initialized at top of scope 296 | QUnit = { 297 | 298 | // call on start of module test to prepend name to all tests 299 | module: function( name, testEnvironment ) { 300 | config.currentModule = name; 301 | config.currentModuleTestEnviroment = testEnvironment; 302 | }, 303 | 304 | asyncTest: function( testName, expected, callback ) { 305 | if ( arguments.length === 2 ) { 306 | callback = expected; 307 | expected = null; 308 | } 309 | 310 | QUnit.test( testName, expected, callback, true ); 311 | }, 312 | 313 | test: function( testName, expected, callback, async ) { 314 | var test, 315 | name = "" + escapeInnerText( testName ) + ""; 316 | 317 | if ( arguments.length === 2 ) { 318 | callback = expected; 319 | expected = null; 320 | } 321 | 322 | if ( config.currentModule ) { 323 | name = "" + config.currentModule + ": " + name; 324 | } 325 | 326 | test = new Test({ 327 | name: name, 328 | testName: testName, 329 | expected: expected, 330 | async: async, 331 | callback: callback, 332 | module: config.currentModule, 333 | moduleTestEnvironment: config.currentModuleTestEnviroment, 334 | stack: sourceFromStacktrace( 2 ) 335 | }); 336 | 337 | if ( !validTest( test ) ) { 338 | return; 339 | } 340 | 341 | test.queue(); 342 | }, 343 | 344 | // Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through. 345 | expect: function( asserts ) { 346 | config.current.expected = asserts; 347 | }, 348 | 349 | start: function( count ) { 350 | config.semaphore -= count || 1; 351 | // don't start until equal number of stop-calls 352 | if ( config.semaphore > 0 ) { 353 | return; 354 | } 355 | // ignore if start is called more often then stop 356 | if ( config.semaphore < 0 ) { 357 | config.semaphore = 0; 358 | } 359 | // A slight delay, to avoid any current callbacks 360 | if ( defined.setTimeout ) { 361 | window.setTimeout(function() { 362 | if ( config.semaphore > 0 ) { 363 | return; 364 | } 365 | if ( config.timeout ) { 366 | clearTimeout( config.timeout ); 367 | } 368 | 369 | config.blocking = false; 370 | process( true ); 371 | }, 13); 372 | } else { 373 | config.blocking = false; 374 | process( true ); 375 | } 376 | }, 377 | 378 | stop: function( count ) { 379 | config.semaphore += count || 1; 380 | config.blocking = true; 381 | 382 | if ( config.testTimeout && defined.setTimeout ) { 383 | clearTimeout( config.timeout ); 384 | config.timeout = window.setTimeout(function() { 385 | QUnit.ok( false, "Test timed out" ); 386 | config.semaphore = 1; 387 | QUnit.start(); 388 | }, config.testTimeout ); 389 | } 390 | } 391 | }; 392 | 393 | // Asssert helpers 394 | // All of these must call either QUnit.push() or manually do: 395 | // - runLoggingCallbacks( "log", .. ); 396 | // - config.current.assertions.push({ .. }); 397 | QUnit.assert = { 398 | /** 399 | * Asserts rough true-ish result. 400 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); 401 | */ 402 | ok: function( result, msg ) { 403 | if ( !config.current ) { 404 | throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) ); 405 | } 406 | result = !!result; 407 | 408 | var source, 409 | details = { 410 | result: result, 411 | message: msg 412 | }; 413 | 414 | msg = escapeInnerText( msg || (result ? "okay" : "failed" ) ); 415 | msg = ""; 416 | 417 | if ( !result ) { 418 | source = sourceFromStacktrace( 2 ); 419 | if ( source ) { 420 | details.source = source; 421 | msg += "
| Source: | " + escapeInnerText( source ) + " |
|---|
" + escapeInnerText( document.title ) + "
" + 615 | "" + 616 | "" + 617 | "" + 618 | ""; 643 | } 644 | }, 645 | 646 | // Resets the test setup. Useful for tests that modify the DOM. 647 | // If jQuery is available, uses jQuery's html(), otherwise just innerHTML. 648 | reset: function() { 649 | var fixture; 650 | 651 | if ( window.jQuery ) { 652 | jQuery( "#qunit-fixture" ).html( config.fixture ); 653 | } else { 654 | fixture = id( "qunit-fixture" ); 655 | if ( fixture ) { 656 | fixture.innerHTML = config.fixture; 657 | } 658 | } 659 | }, 660 | 661 | // Trigger an event on an element. 662 | // @example triggerEvent( document.body, "click" ); 663 | triggerEvent: function( elem, type, event ) { 664 | if ( document.createEvent ) { 665 | event = document.createEvent( "MouseEvents" ); 666 | event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView, 667 | 0, 0, 0, 0, 0, false, false, false, false, 0, null); 668 | 669 | elem.dispatchEvent( event ); 670 | } else if ( elem.fireEvent ) { 671 | elem.fireEvent( "on" + type ); 672 | } 673 | }, 674 | 675 | // Safe object type checking 676 | is: function( type, obj ) { 677 | return QUnit.objectType( obj ) == type; 678 | }, 679 | 680 | objectType: function( obj ) { 681 | if ( typeof obj === "undefined" ) { 682 | return "undefined"; 683 | // consider: typeof null === object 684 | } 685 | if ( obj === null ) { 686 | return "null"; 687 | } 688 | 689 | var type = toString.call( obj ).match(/^\[object\s(.*)\]$/)[1] || ""; 690 | 691 | switch ( type ) { 692 | case "Number": 693 | if ( isNaN(obj) ) { 694 | return "nan"; 695 | } 696 | return "number"; 697 | case "String": 698 | case "Boolean": 699 | case "Array": 700 | case "Date": 701 | case "RegExp": 702 | case "Function": 703 | return type.toLowerCase(); 704 | } 705 | if ( typeof obj === "object" ) { 706 | return "object"; 707 | } 708 | return undefined; 709 | }, 710 | 711 | push: function( result, actual, expected, message ) { 712 | if ( !config.current ) { 713 | throw new Error( "assertion outside test context, was " + sourceFromStacktrace() ); 714 | } 715 | 716 | var output, source, 717 | details = { 718 | result: result, 719 | message: message, 720 | actual: actual, 721 | expected: expected 722 | }; 723 | 724 | message = escapeInnerText( message ) || ( result ? "okay" : "failed" ); 725 | message = ""; 726 | output = message; 727 | 728 | if ( !result ) { 729 | expected = escapeInnerText( QUnit.jsDump.parse(expected) ); 730 | actual = escapeInnerText( QUnit.jsDump.parse(actual) ); 731 | output += "
| Expected: | " + expected + " |
|---|---|
| Result: | " + actual + " |
| Diff: | " + QUnit.diff( expected, actual ) + " |
| Source: | " + escapeInnerText( source ) + " |
| Source: | " + escapeInnerText( source ) + " |
|---|
", 963 | "", 964 | passed, 965 | " tests of ", 966 | config.stats.all, 967 | " passed, ", 968 | config.stats.bad, 969 | " failed." 970 | ].join( "" ); 971 | 972 | if ( banner ) { 973 | banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" ); 974 | } 975 | 976 | if ( tests ) { 977 | id( "qunit-testresult" ).innerHTML = html; 978 | } 979 | 980 | if ( config.altertitle && typeof document !== "undefined" && document.title ) { 981 | // show ✖ for good, ✔ for bad suite result in title 982 | // use escape sequences in case file gets loaded with non-utf-8-charset 983 | document.title = [ 984 | ( config.stats.bad ? "\u2716" : "\u2714" ), 985 | document.title.replace( /^[\u2714\u2716] /i, "" ) 986 | ].join( " " ); 987 | } 988 | 989 | // clear own sessionStorage items if all tests passed 990 | if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) { 991 | // `key` & `i` initialized at top of scope 992 | for ( i = 0; i < sessionStorage.length; i++ ) { 993 | key = sessionStorage.key( i++ ); 994 | if ( key.indexOf( "qunit-test-" ) === 0 ) { 995 | sessionStorage.removeItem( key ); 996 | } 997 | } 998 | } 999 | 1000 | runLoggingCallbacks( "done", QUnit, { 1001 | failed: config.stats.bad, 1002 | passed: passed, 1003 | total: config.stats.all, 1004 | runtime: runtime 1005 | }); 1006 | } 1007 | 1008 | function validTest( test ) { 1009 | var include, 1010 | filter = config.filter, 1011 | fullName = test.module + ": " + test.testName; 1012 | 1013 | if ( config.testNumber ) { 1014 | return test.testNumber === config.testNumber; 1015 | } 1016 | 1017 | if ( !filter ) { 1018 | return true; 1019 | } 1020 | 1021 | include = filter.charAt( 0 ) !== "!"; 1022 | if ( !include ) { 1023 | filter = filter.slice( 1 ); 1024 | } 1025 | 1026 | // If the filter matches, we need to honour include 1027 | if ( fullName.indexOf( filter ) !== -1 ) { 1028 | return include; 1029 | } 1030 | 1031 | // Otherwise, do the opposite 1032 | return !include; 1033 | } 1034 | 1035 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions) 1036 | // Later Safari and IE10 are supposed to support error.stack as well 1037 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack 1038 | function extractStacktrace( e, offset ) { 1039 | offset = offset || 3; 1040 | 1041 | var stack; 1042 | 1043 | if ( e.stacktrace ) { 1044 | // Opera 1045 | return e.stacktrace.split( "\n" )[ offset + 3 ]; 1046 | } else if ( e.stack ) { 1047 | // Firefox, Chrome 1048 | stack = e.stack.split( "\n" ); 1049 | if (/^error$/i.test( stack[0] ) ) { 1050 | stack.shift(); 1051 | } 1052 | return stack[ offset ]; 1053 | } else if ( e.sourceURL ) { 1054 | // Safari, PhantomJS 1055 | // hopefully one day Safari provides actual stacktraces 1056 | // exclude useless self-reference for generated Error objects 1057 | if ( /qunit.js$/.test( e.sourceURL ) ) { 1058 | return; 1059 | } 1060 | // for actual exceptions, this is useful 1061 | return e.sourceURL + ":" + e.line; 1062 | } 1063 | } 1064 | function sourceFromStacktrace( offset ) { 1065 | try { 1066 | throw new Error(); 1067 | } catch ( e ) { 1068 | return extractStacktrace( e, offset ); 1069 | } 1070 | } 1071 | 1072 | function escapeInnerText( s ) { 1073 | if ( !s ) { 1074 | return ""; 1075 | } 1076 | s = s + ""; 1077 | return s.replace( /[\&<>]/g, function( s ) { 1078 | switch( s ) { 1079 | case "&": return "&"; 1080 | case "<": return "<"; 1081 | case ">": return ">"; 1082 | default: return s; 1083 | } 1084 | }); 1085 | } 1086 | 1087 | function synchronize( callback, last ) { 1088 | config.queue.push( callback ); 1089 | 1090 | if ( config.autorun && !config.blocking ) { 1091 | process( last ); 1092 | } 1093 | } 1094 | 1095 | function process( last ) { 1096 | function next() { 1097 | process( last ); 1098 | } 1099 | var start = new Date().getTime(); 1100 | config.depth = config.depth ? config.depth + 1 : 1; 1101 | 1102 | while ( config.queue.length && !config.blocking ) { 1103 | if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) { 1104 | config.queue.shift()(); 1105 | } else { 1106 | window.setTimeout( next, 13 ); 1107 | break; 1108 | } 1109 | } 1110 | config.depth--; 1111 | if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) { 1112 | done(); 1113 | } 1114 | } 1115 | 1116 | function saveGlobal() { 1117 | config.pollution = []; 1118 | 1119 | if ( config.noglobals ) { 1120 | for ( var key in window ) { 1121 | // in Opera sometimes DOM element ids show up here, ignore them 1122 | if ( !hasOwn.call( window, key ) || /^qunit-test-output/.test( key ) ) { 1123 | continue; 1124 | } 1125 | config.pollution.push( key ); 1126 | } 1127 | } 1128 | } 1129 | 1130 | function checkPollution( name ) { 1131 | var newGlobals, 1132 | deletedGlobals, 1133 | old = config.pollution; 1134 | 1135 | saveGlobal(); 1136 | 1137 | newGlobals = diff( config.pollution, old ); 1138 | if ( newGlobals.length > 0 ) { 1139 | QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") ); 1140 | } 1141 | 1142 | deletedGlobals = diff( old, config.pollution ); 1143 | if ( deletedGlobals.length > 0 ) { 1144 | QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") ); 1145 | } 1146 | } 1147 | 1148 | // returns a new Array with the elements that are in a but not in b 1149 | function diff( a, b ) { 1150 | var i, j, 1151 | result = a.slice(); 1152 | 1153 | for ( i = 0; i < result.length; i++ ) { 1154 | for ( j = 0; j < b.length; j++ ) { 1155 | if ( result[i] === b[j] ) { 1156 | result.splice( i, 1 ); 1157 | i--; 1158 | break; 1159 | } 1160 | } 1161 | } 1162 | return result; 1163 | } 1164 | 1165 | function extend( a, b ) { 1166 | for ( var prop in b ) { 1167 | if ( b[ prop ] === undefined ) { 1168 | delete a[ prop ]; 1169 | 1170 | // Avoid "Member not found" error in IE8 caused by setting window.constructor 1171 | } else if ( prop !== "constructor" || a !== window ) { 1172 | a[ prop ] = b[ prop ]; 1173 | } 1174 | } 1175 | 1176 | return a; 1177 | } 1178 | 1179 | function addEvent( elem, type, fn ) { 1180 | if ( elem.addEventListener ) { 1181 | elem.addEventListener( type, fn, false ); 1182 | } else if ( elem.attachEvent ) { 1183 | elem.attachEvent( "on" + type, fn ); 1184 | } else { 1185 | fn(); 1186 | } 1187 | } 1188 | 1189 | function id( name ) { 1190 | return !!( typeof document !== "undefined" && document && document.getElementById ) && 1191 | document.getElementById( name ); 1192 | } 1193 | 1194 | function registerLoggingCallback( key ) { 1195 | return function( callback ) { 1196 | config[key].push( callback ); 1197 | }; 1198 | } 1199 | 1200 | // Supports deprecated method of completely overwriting logging callbacks 1201 | function runLoggingCallbacks( key, scope, args ) { 1202 | //debugger; 1203 | var i, callbacks; 1204 | if ( QUnit.hasOwnProperty( key ) ) { 1205 | QUnit[ key ].call(scope, args ); 1206 | } else { 1207 | callbacks = config[ key ]; 1208 | for ( i = 0; i < callbacks.length; i++ ) { 1209 | callbacks[ i ].call( scope, args ); 1210 | } 1211 | } 1212 | } 1213 | 1214 | // Test for equality any JavaScript type. 1215 | // Author: Philippe Rathé
" : "\n" : this.HTML ? " " : " "; 1492 | }, 1493 | indent: function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing 1494 | if ( !this.multiline ) { 1495 | return ""; 1496 | } 1497 | var chr = this.indentChar; 1498 | if ( this.HTML ) { 1499 | chr = chr.replace( /\t/g, " " ).replace( / /g, " " ); 1500 | } 1501 | return new Array( this._depth_ + (extra||0) ).join(chr); 1502 | }, 1503 | up: function( a ) { 1504 | this._depth_ += a || 1; 1505 | }, 1506 | down: function( a ) { 1507 | this._depth_ -= a || 1; 1508 | }, 1509 | setParser: function( name, parser ) { 1510 | this.parsers[name] = parser; 1511 | }, 1512 | // The next 3 are exposed so you can use them 1513 | quote: quote, 1514 | literal: literal, 1515 | join: join, 1516 | // 1517 | _depth_: 1, 1518 | // This is the list of parsers, to modify them, use jsDump.setParser 1519 | parsers: { 1520 | window: "[Window]", 1521 | document: "[Document]", 1522 | error: "[ERROR]", //when no parser is found, shouldn"t happen 1523 | unknown: "[Unknown]", 1524 | "null": "null", 1525 | "undefined": "undefined", 1526 | "function": function( fn ) { 1527 | var ret = "function", 1528 | name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];//functions never have name in IE 1529 | 1530 | if ( name ) { 1531 | ret += " " + name; 1532 | } 1533 | ret += "( "; 1534 | 1535 | ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" ); 1536 | return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" ); 1537 | }, 1538 | array: array, 1539 | nodelist: array, 1540 | "arguments": array, 1541 | object: function( map, stack ) { 1542 | var ret = [ ], keys, key, val, i; 1543 | QUnit.jsDump.up(); 1544 | if ( Object.keys ) { 1545 | keys = Object.keys( map ); 1546 | } else { 1547 | keys = []; 1548 | for ( key in map ) { 1549 | keys.push( key ); 1550 | } 1551 | } 1552 | keys.sort(); 1553 | for ( i = 0; i < keys.length; i++ ) { 1554 | key = keys[ i ]; 1555 | val = map[ key ]; 1556 | ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) ); 1557 | } 1558 | QUnit.jsDump.down(); 1559 | return join( "{", ret, "}" ); 1560 | }, 1561 | node: function( node ) { 1562 | var a, val, 1563 | open = QUnit.jsDump.HTML ? "<" : "<", 1564 | close = QUnit.jsDump.HTML ? ">" : ">", 1565 | tag = node.nodeName.toLowerCase(), 1566 | ret = open + tag; 1567 | 1568 | for ( a in QUnit.jsDump.DOMAttrs ) { 1569 | val = node[ QUnit.jsDump.DOMAttrs[a] ]; 1570 | if ( val ) { 1571 | ret += " " + a + "=" + QUnit.jsDump.parse( val, "attribute" ); 1572 | } 1573 | } 1574 | return ret + close + open + "/" + tag + close; 1575 | }, 1576 | functionArgs: function( fn ) {//function calls it internally, it's the arguments part of the function 1577 | var args, 1578 | l = fn.length; 1579 | 1580 | if ( !l ) { 1581 | return ""; 1582 | } 1583 | 1584 | args = new Array(l); 1585 | while ( l-- ) { 1586 | args[l] = String.fromCharCode(97+l);//97 is 'a' 1587 | } 1588 | return " " + args.join( ", " ) + " "; 1589 | }, 1590 | key: quote, //object calls it internally, the key part of an item in a map 1591 | functionCode: "[code]", //function calls it internally, it's the content of the function 1592 | attribute: quote, //node calls it internally, it's an html attribute value 1593 | string: quote, 1594 | date: quote, 1595 | regexp: literal, //regex 1596 | number: literal, 1597 | "boolean": literal 1598 | }, 1599 | DOMAttrs: { 1600 | //attributes to dump from nodes, name=>realName 1601 | id: "id", 1602 | name: "name", 1603 | "class": "className" 1604 | }, 1605 | HTML: false,//if true, entities are escaped ( <, >, \t, space and \n ) 1606 | indentChar: " ",//indentation unit 1607 | multiline: true //if true, items in a collection, are separated by a \n, else just a space. 1608 | }; 1609 | 1610 | return jsDump; 1611 | }()); 1612 | 1613 | // from Sizzle.js 1614 | function getText( elems ) { 1615 | var i, elem, 1616 | ret = ""; 1617 | 1618 | for ( i = 0; elems[i]; i++ ) { 1619 | elem = elems[i]; 1620 | 1621 | // Get the text from text nodes and CDATA nodes 1622 | if ( elem.nodeType === 3 || elem.nodeType === 4 ) { 1623 | ret += elem.nodeValue; 1624 | 1625 | // Traverse everything else, except comment nodes 1626 | } else if ( elem.nodeType !== 8 ) { 1627 | ret += getText( elem.childNodes ); 1628 | } 1629 | } 1630 | 1631 | return ret; 1632 | } 1633 | 1634 | // from jquery.js 1635 | function inArray( elem, array ) { 1636 | if ( array.indexOf ) { 1637 | return array.indexOf( elem ); 1638 | } 1639 | 1640 | for ( var i = 0, length = array.length; i < length; i++ ) { 1641 | if ( array[ i ] === elem ) { 1642 | return i; 1643 | } 1644 | } 1645 | 1646 | return -1; 1647 | } 1648 | 1649 | /* 1650 | * Javascript Diff Algorithm 1651 | * By John Resig (http://ejohn.org/) 1652 | * Modified by Chu Alan "sprite" 1653 | * 1654 | * Released under the MIT license. 1655 | * 1656 | * More Info: 1657 | * http://ejohn.org/projects/javascript-diff-algorithm/ 1658 | * 1659 | * Usage: QUnit.diff(expected, actual) 1660 | * 1661 | * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the quick