├── README ├── test ├── data │ ├── invalid.js │ ├── valid.js │ ├── valid_batch.js │ └── invalid_batch.js ├── index.html ├── qunit.css ├── tests.js └── qunit.js ├── bower.json ├── server.js ├── UNLICENSE ├── README.md └── jquery.jsonrpc.js /README: -------------------------------------------------------------------------------- 1 | README.md 2 | -------------------------------------------------------------------------------- /test/data/invalid.js: -------------------------------------------------------------------------------- 1 | {"jsonrpc": "1.0","result":[],"error":null} 2 | -------------------------------------------------------------------------------- /test/data/valid.js: -------------------------------------------------------------------------------- 1 | {"jsonrpc": "2.0","result":[],"error":null} 2 | -------------------------------------------------------------------------------- /test/data/valid_batch.js: -------------------------------------------------------------------------------- 1 | {"jsonrpc": "2.0","result":[],"error":null} 2 | -------------------------------------------------------------------------------- /test/data/invalid_batch.js: -------------------------------------------------------------------------------- 1 | {"jsonrpc": "1.0","result":[],"error":null} 2 | -------------------------------------------------------------------------------- /bower.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jquery-jsonrpc", 3 | "version": "0.1.1", 4 | "homepage": "https://github.com/datagraph/jquery-jsonrpc", 5 | "description": "A JSON RPC 2.0 client for jQuery", 6 | "main": "jquery.jsonrpc.js", 7 | "moduleType": [ 8 | "globals" 9 | ], 10 | "keywords": [ 11 | "jquery", 12 | "jsonrpc" 13 | ], 14 | "license": "Unlicense", 15 | "dependencies": { 16 | "jquery": ">=1.4" 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /server.js: -------------------------------------------------------------------------------- 1 | var express = require('express'), 2 | app = express(); 3 | 4 | app.use(express.static(__dirname)); 5 | 6 | app.post('/test/data/valid.js', function(req, res) { 7 | res.sendfile('test/data/valid.js') 8 | }); 9 | 10 | app.post('/test/data/valid_batch.js', function(req, res) { 11 | res.sendfile('test/data/valid_batch.js') 12 | }); 13 | 14 | app.post('/test/data/invalid.js', function(req, res) { 15 | res.sendfile('test/data/invalid.js') 16 | }); 17 | 18 | app.listen(3000); 19 | -------------------------------------------------------------------------------- /test/index.html: -------------------------------------------------------------------------------- 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |

jQuery JSON RPC 2.0 plugin specs

13 | 14 |

15 |

16 |

17 | 18 | 19 | -------------------------------------------------------------------------------- /UNLICENSE: -------------------------------------------------------------------------------- 1 | This is free and unencumbered software released into the public domain. 2 | 3 | Anyone is free to copy, modify, publish, use, compile, sell, or 4 | distribute this software, either in source code form or as a compiled 5 | binary, for any purpose, commercial or non-commercial, and by any 6 | means. 7 | 8 | In jurisdictions that recognize copyright laws, the author or authors 9 | of this software dedicate any and all copyright interest in the 10 | software to the public domain. We make this dedication for the benefit 11 | of the public at large and to the detriment of our heirs and 12 | successors. We intend this dedication to be an overt act of 13 | relinquishment in perpetuity of all present and future rights to this 14 | software under copyright law. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | 24 | For more information, please refer to 25 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # JSON RPC 2.0 jQuery Plugin 2 | 3 | A [JSON RPC 2.0](http://groups.google.com/group/json-rpc/web/json-rpc-2-0) compatible client library and jQuery (1.4, 1.5, and 1.6 compatible) plugin. 4 | 5 | ## First, a quick compatibility note 6 | 7 | If you need to support IE6 & IE7, you will need to include Douglas Crockford's [JSON](https://github.com/douglascrockford/JSON-js) library in order for this plugin to work. The specific file you need from that repository is json2.js. 8 | 9 | ## Getting Started 10 | 11 | The simplest way to configure jsonRPC is via the setup method 12 | 13 | $.jsonRPC.setup({ 14 | endPoint: '/rpc', 15 | namespace: 'datagraph' 16 | }); 17 | 18 | This will set a default endpoint and namespace for all subsequent requests. 19 | 20 | Once you've configured an end point, making requests is a matter of 21 | 22 | $.jsonRPC.request('method.name', { 23 | params: params, 24 | success: function(result) { 25 | // Do something with the result here 26 | // It comes back as an RPC 2.0 compatible response object 27 | }, 28 | error: function(result) { 29 | // Result is an RPC 2.0 compatible response object 30 | } 31 | }); 32 | 33 | Want to do batch requests? We've got you covered 34 | 35 | $.jsonRPC.batchRequest([ 36 | { 37 | method: 'method.one', 38 | params: [1,2,3] 39 | }, 40 | { 41 | method: 'method.two' 42 | } 43 | ], { 44 | success: function(result) { 45 | // Handle response object here 46 | } 47 | } 48 | }); 49 | 50 | Need to temporarily override your end point or namespace? Easy enough... 51 | 52 | $.jsonRPC.withOptions({ 53 | endPoint: '/anotherRpc', 54 | namespace: 'somethingElse' 55 | }, function() { 56 | this.request('method.name'); 57 | }); 58 | 59 | After your call, your endPoint and namespace are back to their defaults. Or you can override the end point for a single request via 60 | 61 | $.jsonRPC.request('method.name', { 62 | params: [1,2,3], 63 | endPoint: '/anotherEndPoint' 64 | }); 65 | 66 | ## Running the tests 67 | 68 | The tests currently rely on being able to successfully make local AJAX calls to load test data. This works fine in Firefox (3.6, 4, and 5), but WebKit (Chrome and Safari) does not allow file-based AJAX calls. To successfully run tests in Safari or Chrome, you will need to serve the tests from a proper web server like Apache or Nginx. The tests have been verified against jQuery 1.4, 1.5, and 1.6. 69 | 70 | ## Authors, License, Development, Thanks 71 | 72 | #### Authors 73 | * Josh Huckabee 74 | * Chris Petersen 75 | * Jerry Ablan 76 | 77 | #### 'License' 78 | This plugin is free and unemcumbered software released into the public 79 | domain. For more information, see the included UNLICENSE file. 80 | 81 | #### Development / Contributing 82 | Fork it on Github and go. Please make sure you're kosher with the UNLICENSE 83 | file before contributing. 84 | 85 | Add your tests (see test directory), make sure they all pass, and submit 86 | a pull request. 87 | 88 | #### Thanks 89 | Inspiration for this plugin came from (and is partly based on) the following existing plugins: 90 | 91 | * [http://plugins.jquery.com/project/C4PCJsonRPC](http://plugins.jquery.com/project/C4PCJsonRPC) via [safchain](http://plugins.jquery.com/users/safchain) 92 | * [http://plugins.jquery.com/project/jsonRPC2](http://plugins.jquery.com/project/jsonRPC2) via [kusmierz](http://plugins.jquery.com/user/30124) 93 | -------------------------------------------------------------------------------- /test/qunit.css: -------------------------------------------------------------------------------- 1 | /** Font Family and Sizes */ 2 | 3 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult { 4 | font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial; 5 | } 6 | 7 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; } 8 | #qunit-tests { font-size: smaller; } 9 | 10 | 11 | /** Resets */ 12 | 13 | #qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult { 14 | margin: 0; 15 | padding: 0; 16 | } 17 | 18 | 19 | /** Header */ 20 | 21 | #qunit-header { 22 | padding: 0.5em 0 0.5em 1em; 23 | 24 | color: #fff; 25 | text-shadow: rgba(0, 0, 0, 0.5) 4px 4px 1px; 26 | background-color: #0d3349; 27 | 28 | border-radius: 15px 15px 0 0; 29 | -moz-border-radius: 15px 15px 0 0; 30 | -webkit-border-top-right-radius: 15px; 31 | -webkit-border-top-left-radius: 15px; 32 | } 33 | 34 | #qunit-header a { 35 | text-decoration: none; 36 | color: white; 37 | } 38 | 39 | #qunit-banner { 40 | height: 5px; 41 | } 42 | 43 | #qunit-testrunner-toolbar { 44 | padding: 0em 0 0.5em 2em; 45 | } 46 | 47 | #qunit-userAgent { 48 | padding: 0.5em 0 0.5em 2.5em; 49 | background-color: #2b81af; 50 | color: #fff; 51 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; 52 | } 53 | 54 | 55 | /** Tests: Pass/Fail */ 56 | 57 | #qunit-tests { 58 | list-style-position: inside; 59 | } 60 | 61 | #qunit-tests li { 62 | padding: 0.4em 0.5em 0.4em 2.5em; 63 | border-bottom: 1px solid #fff; 64 | list-style-position: inside; 65 | } 66 | 67 | #qunit-tests li strong { 68 | cursor: pointer; 69 | } 70 | 71 | #qunit-tests ol { 72 | margin-top: 0.5em; 73 | padding: 0.5em; 74 | 75 | background-color: #fff; 76 | 77 | border-radius: 15px; 78 | -moz-border-radius: 15px; 79 | -webkit-border-radius: 15px; 80 | 81 | box-shadow: inset 0px 2px 13px #999; 82 | -moz-box-shadow: inset 0px 2px 13px #999; 83 | -webkit-box-shadow: inset 0px 2px 13px #999; 84 | } 85 | 86 | /*** Test Counts */ 87 | 88 | #qunit-tests b.counts { color: black; } 89 | #qunit-tests b.passed { color: #5E740B; } 90 | #qunit-tests b.failed { color: #710909; } 91 | 92 | #qunit-tests li li { 93 | margin: 0.5em; 94 | padding: 0.4em 0.5em 0.4em 0.5em; 95 | background-color: #fff; 96 | border-bottom: none; 97 | list-style-position: inside; 98 | } 99 | 100 | /*** Passing Styles */ 101 | 102 | #qunit-tests li li.pass { 103 | color: #5E740B; 104 | background-color: #fff; 105 | border-left: 26px solid #C6E746; 106 | } 107 | 108 | #qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; } 109 | #qunit-tests .pass .test-name { color: #366097; } 110 | 111 | #qunit-tests .pass .test-actual, 112 | #qunit-tests .pass .test-expected { color: #999999; } 113 | 114 | #qunit-banner.qunit-pass { background-color: #C6E746; } 115 | 116 | /*** Failing Styles */ 117 | 118 | #qunit-tests li li.fail { 119 | color: #710909; 120 | background-color: #fff; 121 | border-left: 26px solid #EE5757; 122 | } 123 | 124 | #qunit-tests .fail { color: #000000; background-color: #EE5757; } 125 | #qunit-tests .fail .test-name, 126 | #qunit-tests .fail .module-name { color: #000000; } 127 | 128 | #qunit-tests .fail .test-actual { color: #EE5757; } 129 | #qunit-tests .fail .test-expected { color: green; } 130 | 131 | #qunit-banner.qunit-fail, 132 | #qunit-testrunner-toolbar { background-color: #EE5757; } 133 | 134 | 135 | /** Footer */ 136 | 137 | #qunit-testresult { 138 | padding: 0.5em 0.5em 0.5em 2.5em; 139 | 140 | color: #2b81af; 141 | background-color: #D2E0E6; 142 | 143 | border-radius: 0 0 15px 15px; 144 | -moz-border-radius: 0 0 15px 15px; 145 | -webkit-border-bottom-right-radius: 15px; 146 | -webkit-border-bottom-left-radius: 15px; 147 | } 148 | 149 | /** Fixture */ 150 | 151 | #qunit-fixture { 152 | position: absolute; 153 | top: -10000px; 154 | left: -10000px; 155 | } 156 | -------------------------------------------------------------------------------- /test/tests.js: -------------------------------------------------------------------------------- 1 | $(document).ready(function(){ 2 | 3 | module("parameter validation"); 4 | 5 | test("when empty", function() { 6 | var errMsg = ''; 7 | try { 8 | $.jsonRPC.setup(); 9 | } 10 | catch(e) { 11 | errMsg = e; 12 | } 13 | equal(errMsg, "No params specified", "Should raise error about no params being specified"); 14 | }); 15 | 16 | test("with invalid endpoint", function() { 17 | var errMsg = ''; 18 | try { 19 | $.jsonRPC.setup({endPoint: []}); 20 | } 21 | catch(e) { 22 | errMsg = e; 23 | } 24 | equal(errMsg, "endPoint must be a string", "Should raise an error about endPoint not being a string"); 25 | }); 26 | 27 | test("with invalid namespace", function() { 28 | var errMsg = ''; 29 | try { 30 | $.jsonRPC.setup({namespace: []}); 31 | } 32 | catch(e) { 33 | errMsg = e; 34 | } 35 | equal(errMsg, "namespace must be a string", "Should raise an error about namespace not being a string"); 36 | }); 37 | 38 | module("setup"); 39 | 40 | test("with no args", function() { 41 | var errMsg = false; 42 | try { 43 | $.jsonRPC.setup(); 44 | } 45 | catch(e) { 46 | errMsg = e; 47 | } 48 | ok(errMsg, "should raise an error"); 49 | }); 50 | 51 | test("with a valid params hash", function() { 52 | var rpc = $.jsonRPC.setup({endPoint: '/rpc', namespace: 'datagraph'}); 53 | equal('/rpc', rpc.endPoint, "Should set the endPoint"); 54 | equal('datagraph', rpc.namespace, "Should set the namespace"); 55 | }); 56 | 57 | module("withOptions"); 58 | 59 | test("with no callback", function() { 60 | var errMsg = false; 61 | try { 62 | $.jsonRPC.withOptions({namespace:"test"}); 63 | } 64 | catch(e) { 65 | errMsg = e; 66 | } 67 | ok(errMsg, "should raise an error"); 68 | }); 69 | 70 | test("with a callback and namespace param set", function() { 71 | $.jsonRPC.namespace = 'test'; 72 | $.jsonRPC.withOptions({namespace:"testWithOptions"}, function() { 73 | equal('testWithOptions', this.namespace, "should temporarily set namespace"); 74 | }); 75 | equal('test', $.jsonRPC.namespace, "should set namespace back after execution"); 76 | }); 77 | 78 | test("with a callback and endPoint param set", function() { 79 | $.jsonRPC.endPoint = '/test'; 80 | $.jsonRPC.withOptions({endPoint:"/testWithOptions"}, function() { 81 | equal('/testWithOptions', this.endPoint, "should temporarily set endPoint"); 82 | }); 83 | equal('/test', $.jsonRPC.endPoint, "should set endPoint back after execution"); 84 | }); 85 | 86 | test("with callback, namespace and endPoint params set", function() { 87 | $.jsonRPC.namespace = 'test'; 88 | $.jsonRPC.endPoint = '/test'; 89 | $.jsonRPC.withOptions({namespace: "testWithOptions", endPoint:"/testWithOptions"}, function() { 90 | equal('testWithOptions', this.namespace, "should temporarily set namespace"); 91 | equal('/testWithOptions', this.endPoint, "should temporarily set endPoint"); 92 | }); 93 | equal('test', $.jsonRPC.namespace, "should set namespace back after execution"); 94 | equal('/test', $.jsonRPC.endPoint, "should set endPoint back after execution"); 95 | }); 96 | 97 | module("request") 98 | 99 | test("without a method", function() { 100 | var errMsg = false; 101 | try { 102 | $.jsonRPC.request(); 103 | } 104 | catch(e) { 105 | errMsg = e; 106 | } 107 | ok(errMsg, "should raise an error"); 108 | }); 109 | 110 | test("with an invalid method", function() { 111 | expect(3); 112 | var params = [[], {}, function(){}], 113 | errMsg; 114 | $.each(params, function(i, param) { 115 | errMsg = false; 116 | try { 117 | $.jsonRPC.request([]); 118 | } 119 | catch(e) { 120 | errMsg = e; 121 | } 122 | ok(errMsg, "should raise an error"); 123 | }); 124 | }); 125 | 126 | test("with a valid method and invalid params", function() { 127 | var errMsg = false; 128 | try { 129 | $.jsonRPC.request('test', {params: ''}); 130 | } 131 | catch(e) { 132 | errMsg = e; 133 | } 134 | ok(errMsg, "should raise an error"); 135 | }); 136 | 137 | test("with a valid method, no params, and no callbacks", function() { 138 | stop(); 139 | $.jsonRPC.endPoint = 'data/valid.js' 140 | ok($.jsonRPC.request('test')); 141 | start(); 142 | }); 143 | 144 | test("with a valid method and param and no callbacks", function() { 145 | stop(); 146 | $.jsonRPC.endPoint = 'data/valid.js' 147 | ok($.jsonRPC.request('test'), {params: []}); 148 | ok($.jsonRPC.request('test'), {params: {}}); 149 | ok($.jsonRPC.request('test'), {params: null}); 150 | start(); 151 | }); 152 | 153 | test("with a valid method, no params, and invalid callbacks", function() { 154 | expect(6); 155 | 156 | var callbacks = [null, '', []], 157 | errMsg; 158 | 159 | $.each(callbacks, function(i, callbackFunction) { 160 | errMsg = false; 161 | try { 162 | $.jsonRPC.request('test', {error:callbackFunction}); 163 | } 164 | catch(e) { 165 | errMsg = e; 166 | } 167 | ok(errMsg, "should raise an error"); 168 | }); 169 | $.each(callbacks, function(i, callbackFunction) { 170 | errMsg = false; 171 | try { 172 | $.jsonRPC.request('test', {success:callbackFunction}); 173 | } 174 | catch(e) { 175 | errMsg = e; 176 | } 177 | ok(errMsg, "should raise an error"); 178 | }); 179 | }); 180 | 181 | test("with a valid method, no params, and valid callbacks on success", function() { 182 | expect(1); 183 | stop(); 184 | $.jsonRPC.endPoint = 'data/valid.js' 185 | $.jsonRPC.request('test', { 186 | error: function(json) { 187 | ok(false, "should not execute this"); 188 | start(); 189 | }, 190 | success: function(json) { 191 | ok(json, "should execute success callback"); 192 | start(); 193 | } 194 | }); 195 | }); 196 | 197 | test("with a valid method, no params, and valid callbacks on error", function() { 198 | expect(1); 199 | stop(); 200 | $.jsonRPC.endPoint = 'data/invalid.js' 201 | $.jsonRPC.request('test', { 202 | error: function(json) { 203 | ok(json, "should execute error callback"); 204 | start(); 205 | }, 206 | success: function(json) { 207 | ok(false, "should not execute success callback"); 208 | start(); 209 | } 210 | }); 211 | }); 212 | 213 | test("with a valid method, valid params, valid callbacks, and an overriden url", function() { 214 | expect(1); 215 | stop(); 216 | $.jsonRPC.endPoint = 'data/invalid.js' 217 | $.jsonRPC.request('test', { 218 | params: ['param'], 219 | url: 'data/valid.js', 220 | error: function(json) { 221 | ok(false, "should not execute error callback"); 222 | start(); 223 | }, 224 | success: function(json) { 225 | ok(true, "should execute success callback"); 226 | start(); 227 | } 228 | }); 229 | 230 | }); 231 | 232 | test("with a valid method, valid params, valid callbacks, and an overriden url specified as 'endPoint'", function() { 233 | expect(1); 234 | stop(); 235 | $.jsonRPC.endPoint = 'data/invalid.js' 236 | $.jsonRPC.request('test', { 237 | params: ['param'], 238 | endPoint: 'data/valid.js', 239 | error: function(json) { 240 | ok(false, "should not execute error callback"); 241 | start(); 242 | }, 243 | success: function(json) { 244 | ok(true, "should execute success callback"); 245 | start(); 246 | } 247 | }); 248 | 249 | }); 250 | 251 | module("batchRequest"); 252 | 253 | test("with invalid requests object", function() { 254 | expect(7); 255 | var requests = [ 256 | 'some string', 257 | function(){}, 258 | {}, 259 | [], 260 | [1], 261 | [{method:null}], 262 | [{method:'test', params:''}], 263 | ], 264 | errMsg; 265 | 266 | $.each(requests, function(i, request) { 267 | errMsg = false; 268 | try { 269 | $.jsonRPC.batchRequest(request); 270 | } 271 | catch(e) { 272 | errMsg = e; 273 | } 274 | ok(errMsg, "should raise an error"); 275 | }); 276 | }); 277 | 278 | test("with a valid method, valid params, valid callbacks, and an overriden url", function() { 279 | expect(1); 280 | stop(); 281 | $.jsonRPC.endPoint = 'data/invalid_batch.js' 282 | $.jsonRPC.batchRequest([ 283 | {method: 'test', params: ['param']} 284 | ], { 285 | url: 'data/valid_batch.js', 286 | error: function(json) { 287 | ok(false, "should not execute error callback"); 288 | start(); 289 | }, 290 | success: function(json) { 291 | ok(true, "should execute success callback"); 292 | start(); 293 | } 294 | }); 295 | 296 | }); 297 | 298 | }); 299 | -------------------------------------------------------------------------------- /jquery.jsonrpc.js: -------------------------------------------------------------------------------- 1 | (function($, undefined) { 2 | $.extend({ 3 | jsonRPC: { 4 | // RPC Version Number 5 | version: '2.0', 6 | 7 | // End point URL, sets default in requests if not 8 | // specified with the request call 9 | endPoint: null, 10 | 11 | // Default namespace for methods 12 | namespace: null, 13 | 14 | /* 15 | * Provides the RPC client with an optional default endpoint and namespace 16 | * 17 | * @param {object} The params object which can contain 18 | * endPoint {string} The default endpoint for RPC requests 19 | * namespace {string} The default namespace for RPC requests 20 | * cache {boolean} If set to false, it will force requested 21 | * pages not to be cached by the browser. Setting cache 22 | * to false also appends a query string parameter, 23 | * "_=[TIMESTAMP]", to the URL. (Default: true) 24 | */ 25 | setup: function(params) { 26 | this._validateConfigParams(params); 27 | this.endPoint = params.endPoint; 28 | this.namespace = params.namespace; 29 | this.cache = params.cache !== undefined ? params.cache : true; 30 | return this; 31 | }, 32 | 33 | /* 34 | * Convenience wrapper method to allow you to temporarily set a config parameter 35 | * (endPoint or namespace) and ensure it gets set back to what it was before 36 | * 37 | * @param {object} The params object which can contains 38 | * endPoint {string} The default endpoint for RPC requests 39 | * namespace {string} The default namespace for RPC requests 40 | * @param {function} callback The function to call with the new params in place 41 | */ 42 | withOptions: function(params, callback) { 43 | this._validateConfigParams(params); 44 | // No point in running if there isn't a callback received to run 45 | if(callback === undefined) throw("No callback specified"); 46 | 47 | origParams = {endPoint: this.endPoint, namespace: this.namespace}; 48 | this.setup(params); 49 | callback.call(this); 50 | this.setup(origParams); 51 | }, 52 | 53 | /* 54 | * Performas a single RPC request 55 | * 56 | * @param {string} method The name of the rpc method to be called 57 | * @param {object} options A collection of object which can contains 58 | * params {array} the params array to send along with the request 59 | * success {function} a function that will be executed if the request succeeds 60 | * error {function} a function that will be executed if the request fails 61 | * url {string} the url to send the request to 62 | * id {string} the provenance id for this request (defaults to 1) 63 | * cache {boolean} If set to false, it will force requested 64 | * pages not to be cached by the browser. Setting cache 65 | * to false also appends a query string parameter, 66 | * "_=[TIMESTAMP]", to the URL. (Default: cache value 67 | * set with the setup method) 68 | * @return {undefined} 69 | */ 70 | request: function(method, options) { 71 | if(options === undefined) { 72 | options = { id: 1 }; 73 | } 74 | if (options.id === undefined) { 75 | options.id = 1; 76 | } 77 | if (options.cache === undefined) { 78 | options.cache = this.cache; 79 | } 80 | 81 | // Validate method arguments 82 | this._validateRequestMethod(method); 83 | this._validateRequestParams(options.params); 84 | this._validateRequestCallbacks(options.success, options.error); 85 | 86 | // Perform the actual request 87 | this._doRequest(JSON.stringify(this._requestDataObj(method, options.params, options.id)), options); 88 | 89 | return true; 90 | }, 91 | 92 | /* 93 | * Submits multiple requests 94 | * Takes an array of objects that contain a method and params 95 | * 96 | * @params {array} requests an array of request object which can contain 97 | * method {string} the name of the method 98 | * param {object} the params object to be sent with the request 99 | * id {string} the provenance id for the request (defaults to an incrementer starting at 1) 100 | * @param {object} options A collection of object which can contains 101 | * success {function} a function that will be executed if the request succeeds 102 | * error {function} a function that will be executed if the request fails 103 | * url {string} the url to send the request to 104 | * @return {undefined} 105 | */ 106 | batchRequest: function(requests, options) { 107 | if(options === undefined) { 108 | options = {}; 109 | } 110 | 111 | // Ensure our requests come in as an array 112 | if(!$.isArray(requests) || requests.length === 0) throw("Invalid requests supplied for jsonRPC batchRequest. Must be an array object that contain at least a method attribute"); 113 | 114 | // Make sure each of our request objects are valid 115 | var _that = this; 116 | $.each(requests, function(i, req) { 117 | _that._validateRequestMethod(req.method); 118 | _that._validateRequestParams(req.params); 119 | if (req.id === undefined) { 120 | req.id = i + 1; 121 | } 122 | }); 123 | this._validateRequestCallbacks(options.success, options.error); 124 | 125 | var data = [], 126 | request; 127 | 128 | // Prepare our request object 129 | for(var i = 0; i 0 && json[0].jsonrpc !== '2.0') || 277 | (!$.isArray(json) && json.jsonrpc !== '2.0')) { 278 | throw 'Version error'; 279 | } 280 | 281 | return json; 282 | } 283 | catch (e) { 284 | return { 285 | error: 'Internal server error: ' + e, 286 | version: '2.0' 287 | } 288 | } 289 | } 290 | } 291 | 292 | } 293 | }); 294 | })(jQuery); 295 | -------------------------------------------------------------------------------- /test/qunit.js: -------------------------------------------------------------------------------- 1 | /* 2 | * QUnit - A JavaScript Unit Testing Framework 3 | * 4 | * http://docs.jquery.com/QUnit 5 | * 6 | * Copyright (c) 2009 John Resig, Jörn Zaefferer 7 | * Dual licensed under the MIT (MIT-LICENSE.txt) 8 | * and GPL (GPL-LICENSE.txt) licenses. 9 | */ 10 | 11 | (function(window) { 12 | 13 | var QUnit = { 14 | 15 | // call on start of module test to prepend name to all tests 16 | module: function(name, testEnvironment) { 17 | config.currentModule = name; 18 | 19 | synchronize(function() { 20 | if ( config.currentModule ) { 21 | QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all ); 22 | } 23 | 24 | config.currentModule = name; 25 | config.moduleTestEnvironment = testEnvironment; 26 | config.moduleStats = { all: 0, bad: 0 }; 27 | 28 | QUnit.moduleStart( name, testEnvironment ); 29 | }); 30 | }, 31 | 32 | asyncTest: function(testName, expected, callback) { 33 | if ( arguments.length === 2 ) { 34 | callback = expected; 35 | expected = 0; 36 | } 37 | 38 | QUnit.test(testName, expected, callback, true); 39 | }, 40 | 41 | test: function(testName, expected, callback, async) { 42 | var name = '' + testName + '', testEnvironment, testEnvironmentArg; 43 | 44 | if ( arguments.length === 2 ) { 45 | callback = expected; 46 | expected = null; 47 | } 48 | // is 2nd argument a testEnvironment? 49 | if ( expected && typeof expected === 'object') { 50 | testEnvironmentArg = expected; 51 | expected = null; 52 | } 53 | 54 | if ( config.currentModule ) { 55 | name = '' + config.currentModule + ": " + name; 56 | } 57 | 58 | if ( !validTest(config.currentModule + ": " + testName) ) { 59 | return; 60 | } 61 | 62 | synchronize(function() { 63 | 64 | testEnvironment = extend({ 65 | setup: function() {}, 66 | teardown: function() {} 67 | }, config.moduleTestEnvironment); 68 | if (testEnvironmentArg) { 69 | extend(testEnvironment,testEnvironmentArg); 70 | } 71 | 72 | QUnit.testStart( testName, testEnvironment ); 73 | 74 | // allow utility functions to access the current test environment 75 | QUnit.current_testEnvironment = testEnvironment; 76 | 77 | config.assertions = []; 78 | config.expected = expected; 79 | 80 | var tests = id("qunit-tests"); 81 | if (tests) { 82 | var b = document.createElement("strong"); 83 | b.innerHTML = "Running " + name; 84 | var li = document.createElement("li"); 85 | li.appendChild( b ); 86 | li.id = "current-test-output"; 87 | tests.appendChild( li ) 88 | } 89 | 90 | try { 91 | if ( !config.pollution ) { 92 | saveGlobal(); 93 | } 94 | 95 | testEnvironment.setup.call(testEnvironment); 96 | } catch(e) { 97 | QUnit.ok( false, "Setup failed on " + name + ": " + e.message ); 98 | } 99 | }); 100 | 101 | synchronize(function() { 102 | if ( async ) { 103 | QUnit.stop(); 104 | } 105 | 106 | try { 107 | callback.call(testEnvironment); 108 | } catch(e) { 109 | fail("Test " + name + " died, exception and test follows", e, callback); 110 | QUnit.ok( false, "Died on test #" + (config.assertions.length + 1) + ": " + e.message ); 111 | // else next test will carry the responsibility 112 | saveGlobal(); 113 | 114 | // Restart the tests if they're blocking 115 | if ( config.blocking ) { 116 | start(); 117 | } 118 | } 119 | }); 120 | 121 | synchronize(function() { 122 | try { 123 | checkPollution(); 124 | testEnvironment.teardown.call(testEnvironment); 125 | } catch(e) { 126 | QUnit.ok( false, "Teardown failed on " + name + ": " + e.message ); 127 | } 128 | }); 129 | 130 | synchronize(function() { 131 | try { 132 | QUnit.reset(); 133 | } catch(e) { 134 | fail("reset() failed, following Test " + name + ", exception and reset fn follows", e, QUnit.reset); 135 | } 136 | 137 | if ( config.expected && config.expected != config.assertions.length ) { 138 | QUnit.ok( false, "Expected " + config.expected + " assertions, but " + config.assertions.length + " were run" ); 139 | } 140 | 141 | var good = 0, bad = 0, 142 | tests = id("qunit-tests"); 143 | 144 | config.stats.all += config.assertions.length; 145 | config.moduleStats.all += config.assertions.length; 146 | 147 | if ( tests ) { 148 | var ol = document.createElement("ol"); 149 | 150 | for ( var i = 0; i < config.assertions.length; i++ ) { 151 | var assertion = config.assertions[i]; 152 | 153 | var li = document.createElement("li"); 154 | li.className = assertion.result ? "pass" : "fail"; 155 | li.innerHTML = assertion.message || "(no message)"; 156 | ol.appendChild( li ); 157 | 158 | if ( assertion.result ) { 159 | good++; 160 | } else { 161 | bad++; 162 | config.stats.bad++; 163 | config.moduleStats.bad++; 164 | } 165 | } 166 | if (bad == 0) { 167 | ol.style.display = "none"; 168 | } 169 | 170 | var b = document.createElement("strong"); 171 | b.innerHTML = name + " (" + bad + ", " + good + ", " + config.assertions.length + ")"; 172 | 173 | addEvent(b, "click", function() { 174 | var next = b.nextSibling, display = next.style.display; 175 | next.style.display = display === "none" ? "block" : "none"; 176 | }); 177 | 178 | addEvent(b, "dblclick", function(e) { 179 | var target = e && e.target ? e.target : window.event.srcElement; 180 | if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) { 181 | target = target.parentNode; 182 | } 183 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) { 184 | window.location.search = "?" + encodeURIComponent(getText([target]).replace(/$.+$$/, "").replace(/(^\s*|\s*$)/g, "")); 185 | } 186 | }); 187 | 188 | var li = id("current-test-output"); 189 | li.id = ""; 190 | li.className = bad ? "fail" : "pass"; 191 | li.removeChild( li.firstChild ); 192 | li.appendChild( b ); 193 | li.appendChild( ol ); 194 | 195 | if ( bad ) { 196 | var toolbar = id("qunit-testrunner-toolbar"); 197 | if ( toolbar ) { 198 | toolbar.style.display = "block"; 199 | id("qunit-filter-pass").disabled = null; 200 | id("qunit-filter-missing").disabled = null; 201 | } 202 | } 203 | 204 | } else { 205 | for ( var i = 0; i < config.assertions.length; i++ ) { 206 | if ( !config.assertions[i].result ) { 207 | bad++; 208 | config.stats.bad++; 209 | config.moduleStats.bad++; 210 | } 211 | } 212 | } 213 | 214 | QUnit.testDone( testName, bad, config.assertions.length ); 215 | 216 | if ( !window.setTimeout && !config.queue.length ) { 217 | done(); 218 | } 219 | }); 220 | 221 | synchronize( done ); 222 | }, 223 | 224 | /** 225 | * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through. 226 | */ 227 | expect: function(asserts) { 228 | config.expected = asserts; 229 | }, 230 | 231 | /** 232 | * Asserts true. 233 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); 234 | */ 235 | ok: function(a, msg) { 236 | msg = escapeHtml(msg); 237 | QUnit.log(a, msg); 238 | 239 | config.assertions.push({ 240 | result: !!a, 241 | message: msg 242 | }); 243 | }, 244 | 245 | /** 246 | * Checks that the first two arguments are equal, with an optional message. 247 | * Prints out both actual and expected values. 248 | * 249 | * Prefered to ok( actual == expected, message ) 250 | * 251 | * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." ); 252 | * 253 | * @param Object actual 254 | * @param Object expected 255 | * @param String message (optional) 256 | */ 257 | equal: function(actual, expected, message) { 258 | push(expected == actual, actual, expected, message); 259 | }, 260 | 261 | notEqual: function(actual, expected, message) { 262 | push(expected != actual, actual, expected, message); 263 | }, 264 | 265 | deepEqual: function(actual, expected, message) { 266 | push(QUnit.equiv(actual, expected), actual, expected, message); 267 | }, 268 | 269 | notDeepEqual: function(actual, expected, message) { 270 | push(!QUnit.equiv(actual, expected), actual, expected, message); 271 | }, 272 | 273 | strictEqual: function(actual, expected, message) { 274 | push(expected === actual, actual, expected, message); 275 | }, 276 | 277 | notStrictEqual: function(actual, expected, message) { 278 | push(expected !== actual, actual, expected, message); 279 | }, 280 | 281 | raises: function(fn, message) { 282 | try { 283 | fn(); 284 | ok( false, message ); 285 | } 286 | catch (e) { 287 | ok( true, message ); 288 | } 289 | }, 290 | 291 | start: function() { 292 | // A slight delay, to avoid any current callbacks 293 | if ( window.setTimeout ) { 294 | window.setTimeout(function() { 295 | if ( config.timeout ) { 296 | clearTimeout(config.timeout); 297 | } 298 | 299 | config.blocking = false; 300 | process(); 301 | }, 13); 302 | } else { 303 | config.blocking = false; 304 | process(); 305 | } 306 | }, 307 | 308 | stop: function(timeout) { 309 | config.blocking = true; 310 | 311 | if ( timeout && window.setTimeout ) { 312 | config.timeout = window.setTimeout(function() { 313 | QUnit.ok( false, "Test timed out" ); 314 | QUnit.start(); 315 | }, timeout); 316 | } 317 | } 318 | 319 | }; 320 | 321 | // Backwards compatibility, deprecated 322 | QUnit.equals = QUnit.equal; 323 | QUnit.same = QUnit.deepEqual; 324 | 325 | // Maintain internal state 326 | var config = { 327 | // The queue of tests to run 328 | queue: [], 329 | 330 | // block until document ready 331 | blocking: true 332 | }; 333 | 334 | // Load paramaters 335 | (function() { 336 | var location = window.location || { search: "", protocol: "file:" }, 337 | GETParams = location.search.slice(1).split('&'); 338 | 339 | for ( var i = 0; i < GETParams.length; i++ ) { 340 | GETParams[i] = decodeURIComponent( GETParams[i] ); 341 | if ( GETParams[i] === "noglobals" ) { 342 | GETParams.splice( i, 1 ); 343 | i--; 344 | config.noglobals = true; 345 | } else if ( GETParams[i].search('=') > -1 ) { 346 | GETParams.splice( i, 1 ); 347 | i--; 348 | } 349 | } 350 | 351 | // restrict modules/tests by get parameters 352 | config.filters = GETParams; 353 | 354 | // Figure out if we're running the tests from a server or not 355 | QUnit.isLocal = !!(location.protocol === 'file:'); 356 | })(); 357 | 358 | // Expose the API as global variables, unless an 'exports' 359 | // object exists, in that case we assume we're in CommonJS 360 | if ( typeof exports === "undefined" || typeof require === "undefined" ) { 361 | extend(window, QUnit); 362 | window.QUnit = QUnit; 363 | } else { 364 | extend(exports, QUnit); 365 | exports.QUnit = QUnit; 366 | } 367 | 368 | // define these after exposing globals to keep them in these QUnit namespace only 369 | extend(QUnit, { 370 | config: config, 371 | 372 | // Initialize the configuration options 373 | init: function() { 374 | extend(config, { 375 | stats: { all: 0, bad: 0 }, 376 | moduleStats: { all: 0, bad: 0 }, 377 | started: +new Date, 378 | updateRate: 1000, 379 | blocking: false, 380 | autostart: true, 381 | autorun: false, 382 | assertions: [], 383 | filters: [], 384 | queue: [] 385 | }); 386 | 387 | var tests = id("qunit-tests"), 388 | banner = id("qunit-banner"), 389 | result = id("qunit-testresult"); 390 | 391 | if ( tests ) { 392 | tests.innerHTML = ""; 393 | } 394 | 395 | if ( banner ) { 396 | banner.className = ""; 397 | } 398 | 399 | if ( result ) { 400 | result.parentNode.removeChild( result ); 401 | } 402 | }, 403 | 404 | /** 405 | * Resets the test setup. Useful for tests that modify the DOM. 406 | */ 407 | reset: function() { 408 | if ( window.jQuery ) { 409 | jQuery("#main, #qunit-fixture").html( config.fixture ); 410 | } 411 | }, 412 | 413 | /** 414 | * Trigger an event on an element. 415 | * 416 | * @example triggerEvent( document.body, "click" ); 417 | * 418 | * @param DOMElement elem 419 | * @param String type 420 | */ 421 | triggerEvent: function( elem, type, event ) { 422 | if ( document.createEvent ) { 423 | event = document.createEvent("MouseEvents"); 424 | event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView, 425 | 0, 0, 0, 0, 0, false, false, false, false, 0, null); 426 | elem.dispatchEvent( event ); 427 | 428 | } else if ( elem.fireEvent ) { 429 | elem.fireEvent("on"+type); 430 | } 431 | }, 432 | 433 | // Safe object type checking 434 | is: function( type, obj ) { 435 | return QUnit.objectType( obj ) == type; 436 | }, 437 | 438 | objectType: function( obj ) { 439 | if (typeof obj === "undefined") { 440 | return "undefined"; 441 | 442 | // consider: typeof null === object 443 | } 444 | if (obj === null) { 445 | return "null"; 446 | } 447 | 448 | var type = Object.prototype.toString.call( obj ) 449 | .match(/^\[object\s(.*)\]$/)[1] || ''; 450 | 451 | switch (type) { 452 | case 'Number': 453 | if (isNaN(obj)) { 454 | return "nan"; 455 | } else { 456 | return "number"; 457 | } 458 | case 'String': 459 | case 'Boolean': 460 | case 'Array': 461 | case 'Date': 462 | case 'RegExp': 463 | case 'Function': 464 | return type.toLowerCase(); 465 | } 466 | if (typeof obj === "object") { 467 | return "object"; 468 | } 469 | return undefined; 470 | }, 471 | 472 | // Logging callbacks 473 | begin: function() {}, 474 | done: function(failures, total) {}, 475 | log: function(result, message) {}, 476 | testStart: function(name, testEnvironment) {}, 477 | testDone: function(name, failures, total) {}, 478 | moduleStart: function(name, testEnvironment) {}, 479 | moduleDone: function(name, failures, total) {} 480 | }); 481 | 482 | if ( typeof document === "undefined" || document.readyState === "complete" ) { 483 | config.autorun = true; 484 | } 485 | 486 | addEvent(window, "load", function() { 487 | QUnit.begin(); 488 | 489 | // Initialize the config, saving the execution queue 490 | var oldconfig = extend({}, config); 491 | QUnit.init(); 492 | extend(config, oldconfig); 493 | 494 | config.blocking = false; 495 | 496 | var userAgent = id("qunit-userAgent"); 497 | if ( userAgent ) { 498 | userAgent.innerHTML = navigator.userAgent; 499 | } 500 | var banner = id("qunit-header"); 501 | if ( banner ) { 502 | banner.innerHTML = '' + banner.innerHTML + ''; 503 | } 504 | 505 | var toolbar = id("qunit-testrunner-toolbar"); 506 | if ( toolbar ) { 507 | toolbar.style.display = "none"; 508 | 509 | var filter = document.createElement("input"); 510 | filter.type = "checkbox"; 511 | filter.id = "qunit-filter-pass"; 512 | filter.disabled = true; 513 | addEvent( filter, "click", function() { 514 | var li = document.getElementsByTagName("li"); 515 | for ( var i = 0; i < li.length; i++ ) { 516 | if ( li[i].className.indexOf("pass") > -1 ) { 517 | li[i].style.display = filter.checked ? "none" : ""; 518 | } 519 | } 520 | }); 521 | toolbar.appendChild( filter ); 522 | 523 | var label = document.createElement("label"); 524 | label.setAttribute("for", "qunit-filter-pass"); 525 | label.innerHTML = "Hide passed tests"; 526 | toolbar.appendChild( label ); 527 | 528 | var missing = document.createElement("input"); 529 | missing.type = "checkbox"; 530 | missing.id = "qunit-filter-missing"; 531 | missing.disabled = true; 532 | addEvent( missing, "click", function() { 533 | var li = document.getElementsByTagName("li"); 534 | for ( var i = 0; i < li.length; i++ ) { 535 | if ( li[i].className.indexOf("fail") > -1 && li[i].innerHTML.indexOf('missing test - untested code is broken code') > - 1 ) { 536 | li[i].parentNode.parentNode.style.display = missing.checked ? "none" : "block"; 537 | } 538 | } 539 | }); 540 | toolbar.appendChild( missing ); 541 | 542 | label = document.createElement("label"); 543 | label.setAttribute("for", "qunit-filter-missing"); 544 | label.innerHTML = "Hide missing tests (untested code is broken code)"; 545 | toolbar.appendChild( label ); 546 | } 547 | 548 | var main = id('main') || id('qunit-fixture'); 549 | if ( main ) { 550 | config.fixture = main.innerHTML; 551 | } 552 | 553 | if (config.autostart) { 554 | QUnit.start(); 555 | } 556 | }); 557 | 558 | function done() { 559 | if ( config.doneTimer && window.clearTimeout ) { 560 | window.clearTimeout( config.doneTimer ); 561 | config.doneTimer = null; 562 | } 563 | 564 | if ( config.queue.length ) { 565 | config.doneTimer = window.setTimeout(function(){ 566 | if ( !config.queue.length ) { 567 | done(); 568 | } else { 569 | synchronize( done ); 570 | } 571 | }, 13); 572 | 573 | return; 574 | } 575 | 576 | config.autorun = true; 577 | 578 | // Log the last module results 579 | if ( config.currentModule ) { 580 | QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all ); 581 | } 582 | 583 | var banner = id("qunit-banner"), 584 | tests = id("qunit-tests"), 585 | html = ['Tests completed in ', 586 | +new Date - config.started, ' milliseconds.
', 587 | '', config.stats.all - config.stats.bad, ' tests of ', config.stats.all, ' passed, ', config.stats.bad,' failed.'].join(''); 588 | 589 | if ( banner ) { 590 | banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass"); 591 | } 592 | 593 | if ( tests ) { 594 | var result = id("qunit-testresult"); 595 | 596 | if ( !result ) { 597 | result = document.createElement("p"); 598 | result.id = "qunit-testresult"; 599 | result.className = "result"; 600 | tests.parentNode.insertBefore( result, tests.nextSibling ); 601 | } 602 | 603 | result.innerHTML = html; 604 | } 605 | 606 | QUnit.done( config.stats.bad, config.stats.all ); 607 | } 608 | 609 | function validTest( name ) { 610 | var i = config.filters.length, 611 | run = false; 612 | 613 | if ( !i ) { 614 | return true; 615 | } 616 | 617 | while ( i-- ) { 618 | var filter = config.filters[i], 619 | not = filter.charAt(0) == '!'; 620 | 621 | if ( not ) { 622 | filter = filter.slice(1); 623 | } 624 | 625 | if ( name.indexOf(filter) !== -1 ) { 626 | return !not; 627 | } 628 | 629 | if ( not ) { 630 | run = true; 631 | } 632 | } 633 | 634 | return run; 635 | } 636 | 637 | function escapeHtml(s) { 638 | s = s === null ? "" : s + ""; 639 | return s.replace(/[\&"<>\\]/g, function(s) { 640 | switch(s) { 641 | case "&": return "&"; 642 | case "\\": return "\\\\"; 643 | case '"': return '\"'; 644 | case "<": return "<"; 645 | case ">": return ">"; 646 | default: return s; 647 | } 648 | }); 649 | } 650 | 651 | function push(result, actual, expected, message) { 652 | message = escapeHtml(message) || (result ? "okay" : "failed"); 653 | message = '' + message + ""; 654 | expected = escapeHtml(QUnit.jsDump.parse(expected)); 655 | actual = escapeHtml(QUnit.jsDump.parse(actual)); 656 | var output = message + ', expected: ' + expected + ''; 657 | if (actual != expected) { 658 | output += ' result: ' + actual + ', diff: ' + QUnit.diff(expected, actual); 659 | } 660 | 661 | // can't use ok, as that would double-escape messages 662 | QUnit.log(result, output); 663 | config.assertions.push({ 664 | result: !!result, 665 | message: output 666 | }); 667 | } 668 | 669 | function synchronize( callback ) { 670 | config.queue.push( callback ); 671 | 672 | if ( config.autorun && !config.blocking ) { 673 | process(); 674 | } 675 | } 676 | 677 | function process() { 678 | var start = (new Date()).getTime(); 679 | 680 | while ( config.queue.length && !config.blocking ) { 681 | if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) { 682 | config.queue.shift()(); 683 | 684 | } else { 685 | setTimeout( process, 13 ); 686 | break; 687 | } 688 | } 689 | } 690 | 691 | function saveGlobal() { 692 | config.pollution = []; 693 | 694 | if ( config.noglobals ) { 695 | for ( var key in window ) { 696 | config.pollution.push( key ); 697 | } 698 | } 699 | } 700 | 701 | function checkPollution( name ) { 702 | var old = config.pollution; 703 | saveGlobal(); 704 | 705 | var newGlobals = diff( old, config.pollution ); 706 | if ( newGlobals.length > 0 ) { 707 | ok( false, "Introduced global variable(s): " + newGlobals.join(", ") ); 708 | config.expected++; 709 | } 710 | 711 | var deletedGlobals = diff( config.pollution, old ); 712 | if ( deletedGlobals.length > 0 ) { 713 | ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") ); 714 | config.expected++; 715 | } 716 | } 717 | 718 | // returns a new Array with the elements that are in a but not in b 719 | function diff( a, b ) { 720 | var result = a.slice(); 721 | for ( var i = 0; i < result.length; i++ ) { 722 | for ( var j = 0; j < b.length; j++ ) { 723 | if ( result[i] === b[j] ) { 724 | result.splice(i, 1); 725 | i--; 726 | break; 727 | } 728 | } 729 | } 730 | return result; 731 | } 732 | 733 | function fail(message, exception, callback) { 734 | if ( typeof console !== "undefined" && console.error && console.warn ) { 735 | console.error(message); 736 | console.error(exception); 737 | console.warn(callback.toString()); 738 | 739 | } else if ( window.opera && opera.postError ) { 740 | opera.postError(message, exception, callback.toString); 741 | } 742 | } 743 | 744 | function extend(a, b) { 745 | for ( var prop in b ) { 746 | a[prop] = b[prop]; 747 | } 748 | 749 | return a; 750 | } 751 | 752 | function addEvent(elem, type, fn) { 753 | if ( elem.addEventListener ) { 754 | elem.addEventListener( type, fn, false ); 755 | } else if ( elem.attachEvent ) { 756 | elem.attachEvent( "on" + type, fn ); 757 | } else { 758 | fn(); 759 | } 760 | } 761 | 762 | function id(name) { 763 | return !!(typeof document !== "undefined" && document && document.getElementById) && 764 | document.getElementById( name ); 765 | } 766 | 767 | // Test for equality any JavaScript type. 768 | // Discussions and reference: http://philrathe.com/articles/equiv 769 | // Test suites: http://philrathe.com/tests/equiv 770 | // Author: Philippe Rathé 771 | QUnit.equiv = function () { 772 | 773 | var innerEquiv; // the real equiv function 774 | var callers = []; // stack to decide between skip/abort functions 775 | var parents = []; // stack to avoiding loops from circular referencing 776 | 777 | // Call the o related callback with the given arguments. 778 | function bindCallbacks(o, callbacks, args) { 779 | var prop = QUnit.objectType(o); 780 | if (prop) { 781 | if (QUnit.objectType(callbacks[prop]) === "function") { 782 | return callbacks[prop].apply(callbacks, args); 783 | } else { 784 | return callbacks[prop]; // or undefined 785 | } 786 | } 787 | } 788 | 789 | var callbacks = function () { 790 | 791 | // for string, boolean, number and null 792 | function useStrictEquality(b, a) { 793 | if (b instanceof a.constructor || a instanceof b.constructor) { 794 | // to catch short annotaion VS 'new' annotation of a declaration 795 | // e.g. var i = 1; 796 | // var j = new Number(1); 797 | return a == b; 798 | } else { 799 | return a === b; 800 | } 801 | } 802 | 803 | return { 804 | "string": useStrictEquality, 805 | "boolean": useStrictEquality, 806 | "number": useStrictEquality, 807 | "null": useStrictEquality, 808 | "undefined": useStrictEquality, 809 | 810 | "nan": function (b) { 811 | return isNaN(b); 812 | }, 813 | 814 | "date": function (b, a) { 815 | return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf(); 816 | }, 817 | 818 | "regexp": function (b, a) { 819 | return QUnit.objectType(b) === "regexp" && 820 | a.source === b.source && // the regex itself 821 | a.global === b.global && // and its modifers (gmi) ... 822 | a.ignoreCase === b.ignoreCase && 823 | a.multiline === b.multiline; 824 | }, 825 | 826 | // - skip when the property is a method of an instance (OOP) 827 | // - abort otherwise, 828 | // initial === would have catch identical references anyway 829 | "function": function () { 830 | var caller = callers[callers.length - 1]; 831 | return caller !== Object && 832 | typeof caller !== "undefined"; 833 | }, 834 | 835 | "array": function (b, a) { 836 | var i, j, loop; 837 | var len; 838 | 839 | // b could be an object literal here 840 | if ( ! (QUnit.objectType(b) === "array")) { 841 | return false; 842 | } 843 | 844 | len = a.length; 845 | if (len !== b.length) { // safe and faster 846 | return false; 847 | } 848 | 849 | //track reference to avoid circular references 850 | parents.push(a); 851 | for (i = 0; i < len; i++) { 852 | loop = false; 853 | for(j=0;j= 0) { 998 | type = "array"; 999 | } else { 1000 | type = typeof obj; 1001 | } 1002 | return type; 1003 | }, 1004 | separator:function() { 1005 | return this.multiline ? this.HTML ? '
' : '\n' : this.HTML ? ' ' : ' '; 1006 | }, 1007 | indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing 1008 | if ( !this.multiline ) 1009 | return ''; 1010 | var chr = this.indentChar; 1011 | if ( this.HTML ) 1012 | chr = chr.replace(/\t/g,' ').replace(/ /g,' '); 1013 | return Array( this._depth_ + (extra||0) ).join(chr); 1014 | }, 1015 | up:function( a ) { 1016 | this._depth_ += a || 1; 1017 | }, 1018 | down:function( a ) { 1019 | this._depth_ -= a || 1; 1020 | }, 1021 | setParser:function( name, parser ) { 1022 | this.parsers[name] = parser; 1023 | }, 1024 | // The next 3 are exposed so you can use them 1025 | quote:quote, 1026 | literal:literal, 1027 | join:join, 1028 | // 1029 | _depth_: 1, 1030 | // This is the list of parsers, to modify them, use jsDump.setParser 1031 | parsers:{ 1032 | window: '[Window]', 1033 | document: '[Document]', 1034 | error:'[ERROR]', //when no parser is found, shouldn't happen 1035 | unknown: '[Unknown]', 1036 | 'null':'null', 1037 | undefined:'undefined', 1038 | 'function':function( fn ) { 1039 | var ret = 'function', 1040 | name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE 1041 | if ( name ) 1042 | ret += ' ' + name; 1043 | ret += '('; 1044 | 1045 | ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join(''); 1046 | return join( ret, this.parse(fn,'functionCode'), '}' ); 1047 | }, 1048 | array: array, 1049 | nodelist: array, 1050 | arguments: array, 1051 | object:function( map ) { 1052 | var ret = [ ]; 1053 | this.up(); 1054 | for ( var key in map ) 1055 | ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) ); 1056 | this.down(); 1057 | return join( '{', ret, '}' ); 1058 | }, 1059 | node:function( node ) { 1060 | var open = this.HTML ? '<' : '<', 1061 | close = this.HTML ? '>' : '>'; 1062 | 1063 | var tag = node.nodeName.toLowerCase(), 1064 | ret = open + tag; 1065 | 1066 | for ( var a in this.DOMAttrs ) { 1067 | var val = node[this.DOMAttrs[a]]; 1068 | if ( val ) 1069 | ret += ' ' + a + '=' + this.parse( val, 'attribute' ); 1070 | } 1071 | return ret + close + open + '/' + tag + close; 1072 | }, 1073 | functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function 1074 | var l = fn.length; 1075 | if ( !l ) return ''; 1076 | 1077 | var args = Array(l); 1078 | while ( l-- ) 1079 | args[l] = String.fromCharCode(97+l);//97 is 'a' 1080 | return ' ' + args.join(', ') + ' '; 1081 | }, 1082 | key:quote, //object calls it internally, the key part of an item in a map 1083 | functionCode:'[code]', //function calls it internally, it's the content of the function 1084 | attribute:quote, //node calls it internally, it's an html attribute value 1085 | string:quote, 1086 | date:quote, 1087 | regexp:literal, //regex 1088 | number:literal, 1089 | 'boolean':literal 1090 | }, 1091 | DOMAttrs:{//attributes to dump from nodes, name=>realName 1092 | id:'id', 1093 | name:'name', 1094 | 'class':'className' 1095 | }, 1096 | HTML:false,//if true, entities are escaped ( <, >, \t, space and \n ) 1097 | indentChar:' ',//indentation unit 1098 | multiline:false //if true, items in a collection, are separated by a \n, else just a space. 1099 | }; 1100 | 1101 | return jsDump; 1102 | })(); 1103 | 1104 | // from Sizzle.js 1105 | function getText( elems ) { 1106 | var ret = "", elem; 1107 | 1108 | for ( var i = 0; elems[i]; i++ ) { 1109 | elem = elems[i]; 1110 | 1111 | // Get the text from text nodes and CDATA nodes 1112 | if ( elem.nodeType === 3 || elem.nodeType === 4 ) { 1113 | ret += elem.nodeValue; 1114 | 1115 | // Traverse everything else, except comment nodes 1116 | } else if ( elem.nodeType !== 8 ) { 1117 | ret += getText( elem.childNodes ); 1118 | } 1119 | } 1120 | 1121 | return ret; 1122 | }; 1123 | 1124 | /* 1125 | * Javascript Diff Algorithm 1126 | * By John Resig (http://ejohn.org/) 1127 | * Modified by Chu Alan "sprite" 1128 | * 1129 | * Released under the MIT license. 1130 | * 1131 | * More Info: 1132 | * http://ejohn.org/projects/javascript-diff-algorithm/ 1133 | * 1134 | * Usage: QUnit.diff(expected, actual) 1135 | * 1136 | * QUnit.diff("the quick brown fox jumped over", "the quick fox jumps over") == "the quick ~~brown~~ fox ~~jumped~~ jumps over" 1137 | */ 1138 | QUnit.diff = (function() { 1139 | function diff(o, n){ 1140 | var ns = new Object(); 1141 | var os = new Object(); 1142 | 1143 | for (var i = 0; i < n.length; i++) { 1144 | if (ns[n[i]] == null) 1145 | ns[n[i]] = { 1146 | rows: new Array(), 1147 | o: null 1148 | }; 1149 | ns[n[i]].rows.push(i); 1150 | } 1151 | 1152 | for (var i = 0; i < o.length; i++) { 1153 | if (os[o[i]] == null) 1154 | os[o[i]] = { 1155 | rows: new Array(), 1156 | n: null 1157 | }; 1158 | os[o[i]].rows.push(i); 1159 | } 1160 | 1161 | for (var i in ns) { 1162 | if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) { 1163 | n[ns[i].rows[0]] = { 1164 | text: n[ns[i].rows[0]], 1165 | row: os[i].rows[0] 1166 | }; 1167 | o[os[i].rows[0]] = { 1168 | text: o[os[i].rows[0]], 1169 | row: ns[i].rows[0] 1170 | }; 1171 | } 1172 | } 1173 | 1174 | for (var i = 0; i < n.length - 1; i++) { 1175 | if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null && 1176 | n[i + 1] == o[n[i].row + 1]) { 1177 | n[i + 1] = { 1178 | text: n[i + 1], 1179 | row: n[i].row + 1 1180 | }; 1181 | o[n[i].row + 1] = { 1182 | text: o[n[i].row + 1], 1183 | row: i + 1 1184 | }; 1185 | } 1186 | } 1187 | 1188 | for (var i = n.length - 1; i > 0; i--) { 1189 | if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null && 1190 | n[i - 1] == o[n[i].row - 1]) { 1191 | n[i - 1] = { 1192 | text: n[i - 1], 1193 | row: n[i].row - 1 1194 | }; 1195 | o[n[i].row - 1] = { 1196 | text: o[n[i].row - 1], 1197 | row: i - 1 1198 | }; 1199 | } 1200 | } 1201 | 1202 | return { 1203 | o: o, 1204 | n: n 1205 | }; 1206 | } 1207 | 1208 | return function(o, n){ 1209 | o = o.replace(/\s+$/, ''); 1210 | n = n.replace(/\s+$/, ''); 1211 | var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/)); 1212 | 1213 | var str = ""; 1214 | 1215 | var oSpace = o.match(/\s+/g); 1216 | if (oSpace == null) { 1217 | oSpace = [" "]; 1218 | } 1219 | else { 1220 | oSpace.push(" "); 1221 | } 1222 | var nSpace = n.match(/\s+/g); 1223 | if (nSpace == null) { 1224 | nSpace = [" "]; 1225 | } 1226 | else { 1227 | nSpace.push(" "); 1228 | } 1229 | 1230 | if (out.n.length == 0) { 1231 | for (var i = 0; i < out.o.length; i++) { 1232 | str += '~~' + out.o[i] + oSpace[i] + "~~"; 1233 | } 1234 | } 1235 | else { 1236 | if (out.n[0].text == null) { 1237 | for (n = 0; n < out.o.length && out.o[n].text == null; n++) { 1238 | str += '~~' + out.o[n] + oSpace[n] + "~~"; 1239 | } 1240 | } 1241 | 1242 | for (var i = 0; i < out.n.length; i++) { 1243 | if (out.n[i].text == null) { 1244 | str += '' + out.n[i] + nSpace[i] + ""; 1245 | } 1246 | else { 1247 | var pre = ""; 1248 | 1249 | for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) { 1250 | pre += '~~' + out.o[n] + oSpace[n] + "~~"; 1251 | } 1252 | str += " " + out.n[i].text + nSpace[i] + pre; 1253 | } 1254 | } 1255 | } 1256 | 1257 | return str; 1258 | } 1259 | })(); 1260 | 1261 | })(this); 1262 | --------------------------------------------------------------------------------