├── .gitignore ├── .travis.yml ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── bower.json ├── demo ├── datepicker.html └── index.html ├── dist ├── jquery.maskedinput.js └── jquery.maskedinput.min.js ├── gruntfile.js ├── jquery.maskedinput.nuspec ├── lib ├── jquery-1.8.3.min.js └── jquery-1.9.0.min.js ├── package.json ├── spec ├── Backspace.Spec.js ├── Completed.Spec.js ├── Delete.spec.js ├── Enter.Spec.js ├── Escape.Spec.js ├── Focus.Spec.js ├── Init.Spec.js ├── Optional.Spec.js ├── Paste.Spec.js ├── Placeholder.spec.js ├── Raw.Spec.js ├── Readonly.Spec.js ├── Setup.Spec.js ├── Typing.Spec.js └── lib │ ├── jasmine-species │ ├── BSD.LICENSE │ ├── jasmine-be-calm.css │ ├── jasmine-grammar.js │ ├── jasmine-reporting.js │ └── version.json │ ├── jasmine │ ├── MIT.LICENSE │ ├── jasmine-html.js │ ├── jasmine.css │ └── jasmine.js │ ├── jquery.keymasher.js │ ├── matchers.js │ └── setup.js └── src └── jquery.maskedinput.js /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | .idea/* 3 | 4 | node_modules/ 5 | bower_components/ 6 | dist/ 7 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | node_js: 3 | - "0.10" 4 | before_script: 5 | - npm install -g grunt-cli 6 | 7 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing 2 | 3 | Please take a moment to review this document in order to make the contribution 4 | process easy and effective for everyone involved! 5 | 6 | ## Using the issue tracker 7 | 8 | The issue tracker is for: 9 | * [Bug Reports](#bug-reports) 10 | * [Feature Requests](#feature-requests) 11 | * [Submitting Pull Requests](#pull-requests) 12 | 13 | Please **do not** use the issue tracker for personal support requests. 14 | 15 | ## Bug Reports 16 | 17 | A bug is a _demonstrable problem_ that is caused by the code in the repository. 18 | 19 | Guidelines for bug reports: 20 | 21 | 1. **Use the GitHub issue search** — check if the issue has already been 22 | reported. 23 | 24 | 2. **Check if the issue has been fixed** — try to reproduce it using the 25 | `master` branch in the repository. 26 | 27 | 3. **Isolate and report the problem** — ideally create a reduced test 28 | case or a small [jsfiddle](http://jsfiddle.net) showing the issue. 29 | 30 | Please try to be as detailed as possible in your report. Include information about 31 | your operating system, browser, jQuery version, and masked input plugin version. 32 | Please provide steps to reproduce the issue as well as the outcome you were expecting. 33 | 34 | ## Feature Requests 35 | 36 | Feature requests are welcome. It's up to *you* to make a strong case of the merits of 37 | this feature. Please provide as much detail and context as possible. 38 | 39 | Features that have a very narrow use case are unlikely to be accepted unless we 40 | can come up with a way to come to a more general solution. Please don't let 41 | that stop you from sharing your ideas, just keep that in mind. 42 | 43 | ## Pull Requests 44 | 45 | Good pull requests are very helpful. They should remain focused 46 | in scope and avoid containing unrelated commits. 47 | 48 | **IMPORTANT**: By submitting a patch, you agree that your work will be 49 | licensed under the license used by the project. 50 | 51 | If you have any large pull request in mind (e.g. implementing features, 52 | refactoring code, etc), **please ask first** otherwise you risk spending 53 | a lot of time working on something that the project's developers might 54 | not want to merge into the project. 55 | 56 | Please adhere to the coding conventions in the project (indentation, 57 | accurate comments, etc.) and don't forget to add your own tests and 58 | documentation. When working with git, we recommend the following process 59 | in order to craft an excellent pull request: 60 | 61 | 1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork, 62 | and configure the remotes: 63 | 64 | ```bash 65 | # Clone your fork of the repo into the current directory 66 | git clone https://github.com//jquery.maskedinput 67 | # Navigate to the newly cloned directory 68 | cd jquery.maskedinput 69 | # Assign the original repo to a remote called "upstream" 70 | git remote add upstream https://github.com/digitalBush/jquery.maskedinput 71 | ``` 72 | 73 | 2. If you cloned a while ago, get the latest changes from upstream: 74 | 75 | ```bash 76 | git checkout master 77 | git pull upstream master 78 | ``` 79 | 80 | 3. Create a new topic branch (off of `master`) to contain your feature, change, 81 | or fix. 82 | 83 | **IMPORTANT**: Making changes in `master` is discouraged. You should always 84 | keep your local `master` in sync with upstream `master` and make your 85 | changes in topic branches. 86 | 87 | ```bash 88 | git checkout -b 89 | ``` 90 | 91 | 4. Commit your changes in logical chunks. Keep your commit messages organized, 92 | with a short description in the first line and more detailed information on 93 | the following lines. 94 | 95 | Please use git's 96 | [interactive rebase](https://help.github.com/articles/interactive-rebase) 97 | feature to tidy up your commits before making them public. Ideally when you 98 | are finished you'll have a single commit. 99 | 100 | 5. Make sure all the tests are still passing. 101 | 102 | ```bash 103 | npm test 104 | ``` 105 | 106 | 6. Push your topic branch up to your fork: 107 | 108 | ```bash 109 | git push origin 110 | ``` 111 | 112 | 7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) 113 | with a clear title and description. 114 | 115 | 8. If you haven't updated your pull request for a while, you should consider 116 | rebasing on master and resolving any conflicts. 117 | 118 | **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You 119 | should always `git rebase` on `master` to bring your changes up to date when 120 | necessary. 121 | 122 | ```bash 123 | git checkout master 124 | git pull upstream master 125 | git checkout 126 | git rebase master 127 | ``` 128 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2007-2015 Josh Bush (digitalbush.com) 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 | Masked Input Plugin for jQuery 2 | ============================== 3 | **Notice: This project is no longer being maintained.** 4 | 5 | I started this project [over 10 years ago](https://forum.jquery.com/topic/jquery-introduction-and-masked-input-plugin) to fill a need for a side project I was working on at the time. Nothing ever became of that side project, but this little plugin lived on. Over the years it brought me joy to stumble on sites using this thing. It was super encouraging to hear from people using it in their own products. I tried for a while to maintain it, even after I had moved away from front end web development. 6 | 7 | The time has come to officially call it quits. The web has changed(**A LOT**) and there are better things out there like [Cleave.js](https://nosir.github.io/cleave.js/). I'll leave this repo up for posterity in an archived state. Thank you to everyone who contributed to or used this plugin over the years. 8 | 9 | 10 | Overview 11 | -------- 12 | This is a masked input plugin for the jQuery javascript library. It allows a user to more easily enter fixed width input where you would like them to enter the data in a certain format (dates,phone numbers, etc). It has been tested on Internet Explorer, Firefox, Safari, Opera, and Chrome. A mask is defined by a format made up of mask literals and mask definitions. Any character not in the definitions list below is considered a mask literal. Mask literals will be automatically entered for the user as they type and will not be able to be removed by the user.The following mask definitions are predefined: 13 | 14 | * a - Represents an alpha character (A-Z,a-z) 15 | * 9 - Represents a numeric character (0-9) 16 | * \* - Represents an alphanumeric character (A-Z,a-z,0-9) 17 | 18 | ### Usage 19 | First, include the jQuery and masked input javascript files. 20 | 21 | ```html 22 | 23 | 24 | ``` 25 | 26 | Next, call the mask function for those items you wish to have masked. 27 | 28 | ```html 29 | jQuery(function($){ 30 | $("#date").mask("99/99/9999"); 31 | $("#phone").mask("(999) 999-9999"); 32 | $("#tin").mask("99-9999999"); 33 | $("#ssn").mask("999-99-9999"); 34 | }); 35 | ``` 36 | 37 | Optionally, if you are not satisfied with the underscore ('_') character as a placeholder, you may pass an optional argument to the maskedinput method. 38 | 39 | ```html 40 | jQuery(function($){ 41 | $("#product").mask("99/99/9999",{placeholder:" "}); 42 | }); 43 | ``` 44 | 45 | Optionally, if you would like to execute a function once the mask has been completed, you can specify that function as an optional argument to the maskedinput method. 46 | 47 | ```html 48 | jQuery(function($){ 49 | $("#product").mask("99/99/9999",{completed:function(){alert("You typed the following: "+this.val());}}); 50 | }); 51 | ``` 52 | 53 | Optionally, if you would like to disable the automatic discarding of the uncomplete input, you may pass an optional argument to the maskedinput method 54 | ```html 55 | jQuery(function($){ 56 | $("#product").mask("99/99/9999",{autoclear: false}); 57 | }); 58 | ``` 59 | 60 | You can now supply your own mask definitions. 61 | ```html 62 | jQuery(function($){ 63 | $.mask.definitions['~']='[+-]'; 64 | $("#eyescript").mask("~9.99 ~9.99 999"); 65 | }); 66 | ``` 67 | 68 | You can have part of your mask be optional. Anything listed after '?' within the mask is considered optional user input. The common example for this is phone number + optional extension. 69 | 70 | ```html 71 | jQuery(function($){ 72 | $("#phone").mask("(999) 999-9999? x99999"); 73 | }); 74 | ``` 75 | 76 | If your requirements aren't met by the predefined placeholders, you can always add your own. For example, maybe you need a mask to only allow hexadecimal characters. You can add your own definition for a placeholder, say 'h', like so: `$.mask.definitions['h'] = "[A-Fa-f0-9]";` Then you can use that to mask for something like css colors in hex with a `mask "#hhhhhh"`. 77 | 78 | ```html 79 | jQuery(function($){ 80 | $("#phone").mask("#hhhhhh"); 81 | }); 82 | ``` 83 | 84 | 85 | By design, this plugin will reject input which doesn't complete the mask. You can bypass this by using a '?' character at the position where you would like to consider input optional. For example, a mask of "(999) 999-9999? x99999" would require only the first 10 digits of a phone number with extension being optional. 86 | 87 | 88 | Getting the bits 89 | ---------------- 90 | We generally recommend that you use [bower](http://bower.io) to install jquery.maskedinput plugin. 91 | 92 | $ bower install --save jquery.maskedinput 93 | 94 | 95 | Setting up your Developer Environment 96 | ------------------------------------- 97 | jQuery Masked Input uses [NodeJS](http://www.nodejs.org) and [GruntJS](http://www.gruntjs.com) as it's developer platform and build automation tool. 98 | 99 | To get your environment setup correctly, you'll need nodejs version 0.8.25 or greater installed. You'll also need to install the grunt command line tool: 100 | 101 | $ sudo npm install -g grunt-cli 102 | 103 | Once node is installed on your system all that you need to do is install the developer dependencies and run the grunt build: 104 | 105 | $ npm install 106 | $ grunt 107 | 108 | All of the tests for jQuery Masked Input are run using the [jasmine](http://jasmine.github.io/) test runner. 109 | -------------------------------------------------------------------------------- /bower.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jquery.maskedinput", 3 | "homepage": "http://digitalbush.com/projects/masked-input-plugin/", 4 | "authors": [ 5 | "Josh Bush (digitalbush.com)" 6 | ], 7 | "description": "jQuery Masked Input Plugin", 8 | "main": "./dist/jquery.maskedinput.js", 9 | "moduleType": [ 10 | "es6" 11 | ], 12 | "keywords": [ 13 | "input", 14 | "form", 15 | "mask", 16 | "jquery" 17 | ], 18 | "license": "MIT", 19 | "ignore": [ 20 | "**/.*", 21 | "node_modules", 22 | "bower_components", 23 | "spec", 24 | "lib" 25 | ], 26 | "dependencies": { 27 | "jquery": ">=1.8.3" 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /demo/datepicker.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | datepicker demo 4 | 5 | 6 | 7 | 8 | 16 | 17 | 18 | 19 | 20 |
Date99/99/9999
21 | 22 | 23 | -------------------------------------------------------------------------------- /demo/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | jQuery Mask Test 4 | 5 | 6 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 |
Date99/99/9999
Phone(999) 999-9999
Phone(Readonly)(999) 999-9999
Phone + Ext(999) 999-9999? x99999
Int'l Phone+33 999 999 999
Tax ID99-9999999
SSN999-99-9999
Product Keya*-999-a999
Eye Script~9.99 ~9.99 999
Purchase Orderaaa-999-***
Percent99%
Phone (autoclear=false)(999) 999-9999
Phone + Ext (autoclear=false)(999) 999-9999? x99999
47 |
48 | 49 | 50 | -------------------------------------------------------------------------------- /dist/jquery.maskedinput.js: -------------------------------------------------------------------------------- 1 | /* 2 | jQuery Masked Input Plugin 3 | Copyright (c) 2007 - 2015 Josh Bush (digitalbush.com) 4 | Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) 5 | Version: 1.4.1 6 | */ 7 | !function(factory) { 8 | "function" == typeof define && define.amd ? define([ "jquery" ], factory) : factory("object" == typeof exports ? require("jquery") : jQuery); 9 | }(function($) { 10 | var caretTimeoutId, ua = navigator.userAgent, iPhone = /iphone/i.test(ua), chrome = /chrome/i.test(ua), android = /android/i.test(ua); 11 | $.mask = { 12 | definitions: { 13 | "9": "[0-9]", 14 | a: "[A-Za-z]", 15 | "*": "[A-Za-z0-9]" 16 | }, 17 | autoclear: !0, 18 | dataName: "rawMaskFn", 19 | placeholder: "_" 20 | }, $.fn.extend({ 21 | caret: function(begin, end) { 22 | var range; 23 | if (0 !== this.length && !this.is(":hidden")) return "number" == typeof begin ? (end = "number" == typeof end ? end : begin, 24 | this.each(function() { 25 | this.setSelectionRange ? this.setSelectionRange(begin, end) : this.createTextRange && (range = this.createTextRange(), 26 | range.collapse(!0), range.moveEnd("character", end), range.moveStart("character", begin), 27 | range.select()); 28 | })) : (this[0].setSelectionRange ? (begin = this[0].selectionStart, end = this[0].selectionEnd) : document.selection && document.selection.createRange && (range = document.selection.createRange(), 29 | begin = 0 - range.duplicate().moveStart("character", -1e5), end = begin + range.text.length), 30 | { 31 | begin: begin, 32 | end: end 33 | }); 34 | }, 35 | unmask: function() { 36 | return this.trigger("unmask"); 37 | }, 38 | mask: function(mask, settings) { 39 | var input, defs, tests, partialPosition, firstNonMaskPos, lastRequiredNonMaskPos, len, oldVal; 40 | if (!mask && this.length > 0) { 41 | input = $(this[0]); 42 | var fn = input.data($.mask.dataName); 43 | return fn ? fn() : void 0; 44 | } 45 | return settings = $.extend({ 46 | autoclear: $.mask.autoclear, 47 | placeholder: $.mask.placeholder, 48 | completed: null 49 | }, settings), defs = $.mask.definitions, tests = [], partialPosition = len = mask.length, 50 | firstNonMaskPos = null, $.each(mask.split(""), function(i, c) { 51 | "?" == c ? (len--, partialPosition = i) : defs[c] ? (tests.push(new RegExp(defs[c])), 52 | null === firstNonMaskPos && (firstNonMaskPos = tests.length - 1), partialPosition > i && (lastRequiredNonMaskPos = tests.length - 1)) : tests.push(null); 53 | }), this.trigger("unmask").each(function() { 54 | function tryFireCompleted() { 55 | if (settings.completed) { 56 | for (var i = firstNonMaskPos; lastRequiredNonMaskPos >= i; i++) if (tests[i] && buffer[i] === getPlaceholder(i)) return; 57 | settings.completed.call(input); 58 | } 59 | } 60 | function getPlaceholder(i) { 61 | return settings.placeholder.charAt(i < settings.placeholder.length ? i : 0); 62 | } 63 | function seekNext(pos) { 64 | for (;++pos < len && !tests[pos]; ) ; 65 | return pos; 66 | } 67 | function seekPrev(pos) { 68 | for (;--pos >= 0 && !tests[pos]; ) ; 69 | return pos; 70 | } 71 | function shiftL(begin, end) { 72 | var i, j; 73 | if (!(0 > begin)) { 74 | for (i = begin, j = seekNext(end); len > i; i++) if (tests[i]) { 75 | if (!(len > j && tests[i].test(buffer[j]))) break; 76 | buffer[i] = buffer[j], buffer[j] = getPlaceholder(j), j = seekNext(j); 77 | } 78 | writeBuffer(), input.caret(Math.max(firstNonMaskPos, begin)); 79 | } 80 | } 81 | function shiftR(pos) { 82 | var i, c, j, t; 83 | for (i = pos, c = getPlaceholder(pos); len > i; i++) if (tests[i]) { 84 | if (j = seekNext(i), t = buffer[i], buffer[i] = c, !(len > j && tests[j].test(t))) break; 85 | c = t; 86 | } 87 | } 88 | function androidInputEvent() { 89 | var curVal = input.val(), pos = input.caret(); 90 | if (oldVal && oldVal.length && oldVal.length > curVal.length) { 91 | for (checkVal(!0); pos.begin > 0 && !tests[pos.begin - 1]; ) pos.begin--; 92 | if (0 === pos.begin) for (;pos.begin < firstNonMaskPos && !tests[pos.begin]; ) pos.begin++; 93 | input.caret(pos.begin, pos.begin); 94 | } else { 95 | for (checkVal(!0); pos.begin < len && !tests[pos.begin]; ) pos.begin++; 96 | input.caret(pos.begin, pos.begin); 97 | } 98 | tryFireCompleted(); 99 | } 100 | function blurEvent() { 101 | checkVal(), input.val() != focusText && input.change(); 102 | } 103 | function keydownEvent(e) { 104 | if (!input.prop("readonly")) { 105 | var pos, begin, end, k = e.which || e.keyCode; 106 | oldVal = input.val(), 8 === k || 46 === k || iPhone && 127 === k ? (pos = input.caret(), 107 | begin = pos.begin, end = pos.end, end - begin === 0 && (begin = 46 !== k ? seekPrev(begin) : end = seekNext(begin - 1), 108 | end = 46 === k ? seekNext(end) : end), clearBuffer(begin, end), shiftL(begin, end - 1), 109 | e.preventDefault()) : 13 === k ? blurEvent.call(this, e) : 27 === k && (input.val(focusText), 110 | input.caret(0, checkVal()), e.preventDefault()); 111 | } 112 | } 113 | function keypressEvent(e) { 114 | if (!input.prop("readonly")) { 115 | var p, c, next, k = e.which || e.keyCode, pos = input.caret(); 116 | if (!(e.ctrlKey || e.altKey || e.metaKey || 32 > k) && k && 13 !== k) { 117 | if (pos.end - pos.begin !== 0 && (clearBuffer(pos.begin, pos.end), shiftL(pos.begin, pos.end - 1)), 118 | p = seekNext(pos.begin - 1), len > p && (c = String.fromCharCode(k), tests[p].test(c))) { 119 | if (shiftR(p), buffer[p] = c, writeBuffer(), next = seekNext(p), android) { 120 | var proxy = function() { 121 | $.proxy($.fn.caret, input, next)(); 122 | }; 123 | setTimeout(proxy, 0); 124 | } else input.caret(next); 125 | pos.begin <= lastRequiredNonMaskPos && tryFireCompleted(); 126 | } 127 | e.preventDefault(); 128 | } 129 | } 130 | } 131 | function clearBuffer(start, end) { 132 | var i; 133 | for (i = start; end > i && len > i; i++) tests[i] && (buffer[i] = getPlaceholder(i)); 134 | } 135 | function writeBuffer() { 136 | input.val(buffer.join("")); 137 | } 138 | function checkVal(allow) { 139 | var i, c, pos, test = input.val(), lastMatch = -1; 140 | for (i = 0, pos = 0; len > i; i++) if (tests[i]) { 141 | for (buffer[i] = getPlaceholder(i); pos++ < test.length; ) if (c = test.charAt(pos - 1), 142 | tests[i].test(c)) { 143 | buffer[i] = c, lastMatch = i; 144 | break; 145 | } 146 | if (pos > test.length) { 147 | clearBuffer(i + 1, len); 148 | break; 149 | } 150 | } else buffer[i] === test.charAt(pos) && pos++, partialPosition > i && (lastMatch = i); 151 | return allow ? writeBuffer() : partialPosition > lastMatch + 1 ? settings.autoclear || buffer.join("") === defaultBuffer ? (input.val() && input.val(""), 152 | clearBuffer(0, len)) : writeBuffer() : (writeBuffer(), input.val(input.val().substring(0, lastMatch + 1))), 153 | partialPosition ? i : firstNonMaskPos; 154 | } 155 | var input = $(this), buffer = $.map(mask.split(""), function(c, i) { 156 | return "?" != c ? defs[c] ? getPlaceholder(i) : c : void 0; 157 | }), defaultBuffer = buffer.join(""), focusText = input.val(); 158 | input.data($.mask.dataName, function() { 159 | return $.map(buffer, function(c, i) { 160 | return tests[i] && c != getPlaceholder(i) ? c : null; 161 | }).join(""); 162 | }), input.one("unmask", function() { 163 | input.off(".mask").removeData($.mask.dataName); 164 | }).on("focus.mask", function() { 165 | if (!input.prop("readonly")) { 166 | clearTimeout(caretTimeoutId); 167 | var pos; 168 | focusText = input.val(), pos = checkVal(), caretTimeoutId = setTimeout(function() { 169 | input.get(0) === document.activeElement && (writeBuffer(), pos == mask.replace("?", "").length ? input.caret(0, pos) : input.caret(pos)); 170 | }, 10); 171 | } 172 | }).on("blur.mask", blurEvent).on("keydown.mask", keydownEvent).on("keypress.mask", keypressEvent).on("input.mask paste.mask", function() { 173 | input.prop("readonly") || setTimeout(function() { 174 | var pos = checkVal(!0); 175 | input.caret(pos), tryFireCompleted(); 176 | }, 0); 177 | }), chrome && android && input.off("input.mask").on("input.mask", androidInputEvent), 178 | checkVal(); 179 | }); 180 | } 181 | }); 182 | }); -------------------------------------------------------------------------------- /dist/jquery.maskedinput.min.js: -------------------------------------------------------------------------------- 1 | /* 2 | jQuery Masked Input Plugin 3 | Copyright (c) 2007 - 2015 Josh Bush (digitalbush.com) 4 | Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license) 5 | Version: 1.4.1 6 | */ 7 | !function(a){"function"==typeof define&&define.amd?define(["jquery"],a):a("object"==typeof exports?require("jquery"):jQuery)}(function(a){var b,c=navigator.userAgent,d=/iphone/i.test(c),e=/chrome/i.test(c),f=/android/i.test(c);a.mask={definitions:{9:"[0-9]",a:"[A-Za-z]","*":"[A-Za-z0-9]"},autoclear:!0,dataName:"rawMaskFn",placeholder:"_"},a.fn.extend({caret:function(a,b){var c;if(0!==this.length&&!this.is(":hidden"))return"number"==typeof a?(b="number"==typeof b?b:a,this.each(function(){this.setSelectionRange?this.setSelectionRange(a,b):this.createTextRange&&(c=this.createTextRange(),c.collapse(!0),c.moveEnd("character",b),c.moveStart("character",a),c.select())})):(this[0].setSelectionRange?(a=this[0].selectionStart,b=this[0].selectionEnd):document.selection&&document.selection.createRange&&(c=document.selection.createRange(),a=0-c.duplicate().moveStart("character",-1e5),b=a+c.text.length),{begin:a,end:b})},unmask:function(){return this.trigger("unmask")},mask:function(c,g){var h,i,j,k,l,m,n,o;if(!c&&this.length>0){h=a(this[0]);var p=h.data(a.mask.dataName);return p?p():void 0}return g=a.extend({autoclear:a.mask.autoclear,placeholder:a.mask.placeholder,completed:null},g),i=a.mask.definitions,j=[],k=n=c.length,l=null,a.each(c.split(""),function(a,b){"?"==b?(n--,k=a):i[b]?(j.push(new RegExp(i[b])),null===l&&(l=j.length-1),k>a&&(m=j.length-1)):j.push(null)}),this.trigger("unmask").each(function(){function h(){if(g.completed){for(var a=l;m>=a;a++)if(j[a]&&C[a]===p(a))return;g.completed.call(B)}}function p(a){return g.placeholder.charAt(a=0&&!j[a];);return a}function s(a,b){var c,d;if(!(0>a)){for(c=a,d=q(b);n>c;c++)if(j[c]){if(!(n>d&&j[c].test(C[d])))break;C[c]=C[d],C[d]=p(d),d=q(d)}z(),B.caret(Math.max(l,a))}}function t(a){var b,c,d,e;for(b=a,c=p(a);n>b;b++)if(j[b]){if(d=q(b),e=C[b],C[b]=c,!(n>d&&j[d].test(e)))break;c=e}}function u(){var a=B.val(),b=B.caret();if(o&&o.length&&o.length>a.length){for(A(!0);b.begin>0&&!j[b.begin-1];)b.begin--;if(0===b.begin)for(;b.beging)&&g&&13!==g){if(i.end-i.begin!==0&&(y(i.begin,i.end),s(i.begin,i.end-1)),c=q(i.begin-1),n>c&&(d=String.fromCharCode(g),j[c].test(d))){if(t(c),C[c]=d,z(),e=q(c),f){var k=function(){a.proxy(a.fn.caret,B,e)()};setTimeout(k,0)}else B.caret(e);i.begin<=m&&h()}b.preventDefault()}}}function y(a,b){var c;for(c=a;b>c&&n>c;c++)j[c]&&(C[c]=p(c))}function z(){B.val(C.join(""))}function A(a){var b,c,d,e=B.val(),f=-1;for(b=0,d=0;n>b;b++)if(j[b]){for(C[b]=p(b);d++e.length){y(b+1,n);break}}else C[b]===e.charAt(d)&&d++,k>b&&(f=b);return a?z():k>f+1?g.autoclear||C.join("")===D?(B.val()&&B.val(""),y(0,n)):z():(z(),B.val(B.val().substring(0,f+1))),k?b:l}var B=a(this),C=a.map(c.split(""),function(a,b){return"?"!=a?i[a]?p(b):a:void 0}),D=C.join(""),E=B.val();B.data(a.mask.dataName,function(){return a.map(C,function(a,b){return j[b]&&a!=p(b)?a:null}).join("")}),B.one("unmask",function(){B.off(".mask").removeData(a.mask.dataName)}).on("focus.mask",function(){if(!B.prop("readonly")){clearTimeout(b);var a;E=B.val(),a=A(),b=setTimeout(function(){B.get(0)===document.activeElement&&(z(),a==c.replace("?","").length?B.caret(0,a):B.caret(a))},10)}}).on("blur.mask",v).on("keydown.mask",w).on("keypress.mask",x).on("input.mask paste.mask",function(){B.prop("readonly")||setTimeout(function(){var a=A(!0);B.caret(a),h()},0)}),e&&f&&B.off("input.mask").on("input.mask",u),A()})}})}); -------------------------------------------------------------------------------- /gruntfile.js: -------------------------------------------------------------------------------- 1 | 2 | "use strict"; 3 | 4 | module.exports = function( grunt ) { 5 | grunt.initConfig({ 6 | // TODO: change to read component.json 7 | pkg: require('./package.json'), 8 | 9 | uglify: { 10 | options: { 11 | banner: '/*\n <%= pkg.description %>\n Copyright (c) 2007 - <%= grunt.template.today("yyyy") %> <%= pkg.author %>\n Licensed under the MIT license (http://digitalbush.com/projects/masked-input-plugin/#license)\n Version: <%= pkg.version %>\n*/\n' 12 | }, 13 | 14 | dev: { 15 | options: { 16 | beautify: true, 17 | mangle: false 18 | }, 19 | 20 | files: { 21 | 'dist/jquery.maskedinput.js': ['src/jquery.maskedinput.js'] 22 | } 23 | }, 24 | 25 | min: { 26 | files: { 27 | 'dist/jquery.maskedinput.min.js': ['src/jquery.maskedinput.js'] 28 | } 29 | } 30 | }, 31 | 32 | jasmine: { 33 | full: { 34 | src: "src/**/*.js", 35 | options: { 36 | specs: "spec/*[S|s]pec.js", 37 | vendor: [ 38 | "spec/lib/matchers.js", 39 | "spec/lib/jasmine-species/jasmine-grammar.js", 40 | "spec/lib/setup.js", 41 | "lib/jquery-1.9.0.min.js", 42 | "spec/lib/jquery.keymasher.js" 43 | ] 44 | } 45 | } 46 | }, 47 | nugetpack: { 48 | dist: { 49 | src: 'jquery.maskedinput.nuspec', 50 | dest: 'dist/' 51 | } 52 | } 53 | }); 54 | 55 | grunt.loadNpmTasks("grunt-contrib-jasmine"); 56 | grunt.loadNpmTasks("grunt-contrib-uglify"); 57 | grunt.loadNpmTasks('grunt-nuget'); 58 | 59 | grunt.registerTask('test', ['jasmine']); 60 | grunt.registerTask('pack', ['default','nugetpack']); 61 | grunt.registerTask('default', ['test', 'uglify']); 62 | }; 63 | -------------------------------------------------------------------------------- /jquery.maskedinput.nuspec: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | jQuery.MaskedInput 5 | 1.4.1.0 6 | digitalBush 7 | stimms 8 | https://github.com/digitalBush/jquery.maskedinput/blob/master/LICENSE 9 | http://digitalbush.com/projects/masked-input-plugin/ 10 | false 11 | A jQuery plugin which applies a mask to input boxes to provide both a UI hint for users as well as some rudimentary input checking. 12 | jQuery,plugins 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jquery.maskedinput", 3 | "version": "1.4.1", 4 | "author": "Josh Bush (digitalbush.com)", 5 | "description": "jQuery Masked Input Plugin", 6 | "devDependencies": { 7 | "grunt": "0.4.x", 8 | "grunt-contrib-jasmine": "0.5.x", 9 | "grunt-contrib-uglify": "0.2.x", 10 | "grunt-contrib-watch": "0.5.x", 11 | "grunt-nuget": "^0.1.4" 12 | }, 13 | "scripts": { 14 | "test": "grunt test" 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /spec/Backspace.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Backspace Key", function() { 2 | story('User presses backspace with cursor to the right of a mask literal',function(){ 3 | scenario('character at cursor matches definition to the left',function(){ 4 | given("an input with a mask definition of '9-99'", function(){ 5 | input 6 | .mask("9-99") 7 | .mashKeys("123"); 8 | }); 9 | 10 | given("the input has cursor positioned to the right of literal", function(){ 11 | input.caret(2); 12 | }); 13 | 14 | when("hitting the backspace key",function(){ 15 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 16 | }); 17 | 18 | then("value should be correct",function(){ 19 | expect(input).toHaveValue('2-3_'); 20 | }); 21 | 22 | and("caret position should be correct",function(){ 23 | expect(input.caret().begin).toEqual(0); 24 | }); 25 | }); 26 | 27 | scenario('character at cursor does not match definition to the left',function(){ 28 | given("an input with a mask definition of 'a-99'", function(){ 29 | input 30 | .mask("a-99") 31 | .mashKeys("z12"); 32 | }); 33 | 34 | given("the input has cursor positioned to the right of literal", function(){ 35 | input.caret(2); 36 | }); 37 | 38 | when("hitting the backspace key",function(){ 39 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 40 | }); 41 | 42 | then("value should be correct",function(){ 43 | expect(input).toHaveValue('_-12'); 44 | }); 45 | 46 | and("caret position should be correct",function(){ 47 | expect(input.caret().begin).toEqual(0); 48 | }); 49 | }); 50 | }); 51 | 52 | story('User presses backspace with cursor on last character',function(){ 53 | scenario('cursor character matches definition to the left',function(){ 54 | given("an input with a mask definition of '99'", function(){ 55 | input 56 | .mask("99") 57 | .mashKeys("12"); 58 | }); 59 | 60 | given("the input has cursor positioned on first character", function(){ 61 | input.caret(1); 62 | }); 63 | 64 | when("hitting the backspace key",function(){ 65 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 66 | }); 67 | 68 | then("value should be correct",function(){ 69 | expect(input).toHaveValue('2_'); 70 | }); 71 | 72 | and("caret position should be correct",function(){ 73 | expect(input.caret().begin).toEqual(0); 74 | }); 75 | }); 76 | 77 | scenario('cursor character does not match definition to the left',function(){ 78 | given("an input with a mask definition of '9a'", function(){ 79 | input 80 | .mask("9a") 81 | .mashKeys("1z"); 82 | }); 83 | 84 | given("the input has cursor positioned on first character", function(){ 85 | input.caret(1); 86 | }); 87 | 88 | when("hitting the backspace key",function(){ 89 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 90 | }); 91 | 92 | then("value should be correct",function(){ 93 | expect(input).toHaveValue('_z'); 94 | }); 95 | 96 | and("caret position should be correct",function(){ 97 | expect(input.caret().begin).toEqual(0); 98 | }); 99 | }); 100 | 101 | describe('There is a mask literal between the two placeholders',function(){ 102 | scenario('character at end matches definition of first position',function(){ 103 | given("an input with a mask definition of '9-9'", function(){ 104 | input 105 | .mask("9-9") 106 | .mashKeys("12"); 107 | }); 108 | 109 | given("the input has cursor positioned on literal", function(){ 110 | input.caret(1); 111 | }); 112 | 113 | when("hitting the backspace key",function(){ 114 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 115 | }); 116 | 117 | then("value should be correct",function(){ 118 | expect(input).toHaveValue('2-_'); 119 | }); 120 | 121 | and("caret position should be correct",function(){ 122 | expect(input.caret().begin).toEqual(0); 123 | }); 124 | }); 125 | 126 | scenario('character at end does not match definition of first position',function(){ 127 | given("an input with a mask definition of '9-9'", function(){ 128 | input 129 | .mask("9-a") 130 | .mashKeys("1z"); 131 | }); 132 | 133 | given("the input has cursor positioned on literal", function(){ 134 | input.caret(1); 135 | }); 136 | 137 | when("hitting the backspace key",function(){ 138 | input.mashKeys(function(keys){keys.type(keys.backspace)}); 139 | }); 140 | 141 | then("value should be correct",function(){ 142 | expect(input).toHaveValue('_-z'); 143 | }); 144 | 145 | and("caret position should be correct",function(){ 146 | expect(input.caret().begin).toEqual(0); 147 | }); 148 | }); 149 | }); 150 | }); 151 | }); 152 | -------------------------------------------------------------------------------- /spec/Completed.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Completed callback", function() { 2 | scenario('Completing mask by typing last character',function(){ 3 | var completed=false; 4 | given("an input with a completed callback", function(){ 5 | input.mask("99",{completed:function(){completed=true;}}); 6 | }); 7 | 8 | when("typing left to right",function(){ 9 | input.mashKeys("12"); 10 | }); 11 | 12 | then("completed callback should be called",function(){ 13 | expect(completed).toBeTruthy(); 14 | }); 15 | then("value should be correct",function(){ 16 | expect(input).toHaveValue('12'); 17 | }); 18 | }); 19 | 20 | scenario('Completing mask by typing first character',function(){ 21 | var completed=false; 22 | given("an input with a completed callback", function(){ 23 | input.val("12").mask("99",{completed:function(){completed=true;}}); 24 | }); 25 | 26 | when("replacing first character value",function(){ 27 | input 28 | .caret(1) 29 | .mashKeys(function(keys){keys.type(keys.backspace)}) 30 | .mashKeys("3"); 31 | }); 32 | 33 | then("completed callback should be called",function(){ 34 | expect(completed).toBeTruthy(); 35 | }); 36 | 37 | then("value should be correct",function(){ 38 | expect(input).toHaveValue('32'); 39 | }); 40 | }); 41 | 42 | scenario('Typing last character of incomplete mask',function(){ 43 | var completed=false; 44 | given("an input with a completed callback", function(){ 45 | input 46 | .mask("99",{completed:function(){completed=true;}}) 47 | .mashKeys("1") 48 | .mashKeys(function(keys){keys.type(keys.backspace)}); 49 | }); 50 | 51 | when("moving cursor to last position and typing",function(){ 52 | input.caret(1).mashKeys("5"); 53 | }); 54 | 55 | then("completed callback should not be called",function(){ 56 | expect(completed).toBeFalsy(); 57 | }); 58 | 59 | then("value should be correct",function(){ 60 | expect(input).toHaveValue('_5'); 61 | }); 62 | 63 | }); 64 | 65 | scenario('Typing last character of required portion of mask containing optional',function(){ 66 | var completed=false; 67 | given("an input with a completed callback", function(){ 68 | input.mask("99?99",{completed:function(){completed=true;}}); 69 | }); 70 | 71 | when("typing left to right",function(){ 72 | input.mashKeys("12"); 73 | }); 74 | 75 | then("completed callback should be called",function(){ 76 | expect(completed).toBeTruthy(); 77 | }); 78 | 79 | then("value should be correct",function(){ 80 | expect(input).toHaveValue('12__'); 81 | }); 82 | }); 83 | 84 | scenario('Typing all characters of required portion of mask containing optional',function(){ 85 | var completedCount=0; 86 | given("an input with a completed callback", function(){ 87 | input.mask("99?99",{completed:function(){completedCount++;}}); 88 | }); 89 | 90 | when("typing left to right",function(){ 91 | input.mashKeys("1234"); 92 | }); 93 | 94 | then("completed callback should be called",function(){ 95 | expect(completedCount).toEqual(1); 96 | }); 97 | 98 | then("value should be correct",function(){ 99 | expect(input).toHaveValue('1234'); 100 | }); 101 | }); 102 | 103 | scenario('Completing mask by typing last character with literal to right',function(){ 104 | var completed=false; 105 | given("an input with a completed callback", function(){ 106 | input.mask("99!",{completed:function(){completed=true;}}); 107 | }); 108 | 109 | when("typing left to right",function(){ 110 | input.mashKeys("12"); 111 | }); 112 | 113 | then("completed callback should be called",function(){ 114 | expect(completed).toBeTruthy(); 115 | }); 116 | then("value should be correct",function(){ 117 | expect(input).toHaveValue('12!'); 118 | }); 119 | }); 120 | 121 | 122 | }); 123 | -------------------------------------------------------------------------------- /spec/Delete.spec.js: -------------------------------------------------------------------------------- 1 | feature("Delete Key", function() { 2 | story('User presses delete with cursor on a mask literal',function(){ 3 | scenario('character at end matches definition to the right',function(){ 4 | given("an input with a mask definition of '9-99'", function(){ 5 | input 6 | .mask("9-99") 7 | .mashKeys("123"); 8 | }); 9 | 10 | given("the input has cursor positioned on literal", function(){ 11 | input.caret(1); 12 | }); 13 | 14 | when("hitting the delete key",function(){ 15 | input.mashKeys(function(keys){keys.type(keys.delete)}); 16 | }); 17 | 18 | then("value should be correct",function(){ 19 | expect(input).toHaveValue('1-3_'); 20 | }); 21 | 22 | and("caret position should be correct",function(){ 23 | expect(input.caret().begin).toEqual(2); 24 | }); 25 | }); 26 | 27 | scenario('character at end does not match definition to the right',function(){ 28 | given("an input with a mask definition of '9-9a'", function(){ 29 | input 30 | .mask("9-9a") 31 | .mashKeys("12z"); 32 | }); 33 | 34 | given("the input has cursor positioned on literal", function(){ 35 | input.caret(1); 36 | }); 37 | 38 | when("hitting the delete key",function(){ 39 | input.mashKeys(function(keys){keys.type(keys.delete)}); 40 | }); 41 | 42 | then("value should be correct",function(){ 43 | expect(input).toHaveValue('1-_z'); 44 | }); 45 | 46 | and("caret position should be correct",function(){ 47 | expect(input.caret().begin).toEqual(2); 48 | }); 49 | }); 50 | }); 51 | 52 | story('User presses delete with cursor on first character',function(){ 53 | scenario('character to right matches definition of current position',function(){ 54 | given("an input with a mask definition of '99'", function(){ 55 | input 56 | .mask("99") 57 | .mashKeys("12"); 58 | }); 59 | 60 | given("the input has cursor positioned on first character", function(){ 61 | input.caret(0); 62 | }); 63 | 64 | when("hitting the delete key",function(){ 65 | input.mashKeys(function(keys){keys.type(keys.delete)}); 66 | }); 67 | 68 | then("value should be correct",function(){ 69 | expect(input).toHaveValue('2_'); 70 | }); 71 | 72 | and("caret position should be correct",function(){ 73 | expect(input.caret().begin).toEqual(0); 74 | }); 75 | }); 76 | 77 | scenario('character to right does not match definition of current position',function(){ 78 | given("an input with a mask definition of '9a'", function(){ 79 | input 80 | .mask("9a") 81 | .mashKeys("1z"); 82 | }); 83 | 84 | given("the input has cursor positioned on first character", function(){ 85 | input.caret(0); 86 | }); 87 | 88 | when("hitting the delete key",function(){ 89 | input.mashKeys(function(keys){keys.type(keys.delete)}); 90 | }); 91 | 92 | then("value should be correct",function(){ 93 | expect(input).toHaveValue('_z'); 94 | }); 95 | 96 | and("caret position should be correct",function(){ 97 | expect(input.caret().begin).toEqual(0); 98 | }); 99 | }); 100 | 101 | describe('There is a mask literal between the two placeholders',function(){ 102 | scenario('character to right matches definition of current position',function(){ 103 | given("an input with a mask definition of '9-9'", function(){ 104 | input 105 | .mask("9-9") 106 | .mashKeys("12"); 107 | }); 108 | 109 | given("the input has cursor positioned on first character", function(){ 110 | input.caret(0); 111 | }); 112 | 113 | when("hitting the delete key",function(){ 114 | input.mashKeys(function(keys){keys.type(keys.delete)}); 115 | }); 116 | 117 | then("value should be correct",function(){ 118 | expect(input).toHaveValue('2-_'); 119 | }); 120 | 121 | and("caret position should be correct",function(){ 122 | expect(input.caret().begin).toEqual(0); 123 | }); 124 | }); 125 | 126 | scenario('character to right does not match definition of current position',function(){ 127 | given("an input with a mask definition of '9-9'", function(){ 128 | input 129 | .mask("9-a") 130 | .mashKeys("1z"); 131 | }); 132 | 133 | given("the input has cursor positioned on first character", function(){ 134 | input.caret(0); 135 | }); 136 | 137 | when("hitting the delete key",function(){ 138 | input.mashKeys(function(keys){keys.type(keys.delete)}); 139 | }); 140 | 141 | then("value should be correct",function(){ 142 | expect(input).toHaveValue('_-z'); 143 | }); 144 | 145 | and("caret position should be correct",function(){ 146 | expect(input.caret().begin).toEqual(0); 147 | }); 148 | }); 149 | }); 150 | }); 151 | }); 152 | -------------------------------------------------------------------------------- /spec/Enter.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Enter Key", function() { 2 | var enterKeyEvent = $.Event('keydown.mask'); 3 | enterKeyEvent.which = enterKeyEvent.keyCode = 13; 4 | 5 | story('User presses enter key after typing in some changes',function(){ 6 | scenario("All placeholders filled",function(){ 7 | given("a mask with two placeholders",function(){ 8 | input.mask("99"); 9 | }); 10 | when("typing two characters and pressing enter",function(){ 11 | input.mashKeys("12").trigger(enterKeyEvent); 12 | }); 13 | then("value should be correct",function(){ 14 | expect(input).toHaveValue("12"); 15 | }); 16 | }); 17 | 18 | scenario("Empty placeholders remaining",function(){ 19 | given("a mask with two placeholders",function(){ 20 | input.mask("99"); 21 | }); 22 | when("typing one character and pressing enter",function(){ 23 | input.mashKeys("1").trigger(enterKeyEvent); 24 | }); 25 | then("value should be empty",function(){ 26 | expect(input).toHaveValue(""); 27 | }); 28 | }); 29 | 30 | scenario("Empty placeholders remaining with autoclear set to false",function(){ 31 | given("a mask with two placeholders",function(){ 32 | input.mask("99", { autoclear: false }); 33 | }); 34 | when("typing one character and pressing enter",function(){ 35 | input.caret(0); 36 | input.mashKeys("1") 37 | input.trigger(enterKeyEvent); 38 | }); 39 | then("value should remain visible with placeholders",function(){ 40 | expect(input).toHaveValue("1_"); 41 | }); 42 | }); 43 | }); 44 | 45 | story("User presses enter key after typing in some changes and masks contain Optional Markers",function(){ 46 | scenario("Placeholders not filled to marker",function(){ 47 | given("a mask with an optional marker",function(){ 48 | input.mask("99?99"); 49 | }); 50 | when("typing one character and leaving",function(){ 51 | input.mashKeys("1").trigger(enterKeyEvent); 52 | }); 53 | then("value should be empty",function(){ 54 | expect(input).toHaveValue(""); 55 | }); 56 | }); 57 | 58 | scenario("Placeholders not filled to marker and autoclear = false", function() { 59 | given("a mask with an optional marker",function(){ 60 | input.mask("99?99", { autoclear: false }); 61 | }); 62 | when("typing one character and leaving",function(){ 63 | input.mashKeys("1").trigger(enterKeyEvent); 64 | }); 65 | then("value should be empty",function(){ 66 | expect(input).toHaveValue("1___"); 67 | }); 68 | }); 69 | 70 | scenario("Placeholders filled to marker",function(){ 71 | given("a mask with an optional marker",function(){ 72 | input.mask("99?99"); 73 | }); 74 | when("typing two characters and leaving",function(){ 75 | input.mashKeys("12").trigger(enterKeyEvent); 76 | }); 77 | then("value should remain",function(){ 78 | expect(input).toHaveValue("12"); 79 | }); 80 | }); 81 | 82 | scenario("Placeholders filled to marker and autoclear = false", function() { 83 | given("a mask with an optional marker",function(){ 84 | input.mask("99?99", { autoclear: false }); 85 | }); 86 | when("typing two characters and leaving",function(){ 87 | input.mashKeys("12").trigger(enterKeyEvent); 88 | }); 89 | then("value should remain",function(){ 90 | expect(input).toHaveValue("12"); 91 | }); 92 | }); 93 | 94 | scenario("Placeholders filled, one marker filled, and autoclear = false", function() { 95 | given("a mask with an optional marker",function(){ 96 | input.mask("99?99", { autoclear: false }); 97 | }); 98 | when("typing three characters and leaving",function(){ 99 | input.mashKeys("123").trigger(enterKeyEvent); 100 | }); 101 | then("value should remain",function(){ 102 | expect(input).toHaveValue("123"); 103 | }); 104 | }); 105 | 106 | scenario("Placeholders and markers filled, and autoclear = false", function() { 107 | given("a mask with an optional marker",function(){ 108 | input.mask("99?99", { autoclear: false }); 109 | }); 110 | when("typing four characters and leaving",function(){ 111 | input.mashKeys("1234").trigger(enterKeyEvent); 112 | }); 113 | then("value should remain",function(){ 114 | expect(input).toHaveValue("1234"); 115 | }); 116 | }); 117 | }); 118 | }); 119 | -------------------------------------------------------------------------------- /spec/Escape.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Escape Key", function() { 2 | story('User presses escape key after typing in some changes',function(){ 3 | scenario('mask is applied with an existing value',function(){ 4 | given("an input an existing value '6'", function(){ 5 | input 6 | .val('6'); 7 | }); 8 | 9 | given("a mask definition of '9'", function(){ 10 | input 11 | .mask('9').focus(); 12 | }); 13 | waits(1); 14 | when("user types something different then hits escape key",function(){ 15 | input.mashKeys(function(keys){keys.type('1',keys.esc)}); 16 | }); 17 | 18 | then("value is return to previous value",function(){ 19 | expect(input).toHaveValue('6'); 20 | }); 21 | }); 22 | }); 23 | }); 24 | -------------------------------------------------------------------------------- /spec/Focus.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Focusing A Masked Input",function(){ 2 | scenario("Mask starts with a placeholder",function(){ 3 | given("a mask beginning with a placeholder",function(){ 4 | input.mask("9"); 5 | }); 6 | when("focusing",function(){ 7 | input.focus(); 8 | }); 9 | waits(20); 10 | then("placeholder text should be correct",function(){ 11 | expect(input).toHaveValue('_'); 12 | }); 13 | and("caret position should be correct",function(){ 14 | var caret=input.caret(); 15 | expect(caret.begin).toEqual(0); 16 | expect(caret.end).toEqual(0); 17 | }); 18 | }); 19 | 20 | scenario("Mask starts with a literal",function(){ 21 | given("a mask beginning with a literal",function(){ 22 | input.mask("(9)"); 23 | }); 24 | when("focusing",function(){ 25 | input.focus(); 26 | }); 27 | waits(20); 28 | then("placeholder text should be correct",function(){ 29 | expect(input).toHaveValue('(_)'); 30 | }); 31 | and("caret position should be correct",function(){ 32 | var caret=input.caret(); 33 | expect(caret.begin).toEqual(1); 34 | expect(caret.end).toEqual(1); 35 | }); 36 | }); 37 | 38 | scenario("Mask starts with a literal that fits first placeholder",function(){ 39 | given("a mask beginning with a literal",function(){ 40 | input.mask("19").focus(); 41 | }); 42 | waits(20); 43 | when("blurring",function(){ 44 | input.blur(); 45 | }); 46 | waits(20); 47 | then("input value should be correct",function(){ 48 | expect(input).toHaveValue(''); 49 | }); 50 | }); 51 | 52 | scenario("Mask starts with a literal that fits first placeholder and autoclear set to false",function(){ 53 | given("a mask beginning with a literal",function(){ 54 | input.mask("?19",{autoclear: false}).focus(); 55 | }); 56 | waits(20); 57 | when("blurring",function(){ 58 | input.blur(); 59 | }); 60 | waits(20); 61 | then("input value should be correct",function(){ 62 | expect(input).toHaveValue(''); 63 | }); 64 | }); 65 | 66 | scenario("Masking a hidden input",function(){ 67 | var error; 68 | $(window).on("error.test",function(err){error=err;}) 69 | 70 | given("a mask on a hidden input",function(){ 71 | input.hide().mask("9"); 72 | }); 73 | when("focusing input",function(){ 74 | input.focus(); 75 | }); 76 | waits(1); 77 | then("should not throw an error",function(){ 78 | expect(error).toBeUndefined(); 79 | }) 80 | }); 81 | 82 | scenario("Mask contains a partial value with autoclear set to false",function(){ 83 | given("the input has a partial value",function(){ 84 | input.val("1"); 85 | }); 86 | given("a mask with two placeholders and autoclear=false",function(){ 87 | input.mask("99", { autoclear: false }); 88 | }); 89 | when("focusing on the input",function(){ 90 | input.focus(); 91 | }); 92 | then("the value should be partially filled out",function(){ 93 | expect(input).toHaveValue("1_"); 94 | }); 95 | then("the input partial value should remain",function(){ 96 | expect(input).toHaveValue("1_"); 97 | }); 98 | }); 99 | 100 | scenario("Mask containing optional mask ?",function(){ 101 | given("the input has a partial value",function(){ 102 | input.val("99"); 103 | }); 104 | given("a optional mask on input",function(){ 105 | input.mask("9?9"); 106 | }); 107 | when("focusing input",function(){ 108 | input.focus(); 109 | }); 110 | waits(1); 111 | then("caret position should be correct",function(){ 112 | var caret=input.caret(); 113 | expect(caret.begin).toEqual(0); 114 | expect(caret.end).toEqual(2); 115 | }); 116 | }); 117 | }); 118 | 119 | feature("Leaving A Masked Input",function(){ 120 | scenario("All placeholders filled",function(){ 121 | given("a mask with two placeholders",function(){ 122 | input.mask("99"); 123 | }); 124 | when("typing two characters and blurring",function(){ 125 | input.mashKeys("12").blur(); 126 | }); 127 | then("value should be correct",function(){ 128 | expect(input).toHaveValue("12"); 129 | }); 130 | }); 131 | 132 | scenario("Empty placeholders remaining",function(){ 133 | given("a mask with two placeholders",function(){ 134 | input.mask("99"); 135 | }); 136 | when("typing one character and blurring",function(){ 137 | input.mashKeys("1").blur(); 138 | }); 139 | then("value should be empty",function(){ 140 | expect(input).toHaveValue(""); 141 | }); 142 | }); 143 | 144 | scenario("Mask ending in literal",function(){ 145 | given("a mask ending in a literal",function(){ 146 | input.mask("99!"); 147 | }); 148 | when("typing two characters and blurring",function(){ 149 | input.mashKeys("12").blur(); 150 | }); 151 | then("value should remain",function(){ 152 | expect(input).toHaveValue("12!"); 153 | }); 154 | }); 155 | 156 | scenario("Empty placeholders remaining with autoclear set to false",function(){ 157 | given("a mask with two placeholders",function(){ 158 | input.mask("99", { autoclear: false }); 159 | }); 160 | when("typing one character and blurring",function(){ 161 | input.caret(0); 162 | input.mashKeys("1") 163 | input.blur(); 164 | }); 165 | then("value should remain visible with placeholders",function(){ 166 | expect(input).toHaveValue("1_"); 167 | }); 168 | }); 169 | 170 | scenario("Shifts characters left on blur with autoclear false",function(){ 171 | given("a mask with 10 placeholders",function(){ 172 | input.mask("(999) 999-9999", { autoclear: false }); 173 | }); 174 | when("focusing input",function(){ 175 | input.focus(); 176 | }); 177 | waits(20); 178 | when("typing characters at the end of the mask and blurring",function(){ 179 | input.caret(12); 180 | input.mashKeys("44").blur(); 181 | }); 182 | then("characters should shift left to beginning of mask",function(){ 183 | expect(input).toHaveValue("(44_) ___-____"); 184 | }); 185 | }); 186 | }); 187 | -------------------------------------------------------------------------------- /spec/Init.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Initializing a Mask",function(){ 2 | scenario("An input with no value",function(){ 3 | given("an input with no value",function(){ 4 | input.val(""); 5 | }); 6 | when("setting a mask with two placeholders",function(){ 7 | input.mask("99"); 8 | }); 9 | then("the value should be an empty string",function(){ 10 | expect(input).toHaveValue(""); 11 | }); 12 | }); 13 | 14 | scenario("An input with a valid value and no placeholders remaining",function(){ 15 | given("an input with a valid value",function(){ 16 | input.val("5555555555"); 17 | }); 18 | when("setting a mask",function(){ 19 | input.mask("(999) 999-9999"); 20 | }); 21 | then("the value should be intact",function(){ 22 | expect(input).toHaveValue("(555) 555-5555"); 23 | }); 24 | }); 25 | 26 | scenario("An input with a valid value ending in a literal",function(){ 27 | given("an input with a valid value",function(){ 28 | input.val("12"); 29 | }); 30 | when("setting a mask",function(){ 31 | input.mask("(99)"); 32 | }); 33 | then("the value should be intact",function(){ 34 | expect(input).toHaveValue("(12)"); 35 | }); 36 | }); 37 | 38 | scenario("An input with an invalid value and placeholders remaining",function(){ 39 | given("an invalid input value",function(){ 40 | input.val("55555555"); 41 | }); 42 | when("setting a mask",function(){ 43 | input.mask("(999) 999-9999"); 44 | }); 45 | then("the value should be empty",function(){ 46 | expect(input).toHaveValue(""); 47 | }); 48 | }); 49 | 50 | scenario("An input with an invalid value, placeholders remaining and autoclear set to false",function(){ 51 | given("an invalid input value",function(){ 52 | input.val("55555555"); 53 | }); 54 | when("setting a mask with autoclear set to false",function(){ 55 | input.mask("(999) 999-9999", { autoclear: false }); 56 | }); 57 | then("the value be intact with placeholders visible",function(){ 58 | expect(input).toHaveValue("(555) 555-55__"); 59 | }); 60 | }); 61 | 62 | scenario("An input no value and autoclear set to false", function() { 63 | given("an input with no value",function(){ 64 | input.val(""); 65 | }); 66 | when("setting a mask with autoclear set to false",function(){ 67 | input.mask("(999) 999-9999", { autoclear: false }); 68 | }); 69 | then("the value should be empty",function(){ 70 | expect(input).toHaveValue(""); 71 | }); 72 | }); 73 | }); 74 | -------------------------------------------------------------------------------- /spec/Optional.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Optional marker",function(){ 2 | scenario("Placeholders not filled to marker",function(){ 3 | given("a mask with an optional marker",function(){ 4 | input.mask("99?99"); 5 | }); 6 | when("typing one character and leaving",function(){ 7 | input.mashKeys("1").blur(); 8 | }); 9 | then("value should be empty",function(){ 10 | expect(input).toHaveValue(""); 11 | }); 12 | }); 13 | 14 | scenario("Placeholders not filled to marker and autoclear = false", function() { 15 | given("a mask with an optional marker",function(){ 16 | input.mask("99?99", { autoclear: false }); 17 | }); 18 | when("typing one character and leaving",function(){ 19 | input.mashKeys("1").blur(); 20 | }); 21 | then("value should be empty",function(){ 22 | expect(input).toHaveValue("1___"); 23 | }); 24 | }); 25 | 26 | scenario("Placeholders filled to marker",function(){ 27 | given("a mask with an optional marker",function(){ 28 | input.mask("99?99"); 29 | }); 30 | when("typing two characters and leaving",function(){ 31 | input.mashKeys("12").blur(); 32 | }); 33 | then("value should remain",function(){ 34 | expect(input).toHaveValue("12"); 35 | }); 36 | }); 37 | 38 | scenario("Placeholders filled to marker with literals after",function(){ 39 | given("a mask with an optional marker and literals",function(){ 40 | input.mask("99!? x 99"); 41 | }); 42 | when("typing two characters and leaving",function(){ 43 | input.mashKeys("12").blur(); 44 | }); 45 | then("value should remain",function(){ 46 | expect(input).toHaveValue("12!"); 47 | }); 48 | }); 49 | 50 | scenario("Placeholders filled to marker and autoclear = false", function() { 51 | given("a mask with an optional marker",function(){ 52 | input.mask("99?99", { autoclear: false }); 53 | }); 54 | when("typing two characters and leaving",function(){ 55 | input.mashKeys("12").blur(); 56 | }); 57 | then("value should remain",function(){ 58 | expect(input).toHaveValue("12"); 59 | }); 60 | }); 61 | 62 | scenario("Placeholders filled, one marker filled, and autoclear = false", function() { 63 | given("a mask with an optional marker",function(){ 64 | input.mask("99?99", { autoclear: false }); 65 | }); 66 | when("typing three characters and leaving",function(){ 67 | input.mashKeys("123").blur(); 68 | }); 69 | then("value should remain",function(){ 70 | expect(input).toHaveValue("123"); 71 | }); 72 | }); 73 | 74 | scenario("Placeholders and markers filled, and autoclear = false", function() { 75 | given("a mask with an optional marker",function(){ 76 | input.mask("99?99", { autoclear: false }); 77 | }); 78 | when("typing four characters and leaving",function(){ 79 | input.mashKeys("1234").blur(); 80 | }); 81 | then("value should remain",function(){ 82 | expect(input).toHaveValue("1234"); 83 | }); 84 | }); 85 | }); 86 | -------------------------------------------------------------------------------- /spec/Paste.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Pasting", function() { 2 | scenario('When pasting a value',function(){ 3 | var completed=false; 4 | given("an input with a completed callback", function(){ 5 | input.mask("99",{completed:function(){completed=true;}}); 6 | }); 7 | 8 | when("pasting",function(){ 9 | input.val("99").trigger("paste").trigger("input"); 10 | }); 11 | waits(1); 12 | then("completed callback should be called",function(){ 13 | expect(completed).toBeTruthy(); 14 | }); 15 | }); 16 | }); -------------------------------------------------------------------------------- /spec/Placeholder.spec.js: -------------------------------------------------------------------------------- 1 | feature("Multiple character placeholders",function(){ 2 | scenario("Focusing",function(){ 3 | given("a mask beginning with multi character placeholder",function(){ 4 | input.mask("99/9999",{placeholder:"mm/yyyy"}); 5 | }); 6 | when("focusing",function(){ 7 | input.focus(); 8 | }); 9 | waits(20); 10 | then("placeholder text should be correct",function(){ 11 | expect(input).toHaveValue('mm/yyyy'); 12 | }); 13 | }); 14 | 15 | scenario("Typing",function(){ 16 | given("a mask beginning with multi character placeholder",function(){ 17 | input.mask("99/9999",{placeholder:"mm/yyyy"}); 18 | }); 19 | when("typing",function(){ 20 | input.mashKeys("12"); 21 | }); 22 | waits(20); 23 | then("placeholder text should be correct",function(){ 24 | expect(input).toHaveValue('12/yyyy'); 25 | }); 26 | }); 27 | }); 28 | -------------------------------------------------------------------------------- /spec/Raw.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Getting raw value",function(){ 2 | scenario("After typing",function(){ 3 | given("an input with a mask containing a literal", function(){ 4 | input 5 | .mask("9/9"); 6 | }); 7 | 8 | when("typing all numbers",function(){ 9 | input.mashKeys("12"); 10 | }); 11 | 12 | then("raw value should be correct",function(){ 13 | expect(input.mask()).toEqual("12"); 14 | }); 15 | }); 16 | 17 | scenario("While typing",function(){ 18 | given("an input with a mask containing a literal", function(){ 19 | input 20 | .mask("9/9"); 21 | }); 22 | 23 | when("typing a number",function(){ 24 | input.mashKeys("1"); 25 | }); 26 | 27 | then("raw value should be correct",function(){ 28 | expect(input.mask()).toEqual("1"); 29 | }); 30 | }); 31 | 32 | scenario("Before typing",function(){ 33 | given("an input with a mask containing a literal", function(){ 34 | input 35 | .mask("9/9"); 36 | }); 37 | 38 | then("raw value should be correct",function(){ 39 | expect(input.mask()).toEqual(""); 40 | }); 41 | }); 42 | 43 | scenario("After typing partial input past an optional marker",function(){ 44 | given("an input with a mask containing a literal", function(){ 45 | input 46 | .mask("9?99"); 47 | }); 48 | 49 | when("typing a partial input",function(){ 50 | input.mashKeys("12"); 51 | }); 52 | 53 | then("raw value should be correct",function(){ 54 | expect(input.mask()).toEqual("12"); 55 | }); 56 | }); 57 | 58 | scenario("Verify if the input hasn't the mask bound through the raw value", function() { 59 | given("an input without a mask", function() { 60 | input 61 | .mask("9/9-9_9").unmask(); 62 | }); 63 | 64 | then("The raw value should be undefined and no error must occur", function() { 65 | expect(input.mask()).toBe(undefined); 66 | }); 67 | }); 68 | }); 69 | 70 | feature("Getting raw value with autoclear set to false", function() { 71 | scenario("After typing",function(){ 72 | given("an input with a mask containing a literal", function(){ 73 | input.mask("9/9", { autoclear: false }); 74 | }); 75 | 76 | when("typing all numbers",function(){ 77 | input.mashKeys("12"); 78 | }); 79 | 80 | then("raw value should be correct",function(){ 81 | expect(input.mask()).toEqual("12"); 82 | }); 83 | }); 84 | 85 | scenario("While typing",function(){ 86 | given("an input with a mask containing a literal", function(){ 87 | input.mask("9/9", { autoclear: false }); 88 | }); 89 | 90 | when("typing a number",function(){ 91 | input.mashKeys("1"); 92 | }); 93 | 94 | then("raw value should be correct",function(){ 95 | expect(input.mask()).toEqual("1"); 96 | }); 97 | }); 98 | 99 | scenario("Before typing",function(){ 100 | given("an input with a mask containing a literal", function(){ 101 | input.mask("9/9", { autoclear: false }); 102 | }); 103 | 104 | then("raw value should be correct",function(){ 105 | expect(input.mask()).toEqual(""); 106 | }); 107 | }); 108 | 109 | scenario("After typing partial input past an optional marker",function(){ 110 | given("an input with a mask containing a literal", function(){ 111 | input.mask("9?99", { autoclear: false }); 112 | }); 113 | 114 | when("typing a partial input",function(){ 115 | input.mashKeys("12"); 116 | }); 117 | 118 | then("raw value should be correct",function(){ 119 | expect(input.mask()).toEqual("12"); 120 | }); 121 | }); 122 | 123 | scenario("After typing partial input",function(){ 124 | given("an input with a mask containing a literal", function(){ 125 | input.mask("99?99", { autoclear: false }); 126 | }); 127 | 128 | when("typing a partial input",function(){ 129 | input.mashKeys("1"); 130 | }); 131 | 132 | then("raw value should be correct",function(){ 133 | expect(input.mask()).toEqual("1"); 134 | }); 135 | }); 136 | 137 | scenario("After typing partial input up to an optional marker",function(){ 138 | given("an input with a mask containing a literal", function(){ 139 | input.mask("9?99", { autoclear: false }); 140 | }); 141 | 142 | when("typing a partial input",function(){ 143 | input.mashKeys("1"); 144 | }); 145 | 146 | then("raw value should be correct",function(){ 147 | expect(input.mask()).toEqual("1"); 148 | }); 149 | }); 150 | }); 151 | -------------------------------------------------------------------------------- /spec/Readonly.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Readonly Inputs", function() { 2 | scenario('Typing',function(){ 3 | 4 | given("a input with readonly added after mask", function(){ 5 | input.mask("99").attr("readonly",true); 6 | }); 7 | 8 | when("typing left to right",function(){ 9 | input.mashKeys("12"); 10 | }); 11 | 12 | then("Input should be ignored",function(){ 13 | expect(input).toHaveValue(""); 14 | }); 15 | }); 16 | }); 17 | -------------------------------------------------------------------------------- /spec/Setup.Spec.js: -------------------------------------------------------------------------------- 1 | feature("Masking an Input", function() { 2 | scenario('Applying a mask to an already masked input',function(){ 3 | given("an input with two masks", function(){ 4 | input 5 | .mask("9") 6 | .mask("99"); 7 | }); 8 | 9 | when("typing a number",function(){ 10 | input.mashKeys("1"); 11 | }); 12 | 13 | then("value should be correct",function(){ 14 | expect(input).toHaveValue('1_'); 15 | }); 16 | }); 17 | }); 18 | 19 | -------------------------------------------------------------------------------- /spec/Typing.Spec.js: -------------------------------------------------------------------------------- 1 | describe("Typing Specifications", function() { 2 | 3 | describe("with caret position to the left of a character",function(){ 4 | describe("when character to right matches the next mask definition",function(){ 5 | beforeEach(function(){ 6 | runs(function(){ 7 | input 8 | .mask("99") 9 | .focus() 10 | }); 11 | waits(1); 12 | runs(function(){ 13 | input 14 | .mashKeys("1") 15 | .caret(0) 16 | .mashKeys("2"); 17 | }); 18 | }) 19 | 20 | it("should shift character to the right",function(){ 21 | expect(input).toHaveValue("21"); 22 | }); 23 | 24 | it("should have correct caret position",function(){ 25 | var caret=input.caret(); 26 | expect(caret.begin).toEqual(1); 27 | expect(caret.end).toEqual(1); 28 | }); 29 | }); 30 | 31 | describe("when character to right does not match the next mask definition",function(){ 32 | beforeEach(function(){ 33 | runs(function(){ 34 | input 35 | .mask("9a") 36 | .focus() 37 | }); 38 | waits(1); 39 | runs(function(){ 40 | input 41 | .mashKeys("1") 42 | .caret(0) 43 | .mashKeys("2"); 44 | }); 45 | }) 46 | 47 | it("should overwrite character",function(){ 48 | expect(input).toHaveValue("2_"); 49 | }); 50 | 51 | it("should have correct caret position",function(){ 52 | var caret=input.caret(); 53 | expect(caret.begin).toEqual(1); 54 | expect(caret.end).toEqual(1); 55 | }); 56 | }); 57 | }); 58 | }); -------------------------------------------------------------------------------- /spec/lib/jasmine-species/BSD.LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2010-2011, Rudy Lattae 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are met: 6 | * Redistributions of source code must retain the above copyright 7 | notice, this list of conditions and the following disclaimer. 8 | * Redistributions in binary form must reproduce the above copyright 9 | notice, this list of conditions and the following disclaimer in the 10 | documentation and/or other materials provided with the distribution. 11 | * Neither the name of Rudy Lattae nor the 12 | names of its contributors may be used to endorse or promote products 13 | derived from this software without specific prior written permission. 14 | 15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 16 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 17 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 18 | DISCLAIMED. IN NO EVENT SHALL Rudy Lattae BE LIABLE FOR ANY 19 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 20 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 22 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 24 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -------------------------------------------------------------------------------- /spec/lib/jasmine-species/jasmine-be-calm.css: -------------------------------------------------------------------------------- 1 | /** 2 | * Calm theme for the jasmine-bloom StyledHtmlReporter output. 3 | * 4 | * This theme does away with the default boxey look. The resulting report 5 | * is a lot less "busy" thus making it easy to focus on your specs. 6 | */ 7 | 8 | /* jasmine-reporter style overrides for */ 9 | .jasmine_reporter a { text-decoration:none; } 10 | 11 | .jasmine_reporter > .suite { 12 | padding-bottom: 0.3em; 13 | margin-bottom: 0.3em; 14 | border-bottom: solid 2px #eee; } 15 | 16 | .banner, .runner { 17 | -webkit-border-radius: 7px; 18 | -moz-border-radius: 7px; 19 | border-radius: 7px; } 20 | 21 | .runner { 22 | -webkit-box-shadow: 2px 2px 3px #888; 23 | -moz-box-shadow: 2px 2px 3px #888; 24 | box-shadow: 2px 2px 5px #888; } 25 | 26 | .suite { 27 | border: none; 28 | padding-left: 0.5em; } 29 | .suite.failed, 30 | .suite.passed, 31 | .suite.skipped { 32 | background: transparent; } 33 | .suite.passed > a { 34 | color: green; } 35 | .suite.failed > a { 36 | color: #c11b17; } 37 | .suite.skipped > a { 38 | color: #aaa; } 39 | .suite > .description { 40 | font-weight: bold; } 41 | .suite.step > .description { 42 | font-weight: normal; } 43 | 44 | .spec { 45 | margin: 0px; 46 | border: none; 47 | padding-left: 0.5em; 48 | margin-left: 0.5em; 49 | margin-top: 0.2em; } 50 | .spec.failed, 51 | .spec.passed, 52 | .spec.skipped { 53 | background: transparent; 54 | border: none; 55 | padding-bottom: 0.2em; } 56 | .spec.failed a { 57 | color: #c11b17; } 58 | .spec.passed a { 59 | color: green; } 60 | .spec.skipped a { 61 | color: #ccc; } 62 | .spec:hover { 63 | background-color: #eee; 64 | -webkit-border-radius: 7px; 65 | -moz-border-radius: 7px; 66 | border-radius: 7px; } 67 | .spec .description { 68 | padding-left: 0.5em; } 69 | 70 | .messages { 71 | border: none; 72 | margin-left: 1em; 73 | padding-bottom: 0.5em; } 74 | 75 | .jasmine_reporter .summary ul { 76 | font-size: 0.9em; 77 | color: #333; 78 | padding-left: 0.2em; 79 | margin: 0 0.5em; } 80 | 81 | .jasmine_reporter .summary li { 82 | list-style: none; } 83 | 84 | .jasmine_reporter .details ul { 85 | font-size: 0.8em; 86 | color: #777; 87 | padding-left: 0.2em; 88 | margin: 0 0.8em; } 89 | 90 | .jasmine_reporter .details li { 91 | list-style: none; } 92 | 93 | 94 | /* header style (if header is used) */ 95 | .header { 96 | margin: 0 5px; } 97 | .header h1 { 98 | font-size: 1.3em; } 99 | .header ul.menu { 100 | margin: 0 0 0.5em 0; 101 | padding: 0.3em; 102 | background-color: #eee; } 103 | .header ul.menu li { 104 | display: inline; 105 | list-style-type: none; 106 | margin-right: 1em; } -------------------------------------------------------------------------------- /spec/lib/jasmine-species/jasmine-grammar.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Jasmine Grammar - Additional Jasmine grammar to enable alternate BDD approaches. 3 | * 4 | * Copyright (C) 2010-2011, Rudy Lattae 5 | * License: Simplified BSD 6 | * 7 | * Jasmine-Grammar contains some additions to the jasmine api that make it 8 | * more suitable to alternate BDD approaches. The end-goal is streamline the 9 | * grammatical aspect of specing out an application from different view-points. 10 | * 11 | * The new grammar should make it easier to create other types of specifications 12 | * apart from "describe" and "it should". They are simply wrappers 13 | * for "describe" and "it" so they follow the same rules for nesting. 14 | */ 15 | 16 | // Top level namespace for the package 17 | jasmine.grammar = (typeof jasmine.grammar === 'undefined') ? {} : jasmine.grammar; 18 | 19 | 20 | /** 21 | * Feature / Story => Scenario => ... style grammar 22 | */ 23 | jasmine.grammar.FeatureStory = { 24 | 25 | /** 26 | * Defines a suite tagged as a "feature" 27 | */ 28 | feature: function(description, specDefinitions) { 29 | var suite = jasmine.grammar.getEnv().describe('Feature: ' + description, specDefinitions); 30 | suite.tags = ['feature']; 31 | return suite; 32 | }, 33 | 34 | /** 35 | * Defines a suite tagged as a "story" 36 | */ 37 | story: function(description, specDefinitions) { 38 | var suite = jasmine.grammar.getEnv().describe('Story: ' + description, specDefinitions); 39 | suite.tags = ['story']; 40 | return suite; 41 | }, 42 | 43 | /** 44 | * Defines a suite tagged as a "component" 45 | */ 46 | component: function(description, specDefinitions) { 47 | var suite = jasmine.grammar.getEnv().describe('Component: ' + description, specDefinitions); 48 | suite.tags = ['component']; 49 | return suite; 50 | }, 51 | 52 | /** 53 | * Defines a spec marked as a "scenario" 54 | */ 55 | scenario: function(desc, func) { 56 | return jasmine.grammar.getEnv().it('Scenario: ' + desc, func); 57 | } 58 | }; 59 | 60 | 61 | /** 62 | * Given => When => Then ... style grammar 63 | */ 64 | jasmine.grammar.GWT = { 65 | 66 | /** 67 | * Defines a "given" step as a runs block that marks the beginning of a GWT chain 68 | */ 69 | given: function(desc, func) { 70 | return this._addStepToCurrentSpec('Given ' + desc, func); 71 | }, 72 | 73 | /** 74 | * Defines a "when" step as a runs block that marks the interesting event in a GWT chain 75 | */ 76 | when: function(desc, func) { 77 | return this._addStepToCurrentSpec('When ' + desc, func); 78 | }, 79 | 80 | /** 81 | * Defines a "then" step as a runs block that marks the conclusion of a Given, when, then construct 82 | */ 83 | then: function(desc, func) { 84 | return this._addStepToCurrentSpec('Then ' + desc, func); 85 | }, 86 | 87 | /** 88 | * Defines an "and" step as a runs block that is a continuation from a "then" statement 89 | */ 90 | and: function(desc, func) { 91 | return this._addStepToCurrentSpec('And ' + desc, func); 92 | }, 93 | 94 | /** 95 | * Defines a "but" step as a runs block that is a continuation from a "then" statement 96 | */ 97 | but: function(desc, func) { 98 | return this._addStepToCurrentSpec('But ' + desc, func); 99 | }, 100 | 101 | /** 102 | * Adds the given function as a step (runs block) in the current spec. Also adds the description to the details list of the spec 103 | */ 104 | _addStepToCurrentSpec: function(desc, func) { 105 | var spec = jasmine.grammar.getEnv().currentSpec; 106 | spec.details = spec.details || []; 107 | spec.details.push(desc); 108 | spec.runs(func); 109 | return spec; 110 | } 111 | }; 112 | 113 | 114 | 115 | /** 116 | * Concern => Context => Specification style grammar 117 | */ 118 | jasmine.grammar.ContextSpecification = { 119 | 120 | /** 121 | * Defines a suite tagged as a "concern" 122 | */ 123 | concern: function(description, specDefinitions) { 124 | var suite = jasmine.grammar.getEnv().describe(description, specDefinitions); 125 | suite.tags = ['concern']; 126 | return suite; 127 | }, 128 | 129 | /** 130 | * Defines a suite tagged as a "context" 131 | */ 132 | context: function(description, specDefinitions) { 133 | var suite = jasmine.grammar.getEnv().describe(description, specDefinitions); 134 | suite.tags = ['context']; 135 | return suite; 136 | }, 137 | 138 | /** 139 | * Defines a simple spec -- similar to it 140 | */ 141 | spec: function(desc, func) { 142 | return jasmine.grammar.getEnv().it(desc, func); 143 | } 144 | } 145 | 146 | /** 147 | * Executable docs (Topic => Example) style grammar 148 | */ 149 | jasmine.grammar.XDoc = { 150 | 151 | /** 152 | * Defines a suite tagged as a "topic" 153 | */ 154 | topic: function(description, specDefinitions) { 155 | var suite = jasmine.grammar.getEnv().describe(description, specDefinitions); 156 | suite.tags = ['topic']; 157 | return suite; 158 | }, 159 | 160 | /** 161 | * Defines a suite tagged as an "example". 162 | * 163 | * An axample suite actually stores the inner suites as a string in the "defs" attribute 164 | */ 165 | example: function(description, specDefinitions) { 166 | var suite = jasmine.grammar.getEnv().describe(description, specDefinitions); 167 | suite.tags = ['example']; 168 | suite.expose = true; 169 | suite.defs = specDefinitions.toString() 170 | .replace(/^function.*\(.*\).*{/, '') 171 | .replace(/}$/, '').trim(); // stored for later output 172 | return suite; 173 | }, 174 | 175 | /** 176 | * Defines a simple spec without any associated function 177 | */ 178 | pass: function(desc, func) { 179 | return jasmine.grammar.getEnv().it(desc); 180 | } 181 | }; 182 | 183 | 184 | /** 185 | * Some more useful constructs that attach metadata to suites and specs 186 | */ 187 | jasmine.grammar.Meta = { 188 | 189 | /** 190 | * Adds summary content to the current suite. 191 | * 192 | * @param {String} content(s) variable number of detail content 193 | * @see jasmine.grammar.SuiteDetails 194 | */ 195 | summary: function() { 196 | var suite = jasmine.grammar.getEnv().currentSuite; 197 | suite.summary = suite.summary || []; 198 | 199 | if (arguments.length > 0) { 200 | for(i=0; i 0) { 217 | for(i=0; i 0) { 144 | specDiv.appendChild(messagesDiv); 145 | } 146 | 147 | this.suiteDivs[spec.suite.id].appendChild(specDiv); 148 | }; 149 | 150 | /** 151 | * Creates the proper dom element for the given data object. 152 | * 153 | * If the data is a simple string, the element created is a "p". 154 | * If the data is a list, the element created is an unordered list. 155 | * The tags are rendered to the class attribute on the dom element created 156 | */ 157 | jasmine.reporting.StyledHtmlReporter.prototype.createDomFromListOrString = function(data, tags) { 158 | var classAttrs = ''; 159 | if (typeof tags !== 'undefined') { 160 | classAttrs = (tags instanceof Array) ? tags.join(' ') : tags; 161 | } 162 | if (data instanceof Array) { 163 | return this.createDomList('ul', ((classAttrs == '') ? {} : { className: classAttrs}), data); 164 | } 165 | 166 | return this.createDom('p', { className: classAttrs}, data); 167 | } 168 | 169 | /** 170 | * Creates dom element with the suite defs as content 171 | */ 172 | jasmine.reporting.StyledHtmlReporter.prototype.createDomFromSuiteDefs = function(defs) { 173 | var classAttrs = ''; 174 | if (typeof defs !== 'undefined') { 175 | return this.createDom('p', {}, defs); 176 | } 177 | } 178 | 179 | /** 180 | * Creates a list of 'li' elements given an array 181 | */ 182 | jasmine.reporting.StyledHtmlReporter.prototype.createDomList = function(type, attrs, items) { 183 | var list; 184 | if (typeof items !== 'undefined' && items.length > 0) { 185 | list = this.createDom(type, attrs); 186 | for (var i = 0; i < items.length; i++) { 187 | list.appendChild(this.createDom('li', {}, items[i])); 188 | } 189 | } 190 | return list; 191 | }; -------------------------------------------------------------------------------- /spec/lib/jasmine-species/version.json: -------------------------------------------------------------------------------- 1 | {"version": "0.8.5b"} -------------------------------------------------------------------------------- /spec/lib/jasmine/MIT.LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2008-2010 Pivotal Labs 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | -------------------------------------------------------------------------------- /spec/lib/jasmine/jasmine-html.js: -------------------------------------------------------------------------------- 1 | jasmine.TrivialReporter = function(doc) { 2 | this.document = doc || document; 3 | this.suiteDivs = {}; 4 | this.logRunningSpecs = false; 5 | }; 6 | 7 | jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) { 8 | var el = document.createElement(type); 9 | 10 | for (var i = 2; i < arguments.length; i++) { 11 | var child = arguments[i]; 12 | 13 | if (typeof child === 'string') { 14 | el.appendChild(document.createTextNode(child)); 15 | } else { 16 | if (child) { el.appendChild(child); } 17 | } 18 | } 19 | 20 | for (var attr in attrs) { 21 | if (attr == "className") { 22 | el[attr] = attrs[attr]; 23 | } else { 24 | el.setAttribute(attr, attrs[attr]); 25 | } 26 | } 27 | 28 | return el; 29 | }; 30 | 31 | jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) { 32 | var showPassed, showSkipped; 33 | 34 | this.outerDiv = this.createDom('div', { className: 'jasmine_reporter' }, 35 | this.createDom('div', { className: 'banner' }, 36 | this.createDom('div', { className: 'logo' }, 37 | this.createDom('a', { href: 'http://pivotal.github.com/jasmine/', target: "_blank" }, "Jasmine"), 38 | this.createDom('span', { className: 'version' }, runner.env.versionString())), 39 | this.createDom('div', { className: 'options' }, 40 | "Show ", 41 | showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }), 42 | this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "), 43 | showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }), 44 | this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped") 45 | ) 46 | ), 47 | 48 | this.runnerDiv = this.createDom('div', { className: 'runner running' }, 49 | this.createDom('a', { className: 'run_spec', href: '?' }, "run all"), 50 | this.runnerMessageSpan = this.createDom('span', {}, "Running..."), 51 | this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, "")) 52 | ); 53 | 54 | this.document.body.appendChild(this.outerDiv); 55 | 56 | var suites = runner.suites(); 57 | for (var i = 0; i < suites.length; i++) { 58 | var suite = suites[i]; 59 | var suiteDiv = this.createDom('div', { className: 'suite' }, 60 | this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"), 61 | this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description)); 62 | this.suiteDivs[suite.id] = suiteDiv; 63 | var parentDiv = this.outerDiv; 64 | if (suite.parentSuite) { 65 | parentDiv = this.suiteDivs[suite.parentSuite.id]; 66 | } 67 | parentDiv.appendChild(suiteDiv); 68 | } 69 | 70 | this.startedAt = new Date(); 71 | 72 | var self = this; 73 | showPassed.onclick = function(evt) { 74 | if (showPassed.checked) { 75 | self.outerDiv.className += ' show-passed'; 76 | } else { 77 | self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, ''); 78 | } 79 | }; 80 | 81 | showSkipped.onclick = function(evt) { 82 | if (showSkipped.checked) { 83 | self.outerDiv.className += ' show-skipped'; 84 | } else { 85 | self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, ''); 86 | } 87 | }; 88 | }; 89 | 90 | jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) { 91 | var results = runner.results(); 92 | var className = (results.failedCount > 0) ? "runner failed" : "runner passed"; 93 | this.runnerDiv.setAttribute("class", className); 94 | //do it twice for IE 95 | this.runnerDiv.setAttribute("className", className); 96 | var specs = runner.specs(); 97 | var specCount = 0; 98 | for (var i = 0; i < specs.length; i++) { 99 | if (this.specFilter(specs[i])) { 100 | specCount++; 101 | } 102 | } 103 | var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s"); 104 | message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"; 105 | this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild); 106 | 107 | this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString())); 108 | }; 109 | 110 | jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) { 111 | var results = suite.results(); 112 | var status = results.passed() ? 'passed' : 'failed'; 113 | if (results.totalCount == 0) { // todo: change this to check results.skipped 114 | status = 'skipped'; 115 | } 116 | this.suiteDivs[suite.id].className += " " + status; 117 | }; 118 | 119 | jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) { 120 | if (this.logRunningSpecs) { 121 | this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...'); 122 | } 123 | }; 124 | 125 | jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) { 126 | var results = spec.results(); 127 | var status = results.passed() ? 'passed' : 'failed'; 128 | if (results.skipped) { 129 | status = 'skipped'; 130 | } 131 | var specDiv = this.createDom('div', { className: 'spec ' + status }, 132 | this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"), 133 | this.createDom('a', { 134 | className: 'description', 135 | href: '?spec=' + encodeURIComponent(spec.getFullName()), 136 | title: spec.getFullName() 137 | }, spec.description)); 138 | 139 | 140 | var resultItems = results.getItems(); 141 | var messagesDiv = this.createDom('div', { className: 'messages' }); 142 | for (var i = 0; i < resultItems.length; i++) { 143 | var result = resultItems[i]; 144 | 145 | if (result.type == 'log') { 146 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString())); 147 | } else if (result.type == 'expect' && result.passed && !result.passed()) { 148 | messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message)); 149 | 150 | if (result.trace.stack) { 151 | messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack)); 152 | } 153 | } 154 | } 155 | 156 | if (messagesDiv.childNodes.length > 0) { 157 | specDiv.appendChild(messagesDiv); 158 | } 159 | 160 | this.suiteDivs[spec.suite.id].appendChild(specDiv); 161 | }; 162 | 163 | jasmine.TrivialReporter.prototype.log = function() { 164 | var console = jasmine.getGlobal().console; 165 | if (console && console.log) { 166 | if (console.log.apply) { 167 | console.log.apply(console, arguments); 168 | } else { 169 | console.log(arguments); // ie fix: console.log.apply doesn't exist on ie 170 | } 171 | } 172 | }; 173 | 174 | jasmine.TrivialReporter.prototype.getLocation = function() { 175 | return this.document.location; 176 | }; 177 | 178 | jasmine.TrivialReporter.prototype.specFilter = function(spec) { 179 | var paramMap = {}; 180 | var params = this.getLocation().search.substring(1).split('&'); 181 | for (var i = 0; i < params.length; i++) { 182 | var p = params[i].split('='); 183 | paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]); 184 | } 185 | 186 | if (!paramMap["spec"]) return true; 187 | return spec.getFullName().indexOf(paramMap["spec"]) == 0; 188 | }; 189 | -------------------------------------------------------------------------------- /spec/lib/jasmine/jasmine.css: -------------------------------------------------------------------------------- 1 | body { 2 | font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; 3 | } 4 | 5 | 6 | .jasmine_reporter a:visited, .jasmine_reporter a { 7 | color: #303; 8 | } 9 | 10 | .jasmine_reporter a:hover, .jasmine_reporter a:active { 11 | color: blue; 12 | } 13 | 14 | .run_spec { 15 | float:right; 16 | padding-right: 5px; 17 | font-size: .8em; 18 | text-decoration: none; 19 | } 20 | 21 | .jasmine_reporter { 22 | margin: 0 5px; 23 | } 24 | 25 | .banner { 26 | color: #303; 27 | background-color: #fef; 28 | padding: 5px; 29 | } 30 | 31 | .logo { 32 | float: left; 33 | font-size: 1.1em; 34 | padding-left: 5px; 35 | } 36 | 37 | .logo .version { 38 | font-size: .6em; 39 | padding-left: 1em; 40 | } 41 | 42 | .runner.running { 43 | background-color: yellow; 44 | } 45 | 46 | 47 | .options { 48 | text-align: right; 49 | font-size: .8em; 50 | } 51 | 52 | 53 | 54 | 55 | .suite { 56 | border: 1px outset gray; 57 | margin: 5px 0; 58 | padding-left: 1em; 59 | } 60 | 61 | .suite .suite { 62 | margin: 5px; 63 | } 64 | 65 | .suite.passed { 66 | background-color: #dfd; 67 | } 68 | 69 | .suite.failed { 70 | background-color: #fdd; 71 | } 72 | 73 | .spec { 74 | margin: 5px; 75 | padding-left: 1em; 76 | clear: both; 77 | } 78 | 79 | .spec.failed, .spec.passed, .spec.skipped { 80 | padding-bottom: 5px; 81 | border: 1px solid gray; 82 | } 83 | 84 | .spec.failed { 85 | background-color: #fbb; 86 | border-color: red; 87 | } 88 | 89 | .spec.passed { 90 | background-color: #bfb; 91 | border-color: green; 92 | } 93 | 94 | .spec.skipped { 95 | background-color: #bbb; 96 | } 97 | 98 | .messages { 99 | border-left: 1px dashed gray; 100 | padding-left: 1em; 101 | padding-right: 1em; 102 | } 103 | 104 | .passed { 105 | background-color: #cfc; 106 | /*display: none;*/ 107 | } 108 | 109 | .failed { 110 | background-color: #fbb; 111 | } 112 | 113 | .skipped { 114 | color: #777; 115 | background-color: #eee; 116 | display: none; 117 | } 118 | 119 | 120 | /*.resultMessage {*/ 121 | /*white-space: pre;*/ 122 | /*}*/ 123 | 124 | .resultMessage span.result { 125 | display: block; 126 | line-height: 2em; 127 | color: black; 128 | } 129 | 130 | .resultMessage .mismatch { 131 | color: black; 132 | } 133 | 134 | .stackTrace { 135 | white-space: pre; 136 | font-size: .8em; 137 | margin-left: 10px; 138 | max-height: 5em; 139 | overflow: auto; 140 | border: 1px inset red; 141 | padding: 1em; 142 | background: #eef; 143 | } 144 | 145 | .finished-at { 146 | padding-left: 1em; 147 | font-size: .6em; 148 | } 149 | 150 | .show-passed .passed, 151 | .show-skipped .skipped { 152 | display: block; 153 | } 154 | 155 | 156 | #jasmine_content { 157 | position:fixed; 158 | right: 100%; 159 | } 160 | 161 | .runner { 162 | border: 1px solid gray; 163 | display: block; 164 | margin: 5px 0; 165 | padding: 2px 0 2px 10px; 166 | } 167 | -------------------------------------------------------------------------------- /spec/lib/jasmine/jasmine.js: -------------------------------------------------------------------------------- 1 | /** 2 | * Top level namespace for Jasmine, a lightweight JavaScript BDD/spec/testing framework. 3 | * 4 | * @namespace 5 | */ 6 | var jasmine = {}; 7 | 8 | /** 9 | * @private 10 | */ 11 | jasmine.unimplementedMethod_ = function() { 12 | throw new Error("unimplemented method"); 13 | }; 14 | 15 | /** 16 | * Use jasmine.undefined instead of undefined, since undefined is just 17 | * a plain old variable and may be redefined by somebody else. 18 | * 19 | * @private 20 | */ 21 | jasmine.undefined = jasmine.___undefined___; 22 | 23 | /** 24 | * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed. 25 | * 26 | */ 27 | jasmine.DEFAULT_UPDATE_INTERVAL = 250; 28 | 29 | /** 30 | * Default timeout interval in milliseconds for waitsFor() blocks. 31 | */ 32 | jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000; 33 | 34 | jasmine.getGlobal = function() { 35 | function getGlobal() { 36 | return this; 37 | } 38 | 39 | return getGlobal(); 40 | }; 41 | 42 | /** 43 | * Allows for bound functions to be compared. Internal use only. 44 | * 45 | * @ignore 46 | * @private 47 | * @param base {Object} bound 'this' for the function 48 | * @param name {Function} function to find 49 | */ 50 | jasmine.bindOriginal_ = function(base, name) { 51 | var original = base[name]; 52 | if (original.apply) { 53 | return function() { 54 | return original.apply(base, arguments); 55 | }; 56 | } else { 57 | // IE support 58 | return jasmine.getGlobal()[name]; 59 | } 60 | }; 61 | 62 | jasmine.setTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'setTimeout'); 63 | jasmine.clearTimeout = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearTimeout'); 64 | jasmine.setInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'setInterval'); 65 | jasmine.clearInterval = jasmine.bindOriginal_(jasmine.getGlobal(), 'clearInterval'); 66 | 67 | jasmine.MessageResult = function(values) { 68 | this.type = 'log'; 69 | this.values = values; 70 | this.trace = new Error(); // todo: test better 71 | }; 72 | 73 | jasmine.MessageResult.prototype.toString = function() { 74 | var text = ""; 75 | for(var i = 0; i < this.values.length; i++) { 76 | if (i > 0) text += " "; 77 | if (jasmine.isString_(this.values[i])) { 78 | text += this.values[i]; 79 | } else { 80 | text += jasmine.pp(this.values[i]); 81 | } 82 | } 83 | return text; 84 | }; 85 | 86 | jasmine.ExpectationResult = function(params) { 87 | this.type = 'expect'; 88 | this.matcherName = params.matcherName; 89 | this.passed_ = params.passed; 90 | this.expected = params.expected; 91 | this.actual = params.actual; 92 | 93 | this.message = this.passed_ ? 'Passed.' : params.message; 94 | this.trace = this.passed_ ? '' : new Error(this.message); 95 | }; 96 | 97 | jasmine.ExpectationResult.prototype.toString = function () { 98 | return this.message; 99 | }; 100 | 101 | jasmine.ExpectationResult.prototype.passed = function () { 102 | return this.passed_; 103 | }; 104 | 105 | /** 106 | * Getter for the Jasmine environment. Ensures one gets created 107 | */ 108 | jasmine.getEnv = function() { 109 | return jasmine.currentEnv_ = jasmine.currentEnv_ || new jasmine.Env(); 110 | }; 111 | 112 | /** 113 | * @ignore 114 | * @private 115 | * @param value 116 | * @returns {Boolean} 117 | */ 118 | jasmine.isArray_ = function(value) { 119 | return jasmine.isA_("Array", value); 120 | }; 121 | 122 | /** 123 | * @ignore 124 | * @private 125 | * @param value 126 | * @returns {Boolean} 127 | */ 128 | jasmine.isString_ = function(value) { 129 | return jasmine.isA_("String", value); 130 | }; 131 | 132 | /** 133 | * @ignore 134 | * @private 135 | * @param value 136 | * @returns {Boolean} 137 | */ 138 | jasmine.isNumber_ = function(value) { 139 | return jasmine.isA_("Number", value); 140 | }; 141 | 142 | /** 143 | * @ignore 144 | * @private 145 | * @param {String} typeName 146 | * @param value 147 | * @returns {Boolean} 148 | */ 149 | jasmine.isA_ = function(typeName, value) { 150 | return Object.prototype.toString.apply(value) === '[object ' + typeName + ']'; 151 | }; 152 | 153 | /** 154 | * Pretty printer for expecations. Takes any object and turns it into a human-readable string. 155 | * 156 | * @param value {Object} an object to be outputted 157 | * @returns {String} 158 | */ 159 | jasmine.pp = function(value) { 160 | var stringPrettyPrinter = new jasmine.StringPrettyPrinter(); 161 | stringPrettyPrinter.format(value); 162 | return stringPrettyPrinter.string; 163 | }; 164 | 165 | /** 166 | * Returns true if the object is a DOM Node. 167 | * 168 | * @param {Object} obj object to check 169 | * @returns {Boolean} 170 | */ 171 | jasmine.isDomNode = function(obj) { 172 | return obj['nodeType'] > 0; 173 | }; 174 | 175 | /** 176 | * Returns a matchable 'generic' object of the class type. For use in expecations of type when values don't matter. 177 | * 178 | * @example 179 | * // don't care about which function is passed in, as long as it's a function 180 | * expect(mySpy).toHaveBeenCalledWith(jasmine.any(Function)); 181 | * 182 | * @param {Class} clazz 183 | * @returns matchable object of the type clazz 184 | */ 185 | jasmine.any = function(clazz) { 186 | return new jasmine.Matchers.Any(clazz); 187 | }; 188 | 189 | /** 190 | * Jasmine Spies are test doubles that can act as stubs, spies, fakes or when used in an expecation, mocks. 191 | * 192 | * Spies should be created in test setup, before expectations. They can then be checked, using the standard Jasmine 193 | * expectation syntax. Spies can be checked if they were called or not and what the calling params were. 194 | * 195 | * A Spy has the following fields: wasCalled, callCount, mostRecentCall, and argsForCall (see docs). 196 | * 197 | * Spies are torn down at the end of every spec. 198 | * 199 | * Note: Do not call new jasmine.Spy() directly - a spy must be created using spyOn, jasmine.createSpy or jasmine.createSpyObj. 200 | * 201 | * @example 202 | * // a stub 203 | * var myStub = jasmine.createSpy('myStub'); // can be used anywhere 204 | * 205 | * // spy example 206 | * var foo = { 207 | * not: function(bool) { return !bool; } 208 | * } 209 | * 210 | * // actual foo.not will not be called, execution stops 211 | * spyOn(foo, 'not'); 212 | 213 | // foo.not spied upon, execution will continue to implementation 214 | * spyOn(foo, 'not').andCallThrough(); 215 | * 216 | * // fake example 217 | * var foo = { 218 | * not: function(bool) { return !bool; } 219 | * } 220 | * 221 | * // foo.not(val) will return val 222 | * spyOn(foo, 'not').andCallFake(function(value) {return value;}); 223 | * 224 | * // mock example 225 | * foo.not(7 == 7); 226 | * expect(foo.not).toHaveBeenCalled(); 227 | * expect(foo.not).toHaveBeenCalledWith(true); 228 | * 229 | * @constructor 230 | * @see spyOn, jasmine.createSpy, jasmine.createSpyObj 231 | * @param {String} name 232 | */ 233 | jasmine.Spy = function(name) { 234 | /** 235 | * The name of the spy, if provided. 236 | */ 237 | this.identity = name || 'unknown'; 238 | /** 239 | * Is this Object a spy? 240 | */ 241 | this.isSpy = true; 242 | /** 243 | * The actual function this spy stubs. 244 | */ 245 | this.plan = function() { 246 | }; 247 | /** 248 | * Tracking of the most recent call to the spy. 249 | * @example 250 | * var mySpy = jasmine.createSpy('foo'); 251 | * mySpy(1, 2); 252 | * mySpy.mostRecentCall.args = [1, 2]; 253 | */ 254 | this.mostRecentCall = {}; 255 | 256 | /** 257 | * Holds arguments for each call to the spy, indexed by call count 258 | * @example 259 | * var mySpy = jasmine.createSpy('foo'); 260 | * mySpy(1, 2); 261 | * mySpy(7, 8); 262 | * mySpy.mostRecentCall.args = [7, 8]; 263 | * mySpy.argsForCall[0] = [1, 2]; 264 | * mySpy.argsForCall[1] = [7, 8]; 265 | */ 266 | this.argsForCall = []; 267 | this.calls = []; 268 | }; 269 | 270 | /** 271 | * Tells a spy to call through to the actual implemenatation. 272 | * 273 | * @example 274 | * var foo = { 275 | * bar: function() { // do some stuff } 276 | * } 277 | * 278 | * // defining a spy on an existing property: foo.bar 279 | * spyOn(foo, 'bar').andCallThrough(); 280 | */ 281 | jasmine.Spy.prototype.andCallThrough = function() { 282 | this.plan = this.originalValue; 283 | return this; 284 | }; 285 | 286 | /** 287 | * For setting the return value of a spy. 288 | * 289 | * @example 290 | * // defining a spy from scratch: foo() returns 'baz' 291 | * var foo = jasmine.createSpy('spy on foo').andReturn('baz'); 292 | * 293 | * // defining a spy on an existing property: foo.bar() returns 'baz' 294 | * spyOn(foo, 'bar').andReturn('baz'); 295 | * 296 | * @param {Object} value 297 | */ 298 | jasmine.Spy.prototype.andReturn = function(value) { 299 | this.plan = function() { 300 | return value; 301 | }; 302 | return this; 303 | }; 304 | 305 | /** 306 | * For throwing an exception when a spy is called. 307 | * 308 | * @example 309 | * // defining a spy from scratch: foo() throws an exception w/ message 'ouch' 310 | * var foo = jasmine.createSpy('spy on foo').andThrow('baz'); 311 | * 312 | * // defining a spy on an existing property: foo.bar() throws an exception w/ message 'ouch' 313 | * spyOn(foo, 'bar').andThrow('baz'); 314 | * 315 | * @param {String} exceptionMsg 316 | */ 317 | jasmine.Spy.prototype.andThrow = function(exceptionMsg) { 318 | this.plan = function() { 319 | throw exceptionMsg; 320 | }; 321 | return this; 322 | }; 323 | 324 | /** 325 | * Calls an alternate implementation when a spy is called. 326 | * 327 | * @example 328 | * var baz = function() { 329 | * // do some stuff, return something 330 | * } 331 | * // defining a spy from scratch: foo() calls the function baz 332 | * var foo = jasmine.createSpy('spy on foo').andCall(baz); 333 | * 334 | * // defining a spy on an existing property: foo.bar() calls an anonymnous function 335 | * spyOn(foo, 'bar').andCall(function() { return 'baz';} ); 336 | * 337 | * @param {Function} fakeFunc 338 | */ 339 | jasmine.Spy.prototype.andCallFake = function(fakeFunc) { 340 | this.plan = fakeFunc; 341 | return this; 342 | }; 343 | 344 | /** 345 | * Resets all of a spy's the tracking variables so that it can be used again. 346 | * 347 | * @example 348 | * spyOn(foo, 'bar'); 349 | * 350 | * foo.bar(); 351 | * 352 | * expect(foo.bar.callCount).toEqual(1); 353 | * 354 | * foo.bar.reset(); 355 | * 356 | * expect(foo.bar.callCount).toEqual(0); 357 | */ 358 | jasmine.Spy.prototype.reset = function() { 359 | this.wasCalled = false; 360 | this.callCount = 0; 361 | this.argsForCall = []; 362 | this.calls = []; 363 | this.mostRecentCall = {}; 364 | }; 365 | 366 | jasmine.createSpy = function(name) { 367 | 368 | var spyObj = function() { 369 | spyObj.wasCalled = true; 370 | spyObj.callCount++; 371 | var args = jasmine.util.argsToArray(arguments); 372 | spyObj.mostRecentCall.object = this; 373 | spyObj.mostRecentCall.args = args; 374 | spyObj.argsForCall.push(args); 375 | spyObj.calls.push({object: this, args: args}); 376 | return spyObj.plan.apply(this, arguments); 377 | }; 378 | 379 | var spy = new jasmine.Spy(name); 380 | 381 | for (var prop in spy) { 382 | spyObj[prop] = spy[prop]; 383 | } 384 | 385 | spyObj.reset(); 386 | 387 | return spyObj; 388 | }; 389 | 390 | /** 391 | * Determines whether an object is a spy. 392 | * 393 | * @param {jasmine.Spy|Object} putativeSpy 394 | * @returns {Boolean} 395 | */ 396 | jasmine.isSpy = function(putativeSpy) { 397 | return putativeSpy && putativeSpy.isSpy; 398 | }; 399 | 400 | /** 401 | * Creates a more complicated spy: an Object that has every property a function that is a spy. Used for stubbing something 402 | * large in one call. 403 | * 404 | * @param {String} baseName name of spy class 405 | * @param {Array} methodNames array of names of methods to make spies 406 | */ 407 | jasmine.createSpyObj = function(baseName, methodNames) { 408 | if (!jasmine.isArray_(methodNames) || methodNames.length == 0) { 409 | throw new Error('createSpyObj requires a non-empty array of method names to create spies for'); 410 | } 411 | var obj = {}; 412 | for (var i = 0; i < methodNames.length; i++) { 413 | obj[methodNames[i]] = jasmine.createSpy(baseName + '.' + methodNames[i]); 414 | } 415 | return obj; 416 | }; 417 | 418 | /** 419 | * All parameters are pretty-printed and concatenated together, then written to the current spec's output. 420 | * 421 | * Be careful not to leave calls to jasmine.log in production code. 422 | */ 423 | jasmine.log = function() { 424 | var spec = jasmine.getEnv().currentSpec; 425 | spec.log.apply(spec, arguments); 426 | }; 427 | 428 | /** 429 | * Function that installs a spy on an existing object's method name. Used within a Spec to create a spy. 430 | * 431 | * @example 432 | * // spy example 433 | * var foo = { 434 | * not: function(bool) { return !bool; } 435 | * } 436 | * spyOn(foo, 'not'); // actual foo.not will not be called, execution stops 437 | * 438 | * @see jasmine.createSpy 439 | * @param obj 440 | * @param methodName 441 | * @returns a Jasmine spy that can be chained with all spy methods 442 | */ 443 | var spyOn = function(obj, methodName) { 444 | return jasmine.getEnv().currentSpec.spyOn(obj, methodName); 445 | }; 446 | 447 | /** 448 | * Creates a Jasmine spec that will be added to the current suite. 449 | * 450 | * // TODO: pending tests 451 | * 452 | * @example 453 | * it('should be true', function() { 454 | * expect(true).toEqual(true); 455 | * }); 456 | * 457 | * @param {String} desc description of this specification 458 | * @param {Function} func defines the preconditions and expectations of the spec 459 | */ 460 | var it = function(desc, func) { 461 | return jasmine.getEnv().it(desc, func); 462 | }; 463 | 464 | /** 465 | * Creates a disabled Jasmine spec. 466 | * 467 | * A convenience method that allows existing specs to be disabled temporarily during development. 468 | * 469 | * @param {String} desc description of this specification 470 | * @param {Function} func defines the preconditions and expectations of the spec 471 | */ 472 | var xit = function(desc, func) { 473 | return jasmine.getEnv().xit(desc, func); 474 | }; 475 | 476 | /** 477 | * Starts a chain for a Jasmine expectation. 478 | * 479 | * It is passed an Object that is the actual value and should chain to one of the many 480 | * jasmine.Matchers functions. 481 | * 482 | * @param {Object} actual Actual value to test against and expected value 483 | */ 484 | var expect = function(actual) { 485 | return jasmine.getEnv().currentSpec.expect(actual); 486 | }; 487 | 488 | /** 489 | * Defines part of a jasmine spec. Used in cominbination with waits or waitsFor in asynchrnous specs. 490 | * 491 | * @param {Function} func Function that defines part of a jasmine spec. 492 | */ 493 | var runs = function(func) { 494 | jasmine.getEnv().currentSpec.runs(func); 495 | }; 496 | 497 | /** 498 | * Waits a fixed time period before moving to the next block. 499 | * 500 | * @deprecated Use waitsFor() instead 501 | * @param {Number} timeout milliseconds to wait 502 | */ 503 | var waits = function(timeout) { 504 | jasmine.getEnv().currentSpec.waits(timeout); 505 | }; 506 | 507 | /** 508 | * Waits for the latchFunction to return true before proceeding to the next block. 509 | * 510 | * @param {Function} latchFunction 511 | * @param {String} optional_timeoutMessage 512 | * @param {Number} optional_timeout 513 | */ 514 | var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) { 515 | jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments); 516 | }; 517 | 518 | /** 519 | * A function that is called before each spec in a suite. 520 | * 521 | * Used for spec setup, including validating assumptions. 522 | * 523 | * @param {Function} beforeEachFunction 524 | */ 525 | var beforeEach = function(beforeEachFunction) { 526 | jasmine.getEnv().beforeEach(beforeEachFunction); 527 | }; 528 | 529 | /** 530 | * A function that is called after each spec in a suite. 531 | * 532 | * Used for restoring any state that is hijacked during spec execution. 533 | * 534 | * @param {Function} afterEachFunction 535 | */ 536 | var afterEach = function(afterEachFunction) { 537 | jasmine.getEnv().afterEach(afterEachFunction); 538 | }; 539 | 540 | /** 541 | * Defines a suite of specifications. 542 | * 543 | * Stores the description and all defined specs in the Jasmine environment as one suite of specs. Variables declared 544 | * are accessible by calls to beforeEach, it, and afterEach. Describe blocks can be nested, allowing for specialization 545 | * of setup in some tests. 546 | * 547 | * @example 548 | * // TODO: a simple suite 549 | * 550 | * // TODO: a simple suite with a nested describe block 551 | * 552 | * @param {String} description A string, usually the class under test. 553 | * @param {Function} specDefinitions function that defines several specs. 554 | */ 555 | var describe = function(description, specDefinitions) { 556 | return jasmine.getEnv().describe(description, specDefinitions); 557 | }; 558 | 559 | /** 560 | * Disables a suite of specifications. Used to disable some suites in a file, or files, temporarily during development. 561 | * 562 | * @param {String} description A string, usually the class under test. 563 | * @param {Function} specDefinitions function that defines several specs. 564 | */ 565 | var xdescribe = function(description, specDefinitions) { 566 | return jasmine.getEnv().xdescribe(description, specDefinitions); 567 | }; 568 | 569 | 570 | // Provide the XMLHttpRequest class for IE 5.x-6.x: 571 | jasmine.XmlHttpRequest = (typeof XMLHttpRequest == "undefined") ? function() { 572 | try { 573 | return new ActiveXObject("Msxml2.XMLHTTP.6.0"); 574 | } catch(e) { 575 | } 576 | try { 577 | return new ActiveXObject("Msxml2.XMLHTTP.3.0"); 578 | } catch(e) { 579 | } 580 | try { 581 | return new ActiveXObject("Msxml2.XMLHTTP"); 582 | } catch(e) { 583 | } 584 | try { 585 | return new ActiveXObject("Microsoft.XMLHTTP"); 586 | } catch(e) { 587 | } 588 | throw new Error("This browser does not support XMLHttpRequest."); 589 | } : XMLHttpRequest; 590 | /** 591 | * @namespace 592 | */ 593 | jasmine.util = {}; 594 | 595 | /** 596 | * Declare that a child class inherit it's prototype from the parent class. 597 | * 598 | * @private 599 | * @param {Function} childClass 600 | * @param {Function} parentClass 601 | */ 602 | jasmine.util.inherit = function(childClass, parentClass) { 603 | /** 604 | * @private 605 | */ 606 | var subclass = function() { 607 | }; 608 | subclass.prototype = parentClass.prototype; 609 | childClass.prototype = new subclass; 610 | }; 611 | 612 | jasmine.util.formatException = function(e) { 613 | var lineNumber; 614 | if (e.line) { 615 | lineNumber = e.line; 616 | } 617 | else if (e.lineNumber) { 618 | lineNumber = e.lineNumber; 619 | } 620 | 621 | var file; 622 | 623 | if (e.sourceURL) { 624 | file = e.sourceURL; 625 | } 626 | else if (e.fileName) { 627 | file = e.fileName; 628 | } 629 | 630 | var message = (e.name && e.message) ? (e.name + ': ' + e.message) : e.toString(); 631 | 632 | if (file && lineNumber) { 633 | message += ' in ' + file + ' (line ' + lineNumber + ')'; 634 | } 635 | 636 | return message; 637 | }; 638 | 639 | jasmine.util.htmlEscape = function(str) { 640 | if (!str) return str; 641 | return str.replace(/&/g, '&') 642 | .replace(//g, '>'); 644 | }; 645 | 646 | jasmine.util.argsToArray = function(args) { 647 | var arrayOfArgs = []; 648 | for (var i = 0; i < args.length; i++) arrayOfArgs.push(args[i]); 649 | return arrayOfArgs; 650 | }; 651 | 652 | jasmine.util.extend = function(destination, source) { 653 | for (var property in source) destination[property] = source[property]; 654 | return destination; 655 | }; 656 | 657 | /** 658 | * Environment for Jasmine 659 | * 660 | * @constructor 661 | */ 662 | jasmine.Env = function() { 663 | this.currentSpec = null; 664 | this.currentSuite = null; 665 | this.currentRunner_ = new jasmine.Runner(this); 666 | 667 | this.reporter = new jasmine.MultiReporter(); 668 | 669 | this.updateInterval = jasmine.DEFAULT_UPDATE_INTERVAL; 670 | this.defaultTimeoutInterval = jasmine.DEFAULT_TIMEOUT_INTERVAL; 671 | this.lastUpdate = 0; 672 | this.specFilter = function() { 673 | return true; 674 | }; 675 | 676 | this.nextSpecId_ = 0; 677 | this.nextSuiteId_ = 0; 678 | this.equalityTesters_ = []; 679 | 680 | // wrap matchers 681 | this.matchersClass = function() { 682 | jasmine.Matchers.apply(this, arguments); 683 | }; 684 | jasmine.util.inherit(this.matchersClass, jasmine.Matchers); 685 | 686 | jasmine.Matchers.wrapInto_(jasmine.Matchers.prototype, this.matchersClass); 687 | }; 688 | 689 | 690 | jasmine.Env.prototype.setTimeout = jasmine.setTimeout; 691 | jasmine.Env.prototype.clearTimeout = jasmine.clearTimeout; 692 | jasmine.Env.prototype.setInterval = jasmine.setInterval; 693 | jasmine.Env.prototype.clearInterval = jasmine.clearInterval; 694 | 695 | /** 696 | * @returns an object containing jasmine version build info, if set. 697 | */ 698 | jasmine.Env.prototype.version = function () { 699 | if (jasmine.version_) { 700 | return jasmine.version_; 701 | } else { 702 | throw new Error('Version not set'); 703 | } 704 | }; 705 | 706 | /** 707 | * @returns string containing jasmine version build info, if set. 708 | */ 709 | jasmine.Env.prototype.versionString = function() { 710 | if (jasmine.version_) { 711 | var version = this.version(); 712 | return version.major + "." + version.minor + "." + version.build + " revision " + version.revision; 713 | } else { 714 | return "version unknown"; 715 | } 716 | }; 717 | 718 | /** 719 | * @returns a sequential integer starting at 0 720 | */ 721 | jasmine.Env.prototype.nextSpecId = function () { 722 | return this.nextSpecId_++; 723 | }; 724 | 725 | /** 726 | * @returns a sequential integer starting at 0 727 | */ 728 | jasmine.Env.prototype.nextSuiteId = function () { 729 | return this.nextSuiteId_++; 730 | }; 731 | 732 | /** 733 | * Register a reporter to receive status updates from Jasmine. 734 | * @param {jasmine.Reporter} reporter An object which will receive status updates. 735 | */ 736 | jasmine.Env.prototype.addReporter = function(reporter) { 737 | this.reporter.addReporter(reporter); 738 | }; 739 | 740 | jasmine.Env.prototype.execute = function() { 741 | this.currentRunner_.execute(); 742 | }; 743 | 744 | jasmine.Env.prototype.describe = function(description, specDefinitions) { 745 | var suite = new jasmine.Suite(this, description, specDefinitions, this.currentSuite); 746 | 747 | var parentSuite = this.currentSuite; 748 | if (parentSuite) { 749 | parentSuite.add(suite); 750 | } else { 751 | this.currentRunner_.add(suite); 752 | } 753 | 754 | this.currentSuite = suite; 755 | 756 | var declarationError = null; 757 | try { 758 | specDefinitions.call(suite); 759 | } catch(e) { 760 | declarationError = e; 761 | } 762 | 763 | this.currentSuite = parentSuite; 764 | 765 | if (declarationError) { 766 | this.it("encountered a declaration exception", function() { 767 | throw declarationError; 768 | }); 769 | } 770 | 771 | return suite; 772 | }; 773 | 774 | jasmine.Env.prototype.beforeEach = function(beforeEachFunction) { 775 | if (this.currentSuite) { 776 | this.currentSuite.beforeEach(beforeEachFunction); 777 | } else { 778 | this.currentRunner_.beforeEach(beforeEachFunction); 779 | } 780 | }; 781 | 782 | jasmine.Env.prototype.currentRunner = function () { 783 | return this.currentRunner_; 784 | }; 785 | 786 | jasmine.Env.prototype.afterEach = function(afterEachFunction) { 787 | if (this.currentSuite) { 788 | this.currentSuite.afterEach(afterEachFunction); 789 | } else { 790 | this.currentRunner_.afterEach(afterEachFunction); 791 | } 792 | 793 | }; 794 | 795 | jasmine.Env.prototype.xdescribe = function(desc, specDefinitions) { 796 | return { 797 | execute: function() { 798 | } 799 | }; 800 | }; 801 | 802 | jasmine.Env.prototype.it = function(description, func) { 803 | var spec = new jasmine.Spec(this, this.currentSuite, description); 804 | this.currentSuite.add(spec); 805 | this.currentSpec = spec; 806 | 807 | if (func) { 808 | spec.runs(func); 809 | } 810 | 811 | return spec; 812 | }; 813 | 814 | jasmine.Env.prototype.xit = function(desc, func) { 815 | return { 816 | id: this.nextSpecId(), 817 | runs: function() { 818 | } 819 | }; 820 | }; 821 | 822 | jasmine.Env.prototype.compareObjects_ = function(a, b, mismatchKeys, mismatchValues) { 823 | if (a.__Jasmine_been_here_before__ === b && b.__Jasmine_been_here_before__ === a) { 824 | return true; 825 | } 826 | 827 | a.__Jasmine_been_here_before__ = b; 828 | b.__Jasmine_been_here_before__ = a; 829 | 830 | var hasKey = function(obj, keyName) { 831 | return obj != null && obj[keyName] !== jasmine.undefined; 832 | }; 833 | 834 | for (var property in b) { 835 | if (!hasKey(a, property) && hasKey(b, property)) { 836 | mismatchKeys.push("expected has key '" + property + "', but missing from actual."); 837 | } 838 | } 839 | for (property in a) { 840 | if (!hasKey(b, property) && hasKey(a, property)) { 841 | mismatchKeys.push("expected missing key '" + property + "', but present in actual."); 842 | } 843 | } 844 | for (property in b) { 845 | if (property == '__Jasmine_been_here_before__') continue; 846 | if (!this.equals_(a[property], b[property], mismatchKeys, mismatchValues)) { 847 | mismatchValues.push("'" + property + "' was '" + (b[property] ? jasmine.util.htmlEscape(b[property].toString()) : b[property]) + "' in expected, but was '" + (a[property] ? jasmine.util.htmlEscape(a[property].toString()) : a[property]) + "' in actual."); 848 | } 849 | } 850 | 851 | if (jasmine.isArray_(a) && jasmine.isArray_(b) && a.length != b.length) { 852 | mismatchValues.push("arrays were not the same length"); 853 | } 854 | 855 | delete a.__Jasmine_been_here_before__; 856 | delete b.__Jasmine_been_here_before__; 857 | return (mismatchKeys.length == 0 && mismatchValues.length == 0); 858 | }; 859 | 860 | jasmine.Env.prototype.equals_ = function(a, b, mismatchKeys, mismatchValues) { 861 | mismatchKeys = mismatchKeys || []; 862 | mismatchValues = mismatchValues || []; 863 | 864 | for (var i = 0; i < this.equalityTesters_.length; i++) { 865 | var equalityTester = this.equalityTesters_[i]; 866 | var result = equalityTester(a, b, this, mismatchKeys, mismatchValues); 867 | if (result !== jasmine.undefined) return result; 868 | } 869 | 870 | if (a === b) return true; 871 | 872 | if (a === jasmine.undefined || a === null || b === jasmine.undefined || b === null) { 873 | return (a == jasmine.undefined && b == jasmine.undefined); 874 | } 875 | 876 | if (jasmine.isDomNode(a) && jasmine.isDomNode(b)) { 877 | return a === b; 878 | } 879 | 880 | if (a instanceof Date && b instanceof Date) { 881 | return a.getTime() == b.getTime(); 882 | } 883 | 884 | if (a instanceof jasmine.Matchers.Any) { 885 | return a.matches(b); 886 | } 887 | 888 | if (b instanceof jasmine.Matchers.Any) { 889 | return b.matches(a); 890 | } 891 | 892 | if (jasmine.isString_(a) && jasmine.isString_(b)) { 893 | return (a == b); 894 | } 895 | 896 | if (jasmine.isNumber_(a) && jasmine.isNumber_(b)) { 897 | return (a == b); 898 | } 899 | 900 | if (typeof a === "object" && typeof b === "object") { 901 | return this.compareObjects_(a, b, mismatchKeys, mismatchValues); 902 | } 903 | 904 | //Straight check 905 | return (a === b); 906 | }; 907 | 908 | jasmine.Env.prototype.contains_ = function(haystack, needle) { 909 | if (jasmine.isArray_(haystack)) { 910 | for (var i = 0; i < haystack.length; i++) { 911 | if (this.equals_(haystack[i], needle)) return true; 912 | } 913 | return false; 914 | } 915 | return haystack.indexOf(needle) >= 0; 916 | }; 917 | 918 | jasmine.Env.prototype.addEqualityTester = function(equalityTester) { 919 | this.equalityTesters_.push(equalityTester); 920 | }; 921 | /** No-op base class for Jasmine reporters. 922 | * 923 | * @constructor 924 | */ 925 | jasmine.Reporter = function() { 926 | }; 927 | 928 | //noinspection JSUnusedLocalSymbols 929 | jasmine.Reporter.prototype.reportRunnerStarting = function(runner) { 930 | }; 931 | 932 | //noinspection JSUnusedLocalSymbols 933 | jasmine.Reporter.prototype.reportRunnerResults = function(runner) { 934 | }; 935 | 936 | //noinspection JSUnusedLocalSymbols 937 | jasmine.Reporter.prototype.reportSuiteResults = function(suite) { 938 | }; 939 | 940 | //noinspection JSUnusedLocalSymbols 941 | jasmine.Reporter.prototype.reportSpecStarting = function(spec) { 942 | }; 943 | 944 | //noinspection JSUnusedLocalSymbols 945 | jasmine.Reporter.prototype.reportSpecResults = function(spec) { 946 | }; 947 | 948 | //noinspection JSUnusedLocalSymbols 949 | jasmine.Reporter.prototype.log = function(str) { 950 | }; 951 | 952 | /** 953 | * Blocks are functions with executable code that make up a spec. 954 | * 955 | * @constructor 956 | * @param {jasmine.Env} env 957 | * @param {Function} func 958 | * @param {jasmine.Spec} spec 959 | */ 960 | jasmine.Block = function(env, func, spec) { 961 | this.env = env; 962 | this.func = func; 963 | this.spec = spec; 964 | }; 965 | 966 | jasmine.Block.prototype.execute = function(onComplete) { 967 | try { 968 | this.func.apply(this.spec); 969 | } catch (e) { 970 | this.spec.fail(e); 971 | } 972 | onComplete(); 973 | }; 974 | /** JavaScript API reporter. 975 | * 976 | * @constructor 977 | */ 978 | jasmine.JsApiReporter = function() { 979 | this.started = false; 980 | this.finished = false; 981 | this.suites_ = []; 982 | this.results_ = {}; 983 | }; 984 | 985 | jasmine.JsApiReporter.prototype.reportRunnerStarting = function(runner) { 986 | this.started = true; 987 | var suites = runner.topLevelSuites(); 988 | for (var i = 0; i < suites.length; i++) { 989 | var suite = suites[i]; 990 | this.suites_.push(this.summarize_(suite)); 991 | } 992 | }; 993 | 994 | jasmine.JsApiReporter.prototype.suites = function() { 995 | return this.suites_; 996 | }; 997 | 998 | jasmine.JsApiReporter.prototype.summarize_ = function(suiteOrSpec) { 999 | var isSuite = suiteOrSpec instanceof jasmine.Suite; 1000 | var summary = { 1001 | id: suiteOrSpec.id, 1002 | name: suiteOrSpec.description, 1003 | type: isSuite ? 'suite' : 'spec', 1004 | children: [] 1005 | }; 1006 | 1007 | if (isSuite) { 1008 | var children = suiteOrSpec.children(); 1009 | for (var i = 0; i < children.length; i++) { 1010 | summary.children.push(this.summarize_(children[i])); 1011 | } 1012 | } 1013 | return summary; 1014 | }; 1015 | 1016 | jasmine.JsApiReporter.prototype.results = function() { 1017 | return this.results_; 1018 | }; 1019 | 1020 | jasmine.JsApiReporter.prototype.resultsForSpec = function(specId) { 1021 | return this.results_[specId]; 1022 | }; 1023 | 1024 | //noinspection JSUnusedLocalSymbols 1025 | jasmine.JsApiReporter.prototype.reportRunnerResults = function(runner) { 1026 | this.finished = true; 1027 | }; 1028 | 1029 | //noinspection JSUnusedLocalSymbols 1030 | jasmine.JsApiReporter.prototype.reportSuiteResults = function(suite) { 1031 | }; 1032 | 1033 | //noinspection JSUnusedLocalSymbols 1034 | jasmine.JsApiReporter.prototype.reportSpecResults = function(spec) { 1035 | this.results_[spec.id] = { 1036 | messages: spec.results().getItems(), 1037 | result: spec.results().failedCount > 0 ? "failed" : "passed" 1038 | }; 1039 | }; 1040 | 1041 | //noinspection JSUnusedLocalSymbols 1042 | jasmine.JsApiReporter.prototype.log = function(str) { 1043 | }; 1044 | 1045 | jasmine.JsApiReporter.prototype.resultsForSpecs = function(specIds){ 1046 | var results = {}; 1047 | for (var i = 0; i < specIds.length; i++) { 1048 | var specId = specIds[i]; 1049 | results[specId] = this.summarizeResult_(this.results_[specId]); 1050 | } 1051 | return results; 1052 | }; 1053 | 1054 | jasmine.JsApiReporter.prototype.summarizeResult_ = function(result){ 1055 | var summaryMessages = []; 1056 | var messagesLength = result.messages.length; 1057 | for (var messageIndex = 0; messageIndex < messagesLength; messageIndex++) { 1058 | var resultMessage = result.messages[messageIndex]; 1059 | summaryMessages.push({ 1060 | text: resultMessage.type == 'log' ? resultMessage.toString() : jasmine.undefined, 1061 | passed: resultMessage.passed ? resultMessage.passed() : true, 1062 | type: resultMessage.type, 1063 | message: resultMessage.message, 1064 | trace: { 1065 | stack: resultMessage.passed && !resultMessage.passed() ? resultMessage.trace.stack : jasmine.undefined 1066 | } 1067 | }); 1068 | } 1069 | 1070 | return { 1071 | result : result.result, 1072 | messages : summaryMessages 1073 | }; 1074 | }; 1075 | 1076 | /** 1077 | * @constructor 1078 | * @param {jasmine.Env} env 1079 | * @param actual 1080 | * @param {jasmine.Spec} spec 1081 | */ 1082 | jasmine.Matchers = function(env, actual, spec, opt_isNot) { 1083 | this.env = env; 1084 | this.actual = actual; 1085 | this.spec = spec; 1086 | this.isNot = opt_isNot || false; 1087 | this.reportWasCalled_ = false; 1088 | }; 1089 | 1090 | // todo: @deprecated as of Jasmine 0.11, remove soon [xw] 1091 | jasmine.Matchers.pp = function(str) { 1092 | throw new Error("jasmine.Matchers.pp() is no longer supported, please use jasmine.pp() instead!"); 1093 | }; 1094 | 1095 | // todo: @deprecated Deprecated as of Jasmine 0.10. Rewrite your custom matchers to return true or false. [xw] 1096 | jasmine.Matchers.prototype.report = function(result, failing_message, details) { 1097 | throw new Error("As of jasmine 0.11, custom matchers must be implemented differently -- please see jasmine docs"); 1098 | }; 1099 | 1100 | jasmine.Matchers.wrapInto_ = function(prototype, matchersClass) { 1101 | for (var methodName in prototype) { 1102 | if (methodName == 'report') continue; 1103 | var orig = prototype[methodName]; 1104 | matchersClass.prototype[methodName] = jasmine.Matchers.matcherFn_(methodName, orig); 1105 | } 1106 | }; 1107 | 1108 | jasmine.Matchers.matcherFn_ = function(matcherName, matcherFunction) { 1109 | return function() { 1110 | var matcherArgs = jasmine.util.argsToArray(arguments); 1111 | var result = matcherFunction.apply(this, arguments); 1112 | 1113 | if (this.isNot) { 1114 | result = !result; 1115 | } 1116 | 1117 | if (this.reportWasCalled_) return result; 1118 | 1119 | var message; 1120 | if (!result) { 1121 | if (this.message) { 1122 | message = this.message.apply(this, arguments); 1123 | if (jasmine.isArray_(message)) { 1124 | message = message[this.isNot ? 1 : 0]; 1125 | } 1126 | } else { 1127 | var englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); }); 1128 | message = "Expected " + jasmine.pp(this.actual) + (this.isNot ? " not " : " ") + englishyPredicate; 1129 | if (matcherArgs.length > 0) { 1130 | for (var i = 0; i < matcherArgs.length; i++) { 1131 | if (i > 0) message += ","; 1132 | message += " " + jasmine.pp(matcherArgs[i]); 1133 | } 1134 | } 1135 | message += "."; 1136 | } 1137 | } 1138 | var expectationResult = new jasmine.ExpectationResult({ 1139 | matcherName: matcherName, 1140 | passed: result, 1141 | expected: matcherArgs.length > 1 ? matcherArgs : matcherArgs[0], 1142 | actual: this.actual, 1143 | message: message 1144 | }); 1145 | this.spec.addMatcherResult(expectationResult); 1146 | return jasmine.undefined; 1147 | }; 1148 | }; 1149 | 1150 | 1151 | 1152 | 1153 | /** 1154 | * toBe: compares the actual to the expected using === 1155 | * @param expected 1156 | */ 1157 | jasmine.Matchers.prototype.toBe = function(expected) { 1158 | return this.actual === expected; 1159 | }; 1160 | 1161 | /** 1162 | * toNotBe: compares the actual to the expected using !== 1163 | * @param expected 1164 | * @deprecated as of 1.0. Use not.toBe() instead. 1165 | */ 1166 | jasmine.Matchers.prototype.toNotBe = function(expected) { 1167 | return this.actual !== expected; 1168 | }; 1169 | 1170 | /** 1171 | * toEqual: compares the actual to the expected using common sense equality. Handles Objects, Arrays, etc. 1172 | * 1173 | * @param expected 1174 | */ 1175 | jasmine.Matchers.prototype.toEqual = function(expected) { 1176 | return this.env.equals_(this.actual, expected); 1177 | }; 1178 | 1179 | /** 1180 | * toNotEqual: compares the actual to the expected using the ! of jasmine.Matchers.toEqual 1181 | * @param expected 1182 | * @deprecated as of 1.0. Use not.toNotEqual() instead. 1183 | */ 1184 | jasmine.Matchers.prototype.toNotEqual = function(expected) { 1185 | return !this.env.equals_(this.actual, expected); 1186 | }; 1187 | 1188 | /** 1189 | * Matcher that compares the actual to the expected using a regular expression. Constructs a RegExp, so takes 1190 | * a pattern or a String. 1191 | * 1192 | * @param expected 1193 | */ 1194 | jasmine.Matchers.prototype.toMatch = function(expected) { 1195 | return new RegExp(expected).test(this.actual); 1196 | }; 1197 | 1198 | /** 1199 | * Matcher that compares the actual to the expected using the boolean inverse of jasmine.Matchers.toMatch 1200 | * @param expected 1201 | * @deprecated as of 1.0. Use not.toMatch() instead. 1202 | */ 1203 | jasmine.Matchers.prototype.toNotMatch = function(expected) { 1204 | return !(new RegExp(expected).test(this.actual)); 1205 | }; 1206 | 1207 | /** 1208 | * Matcher that compares the actual to jasmine.undefined. 1209 | */ 1210 | jasmine.Matchers.prototype.toBeDefined = function() { 1211 | return (this.actual !== jasmine.undefined); 1212 | }; 1213 | 1214 | /** 1215 | * Matcher that compares the actual to jasmine.undefined. 1216 | */ 1217 | jasmine.Matchers.prototype.toBeUndefined = function() { 1218 | return (this.actual === jasmine.undefined); 1219 | }; 1220 | 1221 | /** 1222 | * Matcher that compares the actual to null. 1223 | */ 1224 | jasmine.Matchers.prototype.toBeNull = function() { 1225 | return (this.actual === null); 1226 | }; 1227 | 1228 | /** 1229 | * Matcher that boolean not-nots the actual. 1230 | */ 1231 | jasmine.Matchers.prototype.toBeTruthy = function() { 1232 | return !!this.actual; 1233 | }; 1234 | 1235 | 1236 | /** 1237 | * Matcher that boolean nots the actual. 1238 | */ 1239 | jasmine.Matchers.prototype.toBeFalsy = function() { 1240 | return !this.actual; 1241 | }; 1242 | 1243 | 1244 | /** 1245 | * Matcher that checks to see if the actual, a Jasmine spy, was called. 1246 | */ 1247 | jasmine.Matchers.prototype.toHaveBeenCalled = function() { 1248 | if (arguments.length > 0) { 1249 | throw new Error('toHaveBeenCalled does not take arguments, use toHaveBeenCalledWith'); 1250 | } 1251 | 1252 | if (!jasmine.isSpy(this.actual)) { 1253 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1254 | } 1255 | 1256 | this.message = function() { 1257 | return [ 1258 | "Expected spy " + this.actual.identity + " to have been called.", 1259 | "Expected spy " + this.actual.identity + " not to have been called." 1260 | ]; 1261 | }; 1262 | 1263 | return this.actual.wasCalled; 1264 | }; 1265 | 1266 | /** @deprecated Use expect(xxx).toHaveBeenCalled() instead */ 1267 | jasmine.Matchers.prototype.wasCalled = jasmine.Matchers.prototype.toHaveBeenCalled; 1268 | 1269 | /** 1270 | * Matcher that checks to see if the actual, a Jasmine spy, was not called. 1271 | * 1272 | * @deprecated Use expect(xxx).not.toHaveBeenCalled() instead 1273 | */ 1274 | jasmine.Matchers.prototype.wasNotCalled = function() { 1275 | if (arguments.length > 0) { 1276 | throw new Error('wasNotCalled does not take arguments'); 1277 | } 1278 | 1279 | if (!jasmine.isSpy(this.actual)) { 1280 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1281 | } 1282 | 1283 | this.message = function() { 1284 | return [ 1285 | "Expected spy " + this.actual.identity + " to not have been called.", 1286 | "Expected spy " + this.actual.identity + " to have been called." 1287 | ]; 1288 | }; 1289 | 1290 | return !this.actual.wasCalled; 1291 | }; 1292 | 1293 | /** 1294 | * Matcher that checks to see if the actual, a Jasmine spy, was called with a set of parameters. 1295 | * 1296 | * @example 1297 | * 1298 | */ 1299 | jasmine.Matchers.prototype.toHaveBeenCalledWith = function() { 1300 | var expectedArgs = jasmine.util.argsToArray(arguments); 1301 | if (!jasmine.isSpy(this.actual)) { 1302 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1303 | } 1304 | this.message = function() { 1305 | if (this.actual.callCount == 0) { 1306 | // todo: what should the failure message for .not.toHaveBeenCalledWith() be? is this right? test better. [xw] 1307 | return [ 1308 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was never called.", 1309 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was." 1310 | ]; 1311 | } else { 1312 | return [ 1313 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall), 1314 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but was called with " + jasmine.pp(this.actual.argsForCall) 1315 | ]; 1316 | } 1317 | }; 1318 | 1319 | return this.env.contains_(this.actual.argsForCall, expectedArgs); 1320 | }; 1321 | 1322 | /** @deprecated Use expect(xxx).toHaveBeenCalledWith() instead */ 1323 | jasmine.Matchers.prototype.wasCalledWith = jasmine.Matchers.prototype.toHaveBeenCalledWith; 1324 | 1325 | /** @deprecated Use expect(xxx).not.toHaveBeenCalledWith() instead */ 1326 | jasmine.Matchers.prototype.wasNotCalledWith = function() { 1327 | var expectedArgs = jasmine.util.argsToArray(arguments); 1328 | if (!jasmine.isSpy(this.actual)) { 1329 | throw new Error('Expected a spy, but got ' + jasmine.pp(this.actual) + '.'); 1330 | } 1331 | 1332 | this.message = function() { 1333 | return [ 1334 | "Expected spy not to have been called with " + jasmine.pp(expectedArgs) + " but it was", 1335 | "Expected spy to have been called with " + jasmine.pp(expectedArgs) + " but it was" 1336 | ] 1337 | }; 1338 | 1339 | return !this.env.contains_(this.actual.argsForCall, expectedArgs); 1340 | }; 1341 | 1342 | /** 1343 | * Matcher that checks that the expected item is an element in the actual Array. 1344 | * 1345 | * @param {Object} expected 1346 | */ 1347 | jasmine.Matchers.prototype.toContain = function(expected) { 1348 | return this.env.contains_(this.actual, expected); 1349 | }; 1350 | 1351 | /** 1352 | * Matcher that checks that the expected item is NOT an element in the actual Array. 1353 | * 1354 | * @param {Object} expected 1355 | * @deprecated as of 1.0. Use not.toNotContain() instead. 1356 | */ 1357 | jasmine.Matchers.prototype.toNotContain = function(expected) { 1358 | return !this.env.contains_(this.actual, expected); 1359 | }; 1360 | 1361 | jasmine.Matchers.prototype.toBeLessThan = function(expected) { 1362 | return this.actual < expected; 1363 | }; 1364 | 1365 | jasmine.Matchers.prototype.toBeGreaterThan = function(expected) { 1366 | return this.actual > expected; 1367 | }; 1368 | 1369 | /** 1370 | * Matcher that checks that the expected exception was thrown by the actual. 1371 | * 1372 | * @param {String} expected 1373 | */ 1374 | jasmine.Matchers.prototype.toThrow = function(expected) { 1375 | var result = false; 1376 | var exception; 1377 | if (typeof this.actual != 'function') { 1378 | throw new Error('Actual is not a function'); 1379 | } 1380 | try { 1381 | this.actual(); 1382 | } catch (e) { 1383 | exception = e; 1384 | } 1385 | if (exception) { 1386 | result = (expected === jasmine.undefined || this.env.equals_(exception.message || exception, expected.message || expected)); 1387 | } 1388 | 1389 | var not = this.isNot ? "not " : ""; 1390 | 1391 | this.message = function() { 1392 | if (exception && (expected === jasmine.undefined || !this.env.equals_(exception.message || exception, expected.message || expected))) { 1393 | return ["Expected function " + not + "to throw", expected ? expected.message || expected : " an exception", ", but it threw", exception.message || exception].join(' '); 1394 | } else { 1395 | return "Expected function to throw an exception."; 1396 | } 1397 | }; 1398 | 1399 | return result; 1400 | }; 1401 | 1402 | jasmine.Matchers.Any = function(expectedClass) { 1403 | this.expectedClass = expectedClass; 1404 | }; 1405 | 1406 | jasmine.Matchers.Any.prototype.matches = function(other) { 1407 | if (this.expectedClass == String) { 1408 | return typeof other == 'string' || other instanceof String; 1409 | } 1410 | 1411 | if (this.expectedClass == Number) { 1412 | return typeof other == 'number' || other instanceof Number; 1413 | } 1414 | 1415 | if (this.expectedClass == Function) { 1416 | return typeof other == 'function' || other instanceof Function; 1417 | } 1418 | 1419 | if (this.expectedClass == Object) { 1420 | return typeof other == 'object'; 1421 | } 1422 | 1423 | return other instanceof this.expectedClass; 1424 | }; 1425 | 1426 | jasmine.Matchers.Any.prototype.toString = function() { 1427 | return ''; 1428 | }; 1429 | 1430 | /** 1431 | * @constructor 1432 | */ 1433 | jasmine.MultiReporter = function() { 1434 | this.subReporters_ = []; 1435 | }; 1436 | jasmine.util.inherit(jasmine.MultiReporter, jasmine.Reporter); 1437 | 1438 | jasmine.MultiReporter.prototype.addReporter = function(reporter) { 1439 | this.subReporters_.push(reporter); 1440 | }; 1441 | 1442 | (function() { 1443 | var functionNames = [ 1444 | "reportRunnerStarting", 1445 | "reportRunnerResults", 1446 | "reportSuiteResults", 1447 | "reportSpecStarting", 1448 | "reportSpecResults", 1449 | "log" 1450 | ]; 1451 | for (var i = 0; i < functionNames.length; i++) { 1452 | var functionName = functionNames[i]; 1453 | jasmine.MultiReporter.prototype[functionName] = (function(functionName) { 1454 | return function() { 1455 | for (var j = 0; j < this.subReporters_.length; j++) { 1456 | var subReporter = this.subReporters_[j]; 1457 | if (subReporter[functionName]) { 1458 | subReporter[functionName].apply(subReporter, arguments); 1459 | } 1460 | } 1461 | }; 1462 | })(functionName); 1463 | } 1464 | })(); 1465 | /** 1466 | * Holds results for a set of Jasmine spec. Allows for the results array to hold another jasmine.NestedResults 1467 | * 1468 | * @constructor 1469 | */ 1470 | jasmine.NestedResults = function() { 1471 | /** 1472 | * The total count of results 1473 | */ 1474 | this.totalCount = 0; 1475 | /** 1476 | * Number of passed results 1477 | */ 1478 | this.passedCount = 0; 1479 | /** 1480 | * Number of failed results 1481 | */ 1482 | this.failedCount = 0; 1483 | /** 1484 | * Was this suite/spec skipped? 1485 | */ 1486 | this.skipped = false; 1487 | /** 1488 | * @ignore 1489 | */ 1490 | this.items_ = []; 1491 | }; 1492 | 1493 | /** 1494 | * Roll up the result counts. 1495 | * 1496 | * @param result 1497 | */ 1498 | jasmine.NestedResults.prototype.rollupCounts = function(result) { 1499 | this.totalCount += result.totalCount; 1500 | this.passedCount += result.passedCount; 1501 | this.failedCount += result.failedCount; 1502 | }; 1503 | 1504 | /** 1505 | * Adds a log message. 1506 | * @param values Array of message parts which will be concatenated later. 1507 | */ 1508 | jasmine.NestedResults.prototype.log = function(values) { 1509 | this.items_.push(new jasmine.MessageResult(values)); 1510 | }; 1511 | 1512 | /** 1513 | * Getter for the results: message & results. 1514 | */ 1515 | jasmine.NestedResults.prototype.getItems = function() { 1516 | return this.items_; 1517 | }; 1518 | 1519 | /** 1520 | * Adds a result, tracking counts (total, passed, & failed) 1521 | * @param {jasmine.ExpectationResult|jasmine.NestedResults} result 1522 | */ 1523 | jasmine.NestedResults.prototype.addResult = function(result) { 1524 | if (result.type != 'log') { 1525 | if (result.items_) { 1526 | this.rollupCounts(result); 1527 | } else { 1528 | this.totalCount++; 1529 | if (result.passed()) { 1530 | this.passedCount++; 1531 | } else { 1532 | this.failedCount++; 1533 | } 1534 | } 1535 | } 1536 | this.items_.push(result); 1537 | }; 1538 | 1539 | /** 1540 | * @returns {Boolean} True if everything below passed 1541 | */ 1542 | jasmine.NestedResults.prototype.passed = function() { 1543 | return this.passedCount === this.totalCount; 1544 | }; 1545 | /** 1546 | * Base class for pretty printing for expectation results. 1547 | */ 1548 | jasmine.PrettyPrinter = function() { 1549 | this.ppNestLevel_ = 0; 1550 | }; 1551 | 1552 | /** 1553 | * Formats a value in a nice, human-readable string. 1554 | * 1555 | * @param value 1556 | */ 1557 | jasmine.PrettyPrinter.prototype.format = function(value) { 1558 | if (this.ppNestLevel_ > 40) { 1559 | throw new Error('jasmine.PrettyPrinter: format() nested too deeply!'); 1560 | } 1561 | 1562 | this.ppNestLevel_++; 1563 | try { 1564 | if (value === jasmine.undefined) { 1565 | this.emitScalar('undefined'); 1566 | } else if (value === null) { 1567 | this.emitScalar('null'); 1568 | } else if (value === jasmine.getGlobal()) { 1569 | this.emitScalar(''); 1570 | } else if (value instanceof jasmine.Matchers.Any) { 1571 | this.emitScalar(value.toString()); 1572 | } else if (typeof value === 'string') { 1573 | this.emitString(value); 1574 | } else if (jasmine.isSpy(value)) { 1575 | this.emitScalar("spy on " + value.identity); 1576 | } else if (value instanceof RegExp) { 1577 | this.emitScalar(value.toString()); 1578 | } else if (typeof value === 'function') { 1579 | this.emitScalar('Function'); 1580 | } else if (typeof value.nodeType === 'number') { 1581 | this.emitScalar('HTMLNode'); 1582 | } else if (value instanceof Date) { 1583 | this.emitScalar('Date(' + value + ')'); 1584 | } else if (value.__Jasmine_been_here_before__) { 1585 | this.emitScalar(''); 1586 | } else if (jasmine.isArray_(value) || typeof value == 'object') { 1587 | value.__Jasmine_been_here_before__ = true; 1588 | if (jasmine.isArray_(value)) { 1589 | this.emitArray(value); 1590 | } else { 1591 | this.emitObject(value); 1592 | } 1593 | delete value.__Jasmine_been_here_before__; 1594 | } else { 1595 | this.emitScalar(value.toString()); 1596 | } 1597 | } finally { 1598 | this.ppNestLevel_--; 1599 | } 1600 | }; 1601 | 1602 | jasmine.PrettyPrinter.prototype.iterateObject = function(obj, fn) { 1603 | for (var property in obj) { 1604 | if (property == '__Jasmine_been_here_before__') continue; 1605 | fn(property, obj.__lookupGetter__ ? (obj.__lookupGetter__(property) != null) : false); 1606 | } 1607 | }; 1608 | 1609 | jasmine.PrettyPrinter.prototype.emitArray = jasmine.unimplementedMethod_; 1610 | jasmine.PrettyPrinter.prototype.emitObject = jasmine.unimplementedMethod_; 1611 | jasmine.PrettyPrinter.prototype.emitScalar = jasmine.unimplementedMethod_; 1612 | jasmine.PrettyPrinter.prototype.emitString = jasmine.unimplementedMethod_; 1613 | 1614 | jasmine.StringPrettyPrinter = function() { 1615 | jasmine.PrettyPrinter.call(this); 1616 | 1617 | this.string = ''; 1618 | }; 1619 | jasmine.util.inherit(jasmine.StringPrettyPrinter, jasmine.PrettyPrinter); 1620 | 1621 | jasmine.StringPrettyPrinter.prototype.emitScalar = function(value) { 1622 | this.append(value); 1623 | }; 1624 | 1625 | jasmine.StringPrettyPrinter.prototype.emitString = function(value) { 1626 | this.append("'" + value + "'"); 1627 | }; 1628 | 1629 | jasmine.StringPrettyPrinter.prototype.emitArray = function(array) { 1630 | this.append('[ '); 1631 | for (var i = 0; i < array.length; i++) { 1632 | if (i > 0) { 1633 | this.append(', '); 1634 | } 1635 | this.format(array[i]); 1636 | } 1637 | this.append(' ]'); 1638 | }; 1639 | 1640 | jasmine.StringPrettyPrinter.prototype.emitObject = function(obj) { 1641 | var self = this; 1642 | this.append('{ '); 1643 | var first = true; 1644 | 1645 | this.iterateObject(obj, function(property, isGetter) { 1646 | if (first) { 1647 | first = false; 1648 | } else { 1649 | self.append(', '); 1650 | } 1651 | 1652 | self.append(property); 1653 | self.append(' : '); 1654 | if (isGetter) { 1655 | self.append(''); 1656 | } else { 1657 | self.format(obj[property]); 1658 | } 1659 | }); 1660 | 1661 | this.append(' }'); 1662 | }; 1663 | 1664 | jasmine.StringPrettyPrinter.prototype.append = function(value) { 1665 | this.string += value; 1666 | }; 1667 | jasmine.Queue = function(env) { 1668 | this.env = env; 1669 | this.blocks = []; 1670 | this.running = false; 1671 | this.index = 0; 1672 | this.offset = 0; 1673 | this.abort = false; 1674 | }; 1675 | 1676 | jasmine.Queue.prototype.addBefore = function(block) { 1677 | this.blocks.unshift(block); 1678 | }; 1679 | 1680 | jasmine.Queue.prototype.add = function(block) { 1681 | this.blocks.push(block); 1682 | }; 1683 | 1684 | jasmine.Queue.prototype.insertNext = function(block) { 1685 | this.blocks.splice((this.index + this.offset + 1), 0, block); 1686 | this.offset++; 1687 | }; 1688 | 1689 | jasmine.Queue.prototype.start = function(onComplete) { 1690 | this.running = true; 1691 | this.onComplete = onComplete; 1692 | this.next_(); 1693 | }; 1694 | 1695 | jasmine.Queue.prototype.isRunning = function() { 1696 | return this.running; 1697 | }; 1698 | 1699 | jasmine.Queue.LOOP_DONT_RECURSE = true; 1700 | 1701 | jasmine.Queue.prototype.next_ = function() { 1702 | var self = this; 1703 | var goAgain = true; 1704 | 1705 | while (goAgain) { 1706 | goAgain = false; 1707 | 1708 | if (self.index < self.blocks.length && !this.abort) { 1709 | var calledSynchronously = true; 1710 | var completedSynchronously = false; 1711 | 1712 | var onComplete = function () { 1713 | if (jasmine.Queue.LOOP_DONT_RECURSE && calledSynchronously) { 1714 | completedSynchronously = true; 1715 | return; 1716 | } 1717 | 1718 | if (self.blocks[self.index].abort) { 1719 | self.abort = true; 1720 | } 1721 | 1722 | self.offset = 0; 1723 | self.index++; 1724 | 1725 | var now = new Date().getTime(); 1726 | if (self.env.updateInterval && now - self.env.lastUpdate > self.env.updateInterval) { 1727 | self.env.lastUpdate = now; 1728 | self.env.setTimeout(function() { 1729 | self.next_(); 1730 | }, 0); 1731 | } else { 1732 | if (jasmine.Queue.LOOP_DONT_RECURSE && completedSynchronously) { 1733 | goAgain = true; 1734 | } else { 1735 | self.next_(); 1736 | } 1737 | } 1738 | }; 1739 | self.blocks[self.index].execute(onComplete); 1740 | 1741 | calledSynchronously = false; 1742 | if (completedSynchronously) { 1743 | onComplete(); 1744 | } 1745 | 1746 | } else { 1747 | self.running = false; 1748 | if (self.onComplete) { 1749 | self.onComplete(); 1750 | } 1751 | } 1752 | } 1753 | }; 1754 | 1755 | jasmine.Queue.prototype.results = function() { 1756 | var results = new jasmine.NestedResults(); 1757 | for (var i = 0; i < this.blocks.length; i++) { 1758 | if (this.blocks[i].results) { 1759 | results.addResult(this.blocks[i].results()); 1760 | } 1761 | } 1762 | return results; 1763 | }; 1764 | 1765 | 1766 | /** 1767 | * Runner 1768 | * 1769 | * @constructor 1770 | * @param {jasmine.Env} env 1771 | */ 1772 | jasmine.Runner = function(env) { 1773 | var self = this; 1774 | self.env = env; 1775 | self.queue = new jasmine.Queue(env); 1776 | self.before_ = []; 1777 | self.after_ = []; 1778 | self.suites_ = []; 1779 | }; 1780 | 1781 | jasmine.Runner.prototype.execute = function() { 1782 | var self = this; 1783 | if (self.env.reporter.reportRunnerStarting) { 1784 | self.env.reporter.reportRunnerStarting(this); 1785 | } 1786 | self.queue.start(function () { 1787 | self.finishCallback(); 1788 | }); 1789 | }; 1790 | 1791 | jasmine.Runner.prototype.beforeEach = function(beforeEachFunction) { 1792 | beforeEachFunction.typeName = 'beforeEach'; 1793 | this.before_.splice(0,0,beforeEachFunction); 1794 | }; 1795 | 1796 | jasmine.Runner.prototype.afterEach = function(afterEachFunction) { 1797 | afterEachFunction.typeName = 'afterEach'; 1798 | this.after_.splice(0,0,afterEachFunction); 1799 | }; 1800 | 1801 | 1802 | jasmine.Runner.prototype.finishCallback = function() { 1803 | this.env.reporter.reportRunnerResults(this); 1804 | }; 1805 | 1806 | jasmine.Runner.prototype.addSuite = function(suite) { 1807 | this.suites_.push(suite); 1808 | }; 1809 | 1810 | jasmine.Runner.prototype.add = function(block) { 1811 | if (block instanceof jasmine.Suite) { 1812 | this.addSuite(block); 1813 | } 1814 | this.queue.add(block); 1815 | }; 1816 | 1817 | jasmine.Runner.prototype.specs = function () { 1818 | var suites = this.suites(); 1819 | var specs = []; 1820 | for (var i = 0; i < suites.length; i++) { 1821 | specs = specs.concat(suites[i].specs()); 1822 | } 1823 | return specs; 1824 | }; 1825 | 1826 | jasmine.Runner.prototype.suites = function() { 1827 | return this.suites_; 1828 | }; 1829 | 1830 | jasmine.Runner.prototype.topLevelSuites = function() { 1831 | var topLevelSuites = []; 1832 | for (var i = 0; i < this.suites_.length; i++) { 1833 | if (!this.suites_[i].parentSuite) { 1834 | topLevelSuites.push(this.suites_[i]); 1835 | } 1836 | } 1837 | return topLevelSuites; 1838 | }; 1839 | 1840 | jasmine.Runner.prototype.results = function() { 1841 | return this.queue.results(); 1842 | }; 1843 | /** 1844 | * Internal representation of a Jasmine specification, or test. 1845 | * 1846 | * @constructor 1847 | * @param {jasmine.Env} env 1848 | * @param {jasmine.Suite} suite 1849 | * @param {String} description 1850 | */ 1851 | jasmine.Spec = function(env, suite, description) { 1852 | if (!env) { 1853 | throw new Error('jasmine.Env() required'); 1854 | } 1855 | if (!suite) { 1856 | throw new Error('jasmine.Suite() required'); 1857 | } 1858 | var spec = this; 1859 | spec.id = env.nextSpecId ? env.nextSpecId() : null; 1860 | spec.env = env; 1861 | spec.suite = suite; 1862 | spec.description = description; 1863 | spec.queue = new jasmine.Queue(env); 1864 | 1865 | spec.afterCallbacks = []; 1866 | spec.spies_ = []; 1867 | 1868 | spec.results_ = new jasmine.NestedResults(); 1869 | spec.results_.description = description; 1870 | spec.matchersClass = null; 1871 | }; 1872 | 1873 | jasmine.Spec.prototype.getFullName = function() { 1874 | return this.suite.getFullName() + ' ' + this.description + '.'; 1875 | }; 1876 | 1877 | 1878 | jasmine.Spec.prototype.results = function() { 1879 | return this.results_; 1880 | }; 1881 | 1882 | /** 1883 | * All parameters are pretty-printed and concatenated together, then written to the spec's output. 1884 | * 1885 | * Be careful not to leave calls to jasmine.log in production code. 1886 | */ 1887 | jasmine.Spec.prototype.log = function() { 1888 | return this.results_.log(arguments); 1889 | }; 1890 | 1891 | jasmine.Spec.prototype.runs = function (func) { 1892 | var block = new jasmine.Block(this.env, func, this); 1893 | this.addToQueue(block); 1894 | return this; 1895 | }; 1896 | 1897 | jasmine.Spec.prototype.addToQueue = function (block) { 1898 | if (this.queue.isRunning()) { 1899 | this.queue.insertNext(block); 1900 | } else { 1901 | this.queue.add(block); 1902 | } 1903 | }; 1904 | 1905 | /** 1906 | * @param {jasmine.ExpectationResult} result 1907 | */ 1908 | jasmine.Spec.prototype.addMatcherResult = function(result) { 1909 | this.results_.addResult(result); 1910 | }; 1911 | 1912 | jasmine.Spec.prototype.expect = function(actual) { 1913 | var positive = new (this.getMatchersClass_())(this.env, actual, this); 1914 | positive.not = new (this.getMatchersClass_())(this.env, actual, this, true); 1915 | return positive; 1916 | }; 1917 | 1918 | /** 1919 | * Waits a fixed time period before moving to the next block. 1920 | * 1921 | * @deprecated Use waitsFor() instead 1922 | * @param {Number} timeout milliseconds to wait 1923 | */ 1924 | jasmine.Spec.prototype.waits = function(timeout) { 1925 | var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this); 1926 | this.addToQueue(waitsFunc); 1927 | return this; 1928 | }; 1929 | 1930 | /** 1931 | * Waits for the latchFunction to return true before proceeding to the next block. 1932 | * 1933 | * @param {Function} latchFunction 1934 | * @param {String} optional_timeoutMessage 1935 | * @param {Number} optional_timeout 1936 | */ 1937 | jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) { 1938 | var latchFunction_ = null; 1939 | var optional_timeoutMessage_ = null; 1940 | var optional_timeout_ = null; 1941 | 1942 | for (var i = 0; i < arguments.length; i++) { 1943 | var arg = arguments[i]; 1944 | switch (typeof arg) { 1945 | case 'function': 1946 | latchFunction_ = arg; 1947 | break; 1948 | case 'string': 1949 | optional_timeoutMessage_ = arg; 1950 | break; 1951 | case 'number': 1952 | optional_timeout_ = arg; 1953 | break; 1954 | } 1955 | } 1956 | 1957 | var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this); 1958 | this.addToQueue(waitsForFunc); 1959 | return this; 1960 | }; 1961 | 1962 | jasmine.Spec.prototype.fail = function (e) { 1963 | var expectationResult = new jasmine.ExpectationResult({ 1964 | passed: false, 1965 | message: e ? jasmine.util.formatException(e) : 'Exception' 1966 | }); 1967 | this.results_.addResult(expectationResult); 1968 | }; 1969 | 1970 | jasmine.Spec.prototype.getMatchersClass_ = function() { 1971 | return this.matchersClass || this.env.matchersClass; 1972 | }; 1973 | 1974 | jasmine.Spec.prototype.addMatchers = function(matchersPrototype) { 1975 | var parent = this.getMatchersClass_(); 1976 | var newMatchersClass = function() { 1977 | parent.apply(this, arguments); 1978 | }; 1979 | jasmine.util.inherit(newMatchersClass, parent); 1980 | jasmine.Matchers.wrapInto_(matchersPrototype, newMatchersClass); 1981 | this.matchersClass = newMatchersClass; 1982 | }; 1983 | 1984 | jasmine.Spec.prototype.finishCallback = function() { 1985 | this.env.reporter.reportSpecResults(this); 1986 | }; 1987 | 1988 | jasmine.Spec.prototype.finish = function(onComplete) { 1989 | this.removeAllSpies(); 1990 | this.finishCallback(); 1991 | if (onComplete) { 1992 | onComplete(); 1993 | } 1994 | }; 1995 | 1996 | jasmine.Spec.prototype.after = function(doAfter) { 1997 | if (this.queue.isRunning()) { 1998 | this.queue.add(new jasmine.Block(this.env, doAfter, this)); 1999 | } else { 2000 | this.afterCallbacks.unshift(doAfter); 2001 | } 2002 | }; 2003 | 2004 | jasmine.Spec.prototype.execute = function(onComplete) { 2005 | var spec = this; 2006 | if (!spec.env.specFilter(spec)) { 2007 | spec.results_.skipped = true; 2008 | spec.finish(onComplete); 2009 | return; 2010 | } 2011 | 2012 | this.env.reporter.reportSpecStarting(this); 2013 | 2014 | spec.env.currentSpec = spec; 2015 | 2016 | spec.addBeforesAndAftersToQueue(); 2017 | 2018 | spec.queue.start(function () { 2019 | spec.finish(onComplete); 2020 | }); 2021 | }; 2022 | 2023 | jasmine.Spec.prototype.addBeforesAndAftersToQueue = function() { 2024 | var runner = this.env.currentRunner(); 2025 | var i; 2026 | 2027 | for (var suite = this.suite; suite; suite = suite.parentSuite) { 2028 | for (i = 0; i < suite.before_.length; i++) { 2029 | this.queue.addBefore(new jasmine.Block(this.env, suite.before_[i], this)); 2030 | } 2031 | } 2032 | for (i = 0; i < runner.before_.length; i++) { 2033 | this.queue.addBefore(new jasmine.Block(this.env, runner.before_[i], this)); 2034 | } 2035 | for (i = 0; i < this.afterCallbacks.length; i++) { 2036 | this.queue.add(new jasmine.Block(this.env, this.afterCallbacks[i], this)); 2037 | } 2038 | for (suite = this.suite; suite; suite = suite.parentSuite) { 2039 | for (i = 0; i < suite.after_.length; i++) { 2040 | this.queue.add(new jasmine.Block(this.env, suite.after_[i], this)); 2041 | } 2042 | } 2043 | for (i = 0; i < runner.after_.length; i++) { 2044 | this.queue.add(new jasmine.Block(this.env, runner.after_[i], this)); 2045 | } 2046 | }; 2047 | 2048 | jasmine.Spec.prototype.explodes = function() { 2049 | throw 'explodes function should not have been called'; 2050 | }; 2051 | 2052 | jasmine.Spec.prototype.spyOn = function(obj, methodName, ignoreMethodDoesntExist) { 2053 | if (obj == jasmine.undefined) { 2054 | throw "spyOn could not find an object to spy upon for " + methodName + "()"; 2055 | } 2056 | 2057 | if (!ignoreMethodDoesntExist && obj[methodName] === jasmine.undefined) { 2058 | throw methodName + '() method does not exist'; 2059 | } 2060 | 2061 | if (!ignoreMethodDoesntExist && obj[methodName] && obj[methodName].isSpy) { 2062 | throw new Error(methodName + ' has already been spied upon'); 2063 | } 2064 | 2065 | var spyObj = jasmine.createSpy(methodName); 2066 | 2067 | this.spies_.push(spyObj); 2068 | spyObj.baseObj = obj; 2069 | spyObj.methodName = methodName; 2070 | spyObj.originalValue = obj[methodName]; 2071 | 2072 | obj[methodName] = spyObj; 2073 | 2074 | return spyObj; 2075 | }; 2076 | 2077 | jasmine.Spec.prototype.removeAllSpies = function() { 2078 | for (var i = 0; i < this.spies_.length; i++) { 2079 | var spy = this.spies_[i]; 2080 | spy.baseObj[spy.methodName] = spy.originalValue; 2081 | } 2082 | this.spies_ = []; 2083 | }; 2084 | 2085 | /** 2086 | * Internal representation of a Jasmine suite. 2087 | * 2088 | * @constructor 2089 | * @param {jasmine.Env} env 2090 | * @param {String} description 2091 | * @param {Function} specDefinitions 2092 | * @param {jasmine.Suite} parentSuite 2093 | */ 2094 | jasmine.Suite = function(env, description, specDefinitions, parentSuite) { 2095 | var self = this; 2096 | self.id = env.nextSuiteId ? env.nextSuiteId() : null; 2097 | self.description = description; 2098 | self.queue = new jasmine.Queue(env); 2099 | self.parentSuite = parentSuite; 2100 | self.env = env; 2101 | self.before_ = []; 2102 | self.after_ = []; 2103 | self.children_ = []; 2104 | self.suites_ = []; 2105 | self.specs_ = []; 2106 | }; 2107 | 2108 | jasmine.Suite.prototype.getFullName = function() { 2109 | var fullName = this.description; 2110 | for (var parentSuite = this.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) { 2111 | fullName = parentSuite.description + ' ' + fullName; 2112 | } 2113 | return fullName; 2114 | }; 2115 | 2116 | jasmine.Suite.prototype.finish = function(onComplete) { 2117 | this.env.reporter.reportSuiteResults(this); 2118 | this.finished = true; 2119 | if (typeof(onComplete) == 'function') { 2120 | onComplete(); 2121 | } 2122 | }; 2123 | 2124 | jasmine.Suite.prototype.beforeEach = function(beforeEachFunction) { 2125 | beforeEachFunction.typeName = 'beforeEach'; 2126 | this.before_.unshift(beforeEachFunction); 2127 | }; 2128 | 2129 | jasmine.Suite.prototype.afterEach = function(afterEachFunction) { 2130 | afterEachFunction.typeName = 'afterEach'; 2131 | this.after_.unshift(afterEachFunction); 2132 | }; 2133 | 2134 | jasmine.Suite.prototype.results = function() { 2135 | return this.queue.results(); 2136 | }; 2137 | 2138 | jasmine.Suite.prototype.add = function(suiteOrSpec) { 2139 | this.children_.push(suiteOrSpec); 2140 | if (suiteOrSpec instanceof jasmine.Suite) { 2141 | this.suites_.push(suiteOrSpec); 2142 | this.env.currentRunner().addSuite(suiteOrSpec); 2143 | } else { 2144 | this.specs_.push(suiteOrSpec); 2145 | } 2146 | this.queue.add(suiteOrSpec); 2147 | }; 2148 | 2149 | jasmine.Suite.prototype.specs = function() { 2150 | return this.specs_; 2151 | }; 2152 | 2153 | jasmine.Suite.prototype.suites = function() { 2154 | return this.suites_; 2155 | }; 2156 | 2157 | jasmine.Suite.prototype.children = function() { 2158 | return this.children_; 2159 | }; 2160 | 2161 | jasmine.Suite.prototype.execute = function(onComplete) { 2162 | var self = this; 2163 | this.queue.start(function () { 2164 | self.finish(onComplete); 2165 | }); 2166 | }; 2167 | jasmine.WaitsBlock = function(env, timeout, spec) { 2168 | this.timeout = timeout; 2169 | jasmine.Block.call(this, env, null, spec); 2170 | }; 2171 | 2172 | jasmine.util.inherit(jasmine.WaitsBlock, jasmine.Block); 2173 | 2174 | jasmine.WaitsBlock.prototype.execute = function (onComplete) { 2175 | this.env.reporter.log('>> Jasmine waiting for ' + this.timeout + ' ms...'); 2176 | this.env.setTimeout(function () { 2177 | onComplete(); 2178 | }, this.timeout); 2179 | }; 2180 | /** 2181 | * A block which waits for some condition to become true, with timeout. 2182 | * 2183 | * @constructor 2184 | * @extends jasmine.Block 2185 | * @param {jasmine.Env} env The Jasmine environment. 2186 | * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true. 2187 | * @param {Function} latchFunction A function which returns true when the desired condition has been met. 2188 | * @param {String} message The message to display if the desired condition hasn't been met within the given time period. 2189 | * @param {jasmine.Spec} spec The Jasmine spec. 2190 | */ 2191 | jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) { 2192 | this.timeout = timeout || env.defaultTimeoutInterval; 2193 | this.latchFunction = latchFunction; 2194 | this.message = message; 2195 | this.totalTimeSpentWaitingForLatch = 0; 2196 | jasmine.Block.call(this, env, null, spec); 2197 | }; 2198 | jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block); 2199 | 2200 | jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10; 2201 | 2202 | jasmine.WaitsForBlock.prototype.execute = function(onComplete) { 2203 | this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen')); 2204 | var latchFunctionResult; 2205 | try { 2206 | latchFunctionResult = this.latchFunction.apply(this.spec); 2207 | } catch (e) { 2208 | this.spec.fail(e); 2209 | onComplete(); 2210 | return; 2211 | } 2212 | 2213 | if (latchFunctionResult) { 2214 | onComplete(); 2215 | } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) { 2216 | var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen'); 2217 | this.spec.fail({ 2218 | name: 'timeout', 2219 | message: message 2220 | }); 2221 | 2222 | this.abort = true; 2223 | onComplete(); 2224 | } else { 2225 | this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT; 2226 | var self = this; 2227 | this.env.setTimeout(function() { 2228 | self.execute(onComplete); 2229 | }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT); 2230 | } 2231 | }; 2232 | // Mock setTimeout, clearTimeout 2233 | // Contributed by Pivotal Computer Systems, www.pivotalsf.com 2234 | 2235 | jasmine.FakeTimer = function() { 2236 | this.reset(); 2237 | 2238 | var self = this; 2239 | self.setTimeout = function(funcToCall, millis) { 2240 | self.timeoutsMade++; 2241 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, false); 2242 | return self.timeoutsMade; 2243 | }; 2244 | 2245 | self.setInterval = function(funcToCall, millis) { 2246 | self.timeoutsMade++; 2247 | self.scheduleFunction(self.timeoutsMade, funcToCall, millis, true); 2248 | return self.timeoutsMade; 2249 | }; 2250 | 2251 | self.clearTimeout = function(timeoutKey) { 2252 | self.scheduledFunctions[timeoutKey] = jasmine.undefined; 2253 | }; 2254 | 2255 | self.clearInterval = function(timeoutKey) { 2256 | self.scheduledFunctions[timeoutKey] = jasmine.undefined; 2257 | }; 2258 | 2259 | }; 2260 | 2261 | jasmine.FakeTimer.prototype.reset = function() { 2262 | this.timeoutsMade = 0; 2263 | this.scheduledFunctions = {}; 2264 | this.nowMillis = 0; 2265 | }; 2266 | 2267 | jasmine.FakeTimer.prototype.tick = function(millis) { 2268 | var oldMillis = this.nowMillis; 2269 | var newMillis = oldMillis + millis; 2270 | this.runFunctionsWithinRange(oldMillis, newMillis); 2271 | this.nowMillis = newMillis; 2272 | }; 2273 | 2274 | jasmine.FakeTimer.prototype.runFunctionsWithinRange = function(oldMillis, nowMillis) { 2275 | var scheduledFunc; 2276 | var funcsToRun = []; 2277 | for (var timeoutKey in this.scheduledFunctions) { 2278 | scheduledFunc = this.scheduledFunctions[timeoutKey]; 2279 | if (scheduledFunc != jasmine.undefined && 2280 | scheduledFunc.runAtMillis >= oldMillis && 2281 | scheduledFunc.runAtMillis <= nowMillis) { 2282 | funcsToRun.push(scheduledFunc); 2283 | this.scheduledFunctions[timeoutKey] = jasmine.undefined; 2284 | } 2285 | } 2286 | 2287 | if (funcsToRun.length > 0) { 2288 | funcsToRun.sort(function(a, b) { 2289 | return a.runAtMillis - b.runAtMillis; 2290 | }); 2291 | for (var i = 0; i < funcsToRun.length; ++i) { 2292 | try { 2293 | var funcToRun = funcsToRun[i]; 2294 | this.nowMillis = funcToRun.runAtMillis; 2295 | funcToRun.funcToCall(); 2296 | if (funcToRun.recurring) { 2297 | this.scheduleFunction(funcToRun.timeoutKey, 2298 | funcToRun.funcToCall, 2299 | funcToRun.millis, 2300 | true); 2301 | } 2302 | } catch(e) { 2303 | } 2304 | } 2305 | this.runFunctionsWithinRange(oldMillis, nowMillis); 2306 | } 2307 | }; 2308 | 2309 | jasmine.FakeTimer.prototype.scheduleFunction = function(timeoutKey, funcToCall, millis, recurring) { 2310 | this.scheduledFunctions[timeoutKey] = { 2311 | runAtMillis: this.nowMillis + millis, 2312 | funcToCall: funcToCall, 2313 | recurring: recurring, 2314 | timeoutKey: timeoutKey, 2315 | millis: millis 2316 | }; 2317 | }; 2318 | 2319 | /** 2320 | * @namespace 2321 | */ 2322 | jasmine.Clock = { 2323 | defaultFakeTimer: new jasmine.FakeTimer(), 2324 | 2325 | reset: function() { 2326 | jasmine.Clock.assertInstalled(); 2327 | jasmine.Clock.defaultFakeTimer.reset(); 2328 | }, 2329 | 2330 | tick: function(millis) { 2331 | jasmine.Clock.assertInstalled(); 2332 | jasmine.Clock.defaultFakeTimer.tick(millis); 2333 | }, 2334 | 2335 | runFunctionsWithinRange: function(oldMillis, nowMillis) { 2336 | jasmine.Clock.defaultFakeTimer.runFunctionsWithinRange(oldMillis, nowMillis); 2337 | }, 2338 | 2339 | scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) { 2340 | jasmine.Clock.defaultFakeTimer.scheduleFunction(timeoutKey, funcToCall, millis, recurring); 2341 | }, 2342 | 2343 | useMock: function() { 2344 | if (!jasmine.Clock.isInstalled()) { 2345 | var spec = jasmine.getEnv().currentSpec; 2346 | spec.after(jasmine.Clock.uninstallMock); 2347 | 2348 | jasmine.Clock.installMock(); 2349 | } 2350 | }, 2351 | 2352 | installMock: function() { 2353 | jasmine.Clock.installed = jasmine.Clock.defaultFakeTimer; 2354 | }, 2355 | 2356 | uninstallMock: function() { 2357 | jasmine.Clock.assertInstalled(); 2358 | jasmine.Clock.installed = jasmine.Clock.real; 2359 | }, 2360 | 2361 | real: { 2362 | setTimeout: jasmine.getGlobal().setTimeout, 2363 | clearTimeout: jasmine.getGlobal().clearTimeout, 2364 | setInterval: jasmine.getGlobal().setInterval, 2365 | clearInterval: jasmine.getGlobal().clearInterval 2366 | }, 2367 | 2368 | assertInstalled: function() { 2369 | if (!jasmine.Clock.isInstalled()) { 2370 | throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()"); 2371 | } 2372 | }, 2373 | 2374 | isInstalled: function() { 2375 | return jasmine.Clock.installed == jasmine.Clock.defaultFakeTimer; 2376 | }, 2377 | 2378 | installed: null 2379 | }; 2380 | jasmine.Clock.installed = jasmine.Clock.real; 2381 | 2382 | //else for IE support 2383 | jasmine.getGlobal().setTimeout = function(funcToCall, millis) { 2384 | if (jasmine.Clock.installed.setTimeout.apply) { 2385 | return jasmine.Clock.installed.setTimeout.apply(this, arguments); 2386 | } else { 2387 | return jasmine.Clock.installed.setTimeout(funcToCall, millis); 2388 | } 2389 | }; 2390 | 2391 | jasmine.getGlobal().setInterval = function(funcToCall, millis) { 2392 | if (jasmine.Clock.installed.setInterval.apply) { 2393 | return jasmine.Clock.installed.setInterval.apply(this, arguments); 2394 | } else { 2395 | return jasmine.Clock.installed.setInterval(funcToCall, millis); 2396 | } 2397 | }; 2398 | 2399 | jasmine.getGlobal().clearTimeout = function(timeoutKey) { 2400 | if (jasmine.Clock.installed.clearTimeout.apply) { 2401 | return jasmine.Clock.installed.clearTimeout.apply(this, arguments); 2402 | } else { 2403 | return jasmine.Clock.installed.clearTimeout(timeoutKey); 2404 | } 2405 | }; 2406 | 2407 | jasmine.getGlobal().clearInterval = function(timeoutKey) { 2408 | if (jasmine.Clock.installed.clearTimeout.apply) { 2409 | return jasmine.Clock.installed.clearInterval.apply(this, arguments); 2410 | } else { 2411 | return jasmine.Clock.installed.clearInterval(timeoutKey); 2412 | } 2413 | }; 2414 | 2415 | 2416 | jasmine.version_= { 2417 | "major": 1, 2418 | "minor": 0, 2419 | "build": 1, 2420 | "revision": 1286311016 2421 | }; 2422 | -------------------------------------------------------------------------------- /spec/lib/jquery.keymasher.js: -------------------------------------------------------------------------------- 1 | /* 2 | Key Masher plugin for jQuery (https://github.com/digitalBush/jquery.keymasher) 3 | Copyright (c) 2010-2014 Josh Bush (digitalbush.com) 4 | Licensed under the MIT license 5 | Version: 0.4 6 | */ 7 | 8 | (function($,undefined){ 9 | //numberPad={'0':96,'1':97,'2':98,'3':99,'4':100,'5':101,'6':102,'7':103,'8':104,'9':105,'*':106,'+':107,'-':109,'.':110,'/':111}, 10 | 11 | var keys=(function(){ 12 | var defs={}, 13 | keys = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890`-=[]\\;',./ \t\n\r", 14 | shifted = "abcdefghijklmnopqrstuvwxyz!@#$%^&*()~_+{}|:\"<>?", 15 | noprint={shift:16,ctrl:17,meta:91,alt:18,f1:112,f2:113,f3:114,f4:115,f5:116,f6:117,f7:118,f8:119,f9:120,f10:121,f11:122,f12:123, 16 | capslock:20,numlock:144,scrolllock:145,pageup:33,pagedown:34,end:35,home:36,backspace:8, 17 | insert:45, 'delete':46,pause:19,esc:27,left:37,up:38,right:39,down:40,printscreen:44}; 18 | 19 | $.each(keys.split(''),function(index,value){ 20 | var keyCode=value.charCodeAt(0),shift=shifted[index]; 21 | defs[value]={keyCode:keyCode,charCode:keyCode,shift:shift}; 22 | if(shift) 23 | defs[shift]={keyCode:keyCode,charCode:shift.charCodeAt(0),shift:value,requiresShift:index>=26}; 24 | }); 25 | $.each(noprint,function(key,value){defs[key]={keyCode:value};}); 26 | return defs; 27 | })(); 28 | 29 | var KeyMasher=function(elm){ 30 | var modifierState={alt: false, ctrl: false, meta: false, shift: false}, 31 | forced={}; 32 | 33 | var queueModifierEvent=function(direction,modifier,isForced){ 34 | forced[modifier]=isForced; 35 | modifierState[modifier]=(direction=='down'); 36 | var event=$.extend($.Event(), modifierState, {type:'key'+direction, keyCode: keys[modifier].keyCode, charCode: 0}); 37 | elm.trigger(event); 38 | }; 39 | 40 | var queueStroke=function(key){ 41 | if($.type(key)==='string') 42 | key=keys[key]; 43 | if(key.requiresShift && !modifierState.shift) 44 | queueModifierEvent('down','shift',true); 45 | else if(modifierState.shift && key.shift) 46 | key=keys[key.shift]; 47 | 48 | var ignore = !key.charCode || modifierState.alt || modifierState.ctrl || modifierState.meta, 49 | down = $.extend($.Event('keydown'), modifierState, {keyCode: key.keyCode, charCode: 0, which:key.keyCode}), 50 | press = $.extend($.Event('keypress'), modifierState, {keyCode: key.charCode, charCode: key.charCode, which: key.charCode}), 51 | up = $.extend($.Event('keyup'), modifierState, {keyCode: key.keyCode, charCode: 0, which:key.keyCode}); 52 | 53 | elm.trigger(down); 54 | if(!down.isDefaultPrevented() && !ignore){ 55 | elm.trigger(press); 56 | if(!press.isDefaultPrevented() && !elm.prop("readonly")){ 57 | //need to do caret positioning 58 | elm.val(elm.val()+String.fromCharCode(key.charCode)); 59 | } 60 | } 61 | elm.trigger(up); 62 | 63 | if(forced.shift) 64 | queueModifierEvent('up','shift'); 65 | }; 66 | 67 | var public={ 68 | hold:function(holding,typing){ 69 | var toks=holding.split(','); 70 | $.each(toks,function(index,value){queueModifierEvent('down',value);}); 71 | public.type(typing); 72 | $.each(toks,function(index,value){queueModifierEvent('up',value);}); 73 | return public; 74 | }, 75 | type:function(){ 76 | $.each(arguments,function(index,typing){ 77 | if($.type(typing)==='string') 78 | $.each(typing.split(''),function(index,value){queueStroke(value);}); 79 | else 80 | queueStroke(typing); 81 | }); 82 | return public; 83 | } 84 | }; 85 | return $.extend(public,keys); 86 | }; 87 | 88 | $.fn.mashKeys=function(fn){ 89 | if($.type(fn)==='string'){ 90 | var typing=fn; 91 | fn=function(keys){keys.type(typing)}; 92 | } 93 | return this.each(function(){ 94 | fn(KeyMasher($(this))); 95 | }); 96 | }; 97 | })(jQuery); 98 | -------------------------------------------------------------------------------- /spec/lib/matchers.js: -------------------------------------------------------------------------------- 1 | beforeEach(function(){ 2 | this.addMatchers({ 3 | toHaveValue:function(expected){ 4 | return (this.actual=this.actual.val())===expected; 5 | }, 6 | toMatchPropertiesOf:function(expected){ 7 | if($.type(expected)!=='object') 8 | return false; 9 | for(var prop in expected){ 10 | if(this.actual[prop]!==expected[prop]) 11 | return false; 12 | } 13 | return true; 14 | } 15 | }); 16 | }); 17 | -------------------------------------------------------------------------------- /spec/lib/setup.js: -------------------------------------------------------------------------------- 1 | function importGrammar(g){ 2 | for (var prop in g) { 3 | if (g.hasOwnProperty(prop)) 4 | window[prop] = g[prop]; 5 | 6 | } 7 | } 8 | 9 | importGrammar(jasmine.grammar.FeatureStory); 10 | importGrammar(jasmine.grammar.GWT); 11 | 12 | var input; 13 | beforeEach(function(){ input = $("").appendTo("body").focus(); }); 14 | afterEach(function(){ input.remove();}); 15 | -------------------------------------------------------------------------------- /src/jquery.maskedinput.js: -------------------------------------------------------------------------------- 1 | (function (factory) { 2 | if (typeof define === 'function' && define.amd) { 3 | // AMD. Register as an anonymous module. 4 | define(['jquery'], factory); 5 | } else if (typeof exports === 'object') { 6 | // Node/CommonJS 7 | factory(require('jquery')); 8 | } else { 9 | // Browser globals 10 | factory(jQuery); 11 | } 12 | }(function ($) { 13 | 14 | var ua = navigator.userAgent, 15 | iPhone = /iphone/i.test(ua), 16 | chrome = /chrome/i.test(ua), 17 | android = /android/i.test(ua), 18 | caretTimeoutId; 19 | 20 | $.mask = { 21 | //Predefined character definitions 22 | definitions: { 23 | '9': "[0-9]", 24 | 'a': "[A-Za-z]", 25 | '*': "[A-Za-z0-9]" 26 | }, 27 | autoclear: true, 28 | dataName: "rawMaskFn", 29 | placeholder: '_' 30 | }; 31 | 32 | $.fn.extend({ 33 | //Helper Function for Caret positioning 34 | caret: function(begin, end) { 35 | var range; 36 | 37 | if (this.length === 0 || this.is(":hidden") || this.get(0) !== document.activeElement) { 38 | return; 39 | } 40 | 41 | if (typeof begin == 'number') { 42 | end = (typeof end === 'number') ? end : begin; 43 | return this.each(function() { 44 | if (this.setSelectionRange) { 45 | this.setSelectionRange(begin, end); 46 | } else if (this.createTextRange) { 47 | range = this.createTextRange(); 48 | range.collapse(true); 49 | range.moveEnd('character', end); 50 | range.moveStart('character', begin); 51 | range.select(); 52 | } 53 | }); 54 | } else { 55 | if (this[0].setSelectionRange) { 56 | begin = this[0].selectionStart; 57 | end = this[0].selectionEnd; 58 | } else if (document.selection && document.selection.createRange) { 59 | range = document.selection.createRange(); 60 | begin = 0 - range.duplicate().moveStart('character', -100000); 61 | end = begin + range.text.length; 62 | } 63 | return { begin: begin, end: end }; 64 | } 65 | }, 66 | unmask: function() { 67 | return this.trigger("unmask"); 68 | }, 69 | mask: function(mask, settings) { 70 | var input, 71 | defs, 72 | tests, 73 | partialPosition, 74 | firstNonMaskPos, 75 | lastRequiredNonMaskPos, 76 | len, 77 | oldVal; 78 | 79 | if (!mask && this.length > 0) { 80 | input = $(this[0]); 81 | var fn = input.data($.mask.dataName) 82 | return fn?fn():undefined; 83 | } 84 | 85 | settings = $.extend({ 86 | autoclear: $.mask.autoclear, 87 | placeholder: $.mask.placeholder, // Load default placeholder 88 | completed: null 89 | }, settings); 90 | 91 | 92 | defs = $.mask.definitions; 93 | tests = []; 94 | partialPosition = len = mask.length; 95 | firstNonMaskPos = null; 96 | 97 | mask = String(mask); 98 | 99 | $.each(mask.split(""), function(i, c) { 100 | if (c == '?') { 101 | len--; 102 | partialPosition = i; 103 | } else if (defs[c]) { 104 | tests.push(new RegExp(defs[c])); 105 | if (firstNonMaskPos === null) { 106 | firstNonMaskPos = tests.length - 1; 107 | } 108 | if(i < partialPosition){ 109 | lastRequiredNonMaskPos = tests.length - 1; 110 | } 111 | } else { 112 | tests.push(null); 113 | } 114 | }); 115 | 116 | return this.trigger("unmask").each(function() { 117 | var input = $(this), 118 | buffer = $.map( 119 | mask.split(""), 120 | function(c, i) { 121 | if (c != '?') { 122 | return defs[c] ? getPlaceholder(i) : c; 123 | } 124 | }), 125 | defaultBuffer = buffer.join(''), 126 | focusText = input.val(); 127 | 128 | function tryFireCompleted(){ 129 | if (!settings.completed) { 130 | return; 131 | } 132 | 133 | for (var i = firstNonMaskPos; i <= lastRequiredNonMaskPos; i++) { 134 | if (tests[i] && buffer[i] === getPlaceholder(i)) { 135 | return; 136 | } 137 | } 138 | settings.completed.call(input); 139 | } 140 | 141 | function getPlaceholder(i){ 142 | if(i < settings.placeholder.length) 143 | return settings.placeholder.charAt(i); 144 | return settings.placeholder.charAt(0); 145 | } 146 | 147 | function seekNext(pos) { 148 | while (++pos < len && !tests[pos]); 149 | return pos; 150 | } 151 | 152 | function seekPrev(pos) { 153 | while (--pos >= 0 && !tests[pos]); 154 | return pos; 155 | } 156 | 157 | function shiftL(begin,end) { 158 | var i, 159 | j; 160 | 161 | if (begin<0) { 162 | return; 163 | } 164 | 165 | for (i = begin, j = seekNext(end); i < len; i++) { 166 | if (tests[i]) { 167 | if (j < len && tests[i].test(buffer[j])) { 168 | buffer[i] = buffer[j]; 169 | buffer[j] = getPlaceholder(j); 170 | } else { 171 | break; 172 | } 173 | 174 | j = seekNext(j); 175 | } 176 | } 177 | writeBuffer(); 178 | input.caret(Math.max(firstNonMaskPos, begin)); 179 | } 180 | 181 | function shiftR(pos) { 182 | var i, 183 | c, 184 | j, 185 | t; 186 | 187 | for (i = pos, c = getPlaceholder(pos); i < len; i++) { 188 | if (tests[i]) { 189 | j = seekNext(i); 190 | t = buffer[i]; 191 | buffer[i] = c; 192 | if (j < len && tests[j].test(t)) { 193 | c = t; 194 | } else { 195 | break; 196 | } 197 | } 198 | } 199 | } 200 | 201 | function androidInputEvent(e) { 202 | var curVal = input.val(); 203 | var pos = input.caret(); 204 | if (oldVal && oldVal.length && oldVal.length > curVal.length ) { 205 | // a deletion or backspace happened 206 | checkVal(true); 207 | while (pos.begin > 0 && !tests[pos.begin-1]) 208 | pos.begin--; 209 | if (pos.begin === 0) 210 | { 211 | while (pos.begin < firstNonMaskPos && !tests[pos.begin]) 212 | pos.begin++; 213 | } 214 | input.caret(pos.begin,pos.begin); 215 | } else { 216 | var pos2 = checkVal(true); 217 | var lastEnteredValue = curVal.charAt(pos.begin); 218 | if (pos.begin < len){ 219 | if(!tests[pos.begin]){ 220 | pos.begin++; 221 | if(tests[pos.begin].test(lastEnteredValue)){ 222 | pos.begin++; 223 | } 224 | }else{ 225 | if(tests[pos.begin].test(lastEnteredValue)){ 226 | pos.begin++; 227 | } 228 | } 229 | } 230 | input.caret(pos.begin,pos.begin); 231 | } 232 | tryFireCompleted(); 233 | } 234 | 235 | 236 | function blurEvent(e) { 237 | checkVal(); 238 | 239 | if (input.val() != focusText) 240 | input.change(); 241 | } 242 | 243 | function keydownEvent(e) { 244 | if (input.prop("readonly")){ 245 | return; 246 | } 247 | 248 | var k = e.which || e.keyCode, 249 | pos, 250 | begin, 251 | end; 252 | oldVal = input.val(); 253 | //backspace, delete, and escape get special treatment 254 | if (k === 8 || k === 46 || (iPhone && k === 127)) { 255 | pos = input.caret(); 256 | begin = pos.begin; 257 | end = pos.end; 258 | 259 | if (end - begin === 0) { 260 | begin=k!==46?seekPrev(begin):(end=seekNext(begin-1)); 261 | end=k===46?seekNext(end):end; 262 | } 263 | clearBuffer(begin, end); 264 | shiftL(begin, end - 1); 265 | 266 | e.preventDefault(); 267 | } else if( k === 13 ) { // enter 268 | blurEvent.call(this, e); 269 | } else if (k === 27) { // escape 270 | input.val(focusText); 271 | input.caret(0, checkVal()); 272 | e.preventDefault(); 273 | } 274 | } 275 | 276 | function keypressEvent(e) { 277 | if (input.prop("readonly")){ 278 | return; 279 | } 280 | 281 | var k = e.which || e.keyCode, 282 | pos = input.caret(), 283 | p, 284 | c, 285 | next; 286 | 287 | if (e.ctrlKey || e.altKey || e.metaKey || k < 32) {//Ignore 288 | return; 289 | } else if ( k && k !== 13 ) { 290 | if (pos.end - pos.begin !== 0){ 291 | clearBuffer(pos.begin, pos.end); 292 | shiftL(pos.begin, pos.end-1); 293 | } 294 | 295 | p = seekNext(pos.begin - 1); 296 | if (p < len) { 297 | c = String.fromCharCode(k); 298 | if (tests[p].test(c)) { 299 | shiftR(p); 300 | 301 | buffer[p] = c; 302 | writeBuffer(); 303 | next = seekNext(p); 304 | 305 | if(android){ 306 | //Path for CSP Violation on FireFox OS 1.1 307 | var proxy = function() { 308 | $.proxy($.fn.caret,input,next)(); 309 | }; 310 | 311 | setTimeout(proxy,0); 312 | }else{ 313 | input.caret(next); 314 | } 315 | if(pos.begin <= lastRequiredNonMaskPos){ 316 | tryFireCompleted(); 317 | } 318 | } 319 | } 320 | e.preventDefault(); 321 | } 322 | } 323 | 324 | function clearBuffer(start, end) { 325 | var i; 326 | for (i = start; i < end && i < len; i++) { 327 | if (tests[i]) { 328 | buffer[i] = getPlaceholder(i); 329 | } 330 | } 331 | } 332 | 333 | function writeBuffer() { input.val(buffer.join('')); } 334 | 335 | function checkVal(allow) { 336 | //try to place characters where they belong 337 | var test = input.val(), 338 | lastMatch = -1, 339 | i, 340 | c, 341 | pos; 342 | 343 | for (i = 0, pos = 0; i < len; i++) { 344 | if (tests[i]) { 345 | buffer[i] = getPlaceholder(i); 346 | while (pos++ < test.length) { 347 | c = test.charAt(pos - 1); 348 | if (tests[i].test(c)) { 349 | buffer[i] = c; 350 | lastMatch = i; 351 | break; 352 | } 353 | } 354 | if (pos > test.length) { 355 | clearBuffer(i + 1, len); 356 | break; 357 | } 358 | } else { 359 | if (buffer[i] === test.charAt(pos)) { 360 | pos++; 361 | } 362 | if( i < partialPosition){ 363 | lastMatch = i; 364 | } 365 | } 366 | } 367 | if (allow) { 368 | writeBuffer(); 369 | } else if (lastMatch + 1 < partialPosition) { 370 | if (settings.autoclear || buffer.join('') === defaultBuffer) { 371 | // Invalid value. Remove it and replace it with the 372 | // mask, which is the default behavior. 373 | if(input.val()) input.val(""); 374 | clearBuffer(0, len); 375 | } else { 376 | // Invalid value, but we opt to show the value to the 377 | // user and allow them to correct their mistake. 378 | writeBuffer(); 379 | } 380 | } else { 381 | writeBuffer(); 382 | input.val(input.val().substring(0, lastMatch + 1)); 383 | } 384 | return (partialPosition ? i : firstNonMaskPos); 385 | } 386 | 387 | input.data($.mask.dataName,function(){ 388 | return $.map(buffer, function(c, i) { 389 | return tests[i]&&c!=getPlaceholder(i) ? c : null; 390 | }).join(''); 391 | }); 392 | 393 | 394 | input 395 | .one("unmask", function() { 396 | input 397 | .off(".mask") 398 | .removeData($.mask.dataName); 399 | }) 400 | .on("focus.mask", function() { 401 | if (input.prop("readonly")){ 402 | return; 403 | } 404 | 405 | clearTimeout(caretTimeoutId); 406 | var pos; 407 | 408 | focusText = input.val(); 409 | 410 | pos = checkVal(); 411 | 412 | caretTimeoutId = setTimeout(function(){ 413 | if(input.get(0) !== document.activeElement){ 414 | return; 415 | } 416 | writeBuffer(); 417 | if (pos == mask.replace("?","").length) { 418 | input.caret(0, pos); 419 | } else { 420 | input.caret(pos); 421 | } 422 | }, 10); 423 | }) 424 | .on("blur.mask", blurEvent) 425 | .on("keydown.mask", keydownEvent) 426 | .on("keypress.mask", keypressEvent) 427 | .on("input.mask paste.mask", function() { 428 | if (input.prop("readonly")){ 429 | return; 430 | } 431 | 432 | setTimeout(function() { 433 | var pos=checkVal(true); 434 | input.caret(pos); 435 | tryFireCompleted(); 436 | }, 0); 437 | }); 438 | if (chrome && android) 439 | { 440 | input 441 | .off('input.mask') 442 | .on('input.mask', androidInputEvent); 443 | } 444 | checkVal(); //Perform initial check for existing values 445 | }); 446 | } 447 | }); 448 | })); 449 | --------------------------------------------------------------------------------