├── .gitignore
├── .travis.yml.notyet
├── Gruntfile.js
├── LICENSE-MIT
├── README.md
├── demo
    ├── child.html
    └── index.html
├── dist
    ├── jquery.responsiveiframe.js
    └── jquery.responsiveiframe.min.js
├── libs
    ├── jquery
    │   └── jquery.js
    └── qunit
    │   ├── qunit.css
    │   └── qunit.js
├── package.json
├── src
    └── jquery.responsiveiframe.js
└── test
    ├── jquery.responsiveiframe.html
    └── jquery.responsiveiframe_test.js


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | .DS_Store
3 | node_modules
4 | 


--------------------------------------------------------------------------------
/.travis.yml.notyet:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "0.6"
4 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | module.exports = function(grunt) {
 4 | 
 5 |   // Project configuration.
 6 |   grunt.initConfig({
 7 |     pkg: grunt.file.readJSON('package.json'),
 8 |     banner: '/*! <%= pkg.title || pkg.name %> - v<%= pkg.version %> - ' +
 9 |         '<%= grunt.template.today("yyyy-mm-dd") %>\n' +
10 |         '<%= pkg.homepage ? "* " + pkg.homepage + "\\n" : "" %>' +
11 |         '* Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author.name %>;' +
12 |         ' Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %> */\n',
13 |     // Task configuration.
14 |     clean: {
15 |       files: ['dist']
16 |     },
17 |     concat: {
18 |       options: {
19 |         banner: '<%= banner %>'
20 |       },
21 |       dist: {
22 |         src: ['src/<%= pkg.name %>.js'],
23 |         dest: 'dist/<%= pkg.name %>.js'
24 |       }
25 |     },
26 |     uglify: {
27 |       options: {
28 |         banner: '<%= banner %>',
29 |         compress: true
30 |       },
31 |       build: {
32 |         files: {
33 |           'dist/<%= pkg.name %>.min.js': ['<%= concat.dist.dest %>']
34 |         }
35 |       }
36 |     },
37 |     qunit: {
38 |       files: ['test/**/*.html']
39 |     },
40 |     jslint: {
41 |       client:{
42 |         src: ['grunt.js', 'src/**/*.js', 'test/**/*.js'] ,
43 |         directives: {
44 |             browser: true,
45 |             predef: [
46 |                 'jQuery'
47 |             ]
48 |         }
49 |       }
50 |     },
51 |     watch: {
52 |       files: '<config:lint.files>',
53 |       tasks: 'lint qunit'
54 |     },
55 |     jshint: {
56 |       options: {
57 |         curly: true,
58 |         eqeqeq: true,
59 |         immed: true,
60 |         latedef: true,
61 |         newcap: true,
62 |         noarg: true,
63 |         sub: true,
64 |         undef: true,
65 |         boss: true,
66 |         eqnull: true,
67 |         browser: true
68 |       },
69 |       globals: {
70 |         jQuery: true
71 |       }
72 |     }
73 |   });
74 | 
75 |   grunt.loadNpmTasks('grunt-jslint');
76 |   grunt.loadNpmTasks('grunt-contrib-qunit');
77 |   grunt.loadNpmTasks('grunt-contrib-clean');
78 |   grunt.loadNpmTasks('grunt-contrib-concat');
79 |   grunt.loadNpmTasks('grunt-contrib-uglify');
80 | 
81 |   // Default task.
82 |   grunt.registerTask('default', ['jslint','clean','concat','uglify']);
83 | 
84 | };
85 | 


--------------------------------------------------------------------------------
/LICENSE-MIT:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2012 NPR
 2 | 
 3 | Permission is hereby granted, free of charge, to any person
 4 | obtaining a copy of this software and associated documentation
 5 | files (the "Software"), to deal in the Software without
 6 | restriction, including without limitation the rights to use,
 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the
 9 | Software is furnished to do so, subject to the following
10 | conditions:
11 | 
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## Documentation
 2 | 
 3 | [http://npr.github.com/responsiveiframe/](http://npr.github.com/responsiveiframe/)
 4 | 
 5 | ## Credits
 6 | 
 7 | Built and maintained [@NPR](http://github.com/npr/) by
 8 | * [John Nelson](https://github.com/johnymonster),
 9 | * [Mike Seid](https://github.com/mbseid),
10 | * [Jared Biehler] (https://github.com/jaredbiehler),
11 | * [Irakli Nadareishvili](https://github.com/inadarei) and
12 | * [Andy Winder](https://github.com/awinder)
13 | 
14 | Based on the original prototype by [Ioseb Dzmanashvili](https://github.com/ioseb). 
15 | 
16 | ## License 
17 | 
18 | The MIT License (MIT)
19 | 
20 | Copyright (c) 2011-2014 NPR.
21 | 
22 | Permission is hereby granted, free of charge, to any person obtaining
23 | a copy of this software and associated documentation files (the
24 | 'Software'), to deal in the Software without restriction, including
25 | without limitation the rights to use, copy, modify, merge, publish,
26 | distribute, sublicense, and/or sell copies of the Software, and to
27 | permit persons to whom the Software is furnished to do so, subject to
28 | the following conditions:
29 | 
30 | The above copyright notice and this permission notice shall be
31 | included in all copies or substantial portions of the Software.
32 | 
33 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
34 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
35 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
36 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
37 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
38 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
39 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
40 | 


--------------------------------------------------------------------------------
/demo/child.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 
 3 | <head>
 4 | 	<script type="text/javascript" src="../src/jquery.responsiveiframe.js"></script>
 5 | 	<script type="text/javascript">	
 6 | 		var ir = responsiveIframe();
 7 | 		ir.allowResponsiveEmbedding();
 8 | 	</script>
 9 | </head>
10 | <body>
11 | 	<div>
12 | 	Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam rhoncus elit id velit pharetra sodales. Sed eu tellus in orci vestibulum elementum. Aliquam erat volutpat. In pharetra neque a massa pretium hendrerit. Ut aliquet lorem sed est tincidunt semper. Suspendisse ut diam tortor, ac porttitor tellus. Donec sit amet sapien at magna facilisis facilisis. Vivamus eget libero ac diam molestie cursus. Nulla mauris lectus, ullamcorper vitae blandit sit amet, tempus eget nisi. Ut id lacus ut sem adipiscing rutrum vel sit amet neque. Nullam egestas porttitor risus, at ultricies mi tristique ac. Praesent fermentum ipsum rhoncus lorem scelerisque quis venenatis lacus sagittis. Aenean aliquam, nunc ut sollicitudin suscipit, metus massa sodales justo, quis convallis tellus turpis a nunc. Integer lacinia erat ut dolor rhoncus eu venenatis dolor luctus. Aenean sit amet diam sed erat sagittis tempus. Quisque sed ultrices nunc.
13 | 
14 | Nullam tempus commodo tortor. Fusce at cursus est. Vestibulum euismod odio nisl, congue congue lectus. Donec ac nunc nec sapien volutpat aliquet et a turpis. Nulla eget ipsum arcu. Suspendisse facilisis dignissim elementum. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Morbi sem ante, viverra nec tristique placerat, imperdiet in augue. Sed vel tempus justo. Sed ac odio at massa iaculis dignissim ut sed tellus. Cras in diam et lorem congue fermentum. Ut porta lectus a risus dapibus bibendum. Vivamus eget felis purus, tristique pretium diam.
15 | 
16 | Vivamus enim sapien, consectetur sit amet euismod a, porttitor a quam. Morbi ac arcu nec purus interdum egestas at non magna. Mauris vel nibh leo, ac ullamcorper dolor. Donec ullamcorper purus dapibus odio varius tempus. Etiam scelerisque, urna cursus feugiat scelerisque, libero ante ultrices odio, sed tempor ante enim non ante. Proin eu nibh eget nunc ornare vulputate. Nullam in rhoncus eros. Nunc vel faucibus sem. Sed vel dignissim sapien. Praesent a erat a sapien ullamcorper varius. Duis purus mi, molestie vitae ultricies at, dignissim quis lectus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin non ante ut sapien fringilla ornare a ac metus. Mauris vitae enim libero. Integer tortor libero, volutpat eu gravida sit amet, ultrices non est. Curabitur eget sapien lorem, nec ullamcorper nisl.
17 | 
18 | Maecenas nisl lorem, blandit in rhoncus ut, hendrerit vel metus. Phasellus diam quam, tristique nec vehicula nec, cursus nec eros. Duis odio metus, tincidunt ac bibendum sodales, tristique quis diam. Aenean imperdiet dui quis elit ornare suscipit. Nulla a fringilla nisl. Nulla facilisi. Nulla ut magna ac erat dapibus tempor et et nisl. Integer aliquet, dui eget pharetra dapibus, sapien neque aliquet diam, non molestie mi risus et dolor. Aliquam non ultrices nibh. Duis sed urna dolor. Etiam vitae dolor arcu, quis lacinia ligula.
19 | 
20 | Vestibulum auctor mattis adipiscing. Integer condimentum, tellus sed commodo bibendum, justo quam pharetra nisl, vel viverra ipsum quam at purus. Aliquam aliquet velit imperdiet leo consequat quis tempor neque aliquam. Pellentesque aliquet varius porttitor. Nulla facilisi. Aenean nec tempor elit. Morbi nec congue lectus.
21 | 	</div>
22 | </body>
23 | </html>
24 | 


--------------------------------------------------------------------------------
/demo/index.html:
--------------------------------------------------------------------------------
 1 | <html>
 2 | 
 3 | <head>
 4 |     <script src="https:////ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js"></script>
 5 | 	<script type="text/javascript" src="../src/jquery.responsiveiframe.js"></script>
 6 | 	<script type="text/javascript">	
 7 | 		$(function() {
 8 |       $('iframe').responsiveIframe({this: 'isnt', that: 'is'});
 9 |     });
10 | 	</script>
11 | </head>
12 | <body>
13 | 	<div id="embed"><iframe src="child.html" style="width: 100%; padding: 0px;margin: 0; border: none; display: block;height:0px; overflow: hidden;"></iframe></div>
14 | </body>
15 | </html>
16 | 


--------------------------------------------------------------------------------
/dist/jquery.responsiveiframe.js:
--------------------------------------------------------------------------------
  1 | /*! jQuery ResponsiveIframe - v0.0.3 - 2013-09-05
  2 | * https://github.com/npr/responsiveiframe
  3 | * Copyright (c) 2013 Irakli Nadareishvili; Licensed MIT, GPL */
  4 | if (typeof jQuery !== 'undefined') {
  5 |   (function( $ ){
  6 |     var settings = {
  7 |       xdomain: '*',
  8 |       ie : navigator.userAgent.toLowerCase().indexOf('msie') > -1,
  9 |       scrollToTop: true
 10 |     };
 11 | 
 12 |     var methods = {
 13 |       // initialization for the parent, the one housing this
 14 |       init: function() {
 15 |         return this.each(function(self){
 16 |           var $this = $(this);
 17 | 
 18 |           if (window.postMessage) {
 19 |             if (window.addEventListener) {
 20 |               window.addEventListener('message', function(e) {
 21 |                 privateMethods.messageHandler($this,e);
 22 |               } , false);
 23 |             } else if (window.attachEvent) {
 24 |               window.attachEvent('onmessage', function(e) {
 25 |                 privateMethods.messageHandler($this,e);
 26 |               }, $this);
 27 |             }
 28 |           } else {
 29 |             setInterval(function () {
 30 |               var hash = window.location.hash, matches = hash.match(/^#h(\d+)(s?)$/);
 31 |               if (matches) {
 32 |                 privateMethods.setHeight($this, matches[1]);
 33 |                 if (settings.scrollToTop && matches[2] === 's'){
 34 |                   scroll(0,0);
 35 |                 }
 36 |               }
 37 |             }, 150);
 38 |           }
 39 |         });
 40 |       }
 41 |     };
 42 | 
 43 |     var privateMethods = {
 44 |       messageHandler: function (elem, e) {
 45 |         var height,
 46 |           r,
 47 |           matches,
 48 |           strD;
 49 | 
 50 |         if (settings.xdomain !== '*') {
 51 |           var regex = new RegExp(settings.xdomain + '$');
 52 |           if(e.origin == "null"){
 53 |             throw new Error("messageHandler( elem, e): There is no origin.  You are viewing the page from your file system.  Please run through a web server.");
 54 |           }
 55 |           if(e.origin.match(regex)){
 56 |             matches = true;
 57 |           }else{
 58 |             throw new Error("messageHandler( elem, e): The orgin doesn't match the responsiveiframe  xdomain.");
 59 |           }
 60 |         
 61 |         }
 62 | 
 63 |         if(settings.xdomain === '*' || matches ) {
 64 |           strD = e.data + "";
 65 |           r = strD.match(/^(\d+)(s?)$/);
 66 |           if(r && r.length === 3){
 67 |             height = parseInt(r[1], 10);
 68 |             if (!isNaN(height)) {
 69 |               try {
 70 |                 privateMethods.setHeight(elem, height);
 71 |               } catch (ex) {}
 72 |             }
 73 |             if (settings.scrollToTop && r[2] === "s"){
 74 |               scroll(0,0);
 75 |             }
 76 |           }
 77 |         }
 78 |       },
 79 | 
 80 |       // Sets the height of the iframe
 81 |       setHeight : function (elem, height) {
 82 |         elem.css('height', height + 'px');
 83 |       },
 84 |       getDocHeight: function () {
 85 |         var D = document;
 86 |         return Math.min(
 87 |           Math.max(D.body.scrollHeight, D.documentElement.scrollHeight),
 88 |           Math.max(D.body.offsetHeight, D.documentElement.offsetHeight),
 89 |           Math.max(D.body.clientHeight, D.documentElement.clientHeight)
 90 |         );
 91 |       }
 92 |     };
 93 | 
 94 |     $.fn.responsiveIframe = function( method ) {
 95 |       if ( methods[method] ) {
 96 |         return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ));
 97 |       } else if ( typeof method === 'object' || ! method ) {
 98 |         $.extend(settings, arguments[0]);
 99 |         return methods.init.apply( this );
100 |       } else {
101 |         $.error( 'Method ' +  method + ' does not exist on jQuery.responsiveIframe' );
102 |       }
103 |     };
104 |   }( jQuery ));
105 | }
106 | 
107 | ;(function(){
108 |   var self,
109 |       module,
110 |       ResponsiveIframe = function () {self = this;};
111 | 
112 |   ResponsiveIframe.prototype.allowResponsiveEmbedding = function() {
113 |     if (window.addEventListener) {
114 |       window.addEventListener("load", self.messageParent, false);
115 |       window.addEventListener("resize", self.messageParent, false);
116 |     } else if (window.attachEvent) {
117 |       window.attachEvent("onload", self.messageParent);
118 |       window.attachEvent("onresize", self.messageParent);
119 |     }
120 |   };
121 | 
122 |   ResponsiveIframe.prototype.messageParent = function(scrollTop) {
123 |     var h = document.body.offsetHeight;
124 |     h = (scrollTop)? h+'s':h;
125 |     if(top.postMessage){
126 |       top.postMessage( h , '*');
127 |     } else {
128 |       window.location.hash = 'h'+h;
129 |     }
130 |   };
131 | 
132 |   function responsiveIframe() {
133 |     return new ResponsiveIframe();
134 |   }
135 | 
136 |   // expose
137 |   if ('undefined' === typeof exports) {
138 |     window.responsiveIframe = responsiveIframe;
139 |   } else {
140 |     module.exports.responsiveIframe = responsiveIframe;
141 |   }
142 | }());


--------------------------------------------------------------------------------
/dist/jquery.responsiveiframe.min.js:
--------------------------------------------------------------------------------
1 | /*! jQuery ResponsiveIframe - v0.0.3 - 2013-09-05
2 | * https://github.com/npr/responsiveiframe
3 | * Copyright (c) 2013 Irakli Nadareishvili; Licensed MIT, GPL */
4 | "undefined"!=typeof jQuery&&!function(a){var b={xdomain:"*",ie:navigator.userAgent.toLowerCase().indexOf("msie")>-1,scrollToTop:!0},c={init:function(){return this.each(function(){var c=a(this);window.postMessage?window.addEventListener?window.addEventListener("message",function(a){d.messageHandler(c,a)},!1):window.attachEvent&&window.attachEvent("onmessage",function(a){d.messageHandler(c,a)},c):setInterval(function(){var a=window.location.hash,e=a.match(/^#h(\d+)(s?)$/);e&&(d.setHeight(c,e[1]),b.scrollToTop&&"s"===e[2]&&scroll(0,0))},150)})}},d={messageHandler:function(a,c){var e,f,g,h;if("*"!==b.xdomain){var i=new RegExp(b.xdomain+"$");if("null"==c.origin)throw new Error("messageHandler( elem, e): There is no origin.  You are viewing the page from your file system.  Please run through a web server.");if(!c.origin.match(i))throw new Error("messageHandler( elem, e): The orgin doesn't match the responsiveiframe  xdomain.");g=!0}if(("*"===b.xdomain||g)&&(h=c.data+"",f=h.match(/^(\d+)(s?)$/),f&&3===f.length)){if(e=parseInt(f[1],10),!isNaN(e))try{d.setHeight(a,e)}catch(j){}b.scrollToTop&&"s"===f[2]&&scroll(0,0)}},setHeight:function(a,b){a.css("height",b+"px")},getDocHeight:function(){var a=document;return Math.min(Math.max(a.body.scrollHeight,a.documentElement.scrollHeight),Math.max(a.body.offsetHeight,a.documentElement.offsetHeight),Math.max(a.body.clientHeight,a.documentElement.clientHeight))}};a.fn.responsiveIframe=function(d){return c[d]?c[d].apply(this,Array.prototype.slice.call(arguments,1)):"object"!=typeof d&&d?(a.error("Method "+d+" does not exist on jQuery.responsiveIframe"),void 0):(a.extend(b,arguments[0]),c.init.apply(this))}}(jQuery),function(){function a(){return new d}var b,c,d=function(){b=this};d.prototype.allowResponsiveEmbedding=function(){window.addEventListener?(window.addEventListener("load",b.messageParent,!1),window.addEventListener("resize",b.messageParent,!1)):window.attachEvent&&(window.attachEvent("onload",b.messageParent),window.attachEvent("onresize",b.messageParent))},d.prototype.messageParent=function(a){var b=document.body.offsetHeight;b=a?b+"s":b,top.postMessage?top.postMessage(b,"*"):window.location.hash="h"+b},"undefined"==typeof exports?window.responsiveIframe=a:c.exports.responsiveIframe=a}();


--------------------------------------------------------------------------------
/libs/qunit/qunit.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * QUnit v1.4.0 - A JavaScript Unit Testing Framework
  3 |  *
  4 |  * http://docs.jquery.com/QUnit
  5 |  *
  6 |  * Copyright (c) 2012 John Resig, Jörn Zaefferer
  7 |  * Dual licensed under the MIT (MIT-LICENSE.txt)
  8 |  * or GPL (GPL-LICENSE.txt) licenses.
  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-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
 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: 15px 15px 0 0;
 42 | 	-moz-border-radius: 15px 15px 0 0;
 43 | 	-webkit-border-top-right-radius: 15px;
 44 | 	-webkit-border-top-left-radius: 15px;
 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-header label {
 58 | 	display: inline-block;
 59 | }
 60 | 
 61 | #qunit-banner {
 62 | 	height: 5px;
 63 | }
 64 | 
 65 | #qunit-testrunner-toolbar {
 66 | 	padding: 0.5em 0 0.5em 2em;
 67 | 	color: #5E740B;
 68 | 	background-color: #eee;
 69 | }
 70 | 
 71 | #qunit-userAgent {
 72 | 	padding: 0.5em 0 0.5em 2.5em;
 73 | 	background-color: #2b81af;
 74 | 	color: #fff;
 75 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 76 | }
 77 | 
 78 | 
 79 | /** Tests: Pass/Fail */
 80 | 
 81 | #qunit-tests {
 82 | 	list-style-position: inside;
 83 | }
 84 | 
 85 | #qunit-tests li {
 86 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 87 | 	border-bottom: 1px solid #fff;
 88 | 	list-style-position: inside;
 89 | }
 90 | 
 91 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 92 | 	display: none;
 93 | }
 94 | 
 95 | #qunit-tests li strong {
 96 | 	cursor: pointer;
 97 | }
 98 | 
 99 | #qunit-tests li a {
100 | 	padding: 0.5em;
101 | 	color: #c2ccd1;
102 | 	text-decoration: none;
103 | }
104 | #qunit-tests li a:hover,
105 | #qunit-tests li a:focus {
106 | 	color: #000;
107 | }
108 | 
109 | #qunit-tests ol {
110 | 	margin-top: 0.5em;
111 | 	padding: 0.5em;
112 | 
113 | 	background-color: #fff;
114 | 
115 | 	border-radius: 15px;
116 | 	-moz-border-radius: 15px;
117 | 	-webkit-border-radius: 15px;
118 | 
119 | 	box-shadow: inset 0px 2px 13px #999;
120 | 	-moz-box-shadow: inset 0px 2px 13px #999;
121 | 	-webkit-box-shadow: inset 0px 2px 13px #999;
122 | }
123 | 
124 | #qunit-tests table {
125 | 	border-collapse: collapse;
126 | 	margin-top: .2em;
127 | }
128 | 
129 | #qunit-tests th {
130 | 	text-align: right;
131 | 	vertical-align: top;
132 | 	padding: 0 .5em 0 0;
133 | }
134 | 
135 | #qunit-tests td {
136 | 	vertical-align: top;
137 | }
138 | 
139 | #qunit-tests pre {
140 | 	margin: 0;
141 | 	white-space: pre-wrap;
142 | 	word-wrap: break-word;
143 | }
144 | 
145 | #qunit-tests del {
146 | 	background-color: #e0f2be;
147 | 	color: #374e0c;
148 | 	text-decoration: none;
149 | }
150 | 
151 | #qunit-tests ins {
152 | 	background-color: #ffcaca;
153 | 	color: #500;
154 | 	text-decoration: none;
155 | }
156 | 
157 | /*** Test Counts */
158 | 
159 | #qunit-tests b.counts                       { color: black; }
160 | #qunit-tests b.passed                       { color: #5E740B; }
161 | #qunit-tests b.failed                       { color: #710909; }
162 | 
163 | #qunit-tests li li {
164 | 	margin: 0.5em;
165 | 	padding: 0.4em 0.5em 0.4em 0.5em;
166 | 	background-color: #fff;
167 | 	border-bottom: none;
168 | 	list-style-position: inside;
169 | }
170 | 
171 | /*** Passing Styles */
172 | 
173 | #qunit-tests li li.pass {
174 | 	color: #5E740B;
175 | 	background-color: #fff;
176 | 	border-left: 26px solid #C6E746;
177 | }
178 | 
179 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
180 | #qunit-tests .pass .test-name               { color: #366097; }
181 | 
182 | #qunit-tests .pass .test-actual,
183 | #qunit-tests .pass .test-expected           { color: #999999; }
184 | 
185 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
186 | 
187 | /*** Failing Styles */
188 | 
189 | #qunit-tests li li.fail {
190 | 	color: #710909;
191 | 	background-color: #fff;
192 | 	border-left: 26px solid #EE5757;
193 | 	white-space: pre;
194 | }
195 | 
196 | #qunit-tests > li:last-child {
197 | 	border-radius: 0 0 15px 15px;
198 | 	-moz-border-radius: 0 0 15px 15px;
199 | 	-webkit-border-bottom-right-radius: 15px;
200 | 	-webkit-border-bottom-left-radius: 15px;
201 | }
202 | 
203 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
204 | #qunit-tests .fail .test-name,
205 | #qunit-tests .fail .module-name             { color: #000000; }
206 | 
207 | #qunit-tests .fail .test-actual             { color: #EE5757; }
208 | #qunit-tests .fail .test-expected           { color: green;   }
209 | 
210 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
211 | 
212 | 
213 | /** Result */
214 | 
215 | #qunit-testresult {
216 | 	padding: 0.5em 0.5em 0.5em 2.5em;
217 | 
218 | 	color: #2b81af;
219 | 	background-color: #D2E0E6;
220 | 
221 | 	border-bottom: 1px solid white;
222 | }
223 | 
224 | /** Fixture */
225 | 
226 | #qunit-fixture {
227 | 	position: absolute;
228 | 	top: -10000px;
229 | 	left: -10000px;
230 | 	width: 1000px;
231 | 	height: 1000px;
232 | }
233 | 


--------------------------------------------------------------------------------
/libs/qunit/qunit.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * QUnit v1.4.0 - A JavaScript Unit Testing Framework
   3 |  *
   4 |  * http://docs.jquery.com/QUnit
   5 |  *
   6 |  * Copyright (c) 2012 John Resig, Jörn Zaefferer
   7 |  * Dual licensed under the MIT (MIT-LICENSE.txt)
   8 |  * or GPL (GPL-LICENSE.txt) licenses.
   9 |  */
  10 | 
  11 | (function(window) {
  12 | 
  13 | var defined = {
  14 | 	setTimeout: typeof window.setTimeout !== "undefined",
  15 | 	sessionStorage: (function() {
  16 | 		var x = "qunit-test-string";
  17 | 		try {
  18 | 			sessionStorage.setItem(x, x);
  19 | 			sessionStorage.removeItem(x);
  20 | 			return true;
  21 | 		} catch(e) {
  22 | 			return false;
  23 | 		}
  24 | 	}())
  25 | };
  26 | 
  27 | var	testId = 0,
  28 | 	toString = Object.prototype.toString,
  29 | 	hasOwn = Object.prototype.hasOwnProperty;
  30 | 
  31 | var Test = function(name, testName, expected, async, callback) {
  32 | 	this.name = name;
  33 | 	this.testName = testName;
  34 | 	this.expected = expected;
  35 | 	this.async = async;
  36 | 	this.callback = callback;
  37 | 	this.assertions = [];
  38 | };
  39 | Test.prototype = {
  40 | 	init: function() {
  41 | 		var tests = id("qunit-tests");
  42 | 		if (tests) {
  43 | 			var b = document.createElement("strong");
  44 | 				b.innerHTML = "Running " + this.name;
  45 | 			var li = document.createElement("li");
  46 | 				li.appendChild( b );
  47 | 				li.className = "running";
  48 | 				li.id = this.id = "test-output" + testId++;
  49 | 			tests.appendChild( li );
  50 | 		}
  51 | 	},
  52 | 	setup: function() {
  53 | 		if (this.module != config.previousModule) {
  54 | 			if ( config.previousModule ) {
  55 | 				runLoggingCallbacks('moduleDone', QUnit, {
  56 | 					name: config.previousModule,
  57 | 					failed: config.moduleStats.bad,
  58 | 					passed: config.moduleStats.all - config.moduleStats.bad,
  59 | 					total: config.moduleStats.all
  60 | 				} );
  61 | 			}
  62 | 			config.previousModule = this.module;
  63 | 			config.moduleStats = { all: 0, bad: 0 };
  64 | 			runLoggingCallbacks( 'moduleStart', QUnit, {
  65 | 				name: this.module
  66 | 			} );
  67 | 		} else if (config.autorun) {
  68 | 			runLoggingCallbacks( 'moduleStart', QUnit, {
  69 | 				name: this.module
  70 | 			} );
  71 | 		}
  72 | 
  73 | 		config.current = this;
  74 | 		this.testEnvironment = extend({
  75 | 			setup: function() {},
  76 | 			teardown: function() {}
  77 | 		}, this.moduleTestEnvironment);
  78 | 
  79 | 		runLoggingCallbacks( 'testStart', QUnit, {
  80 | 			name: this.testName,
  81 | 			module: this.module
  82 | 		});
  83 | 
  84 | 		// allow utility functions to access the current test environment
  85 | 		// TODO why??
  86 | 		QUnit.current_testEnvironment = this.testEnvironment;
  87 | 
  88 | 		if ( !config.pollution ) {
  89 | 			saveGlobal();
  90 | 		}
  91 | 		if ( config.notrycatch ) {
  92 | 			this.testEnvironment.setup.call(this.testEnvironment);
  93 | 			return;
  94 | 		}
  95 | 		try {
  96 | 			this.testEnvironment.setup.call(this.testEnvironment);
  97 | 		} catch(e) {
  98 | 			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + e.message, extractStacktrace( e, 1 ) );
  99 | 		}
 100 | 	},
 101 | 	run: function() {
 102 | 		config.current = this;
 103 | 		if ( this.async ) {
 104 | 			QUnit.stop();
 105 | 		}
 106 | 
 107 | 		if ( config.notrycatch ) {
 108 | 			this.callback.call(this.testEnvironment);
 109 | 			return;
 110 | 		}
 111 | 		try {
 112 | 			this.callback.call(this.testEnvironment);
 113 | 		} catch(e) {
 114 | 			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + ": " + e.message, extractStacktrace( e, 1 ) );
 115 | 			// else next test will carry the responsibility
 116 | 			saveGlobal();
 117 | 
 118 | 			// Restart the tests if they're blocking
 119 | 			if ( config.blocking ) {
 120 | 				QUnit.start();
 121 | 			}
 122 | 		}
 123 | 	},
 124 | 	teardown: function() {
 125 | 		config.current = this;
 126 | 		if ( config.notrycatch ) {
 127 | 			this.testEnvironment.teardown.call(this.testEnvironment);
 128 | 			return;
 129 | 		} else {
 130 | 			try {
 131 | 				this.testEnvironment.teardown.call(this.testEnvironment);
 132 | 			} catch(e) {
 133 | 				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + e.message, extractStacktrace( e, 1 ) );
 134 | 			}
 135 | 		}
 136 | 		checkPollution();
 137 | 	},
 138 | 	finish: function() {
 139 | 		config.current = this;
 140 | 		if ( this.expected != null && this.expected != this.assertions.length ) {
 141 | 			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" );
 142 | 		} else if ( this.expected == null && !this.assertions.length ) {
 143 | 			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions." );
 144 | 		}
 145 | 
 146 | 		var good = 0, bad = 0,
 147 | 			li, i,
 148 | 			tests = id("qunit-tests");
 149 | 
 150 | 		config.stats.all += this.assertions.length;
 151 | 		config.moduleStats.all += this.assertions.length;
 152 | 
 153 | 		if ( tests ) {
 154 | 			var ol = document.createElement("ol");
 155 | 
 156 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 157 | 				var assertion = this.assertions[i];
 158 | 
 159 | 				li = document.createElement("li");
 160 | 				li.className = assertion.result ? "pass" : "fail";
 161 | 				li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed");
 162 | 				ol.appendChild( li );
 163 | 
 164 | 				if ( assertion.result ) {
 165 | 					good++;
 166 | 				} else {
 167 | 					bad++;
 168 | 					config.stats.bad++;
 169 | 					config.moduleStats.bad++;
 170 | 				}
 171 | 			}
 172 | 
 173 | 			// store result when possible
 174 | 			if ( QUnit.config.reorder && defined.sessionStorage ) {
 175 | 				if (bad) {
 176 | 					sessionStorage.setItem("qunit-test-" + this.module + "-" + this.testName, bad);
 177 | 				} else {
 178 | 					sessionStorage.removeItem("qunit-test-" + this.module + "-" + this.testName);
 179 | 				}
 180 | 			}
 181 | 
 182 | 			if (bad === 0) {
 183 | 				ol.style.display = "none";
 184 | 			}
 185 | 
 186 | 			var b = document.createElement("strong");
 187 | 			b.innerHTML = this.name + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
 188 | 
 189 | 			var a = document.createElement("a");
 190 | 			a.innerHTML = "Rerun";
 191 | 			a.href = QUnit.url({ filter: getText([b]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });
 192 | 
 193 | 			addEvent(b, "click", function() {
 194 | 				var next = b.nextSibling.nextSibling,
 195 | 					display = next.style.display;
 196 | 				next.style.display = display === "none" ? "block" : "none";
 197 | 			});
 198 | 
 199 | 			addEvent(b, "dblclick", function(e) {
 200 | 				var target = e && e.target ? e.target : window.event.srcElement;
 201 | 				if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
 202 | 					target = target.parentNode;
 203 | 				}
 204 | 				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
 205 | 					window.location = QUnit.url({ filter: getText([target]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });
 206 | 				}
 207 | 			});
 208 | 
 209 | 			li = id(this.id);
 210 | 			li.className = bad ? "fail" : "pass";
 211 | 			li.removeChild( li.firstChild );
 212 | 			li.appendChild( b );
 213 | 			li.appendChild( a );
 214 | 			li.appendChild( ol );
 215 | 
 216 | 		} else {
 217 | 			for ( i = 0; i < this.assertions.length; i++ ) {
 218 | 				if ( !this.assertions[i].result ) {
 219 | 					bad++;
 220 | 					config.stats.bad++;
 221 | 					config.moduleStats.bad++;
 222 | 				}
 223 | 			}
 224 | 		}
 225 | 
 226 | 		QUnit.reset();
 227 | 
 228 | 		runLoggingCallbacks( 'testDone', QUnit, {
 229 | 			name: this.testName,
 230 | 			module: this.module,
 231 | 			failed: bad,
 232 | 			passed: this.assertions.length - bad,
 233 | 			total: this.assertions.length
 234 | 		} );
 235 | 	},
 236 | 
 237 | 	queue: function() {
 238 | 		var test = this;
 239 | 		synchronize(function() {
 240 | 			test.init();
 241 | 		});
 242 | 		function run() {
 243 | 			// each of these can by async
 244 | 			synchronize(function() {
 245 | 				test.setup();
 246 | 			});
 247 | 			synchronize(function() {
 248 | 				test.run();
 249 | 			});
 250 | 			synchronize(function() {
 251 | 				test.teardown();
 252 | 			});
 253 | 			synchronize(function() {
 254 | 				test.finish();
 255 | 			});
 256 | 		}
 257 | 		// defer when previous test run passed, if storage is available
 258 | 		var bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-test-" + this.module + "-" + this.testName);
 259 | 		if (bad) {
 260 | 			run();
 261 | 		} else {
 262 | 			synchronize(run, true);
 263 | 		}
 264 | 	}
 265 | 
 266 | };
 267 | 
 268 | var QUnit = {
 269 | 
 270 | 	// call on start of module test to prepend name to all tests
 271 | 	module: function(name, testEnvironment) {
 272 | 		config.currentModule = name;
 273 | 		config.currentModuleTestEnviroment = testEnvironment;
 274 | 	},
 275 | 
 276 | 	asyncTest: function(testName, expected, callback) {
 277 | 		if ( arguments.length === 2 ) {
 278 | 			callback = expected;
 279 | 			expected = null;
 280 | 		}
 281 | 
 282 | 		QUnit.test(testName, expected, callback, true);
 283 | 	},
 284 | 
 285 | 	test: function(testName, expected, callback, async) {
 286 | 		var name = '<span class="test-name">' + escapeInnerText(testName) + '</span>';
 287 | 
 288 | 		if ( arguments.length === 2 ) {
 289 | 			callback = expected;
 290 | 			expected = null;
 291 | 		}
 292 | 
 293 | 		if ( config.currentModule ) {
 294 | 			name = '<span class="module-name">' + config.currentModule + "</span>: " + name;
 295 | 		}
 296 | 
 297 | 		if ( !validTest(config.currentModule + ": " + testName) ) {
 298 | 			return;
 299 | 		}
 300 | 
 301 | 		var test = new Test(name, testName, expected, async, callback);
 302 | 		test.module = config.currentModule;
 303 | 		test.moduleTestEnvironment = config.currentModuleTestEnviroment;
 304 | 		test.queue();
 305 | 	},
 306 | 
 307 | 	// Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
 308 | 	expect: function(asserts) {
 309 | 		config.current.expected = asserts;
 310 | 	},
 311 | 
 312 | 	// Asserts true.
 313 | 	// @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
 314 | 	ok: function(result, msg) {
 315 | 		if (!config.current) {
 316 | 			throw new Error("ok() assertion outside test context, was " + sourceFromStacktrace(2));
 317 | 		}
 318 | 		result = !!result;
 319 | 		var details = {
 320 | 			result: result,
 321 | 			message: msg
 322 | 		};
 323 | 		msg = escapeInnerText(msg || (result ? "okay" : "failed"));
 324 | 		if ( !result ) {
 325 | 			var source = sourceFromStacktrace(2);
 326 | 			if (source) {
 327 | 				details.source = source;
 328 | 				msg += '<table><tr class="test-source"><th>Source: </th><td><pre>' + escapeInnerText(source) + '</pre></td></tr></table>';
 329 | 			}
 330 | 		}
 331 | 		runLoggingCallbacks( 'log', QUnit, details );
 332 | 		config.current.assertions.push({
 333 | 			result: result,
 334 | 			message: msg
 335 | 		});
 336 | 	},
 337 | 
 338 | 	// Checks that the first two arguments are equal, with an optional message. Prints out both actual and expected values.
 339 | 	// @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );
 340 | 	equal: function(actual, expected, message) {
 341 | 		QUnit.push(expected == actual, actual, expected, message);
 342 | 	},
 343 | 
 344 | 	notEqual: function(actual, expected, message) {
 345 | 		QUnit.push(expected != actual, actual, expected, message);
 346 | 	},
 347 | 
 348 | 	deepEqual: function(actual, expected, message) {
 349 | 		QUnit.push(QUnit.equiv(actual, expected), actual, expected, message);
 350 | 	},
 351 | 
 352 | 	notDeepEqual: function(actual, expected, message) {
 353 | 		QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message);
 354 | 	},
 355 | 
 356 | 	strictEqual: function(actual, expected, message) {
 357 | 		QUnit.push(expected === actual, actual, expected, message);
 358 | 	},
 359 | 
 360 | 	notStrictEqual: function(actual, expected, message) {
 361 | 		QUnit.push(expected !== actual, actual, expected, message);
 362 | 	},
 363 | 
 364 | 	raises: function(block, expected, message) {
 365 | 		var actual, ok = false;
 366 | 
 367 | 		if (typeof expected === 'string') {
 368 | 			message = expected;
 369 | 			expected = null;
 370 | 		}
 371 | 
 372 | 		try {
 373 | 			block();
 374 | 		} catch (e) {
 375 | 			actual = e;
 376 | 		}
 377 | 
 378 | 		if (actual) {
 379 | 			// we don't want to validate thrown error
 380 | 			if (!expected) {
 381 | 				ok = true;
 382 | 			// expected is a regexp
 383 | 			} else if (QUnit.objectType(expected) === "regexp") {
 384 | 				ok = expected.test(actual);
 385 | 			// expected is a constructor
 386 | 			} else if (actual instanceof expected) {
 387 | 				ok = true;
 388 | 			// expected is a validation function which returns true is validation passed
 389 | 			} else if (expected.call({}, actual) === true) {
 390 | 				ok = true;
 391 | 			}
 392 | 		}
 393 | 
 394 | 		QUnit.ok(ok, message);
 395 | 	},
 396 | 
 397 | 	start: function(count) {
 398 | 		config.semaphore -= count || 1;
 399 | 		if (config.semaphore > 0) {
 400 | 			// don't start until equal number of stop-calls
 401 | 			return;
 402 | 		}
 403 | 		if (config.semaphore < 0) {
 404 | 			// ignore if start is called more often then stop
 405 | 			config.semaphore = 0;
 406 | 		}
 407 | 		// A slight delay, to avoid any current callbacks
 408 | 		if ( defined.setTimeout ) {
 409 | 			window.setTimeout(function() {
 410 | 				if (config.semaphore > 0) {
 411 | 					return;
 412 | 				}
 413 | 				if ( config.timeout ) {
 414 | 					clearTimeout(config.timeout);
 415 | 				}
 416 | 
 417 | 				config.blocking = false;
 418 | 				process(true);
 419 | 			}, 13);
 420 | 		} else {
 421 | 			config.blocking = false;
 422 | 			process(true);
 423 | 		}
 424 | 	},
 425 | 
 426 | 	stop: function(count) {
 427 | 		config.semaphore += count || 1;
 428 | 		config.blocking = true;
 429 | 
 430 | 		if ( config.testTimeout && defined.setTimeout ) {
 431 | 			clearTimeout(config.timeout);
 432 | 			config.timeout = window.setTimeout(function() {
 433 | 				QUnit.ok( false, "Test timed out" );
 434 | 				config.semaphore = 1;
 435 | 				QUnit.start();
 436 | 			}, config.testTimeout);
 437 | 		}
 438 | 	}
 439 | };
 440 | 
 441 | //We want access to the constructor's prototype
 442 | (function() {
 443 | 	function F(){}
 444 | 	F.prototype = QUnit;
 445 | 	QUnit = new F();
 446 | 	//Make F QUnit's constructor so that we can add to the prototype later
 447 | 	QUnit.constructor = F;
 448 | }());
 449 | 
 450 | // deprecated; still export them to window to provide clear error messages
 451 | // next step: remove entirely
 452 | QUnit.equals = function() {
 453 | 	QUnit.push(false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead");
 454 | };
 455 | QUnit.same = function() {
 456 | 	QUnit.push(false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead");
 457 | };
 458 | 
 459 | // Maintain internal state
 460 | var config = {
 461 | 	// The queue of tests to run
 462 | 	queue: [],
 463 | 
 464 | 	// block until document ready
 465 | 	blocking: true,
 466 | 
 467 | 	// when enabled, show only failing tests
 468 | 	// gets persisted through sessionStorage and can be changed in UI via checkbox
 469 | 	hidepassed: false,
 470 | 
 471 | 	// by default, run previously failed tests first
 472 | 	// very useful in combination with "Hide passed tests" checked
 473 | 	reorder: true,
 474 | 
 475 | 	// by default, modify document.title when suite is done
 476 | 	altertitle: true,
 477 | 
 478 | 	urlConfig: ['noglobals', 'notrycatch'],
 479 | 
 480 | 	//logging callback queues
 481 | 	begin: [],
 482 | 	done: [],
 483 | 	log: [],
 484 | 	testStart: [],
 485 | 	testDone: [],
 486 | 	moduleStart: [],
 487 | 	moduleDone: []
 488 | };
 489 | 
 490 | // Load paramaters
 491 | (function() {
 492 | 	var location = window.location || { search: "", protocol: "file:" },
 493 | 		params = location.search.slice( 1 ).split( "&" ),
 494 | 		length = params.length,
 495 | 		urlParams = {},
 496 | 		current;
 497 | 
 498 | 	if ( params[ 0 ] ) {
 499 | 		for ( var i = 0; i < length; i++ ) {
 500 | 			current = params[ i ].split( "=" );
 501 | 			current[ 0 ] = decodeURIComponent( current[ 0 ] );
 502 | 			// allow just a key to turn on a flag, e.g., test.html?noglobals
 503 | 			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
 504 | 			urlParams[ current[ 0 ] ] = current[ 1 ];
 505 | 		}
 506 | 	}
 507 | 
 508 | 	QUnit.urlParams = urlParams;
 509 | 	config.filter = urlParams.filter;
 510 | 
 511 | 	// Figure out if we're running the tests from a server or not
 512 | 	QUnit.isLocal = location.protocol === 'file:';
 513 | }());
 514 | 
 515 | // Expose the API as global variables, unless an 'exports'
 516 | // object exists, in that case we assume we're in CommonJS - export everything at the end
 517 | if ( typeof exports === "undefined" || typeof require === "undefined" ) {
 518 | 	extend(window, QUnit);
 519 | 	window.QUnit = QUnit;
 520 | }
 521 | 
 522 | // define these after exposing globals to keep them in these QUnit namespace only
 523 | extend(QUnit, {
 524 | 	config: config,
 525 | 
 526 | 	// Initialize the configuration options
 527 | 	init: function() {
 528 | 		extend(config, {
 529 | 			stats: { all: 0, bad: 0 },
 530 | 			moduleStats: { all: 0, bad: 0 },
 531 | 			started: +new Date(),
 532 | 			updateRate: 1000,
 533 | 			blocking: false,
 534 | 			autostart: true,
 535 | 			autorun: false,
 536 | 			filter: "",
 537 | 			queue: [],
 538 | 			semaphore: 0
 539 | 		});
 540 | 
 541 | 		var qunit = id( "qunit" );
 542 | 		if ( qunit ) {
 543 | 			qunit.innerHTML =
 544 | 				'<h1 id="qunit-header">' + escapeInnerText( document.title ) + '</h1>' +
 545 | 				'<h2 id="qunit-banner"></h2>' +
 546 | 				'<div id="qunit-testrunner-toolbar"></div>' +
 547 | 				'<h2 id="qunit-userAgent"></h2>' +
 548 | 				'<ol id="qunit-tests"></ol>';
 549 | 		}
 550 | 
 551 | 		var tests = id( "qunit-tests" ),
 552 | 			banner = id( "qunit-banner" ),
 553 | 			result = id( "qunit-testresult" );
 554 | 
 555 | 		if ( tests ) {
 556 | 			tests.innerHTML = "";
 557 | 		}
 558 | 
 559 | 		if ( banner ) {
 560 | 			banner.className = "";
 561 | 		}
 562 | 
 563 | 		if ( result ) {
 564 | 			result.parentNode.removeChild( result );
 565 | 		}
 566 | 
 567 | 		if ( tests ) {
 568 | 			result = document.createElement( "p" );
 569 | 			result.id = "qunit-testresult";
 570 | 			result.className = "result";
 571 | 			tests.parentNode.insertBefore( result, tests );
 572 | 			result.innerHTML = 'Running...<br/>&nbsp;';
 573 | 		}
 574 | 	},
 575 | 
 576 | 	// Resets the test setup. Useful for tests that modify the DOM.
 577 | 	// If jQuery is available, uses jQuery's html(), otherwise just innerHTML.
 578 | 	reset: function() {
 579 | 		if ( window.jQuery ) {
 580 | 			jQuery( "#qunit-fixture" ).html( config.fixture );
 581 | 		} else {
 582 | 			var main = id( 'qunit-fixture' );
 583 | 			if ( main ) {
 584 | 				main.innerHTML = config.fixture;
 585 | 			}
 586 | 		}
 587 | 	},
 588 | 
 589 | 	// Trigger an event on an element.
 590 | 	// @example triggerEvent( document.body, "click" );
 591 | 	triggerEvent: function( elem, type, event ) {
 592 | 		if ( document.createEvent ) {
 593 | 			event = document.createEvent("MouseEvents");
 594 | 			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
 595 | 				0, 0, 0, 0, 0, false, false, false, false, 0, null);
 596 | 			elem.dispatchEvent( event );
 597 | 
 598 | 		} else if ( elem.fireEvent ) {
 599 | 			elem.fireEvent("on"+type);
 600 | 		}
 601 | 	},
 602 | 
 603 | 	// Safe object type checking
 604 | 	is: function( type, obj ) {
 605 | 		return QUnit.objectType( obj ) == type;
 606 | 	},
 607 | 
 608 | 	objectType: function( obj ) {
 609 | 		if (typeof obj === "undefined") {
 610 | 				return "undefined";
 611 | 
 612 | 		// consider: typeof null === object
 613 | 		}
 614 | 		if (obj === null) {
 615 | 				return "null";
 616 | 		}
 617 | 
 618 | 		var type = toString.call( obj ).match(/^\[object\s(.*)\]$/)[1] || '';
 619 | 
 620 | 		switch (type) {
 621 | 			case 'Number':
 622 | 				if (isNaN(obj)) {
 623 | 					return "nan";
 624 | 				}
 625 | 				return "number";
 626 | 			case 'String':
 627 | 			case 'Boolean':
 628 | 			case 'Array':
 629 | 			case 'Date':
 630 | 			case 'RegExp':
 631 | 			case 'Function':
 632 | 					return type.toLowerCase();
 633 | 		}
 634 | 		if (typeof obj === "object") {
 635 | 				return "object";
 636 | 		}
 637 | 		return undefined;
 638 | 	},
 639 | 
 640 | 	push: function(result, actual, expected, message) {
 641 | 		if (!config.current) {
 642 | 			throw new Error("assertion outside test context, was " + sourceFromStacktrace());
 643 | 		}
 644 | 		var details = {
 645 | 			result: result,
 646 | 			message: message,
 647 | 			actual: actual,
 648 | 			expected: expected
 649 | 		};
 650 | 
 651 | 		message = escapeInnerText(message) || (result ? "okay" : "failed");
 652 | 		message = '<span class="test-message">' + message + "</span>";
 653 | 		var output = message;
 654 | 		if (!result) {
 655 | 			expected = escapeInnerText(QUnit.jsDump.parse(expected));
 656 | 			actual = escapeInnerText(QUnit.jsDump.parse(actual));
 657 | 			output += '<table><tr class="test-expected"><th>Expected: </th><td><pre>' + expected + '</pre></td></tr>';
 658 | 			if (actual != expected) {
 659 | 				output += '<tr class="test-actual"><th>Result: </th><td><pre>' + actual + '</pre></td></tr>';
 660 | 				output += '<tr class="test-diff"><th>Diff: </th><td><pre>' + QUnit.diff(expected, actual) +'</pre></td></tr>';
 661 | 			}
 662 | 			var source = sourceFromStacktrace();
 663 | 			if (source) {
 664 | 				details.source = source;
 665 | 				output += '<tr class="test-source"><th>Source: </th><td><pre>' + escapeInnerText(source) + '</pre></td></tr>';
 666 | 			}
 667 | 			output += "</table>";
 668 | 		}
 669 | 
 670 | 		runLoggingCallbacks( 'log', QUnit, details );
 671 | 
 672 | 		config.current.assertions.push({
 673 | 			result: !!result,
 674 | 			message: output
 675 | 		});
 676 | 	},
 677 | 
 678 | 	pushFailure: function(message, source) {
 679 | 		var details = {
 680 | 			result: false,
 681 | 			message: message
 682 | 		};
 683 | 		var output = escapeInnerText(message);
 684 | 		if (source) {
 685 | 			details.source = source;
 686 | 			output += '<table><tr class="test-source"><th>Source: </th><td><pre>' + escapeInnerText(source) + '</pre></td></tr></table>';
 687 | 		}
 688 | 		runLoggingCallbacks( 'log', QUnit, details );
 689 | 		config.current.assertions.push({
 690 | 			result: false,
 691 | 			message: output
 692 | 		});
 693 | 	},
 694 | 
 695 | 	url: function( params ) {
 696 | 		params = extend( extend( {}, QUnit.urlParams ), params );
 697 | 		var querystring = "?",
 698 | 			key;
 699 | 		for ( key in params ) {
 700 | 			if ( !hasOwn.call( params, key ) ) {
 701 | 				continue;
 702 | 			}
 703 | 			querystring += encodeURIComponent( key ) + "=" +
 704 | 				encodeURIComponent( params[ key ] ) + "&";
 705 | 		}
 706 | 		return window.location.pathname + querystring.slice( 0, -1 );
 707 | 	},
 708 | 
 709 | 	extend: extend,
 710 | 	id: id,
 711 | 	addEvent: addEvent
 712 | });
 713 | 
 714 | //QUnit.constructor is set to the empty F() above so that we can add to it's prototype later
 715 | //Doing this allows us to tell if the following methods have been overwritten on the actual
 716 | //QUnit object, which is a deprecated way of using the callbacks.
 717 | extend(QUnit.constructor.prototype, {
 718 | 	// Logging callbacks; all receive a single argument with the listed properties
 719 | 	// run test/logs.html for any related changes
 720 | 	begin: registerLoggingCallback('begin'),
 721 | 	// done: { failed, passed, total, runtime }
 722 | 	done: registerLoggingCallback('done'),
 723 | 	// log: { result, actual, expected, message }
 724 | 	log: registerLoggingCallback('log'),
 725 | 	// testStart: { name }
 726 | 	testStart: registerLoggingCallback('testStart'),
 727 | 	// testDone: { name, failed, passed, total }
 728 | 	testDone: registerLoggingCallback('testDone'),
 729 | 	// moduleStart: { name }
 730 | 	moduleStart: registerLoggingCallback('moduleStart'),
 731 | 	// moduleDone: { name, failed, passed, total }
 732 | 	moduleDone: registerLoggingCallback('moduleDone')
 733 | });
 734 | 
 735 | if ( typeof document === "undefined" || document.readyState === "complete" ) {
 736 | 	config.autorun = true;
 737 | }
 738 | 
 739 | QUnit.load = function() {
 740 | 	runLoggingCallbacks( 'begin', QUnit, {} );
 741 | 
 742 | 	// Initialize the config, saving the execution queue
 743 | 	var oldconfig = extend({}, config);
 744 | 	QUnit.init();
 745 | 	extend(config, oldconfig);
 746 | 
 747 | 	config.blocking = false;
 748 | 
 749 | 	var urlConfigHtml = '', len = config.urlConfig.length;
 750 | 	for ( var i = 0, val; i < len; i++ ) {
 751 | 		val = config.urlConfig[i];
 752 | 		config[val] = QUnit.urlParams[val];
 753 | 		urlConfigHtml += '<label><input name="' + val + '" type="checkbox"' + ( config[val] ? ' checked="checked"' : '' ) + '>' + val + '</label>';
 754 | 	}
 755 | 
 756 | 	var userAgent = id("qunit-userAgent");
 757 | 	if ( userAgent ) {
 758 | 		userAgent.innerHTML = navigator.userAgent;
 759 | 	}
 760 | 	var banner = id("qunit-header");
 761 | 	if ( banner ) {
 762 | 		banner.innerHTML = '<a href="' + QUnit.url({ filter: undefined }) + '"> ' + banner.innerHTML + '</a> ' + urlConfigHtml;
 763 | 		addEvent( banner, "change", function( event ) {
 764 | 			var params = {};
 765 | 			params[ event.target.name ] = event.target.checked ? true : undefined;
 766 | 			window.location = QUnit.url( params );
 767 | 		});
 768 | 	}
 769 | 
 770 | 	var toolbar = id("qunit-testrunner-toolbar");
 771 | 	if ( toolbar ) {
 772 | 		var filter = document.createElement("input");
 773 | 		filter.type = "checkbox";
 774 | 		filter.id = "qunit-filter-pass";
 775 | 		addEvent( filter, "click", function() {
 776 | 			var ol = document.getElementById("qunit-tests");
 777 | 			if ( filter.checked ) {
 778 | 				ol.className = ol.className + " hidepass";
 779 | 			} else {
 780 | 				var tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
 781 | 				ol.className = tmp.replace(/ hidepass /, " ");
 782 | 			}
 783 | 			if ( defined.sessionStorage ) {
 784 | 				if (filter.checked) {
 785 | 					sessionStorage.setItem("qunit-filter-passed-tests", "true");
 786 | 				} else {
 787 | 					sessionStorage.removeItem("qunit-filter-passed-tests");
 788 | 				}
 789 | 			}
 790 | 		});
 791 | 		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem("qunit-filter-passed-tests") ) {
 792 | 			filter.checked = true;
 793 | 			var ol = document.getElementById("qunit-tests");
 794 | 			ol.className = ol.className + " hidepass";
 795 | 		}
 796 | 		toolbar.appendChild( filter );
 797 | 
 798 | 		var label = document.createElement("label");
 799 | 		label.setAttribute("for", "qunit-filter-pass");
 800 | 		label.innerHTML = "Hide passed tests";
 801 | 		toolbar.appendChild( label );
 802 | 	}
 803 | 
 804 | 	var main = id('qunit-fixture');
 805 | 	if ( main ) {
 806 | 		config.fixture = main.innerHTML;
 807 | 	}
 808 | 
 809 | 	if (config.autostart) {
 810 | 		QUnit.start();
 811 | 	}
 812 | };
 813 | 
 814 | addEvent(window, "load", QUnit.load);
 815 | 
 816 | // addEvent(window, "error") gives us a useless event object
 817 | window.onerror = function( message, file, line ) {
 818 | 	if ( QUnit.config.current ) {
 819 | 		QUnit.pushFailure( message, file + ":" + line );
 820 | 	} else {
 821 | 		QUnit.test( "global failure", function() {
 822 | 			QUnit.pushFailure( message, file + ":" + line );
 823 | 		});
 824 | 	}
 825 | };
 826 | 
 827 | function done() {
 828 | 	config.autorun = true;
 829 | 
 830 | 	// Log the last module results
 831 | 	if ( config.currentModule ) {
 832 | 		runLoggingCallbacks( 'moduleDone', QUnit, {
 833 | 			name: config.currentModule,
 834 | 			failed: config.moduleStats.bad,
 835 | 			passed: config.moduleStats.all - config.moduleStats.bad,
 836 | 			total: config.moduleStats.all
 837 | 		} );
 838 | 	}
 839 | 
 840 | 	var banner = id("qunit-banner"),
 841 | 		tests = id("qunit-tests"),
 842 | 		runtime = +new Date() - config.started,
 843 | 		passed = config.stats.all - config.stats.bad,
 844 | 		html = [
 845 | 			'Tests completed in ',
 846 | 			runtime,
 847 | 			' milliseconds.<br/>',
 848 | 			'<span class="passed">',
 849 | 			passed,
 850 | 			'</span> tests of <span class="total">',
 851 | 			config.stats.all,
 852 | 			'</span> passed, <span class="failed">',
 853 | 			config.stats.bad,
 854 | 			'</span> failed.'
 855 | 		].join('');
 856 | 
 857 | 	if ( banner ) {
 858 | 		banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
 859 | 	}
 860 | 
 861 | 	if ( tests ) {
 862 | 		id( "qunit-testresult" ).innerHTML = html;
 863 | 	}
 864 | 
 865 | 	if ( config.altertitle && typeof document !== "undefined" && document.title ) {
 866 | 		// show ✖ for good, ✔ for bad suite result in title
 867 | 		// use escape sequences in case file gets loaded with non-utf-8-charset
 868 | 		document.title = [
 869 | 			(config.stats.bad ? "\u2716" : "\u2714"),
 870 | 			document.title.replace(/^[\u2714\u2716] /i, "")
 871 | 		].join(" ");
 872 | 	}
 873 | 
 874 | 	// clear own sessionStorage items if all tests passed
 875 | 	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
 876 | 		for (var key in sessionStorage) {
 877 | 			if (sessionStorage.hasOwnProperty(key) && key.indexOf("qunit-test-") === 0 ) {
 878 | 				sessionStorage.removeItem(key);
 879 | 			}
 880 | 		}
 881 | 	}
 882 | 
 883 | 	runLoggingCallbacks( 'done', QUnit, {
 884 | 		failed: config.stats.bad,
 885 | 		passed: passed,
 886 | 		total: config.stats.all,
 887 | 		runtime: runtime
 888 | 	} );
 889 | }
 890 | 
 891 | function validTest( name ) {
 892 | 	var filter = config.filter,
 893 | 		run = false;
 894 | 
 895 | 	if ( !filter ) {
 896 | 		return true;
 897 | 	}
 898 | 
 899 | 	var not = filter.charAt( 0 ) === "!";
 900 | 	if ( not ) {
 901 | 		filter = filter.slice( 1 );
 902 | 	}
 903 | 
 904 | 	if ( name.indexOf( filter ) !== -1 ) {
 905 | 		return !not;
 906 | 	}
 907 | 
 908 | 	if ( not ) {
 909 | 		run = true;
 910 | 	}
 911 | 
 912 | 	return run;
 913 | }
 914 | 
 915 | // so far supports only Firefox, Chrome and Opera (buggy)
 916 | // could be extended in the future to use something like https://github.com/csnover/TraceKit
 917 | function extractStacktrace( e, offset ) {
 918 | 	offset = offset || 3;
 919 | 	if (e.stacktrace) {
 920 | 		// Opera
 921 | 		return e.stacktrace.split("\n")[offset + 3];
 922 | 	} else if (e.stack) {
 923 | 		// Firefox, Chrome
 924 | 		var stack = e.stack.split("\n");
 925 | 		if (/^error$/i.test(stack[0])) {
 926 | 			stack.shift();
 927 | 		}
 928 | 		return stack[offset];
 929 | 	} else if (e.sourceURL) {
 930 | 		// Safari, PhantomJS
 931 | 		// hopefully one day Safari provides actual stacktraces
 932 | 		// exclude useless self-reference for generated Error objects
 933 | 		if ( /qunit.js$/.test( e.sourceURL ) ) {
 934 | 			return;
 935 | 		}
 936 | 		// for actual exceptions, this is useful
 937 | 		return e.sourceURL + ":" + e.line;
 938 | 	}
 939 | }
 940 | function sourceFromStacktrace(offset) {
 941 | 	try {
 942 | 		throw new Error();
 943 | 	} catch ( e ) {
 944 | 		return extractStacktrace( e, offset );
 945 | 	}
 946 | }
 947 | 
 948 | function escapeInnerText(s) {
 949 | 	if (!s) {
 950 | 		return "";
 951 | 	}
 952 | 	s = s + "";
 953 | 	return s.replace(/[\&<>]/g, function(s) {
 954 | 		switch(s) {
 955 | 			case "&": return "&amp;";
 956 | 			case "<": return "&lt;";
 957 | 			case ">": return "&gt;";
 958 | 			default: return s;
 959 | 		}
 960 | 	});
 961 | }
 962 | 
 963 | function synchronize( callback, last ) {
 964 | 	config.queue.push( callback );
 965 | 
 966 | 	if ( config.autorun && !config.blocking ) {
 967 | 		process(last);
 968 | 	}
 969 | }
 970 | 
 971 | function process( last ) {
 972 | 	function next() {
 973 | 		process( last );
 974 | 	}
 975 | 	var start = new Date().getTime();
 976 | 	config.depth = config.depth ? config.depth + 1 : 1;
 977 | 
 978 | 	while ( config.queue.length && !config.blocking ) {
 979 | 		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
 980 | 			config.queue.shift()();
 981 | 		} else {
 982 | 			window.setTimeout( next, 13 );
 983 | 			break;
 984 | 		}
 985 | 	}
 986 | 	config.depth--;
 987 | 	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
 988 | 		done();
 989 | 	}
 990 | }
 991 | 
 992 | function saveGlobal() {
 993 | 	config.pollution = [];
 994 | 
 995 | 	if ( config.noglobals ) {
 996 | 		for ( var key in window ) {
 997 | 			if ( !hasOwn.call( window, key ) ) {
 998 | 				continue;
 999 | 			}
1000 | 			config.pollution.push( key );
1001 | 		}
1002 | 	}
1003 | }
1004 | 
1005 | function checkPollution( name ) {
1006 | 	var old = config.pollution;
1007 | 	saveGlobal();
1008 | 
1009 | 	var newGlobals = diff( config.pollution, old );
1010 | 	if ( newGlobals.length > 0 ) {
1011 | 		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1012 | 	}
1013 | 
1014 | 	var deletedGlobals = diff( old, config.pollution );
1015 | 	if ( deletedGlobals.length > 0 ) {
1016 | 		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1017 | 	}
1018 | }
1019 | 
1020 | // returns a new Array with the elements that are in a but not in b
1021 | function diff( a, b ) {
1022 | 	var result = a.slice();
1023 | 	for ( var i = 0; i < result.length; i++ ) {
1024 | 		for ( var j = 0; j < b.length; j++ ) {
1025 | 			if ( result[i] === b[j] ) {
1026 | 				result.splice(i, 1);
1027 | 				i--;
1028 | 				break;
1029 | 			}
1030 | 		}
1031 | 	}
1032 | 	return result;
1033 | }
1034 | 
1035 | function extend(a, b) {
1036 | 	for ( var prop in b ) {
1037 | 		if ( b[prop] === undefined ) {
1038 | 			delete a[prop];
1039 | 
1040 | 		// Avoid "Member not found" error in IE8 caused by setting window.constructor
1041 | 		} else if ( prop !== "constructor" || a !== window ) {
1042 | 			a[prop] = b[prop];
1043 | 		}
1044 | 	}
1045 | 
1046 | 	return a;
1047 | }
1048 | 
1049 | function addEvent(elem, type, fn) {
1050 | 	if ( elem.addEventListener ) {
1051 | 		elem.addEventListener( type, fn, false );
1052 | 	} else if ( elem.attachEvent ) {
1053 | 		elem.attachEvent( "on" + type, fn );
1054 | 	} else {
1055 | 		fn();
1056 | 	}
1057 | }
1058 | 
1059 | function id(name) {
1060 | 	return !!(typeof document !== "undefined" && document && document.getElementById) &&
1061 | 		document.getElementById( name );
1062 | }
1063 | 
1064 | function registerLoggingCallback(key){
1065 | 	return function(callback){
1066 | 		config[key].push( callback );
1067 | 	};
1068 | }
1069 | 
1070 | // Supports deprecated method of completely overwriting logging callbacks
1071 | function runLoggingCallbacks(key, scope, args) {
1072 | 	//debugger;
1073 | 	var callbacks;
1074 | 	if ( QUnit.hasOwnProperty(key) ) {
1075 | 		QUnit[key].call(scope, args);
1076 | 	} else {
1077 | 		callbacks = config[key];
1078 | 		for( var i = 0; i < callbacks.length; i++ ) {
1079 | 			callbacks[i].call( scope, args );
1080 | 		}
1081 | 	}
1082 | }
1083 | 
1084 | // Test for equality any JavaScript type.
1085 | // Author: Philippe Rathé <prathe@gmail.com>
1086 | QUnit.equiv = (function() {
1087 | 
1088 | 	var innerEquiv; // the real equiv function
1089 | 	var callers = []; // stack to decide between skip/abort functions
1090 | 	var parents = []; // stack to avoiding loops from circular referencing
1091 | 
1092 | 	// Call the o related callback with the given arguments.
1093 | 	function bindCallbacks(o, callbacks, args) {
1094 | 		var prop = QUnit.objectType(o);
1095 | 		if (prop) {
1096 | 			if (QUnit.objectType(callbacks[prop]) === "function") {
1097 | 				return callbacks[prop].apply(callbacks, args);
1098 | 			} else {
1099 | 				return callbacks[prop]; // or undefined
1100 | 			}
1101 | 		}
1102 | 	}
1103 | 
1104 | 	var getProto = Object.getPrototypeOf || function (obj) {
1105 | 		return obj.__proto__;
1106 | 	};
1107 | 
1108 | 	var callbacks = (function () {
1109 | 
1110 | 		// for string, boolean, number and null
1111 | 		function useStrictEquality(b, a) {
1112 | 			if (b instanceof a.constructor || a instanceof b.constructor) {
1113 | 				// to catch short annotaion VS 'new' annotation of a
1114 | 				// declaration
1115 | 				// e.g. var i = 1;
1116 | 				// var j = new Number(1);
1117 | 				return a == b;
1118 | 			} else {
1119 | 				return a === b;
1120 | 			}
1121 | 		}
1122 | 
1123 | 		return {
1124 | 			"string" : useStrictEquality,
1125 | 			"boolean" : useStrictEquality,
1126 | 			"number" : useStrictEquality,
1127 | 			"null" : useStrictEquality,
1128 | 			"undefined" : useStrictEquality,
1129 | 
1130 | 			"nan" : function(b) {
1131 | 				return isNaN(b);
1132 | 			},
1133 | 
1134 | 			"date" : function(b, a) {
1135 | 				return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf();
1136 | 			},
1137 | 
1138 | 			"regexp" : function(b, a) {
1139 | 				return QUnit.objectType(b) === "regexp" &&
1140 | 					// the regex itself
1141 | 					a.source === b.source &&
1142 | 					// and its modifers
1143 | 					a.global === b.global &&
1144 | 					// (gmi) ...
1145 | 					a.ignoreCase === b.ignoreCase &&
1146 | 					a.multiline === b.multiline;
1147 | 			},
1148 | 
1149 | 			// - skip when the property is a method of an instance (OOP)
1150 | 			// - abort otherwise,
1151 | 			// initial === would have catch identical references anyway
1152 | 			"function" : function() {
1153 | 				var caller = callers[callers.length - 1];
1154 | 				return caller !== Object && typeof caller !== "undefined";
1155 | 			},
1156 | 
1157 | 			"array" : function(b, a) {
1158 | 				var i, j, loop;
1159 | 				var len;
1160 | 
1161 | 				// b could be an object literal here
1162 | 				if (QUnit.objectType(b) !== "array") {
1163 | 					return false;
1164 | 				}
1165 | 
1166 | 				len = a.length;
1167 | 				if (len !== b.length) { // safe and faster
1168 | 					return false;
1169 | 				}
1170 | 
1171 | 				// track reference to avoid circular references
1172 | 				parents.push(a);
1173 | 				for (i = 0; i < len; i++) {
1174 | 					loop = false;
1175 | 					for (j = 0; j < parents.length; j++) {
1176 | 						if (parents[j] === a[i]) {
1177 | 							loop = true;// dont rewalk array
1178 | 						}
1179 | 					}
1180 | 					if (!loop && !innerEquiv(a[i], b[i])) {
1181 | 						parents.pop();
1182 | 						return false;
1183 | 					}
1184 | 				}
1185 | 				parents.pop();
1186 | 				return true;
1187 | 			},
1188 | 
1189 | 			"object" : function(b, a) {
1190 | 				var i, j, loop;
1191 | 				var eq = true; // unless we can proove it
1192 | 				var aProperties = [], bProperties = []; // collection of
1193 | 														// strings
1194 | 
1195 | 				// comparing constructors is more strict than using
1196 | 				// instanceof
1197 | 				if (a.constructor !== b.constructor) {
1198 | 					// Allow objects with no prototype to be equivalent to
1199 | 					// objects with Object as their constructor.
1200 | 					if (!((getProto(a) === null && getProto(b) === Object.prototype) ||
1201 | 						(getProto(b) === null && getProto(a) === Object.prototype)))
1202 | 					{
1203 | 						return false;
1204 | 					}
1205 | 				}
1206 | 
1207 | 				// stack constructor before traversing properties
1208 | 				callers.push(a.constructor);
1209 | 				// track reference to avoid circular references
1210 | 				parents.push(a);
1211 | 
1212 | 				for (i in a) { // be strict: don't ensures hasOwnProperty
1213 | 								// and go deep
1214 | 					loop = false;
1215 | 					for (j = 0; j < parents.length; j++) {
1216 | 						if (parents[j] === a[i]) {
1217 | 							// don't go down the same path twice
1218 | 							loop = true;
1219 | 						}
1220 | 					}
1221 | 					aProperties.push(i); // collect a's properties
1222 | 
1223 | 					if (!loop && !innerEquiv(a[i], b[i])) {
1224 | 						eq = false;
1225 | 						break;
1226 | 					}
1227 | 				}
1228 | 
1229 | 				callers.pop(); // unstack, we are done
1230 | 				parents.pop();
1231 | 
1232 | 				for (i in b) {
1233 | 					bProperties.push(i); // collect b's properties
1234 | 				}
1235 | 
1236 | 				// Ensures identical properties name
1237 | 				return eq && innerEquiv(aProperties.sort(), bProperties.sort());
1238 | 			}
1239 | 		};
1240 | 	}());
1241 | 
1242 | 	innerEquiv = function() { // can take multiple arguments
1243 | 		var args = Array.prototype.slice.apply(arguments);
1244 | 		if (args.length < 2) {
1245 | 			return true; // end transition
1246 | 		}
1247 | 
1248 | 		return (function(a, b) {
1249 | 			if (a === b) {
1250 | 				return true; // catch the most you can
1251 | 			} else if (a === null || b === null || typeof a === "undefined" ||
1252 | 					typeof b === "undefined" ||
1253 | 					QUnit.objectType(a) !== QUnit.objectType(b)) {
1254 | 				return false; // don't lose time with error prone cases
1255 | 			} else {
1256 | 				return bindCallbacks(a, callbacks, [ b, a ]);
1257 | 			}
1258 | 
1259 | 			// apply transition with (1..n) arguments
1260 | 		}(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length - 1)));
1261 | 	};
1262 | 
1263 | 	return innerEquiv;
1264 | 
1265 | }());
1266 | 
1267 | /**
1268 |  * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1269 |  * http://flesler.blogspot.com Licensed under BSD
1270 |  * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1271 |  *
1272 |  * @projectDescription Advanced and extensible data dumping for Javascript.
1273 |  * @version 1.0.0
1274 |  * @author Ariel Flesler
1275 |  * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1276 |  */
1277 | QUnit.jsDump = (function() {
1278 | 	function quote( str ) {
1279 | 		return '"' + str.toString().replace(/"/g, '\\"') + '"';
1280 | 	}
1281 | 	function literal( o ) {
1282 | 		return o + '';
1283 | 	}
1284 | 	function join( pre, arr, post ) {
1285 | 		var s = jsDump.separator(),
1286 | 			base = jsDump.indent(),
1287 | 			inner = jsDump.indent(1);
1288 | 		if ( arr.join ) {
1289 | 			arr = arr.join( ',' + s + inner );
1290 | 		}
1291 | 		if ( !arr ) {
1292 | 			return pre + post;
1293 | 		}
1294 | 		return [ pre, inner + arr, base + post ].join(s);
1295 | 	}
1296 | 	function array( arr, stack ) {
1297 | 		var i = arr.length, ret = new Array(i);
1298 | 		this.up();
1299 | 		while ( i-- ) {
1300 | 			ret[i] = this.parse( arr[i] , undefined , stack);
1301 | 		}
1302 | 		this.down();
1303 | 		return join( '[', ret, ']' );
1304 | 	}
1305 | 
1306 | 	var reName = /^function (\w+)/;
1307 | 
1308 | 	var jsDump = {
1309 | 		parse: function( obj, type, stack ) { //type is used mostly internally, you can fix a (custom)type in advance
1310 | 			stack = stack || [ ];
1311 | 			var parser = this.parsers[ type || this.typeOf(obj) ];
1312 | 			type = typeof parser;
1313 | 			var inStack = inArray(obj, stack);
1314 | 			if (inStack != -1) {
1315 | 				return 'recursion('+(inStack - stack.length)+')';
1316 | 			}
1317 | 			//else
1318 | 			if (type == 'function')  {
1319 | 					stack.push(obj);
1320 | 					var res = parser.call( this, obj, stack );
1321 | 					stack.pop();
1322 | 					return res;
1323 | 			}
1324 | 			// else
1325 | 			return (type == 'string') ? parser : this.parsers.error;
1326 | 		},
1327 | 		typeOf: function( obj ) {
1328 | 			var type;
1329 | 			if ( obj === null ) {
1330 | 				type = "null";
1331 | 			} else if (typeof obj === "undefined") {
1332 | 				type = "undefined";
1333 | 			} else if (QUnit.is("RegExp", obj)) {
1334 | 				type = "regexp";
1335 | 			} else if (QUnit.is("Date", obj)) {
1336 | 				type = "date";
1337 | 			} else if (QUnit.is("Function", obj)) {
1338 | 				type = "function";
1339 | 			} else if (typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined") {
1340 | 				type = "window";
1341 | 			} else if (obj.nodeType === 9) {
1342 | 				type = "document";
1343 | 			} else if (obj.nodeType) {
1344 | 				type = "node";
1345 | 			} else if (
1346 | 				// native arrays
1347 | 				toString.call( obj ) === "[object Array]" ||
1348 | 				// NodeList objects
1349 | 				( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1350 | 			) {
1351 | 				type = "array";
1352 | 			} else {
1353 | 				type = typeof obj;
1354 | 			}
1355 | 			return type;
1356 | 		},
1357 | 		separator: function() {
1358 | 			return this.multiline ?	this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
1359 | 		},
1360 | 		indent: function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing
1361 | 			if ( !this.multiline ) {
1362 | 				return '';
1363 | 			}
1364 | 			var chr = this.indentChar;
1365 | 			if ( this.HTML ) {
1366 | 				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
1367 | 			}
1368 | 			return new Array( this._depth_ + (extra||0) ).join(chr);
1369 | 		},
1370 | 		up: function( a ) {
1371 | 			this._depth_ += a || 1;
1372 | 		},
1373 | 		down: function( a ) {
1374 | 			this._depth_ -= a || 1;
1375 | 		},
1376 | 		setParser: function( name, parser ) {
1377 | 			this.parsers[name] = parser;
1378 | 		},
1379 | 		// The next 3 are exposed so you can use them
1380 | 		quote: quote,
1381 | 		literal: literal,
1382 | 		join: join,
1383 | 		//
1384 | 		_depth_: 1,
1385 | 		// This is the list of parsers, to modify them, use jsDump.setParser
1386 | 		parsers: {
1387 | 			window: '[Window]',
1388 | 			document: '[Document]',
1389 | 			error: '[ERROR]', //when no parser is found, shouldn't happen
1390 | 			unknown: '[Unknown]',
1391 | 			'null': 'null',
1392 | 			'undefined': 'undefined',
1393 | 			'function': function( fn ) {
1394 | 				var ret = 'function',
1395 | 					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
1396 | 				if ( name ) {
1397 | 					ret += ' ' + name;
1398 | 				}
1399 | 				ret += '(';
1400 | 
1401 | 				ret = [ ret, QUnit.jsDump.parse( fn, 'functionArgs' ), '){'].join('');
1402 | 				return join( ret, QUnit.jsDump.parse(fn,'functionCode'), '}' );
1403 | 			},
1404 | 			array: array,
1405 | 			nodelist: array,
1406 | 			'arguments': array,
1407 | 			object: function( map, stack ) {
1408 | 				var ret = [ ], keys, key, val, i;
1409 | 				QUnit.jsDump.up();
1410 | 				if (Object.keys) {
1411 | 					keys = Object.keys( map );
1412 | 				} else {
1413 | 					keys = [];
1414 | 					for (key in map) { keys.push( key ); }
1415 | 				}
1416 | 				keys.sort();
1417 | 				for (i = 0; i < keys.length; i++) {
1418 | 					key = keys[ i ];
1419 | 					val = map[ key ];
1420 | 					ret.push( QUnit.jsDump.parse( key, 'key' ) + ': ' + QUnit.jsDump.parse( val, undefined, stack ) );
1421 | 				}
1422 | 				QUnit.jsDump.down();
1423 | 				return join( '{', ret, '}' );
1424 | 			},
1425 | 			node: function( node ) {
1426 | 				var open = QUnit.jsDump.HTML ? '&lt;' : '<',
1427 | 					close = QUnit.jsDump.HTML ? '&gt;' : '>';
1428 | 
1429 | 				var tag = node.nodeName.toLowerCase(),
1430 | 					ret = open + tag;
1431 | 
1432 | 				for ( var a in QUnit.jsDump.DOMAttrs ) {
1433 | 					var val = node[QUnit.jsDump.DOMAttrs[a]];
1434 | 					if ( val ) {
1435 | 						ret += ' ' + a + '=' + QUnit.jsDump.parse( val, 'attribute' );
1436 | 					}
1437 | 				}
1438 | 				return ret + close + open + '/' + tag + close;
1439 | 			},
1440 | 			functionArgs: function( fn ) {//function calls it internally, it's the arguments part of the function
1441 | 				var l = fn.length;
1442 | 				if ( !l ) {
1443 | 					return '';
1444 | 				}
1445 | 
1446 | 				var args = new Array(l);
1447 | 				while ( l-- ) {
1448 | 					args[l] = String.fromCharCode(97+l);//97 is 'a'
1449 | 				}
1450 | 				return ' ' + args.join(', ') + ' ';
1451 | 			},
1452 | 			key: quote, //object calls it internally, the key part of an item in a map
1453 | 			functionCode: '[code]', //function calls it internally, it's the content of the function
1454 | 			attribute: quote, //node calls it internally, it's an html attribute value
1455 | 			string: quote,
1456 | 			date: quote,
1457 | 			regexp: literal, //regex
1458 | 			number: literal,
1459 | 			'boolean': literal
1460 | 		},
1461 | 		DOMAttrs:{//attributes to dump from nodes, name=>realName
1462 | 			id:'id',
1463 | 			name:'name',
1464 | 			'class':'className'
1465 | 		},
1466 | 		HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )
1467 | 		indentChar:'  ',//indentation unit
1468 | 		multiline:true //if true, items in a collection, are separated by a \n, else just a space.
1469 | 	};
1470 | 
1471 | 	return jsDump;
1472 | }());
1473 | 
1474 | // from Sizzle.js
1475 | function getText( elems ) {
1476 | 	var ret = "", elem;
1477 | 
1478 | 	for ( var i = 0; elems[i]; i++ ) {
1479 | 		elem = elems[i];
1480 | 
1481 | 		// Get the text from text nodes and CDATA nodes
1482 | 		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
1483 | 			ret += elem.nodeValue;
1484 | 
1485 | 		// Traverse everything else, except comment nodes
1486 | 		} else if ( elem.nodeType !== 8 ) {
1487 | 			ret += getText( elem.childNodes );
1488 | 		}
1489 | 	}
1490 | 
1491 | 	return ret;
1492 | }
1493 | 
1494 | //from jquery.js
1495 | function inArray( elem, array ) {
1496 | 	if ( array.indexOf ) {
1497 | 		return array.indexOf( elem );
1498 | 	}
1499 | 
1500 | 	for ( var i = 0, length = array.length; i < length; i++ ) {
1501 | 		if ( array[ i ] === elem ) {
1502 | 			return i;
1503 | 		}
1504 | 	}
1505 | 
1506 | 	return -1;
1507 | }
1508 | 
1509 | /*
1510 |  * Javascript Diff Algorithm
1511 |  *  By John Resig (http://ejohn.org/)
1512 |  *  Modified by Chu Alan "sprite"
1513 |  *
1514 |  * Released under the MIT license.
1515 |  *
1516 |  * More Info:
1517 |  *  http://ejohn.org/projects/javascript-diff-algorithm/
1518 |  *
1519 |  * Usage: QUnit.diff(expected, actual)
1520 |  *
1521 |  * QUnit.diff("the quick brown fox jumped over", "the quick fox jumps over") == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
1522 |  */
1523 | QUnit.diff = (function() {
1524 | 	function diff(o, n) {
1525 | 		var ns = {};
1526 | 		var os = {};
1527 | 		var i;
1528 | 
1529 | 		for (i = 0; i < n.length; i++) {
1530 | 			if (ns[n[i]] == null) {
1531 | 				ns[n[i]] = {
1532 | 					rows: [],
1533 | 					o: null
1534 | 				};
1535 | 			}
1536 | 			ns[n[i]].rows.push(i);
1537 | 		}
1538 | 
1539 | 		for (i = 0; i < o.length; i++) {
1540 | 			if (os[o[i]] == null) {
1541 | 				os[o[i]] = {
1542 | 					rows: [],
1543 | 					n: null
1544 | 				};
1545 | 			}
1546 | 			os[o[i]].rows.push(i);
1547 | 		}
1548 | 
1549 | 		for (i in ns) {
1550 | 			if ( !hasOwn.call( ns, i ) ) {
1551 | 				continue;
1552 | 			}
1553 | 			if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
1554 | 				n[ns[i].rows[0]] = {
1555 | 					text: n[ns[i].rows[0]],
1556 | 					row: os[i].rows[0]
1557 | 				};
1558 | 				o[os[i].rows[0]] = {
1559 | 					text: o[os[i].rows[0]],
1560 | 					row: ns[i].rows[0]
1561 | 				};
1562 | 			}
1563 | 		}
1564 | 
1565 | 		for (i = 0; i < n.length - 1; i++) {
1566 | 			if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null &&
1567 | 			n[i + 1] == o[n[i].row + 1]) {
1568 | 				n[i + 1] = {
1569 | 					text: n[i + 1],
1570 | 					row: n[i].row + 1
1571 | 				};
1572 | 				o[n[i].row + 1] = {
1573 | 					text: o[n[i].row + 1],
1574 | 					row: i + 1
1575 | 				};
1576 | 			}
1577 | 		}
1578 | 
1579 | 		for (i = n.length - 1; i > 0; i--) {
1580 | 			if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null &&
1581 | 			n[i - 1] == o[n[i].row - 1]) {
1582 | 				n[i - 1] = {
1583 | 					text: n[i - 1],
1584 | 					row: n[i].row - 1
1585 | 				};
1586 | 				o[n[i].row - 1] = {
1587 | 					text: o[n[i].row - 1],
1588 | 					row: i - 1
1589 | 				};
1590 | 			}
1591 | 		}
1592 | 
1593 | 		return {
1594 | 			o: o,
1595 | 			n: n
1596 | 		};
1597 | 	}
1598 | 
1599 | 	return function(o, n) {
1600 | 		o = o.replace(/\s+$/, '');
1601 | 		n = n.replace(/\s+$/, '');
1602 | 		var out = diff(o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/));
1603 | 
1604 | 		var str = "";
1605 | 		var i;
1606 | 
1607 | 		var oSpace = o.match(/\s+/g);
1608 | 		if (oSpace == null) {
1609 | 			oSpace = [" "];
1610 | 		}
1611 | 		else {
1612 | 			oSpace.push(" ");
1613 | 		}
1614 | 		var nSpace = n.match(/\s+/g);
1615 | 		if (nSpace == null) {
1616 | 			nSpace = [" "];
1617 | 		}
1618 | 		else {
1619 | 			nSpace.push(" ");
1620 | 		}
1621 | 
1622 | 		if (out.n.length === 0) {
1623 | 			for (i = 0; i < out.o.length; i++) {
1624 | 				str += '<del>' + out.o[i] + oSpace[i] + "</del>";
1625 | 			}
1626 | 		}
1627 | 		else {
1628 | 			if (out.n[0].text == null) {
1629 | 				for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
1630 | 					str += '<del>' + out.o[n] + oSpace[n] + "</del>";
1631 | 				}
1632 | 			}
1633 | 
1634 | 			for (i = 0; i < out.n.length; i++) {
1635 | 				if (out.n[i].text == null) {
1636 | 					str += '<ins>' + out.n[i] + nSpace[i] + "</ins>";
1637 | 				}
1638 | 				else {
1639 | 					var pre = "";
1640 | 
1641 | 					for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) {
1642 | 						pre += '<del>' + out.o[n] + oSpace[n] + "</del>";
1643 | 					}
1644 | 					str += " " + out.n[i].text + nSpace[i] + pre;
1645 | 				}
1646 | 			}
1647 | 		}
1648 | 
1649 | 		return str;
1650 | 	};
1651 | }());
1652 | 
1653 | // for CommonJS enviroments, export everything
1654 | if ( typeof exports !== "undefined" || typeof require !== "undefined" ) {
1655 | 	extend(exports, QUnit);
1656 | }
1657 | 
1658 | // get at whatever the global object is, like window in browsers
1659 | }( (function() {return this;}.call()) ));
1660 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "jquery.responsiveiframe",
 3 |   "title": "jQuery ResponsiveIframe",
 4 |   "description": "jQuery ResponsiveIframe by NPR.",
 5 |   "version": "0.0.3",
 6 |   "homepage": "https://github.com/npr/responsiveiframe",
 7 |   "author": {
 8 |     "name": "Irakli Nadareishvili",
 9 |     "email": "irakli@npr.org",
10 |     "url":"http://www.freshblurbs.com"
11 |   },
12 |   "contributors" : [
13 |     {"name" : "Ioseb Dzmanashvili", "url" : "https://github.com/ioseb"},
14 |     {"name" : "Andew Winder", "url" : "https://github.com/awinder"},
15 |     {"name" : "John Nelson", "url" : "https://github.com/johnymonster"},
16 |     {"name" : "Michael Seid", "url" : "https://github.com/mbseid"},
17 |     {"name" : "Adam McElwee", "url" : "https://github.com/acmcelwee"}
18 |   ],
19 |   "repository": {
20 |     "type": "git",
21 |     "url": "https://github.com/npr/responsiveiframe.git"
22 |   },
23 |   "bugs": {
24 |     "url": "https://github.com/npr/responsiveiframe/issues"
25 |   },
26 |   "licenses": [
27 |     {
28 |       "type": "MIT",
29 |       "url": "https://github.com/npr/responsiveiframe/blob/master/LICENSE-MIT"
30 |     },
31 |     {
32 |       "type": "GPL",
33 |       "url": "https://github.com/npr/responsiveiframe/blob/master/LICENSE-GPL"
34 |     }
35 |   ],
36 |   "dependencies": {
37 |     "grunt": "~0.4.0",
38 |     "grunt-contrib-qunit": "",
39 |     "grunt-jslint": ""
40 |   },
41 |   "keywords": [],
42 |   "devDependencies": {
43 |     "grunt-contrib-clean": "~0.5.0",
44 |     "grunt-contrib-uglify": "~0.2.2",
45 |     "grunt-contrib-concat": "~0.3.0",
46 |     "grunt": "~0.4.1"
47 |   }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/jquery.responsiveiframe.js:
--------------------------------------------------------------------------------
  1 | if (typeof jQuery !== 'undefined') {
  2 |   (function( $ ){
  3 |     var settings = {
  4 |       xdomain: '*',
  5 |       ie : navigator.userAgent.toLowerCase().indexOf('msie') > -1,
  6 |       scrollToTop: true
  7 |     };
  8 | 
  9 |     var methods = {
 10 |       // initialization for the parent, the one housing this
 11 |       init: function() {
 12 |         return this.each(function(self){
 13 |           var $this = $(this);
 14 | 
 15 |           if (window.postMessage) {
 16 |             if (window.addEventListener) {
 17 |               window.addEventListener('message', function(e) {
 18 |                 privateMethods.messageHandler($this,e);
 19 |               } , false);
 20 |             } else if (window.attachEvent) {
 21 |               window.attachEvent('onmessage', function(e) {
 22 |                 privateMethods.messageHandler($this,e);
 23 |               }, $this);
 24 |             }
 25 |           } else {
 26 |             setInterval(function () {
 27 |               var hash = window.location.hash, matches = hash.match(/^#h(\d+)(s?)$/);
 28 |               if (matches) {
 29 |                 privateMethods.setHeight($this, matches[1]);
 30 |                 if (settings.scrollToTop && matches[2] === 's'){
 31 |                   scroll(0,0);
 32 |                 }
 33 |               }
 34 |             }, 150);
 35 |           }
 36 |         });
 37 |       }
 38 |     };
 39 | 
 40 |     var privateMethods = {
 41 |       messageHandler: function (elem, e) {
 42 |         var height,
 43 |           r,
 44 |           matches,
 45 |           strD;
 46 | 
 47 |         if (settings.xdomain !== '*') {
 48 |           var regex = new RegExp(settings.xdomain + '$');
 49 |           if(e.origin == "null"){
 50 |             throw new Error("messageHandler( elem, e): There is no origin.  You are viewing the page from your file system.  Please run through a web server.");
 51 |           }
 52 |           if(e.origin.match(regex)){
 53 |             matches = true;
 54 |           }else{
 55 |             throw new Error("messageHandler( elem, e): The orgin doesn't match the responsiveiframe  xdomain.");
 56 |           }
 57 |         
 58 |         }
 59 | 
 60 |         if(settings.xdomain === '*' || matches ) {
 61 |           strD = e.data + "";
 62 |           r = strD.match(/^(\d+)(s?)$/);
 63 |           if(r && r.length === 3){
 64 |             height = parseInt(r[1], 10);
 65 |             if (!isNaN(height)) {
 66 |               try {
 67 |                 privateMethods.setHeight(elem, height);
 68 |               } catch (ex) {}
 69 |             }
 70 |             if (settings.scrollToTop && r[2] === "s"){
 71 |               scroll(0,0);
 72 |             }
 73 |           }
 74 |         }
 75 |       },
 76 | 
 77 |       // Sets the height of the iframe
 78 |       setHeight : function (elem, height) {
 79 |         elem.css('height', height + 'px');
 80 |       },
 81 |       getDocHeight: function () {
 82 |         var D = document;
 83 |         return Math.min(
 84 |           Math.max(D.body.scrollHeight, D.documentElement.scrollHeight),
 85 |           Math.max(D.body.offsetHeight, D.documentElement.offsetHeight),
 86 |           Math.max(D.body.clientHeight, D.documentElement.clientHeight)
 87 |         );
 88 |       }
 89 |     };
 90 | 
 91 |     $.fn.responsiveIframe = function( method ) {
 92 |       if ( methods[method] ) {
 93 |         return methods[ method ].apply( this, Array.prototype.slice.call( arguments, 1 ));
 94 |       } else if ( typeof method === 'object' || ! method ) {
 95 |         $.extend(settings, arguments[0]);
 96 |         return methods.init.apply( this );
 97 |       } else {
 98 |         $.error( 'Method ' +  method + ' does not exist on jQuery.responsiveIframe' );
 99 |       }
100 |     };
101 |   }( jQuery ));
102 | }
103 | 
104 | ;(function(){
105 |   var self,
106 |       module,
107 |       ResponsiveIframe = function () {self = this;};
108 | 
109 |   ResponsiveIframe.prototype.allowResponsiveEmbedding = function() {
110 |     if (window.addEventListener) {
111 |       window.addEventListener("load", self.messageParent, false);
112 |       window.addEventListener("resize", self.messageParent, false);
113 |     } else if (window.attachEvent) {
114 |       window.attachEvent("onload", self.messageParent);
115 |       window.attachEvent("onresize", self.messageParent);
116 |     }
117 |   };
118 | 
119 |   ResponsiveIframe.prototype.messageParent = function(scrollTop) {
120 |     var h = document.body.offsetHeight;
121 |     h = (scrollTop)? h+'s':h;
122 |     if(parent.postMessage){
123 |       parent.postMessage( h , '*');
124 |     } else {
125 |       window.location.hash = 'h'+h;
126 |     }
127 |   };
128 | 
129 |   function responsiveIframe() {
130 |     return new ResponsiveIframe();
131 |   }
132 | 
133 |   // expose
134 |   if ('undefined' === typeof exports) {
135 |     window.responsiveIframe = responsiveIframe;
136 |   } else {
137 |     module.exports.responsiveIframe = responsiveIframe;
138 |   }
139 | }());
140 | 


--------------------------------------------------------------------------------
/test/jquery.responsiveiframe.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 | <head>
 4 |   <meta charset="utf-8">
 5 |   <title>jQuery Responsiveiframe Test Suite</title>
 6 |   <!-- Load local jQuery, removing access to $ (use jQuery, not $). -->
 7 |     <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.0/jquery.min.js"></script>
 8 |   <script>jQuery.noConflict()</script>
 9 |   <!-- Load local QUnit (grunt requires v1.0.0 or newer). -->
10 |   <link rel="stylesheet" href="../libs/qunit/qunit.css" media="screen">
11 |   <script src="../libs/qunit/qunit.js"></script>
12 |   <!-- Load local lib and tests. -->
13 |   <script src="../src/jquery.responsiveiframe.js"></script>
14 |   <script src="jquery.responsiveiframe_test.js"></script>
15 | </head>
16 | <body>
17 |   <h1 id="qunit-header">jQuery Responsiveiframe Test Suite</h1>
18 |   <h2 id="qunit-banner"></h2>
19 |   <div id="qunit-testrunner-toolbar"></div>
20 |   <h2 id="qunit-userAgent"></h2>
21 |   <ol id="qunit-tests"></ol>
22 |   <div id="qunit-fixture">
23 |     <span>lame test markup</span>
24 |     <span>normal test markup</span>
25 |     <span>awesome test markup</span>
26 |   </div>
27 | </body>
28 | </html>
29 | 


--------------------------------------------------------------------------------
/test/jquery.responsiveiframe_test.js:
--------------------------------------------------------------------------------
 1 | /*global QUnit:false, module:false, test:false, asyncTest:false, expect:false*/
 2 | /*global start:false, stop:false ok:false, equal:false, notEqual:false, deepEqual:false*/
 3 | /*global notDeepEqual:false, strictEqual:false, notStrictEqual:false, raises:false*/
 4 | (function($) {
 5 | 
 6 |   /*
 7 |     ======== A Handy Little QUnit Reference ========
 8 |     http://docs.jquery.com/QUnit
 9 | 
10 |     Test methods:
11 |       expect(numAssertions)
12 |       stop(increment)
13 |       start(decrement)
14 |     Test assertions:
15 |       ok(value, [message])
16 |       equal(actual, expected, [message])
17 |       notEqual(actual, expected, [message])
18 |       deepEqual(actual, expected, [message])
19 |       notDeepEqual(actual, expected, [message])
20 |       strictEqual(actual, expected, [message])
21 |       notStrictEqual(actual, expected, [message])
22 |       raises(block, [expected], [message])
23 |   */
24 | 
25 |   module('jQuery#awesome', {
26 |     setup: function() {
27 |       this.elems = $('#qunit-fixture').children();
28 |     }
29 |   });
30 | 
31 |   test('is chainable', 1, function() {
32 |     // Not a bad test to run on collection methods.
33 |     strictEqual(this.elems.awesome(), this.elems, 'should be chaninable');
34 |   });
35 | 
36 |   test('is awesome', 1, function() {
37 |     strictEqual(this.elems.awesome().text(), 'awesomeawesomeawesome', 'should be thoroughly awesome');
38 |   });
39 | 
40 |   module('jQuery.awesome');
41 | 
42 |   test('is awesome', 1, function() {
43 |     strictEqual($.awesome(), 'awesome', 'should be thoroughly awesome');
44 |   });
45 | 
46 |   module(':awesome selector', {
47 |     setup: function() {
48 |       this.elems = $('#qunit-fixture').children();
49 |     }
50 |   });
51 | 
52 |   test('is awesome', 1, function() {
53 |     // Use deepEqual & .get() when comparing jQuery objects.
54 |     deepEqual(this.elems.filter(':awesome').get(), this.elems.last().get(), 'knows awesome when it sees it');
55 |   });
56 | 
57 | }(jQuery));
58 | 


--------------------------------------------------------------------------------