├── .gitignore ├── lib ├── tests │ ├── ember-infinite-pagination_test.coffee │ └── controller_mixin_test.coffee └── src │ ├── controller_mixin.coffee │ └── ember-infinite-pagination.coffee ├── .jshintrc ├── tests ├── index.html ├── resources │ ├── qunit.css │ └── qunit.js └── vendor │ └── handlebars.js ├── package.json ├── bin ├── ember-infinite-pagination.min.js └── ember-infinite-pagination.js ├── Gruntfile.js └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.swp 2 | /node_modules/ 3 | tmp 4 | bin/*tests.js 5 | -------------------------------------------------------------------------------- /lib/tests/ember-infinite-pagination_test.coffee: -------------------------------------------------------------------------------- 1 | module "IHID" 2 | 3 | test "it is defined and an Ember.Namespace", -> 4 | ok IHID, "IHID is defined" -------------------------------------------------------------------------------- /.jshintrc: -------------------------------------------------------------------------------- 1 | { 2 | "strict": false, 3 | "globalstrict": false, 4 | "curly": true, 5 | "eqeqeq": true, 6 | "immed": true, 7 | "latedef": true, 8 | "newcap": true, 9 | "noarg": true, 10 | "sub": true, 11 | "undef": true, 12 | "unused": true, 13 | "boss": true, 14 | "eqnull": true, 15 | "node": true, 16 | "es5": true, 17 | 18 | "globals": { 19 | "Ember": true, 20 | "Em": true, 21 | "DS": false, 22 | "IHID": true, 23 | 24 | "module": true, 25 | "test": true, 26 | "ok": true, 27 | "equal": true, 28 | "deepEqual": true 29 | } 30 | } -------------------------------------------------------------------------------- /tests/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | ember-infinite-pagination tests 6 | 7 | 8 | 9 |

10 |

11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | -------------------------------------------------------------------------------- /lib/src/controller_mixin.coffee: -------------------------------------------------------------------------------- 1 | IHID.InfinitePagination.ControllerMixin = Ember.Mixin.create Ember.Evented, 2 | canLoadMore: true 3 | currentPage: 1 4 | isLoading: false 5 | resetLoadMore: -> @set('currentPage', 1) 6 | 7 | loadMore: -> 8 | return unless @get('canLoadMore') 9 | @incrementProperty('currentPage') 10 | @updateData() 11 | 12 | search: -> 13 | @set('currentPage', 1) 14 | @get('model').clear() 15 | @updateData() 16 | 17 | updateData: -> 18 | @set('isLoading', true) 19 | @get('model').type.find(@paginationParams()).addObserver 'isLoaded', => 20 | @set('isLoading', false) 21 | 22 | paginationParams: -> 23 | page: @get('currentPage') 24 | -------------------------------------------------------------------------------- /lib/tests/controller_mixin_test.coffee: -------------------------------------------------------------------------------- 1 | module "IHID.InfinitePagination.ControllerMixin", 2 | setup: -> 3 | window.controller = Ember.Object.createWithMixins IHID.InfinitePagination.ControllerMixin 4 | 5 | tearDown: -> 6 | window.controller.destroy() 7 | 8 | test "resetLoadMore sets currentPage back to 1", -> 9 | controller.currentPage = 10 10 | equal controller.currentPage, 10, "precond - currentPage is set to 10" 11 | controller.resetLoadMore() 12 | equal controller.currentPage, 1, "currentPage of controller has been reset to 1" 13 | 14 | test "loadMore increments currentPage and invokes updateData", -> 15 | expect 2 16 | 17 | controller.currentPage = 1 18 | controller.reopen updateData: -> 19 | ok true, "updateData has been called" 20 | 21 | controller.loadMore() 22 | 23 | equal controller.currentPage, 2, "currentPage has been incremented" -------------------------------------------------------------------------------- /lib/src/ember-infinite-pagination.coffee: -------------------------------------------------------------------------------- 1 | window.IHID or= {} 2 | window.IHID.InfinitePagination = 3 | 4 | setupRoute: (model, controller) -> 5 | content = model.filter controller.paginationParams(), (data) -> 6 | true 7 | 8 | controller.set 'content', content 9 | 10 | template = """ 11 | {{#if isLoading}} 12 | Fetching some more stuff

13 | {{else}} 14 | {{#if canLoadMore}} 15 | click to load more 16 | {{else}} 17 | no more items 18 | {{/if}} 19 | {{/if}} 20 | """ 21 | 22 | IHID.InfinitePagination.LoadMoreView = Ember.View.extend 23 | template: Ember.Handlebars.compile(template) 24 | didInsertElement: -> 25 | @$().bind 'inview', (event, isInView, visiblePartX, visiblePartY) => 26 | Ember.tryInvoke(@get('controller'), 'loadMore') if isInView 27 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "ember-infinite-pagination", 3 | "author": "Jeremy Walker", 4 | "version": "0.0.1", 5 | "homepage": "https://github.com/iHiD/ember-infinite-pagination", 6 | "description": "Infinite Pagination for EmberJS", 7 | "main": "ember-infinite-pagination.min.js", 8 | "keywords": [ 9 | "emberjs", 10 | "pagination", 11 | "infinite pagination" 12 | ], 13 | "repository": { 14 | "type": "git", 15 | "url": "git@github.com:iHiD/ember-infinite-pagination.git" 16 | }, 17 | "bugs": { 18 | "url": "https://github.com/iHiD/ember-infinite-pagination/issues" 19 | }, 20 | "devDependencies": { 21 | "grunt": "~0.4.1", 22 | "grunt-contrib-clean": "~0.4.0", 23 | "grunt-contrib-coffee": "~0.6.4", 24 | "grunt-contrib-concat": "~0.1.2", 25 | "grunt-contrib-connect": "~0.2.0", 26 | "grunt-contrib-jshint": "~0.1.1", 27 | "grunt-contrib-qunit": "~0.1.1", 28 | "grunt-contrib-uglify": "~0.1.1", 29 | "grunt-contrib-watch": "~0.2.0", 30 | "grunt-coffeelint": "~0.0.6", 31 | "falafel": "~0.2.1" 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /bin/ember-infinite-pagination.min.js: -------------------------------------------------------------------------------- 1 | /*! Infinite Pagination for EmberJS 2 | * (c) 2013 Jeremy Walker 3 | * MIT Licensed. 4 | * 5 | * Written by iHiD (Jeremy Walker) - Based on an idea by @pangratz 6 | * 7 | * https://github.com/iHiD/ember-infinite-pagination 8 | */ 9 | (function(){var e;window.IHID||(window.IHID={}),window.IHID.InfinitePagination={setupRoute:function(e,n){var t;return t=e.filter(n.paginationParams(),function(){return!0}),n.set("content",t)}},e='{{#if isLoading}}\n Fetching some more stuff

\n{{else}}\n {{#if canLoadMore}}\n click to load more\n {{else}}\n no more items\n {{/if}}\n{{/if}}',IHID.InfinitePagination.LoadMoreView=Ember.View.extend({template:Ember.Handlebars.compile(e),didInsertElement:function(){var e=this;return this.$().bind("inview",function(n,t){return t?Ember.tryInvoke(e.get("controller"),"loadMore"):void 0})}})}).call(this),function(){IHID.InfinitePagination.ControllerMixin=Ember.Mixin.create(Ember.Evented,{canLoadMore:!0,currentPage:1,isLoading:!1,resetLoadMore:function(){return this.set("currentPage",1)},loadMore:function(){return this.get("canLoadMore")?(this.incrementProperty("currentPage"),this.updateData()):void 0},search:function(){return this.set("currentPage",1),this.get("model").clear(),this.updateData()},updateData:function(){var e=this;return this.set("isLoading",!0),this.get("model").type.find(this.paginationParams()).addObserver("isLoaded",function(){return e.set("isLoading",!1)})},paginationParams:function(){return{page:this.get("currentPage")}}})}.call(this); -------------------------------------------------------------------------------- /bin/ember-infinite-pagination.js: -------------------------------------------------------------------------------- 1 | /*! Infinite Pagination for EmberJS 2 | * (c) 2013 Jeremy Walker 3 | * MIT Licensed. 4 | * 5 | * Written by iHiD (Jeremy Walker) - Based on an idea by @pangratz 6 | * 7 | * https://github.com/iHiD/ember-infinite-pagination 8 | */ 9 | (function() { 10 | var template; 11 | window.IHID || (window.IHID = {}); 12 | window.IHID.InfinitePagination = { 13 | setupRoute: function(model, controller) { 14 | var content; 15 | content = model.filter(controller.paginationParams(), function(data) { 16 | return true; 17 | }); 18 | return controller.set("content", content); 19 | } 20 | }; 21 | template = '{{#if isLoading}}\n Fetching some more stuff

\n{{else}}\n {{#if canLoadMore}}\n click to load more\n {{else}}\n no more items\n {{/if}}\n{{/if}}'; 22 | IHID.InfinitePagination.LoadMoreView = Ember.View.extend({ 23 | template: Ember.Handlebars.compile(template), 24 | didInsertElement: function() { 25 | var _this = this; 26 | return this.$().bind("inview", function(event, isInView, visiblePartX, visiblePartY) { 27 | if (isInView) { 28 | return Ember.tryInvoke(_this.get("controller"), "loadMore"); 29 | } 30 | }); 31 | } 32 | }); 33 | }).call(this); 34 | 35 | (function() { 36 | IHID.InfinitePagination.ControllerMixin = Ember.Mixin.create(Ember.Evented, { 37 | canLoadMore: true, 38 | currentPage: 1, 39 | isLoading: false, 40 | resetLoadMore: function() { 41 | return this.set("currentPage", 1); 42 | }, 43 | loadMore: function() { 44 | if (!this.get("canLoadMore")) { 45 | return; 46 | } 47 | this.incrementProperty("currentPage"); 48 | return this.updateData(); 49 | }, 50 | search: function() { 51 | this.set("currentPage", 1); 52 | this.get("model").clear(); 53 | return this.updateData(); 54 | }, 55 | updateData: function() { 56 | var _this = this; 57 | this.set("isLoading", true); 58 | return this.get("model").type.find(this.paginationParams()).addObserver("isLoaded", function() { 59 | return _this.set("isLoading", false); 60 | }); 61 | }, 62 | paginationParams: function() { 63 | return { 64 | page: this.get("currentPage") 65 | }; 66 | } 67 | }); 68 | }).call(this); -------------------------------------------------------------------------------- /Gruntfile.js: -------------------------------------------------------------------------------- 1 | module.exports = function(grunt) { 2 | "use strict"; 3 | 4 | // Project configuration. 5 | grunt.initConfig({ 6 | // Metadata. 7 | pkg: grunt.file.readJSON('package.json'), 8 | banner: '/*! <%= pkg.description %>\n' + 9 | '* (c) <%= grunt.template.today("yyyy") %> Jeremy Walker \n' + 10 | '* MIT Licensed.\n' + 11 | '*\n' + 12 | '* Written by iHiD (Jeremy Walker) - Based on an idea by @pangratz\n' + 13 | '*\n' + 14 | '* <%= pkg.homepage %>\n' + 15 | '*/\n', 16 | 17 | clean: { 18 | files: ['bin', 'tmp'] 19 | }, 20 | coffee: { 21 | options: { 22 | separator: ';' 23 | }, 24 | compile: { 25 | files: { 26 | 'tmp/<%= pkg.name %>.js': ['lib/src/<%= pkg.name %>.coffee', 'lib/src/**/*.coffee'], 27 | 'bin/<%= pkg.name %>-tests.js': ['lib/tests/<%= pkg.name %>.coffee', 'lib/tests/**/*.coffee'] 28 | } 29 | } 30 | }, 31 | uglify: { 32 | options: { 33 | banner: '<%= banner %>' 34 | }, 35 | dist: { 36 | src: 'tmp/<%= pkg.name %>.js', 37 | dest: 'bin/<%= pkg.name %>.js', 38 | options: { 39 | mangle: false, 40 | beautify: true, 41 | compress: false 42 | } 43 | }, 44 | minified: { 45 | src: 'tmp/<%= pkg.name %>-stripped.js', 46 | dest: 'bin/<%= pkg.name %>.min.js' 47 | }, 48 | }, 49 | qunit: { 50 | files: ['tests/**/*.html'] 51 | }, 52 | jshint: { 53 | options: { 54 | jshintrc: '.jshintrc' 55 | }, 56 | gruntfile: { 57 | src: 'Gruntfile.js' 58 | } 59 | }, 60 | coffeelint: { 61 | lib: ['lib/**/*.coffee'], 62 | options: { 63 | max_line_length: { 64 | value: 120, 65 | level: 'warn', 66 | message: 'Line exceeds maximum allowed length' 67 | } 68 | } 69 | }, 70 | watch: { 71 | gruntfile: { 72 | files: '<%= jshint.gruntfile.src %>', 73 | tasks: ['jshint:gruntfile'] 74 | }, 75 | lib: { 76 | files: 'lib/**/*.*', 77 | tasks: ['jshint', 'coffee'] 78 | } 79 | }, 80 | strip: { 81 | lib: { 82 | src: 'tmp/<%= pkg.name %>.js', 83 | dest: 'tmp/<%= pkg.name %>-stripped.js' 84 | } 85 | }, 86 | connect: { 87 | server: {} 88 | } 89 | }); 90 | 91 | // These plugins provide necessary tasks. 92 | grunt.loadNpmTasks('grunt-contrib-clean'); 93 | grunt.loadNpmTasks('grunt-contrib-coffee'); 94 | grunt.loadNpmTasks('grunt-contrib-concat'); 95 | grunt.loadNpmTasks('grunt-contrib-connect'); 96 | grunt.loadNpmTasks('grunt-contrib-jshint'); 97 | grunt.loadNpmTasks('grunt-contrib-qunit'); 98 | grunt.loadNpmTasks('grunt-contrib-uglify'); 99 | grunt.loadNpmTasks('grunt-contrib-watch'); 100 | grunt.loadNpmTasks('grunt-coffeelint'); 101 | 102 | // custom tasks 103 | grunt.registerTask('hint', ['jshint', 'coffeelint']); 104 | grunt.registerTask('test', ['coffee', 'qunit']); 105 | grunt.registerTask('default', ['clean', 'hint', 'coffee', 'qunit', 'strip', 'uglify']); 106 | 107 | grunt.registerMultiTask('strip', "Strip all Ember debug statements", function() { 108 | // make this configurable or better: create own Grunt.js task for this 109 | var debugStatements = [ 110 | "Ember.assert", 111 | "Ember.debug", 112 | "Ember.warn", 113 | "Ember.deprecate", 114 | "Ember.Logger.log", 115 | "Ember.Logger.warn", 116 | "Ember.Logger.error", 117 | "Ember.Logger.info", 118 | "Ember.Logger.debug", 119 | "console.log" 120 | ]; 121 | 122 | var stripped = function(src) { 123 | var falafel = require('falafel'); 124 | 125 | var isExpression = function(node) { return node.type === 'ExpressionStatement'; }; 126 | var isCallExpression = function(node) { return node.type === 'CallExpression'; }; 127 | var getCalleeExpression = function(node) { 128 | if (node.type === 'MemberExpression') { return getCalleeExpression(node.object) + '.' + node.property.name; } 129 | else if (node.type === 'Identifier') { return node.name; } 130 | }; 131 | var isEmberDebugStatement = function(node) { 132 | var callee = getCalleeExpression(node); 133 | return debugStatements.indexOf(callee) !== -1; 134 | }; 135 | 136 | return falafel(src, function (node) { 137 | if (isExpression(node) && isCallExpression(node.expression) && isEmberDebugStatement(node.expression.callee)) { 138 | node.update(""); 139 | } 140 | }); 141 | }; 142 | 143 | // TODO refactor this!! 144 | var output = stripped(grunt.file.read(this.data.src)); 145 | grunt.file.write(this.data.dest, output); 146 | }); 147 | }; 148 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Infinite Pagination for EmberJS 2 | ----- 3 | 4 | This adds infinite pagination to [Ember JS](http://emberjs.com/). It works, but it is a work in progress and maybe be riddled with bugs. 5 | 6 | Please add issues galore as I intend to make this good :smiley: 7 | 8 | ## Installation 9 | 10 | You can download the [latest version](https://raw.github.com/iHiD/ember-infinite-pagination/master/bin/ember-infinite-pagination.min.js) from Github. Don't link to this file as Github won't send JS headers. 11 | 12 | You also need jQuery.inView, which you can get the [latest version](https://raw.github.com/protonet/jquery.inview/master/jquery.inview.min.js) from their [Github Repository](https://github.com/protonet/jquery.inview). 13 | 14 | ## Usage 15 | 16 | In your route, you need to setup the controller to have the correct data. Simply pass in your store, model and controller, and the data will be loaded from your paginationParams (see under config). 17 | ``` javascript 18 | App.BlogPostsRoute = Ember.Route.extend({ 19 | setupController: function(controller) { 20 | IHID.InfinitePagination.setupRoute(App.BlogPost, controller) 21 | } 22 | }) 23 | ``` 24 | 25 | In your controller, extend the controller mixin: 26 | ``` javascript 27 | Meducation.ResourcesController = Ember.ArrayController.extend(IHID.InfinitePagination.ControllerMixin) 28 | ``` 29 | 30 | In your template, use the LoadMoreView, e.g.: 31 | 32 | ``` handlebars 33 | {{#each blog_post in controller}} 34 | {{render 'blog_post' blog_post}} 35 | {{/each}} 36 | 37 | {{view IHID.InfinitePagination.LoadMoreView}} 38 | ``` 39 | 40 | ## Configuration 41 | 42 | You can override certain options in the controller. 43 | 44 | ### Can I load more data? 45 | 46 | Specify whether more data can be loaded from the server. Defaults to: 47 | 48 | ``` javascript 49 | canLoadMore:function() { 50 | this.get('currentPage') < 10 51 | }.property('currentPage') 52 | ``` 53 | 54 | ### Changing the parameters 55 | 56 | By default, the current page is added to the request. You can add more parameters like so: 57 | ``` javascript 58 | paginationParams: function(){ 59 | $.extend(this._super(), {searchCriteria: $('.search').val()}) 60 | } 61 | ``` 62 | 63 | ### Searching 64 | 65 | There is some build in support for searching. To implement it, add the following to your view (you'll need a textbox with a class of search in your template). 66 | 67 | ``` javascript 68 | didInsertElement: function() { 69 | $('.search').keypress(function(){ 70 | Ember.tryInvoke(this.get('controller'), 'search') 71 | }) 72 | } 73 | ``` 74 | 75 | This resets the page to 1. You'll need to add whatever parameters you need as per above. 76 | 77 | ## Development 78 | 79 | This project uses [Grunt.js](http://gruntjs.com/), so after checking out the repo, a simple 80 | `npm install` will install all dependencies needed to build this library. 81 | 82 | The source files are located in `lib/src` and the tests are in `lib/tests`. 83 | 84 | To run the tests invoke `grunt test`. 85 | 86 | ## Contributing 87 | 88 | Add issues, send pull requests. All the normal stuff. VERY happy to hear from you! 89 | 90 | As normal: 91 | * Fork 92 | * Branch 93 | * Hack 94 | * Commit 95 | * Pull request 96 | 97 | ## Credit 98 | 99 | The original idea and code for this was by @pangratz. See [this Stack Overflow question](http://stackoverflow.com/questions/11907093/infinite-scroll-with-ember-js-lazy-loading) and [these](https://github.com/pangratz/dashboard/commit/68d1728ec26dae5062eae5be43d61083cfc34f14) [commits](https://github.com/iHiD/meducation_mobile_app/commit/8bd955df461f2813de643cc47b9d8e032b1cec9c) for history. I am now turning that into something more generic and maintainable. 100 | 101 | ## Licence 102 | Copyright (c) 2013 Jeremy Walker and contributors 103 | 104 | Permission is hereby granted, free of charge, to any person obtaining a copy of 105 | this software and associated documentation files (the "Software"), to deal in 106 | the Software without restriction, including without limitation the rights to 107 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 108 | of the Software, and to permit persons to whom the Software is furnished to do 109 | so, subject to the following conditions: 110 | 111 | The above copyright notice and this permission notice shall be included in all 112 | copies or substantial portions of the Software. 113 | 114 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 115 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 116 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 117 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 118 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 119 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 120 | SOFTWARE. 121 | -------------------------------------------------------------------------------- /tests/resources/qunit.css: -------------------------------------------------------------------------------- 1 | /** 2 | * QUnit v1.11.0 - A JavaScript Unit Testing Framework 3 | * 4 | * http://qunitjs.com 5 | * 6 | * Copyright 2012 jQuery Foundation and other contributors 7 | * Released under the MIT license. 8 | * http://jquery.org/license 9 | */ 10 | 11 | /** Font Family and Sizes */ 12 | 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult { 14 | font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif; 15 | } 16 | 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; } 18 | #qunit-tests { font-size: smaller; } 19 | 20 | 21 | /** Resets */ 22 | 23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter { 24 | margin: 0; 25 | padding: 0; 26 | } 27 | 28 | 29 | /** Header */ 30 | 31 | #qunit-header { 32 | padding: 0.5em 0 0.5em 1em; 33 | 34 | color: #8699a4; 35 | background-color: #0d3349; 36 | 37 | font-size: 1.5em; 38 | line-height: 1em; 39 | font-weight: normal; 40 | 41 | border-radius: 5px 5px 0 0; 42 | -moz-border-radius: 5px 5px 0 0; 43 | -webkit-border-top-right-radius: 5px; 44 | -webkit-border-top-left-radius: 5px; 45 | } 46 | 47 | #qunit-header a { 48 | text-decoration: none; 49 | color: #c2ccd1; 50 | } 51 | 52 | #qunit-header a:hover, 53 | #qunit-header a:focus { 54 | color: #fff; 55 | } 56 | 57 | #qunit-testrunner-toolbar label { 58 | display: inline-block; 59 | padding: 0 .5em 0 .1em; 60 | } 61 | 62 | #qunit-banner { 63 | height: 5px; 64 | } 65 | 66 | #qunit-testrunner-toolbar { 67 | padding: 0.5em 0 0.5em 2em; 68 | color: #5E740B; 69 | background-color: #eee; 70 | overflow: hidden; 71 | } 72 | 73 | #qunit-userAgent { 74 | padding: 0.5em 0 0.5em 2.5em; 75 | background-color: #2b81af; 76 | color: #fff; 77 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; 78 | } 79 | 80 | #qunit-modulefilter-container { 81 | float: right; 82 | } 83 | 84 | /** Tests: Pass/Fail */ 85 | 86 | #qunit-tests { 87 | list-style-position: inside; 88 | } 89 | 90 | #qunit-tests li { 91 | padding: 0.4em 0.5em 0.4em 2.5em; 92 | border-bottom: 1px solid #fff; 93 | list-style-position: inside; 94 | } 95 | 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running { 97 | display: none; 98 | } 99 | 100 | #qunit-tests li strong { 101 | cursor: pointer; 102 | } 103 | 104 | #qunit-tests li a { 105 | padding: 0.5em; 106 | color: #c2ccd1; 107 | text-decoration: none; 108 | } 109 | #qunit-tests li a:hover, 110 | #qunit-tests li a:focus { 111 | color: #000; 112 | } 113 | 114 | #qunit-tests li .runtime { 115 | float: right; 116 | font-size: smaller; 117 | } 118 | 119 | .qunit-assert-list { 120 | margin-top: 0.5em; 121 | padding: 0.5em; 122 | 123 | background-color: #fff; 124 | 125 | border-radius: 5px; 126 | -moz-border-radius: 5px; 127 | -webkit-border-radius: 5px; 128 | } 129 | 130 | .qunit-collapsed { 131 | display: none; 132 | } 133 | 134 | #qunit-tests table { 135 | border-collapse: collapse; 136 | margin-top: .2em; 137 | } 138 | 139 | #qunit-tests th { 140 | text-align: right; 141 | vertical-align: top; 142 | padding: 0 .5em 0 0; 143 | } 144 | 145 | #qunit-tests td { 146 | vertical-align: top; 147 | } 148 | 149 | #qunit-tests pre { 150 | margin: 0; 151 | white-space: pre-wrap; 152 | word-wrap: break-word; 153 | } 154 | 155 | #qunit-tests del { 156 | background-color: #e0f2be; 157 | color: #374e0c; 158 | text-decoration: none; 159 | } 160 | 161 | #qunit-tests ins { 162 | background-color: #ffcaca; 163 | color: #500; 164 | text-decoration: none; 165 | } 166 | 167 | /*** Test Counts */ 168 | 169 | #qunit-tests b.counts { color: black; } 170 | #qunit-tests b.passed { color: #5E740B; } 171 | #qunit-tests b.failed { color: #710909; } 172 | 173 | #qunit-tests li li { 174 | padding: 5px; 175 | background-color: #fff; 176 | border-bottom: none; 177 | list-style-position: inside; 178 | } 179 | 180 | /*** Passing Styles */ 181 | 182 | #qunit-tests li li.pass { 183 | color: #3c510c; 184 | background-color: #fff; 185 | border-left: 10px solid #C6E746; 186 | } 187 | 188 | #qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; } 189 | #qunit-tests .pass .test-name { color: #366097; } 190 | 191 | #qunit-tests .pass .test-actual, 192 | #qunit-tests .pass .test-expected { color: #999999; } 193 | 194 | #qunit-banner.qunit-pass { background-color: #C6E746; } 195 | 196 | /*** Failing Styles */ 197 | 198 | #qunit-tests li li.fail { 199 | color: #710909; 200 | background-color: #fff; 201 | border-left: 10px solid #EE5757; 202 | white-space: pre; 203 | } 204 | 205 | #qunit-tests > li:last-child { 206 | border-radius: 0 0 5px 5px; 207 | -moz-border-radius: 0 0 5px 5px; 208 | -webkit-border-bottom-right-radius: 5px; 209 | -webkit-border-bottom-left-radius: 5px; 210 | } 211 | 212 | #qunit-tests .fail { color: #000000; background-color: #EE5757; } 213 | #qunit-tests .fail .test-name, 214 | #qunit-tests .fail .module-name { color: #000000; } 215 | 216 | #qunit-tests .fail .test-actual { color: #EE5757; } 217 | #qunit-tests .fail .test-expected { color: green; } 218 | 219 | #qunit-banner.qunit-fail { background-color: #EE5757; } 220 | 221 | 222 | /** Result */ 223 | 224 | #qunit-testresult { 225 | padding: 0.5em 0.5em 0.5em 2.5em; 226 | 227 | color: #2b81af; 228 | background-color: #D2E0E6; 229 | 230 | border-bottom: 1px solid white; 231 | } 232 | #qunit-testresult .module-name { 233 | font-weight: bold; 234 | } 235 | 236 | /** Fixture */ 237 | 238 | #qunit-fixture { 239 | position: absolute; 240 | top: -10000px; 241 | left: -10000px; 242 | width: 1000px; 243 | height: 1000px; 244 | } 245 | -------------------------------------------------------------------------------- /tests/resources/qunit.js: -------------------------------------------------------------------------------- 1 | /** 2 | * QUnit v1.11.0 - A JavaScript Unit Testing Framework 3 | * 4 | * http://qunitjs.com 5 | * 6 | * Copyright 2012 jQuery Foundation and other contributors 7 | * Released under the MIT license. 8 | * http://jquery.org/license 9 | */ 10 | 11 | (function( window ) { 12 | 13 | var QUnit, 14 | assert, 15 | config, 16 | onErrorFnPrev, 17 | testId = 0, 18 | fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""), 19 | toString = Object.prototype.toString, 20 | hasOwn = Object.prototype.hasOwnProperty, 21 | // Keep a local reference to Date (GH-283) 22 | Date = window.Date, 23 | defined = { 24 | setTimeout: typeof window.setTimeout !== "undefined", 25 | sessionStorage: (function() { 26 | var x = "qunit-test-string"; 27 | try { 28 | sessionStorage.setItem( x, x ); 29 | sessionStorage.removeItem( x ); 30 | return true; 31 | } catch( e ) { 32 | return false; 33 | } 34 | }()) 35 | }, 36 | /** 37 | * Provides a normalized error string, correcting an issue 38 | * with IE 7 (and prior) where Error.prototype.toString is 39 | * not properly implemented 40 | * 41 | * Based on http://es5.github.com/#x15.11.4.4 42 | * 43 | * @param {String|Error} error 44 | * @return {String} error message 45 | */ 46 | errorString = function( error ) { 47 | var name, message, 48 | errorString = error.toString(); 49 | if ( errorString.substring( 0, 7 ) === "[object" ) { 50 | name = error.name ? error.name.toString() : "Error"; 51 | message = error.message ? error.message.toString() : ""; 52 | if ( name && message ) { 53 | return name + ": " + message; 54 | } else if ( name ) { 55 | return name; 56 | } else if ( message ) { 57 | return message; 58 | } else { 59 | return "Error"; 60 | } 61 | } else { 62 | return errorString; 63 | } 64 | }, 65 | /** 66 | * Makes a clone of an object using only Array or Object as base, 67 | * and copies over the own enumerable properties. 68 | * 69 | * @param {Object} obj 70 | * @return {Object} New object with only the own properties (recursively). 71 | */ 72 | objectValues = function( obj ) { 73 | // Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392. 74 | /*jshint newcap: false */ 75 | var key, val, 76 | vals = QUnit.is( "array", obj ) ? [] : {}; 77 | for ( key in obj ) { 78 | if ( hasOwn.call( obj, key ) ) { 79 | val = obj[key]; 80 | vals[key] = val === Object(val) ? objectValues(val) : val; 81 | } 82 | } 83 | return vals; 84 | }; 85 | 86 | function Test( settings ) { 87 | extend( this, settings ); 88 | this.assertions = []; 89 | this.testNumber = ++Test.count; 90 | } 91 | 92 | Test.count = 0; 93 | 94 | Test.prototype = { 95 | init: function() { 96 | var a, b, li, 97 | tests = id( "qunit-tests" ); 98 | 99 | if ( tests ) { 100 | b = document.createElement( "strong" ); 101 | b.innerHTML = this.nameHtml; 102 | 103 | // `a` initialized at top of scope 104 | a = document.createElement( "a" ); 105 | a.innerHTML = "Rerun"; 106 | a.href = QUnit.url({ testNumber: this.testNumber }); 107 | 108 | li = document.createElement( "li" ); 109 | li.appendChild( b ); 110 | li.appendChild( a ); 111 | li.className = "running"; 112 | li.id = this.id = "qunit-test-output" + testId++; 113 | 114 | tests.appendChild( li ); 115 | } 116 | }, 117 | setup: function() { 118 | if ( this.module !== config.previousModule ) { 119 | if ( config.previousModule ) { 120 | runLoggingCallbacks( "moduleDone", QUnit, { 121 | name: config.previousModule, 122 | failed: config.moduleStats.bad, 123 | passed: config.moduleStats.all - config.moduleStats.bad, 124 | total: config.moduleStats.all 125 | }); 126 | } 127 | config.previousModule = this.module; 128 | config.moduleStats = { all: 0, bad: 0 }; 129 | runLoggingCallbacks( "moduleStart", QUnit, { 130 | name: this.module 131 | }); 132 | } else if ( config.autorun ) { 133 | runLoggingCallbacks( "moduleStart", QUnit, { 134 | name: this.module 135 | }); 136 | } 137 | 138 | config.current = this; 139 | 140 | this.testEnvironment = extend({ 141 | setup: function() {}, 142 | teardown: function() {} 143 | }, this.moduleTestEnvironment ); 144 | 145 | this.started = +new Date(); 146 | runLoggingCallbacks( "testStart", QUnit, { 147 | name: this.testName, 148 | module: this.module 149 | }); 150 | 151 | // allow utility functions to access the current test environment 152 | // TODO why?? 153 | QUnit.current_testEnvironment = this.testEnvironment; 154 | 155 | if ( !config.pollution ) { 156 | saveGlobal(); 157 | } 158 | if ( config.notrycatch ) { 159 | this.testEnvironment.setup.call( this.testEnvironment ); 160 | return; 161 | } 162 | try { 163 | this.testEnvironment.setup.call( this.testEnvironment ); 164 | } catch( e ) { 165 | QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) ); 166 | } 167 | }, 168 | run: function() { 169 | config.current = this; 170 | 171 | var running = id( "qunit-testresult" ); 172 | 173 | if ( running ) { 174 | running.innerHTML = "Running:
" + this.nameHtml; 175 | } 176 | 177 | if ( this.async ) { 178 | QUnit.stop(); 179 | } 180 | 181 | this.callbackStarted = +new Date(); 182 | 183 | if ( config.notrycatch ) { 184 | this.callback.call( this.testEnvironment, QUnit.assert ); 185 | this.callbackRuntime = +new Date() - this.callbackStarted; 186 | return; 187 | } 188 | 189 | try { 190 | this.callback.call( this.testEnvironment, QUnit.assert ); 191 | this.callbackRuntime = +new Date() - this.callbackStarted; 192 | } catch( e ) { 193 | this.callbackRuntime = +new Date() - this.callbackStarted; 194 | 195 | QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) ); 196 | // else next test will carry the responsibility 197 | saveGlobal(); 198 | 199 | // Restart the tests if they're blocking 200 | if ( config.blocking ) { 201 | QUnit.start(); 202 | } 203 | } 204 | }, 205 | teardown: function() { 206 | config.current = this; 207 | if ( config.notrycatch ) { 208 | if ( typeof this.callbackRuntime === "undefined" ) { 209 | this.callbackRuntime = +new Date() - this.callbackStarted; 210 | } 211 | this.testEnvironment.teardown.call( this.testEnvironment ); 212 | return; 213 | } else { 214 | try { 215 | this.testEnvironment.teardown.call( this.testEnvironment ); 216 | } catch( e ) { 217 | QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) ); 218 | } 219 | } 220 | checkPollution(); 221 | }, 222 | finish: function() { 223 | config.current = this; 224 | if ( config.requireExpects && this.expected === null ) { 225 | QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack ); 226 | } else if ( this.expected !== null && this.expected !== this.assertions.length ) { 227 | QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack ); 228 | } else if ( this.expected === null && !this.assertions.length ) { 229 | QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack ); 230 | } 231 | 232 | var i, assertion, a, b, time, li, ol, 233 | test = this, 234 | good = 0, 235 | bad = 0, 236 | tests = id( "qunit-tests" ); 237 | 238 | this.runtime = +new Date() - this.started; 239 | config.stats.all += this.assertions.length; 240 | config.moduleStats.all += this.assertions.length; 241 | 242 | if ( tests ) { 243 | ol = document.createElement( "ol" ); 244 | ol.className = "qunit-assert-list"; 245 | 246 | for ( i = 0; i < this.assertions.length; i++ ) { 247 | assertion = this.assertions[i]; 248 | 249 | li = document.createElement( "li" ); 250 | li.className = assertion.result ? "pass" : "fail"; 251 | li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" ); 252 | ol.appendChild( li ); 253 | 254 | if ( assertion.result ) { 255 | good++; 256 | } else { 257 | bad++; 258 | config.stats.bad++; 259 | config.moduleStats.bad++; 260 | } 261 | } 262 | 263 | // store result when possible 264 | if ( QUnit.config.reorder && defined.sessionStorage ) { 265 | if ( bad ) { 266 | sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad ); 267 | } else { 268 | sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName ); 269 | } 270 | } 271 | 272 | if ( bad === 0 ) { 273 | addClass( ol, "qunit-collapsed" ); 274 | } 275 | 276 | // `b` initialized at top of scope 277 | b = document.createElement( "strong" ); 278 | b.innerHTML = this.nameHtml + " (" + bad + ", " + good + ", " + this.assertions.length + ")"; 279 | 280 | addEvent(b, "click", function() { 281 | var next = b.parentNode.lastChild, 282 | collapsed = hasClass( next, "qunit-collapsed" ); 283 | ( collapsed ? removeClass : addClass )( next, "qunit-collapsed" ); 284 | }); 285 | 286 | addEvent(b, "dblclick", function( e ) { 287 | var target = e && e.target ? e.target : window.event.srcElement; 288 | if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) { 289 | target = target.parentNode; 290 | } 291 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) { 292 | window.location = QUnit.url({ testNumber: test.testNumber }); 293 | } 294 | }); 295 | 296 | // `time` initialized at top of scope 297 | time = document.createElement( "span" ); 298 | time.className = "runtime"; 299 | time.innerHTML = this.runtime + " ms"; 300 | 301 | // `li` initialized at top of scope 302 | li = id( this.id ); 303 | li.className = bad ? "fail" : "pass"; 304 | li.removeChild( li.firstChild ); 305 | a = li.firstChild; 306 | li.appendChild( b ); 307 | li.appendChild( a ); 308 | li.appendChild( time ); 309 | li.appendChild( ol ); 310 | 311 | } else { 312 | for ( i = 0; i < this.assertions.length; i++ ) { 313 | if ( !this.assertions[i].result ) { 314 | bad++; 315 | config.stats.bad++; 316 | config.moduleStats.bad++; 317 | } 318 | } 319 | } 320 | 321 | runLoggingCallbacks( "testDone", QUnit, { 322 | name: this.testName, 323 | module: this.module, 324 | failed: bad, 325 | passed: this.assertions.length - bad, 326 | total: this.assertions.length, 327 | duration: this.runtime 328 | }); 329 | 330 | QUnit.reset(); 331 | 332 | config.current = undefined; 333 | }, 334 | 335 | queue: function() { 336 | var bad, 337 | test = this; 338 | 339 | synchronize(function() { 340 | test.init(); 341 | }); 342 | function run() { 343 | // each of these can by async 344 | synchronize(function() { 345 | test.setup(); 346 | }); 347 | synchronize(function() { 348 | test.run(); 349 | }); 350 | synchronize(function() { 351 | test.teardown(); 352 | }); 353 | synchronize(function() { 354 | test.finish(); 355 | }); 356 | } 357 | 358 | // `bad` initialized at top of scope 359 | // defer when previous test run passed, if storage is available 360 | bad = QUnit.config.reorder && defined.sessionStorage && 361 | +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName ); 362 | 363 | if ( bad ) { 364 | run(); 365 | } else { 366 | synchronize( run, true ); 367 | } 368 | } 369 | }; 370 | 371 | // Root QUnit object. 372 | // `QUnit` initialized at top of scope 373 | QUnit = { 374 | 375 | // call on start of module test to prepend name to all tests 376 | module: function( name, testEnvironment ) { 377 | config.currentModule = name; 378 | config.currentModuleTestEnvironment = testEnvironment; 379 | config.modules[name] = true; 380 | }, 381 | 382 | asyncTest: function( testName, expected, callback ) { 383 | if ( arguments.length === 2 ) { 384 | callback = expected; 385 | expected = null; 386 | } 387 | 388 | QUnit.test( testName, expected, callback, true ); 389 | }, 390 | 391 | test: function( testName, expected, callback, async ) { 392 | var test, 393 | nameHtml = "" + escapeText( testName ) + ""; 394 | 395 | if ( arguments.length === 2 ) { 396 | callback = expected; 397 | expected = null; 398 | } 399 | 400 | if ( config.currentModule ) { 401 | nameHtml = "" + escapeText( config.currentModule ) + ": " + nameHtml; 402 | } 403 | 404 | test = new Test({ 405 | nameHtml: nameHtml, 406 | testName: testName, 407 | expected: expected, 408 | async: async, 409 | callback: callback, 410 | module: config.currentModule, 411 | moduleTestEnvironment: config.currentModuleTestEnvironment, 412 | stack: sourceFromStacktrace( 2 ) 413 | }); 414 | 415 | if ( !validTest( test ) ) { 416 | return; 417 | } 418 | 419 | test.queue(); 420 | }, 421 | 422 | // Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through. 423 | expect: function( asserts ) { 424 | if (arguments.length === 1) { 425 | config.current.expected = asserts; 426 | } else { 427 | return config.current.expected; 428 | } 429 | }, 430 | 431 | start: function( count ) { 432 | // QUnit hasn't been initialized yet. 433 | // Note: RequireJS (et al) may delay onLoad 434 | if ( config.semaphore === undefined ) { 435 | QUnit.begin(function() { 436 | // This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first 437 | setTimeout(function() { 438 | QUnit.start( count ); 439 | }); 440 | }); 441 | return; 442 | } 443 | 444 | config.semaphore -= count || 1; 445 | // don't start until equal number of stop-calls 446 | if ( config.semaphore > 0 ) { 447 | return; 448 | } 449 | // ignore if start is called more often then stop 450 | if ( config.semaphore < 0 ) { 451 | config.semaphore = 0; 452 | QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) ); 453 | return; 454 | } 455 | // A slight delay, to avoid any current callbacks 456 | if ( defined.setTimeout ) { 457 | window.setTimeout(function() { 458 | if ( config.semaphore > 0 ) { 459 | return; 460 | } 461 | if ( config.timeout ) { 462 | clearTimeout( config.timeout ); 463 | } 464 | 465 | config.blocking = false; 466 | process( true ); 467 | }, 13); 468 | } else { 469 | config.blocking = false; 470 | process( true ); 471 | } 472 | }, 473 | 474 | stop: function( count ) { 475 | config.semaphore += count || 1; 476 | config.blocking = true; 477 | 478 | if ( config.testTimeout && defined.setTimeout ) { 479 | clearTimeout( config.timeout ); 480 | config.timeout = window.setTimeout(function() { 481 | QUnit.ok( false, "Test timed out" ); 482 | config.semaphore = 1; 483 | QUnit.start(); 484 | }, config.testTimeout ); 485 | } 486 | } 487 | }; 488 | 489 | // `assert` initialized at top of scope 490 | // Asssert helpers 491 | // All of these must either call QUnit.push() or manually do: 492 | // - runLoggingCallbacks( "log", .. ); 493 | // - config.current.assertions.push({ .. }); 494 | // We attach it to the QUnit object *after* we expose the public API, 495 | // otherwise `assert` will become a global variable in browsers (#341). 496 | assert = { 497 | /** 498 | * Asserts rough true-ish result. 499 | * @name ok 500 | * @function 501 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); 502 | */ 503 | ok: function( result, msg ) { 504 | if ( !config.current ) { 505 | throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) ); 506 | } 507 | result = !!result; 508 | 509 | var source, 510 | details = { 511 | module: config.current.module, 512 | name: config.current.testName, 513 | result: result, 514 | message: msg 515 | }; 516 | 517 | msg = escapeText( msg || (result ? "okay" : "failed" ) ); 518 | msg = "" + msg + ""; 519 | 520 | if ( !result ) { 521 | source = sourceFromStacktrace( 2 ); 522 | if ( source ) { 523 | details.source = source; 524 | msg += "

Source:	" + escapeText( source ) + "

"; 525 | } 526 | } 527 | runLoggingCallbacks( "log", QUnit, details ); 528 | config.current.assertions.push({ 529 | result: result, 530 | message: msg 531 | }); 532 | }, 533 | 534 | /** 535 | * Assert that the first two arguments are equal, with an optional message. 536 | * Prints out both actual and expected values. 537 | * @name equal 538 | * @function 539 | * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" ); 540 | */ 541 | equal: function( actual, expected, message ) { 542 | /*jshint eqeqeq:false */ 543 | QUnit.push( expected == actual, actual, expected, message ); 544 | }, 545 | 546 | /** 547 | * @name notEqual 548 | * @function 549 | */ 550 | notEqual: function( actual, expected, message ) { 551 | /*jshint eqeqeq:false */ 552 | QUnit.push( expected != actual, actual, expected, message ); 553 | }, 554 | 555 | /** 556 | * @name propEqual 557 | * @function 558 | */ 559 | propEqual: function( actual, expected, message ) { 560 | actual = objectValues(actual); 561 | expected = objectValues(expected); 562 | QUnit.push( QUnit.equiv(actual, expected), actual, expected, message ); 563 | }, 564 | 565 | /** 566 | * @name notPropEqual 567 | * @function 568 | */ 569 | notPropEqual: function( actual, expected, message ) { 570 | actual = objectValues(actual); 571 | expected = objectValues(expected); 572 | QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message ); 573 | }, 574 | 575 | /** 576 | * @name deepEqual 577 | * @function 578 | */ 579 | deepEqual: function( actual, expected, message ) { 580 | QUnit.push( QUnit.equiv(actual, expected), actual, expected, message ); 581 | }, 582 | 583 | /** 584 | * @name notDeepEqual 585 | * @function 586 | */ 587 | notDeepEqual: function( actual, expected, message ) { 588 | QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message ); 589 | }, 590 | 591 | /** 592 | * @name strictEqual 593 | * @function 594 | */ 595 | strictEqual: function( actual, expected, message ) { 596 | QUnit.push( expected === actual, actual, expected, message ); 597 | }, 598 | 599 | /** 600 | * @name notStrictEqual 601 | * @function 602 | */ 603 | notStrictEqual: function( actual, expected, message ) { 604 | QUnit.push( expected !== actual, actual, expected, message ); 605 | }, 606 | 607 | "throws": function( block, expected, message ) { 608 | var actual, 609 | expectedOutput = expected, 610 | ok = false; 611 | 612 | // 'expected' is optional 613 | if ( typeof expected === "string" ) { 614 | message = expected; 615 | expected = null; 616 | } 617 | 618 | config.current.ignoreGlobalErrors = true; 619 | try { 620 | block.call( config.current.testEnvironment ); 621 | } catch (e) { 622 | actual = e; 623 | } 624 | config.current.ignoreGlobalErrors = false; 625 | 626 | if ( actual ) { 627 | // we don't want to validate thrown error 628 | if ( !expected ) { 629 | ok = true; 630 | expectedOutput = null; 631 | // expected is a regexp 632 | } else if ( QUnit.objectType( expected ) === "regexp" ) { 633 | ok = expected.test( errorString( actual ) ); 634 | // expected is a constructor 635 | } else if ( actual instanceof expected ) { 636 | ok = true; 637 | // expected is a validation function which returns true is validation passed 638 | } else if ( expected.call( {}, actual ) === true ) { 639 | expectedOutput = null; 640 | ok = true; 641 | } 642 | 643 | QUnit.push( ok, actual, expectedOutput, message ); 644 | } else { 645 | QUnit.pushFailure( message, null, 'No exception was thrown.' ); 646 | } 647 | } 648 | }; 649 | 650 | /** 651 | * @deprecate since 1.8.0 652 | * Kept assertion helpers in root for backwards compatibility. 653 | */ 654 | extend( QUnit, assert ); 655 | 656 | /** 657 | * @deprecated since 1.9.0 658 | * Kept root "raises()" for backwards compatibility. 659 | * (Note that we don't introduce assert.raises). 660 | */ 661 | QUnit.raises = assert[ "throws" ]; 662 | 663 | /** 664 | * @deprecated since 1.0.0, replaced with error pushes since 1.3.0 665 | * Kept to avoid TypeErrors for undefined methods. 666 | */ 667 | QUnit.equals = function() { 668 | QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" ); 669 | }; 670 | QUnit.same = function() { 671 | QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" ); 672 | }; 673 | 674 | // We want access to the constructor's prototype 675 | (function() { 676 | function F() {} 677 | F.prototype = QUnit; 678 | QUnit = new F(); 679 | // Make F QUnit's constructor so that we can add to the prototype later 680 | QUnit.constructor = F; 681 | }()); 682 | 683 | /** 684 | * Config object: Maintain internal state 685 | * Later exposed as QUnit.config 686 | * `config` initialized at top of scope 687 | */ 688 | config = { 689 | // The queue of tests to run 690 | queue: [], 691 | 692 | // block until document ready 693 | blocking: true, 694 | 695 | // when enabled, show only failing tests 696 | // gets persisted through sessionStorage and can be changed in UI via checkbox 697 | hidepassed: false, 698 | 699 | // by default, run previously failed tests first 700 | // very useful in combination with "Hide passed tests" checked 701 | reorder: true, 702 | 703 | // by default, modify document.title when suite is done 704 | altertitle: true, 705 | 706 | // when enabled, all tests must call expect() 707 | requireExpects: false, 708 | 709 | // add checkboxes that are persisted in the query-string 710 | // when enabled, the id is set to `true` as a `QUnit.config` property 711 | urlConfig: [ 712 | { 713 | id: "noglobals", 714 | label: "Check for Globals", 715 | tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings." 716 | }, 717 | { 718 | id: "notrycatch", 719 | label: "No try-catch", 720 | tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings." 721 | } 722 | ], 723 | 724 | // Set of all modules. 725 | modules: {}, 726 | 727 | // logging callback queues 728 | begin: [], 729 | done: [], 730 | log: [], 731 | testStart: [], 732 | testDone: [], 733 | moduleStart: [], 734 | moduleDone: [] 735 | }; 736 | 737 | // Export global variables, unless an 'exports' object exists, 738 | // in that case we assume we're in CommonJS (dealt with on the bottom of the script) 739 | if ( typeof exports === "undefined" ) { 740 | extend( window, QUnit ); 741 | 742 | // Expose QUnit object 743 | window.QUnit = QUnit; 744 | } 745 | 746 | // Initialize more QUnit.config and QUnit.urlParams 747 | (function() { 748 | var i, 749 | location = window.location || { search: "", protocol: "file:" }, 750 | params = location.search.slice( 1 ).split( "&" ), 751 | length = params.length, 752 | urlParams = {}, 753 | current; 754 | 755 | if ( params[ 0 ] ) { 756 | for ( i = 0; i < length; i++ ) { 757 | current = params[ i ].split( "=" ); 758 | current[ 0 ] = decodeURIComponent( current[ 0 ] ); 759 | // allow just a key to turn on a flag, e.g., test.html?noglobals 760 | current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true; 761 | urlParams[ current[ 0 ] ] = current[ 1 ]; 762 | } 763 | } 764 | 765 | QUnit.urlParams = urlParams; 766 | 767 | // String search anywhere in moduleName+testName 768 | config.filter = urlParams.filter; 769 | 770 | // Exact match of the module name 771 | config.module = urlParams.module; 772 | 773 | config.testNumber = parseInt( urlParams.testNumber, 10 ) || null; 774 | 775 | // Figure out if we're running the tests from a server or not 776 | QUnit.isLocal = location.protocol === "file:"; 777 | }()); 778 | 779 | // Extend QUnit object, 780 | // these after set here because they should not be exposed as global functions 781 | extend( QUnit, { 782 | assert: assert, 783 | 784 | config: config, 785 | 786 | // Initialize the configuration options 787 | init: function() { 788 | extend( config, { 789 | stats: { all: 0, bad: 0 }, 790 | moduleStats: { all: 0, bad: 0 }, 791 | started: +new Date(), 792 | updateRate: 1000, 793 | blocking: false, 794 | autostart: true, 795 | autorun: false, 796 | filter: "", 797 | queue: [], 798 | semaphore: 1 799 | }); 800 | 801 | var tests, banner, result, 802 | qunit = id( "qunit" ); 803 | 804 | if ( qunit ) { 805 | qunit.innerHTML = 806 | "

" + escapeText( document.title ) + "

" + 807 | "" + 808 | "" + 809 | "

" + 810 | "

"; 811 | } 812 | 813 | tests = id( "qunit-tests" ); 814 | banner = id( "qunit-banner" ); 815 | result = id( "qunit-testresult" ); 816 | 817 | if ( tests ) { 818 | tests.innerHTML = ""; 819 | } 820 | 821 | if ( banner ) { 822 | banner.className = ""; 823 | } 824 | 825 | if ( result ) { 826 | result.parentNode.removeChild( result ); 827 | } 828 | 829 | if ( tests ) { 830 | result = document.createElement( "p" ); 831 | result.id = "qunit-testresult"; 832 | result.className = "result"; 833 | tests.parentNode.insertBefore( result, tests ); 834 | result.innerHTML = "Running...
"; 835 | } 836 | }, 837 | 838 | // Resets the test setup. Useful for tests that modify the DOM. 839 | reset: function() { 840 | var fixture = id( "qunit-fixture" ); 841 | if ( fixture ) { 842 | fixture.innerHTML = config.fixture; 843 | } 844 | }, 845 | 846 | // Trigger an event on an element. 847 | // @example triggerEvent( document.body, "click" ); 848 | triggerEvent: function( elem, type, event ) { 849 | if ( document.createEvent ) { 850 | event = document.createEvent( "MouseEvents" ); 851 | event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView, 852 | 0, 0, 0, 0, 0, false, false, false, false, 0, null); 853 | 854 | elem.dispatchEvent( event ); 855 | } else if ( elem.fireEvent ) { 856 | elem.fireEvent( "on" + type ); 857 | } 858 | }, 859 | 860 | // Safe object type checking 861 | is: function( type, obj ) { 862 | return QUnit.objectType( obj ) === type; 863 | }, 864 | 865 | objectType: function( obj ) { 866 | if ( typeof obj === "undefined" ) { 867 | return "undefined"; 868 | // consider: typeof null === object 869 | } 870 | if ( obj === null ) { 871 | return "null"; 872 | } 873 | 874 | var match = toString.call( obj ).match(/^\[object\s(.*)\]$/), 875 | type = match && match[1] || ""; 876 | 877 | switch ( type ) { 878 | case "Number": 879 | if ( isNaN(obj) ) { 880 | return "nan"; 881 | } 882 | return "number"; 883 | case "String": 884 | case "Boolean": 885 | case "Array": 886 | case "Date": 887 | case "RegExp": 888 | case "Function": 889 | return type.toLowerCase(); 890 | } 891 | if ( typeof obj === "object" ) { 892 | return "object"; 893 | } 894 | return undefined; 895 | }, 896 | 897 | push: function( result, actual, expected, message ) { 898 | if ( !config.current ) { 899 | throw new Error( "assertion outside test context, was " + sourceFromStacktrace() ); 900 | } 901 | 902 | var output, source, 903 | details = { 904 | module: config.current.module, 905 | name: config.current.testName, 906 | result: result, 907 | message: message, 908 | actual: actual, 909 | expected: expected 910 | }; 911 | 912 | message = escapeText( message ) || ( result ? "okay" : "failed" ); 913 | message = "" + message + ""; 914 | output = message; 915 | 916 | if ( !result ) { 917 | expected = escapeText( QUnit.jsDump.parse(expected) ); 918 | actual = escapeText( QUnit.jsDump.parse(actual) ); 919 | output += ""; 920 | 921 | if ( actual !== expected ) { 922 | output += ""; 923 | output += ""; 924 | } 925 | 926 | source = sourceFromStacktrace(); 927 | 928 | if ( source ) { 929 | details.source = source; 930 | output += ""; 931 | } 932 | 933 | output += "

Expected:	" + expected + "
Result:	" + actual + "
Diff:	" + QUnit.diff( expected, actual ) + "
Source:	" + escapeText( source ) + "

"; 934 | } 935 | 936 | runLoggingCallbacks( "log", QUnit, details ); 937 | 938 | config.current.assertions.push({ 939 | result: !!result, 940 | message: output 941 | }); 942 | }, 943 | 944 | pushFailure: function( message, source, actual ) { 945 | if ( !config.current ) { 946 | throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) ); 947 | } 948 | 949 | var output, 950 | details = { 951 | module: config.current.module, 952 | name: config.current.testName, 953 | result: false, 954 | message: message 955 | }; 956 | 957 | message = escapeText( message ) || "error"; 958 | message = "" + message + ""; 959 | output = message; 960 | 961 | output += ""; 962 | 963 | if ( actual ) { 964 | output += ""; 965 | } 966 | 967 | if ( source ) { 968 | details.source = source; 969 | output += ""; 970 | } 971 | 972 | output += "

Result:	" + escapeText( actual ) + "
Source:	" + escapeText( source ) + "

"; 973 | 974 | runLoggingCallbacks( "log", QUnit, details ); 975 | 976 | config.current.assertions.push({ 977 | result: false, 978 | message: output 979 | }); 980 | }, 981 | 982 | url: function( params ) { 983 | params = extend( extend( {}, QUnit.urlParams ), params ); 984 | var key, 985 | querystring = "?"; 986 | 987 | for ( key in params ) { 988 | if ( !hasOwn.call( params, key ) ) { 989 | continue; 990 | } 991 | querystring += encodeURIComponent( key ) + "=" + 992 | encodeURIComponent( params[ key ] ) + "&"; 993 | } 994 | return window.location.protocol + "//" + window.location.host + 995 | window.location.pathname + querystring.slice( 0, -1 ); 996 | }, 997 | 998 | extend: extend, 999 | id: id, 1000 | addEvent: addEvent 1001 | // load, equiv, jsDump, diff: Attached later 1002 | }); 1003 | 1004 | /** 1005 | * @deprecated: Created for backwards compatibility with test runner that set the hook function 1006 | * into QUnit.{hook}, instead of invoking it and passing the hook function. 1007 | * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here. 1008 | * Doing this allows us to tell if the following methods have been overwritten on the actual 1009 | * QUnit object. 1010 | */ 1011 | extend( QUnit.constructor.prototype, { 1012 | 1013 | // Logging callbacks; all receive a single argument with the listed properties 1014 | // run test/logs.html for any related changes 1015 | begin: registerLoggingCallback( "begin" ), 1016 | 1017 | // done: { failed, passed, total, runtime } 1018 | done: registerLoggingCallback( "done" ), 1019 | 1020 | // log: { result, actual, expected, message } 1021 | log: registerLoggingCallback( "log" ), 1022 | 1023 | // testStart: { name } 1024 | testStart: registerLoggingCallback( "testStart" ), 1025 | 1026 | // testDone: { name, failed, passed, total, duration } 1027 | testDone: registerLoggingCallback( "testDone" ), 1028 | 1029 | // moduleStart: { name } 1030 | moduleStart: registerLoggingCallback( "moduleStart" ), 1031 | 1032 | // moduleDone: { name, failed, passed, total } 1033 | moduleDone: registerLoggingCallback( "moduleDone" ) 1034 | }); 1035 | 1036 | if ( typeof document === "undefined" || document.readyState === "complete" ) { 1037 | config.autorun = true; 1038 | } 1039 | 1040 | QUnit.load = function() { 1041 | runLoggingCallbacks( "begin", QUnit, {} ); 1042 | 1043 | // Initialize the config, saving the execution queue 1044 | var banner, filter, i, label, len, main, ol, toolbar, userAgent, val, 1045 | urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter, 1046 | numModules = 0, 1047 | moduleFilterHtml = "", 1048 | urlConfigHtml = "", 1049 | oldconfig = extend( {}, config ); 1050 | 1051 | QUnit.init(); 1052 | extend(config, oldconfig); 1053 | 1054 | config.blocking = false; 1055 | 1056 | len = config.urlConfig.length; 1057 | 1058 | for ( i = 0; i < len; i++ ) { 1059 | val = config.urlConfig[i]; 1060 | if ( typeof val === "string" ) { 1061 | val = { 1062 | id: val, 1063 | label: val, 1064 | tooltip: "[no tooltip available]" 1065 | }; 1066 | } 1067 | config[ val.id ] = QUnit.urlParams[ val.id ]; 1068 | urlConfigHtml += "" + val.label + ""; 1074 | } 1075 | 1076 | moduleFilterHtml += "Module: "; 1089 | 1090 | // `userAgent` initialized at top of scope 1091 | userAgent = id( "qunit-userAgent" ); 1092 | if ( userAgent ) { 1093 | userAgent.innerHTML = navigator.userAgent; 1094 | } 1095 | 1096 | // `banner` initialized at top of scope 1097 | banner = id( "qunit-header" ); 1098 | if ( banner ) { 1099 | banner.innerHTML = "" + banner.innerHTML + " "; 1100 | } 1101 | 1102 | // `toolbar` initialized at top of scope 1103 | toolbar = id( "qunit-testrunner-toolbar" ); 1104 | if ( toolbar ) { 1105 | // `filter` initialized at top of scope 1106 | filter = document.createElement( "input" ); 1107 | filter.type = "checkbox"; 1108 | filter.id = "qunit-filter-pass"; 1109 | 1110 | addEvent( filter, "click", function() { 1111 | var tmp, 1112 | ol = document.getElementById( "qunit-tests" ); 1113 | 1114 | if ( filter.checked ) { 1115 | ol.className = ol.className + " hidepass"; 1116 | } else { 1117 | tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " "; 1118 | ol.className = tmp.replace( / hidepass /, " " ); 1119 | } 1120 | if ( defined.sessionStorage ) { 1121 | if (filter.checked) { 1122 | sessionStorage.setItem( "qunit-filter-passed-tests", "true" ); 1123 | } else { 1124 | sessionStorage.removeItem( "qunit-filter-passed-tests" ); 1125 | } 1126 | } 1127 | }); 1128 | 1129 | if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) { 1130 | filter.checked = true; 1131 | // `ol` initialized at top of scope 1132 | ol = document.getElementById( "qunit-tests" ); 1133 | ol.className = ol.className + " hidepass"; 1134 | } 1135 | toolbar.appendChild( filter ); 1136 | 1137 | // `label` initialized at top of scope 1138 | label = document.createElement( "label" ); 1139 | label.setAttribute( "for", "qunit-filter-pass" ); 1140 | label.setAttribute( "title", "Only show tests and assertons that fail. Stored in sessionStorage." ); 1141 | label.innerHTML = "Hide passed tests"; 1142 | toolbar.appendChild( label ); 1143 | 1144 | urlConfigCheckboxesContainer = document.createElement("span"); 1145 | urlConfigCheckboxesContainer.innerHTML = urlConfigHtml; 1146 | urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input"); 1147 | // For oldIE support: 1148 | // * Add handlers to the individual elements instead of the container 1149 | // * Use "click" instead of "change" 1150 | // * Fallback from event.target to event.srcElement 1151 | addEvents( urlConfigCheckboxes, "click", function( event ) { 1152 | var params = {}, 1153 | target = event.target || event.srcElement; 1154 | params[ target.name ] = target.checked ? true : undefined; 1155 | window.location = QUnit.url( params ); 1156 | }); 1157 | toolbar.appendChild( urlConfigCheckboxesContainer ); 1158 | 1159 | if (numModules > 1) { 1160 | moduleFilter = document.createElement( 'span' ); 1161 | moduleFilter.setAttribute( 'id', 'qunit-modulefilter-container' ); 1162 | moduleFilter.innerHTML = moduleFilterHtml; 1163 | addEvent( moduleFilter.lastChild, "change", function() { 1164 | var selectBox = moduleFilter.getElementsByTagName("select")[0], 1165 | selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value); 1166 | 1167 | window.location = QUnit.url( { module: ( selectedModule === "" ) ? undefined : selectedModule } ); 1168 | }); 1169 | toolbar.appendChild(moduleFilter); 1170 | } 1171 | } 1172 | 1173 | // `main` initialized at top of scope 1174 | main = id( "qunit-fixture" ); 1175 | if ( main ) { 1176 | config.fixture = main.innerHTML; 1177 | } 1178 | 1179 | if ( config.autostart ) { 1180 | QUnit.start(); 1181 | } 1182 | }; 1183 | 1184 | addEvent( window, "load", QUnit.load ); 1185 | 1186 | // `onErrorFnPrev` initialized at top of scope 1187 | // Preserve other handlers 1188 | onErrorFnPrev = window.onerror; 1189 | 1190 | // Cover uncaught exceptions 1191 | // Returning true will surpress the default browser handler, 1192 | // returning false will let it run. 1193 | window.onerror = function ( error, filePath, linerNr ) { 1194 | var ret = false; 1195 | if ( onErrorFnPrev ) { 1196 | ret = onErrorFnPrev( error, filePath, linerNr ); 1197 | } 1198 | 1199 | // Treat return value as window.onerror itself does, 1200 | // Only do our handling if not surpressed. 1201 | if ( ret !== true ) { 1202 | if ( QUnit.config.current ) { 1203 | if ( QUnit.config.current.ignoreGlobalErrors ) { 1204 | return true; 1205 | } 1206 | QUnit.pushFailure( error, filePath + ":" + linerNr ); 1207 | } else { 1208 | QUnit.test( "global failure", extend( function() { 1209 | QUnit.pushFailure( error, filePath + ":" + linerNr ); 1210 | }, { validTest: validTest } ) ); 1211 | } 1212 | return false; 1213 | } 1214 | 1215 | return ret; 1216 | }; 1217 | 1218 | function done() { 1219 | config.autorun = true; 1220 | 1221 | // Log the last module results 1222 | if ( config.currentModule ) { 1223 | runLoggingCallbacks( "moduleDone", QUnit, { 1224 | name: config.currentModule, 1225 | failed: config.moduleStats.bad, 1226 | passed: config.moduleStats.all - config.moduleStats.bad, 1227 | total: config.moduleStats.all 1228 | }); 1229 | } 1230 | 1231 | var i, key, 1232 | banner = id( "qunit-banner" ), 1233 | tests = id( "qunit-tests" ), 1234 | runtime = +new Date() - config.started, 1235 | passed = config.stats.all - config.stats.bad, 1236 | html = [ 1237 | "Tests completed in ", 1238 | runtime, 1239 | " milliseconds.
", 1240 | "", 1241 | passed, 1242 | " assertions of ", 1243 | config.stats.all, 1244 | " passed, ", 1245 | config.stats.bad, 1246 | " failed." 1247 | ].join( "" ); 1248 | 1249 | if ( banner ) { 1250 | banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" ); 1251 | } 1252 | 1253 | if ( tests ) { 1254 | id( "qunit-testresult" ).innerHTML = html; 1255 | } 1256 | 1257 | if ( config.altertitle && typeof document !== "undefined" && document.title ) { 1258 | // show ✖ for good, ✔ for bad suite result in title 1259 | // use escape sequences in case file gets loaded with non-utf-8-charset 1260 | document.title = [ 1261 | ( config.stats.bad ? "\u2716" : "\u2714" ), 1262 | document.title.replace( /^[\u2714\u2716] /i, "" ) 1263 | ].join( " " ); 1264 | } 1265 | 1266 | // clear own sessionStorage items if all tests passed 1267 | if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) { 1268 | // `key` & `i` initialized at top of scope 1269 | for ( i = 0; i < sessionStorage.length; i++ ) { 1270 | key = sessionStorage.key( i++ ); 1271 | if ( key.indexOf( "qunit-test-" ) === 0 ) { 1272 | sessionStorage.removeItem( key ); 1273 | } 1274 | } 1275 | } 1276 | 1277 | // scroll back to top to show results 1278 | if ( window.scrollTo ) { 1279 | window.scrollTo(0, 0); 1280 | } 1281 | 1282 | runLoggingCallbacks( "done", QUnit, { 1283 | failed: config.stats.bad, 1284 | passed: passed, 1285 | total: config.stats.all, 1286 | runtime: runtime 1287 | }); 1288 | } 1289 | 1290 | /** @return Boolean: true if this test should be ran */ 1291 | function validTest( test ) { 1292 | var include, 1293 | filter = config.filter && config.filter.toLowerCase(), 1294 | module = config.module && config.module.toLowerCase(), 1295 | fullName = (test.module + ": " + test.testName).toLowerCase(); 1296 | 1297 | // Internally-generated tests are always valid 1298 | if ( test.callback && test.callback.validTest === validTest ) { 1299 | delete test.callback.validTest; 1300 | return true; 1301 | } 1302 | 1303 | if ( config.testNumber ) { 1304 | return test.testNumber === config.testNumber; 1305 | } 1306 | 1307 | if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) { 1308 | return false; 1309 | } 1310 | 1311 | if ( !filter ) { 1312 | return true; 1313 | } 1314 | 1315 | include = filter.charAt( 0 ) !== "!"; 1316 | if ( !include ) { 1317 | filter = filter.slice( 1 ); 1318 | } 1319 | 1320 | // If the filter matches, we need to honour include 1321 | if ( fullName.indexOf( filter ) !== -1 ) { 1322 | return include; 1323 | } 1324 | 1325 | // Otherwise, do the opposite 1326 | return !include; 1327 | } 1328 | 1329 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions) 1330 | // Later Safari and IE10 are supposed to support error.stack as well 1331 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack 1332 | function extractStacktrace( e, offset ) { 1333 | offset = offset === undefined ? 3 : offset; 1334 | 1335 | var stack, include, i; 1336 | 1337 | if ( e.stacktrace ) { 1338 | // Opera 1339 | return e.stacktrace.split( "\n" )[ offset + 3 ]; 1340 | } else if ( e.stack ) { 1341 | // Firefox, Chrome 1342 | stack = e.stack.split( "\n" ); 1343 | if (/^error$/i.test( stack[0] ) ) { 1344 | stack.shift(); 1345 | } 1346 | if ( fileName ) { 1347 | include = []; 1348 | for ( i = offset; i < stack.length; i++ ) { 1349 | if ( stack[ i ].indexOf( fileName ) !== -1 ) { 1350 | break; 1351 | } 1352 | include.push( stack[ i ] ); 1353 | } 1354 | if ( include.length ) { 1355 | return include.join( "\n" ); 1356 | } 1357 | } 1358 | return stack[ offset ]; 1359 | } else if ( e.sourceURL ) { 1360 | // Safari, PhantomJS 1361 | // hopefully one day Safari provides actual stacktraces 1362 | // exclude useless self-reference for generated Error objects 1363 | if ( /qunit.js$/.test( e.sourceURL ) ) { 1364 | return; 1365 | } 1366 | // for actual exceptions, this is useful 1367 | return e.sourceURL + ":" + e.line; 1368 | } 1369 | } 1370 | function sourceFromStacktrace( offset ) { 1371 | try { 1372 | throw new Error(); 1373 | } catch ( e ) { 1374 | return extractStacktrace( e, offset ); 1375 | } 1376 | } 1377 | 1378 | /** 1379 | * Escape text for attribute or text content. 1380 | */ 1381 | function escapeText( s ) { 1382 | if ( !s ) { 1383 | return ""; 1384 | } 1385 | s = s + ""; 1386 | // Both single quotes and double quotes (for attributes) 1387 | return s.replace( /['"<>&]/g, function( s ) { 1388 | switch( s ) { 1389 | case '\'': 1390 | return '''; 1391 | case '"': 1392 | return '"'; 1393 | case '<': 1394 | return '<'; 1395 | case '>': 1396 | return '>'; 1397 | case '&': 1398 | return '&'; 1399 | } 1400 | }); 1401 | } 1402 | 1403 | function synchronize( callback, last ) { 1404 | config.queue.push( callback ); 1405 | 1406 | if ( config.autorun && !config.blocking ) { 1407 | process( last ); 1408 | } 1409 | } 1410 | 1411 | function process( last ) { 1412 | function next() { 1413 | process( last ); 1414 | } 1415 | var start = new Date().getTime(); 1416 | config.depth = config.depth ? config.depth + 1 : 1; 1417 | 1418 | while ( config.queue.length && !config.blocking ) { 1419 | if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) { 1420 | config.queue.shift()(); 1421 | } else { 1422 | window.setTimeout( next, 13 ); 1423 | break; 1424 | } 1425 | } 1426 | config.depth--; 1427 | if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) { 1428 | done(); 1429 | } 1430 | } 1431 | 1432 | function saveGlobal() { 1433 | config.pollution = []; 1434 | 1435 | if ( config.noglobals ) { 1436 | for ( var key in window ) { 1437 | // in Opera sometimes DOM element ids show up here, ignore them 1438 | if ( !hasOwn.call( window, key ) || /^qunit-test-output/.test( key ) ) { 1439 | continue; 1440 | } 1441 | config.pollution.push( key ); 1442 | } 1443 | } 1444 | } 1445 | 1446 | function checkPollution() { 1447 | var newGlobals, 1448 | deletedGlobals, 1449 | old = config.pollution; 1450 | 1451 | saveGlobal(); 1452 | 1453 | newGlobals = diff( config.pollution, old ); 1454 | if ( newGlobals.length > 0 ) { 1455 | QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") ); 1456 | } 1457 | 1458 | deletedGlobals = diff( old, config.pollution ); 1459 | if ( deletedGlobals.length > 0 ) { 1460 | QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") ); 1461 | } 1462 | } 1463 | 1464 | // returns a new Array with the elements that are in a but not in b 1465 | function diff( a, b ) { 1466 | var i, j, 1467 | result = a.slice(); 1468 | 1469 | for ( i = 0; i < result.length; i++ ) { 1470 | for ( j = 0; j < b.length; j++ ) { 1471 | if ( result[i] === b[j] ) { 1472 | result.splice( i, 1 ); 1473 | i--; 1474 | break; 1475 | } 1476 | } 1477 | } 1478 | return result; 1479 | } 1480 | 1481 | function extend( a, b ) { 1482 | for ( var prop in b ) { 1483 | if ( b[ prop ] === undefined ) { 1484 | delete a[ prop ]; 1485 | 1486 | // Avoid "Member not found" error in IE8 caused by setting window.constructor 1487 | } else if ( prop !== "constructor" || a !== window ) { 1488 | a[ prop ] = b[ prop ]; 1489 | } 1490 | } 1491 | 1492 | return a; 1493 | } 1494 | 1495 | /** 1496 | * @param {HTMLElement} elem 1497 | * @param {string} type 1498 | * @param {Function} fn 1499 | */ 1500 | function addEvent( elem, type, fn ) { 1501 | // Standards-based browsers 1502 | if ( elem.addEventListener ) { 1503 | elem.addEventListener( type, fn, false ); 1504 | // IE 1505 | } else { 1506 | elem.attachEvent( "on" + type, fn ); 1507 | } 1508 | } 1509 | 1510 | /** 1511 | * @param {Array|NodeList} elems 1512 | * @param {string} type 1513 | * @param {Function} fn 1514 | */ 1515 | function addEvents( elems, type, fn ) { 1516 | var i = elems.length; 1517 | while ( i-- ) { 1518 | addEvent( elems[i], type, fn ); 1519 | } 1520 | } 1521 | 1522 | function hasClass( elem, name ) { 1523 | return (" " + elem.className + " ").indexOf(" " + name + " ") > -1; 1524 | } 1525 | 1526 | function addClass( elem, name ) { 1527 | if ( !hasClass( elem, name ) ) { 1528 | elem.className += (elem.className ? " " : "") + name; 1529 | } 1530 | } 1531 | 1532 | function removeClass( elem, name ) { 1533 | var set = " " + elem.className + " "; 1534 | // Class name may appear multiple times 1535 | while ( set.indexOf(" " + name + " ") > -1 ) { 1536 | set = set.replace(" " + name + " " , " "); 1537 | } 1538 | // If possible, trim it for prettiness, but not neccecarily 1539 | elem.className = window.jQuery ? jQuery.trim( set ) : ( set.trim ? set.trim() : set ); 1540 | } 1541 | 1542 | function id( name ) { 1543 | return !!( typeof document !== "undefined" && document && document.getElementById ) && 1544 | document.getElementById( name ); 1545 | } 1546 | 1547 | function registerLoggingCallback( key ) { 1548 | return function( callback ) { 1549 | config[key].push( callback ); 1550 | }; 1551 | } 1552 | 1553 | // Supports deprecated method of completely overwriting logging callbacks 1554 | function runLoggingCallbacks( key, scope, args ) { 1555 | var i, callbacks; 1556 | if ( QUnit.hasOwnProperty( key ) ) { 1557 | QUnit[ key ].call(scope, args ); 1558 | } else { 1559 | callbacks = config[ key ]; 1560 | for ( i = 0; i < callbacks.length; i++ ) { 1561 | callbacks[ i ].call( scope, args ); 1562 | } 1563 | } 1564 | } 1565 | 1566 | // Test for equality any JavaScript type. 1567 | // Author: Philippe Rathé 1568 | QUnit.equiv = (function() { 1569 | 1570 | // Call the o related callback with the given arguments. 1571 | function bindCallbacks( o, callbacks, args ) { 1572 | var prop = QUnit.objectType( o ); 1573 | if ( prop ) { 1574 | if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) { 1575 | return callbacks[ prop ].apply( callbacks, args ); 1576 | } else { 1577 | return callbacks[ prop ]; // or undefined 1578 | } 1579 | } 1580 | } 1581 | 1582 | // the real equiv function 1583 | var innerEquiv, 1584 | // stack to decide between skip/abort functions 1585 | callers = [], 1586 | // stack to avoiding loops from circular referencing 1587 | parents = [], 1588 | 1589 | getProto = Object.getPrototypeOf || function ( obj ) { 1590 | return obj.__proto__; 1591 | }, 1592 | callbacks = (function () { 1593 | 1594 | // for string, boolean, number and null 1595 | function useStrictEquality( b, a ) { 1596 | /*jshint eqeqeq:false */ 1597 | if ( b instanceof a.constructor || a instanceof b.constructor ) { 1598 | // to catch short annotaion VS 'new' annotation of a 1599 | // declaration 1600 | // e.g. var i = 1; 1601 | // var j = new Number(1); 1602 | return a == b; 1603 | } else { 1604 | return a === b; 1605 | } 1606 | } 1607 | 1608 | return { 1609 | "string": useStrictEquality, 1610 | "boolean": useStrictEquality, 1611 | "number": useStrictEquality, 1612 | "null": useStrictEquality, 1613 | "undefined": useStrictEquality, 1614 | 1615 | "nan": function( b ) { 1616 | return isNaN( b ); 1617 | }, 1618 | 1619 | "date": function( b, a ) { 1620 | return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf(); 1621 | }, 1622 | 1623 | "regexp": function( b, a ) { 1624 | return QUnit.objectType( b ) === "regexp" && 1625 | // the regex itself 1626 | a.source === b.source && 1627 | // and its modifers 1628 | a.global === b.global && 1629 | // (gmi) ... 1630 | a.ignoreCase === b.ignoreCase && 1631 | a.multiline === b.multiline && 1632 | a.sticky === b.sticky; 1633 | }, 1634 | 1635 | // - skip when the property is a method of an instance (OOP) 1636 | // - abort otherwise, 1637 | // initial === would have catch identical references anyway 1638 | "function": function() { 1639 | var caller = callers[callers.length - 1]; 1640 | return caller !== Object && typeof caller !== "undefined"; 1641 | }, 1642 | 1643 | "array": function( b, a ) { 1644 | var i, j, len, loop; 1645 | 1646 | // b could be an object literal here 1647 | if ( QUnit.objectType( b ) !== "array" ) { 1648 | return false; 1649 | } 1650 | 1651 | len = a.length; 1652 | if ( len !== b.length ) { 1653 | // safe and faster 1654 | return false; 1655 | } 1656 | 1657 | // track reference to avoid circular references 1658 | parents.push( a ); 1659 | for ( i = 0; i < len; i++ ) { 1660 | loop = false; 1661 | for ( j = 0; j < parents.length; j++ ) { 1662 | if ( parents[j] === a[i] ) { 1663 | loop = true;// dont rewalk array 1664 | } 1665 | } 1666 | if ( !loop && !innerEquiv(a[i], b[i]) ) { 1667 | parents.pop(); 1668 | return false; 1669 | } 1670 | } 1671 | parents.pop(); 1672 | return true; 1673 | }, 1674 | 1675 | "object": function( b, a ) { 1676 | var i, j, loop, 1677 | // Default to true 1678 | eq = true, 1679 | aProperties = [], 1680 | bProperties = []; 1681 | 1682 | // comparing constructors is more strict than using 1683 | // instanceof 1684 | if ( a.constructor !== b.constructor ) { 1685 | // Allow objects with no prototype to be equivalent to 1686 | // objects with Object as their constructor. 1687 | if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) || 1688 | ( getProto(b) === null && getProto(a) === Object.prototype ) ) ) { 1689 | return false; 1690 | } 1691 | } 1692 | 1693 | // stack constructor before traversing properties 1694 | callers.push( a.constructor ); 1695 | // track reference to avoid circular references 1696 | parents.push( a ); 1697 | 1698 | for ( i in a ) { // be strict: don't ensures hasOwnProperty 1699 | // and go deep 1700 | loop = false; 1701 | for ( j = 0; j < parents.length; j++ ) { 1702 | if ( parents[j] === a[i] ) { 1703 | // don't go down the same path twice 1704 | loop = true; 1705 | } 1706 | } 1707 | aProperties.push(i); // collect a's properties 1708 | 1709 | if (!loop && !innerEquiv( a[i], b[i] ) ) { 1710 | eq = false; 1711 | break; 1712 | } 1713 | } 1714 | 1715 | callers.pop(); // unstack, we are done 1716 | parents.pop(); 1717 | 1718 | for ( i in b ) { 1719 | bProperties.push( i ); // collect b's properties 1720 | } 1721 | 1722 | // Ensures identical properties name 1723 | return eq && innerEquiv( aProperties.sort(), bProperties.sort() ); 1724 | } 1725 | }; 1726 | }()); 1727 | 1728 | innerEquiv = function() { // can take multiple arguments 1729 | var args = [].slice.apply( arguments ); 1730 | if ( args.length < 2 ) { 1731 | return true; // end transition 1732 | } 1733 | 1734 | return (function( a, b ) { 1735 | if ( a === b ) { 1736 | return true; // catch the most you can 1737 | } else if ( a === null || b === null || typeof a === "undefined" || 1738 | typeof b === "undefined" || 1739 | QUnit.objectType(a) !== QUnit.objectType(b) ) { 1740 | return false; // don't lose time with error prone cases 1741 | } else { 1742 | return bindCallbacks(a, callbacks, [ b, a ]); 1743 | } 1744 | 1745 | // apply transition with (1..n) arguments 1746 | }( args[0], args[1] ) && arguments.callee.apply( this, args.splice(1, args.length - 1 )) ); 1747 | }; 1748 | 1749 | return innerEquiv; 1750 | }()); 1751 | 1752 | /** 1753 | * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | 1754 | * http://flesler.blogspot.com Licensed under BSD 1755 | * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008 1756 | * 1757 | * @projectDescription Advanced and extensible data dumping for Javascript. 1758 | * @version 1.0.0 1759 | * @author Ariel Flesler 1760 | * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html} 1761 | */ 1762 | QUnit.jsDump = (function() { 1763 | function quote( str ) { 1764 | return '"' + str.toString().replace( /"/g, '\\"' ) + '"'; 1765 | } 1766 | function literal( o ) { 1767 | return o + ""; 1768 | } 1769 | function join( pre, arr, post ) { 1770 | var s = jsDump.separator(), 1771 | base = jsDump.indent(), 1772 | inner = jsDump.indent(1); 1773 | if ( arr.join ) { 1774 | arr = arr.join( "," + s + inner ); 1775 | } 1776 | if ( !arr ) { 1777 | return pre + post; 1778 | } 1779 | return [ pre, inner + arr, base + post ].join(s); 1780 | } 1781 | function array( arr, stack ) { 1782 | var i = arr.length, ret = new Array(i); 1783 | this.up(); 1784 | while ( i-- ) { 1785 | ret[i] = this.parse( arr[i] , undefined , stack); 1786 | } 1787 | this.down(); 1788 | return join( "[", ret, "]" ); 1789 | } 1790 | 1791 | var reName = /^function (\w+)/, 1792 | jsDump = { 1793 | // type is used mostly internally, you can fix a (custom)type in advance 1794 | parse: function( obj, type, stack ) { 1795 | stack = stack || [ ]; 1796 | var inStack, res, 1797 | parser = this.parsers[ type || this.typeOf(obj) ]; 1798 | 1799 | type = typeof parser; 1800 | inStack = inArray( obj, stack ); 1801 | 1802 | if ( inStack !== -1 ) { 1803 | return "recursion(" + (inStack - stack.length) + ")"; 1804 | } 1805 | if ( type === "function" ) { 1806 | stack.push( obj ); 1807 | res = parser.call( this, obj, stack ); 1808 | stack.pop(); 1809 | return res; 1810 | } 1811 | return ( type === "string" ) ? parser : this.parsers.error; 1812 | }, 1813 | typeOf: function( obj ) { 1814 | var type; 1815 | if ( obj === null ) { 1816 | type = "null"; 1817 | } else if ( typeof obj === "undefined" ) { 1818 | type = "undefined"; 1819 | } else if ( QUnit.is( "regexp", obj) ) { 1820 | type = "regexp"; 1821 | } else if ( QUnit.is( "date", obj) ) { 1822 | type = "date"; 1823 | } else if ( QUnit.is( "function", obj) ) { 1824 | type = "function"; 1825 | } else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) { 1826 | type = "window"; 1827 | } else if ( obj.nodeType === 9 ) { 1828 | type = "document"; 1829 | } else if ( obj.nodeType ) { 1830 | type = "node"; 1831 | } else if ( 1832 | // native arrays 1833 | toString.call( obj ) === "[object Array]" || 1834 | // NodeList objects 1835 | ( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) ) 1836 | ) { 1837 | type = "array"; 1838 | } else if ( obj.constructor === Error.prototype.constructor ) { 1839 | type = "error"; 1840 | } else { 1841 | type = typeof obj; 1842 | } 1843 | return type; 1844 | }, 1845 | separator: function() { 1846 | return this.multiline ? this.HTML ? "
" : "\n" : this.HTML ? " " : " "; 1847 | }, 1848 | // extra can be a number, shortcut for increasing-calling-decreasing 1849 | indent: function( extra ) { 1850 | if ( !this.multiline ) { 1851 | return ""; 1852 | } 1853 | var chr = this.indentChar; 1854 | if ( this.HTML ) { 1855 | chr = chr.replace( /\t/g, " " ).replace( / /g, " " ); 1856 | } 1857 | return new Array( this._depth_ + (extra||0) ).join(chr); 1858 | }, 1859 | up: function( a ) { 1860 | this._depth_ += a || 1; 1861 | }, 1862 | down: function( a ) { 1863 | this._depth_ -= a || 1; 1864 | }, 1865 | setParser: function( name, parser ) { 1866 | this.parsers[name] = parser; 1867 | }, 1868 | // The next 3 are exposed so you can use them 1869 | quote: quote, 1870 | literal: literal, 1871 | join: join, 1872 | // 1873 | _depth_: 1, 1874 | // This is the list of parsers, to modify them, use jsDump.setParser 1875 | parsers: { 1876 | window: "[Window]", 1877 | document: "[Document]", 1878 | error: function(error) { 1879 | return "Error(\"" + error.message + "\")"; 1880 | }, 1881 | unknown: "[Unknown]", 1882 | "null": "null", 1883 | "undefined": "undefined", 1884 | "function": function( fn ) { 1885 | var ret = "function", 1886 | // functions never have name in IE 1887 | name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1]; 1888 | 1889 | if ( name ) { 1890 | ret += " " + name; 1891 | } 1892 | ret += "( "; 1893 | 1894 | ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" ); 1895 | return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" ); 1896 | }, 1897 | array: array, 1898 | nodelist: array, 1899 | "arguments": array, 1900 | object: function( map, stack ) { 1901 | var ret = [ ], keys, key, val, i; 1902 | QUnit.jsDump.up(); 1903 | keys = []; 1904 | for ( key in map ) { 1905 | keys.push( key ); 1906 | } 1907 | keys.sort(); 1908 | for ( i = 0; i < keys.length; i++ ) { 1909 | key = keys[ i ]; 1910 | val = map[ key ]; 1911 | ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) ); 1912 | } 1913 | QUnit.jsDump.down(); 1914 | return join( "{", ret, "}" ); 1915 | }, 1916 | node: function( node ) { 1917 | var len, i, val, 1918 | open = QUnit.jsDump.HTML ? "<" : "<", 1919 | close = QUnit.jsDump.HTML ? ">" : ">", 1920 | tag = node.nodeName.toLowerCase(), 1921 | ret = open + tag, 1922 | attrs = node.attributes; 1923 | 1924 | if ( attrs ) { 1925 | for ( i = 0, len = attrs.length; i < len; i++ ) { 1926 | val = attrs[i].nodeValue; 1927 | // IE6 includes all attributes in .attributes, even ones not explicitly set. 1928 | // Those have values like undefined, null, 0, false, "" or "inherit". 1929 | if ( val && val !== "inherit" ) { 1930 | ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" ); 1931 | } 1932 | } 1933 | } 1934 | ret += close; 1935 | 1936 | // Show content of TextNode or CDATASection 1937 | if ( node.nodeType === 3 || node.nodeType === 4 ) { 1938 | ret += node.nodeValue; 1939 | } 1940 | 1941 | return ret + open + "/" + tag + close; 1942 | }, 1943 | // function calls it internally, it's the arguments part of the function 1944 | functionArgs: function( fn ) { 1945 | var args, 1946 | l = fn.length; 1947 | 1948 | if ( !l ) { 1949 | return ""; 1950 | } 1951 | 1952 | args = new Array(l); 1953 | while ( l-- ) { 1954 | // 97 is 'a' 1955 | args[l] = String.fromCharCode(97+l); 1956 | } 1957 | return " " + args.join( ", " ) + " "; 1958 | }, 1959 | // object calls it internally, the key part of an item in a map 1960 | key: quote, 1961 | // function calls it internally, it's the content of the function 1962 | functionCode: "[code]", 1963 | // node calls it internally, it's an html attribute value 1964 | attribute: quote, 1965 | string: quote, 1966 | date: quote, 1967 | regexp: literal, 1968 | number: literal, 1969 | "boolean": literal 1970 | }, 1971 | // if true, entities are escaped ( <, >, \t, space and \n ) 1972 | HTML: false, 1973 | // indentation unit 1974 | indentChar: " ", 1975 | // if true, items in a collection, are separated by a \n, else just a space. 1976 | multiline: true 1977 | }; 1978 | 1979 | return jsDump; 1980 | }()); 1981 | 1982 | // from jquery.js 1983 | function inArray( elem, array ) { 1984 | if ( array.indexOf ) { 1985 | return array.indexOf( elem ); 1986 | } 1987 | 1988 | for ( var i = 0, length = array.length; i < length; i++ ) { 1989 | if ( array[ i ] === elem ) { 1990 | return i; 1991 | } 1992 | } 1993 | 1994 | return -1; 1995 | } 1996 | 1997 | /* 1998 | * Javascript Diff Algorithm 1999 | * By John Resig (http://ejohn.org/) 2000 | * Modified by Chu Alan "sprite" 2001 | * 2002 | * Released under the MIT license. 2003 | * 2004 | * More Info: 2005 | * http://ejohn.org/projects/javascript-diff-algorithm/ 2006 | * 2007 | * Usage: QUnit.diff(expected, actual) 2008 | * 2009 | * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the quick ~~brown~~ fox ~~jumped~~ jumps over" 2010 | */ 2011 | QUnit.diff = (function() { 2012 | /*jshint eqeqeq:false, eqnull:true */ 2013 | function diff( o, n ) { 2014 | var i, 2015 | ns = {}, 2016 | os = {}; 2017 | 2018 | for ( i = 0; i < n.length; i++ ) { 2019 | if ( !hasOwn.call( ns, n[i] ) ) { 2020 | ns[ n[i] ] = { 2021 | rows: [], 2022 | o: null 2023 | }; 2024 | } 2025 | ns[ n[i] ].rows.push( i ); 2026 | } 2027 | 2028 | for ( i = 0; i < o.length; i++ ) { 2029 | if ( !hasOwn.call( os, o[i] ) ) { 2030 | os[ o[i] ] = { 2031 | rows: [], 2032 | n: null 2033 | }; 2034 | } 2035 | os[ o[i] ].rows.push( i ); 2036 | } 2037 | 2038 | for ( i in ns ) { 2039 | if ( !hasOwn.call( ns, i ) ) { 2040 | continue; 2041 | } 2042 | if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) { 2043 | n[ ns[i].rows[0] ] = { 2044 | text: n[ ns[i].rows[0] ], 2045 | row: os[i].rows[0] 2046 | }; 2047 | o[ os[i].rows[0] ] = { 2048 | text: o[ os[i].rows[0] ], 2049 | row: ns[i].rows[0] 2050 | }; 2051 | } 2052 | } 2053 | 2054 | for ( i = 0; i < n.length - 1; i++ ) { 2055 | if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null && 2056 | n[ i + 1 ] == o[ n[i].row + 1 ] ) { 2057 | 2058 | n[ i + 1 ] = { 2059 | text: n[ i + 1 ], 2060 | row: n[i].row + 1 2061 | }; 2062 | o[ n[i].row + 1 ] = { 2063 | text: o[ n[i].row + 1 ], 2064 | row: i + 1 2065 | }; 2066 | } 2067 | } 2068 | 2069 | for ( i = n.length - 1; i > 0; i-- ) { 2070 | if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null && 2071 | n[ i - 1 ] == o[ n[i].row - 1 ]) { 2072 | 2073 | n[ i - 1 ] = { 2074 | text: n[ i - 1 ], 2075 | row: n[i].row - 1 2076 | }; 2077 | o[ n[i].row - 1 ] = { 2078 | text: o[ n[i].row - 1 ], 2079 | row: i - 1 2080 | }; 2081 | } 2082 | } 2083 | 2084 | return { 2085 | o: o, 2086 | n: n 2087 | }; 2088 | } 2089 | 2090 | return function( o, n ) { 2091 | o = o.replace( /\s+$/, "" ); 2092 | n = n.replace( /\s+$/, "" ); 2093 | 2094 | var i, pre, 2095 | str = "", 2096 | out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ), 2097 | oSpace = o.match(/\s+/g), 2098 | nSpace = n.match(/\s+/g); 2099 | 2100 | if ( oSpace == null ) { 2101 | oSpace = [ " " ]; 2102 | } 2103 | else { 2104 | oSpace.push( " " ); 2105 | } 2106 | 2107 | if ( nSpace == null ) { 2108 | nSpace = [ " " ]; 2109 | } 2110 | else { 2111 | nSpace.push( " " ); 2112 | } 2113 | 2114 | if ( out.n.length === 0 ) { 2115 | for ( i = 0; i < out.o.length; i++ ) { 2116 | str += "~~" + out.o[i] + oSpace[i] + "~~"; 2117 | } 2118 | } 2119 | else { 2120 | if ( out.n[0].text == null ) { 2121 | for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) { 2122 | str += "~~" + out.o[n] + oSpace[n] + "~~"; 2123 | } 2124 | } 2125 | 2126 | for ( i = 0; i < out.n.length; i++ ) { 2127 | if (out.n[i].text == null) { 2128 | str += "" + out.n[i] + nSpace[i] + ""; 2129 | } 2130 | else { 2131 | // `pre` initialized at top of scope 2132 | pre = ""; 2133 | 2134 | for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) { 2135 | pre += "~~" + out.o[n] + oSpace[n] + "~~"; 2136 | } 2137 | str += " " + out.n[i].text + nSpace[i] + pre; 2138 | } 2139 | } 2140 | } 2141 | 2142 | return str; 2143 | }; 2144 | }()); 2145 | 2146 | // for CommonJS enviroments, export everything 2147 | if ( typeof exports !== "undefined" ) { 2148 | extend( exports, QUnit ); 2149 | } 2150 | 2151 | // get at whatever the global object is, like window in browsers 2152 | }( (function() {return this;}.call()) )); 2153 | -------------------------------------------------------------------------------- /tests/vendor/handlebars.js: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | Copyright (C) 2011 by Yehuda Katz 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | 23 | */ 24 | 25 | // lib/handlebars/base.js 26 | 27 | /*jshint eqnull:true*/ 28 | this.Handlebars = {}; 29 | 30 | (function(Handlebars) { 31 | 32 | Handlebars.VERSION = "1.0.0-rc.3"; 33 | Handlebars.COMPILER_REVISION = 2; 34 | 35 | Handlebars.REVISION_CHANGES = { 36 | 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it 37 | 2: '>= 1.0.0-rc.3' 38 | }; 39 | 40 | Handlebars.helpers = {}; 41 | Handlebars.partials = {}; 42 | 43 | Handlebars.registerHelper = function(name, fn, inverse) { 44 | if(inverse) { fn.not = inverse; } 45 | this.helpers[name] = fn; 46 | }; 47 | 48 | Handlebars.registerPartial = function(name, str) { 49 | this.partials[name] = str; 50 | }; 51 | 52 | Handlebars.registerHelper('helperMissing', function(arg) { 53 | if(arguments.length === 2) { 54 | return undefined; 55 | } else { 56 | throw new Error("Could not find property '" + arg + "'"); 57 | } 58 | }); 59 | 60 | var toString = Object.prototype.toString, functionType = "[object Function]"; 61 | 62 | Handlebars.registerHelper('blockHelperMissing', function(context, options) { 63 | var inverse = options.inverse || function() {}, fn = options.fn; 64 | 65 | 66 | var ret = ""; 67 | var type = toString.call(context); 68 | 69 | if(type === functionType) { context = context.call(this); } 70 | 71 | if(context === true) { 72 | return fn(this); 73 | } else if(context === false || context == null) { 74 | return inverse(this); 75 | } else if(type === "[object Array]") { 76 | if(context.length > 0) { 77 | return Handlebars.helpers.each(context, options); 78 | } else { 79 | return inverse(this); 80 | } 81 | } else { 82 | return fn(context); 83 | } 84 | }); 85 | 86 | Handlebars.K = function() {}; 87 | 88 | Handlebars.createFrame = Object.create || function(object) { 89 | Handlebars.K.prototype = object; 90 | var obj = new Handlebars.K(); 91 | Handlebars.K.prototype = null; 92 | return obj; 93 | }; 94 | 95 | Handlebars.logger = { 96 | DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3, 97 | 98 | methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'}, 99 | 100 | // can be overridden in the host environment 101 | log: function(level, obj) { 102 | if (Handlebars.logger.level <= level) { 103 | var method = Handlebars.logger.methodMap[level]; 104 | if (typeof console !== 'undefined' && console[method]) { 105 | console[method].call(console, obj); 106 | } 107 | } 108 | } 109 | }; 110 | 111 | Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); }; 112 | 113 | Handlebars.registerHelper('each', function(context, options) { 114 | var fn = options.fn, inverse = options.inverse; 115 | var i = 0, ret = "", data; 116 | 117 | if (options.data) { 118 | data = Handlebars.createFrame(options.data); 119 | } 120 | 121 | if(context && typeof context === 'object') { 122 | if(context instanceof Array){ 123 | for(var j = context.length; i 2) { 331 | expected.push("'" + this.terminals_[p] + "'"); 332 | } 333 | if (this.lexer.showPosition) { 334 | errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; 335 | } else { 336 | errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'"); 337 | } 338 | this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected}); 339 | } 340 | } 341 | if (action[0] instanceof Array && action.length > 1) { 342 | throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol); 343 | } 344 | switch (action[0]) { 345 | case 1: 346 | stack.push(symbol); 347 | vstack.push(this.lexer.yytext); 348 | lstack.push(this.lexer.yylloc); 349 | stack.push(action[1]); 350 | symbol = null; 351 | if (!preErrorSymbol) { 352 | yyleng = this.lexer.yyleng; 353 | yytext = this.lexer.yytext; 354 | yylineno = this.lexer.yylineno; 355 | yyloc = this.lexer.yylloc; 356 | if (recovering > 0) 357 | recovering--; 358 | } else { 359 | symbol = preErrorSymbol; 360 | preErrorSymbol = null; 361 | } 362 | break; 363 | case 2: 364 | len = this.productions_[action[1]][1]; 365 | yyval.$ = vstack[vstack.length - len]; 366 | yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column}; 367 | if (ranges) { 368 | yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]]; 369 | } 370 | r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack); 371 | if (typeof r !== "undefined") { 372 | return r; 373 | } 374 | if (len) { 375 | stack = stack.slice(0, -1 * len * 2); 376 | vstack = vstack.slice(0, -1 * len); 377 | lstack = lstack.slice(0, -1 * len); 378 | } 379 | stack.push(this.productions_[action[1]][0]); 380 | vstack.push(yyval.$); 381 | lstack.push(yyval._$); 382 | newState = table[stack[stack.length - 2]][stack[stack.length - 1]]; 383 | stack.push(newState); 384 | break; 385 | case 3: 386 | return true; 387 | } 388 | } 389 | return true; 390 | } 391 | }; 392 | /* Jison generated lexer */ 393 | var lexer = (function(){ 394 | var lexer = ({EOF:1, 395 | parseError:function parseError(str, hash) { 396 | if (this.yy.parser) { 397 | this.yy.parser.parseError(str, hash); 398 | } else { 399 | throw new Error(str); 400 | } 401 | }, 402 | setInput:function (input) { 403 | this._input = input; 404 | this._more = this._less = this.done = false; 405 | this.yylineno = this.yyleng = 0; 406 | this.yytext = this.matched = this.match = ''; 407 | this.conditionStack = ['INITIAL']; 408 | this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0}; 409 | if (this.options.ranges) this.yylloc.range = [0,0]; 410 | this.offset = 0; 411 | return this; 412 | }, 413 | input:function () { 414 | var ch = this._input[0]; 415 | this.yytext += ch; 416 | this.yyleng++; 417 | this.offset++; 418 | this.match += ch; 419 | this.matched += ch; 420 | var lines = ch.match(/(?:\r\n?|\n).*/g); 421 | if (lines) { 422 | this.yylineno++; 423 | this.yylloc.last_line++; 424 | } else { 425 | this.yylloc.last_column++; 426 | } 427 | if (this.options.ranges) this.yylloc.range[1]++; 428 | 429 | this._input = this._input.slice(1); 430 | return ch; 431 | }, 432 | unput:function (ch) { 433 | var len = ch.length; 434 | var lines = ch.split(/(?:\r\n?|\n)/g); 435 | 436 | this._input = ch + this._input; 437 | this.yytext = this.yytext.substr(0, this.yytext.length-len-1); 438 | //this.yyleng -= len; 439 | this.offset -= len; 440 | var oldLines = this.match.split(/(?:\r\n?|\n)/g); 441 | this.match = this.match.substr(0, this.match.length-1); 442 | this.matched = this.matched.substr(0, this.matched.length-1); 443 | 444 | if (lines.length-1) this.yylineno -= lines.length-1; 445 | var r = this.yylloc.range; 446 | 447 | this.yylloc = {first_line: this.yylloc.first_line, 448 | last_line: this.yylineno+1, 449 | first_column: this.yylloc.first_column, 450 | last_column: lines ? 451 | (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length: 452 | this.yylloc.first_column - len 453 | }; 454 | 455 | if (this.options.ranges) { 456 | this.yylloc.range = [r[0], r[0] + this.yyleng - len]; 457 | } 458 | return this; 459 | }, 460 | more:function () { 461 | this._more = true; 462 | return this; 463 | }, 464 | less:function (n) { 465 | this.unput(this.match.slice(n)); 466 | }, 467 | pastInput:function () { 468 | var past = this.matched.substr(0, this.matched.length - this.match.length); 469 | return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, ""); 470 | }, 471 | upcomingInput:function () { 472 | var next = this.match; 473 | if (next.length < 20) { 474 | next += this._input.substr(0, 20-next.length); 475 | } 476 | return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, ""); 477 | }, 478 | showPosition:function () { 479 | var pre = this.pastInput(); 480 | var c = new Array(pre.length + 1).join("-"); 481 | return pre + this.upcomingInput() + "\n" + c+"^"; 482 | }, 483 | next:function () { 484 | if (this.done) { 485 | return this.EOF; 486 | } 487 | if (!this._input) this.done = true; 488 | 489 | var token, 490 | match, 491 | tempMatch, 492 | index, 493 | col, 494 | lines; 495 | if (!this._more) { 496 | this.yytext = ''; 497 | this.match = ''; 498 | } 499 | var rules = this._currentRules(); 500 | for (var i=0;i < rules.length; i++) { 501 | tempMatch = this._input.match(this.rules[rules[i]]); 502 | if (tempMatch && (!match || tempMatch[0].length > match[0].length)) { 503 | match = tempMatch; 504 | index = i; 505 | if (!this.options.flex) break; 506 | } 507 | } 508 | if (match) { 509 | lines = match[0].match(/(?:\r\n?|\n).*/g); 510 | if (lines) this.yylineno += lines.length; 511 | this.yylloc = {first_line: this.yylloc.last_line, 512 | last_line: this.yylineno+1, 513 | first_column: this.yylloc.last_column, 514 | last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length}; 515 | this.yytext += match[0]; 516 | this.match += match[0]; 517 | this.matches = match; 518 | this.yyleng = this.yytext.length; 519 | if (this.options.ranges) { 520 | this.yylloc.range = [this.offset, this.offset += this.yyleng]; 521 | } 522 | this._more = false; 523 | this._input = this._input.slice(match[0].length); 524 | this.matched += match[0]; 525 | token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]); 526 | if (this.done && this._input) this.done = false; 527 | if (token) return token; 528 | else return; 529 | } 530 | if (this._input === "") { 531 | return this.EOF; 532 | } else { 533 | return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(), 534 | {text: "", token: null, line: this.yylineno}); 535 | } 536 | }, 537 | lex:function lex() { 538 | var r = this.next(); 539 | if (typeof r !== 'undefined') { 540 | return r; 541 | } else { 542 | return this.lex(); 543 | } 544 | }, 545 | begin:function begin(condition) { 546 | this.conditionStack.push(condition); 547 | }, 548 | popState:function popState() { 549 | return this.conditionStack.pop(); 550 | }, 551 | _currentRules:function _currentRules() { 552 | return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules; 553 | }, 554 | topState:function () { 555 | return this.conditionStack[this.conditionStack.length-2]; 556 | }, 557 | pushState:function begin(condition) { 558 | this.begin(condition); 559 | }}); 560 | lexer.options = {}; 561 | lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) { 562 | 563 | var YYSTATE=YY_START 564 | switch($avoiding_name_collisions) { 565 | case 0: 566 | if(yy_.yytext.slice(-1) !== "\\") this.begin("mu"); 567 | if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1), this.begin("emu"); 568 | if(yy_.yytext) return 14; 569 | 570 | break; 571 | case 1: return 14; 572 | break; 573 | case 2: 574 | if(yy_.yytext.slice(-1) !== "\\") this.popState(); 575 | if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1); 576 | return 14; 577 | 578 | break; 579 | case 3: yy_.yytext = yy_.yytext.substr(0, yy_.yyleng-4); this.popState(); return 15; 580 | break; 581 | case 4: this.begin("par"); return 24; 582 | break; 583 | case 5: return 16; 584 | break; 585 | case 6: return 20; 586 | break; 587 | case 7: return 19; 588 | break; 589 | case 8: return 19; 590 | break; 591 | case 9: return 23; 592 | break; 593 | case 10: return 23; 594 | break; 595 | case 11: this.popState(); this.begin('com'); 596 | break; 597 | case 12: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; 598 | break; 599 | case 13: return 22; 600 | break; 601 | case 14: return 36; 602 | break; 603 | case 15: return 35; 604 | break; 605 | case 16: return 35; 606 | break; 607 | case 17: return 39; 608 | break; 609 | case 18: /*ignore whitespace*/ 610 | break; 611 | case 19: this.popState(); return 18; 612 | break; 613 | case 20: this.popState(); return 18; 614 | break; 615 | case 21: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 30; 616 | break; 617 | case 22: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\'/g,"'"); return 30; 618 | break; 619 | case 23: yy_.yytext = yy_.yytext.substr(1); return 28; 620 | break; 621 | case 24: return 32; 622 | break; 623 | case 25: return 32; 624 | break; 625 | case 26: return 31; 626 | break; 627 | case 27: return 35; 628 | break; 629 | case 28: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 35; 630 | break; 631 | case 29: return 'INVALID'; 632 | break; 633 | case 30: /*ignore whitespace*/ 634 | break; 635 | case 31: this.popState(); return 37; 636 | break; 637 | case 32: return 5; 638 | break; 639 | } 640 | }; 641 | lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|$)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\{\{>)/,/^(?:\{\{#)/,/^(?:\{\{\/)/,/^(?:\{\{\^)/,/^(?:\{\{\s*else\b)/,/^(?:\{\{\{)/,/^(?:\{\{&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{)/,/^(?:=)/,/^(?:\.(?=[} ]))/,/^(?:\.\.)/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}\}\})/,/^(?:\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@[a-zA-Z]+)/,/^(?:true(?=[}\s]))/,/^(?:false(?=[}\s]))/,/^(?:[0-9]+(?=[}\s]))/,/^(?:[a-zA-Z0-9_$-]+(?=[=}\s\/.]))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:\s+)/,/^(?:[a-zA-Z0-9_$-/]+)/,/^(?:$)/]; 642 | lexer.conditions = {"mu":{"rules":[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,32],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[3],"inclusive":false},"par":{"rules":[30,31],"inclusive":false},"INITIAL":{"rules":[0,1,32],"inclusive":true}}; 643 | return lexer;})() 644 | parser.lexer = lexer; 645 | function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser; 646 | return new Parser; 647 | })();; 648 | // lib/handlebars/compiler/base.js 649 | Handlebars.Parser = handlebars; 650 | 651 | Handlebars.parse = function(input) { 652 | 653 | // Just return if an already-compile AST was passed in. 654 | if(input.constructor === Handlebars.AST.ProgramNode) { return input; } 655 | 656 | Handlebars.Parser.yy = Handlebars.AST; 657 | return Handlebars.Parser.parse(input); 658 | }; 659 | 660 | Handlebars.print = function(ast) { 661 | return new Handlebars.PrintVisitor().accept(ast); 662 | };; 663 | // lib/handlebars/compiler/ast.js 664 | (function() { 665 | 666 | Handlebars.AST = {}; 667 | 668 | Handlebars.AST.ProgramNode = function(statements, inverse) { 669 | this.type = "program"; 670 | this.statements = statements; 671 | if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); } 672 | }; 673 | 674 | Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) { 675 | this.type = "mustache"; 676 | this.escaped = !unescaped; 677 | this.hash = hash; 678 | 679 | var id = this.id = rawParams[0]; 680 | var params = this.params = rawParams.slice(1); 681 | 682 | // a mustache is an eligible helper if: 683 | // * its id is simple (a single part, not `this` or `..`) 684 | var eligibleHelper = this.eligibleHelper = id.isSimple; 685 | 686 | // a mustache is definitely a helper if: 687 | // * it is an eligible helper, and 688 | // * it has at least one parameter or hash segment 689 | this.isHelper = eligibleHelper && (params.length || hash); 690 | 691 | // if a mustache is an eligible helper but not a definite 692 | // helper, it is ambiguous, and will be resolved in a later 693 | // pass or at runtime. 694 | }; 695 | 696 | Handlebars.AST.PartialNode = function(partialName, context) { 697 | this.type = "partial"; 698 | this.partialName = partialName; 699 | this.context = context; 700 | }; 701 | 702 | var verifyMatch = function(open, close) { 703 | if(open.original !== close.original) { 704 | throw new Handlebars.Exception(open.original + " doesn't match " + close.original); 705 | } 706 | }; 707 | 708 | Handlebars.AST.BlockNode = function(mustache, program, inverse, close) { 709 | verifyMatch(mustache.id, close); 710 | this.type = "block"; 711 | this.mustache = mustache; 712 | this.program = program; 713 | this.inverse = inverse; 714 | 715 | if (this.inverse && !this.program) { 716 | this.isInverse = true; 717 | } 718 | }; 719 | 720 | Handlebars.AST.ContentNode = function(string) { 721 | this.type = "content"; 722 | this.string = string; 723 | }; 724 | 725 | Handlebars.AST.HashNode = function(pairs) { 726 | this.type = "hash"; 727 | this.pairs = pairs; 728 | }; 729 | 730 | Handlebars.AST.IdNode = function(parts) { 731 | this.type = "ID"; 732 | this.original = parts.join("."); 733 | 734 | var dig = [], depth = 0; 735 | 736 | for(var i=0,l=parts.length; i 0) { throw new Handlebars.Exception("Invalid path: " + this.original); } 741 | else if (part === "..") { depth++; } 742 | else { this.isScoped = true; } 743 | } 744 | else { dig.push(part); } 745 | } 746 | 747 | this.parts = dig; 748 | this.string = dig.join('.'); 749 | this.depth = depth; 750 | 751 | // an ID is simple if it only has one part, and that part is not 752 | // `..` or `this`. 753 | this.isSimple = parts.length === 1 && !this.isScoped && depth === 0; 754 | 755 | this.stringModeValue = this.string; 756 | }; 757 | 758 | Handlebars.AST.PartialNameNode = function(name) { 759 | this.type = "PARTIAL_NAME"; 760 | this.name = name; 761 | }; 762 | 763 | Handlebars.AST.DataNode = function(id) { 764 | this.type = "DATA"; 765 | this.id = id; 766 | }; 767 | 768 | Handlebars.AST.StringNode = function(string) { 769 | this.type = "STRING"; 770 | this.string = string; 771 | this.stringModeValue = string; 772 | }; 773 | 774 | Handlebars.AST.IntegerNode = function(integer) { 775 | this.type = "INTEGER"; 776 | this.integer = integer; 777 | this.stringModeValue = Number(integer); 778 | }; 779 | 780 | Handlebars.AST.BooleanNode = function(bool) { 781 | this.type = "BOOLEAN"; 782 | this.bool = bool; 783 | this.stringModeValue = bool === "true"; 784 | }; 785 | 786 | Handlebars.AST.CommentNode = function(comment) { 787 | this.type = "comment"; 788 | this.comment = comment; 789 | }; 790 | 791 | })();; 792 | // lib/handlebars/utils.js 793 | 794 | var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack']; 795 | 796 | Handlebars.Exception = function(message) { 797 | var tmp = Error.prototype.constructor.apply(this, arguments); 798 | 799 | // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work. 800 | for (var idx = 0; idx < errorProps.length; idx++) { 801 | this[errorProps[idx]] = tmp[errorProps[idx]]; 802 | } 803 | }; 804 | Handlebars.Exception.prototype = new Error(); 805 | 806 | // Build out our basic SafeString type 807 | Handlebars.SafeString = function(string) { 808 | this.string = string; 809 | }; 810 | Handlebars.SafeString.prototype.toString = function() { 811 | return this.string.toString(); 812 | }; 813 | 814 | (function() { 815 | var escape = { 816 | "&": "&", 817 | "<": "<", 818 | ">": ">", 819 | '"': """, 820 | "'": "'", 821 | "`": "`" 822 | }; 823 | 824 | var badChars = /[&<>"'`]/g; 825 | var possible = /[&<>"'`]/; 826 | 827 | var escapeChar = function(chr) { 828 | return escape[chr] || "&"; 829 | }; 830 | 831 | Handlebars.Utils = { 832 | escapeExpression: function(string) { 833 | // don't escape SafeStrings, since they're already safe 834 | if (string instanceof Handlebars.SafeString) { 835 | return string.toString(); 836 | } else if (string == null || string === false) { 837 | return ""; 838 | } 839 | 840 | if(!possible.test(string)) { return string; } 841 | return string.replace(badChars, escapeChar); 842 | }, 843 | 844 | isEmpty: function(value) { 845 | if (!value && value !== 0) { 846 | return true; 847 | } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length === 0) { 848 | return true; 849 | } else { 850 | return false; 851 | } 852 | } 853 | }; 854 | })();; 855 | // lib/handlebars/compiler/compiler.js 856 | 857 | /*jshint eqnull:true*/ 858 | Handlebars.Compiler = function() {}; 859 | Handlebars.JavaScriptCompiler = function() {}; 860 | 861 | (function(Compiler, JavaScriptCompiler) { 862 | // the foundHelper register will disambiguate helper lookup from finding a 863 | // function in a context. This is necessary for mustache compatibility, which 864 | // requires that context functions in blocks are evaluated by blockHelperMissing, 865 | // and then proceed as if the resulting value was provided to blockHelperMissing. 866 | 867 | Compiler.prototype = { 868 | compiler: Compiler, 869 | 870 | disassemble: function() { 871 | var opcodes = this.opcodes, opcode, out = [], params, param; 872 | 873 | for (var i=0, l=opcodes.length; i 0) { 1361 | this.source[1] = this.source[1] + ", " + locals.join(", "); 1362 | } 1363 | 1364 | // Generate minimizer alias mappings 1365 | if (!this.isChild) { 1366 | for (var alias in this.context.aliases) { 1367 | this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias]; 1368 | } 1369 | } 1370 | 1371 | if (this.source[1]) { 1372 | this.source[1] = "var " + this.source[1].substring(2) + ";"; 1373 | } 1374 | 1375 | // Merge children 1376 | if (!this.isChild) { 1377 | this.source[1] += '\n' + this.context.programs.join('\n') + '\n'; 1378 | } 1379 | 1380 | if (!this.environment.isSimple) { 1381 | this.source.push("return buffer;"); 1382 | } 1383 | 1384 | var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"]; 1385 | 1386 | for(var i=0, l=this.environment.depths.list.length; i this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); } 1918 | return this.topStackName(); 1919 | }, 1920 | topStackName: function() { 1921 | return "stack" + this.stackSlot; 1922 | }, 1923 | flushInline: function() { 1924 | var inlineStack = this.inlineStack; 1925 | if (inlineStack.length) { 1926 | this.inlineStack = []; 1927 | for (var i = 0, len = inlineStack.length; i < len; i++) { 1928 | var entry = inlineStack[i]; 1929 | if (entry instanceof Literal) { 1930 | this.compileStack.push(entry); 1931 | } else { 1932 | this.pushStack(entry); 1933 | } 1934 | } 1935 | } 1936 | }, 1937 | isInline: function() { 1938 | return this.inlineStack.length; 1939 | }, 1940 | 1941 | popStack: function(wrapped) { 1942 | var inline = this.isInline(), 1943 | item = (inline ? this.inlineStack : this.compileStack).pop(); 1944 | 1945 | if (!wrapped && (item instanceof Literal)) { 1946 | return item.value; 1947 | } else { 1948 | if (!inline) { 1949 | this.stackSlot--; 1950 | } 1951 | return item; 1952 | } 1953 | }, 1954 | 1955 | topStack: function(wrapped) { 1956 | var stack = (this.isInline() ? this.inlineStack : this.compileStack), 1957 | item = stack[stack.length - 1]; 1958 | 1959 | if (!wrapped && (item instanceof Literal)) { 1960 | return item.value; 1961 | } else { 1962 | return item; 1963 | } 1964 | }, 1965 | 1966 | quotedString: function(str) { 1967 | return '"' + str 1968 | .replace(/\\/g, '\\\\') 1969 | .replace(/"/g, '\\"') 1970 | .replace(/\n/g, '\\n') 1971 | .replace(/\r/g, '\\r') + '"'; 1972 | }, 1973 | 1974 | setupHelper: function(paramSize, name, missingParams) { 1975 | var params = []; 1976 | this.setupParams(paramSize, params, missingParams); 1977 | var foundHelper = this.nameLookup('helpers', name, 'helper'); 1978 | 1979 | return { 1980 | params: params, 1981 | name: foundHelper, 1982 | callParams: ["depth0"].concat(params).join(", "), 1983 | helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ") 1984 | }; 1985 | }, 1986 | 1987 | // the params and contexts arguments are passed in arrays 1988 | // to fill in 1989 | setupParams: function(paramSize, params, useRegister) { 1990 | var options = [], contexts = [], types = [], param, inverse, program; 1991 | 1992 | options.push("hash:" + this.popStack()); 1993 | 1994 | inverse = this.popStack(); 1995 | program = this.popStack(); 1996 | 1997 | // Avoid setting fn and inverse if neither are set. This allows 1998 | // helpers to do a check for `if (options.fn)` 1999 | if (program || inverse) { 2000 | if (!program) { 2001 | this.context.aliases.self = "this"; 2002 | program = "self.noop"; 2003 | } 2004 | 2005 | if (!inverse) { 2006 | this.context.aliases.self = "this"; 2007 | inverse = "self.noop"; 2008 | } 2009 | 2010 | options.push("inverse:" + inverse); 2011 | options.push("fn:" + program); 2012 | } 2013 | 2014 | for(var i=0; i