├── .gitignore ├── index.html ├── package.json ├── test ├── cases │ ├── test.js │ ├── misc.js │ ├── literals.js │ ├── states.js │ ├── following.js │ ├── flags.js │ ├── optional.js │ ├── sequence.js │ ├── any.js │ ├── macros.js │ ├── backrefs.js │ ├── or.js │ ├── alt_syntax.js │ ├── capture.js │ ├── repeat.js │ └── readme_cases.js ├── index.html └── resources │ ├── qunit.css │ └── qunit.js ├── .jshintrc ├── tasks └── node_check.js ├── API.md ├── Gruntfile.js ├── License.md ├── TODO.md ├── Readme.md └── regex.js /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | *.swp 3 | *~ 4 | *.orig 5 | regex.min.js 6 | regex.min.map 7 | -------------------------------------------------------------------------------- /index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Loaded. 8 | 9 | 10 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "js-regex", 3 | "devDependencies": { 4 | "grunt": "~0.4.1", 5 | "grunt-contrib-jshint": "~0.6.3", 6 | "grunt-contrib-qunit": "~0.2.2", 7 | "grunt-contrib-uglify": "~0.2.2" 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /test/cases/test.js: -------------------------------------------------------------------------------- 1 | /*global test,ok,regex,module*/ 2 | 3 | module('rb.test'); 4 | 5 | test('can test', function () { 6 | 'use strict'; 7 | ok(regex().literals('a').test('a')); 8 | ok(!regex().literals('b').test('a')); 9 | }); 10 | -------------------------------------------------------------------------------- /test/cases/misc.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,module,ok*/ 2 | 3 | module('miscellaneous tests'); 4 | 5 | test('call passes along args, too', function () { 6 | 'use strict'; 7 | var t1 = {}; 8 | var t2 = {}; 9 | var re = regex(); 10 | function toTest(rb, test1, test2) { 11 | ok(t1 === test1); 12 | ok(t2 === test2); 13 | ok(rb === re); 14 | } 15 | re.call(toTest, t1, t2); 16 | }); 17 | -------------------------------------------------------------------------------- /test/cases/literals.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module*/ 2 | 3 | module('literals'); 4 | 5 | test('.call and .literals()', function () { 6 | 'use strict'; 7 | 8 | regex() 9 | .literals('a') 10 | .call(function (rb) { 11 | strictEqual(rb.peek(), 'a'); 12 | }) 13 | .literals('b') 14 | .call(function (rb) { 15 | strictEqual(rb.peek(), 'ab'); 16 | }); 17 | 18 | }); 19 | -------------------------------------------------------------------------------- /.jshintrc: -------------------------------------------------------------------------------- 1 | { 2 | "browser": true, 3 | "esnext": true, 4 | "bitwise": true, 5 | "curly": true, 6 | "eqeqeq": true, 7 | "immed": true, 8 | "indent": 4, 9 | "latedef": true, 10 | "newcap": true, 11 | "noarg": true, 12 | "quotmark": "single", 13 | "regexp": true, 14 | "undef": true, 15 | "unused": "vars", 16 | "strict": true, 17 | "trailing": true, 18 | "smarttabs": true, 19 | "eqnull": true, 20 | "browser": false, 21 | "devel": false, 22 | "globals": {} 23 | } 24 | -------------------------------------------------------------------------------- /test/cases/states.js: -------------------------------------------------------------------------------- 1 | /*global test,ok,regex,strictEqual,module*/ 2 | 3 | module('direct state tests'); 4 | 5 | test('has the fn', function () { 6 | 'use strict'; 7 | ok(regex._identifyState); 8 | }); 9 | 10 | test('basic states', function () { 11 | 'use strict'; 12 | strictEqual(regex._identifyState(''), 'STATE_EMPTY'); 13 | strictEqual(regex._identifyState('a'), 'STATE_CHARACTER'); 14 | }); 15 | 16 | test('((ab){2}) gives closedgroup state', function () { 17 | 'use strict'; 18 | strictEqual(regex._identifyState('((ab){2})'), 'STATE_CLOSEDGROUP'); 19 | }); 20 | -------------------------------------------------------------------------------- /test/cases/following.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module,ok*/ 2 | 3 | module('following'); 4 | 5 | test('thing Im gonna mention in talk', function () { 6 | 'use strict'; 7 | regex().addMacro('dept-code', regex.either('SH', 'AB', 'DHS')) 8 | .macro('dept-code').capture('entryDept') 9 | .literals('->') 10 | .notFollowedBy().reference('entryDept').end() 11 | .macro('dept-code').capture('exitDept') 12 | .call(function (rb) { 13 | strictEqual(rb.peek(), '(SH|AB|DHS)->(?!\\1)(SH|AB|DHS)'); 14 | ok(!rb.test('SH->SH')); 15 | }); 16 | }); 17 | -------------------------------------------------------------------------------- /tasks/node_check.js: -------------------------------------------------------------------------------- 1 | 2 | module.exports = function(grunt) { 3 | 'use strict'; 4 | 5 | // Just a smoke test to make sure it loads in node 6 | grunt.registerTask('quick_node_check', function () { 7 | function check(result, expected) { 8 | if (result !== expected) { 9 | grunt.fail.warn('result: ' + result + ' was not as expected: ' + expected); 10 | } 11 | } 12 | 13 | var result; 14 | var regex = require('../regex'); 15 | 16 | result = regex() 17 | .literals('aaa') 18 | .peek(); 19 | 20 | check(result, 'aaa'); 21 | }); 22 | 23 | }; 24 | -------------------------------------------------------------------------------- /API.md: -------------------------------------------------------------------------------- 1 | 2 | Functions callable on a `regex()` 3 | 4 | regex#call 5 | regex#peek 6 | regex#literal(literal) 7 | regex#literals(literals) 8 | regex#macro 9 | regex#capture 10 | regex#repeat -- you know, like `*`, `{1,}`, etc 11 | regex#optional -- (like repeat, modifies last term, making it optional) 12 | regex#followedBy(literals) 13 | regex#notFollowedBy(literals) 14 | regex#anyFrom(char1, char2) 15 | regex#noneFrom(char1, char2) 16 | regex#any(literals) 17 | regex#none(literals) 18 | regex#sequence -- starts a simple group, provides `endSequence` 19 | regex#or -- starts an either group, provides `endOr` 20 | regex#flags... -- special literals, like `.`, `\d`, etc 21 | 22 | -------------------------------------------------------------------------------- /test/cases/flags.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module*/ 2 | 3 | module('flags'); 4 | 5 | test('add some basic flags', function () { 6 | 'use strict'; 7 | 8 | regex() 9 | .flags.dot() 10 | .call(function (rb) { 11 | strictEqual(rb.peek(), '.'); 12 | }) 13 | .flags.tab() 14 | .call(function (rb) { 15 | strictEqual(rb.peek(), '.\\t'); 16 | }); 17 | 18 | }); 19 | 20 | test('used from the root context', function () { 21 | 'use strict'; 22 | 23 | regex() 24 | .sequence( 25 | 'a', 26 | regex.flags.digit()) 27 | .call(function (rb) { 28 | strictEqual(rb.peek(), 'a\\d'); 29 | }); 30 | }); 31 | -------------------------------------------------------------------------------- /Gruntfile.js: -------------------------------------------------------------------------------- 1 | 2 | module.exports = function (grunt) { 3 | 'use strict'; 4 | 5 | var jshintOptions = grunt.file.readJSON('.jshintrc'); 6 | 7 | grunt.initConfig({ 8 | uglify: { 9 | options: { 10 | sourceMap: 'regex.min.map', 11 | preserveComments: 'some', 12 | }, 13 | 'regex.min.js': 'regex.js' 14 | }, 15 | qunit: { 16 | all: 'test/index.html' 17 | }, 18 | jshint: { 19 | options: jshintOptions, 20 | src: 'regex.js', 21 | tests: 'test/cases/**/*.js' 22 | }, 23 | }); 24 | 25 | grunt.registerTask('default', [ 26 | 'jshint', 27 | 'qunit', 28 | 'quick_node_check', 29 | 'uglify' 30 | ]); 31 | 32 | grunt.loadTasks('tasks'); 33 | grunt.loadNpmTasks('grunt-contrib-jshint'); 34 | grunt.loadNpmTasks('grunt-contrib-qunit'); 35 | grunt.loadNpmTasks('grunt-contrib-uglify'); 36 | 37 | }; 38 | 39 | -------------------------------------------------------------------------------- /test/cases/optional.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module,ok*/ 2 | 3 | module('optional()'); 4 | 5 | test('non-optional() call doesnt get wrapped unnecessarily', function () { 6 | 'use strict'; 7 | regex() 8 | .literal('?') 9 | .repeat(2) 10 | .call(function (rb) { 11 | strictEqual(rb.peek(), '\\?{2,}'); 12 | }); 13 | }); 14 | 15 | test('marking empty obj as optional gives readable error', function () { 16 | 'use strict'; 17 | try { 18 | regex().optional(); 19 | ok(false, 'regex didnt trigger an error'); 20 | } catch (e) { 21 | // feel free to change the message - something should do it, though 22 | strictEqual(e.message, 'nothing to mark as optional'); 23 | } 24 | }); 25 | 26 | test('repeating an optional requires non-capture', function () { 27 | 'use strict'; 28 | regex() 29 | .literals('?').optional().repeat() 30 | .call(function (rb) { 31 | strictEqual(rb.peek(), '(?:\\??)*'); 32 | }); 33 | }); 34 | -------------------------------------------------------------------------------- /License.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2013 Brian Wyant 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /test/cases/sequence.js: -------------------------------------------------------------------------------- 1 | /*global regex,test,strictEqual,module*/ 2 | 3 | module('sequence() cases'); 4 | 5 | test('basic usage', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | result = regex() 11 | .sequence() 12 | .literals('abc') 13 | .call(function (rb) { 14 | strictEqual(rb.peek(), 'abc'); 15 | }) 16 | .literals('def') 17 | .call(function (rb) { 18 | strictEqual(rb.peek(), 'abcdef'); 19 | }) 20 | .endSequence() 21 | .peek(); 22 | 23 | strictEqual(result, 'abcdef'); 24 | 25 | }); 26 | 27 | test('sequence toTerm preserves term type', function () { 28 | 'use strict'; 29 | 30 | regex() 31 | .sequence( 32 | regex.either( 33 | 'a', 34 | 'b') 35 | .call(function (rb) { 36 | strictEqual(rb.peek(), 'a|b'); 37 | }) 38 | ) 39 | .call(function (rb) { 40 | strictEqual(rb.peek(), 'a|b'); 41 | }) 42 | .literals('a') 43 | .call(function (rb) { 44 | strictEqual(rb.peek(), '(?:a|b)a'); 45 | }); 46 | }); 47 | -------------------------------------------------------------------------------- /test/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | QUnit Example 6 | 7 | 8 | 9 |

10 |

11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -------------------------------------------------------------------------------- /test/cases/any.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module,ok*/ 2 | 3 | module('any()'); 4 | 5 | test('any() and none() do not confuse - chars', function () { 6 | 'use strict'; 7 | 8 | var actual, expected; 9 | 10 | actual = regex().any('a-d').peek(); 11 | expected = '[a\\-d]'; 12 | 13 | strictEqual(actual, expected, '- char should be escaped for any()'); 14 | 15 | actual = regex().none('a-d').peek(); 16 | expected = '[^a\\-d]'; 17 | 18 | strictEqual(actual, expected, '- char should be escaped for any()'); 19 | }); 20 | 21 | test('any() from dash to slash escapes them', function () { 22 | 'use strict'; 23 | 24 | regex() 25 | .anyFrom('-', '/') 26 | .call(function (rb) { 27 | strictEqual(rb.peek(), '[\\--/]'); 28 | ok(rb.test('.'), 'ascii for period is between dash and /, so should test for it correctly'); 29 | }); 30 | }); 31 | 32 | test('capturing two anys from a sequence would need non-capture', function () { 33 | 'use strict'; 34 | regex() 35 | .seq() 36 | .anyOf('ab') 37 | .anyOf('cd') 38 | .end() 39 | .call(function (rb) { 40 | strictEqual(rb.peek(), '[ab][cd]'); 41 | }) 42 | .repeat() 43 | .call(function (rb) { 44 | strictEqual(rb.peek(), '(?:[ab][cd])*'); 45 | }); 46 | }); 47 | -------------------------------------------------------------------------------- /test/cases/macros.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module*/ 2 | 3 | module('macros'); 4 | 5 | test('basic macro details with some literals', function () { 6 | 'use strict'; 7 | 8 | regex() 9 | .addMacro('macro') 10 | .literals('a') 11 | .call(function (rb) { 12 | strictEqual(rb.peek(), 'a'); 13 | }) 14 | .literals('b') 15 | .call(function (rb) { 16 | strictEqual(rb.peek(), 'ab'); 17 | }) 18 | .endMacro() 19 | .call(function (rb) { 20 | strictEqual(rb.peek(), ''); 21 | }) 22 | .macro('macro') 23 | .call(function (rb) { 24 | strictEqual(rb.peek(), 'ab'); 25 | }); 26 | 27 | }); 28 | 29 | test('making a single macro, composed of or, acts like an or', function () { 30 | 'use strict'; 31 | regex() 32 | .addMacro('macro') 33 | .either() 34 | .literals('a') 35 | .literals('b') 36 | .call(function (rb) { 37 | strictEqual(rb.peek(), 'a|b'); 38 | }) 39 | .endEither() 40 | .call(function (rb) { 41 | strictEqual(rb.peek(), 'a|b'); 42 | }) 43 | .endMacro() 44 | .macro('macro') 45 | .call(function (rb) { 46 | strictEqual(rb.peek(), 'a|b'); 47 | }) 48 | .literals('c') 49 | .call(function (rb) { 50 | strictEqual(rb.peek(), '(?:a|b)c'); 51 | }); 52 | }); 53 | 54 | test('making two macros, both act nicely', function () { 55 | 'use strict'; 56 | regex() 57 | .addMacro('m1') 58 | .literals('a') 59 | .end() 60 | .addMacro('m2') 61 | .literals('b') 62 | .end() 63 | .macro('m1').capture() 64 | .macro('m2').capture() 65 | .call(function (rb) { 66 | strictEqual(rb.peek(), '(a)(b)'); 67 | }); 68 | }); 69 | -------------------------------------------------------------------------------- /TODO.md: -------------------------------------------------------------------------------- 1 | Current Internal Structure 2 | --------------- 3 | 4 | Internal state mostly consists of: 5 | 6 | [{ 7 | type: 'term', 8 | term: 'a' 9 | }, { 10 | type: 'term', // notice how a repeat doesn't change the type? 11 | term: '(?:abc)*' 12 | }, { 13 | type: 'open_or', 14 | term: 'ab|cd' 15 | }, { 16 | type: 'term', 17 | captures: ['inner-before-1', 'inner-before-2'] 18 | term: '(abc)(def)' 19 | }, { 20 | type: 'term', // still no type changes through all these ops... 21 | captures: ['outer-with-star', 'inner-1', 'inner-2'] 22 | term: '((?:(abc)(def))*)' 23 | }] 24 | 25 | On the backlog: 26 | A backref node would just look something like `{type: 'term', backrefs: ['outer-with-star']}`. 27 | Better than the alternative of storing it as a plain string and having to postprocess the thing or something. 28 | 29 | Scratchpad 30 | ---------- 31 | 32 | A little too unrealistic, above. 33 | Having fancy backrefs like that almost seems nice, until I consider: how would I process a `.repeat()` after the following? 34 | 35 | `seq( 'abc'.capture('g1'), backref('g1'), 'def' )` 36 | `[{ term: ['(abc)', {backref: 'g1'}, 'def'] }]` 37 | 38 | Ultimately, string concatentation / modification is nice enough here, don't want to lose that. 39 | Instead: 40 | 41 | `[{ term: '(abc)\1def', captures: ['g1'] }]` 42 | 43 | And then, if someone says `.capture('g2')` after that: 44 | 45 | `[{ term: '((abc)\2def)', captures: ['g2', 'g1'] }]` 46 | 47 | The only time I think that processing backrefs in this way could cause "harm" is if it was in a char set, 48 | like `/[\1]/`, but that's already a meaningless regex, so no harm no foul. 49 | 50 | Of course, can't blindly increment either. 51 | If `\1` referenced a capture group from an earlier term, that wouldn't get updated. 52 | 53 | Perhaps it would be simplest to keep some `_captureIdx` state, and have the burden on updating that go to the few 54 | methods that would update it, like closing groups and adding captures on terms that already have captures. 55 | 56 | For above examples, fuller testcase would generate terms like: 57 | 58 | `[{ term: '(g1)', ... }, { term: '((abc)\1\3def)', captures: ['g2', 'g3'] }]` 59 | 60 | Including one backref to a thing just earlier in the seq, and one from before the seq. 61 | 62 | PS, future me: it's turtles all the way down. 63 | What if someone wants to use the alternate API form with a seq naming a backref that doesn't exist yet? 64 | 65 | -------------------------------------------------------------------------------- /test/cases/backrefs.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module,ok*/ 2 | 3 | module('backrefs'); 4 | 5 | test('can add backref in simplet case', function () { 6 | 'use strict'; 7 | regex() 8 | .literals('lit') 9 | .capture('group') 10 | .reference('group') 11 | .call(function (rb) { 12 | strictEqual(rb.peek(), '(lit)\\1'); 13 | }); 14 | }); 15 | 16 | test('can get actual idx of capture', function () { 17 | 'use strict'; 18 | regex() 19 | .literals('a').capture('g1') 20 | .literals('b').capture('g2') 21 | .reference('g2') 22 | .call(function (rb) { 23 | strictEqual(rb.peek(), '(a)(b)\\2'); 24 | strictEqual(rb.exec('abb').g2, 'b'); 25 | ok(rb.test('abb')); 26 | ok(!rb.test('aba')); 27 | ok(!rb.test('ab')); 28 | }); 29 | }); 30 | 31 | test('toTerm (closing seqs, eithers, etc) maintains the backref', function () { 32 | 'use strict'; 33 | regex() 34 | .seq() 35 | .literals('lit') 36 | .capture('group') 37 | .reference('group') 38 | .call(function (rb) { 39 | strictEqual(rb.peek(), '(lit)\\1'); 40 | }) 41 | .end() 42 | .call(function (rb) { 43 | ok(rb._terms[0].backrefs, 'wheres the backref?'); 44 | strictEqual(rb.peek(), '(lit)\\1'); 45 | }); 46 | }); 47 | 48 | test('capturing a sequence updates backreferences', function () { 49 | 'use strict'; 50 | regex() 51 | .seq() 52 | .literals('lit') 53 | .capture('innerGroup') 54 | .reference('innerGroup') 55 | .call(function (rb) { 56 | strictEqual(rb.peek(), '(lit)\\1'); 57 | }) 58 | .end() 59 | .capture('outerGroup') 60 | .call(function (rb) { 61 | strictEqual(rb.peek(), '((lit)\\2)'); 62 | strictEqual(rb.exec('litlit').innerGroup, 'lit'); 63 | strictEqual(rb.exec('litlit').outerGroup, 'litlit'); 64 | }); 65 | }); 66 | 67 | test('capturing a sequence updates ALL backrefs, for that matter', function () { 68 | 'use strict'; 69 | regex() 70 | .seq() 71 | .literals('lit') 72 | .capture('innerGroup') 73 | .reference('innerGroup') 74 | .reference('innerGroup') 75 | .call(function (rb) { 76 | strictEqual(rb.peek(), '(lit)\\1\\1'); 77 | }) 78 | .end() 79 | .capture('outerGroup') 80 | .call(function (rb) { 81 | strictEqual(rb.peek(), '((lit)\\2\\2)'); 82 | strictEqual(rb.exec('litlitlit').innerGroup, 'lit'); 83 | strictEqual(rb.exec('litlitlit').outerGroup, 'litlitlit'); 84 | }); 85 | }); 86 | 87 | test('can make a backref to capture groups from parent', function () { 88 | 'use strict'; 89 | regex() 90 | .literals('prequel').capture('beforeSeq') 91 | .seq() 92 | .reference('beforeSeq') 93 | .end() 94 | .call(function (rb) { 95 | strictEqual(rb.peek(), '(prequel)\\1'); 96 | }); 97 | }); 98 | 99 | test('backrefs to parent capture groups dont get updated on capturing', function () { 100 | 'use strict'; 101 | regex() 102 | .literals('prequel').capture('beforeSeq') 103 | .seq() 104 | .reference('beforeSeq') 105 | .end() 106 | .call(function (rb) { 107 | strictEqual(rb.peek(), '(prequel)\\1'); 108 | }) 109 | .capture() 110 | .call(function (rb) { 111 | strictEqual(rb.peek(), '(prequel)(\\1)'); 112 | }); 113 | }); 114 | -------------------------------------------------------------------------------- /test/cases/or.js: -------------------------------------------------------------------------------- 1 | /*global regex,test,strictEqual,module*/ 2 | 3 | module('or() cases'); 4 | 5 | test('basic usage', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | result = regex() 11 | .or() 12 | .literals('abc') 13 | .call(function (rb) { 14 | strictEqual(rb.peek(), 'abc'); 15 | }) 16 | .literals('def') 17 | .call(function (rb) { 18 | strictEqual(rb.peek(), 'abc|def'); 19 | }) 20 | .endOr() 21 | .peek(); 22 | 23 | strictEqual(result, 'abc|def'); 24 | 25 | }); 26 | 27 | test('literals before and after', function () { 28 | 'use strict'; 29 | 30 | var result; 31 | 32 | result = regex() 33 | .literal('a') 34 | .or() 35 | .literal('b') 36 | .literal('c') 37 | .endOr() 38 | .peek(); 39 | 40 | strictEqual(result, 'a(?:b|c)', 'before'); 41 | 42 | result = regex() 43 | .or() 44 | .literal('b') 45 | .literal('c') 46 | .endOr() 47 | .literal('d') 48 | .peek(); 49 | 50 | strictEqual(result, '(?:b|c)d', 'after'); 51 | 52 | result = regex() 53 | .literal('a') 54 | .or() 55 | .literal('b') 56 | .literal('c') 57 | .endOr() 58 | .literal('d') 59 | .peek(); 60 | 61 | strictEqual(result, 'a(?:b|c)d', 'both before and after'); 62 | 63 | }); 64 | 65 | test('literals before and after, but no wrap needed', function () { 66 | 'use strict'; 67 | 68 | var result; 69 | 70 | result = regex() 71 | .literal('a') 72 | .or() 73 | .literal('b') 74 | .endOr() 75 | .peek(); 76 | 77 | strictEqual(result, 'ab', 'lit before'); 78 | 79 | result = regex() 80 | .or() 81 | .literal('b') 82 | .endOr() 83 | .literal('c') 84 | .peek(); 85 | 86 | strictEqual(result, 'bc', 'lit after'); 87 | 88 | result = regex() 89 | .literal('a') 90 | .or() 91 | .literal('b') 92 | .endOr() 93 | .literal('c') 94 | .peek(); 95 | 96 | strictEqual(result, 'abc', 'lit before and after'); 97 | }); 98 | 99 | test('capturing or()', function () { 100 | 'use strict'; 101 | 102 | var result; 103 | 104 | result = regex() 105 | .literals('a') 106 | .or() 107 | .literals('bc') 108 | .endOr() 109 | .capture() 110 | .peek(); 111 | 112 | strictEqual(result, 'a(bc)', 'No non-capturing group necessary'); 113 | 114 | result = regex() 115 | .literals('a') 116 | .or() 117 | .literals('bc') 118 | .literals('jk') 119 | .endOr() 120 | .capture() 121 | .peek(); 122 | 123 | strictEqual(result, 'a(bc|jk)', 'No non-capturing group necessary'); 124 | }); 125 | 126 | test('or() with single or term reports as such', function () { 127 | 'use strict'; 128 | regex() 129 | .or() 130 | .or() 131 | .literals('a') 132 | .literals('b') 133 | .end() 134 | .call(function (rb) { 135 | strictEqual(rb.peek(), 'a|b'); 136 | }) 137 | .end() 138 | .call(function (rb) { 139 | strictEqual(rb.peek(), 'a|b'); 140 | }) 141 | .literals('c') 142 | .call(function (rb) { 143 | strictEqual(rb.peek(), '(?:a|b)c'); 144 | }); 145 | }); 146 | 147 | test('recursively entering ors doesnt behave oddly', function () { 148 | 'use strict'; 149 | regex() 150 | .or() 151 | .literals('a') 152 | .or() 153 | .literals('a') 154 | .literals('b') 155 | .call(function (rb) { 156 | strictEqual(rb.peek(), 'a|b'); 157 | }) 158 | .end() 159 | .call(function (rb) { 160 | strictEqual(rb.peek(), 'a|(?:a|b)'); 161 | }) 162 | .end() 163 | .call(function (rb) { 164 | strictEqual(rb.peek(), 'a|(?:a|b)'); 165 | }) 166 | .literals('a') 167 | .call(function (rb) { 168 | strictEqual(rb.peek(), '(?:a|(?:a|b))a'); 169 | }); 170 | }); 171 | 172 | test('calling or without doing anything is basically ignored', function () { 173 | 'use strict'; 174 | regex() 175 | .or().call(function () {}).end() 176 | .literals('a') 177 | .call(function (rb) { 178 | strictEqual(rb.peek(), 'a'); 179 | }); 180 | }); 181 | -------------------------------------------------------------------------------- /test/cases/alt_syntax.js: -------------------------------------------------------------------------------- 1 | /*global module,test,regex,ok,strictEqual,module*/ 2 | 3 | module('Alternate usage patterns'); 4 | 5 | test('Functions from root', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | ok(!regex.literal, 'No use for regex.literal function; so doesn\'t exist.'); 11 | ok(!regex.literals, 'No use for regex.literals function; so doesn\'t exist.'); 12 | 13 | ok(regex.any, 'regex.any exists'); 14 | 15 | result = regex 16 | .any('defg') 17 | .peek(); 18 | 19 | strictEqual(result, '[defg]', 'any() able to be called outside of regex'); 20 | 21 | var any = regex.any; 22 | 23 | result = any('defg').peek(); 24 | 25 | strictEqual(result, '[defg]', 'any() doesn\'t use this'); 26 | 27 | ok(regex.sequence, 'regex.sequence exists'); 28 | ok(regex.seq === regex.sequence, 'regex.seq is alias for regex.sequence'); 29 | 30 | result = regex 31 | .sequence().literals('a').any('abc').endSequence() 32 | .peek(); 33 | 34 | strictEqual(result, 'a[abc]', 'sequence() able to be called outside of regex'); 35 | 36 | var sequence = regex.sequence; 37 | 38 | result = sequence('a', regex.any('abc')) 39 | .peek(); 40 | 41 | strictEqual(result, 'a[abc]', 'sequence() doesn\'t use this'); 42 | 43 | ok(regex.or, 'regex.or exists'); 44 | ok(regex.or === regex.either, 'regex.or is alias for regex.either'); 45 | 46 | result = regex.or().literals('abc').literals('def').endOr().peek(); 47 | 48 | strictEqual(result, 'abc|def', 'or() able to be called outside of regex'); 49 | 50 | var or = regex.or; 51 | 52 | result = or('abc', 'def').peek(); 53 | 54 | strictEqual(result, 'abc|def', 'or() doesn\'t use this'); 55 | 56 | ok(regex.flags, 'regex.flags exists'); 57 | 58 | result = regex.flags.digit().peek(); 59 | 60 | strictEqual(result, '\\d', 'flags.digit() able to be called outside of regex'); 61 | 62 | var flags = regex.flags; 63 | 64 | result = flags('dD').peek(); 65 | 66 | strictEqual(result, '\\d\\D', 'flags(...) doesn\'t use this'); 67 | 68 | ok(regex.macro, 'regex.macro exists'); 69 | 70 | regex.addMacro('pie', 'pie'); 71 | 72 | result = regex.macro('pie').peek(); 73 | 74 | strictEqual(result, 'pie', 'macro(name) able to be called outside of regex'); 75 | 76 | var macro = regex.macro; 77 | 78 | result = macro('pie').peek(); 79 | 80 | strictEqual(result, 'pie', 'macro(name) doesn\'t use this'); 81 | 82 | ok(regex.followedBy, 'regex.followedBy exists'); 83 | ok(regex.notFollowedBy, 'regex.notFollowedBy exists'); 84 | 85 | var followedBy = regex.followedBy; 86 | 87 | result = sequence(followedBy('abc'), regex.notFollowedBy('def')).peek(); 88 | 89 | strictEqual(result, '(?=abc)(?!def)', 'can use followedBy/notFollowedBy outside of regex'); 90 | 91 | ok(regex.none, 'regex.none exists'); 92 | ok(regex.noneFrom, 'regex.noneFrom exists'); 93 | ok(regex.anyFrom, 'regex.anyFrom exists'); 94 | 95 | result = sequence(regex.none('abc'), regex.noneFrom('d', 'f'), regex.anyFrom('a', 'z')).peek(); 96 | 97 | strictEqual(result, '[^abc][^d-f][a-z]', 'can use none, noneFrom, anyFrom outside of regex'); 98 | 99 | }); 100 | 101 | test('Basics', function () { 102 | 'use strict'; 103 | 104 | var result; 105 | 106 | result = regex() 107 | .or('abc', regex.any('def')) 108 | .peek(); 109 | 110 | strictEqual(result, 'abc|[def]', 'or() with string literal and any()'); 111 | 112 | result = regex() 113 | .or().literals('abc').any('def').endOr() 114 | .peek(); 115 | 116 | strictEqual(result, 'abc|[def]', 'or() the plain way'); 117 | 118 | result = regex() 119 | .sequence('abc', 'def').repeat() 120 | .peek(); 121 | 122 | strictEqual(result, '(?:abcdef)*', 'sequence() given two string literals'); 123 | 124 | result = regex() 125 | .sequence('abc', regex.any('def')).repeat() 126 | .peek(); 127 | 128 | strictEqual(result, '(?:abc[def])*', 'sequence() given literal and any()'); 129 | 130 | result = regex() 131 | .or('abc', regex.sequence('def', regex.any('ghi'))) 132 | .peek(); 133 | 134 | strictEqual(result, 'abc|def[ghi]', 'or(lit, seq(lit, any(lit)))'); 135 | 136 | result = regex() 137 | .sequence('abc', regex.or('def', regex.any('ghi'))) 138 | .peek(); 139 | 140 | strictEqual(result, 'abc(?:def|[ghi])', 'seq(lit, or(lit, any(lit)))'); 141 | 142 | result = regex() 143 | .sequence('abc', regex.flags('dD'), regex.any('def')) 144 | .peek(); 145 | 146 | strictEqual(result, 'abc\\d\\D[def]', 'seq(lit, flags, any(lit))'); 147 | 148 | result = regex() 149 | .or('abc', regex.flags.digit(), regex.seq('def', 'ghi')) 150 | .peek(); 151 | 152 | strictEqual(result, 'abc|\\d|defghi', 'or(lit, flags.digit(), seq(lit, lit))'); 153 | 154 | result = regex() 155 | .or('abc', regex.flags.digit(), regex.seq('def', 'ghi')).repeat() 156 | .peek(); 157 | 158 | strictEqual(result, '(?:abc|\\d|defghi)*', 'or(lit, flags.digit(), seq(lit, lit)).repeat()'); 159 | 160 | }); 161 | -------------------------------------------------------------------------------- /test/resources/qunit.css: -------------------------------------------------------------------------------- 1 | /** 2 | * QUnit v1.12.0 - A JavaScript Unit Testing Framework 3 | * 4 | * http://qunitjs.com 5 | * 6 | * Copyright 2012 jQuery Foundation and other contributors 7 | * Released under the MIT license. 8 | * http://jquery.org/license 9 | */ 10 | 11 | /** Font Family and Sizes */ 12 | 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult { 14 | font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif; 15 | } 16 | 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; } 18 | #qunit-tests { font-size: smaller; } 19 | 20 | 21 | /** Resets */ 22 | 23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter { 24 | margin: 0; 25 | padding: 0; 26 | } 27 | 28 | 29 | /** Header */ 30 | 31 | #qunit-header { 32 | padding: 0.5em 0 0.5em 1em; 33 | 34 | color: #8699a4; 35 | background-color: #0d3349; 36 | 37 | font-size: 1.5em; 38 | line-height: 1em; 39 | font-weight: normal; 40 | 41 | border-radius: 5px 5px 0 0; 42 | -moz-border-radius: 5px 5px 0 0; 43 | -webkit-border-top-right-radius: 5px; 44 | -webkit-border-top-left-radius: 5px; 45 | } 46 | 47 | #qunit-header a { 48 | text-decoration: none; 49 | color: #c2ccd1; 50 | } 51 | 52 | #qunit-header a:hover, 53 | #qunit-header a:focus { 54 | color: #fff; 55 | } 56 | 57 | #qunit-testrunner-toolbar label { 58 | display: inline-block; 59 | padding: 0 .5em 0 .1em; 60 | } 61 | 62 | #qunit-banner { 63 | height: 5px; 64 | } 65 | 66 | #qunit-testrunner-toolbar { 67 | padding: 0.5em 0 0.5em 2em; 68 | color: #5E740B; 69 | background-color: #eee; 70 | overflow: hidden; 71 | } 72 | 73 | #qunit-userAgent { 74 | padding: 0.5em 0 0.5em 2.5em; 75 | background-color: #2b81af; 76 | color: #fff; 77 | text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px; 78 | } 79 | 80 | #qunit-modulefilter-container { 81 | float: right; 82 | } 83 | 84 | /** Tests: Pass/Fail */ 85 | 86 | #qunit-tests { 87 | list-style-position: inside; 88 | } 89 | 90 | #qunit-tests li { 91 | padding: 0.4em 0.5em 0.4em 2.5em; 92 | border-bottom: 1px solid #fff; 93 | list-style-position: inside; 94 | } 95 | 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running { 97 | display: none; 98 | } 99 | 100 | #qunit-tests li strong { 101 | cursor: pointer; 102 | } 103 | 104 | #qunit-tests li a { 105 | padding: 0.5em; 106 | color: #c2ccd1; 107 | text-decoration: none; 108 | } 109 | #qunit-tests li a:hover, 110 | #qunit-tests li a:focus { 111 | color: #000; 112 | } 113 | 114 | #qunit-tests li .runtime { 115 | float: right; 116 | font-size: smaller; 117 | } 118 | 119 | .qunit-assert-list { 120 | margin-top: 0.5em; 121 | padding: 0.5em; 122 | 123 | background-color: #fff; 124 | 125 | border-radius: 5px; 126 | -moz-border-radius: 5px; 127 | -webkit-border-radius: 5px; 128 | } 129 | 130 | .qunit-collapsed { 131 | display: none; 132 | } 133 | 134 | #qunit-tests table { 135 | border-collapse: collapse; 136 | margin-top: .2em; 137 | } 138 | 139 | #qunit-tests th { 140 | text-align: right; 141 | vertical-align: top; 142 | padding: 0 .5em 0 0; 143 | } 144 | 145 | #qunit-tests td { 146 | vertical-align: top; 147 | } 148 | 149 | #qunit-tests pre { 150 | margin: 0; 151 | white-space: pre-wrap; 152 | word-wrap: break-word; 153 | } 154 | 155 | #qunit-tests del { 156 | background-color: #e0f2be; 157 | color: #374e0c; 158 | text-decoration: none; 159 | } 160 | 161 | #qunit-tests ins { 162 | background-color: #ffcaca; 163 | color: #500; 164 | text-decoration: none; 165 | } 166 | 167 | /*** Test Counts */ 168 | 169 | #qunit-tests b.counts { color: black; } 170 | #qunit-tests b.passed { color: #5E740B; } 171 | #qunit-tests b.failed { color: #710909; } 172 | 173 | #qunit-tests li li { 174 | padding: 5px; 175 | background-color: #fff; 176 | border-bottom: none; 177 | list-style-position: inside; 178 | } 179 | 180 | /*** Passing Styles */ 181 | 182 | #qunit-tests li li.pass { 183 | color: #3c510c; 184 | background-color: #fff; 185 | border-left: 10px solid #C6E746; 186 | } 187 | 188 | #qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; } 189 | #qunit-tests .pass .test-name { color: #366097; } 190 | 191 | #qunit-tests .pass .test-actual, 192 | #qunit-tests .pass .test-expected { color: #999999; } 193 | 194 | #qunit-banner.qunit-pass { background-color: #C6E746; } 195 | 196 | /*** Failing Styles */ 197 | 198 | #qunit-tests li li.fail { 199 | color: #710909; 200 | background-color: #fff; 201 | border-left: 10px solid #EE5757; 202 | white-space: pre; 203 | } 204 | 205 | #qunit-tests > li:last-child { 206 | border-radius: 0 0 5px 5px; 207 | -moz-border-radius: 0 0 5px 5px; 208 | -webkit-border-bottom-right-radius: 5px; 209 | -webkit-border-bottom-left-radius: 5px; 210 | } 211 | 212 | #qunit-tests .fail { color: #000000; background-color: #EE5757; } 213 | #qunit-tests .fail .test-name, 214 | #qunit-tests .fail .module-name { color: #000000; } 215 | 216 | #qunit-tests .fail .test-actual { color: #EE5757; } 217 | #qunit-tests .fail .test-expected { color: green; } 218 | 219 | #qunit-banner.qunit-fail { background-color: #EE5757; } 220 | 221 | 222 | /** Result */ 223 | 224 | #qunit-testresult { 225 | padding: 0.5em 0.5em 0.5em 2.5em; 226 | 227 | color: #2b81af; 228 | background-color: #D2E0E6; 229 | 230 | border-bottom: 1px solid white; 231 | } 232 | #qunit-testresult .module-name { 233 | font-weight: bold; 234 | } 235 | 236 | /** Fixture */ 237 | 238 | #qunit-fixture { 239 | position: absolute; 240 | top: -10000px; 241 | left: -10000px; 242 | width: 1000px; 243 | height: 1000px; 244 | } 245 | -------------------------------------------------------------------------------- /test/cases/capture.js: -------------------------------------------------------------------------------- 1 | /*global test,strictEqual,ok,regex,module*/ 2 | 3 | module('Capture tests'); 4 | 5 | test('Basic usage', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | result = regex() 11 | .literals('a').capture('theA') 12 | .literals('b').capture('theB') 13 | .exec('ab'); 14 | 15 | strictEqual(result.match, 'ab', 'whole result captured'); 16 | strictEqual(result.theA, 'a', 'partial capture - a'); 17 | strictEqual(result.theB, 'b', 'partial capture - b'); 18 | }); 19 | 20 | test('literals captured, repeated, captured', function () { 21 | 'use strict'; 22 | 23 | var result; 24 | 25 | result = regex() 26 | .literals('aa').capture('first') 27 | .repeat().capture('second') 28 | .call(function (regb) { 29 | strictEqual(regb.peek(), '((aa)*)', 'generated nicely nested regex'); 30 | }) 31 | .exec('aaaaaa'); 32 | 33 | strictEqual(result.match, 'aaaaaa', 'whole result captured'); 34 | strictEqual(result.first, 'aa', 'partial capture - aa'); 35 | strictEqual(result.second, 'aaaaaa', 'full capture - aaaaaa'); 36 | }); 37 | 38 | test('literals captured & repeated three times', function () { 39 | 'use strict'; 40 | 41 | var result; 42 | 43 | result = regex() 44 | .literals('ab').capture('first') 45 | .repeat(2, 2).capture('second') 46 | .call(function (rb) { 47 | strictEqual(rb.peek(), '((ab){2})', 'generated right captchas - second step'); 48 | }) 49 | .repeat(2, 2).capture('third') 50 | .call(function (rb) { 51 | strictEqual(rb.peek(), '(((ab){2}){2})', 'generated right captchas - final step'); 52 | }) 53 | .exec('abababab'); 54 | 55 | strictEqual(result.match, 'abababab', 'whole result captured'); 56 | strictEqual(result.first, 'ab', 'partial capture - ab'); 57 | strictEqual(result.second, 'abab', 'partial capture - abab'); 58 | strictEqual(result.third, 'abababab', 'full capture - abababab'); 59 | }); 60 | 61 | test('literals before other literals, then captured repeated captured', function () { 62 | 'use strict'; 63 | 64 | var result; 65 | 66 | result = regex() 67 | .literals('123') 68 | .literals('abc').capture('inner') 69 | .repeat().capture('outer') 70 | .exec('123abcabcabc'); 71 | 72 | strictEqual(result.match, '123abcabcabc', 'whole string captured in match'); 73 | strictEqual(result.inner, 'abc', 'grabbed non-repeated inner portion'); 74 | strictEqual(result.outer, 'abcabcabc', 'grabbed repeated outer portion exactly'); 75 | }); 76 | 77 | // TODO honestly, I should be generating more minimal test cases than this. You want to debug this thing? 78 | test('with a sequence, lots of edge cases in one shot', function () { 79 | 'use strict'; 80 | 81 | var result; 82 | var partialBuilt; 83 | 84 | partialBuilt = regex() 85 | .literals('QUEL').capture('startbit') 86 | .sequence() 87 | .literals('abc').capture('sequence-1') 88 | .literals('def').capture('sequence-2') 89 | .endSequence() 90 | .call(function (rb) { 91 | strictEqual(rb.peek(), '(QUEL)(abc)(def)', 'generated both captures in the sequence'); 92 | }); 93 | 94 | result = 95 | partialBuilt.clone() 96 | .capture('wholeseq') 97 | .call(function (rb) { 98 | strictEqual(rb.peek(), '(QUEL)((abc)(def))', 'and further, generated the repeat and capture group'); 99 | }) 100 | .literals('POST') 101 | .exec('PREQUELabcdefPOSTQUEL'); 102 | 103 | strictEqual(result.match, 'QUELabcdefPOST', 'grabbed relevant parts defined by sequence, literals'); 104 | strictEqual(result.startbit, 'QUEL', 'grabbed precursor to sequence'); 105 | strictEqual(result['sequence-1'], 'abc', 'grabbed first part from sequence'); 106 | strictEqual(result['sequence-2'], 'def', 'grabbed second part from sequence'); 107 | strictEqual(result.wholeseq, 'abcdef', 'wholeseq got the repeated part'); 108 | 109 | result = 110 | partialBuilt.clone() 111 | .repeat().capture('repeated') 112 | .call(function (rb) { 113 | strictEqual(rb.peek(), '(QUEL)((?:(abc)(def))*)', 'generated proper capture/non-capture groups'); 114 | }) 115 | .exec('QUELabcdefabcdef'); 116 | 117 | strictEqual(result.match, 'QUELabcdefabcdef', 'variant2 | grabbed relevant parts defined by sequence, literals'); 118 | strictEqual(result.startbit, 'QUEL', 'variant2 | grabbed precursor to sequence'); 119 | strictEqual(result['sequence-1'], 'abc', 'variant2 | grabbed first part from sequence'); 120 | strictEqual(result['sequence-2'], 'def', 'variant2 | grabbed second part from sequence'); 121 | strictEqual(result.repeated, 'abcdefabcdef', 'variant2 | wholeseq got the repeated part'); 122 | 123 | // .sequence(...capture(2)).capture(1) 124 | // .either(...capture(2)).capture(1) 125 | 126 | }); 127 | 128 | test('capturing eithers and before/after', function () { 129 | 'use strict'; 130 | 131 | var result; 132 | 133 | result = regex() 134 | .literals('1').capture('prequel') 135 | .either() 136 | .literals('a').capture('theA') 137 | .literals('b').capture('theB') 138 | .call(function (rb) { 139 | strictEqual(rb.peek(), '(a)|(b)'); 140 | }) 141 | .endEither() 142 | .call(function (rb) { 143 | strictEqual(rb.peek(), '(1)(?:(a)|(b))'); 144 | }) 145 | .exec('b1a'); 146 | 147 | strictEqual(result.match, '1a'); 148 | strictEqual(result.prequel, '1'); 149 | strictEqual(result.theA, 'a'); 150 | strictEqual(result.theB, undefined); 151 | }); 152 | 153 | test('Banned uses', function () { 154 | 'use strict'; 155 | 156 | try { 157 | regex().literal('a').capture('match'); 158 | ok(false, 'should have failed'); 159 | } catch (err) { 160 | ok(true, 'Cannot use \'match\' capture group, as that is special'); 161 | } 162 | }); 163 | 164 | -------------------------------------------------------------------------------- /test/cases/repeat.js: -------------------------------------------------------------------------------- 1 | /*global test,regex,strictEqual,module*/ 2 | 3 | module('repeat() tests'); 4 | 5 | test('basics', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | result = regex() 11 | .literals('abc') 12 | .repeat() 13 | .call(function (rb) { 14 | strictEqual(rb.peek(), '(?:abc)*', 'will start out non-grouped'); 15 | }) 16 | .capture() 17 | .call(function (rb) { 18 | strictEqual(rb.peek(), '((?:abc)*)', 'but capturing would then add a group'); 19 | }); 20 | 21 | result = regex() 22 | .literals('abc') 23 | .clone() 24 | .repeat() 25 | .call(function (rb) { 26 | strictEqual(rb.peek(), '(?:abc)*', 'will start out non-grouped'); 27 | }) 28 | .clone() 29 | .capture() 30 | .call(function (rb) { 31 | strictEqual(rb.peek(), '((?:abc)*)', 'but capturing would then add a group'); 32 | }); 33 | 34 | result = regex() 35 | .literals('abc') 36 | .repeat(2) 37 | .peek(); 38 | 39 | strictEqual(result, '(?:abc){2,}'); 40 | 41 | result = regex() 42 | .literals('abc') 43 | .repeat(2, 2) 44 | .peek(); 45 | 46 | strictEqual(result, '(?:abc){2}'); 47 | 48 | result = regex() 49 | .literals('abc') 50 | .repeat(0) 51 | .peek(); 52 | 53 | strictEqual(result, '(?:abc)*'); 54 | 55 | result = regex() 56 | .literals('abc') 57 | .repeat(1) 58 | .peek(); 59 | 60 | strictEqual(result, '(?:abc)+'); 61 | 62 | result = regex() 63 | .literal('a') 64 | .repeat() 65 | .peek(); 66 | 67 | strictEqual(result, 'a*'); 68 | 69 | }); 70 | 71 | test('numbered repeating looks like a repeat', function () { 72 | 'use strict'; 73 | regex() 74 | .literals('abc') 75 | .repeat(2, 2) 76 | .call(function (rb) { 77 | strictEqual(rb.peek(), '(?:abc){2}', 'will start out non-grouped'); 78 | }) 79 | .capture() 80 | .call(function (rb) { 81 | strictEqual(rb.peek(), '((?:abc){2})', 'but capturing would then add a group'); 82 | }); 83 | }); 84 | 85 | test('preceded by every token', function () { 86 | 'use strict'; 87 | 88 | var result; 89 | 90 | result = regex() 91 | .literals('aaa').capture() 92 | .repeat() 93 | .peek(); 94 | 95 | strictEqual(result, '(aaa)*', '(aaa)*'); 96 | 97 | result = regex() 98 | .literal('a').capture() 99 | .repeat() 100 | .peek(); 101 | 102 | strictEqual(result, '(a)*', '(a)*'); 103 | 104 | result = regex() 105 | .sequence() 106 | .literal('a') 107 | .endSequence() 108 | .repeat() 109 | .peek(); 110 | 111 | strictEqual(result, 'a*', 'a*'); 112 | 113 | result = regex() 114 | .sequence() 115 | .literal('a') 116 | .literal('b') 117 | .endSequence() 118 | .repeat() 119 | .peek(); 120 | 121 | strictEqual(result, '(?:ab)*', '(?:ab)*'); 122 | 123 | result = regex() 124 | .sequence() 125 | .literal('a') 126 | .or() 127 | .literals('abc') 128 | .literals('abc') 129 | .endOr() 130 | .endSequence() 131 | .repeat() 132 | .peek(); 133 | 134 | strictEqual(result, '(?:a(?:abc|abc))*', 'sequence() with a literal() and or()'); 135 | 136 | result = regex() 137 | .sequence() 138 | .or() 139 | .literals('abc') 140 | .literals('bcd') 141 | .endOr() 142 | .endSequence() 143 | .repeat() 144 | .peek(); 145 | 146 | strictEqual(result, '(?:abc|bcd)*', 'sequence() with just an or()'); 147 | 148 | result = regex() 149 | .f.digit() 150 | .repeat() 151 | .peek(); 152 | 153 | strictEqual(result, '\\d*', 'simple star flag'); 154 | 155 | result = regex() 156 | .flags('sd') 157 | .repeat() 158 | .peek(); 159 | 160 | strictEqual(result, '(?:\\s\\d)*', 'two flags starred'); 161 | 162 | result = regex() 163 | .any('abc') 164 | .repeat() 165 | .peek(); 166 | 167 | strictEqual(result, '[abc]*', 'simple any()'); 168 | 169 | result = regex() 170 | .any() 171 | .f.digit() 172 | .literals('ab') 173 | .endAny() 174 | .repeat() 175 | .peek(); 176 | 177 | strictEqual(result, '[\\dab]*', 'slightly more interesting any()'); 178 | 179 | result = regex() 180 | .none() 181 | .f.digit() 182 | .literals('ab') 183 | .endNone() 184 | .repeat() 185 | .none('abc') 186 | .repeat() 187 | .peek(); 188 | 189 | strictEqual(result, '[^\\dab]*[^abc]*', 'double usage of none'); 190 | 191 | }); 192 | 193 | test('with macros', function () { 194 | 'use strict'; 195 | 196 | var result; 197 | 198 | regex.addMacro('lits') 199 | .literals('lits') 200 | .endMacro(); 201 | 202 | result = regex() 203 | .macro('lits') 204 | .repeat() 205 | .peek(); 206 | 207 | strictEqual(result, '(?:lits)*', 'simple literals macro'); 208 | 209 | regex.addMacro('lit') 210 | .literal('l') 211 | .endMacro(); 212 | 213 | result = regex() 214 | .macro('lit') 215 | .repeat() 216 | .peek(); 217 | 218 | strictEqual(result, 'l*', 'simple literal macro'); 219 | 220 | result = regex() 221 | .sequence() 222 | .macro('lits') 223 | .macro('lit') 224 | .macro('lits') 225 | .endSequence() 226 | .repeat() 227 | .peek(); 228 | 229 | strictEqual(result, '(?:litsllits)*', 'combo macros with sequence()'); 230 | 231 | regex.addMacro('or') 232 | .or() 233 | .literals('abc') 234 | .literals('def') 235 | .endOr() 236 | .endMacro(); 237 | 238 | result = regex() 239 | .macro('or') 240 | .repeat() 241 | .macro('lits') 242 | .repeat() 243 | .peek(); 244 | 245 | strictEqual(result, '(?:abc|def)*(?:lits)*', 'or() and lits macro combined'); 246 | 247 | regex 248 | .addMacro('followedBy') 249 | .literals('abc') 250 | .followedBy() 251 | .literals('def') 252 | .endFollowedBy() 253 | .endMacro(); 254 | 255 | result = regex() 256 | .macro('followedBy') 257 | .repeat() 258 | .peek(); 259 | 260 | strictEqual(result, '(?:abc(?=def))*', 'followedBy() based macro'); 261 | 262 | result = regex() 263 | .sequence() 264 | .literals('abc').capture() 265 | .literals('def').capture() 266 | .endSequence() 267 | .repeat().capture() 268 | .peek(); 269 | 270 | strictEqual(result, '((?:(abc)(def))*)', 'generate minimal capture, even when capturing a repeated sequence'); 271 | }); 272 | 273 | test('basic repeating twice in a row adds noncaptures', function () { 274 | 'use strict'; 275 | regex() 276 | .literals('ab') 277 | .repeat() 278 | .call(function (rb) { 279 | strictEqual(rb.peek(), '(?:ab)*'); 280 | }) 281 | .repeat() 282 | .call(function (rb) { 283 | strictEqual(rb.peek(), '(?:(?:ab)*)*'); 284 | }); 285 | }); 286 | 287 | test('numbered repeating twice in a row adds noncaptures', function () { 288 | 'use strict'; 289 | regex() 290 | .literals('ab') 291 | .repeat(2, 2) 292 | .call(function (rb) { 293 | strictEqual(rb.peek(), '(?:ab){2}'); 294 | }) 295 | .repeat(2, 2) 296 | .call(function (rb) { 297 | strictEqual(rb.peek(), '(?:(?:ab){2}){2}'); 298 | }); 299 | }); 300 | 301 | test('supports non-greedy repeats', function () { 302 | 'use strict'; 303 | regex() 304 | .literals('ab') 305 | .repeat(false) 306 | .call(function (rb) { 307 | strictEqual(rb.peek(), '(?:ab)*?'); 308 | }); 309 | regex() 310 | .literals('ab') 311 | .repeat(1, false) 312 | .call(function (rb) { 313 | strictEqual(rb.peek(), '(?:ab)+?'); 314 | }); 315 | regex() 316 | .literals('ab') 317 | .repeat(true) 318 | .call(function (rb) { 319 | strictEqual(rb.peek(), '(?:ab)*'); 320 | }); 321 | regex() 322 | .literals('ab') 323 | .repeat(1, true) 324 | .call(function (rb) { 325 | strictEqual(rb.peek(), '(?:ab)+'); 326 | }); 327 | }); 328 | -------------------------------------------------------------------------------- /Readme.md: -------------------------------------------------------------------------------- 1 | js-regex 2 | ======== 3 | 4 | What is it? 5 | ----------- 6 | 7 | js-regex is a fluent regex builder for JavaScript. Its aim is to make the writing and maintenance of complicated regexes less taxing and error-prone. 8 | 9 | ### Features 10 | 11 | js-regex has a mix of features that make it especially appealing, when compared to writing raw regexs or using other builder libraries, for building complicated regexes: 12 | 13 | * [Macros](#macros) 14 | - Macros are basically named sequences 15 | - That can be registered for a particular builder instance, or across all js-regex objects 16 | - That are added onto the current regex as a single term by using `.macro(registeredName)` 17 | * [Named Capture Groups](#named-capture-groups-and-exec) 18 | - When using exec and similar functions, you don't get an array of the matches 19 | - Instead, you get an object with the `match` property (representing the entire match of the regex) 20 | - Along with a property for each named property group you gave to `.capture(...)` 21 | * Minimal Generated Expressions 22 | - Some regex builder libraries have a habit of wrapping almost everything you add in a non-capture group (`(?:)`) 23 | - The above works, and is easy to make correct 24 | - But js-regex has the goal of not doing so whenever actually possible 25 | * [Named Backreferences](#named-backreferences) 26 | - Ignore the [pumping lemma](https://en.wikipedia.org/wiki/Pumping_lemma_for_regular_languages) with your non-regular language expressions 27 | - Backreferences, in brief, allow you to refer to a previous captured group, and say that that text has to repeat itself exactly 28 | 29 | 30 | Why? 31 | ---- 32 | 33 | Let's suppose that you've been asked to figure out why the following regex isn't working: 34 | 35 | ``` 36 | (SH|RE|MF)-((?:197[1-9]|19[89]\d|[2-9]\d{3})-(?:0[1-9]|1[012])-(?:0[1-9]|[12]\d|3[01]))-((?!0{5})\d{5}) 37 | ``` 38 | 39 | If you're experienced with regexes, it's certainly possible to gain an understanding of it, but it takes longer than it should. 40 | 41 | This is one example regex that has been built with this library; see [below](#business-logic-regex) to see this example translated into a js-regex equivalent, or simply read on to go through most of the API before jumping into the complex examples. 42 | 43 | Tests 44 | ----- 45 | 46 | In addition to the usage documented below, with a matching test suite [here](https://github.com/wyantb/js-regex/blob/master/test/cases/readme_cases.js), there's a fair number of other test cases [here](https://github.com/wyantb/js-regex/tree/master/test/cases). 47 | 48 | At the time of writing, js-regex has more test code than executable code, and this is likely to remain the case: 49 | 50 | ``` 51 | wc -l regex.js 52 | 851 regex.js 53 | 54 | wc -l test/cases/* 55 | 160 test/cases/alt_syntax.js 56 | 30 test/cases/any.js 57 | 163 test/cases/capture.js 58 | 30 test/cases/flags.js 59 | 18 test/cases/literals.js 60 | 68 test/cases/macros.js 61 | 180 test/cases/or.js 62 | 427 test/cases/readme_cases.js 63 | 299 test/cases/repeat.js 64 | 46 test/cases/sequence.js 65 | 20 test/cases/states.js 66 | 9 test/cases/test.js 67 | 1450 total 68 | ``` 69 | 70 | Usage 71 | ----- 72 | 73 | ### Simple usage with peek() 74 | 75 | ```javascript 76 | regex() 77 | .literals('abc') 78 | .peek(); // Will return 'abc' 79 | ``` 80 | 81 | ### Never stop chaining! 82 | 83 | ```javascript 84 | regex() 85 | .literals('abc') 86 | .call(function (curNode) { 87 | console.log(this === curNode); // Will print true 88 | console.log(curNode.peek()); // Will print 'abc' 89 | }) 90 | .literals('def') 91 | .call(function (curNode) { 92 | console.log(curNode.peek()); // Will print 'abcdef' 93 | }); 94 | ``` 95 | 96 | ### Special Flags 97 | 98 | ```javascript 99 | regex() 100 | .f.digit() 101 | .f.whitespace() 102 | .peek(); // Will return '\d\s' 103 | ``` 104 | 105 | ### Capture Groups 106 | 107 | ```javascript 108 | regex() 109 | .literals('aaa') 110 | .capture() 111 | .peek(); // Will return '(aaa)' 112 | ``` 113 | 114 | ### Repeating 115 | 116 | ```javascript 117 | regex() 118 | .literals('aaa') 119 | .repeat() 120 | .peek(); // Will return '(?:aaa)*' 121 | 122 | regex() 123 | .literals('aaa') 124 | .call(function (curNode) { 125 | console.log(curNode.peek()); // Will print 'aaa' 126 | }) 127 | .repeat(1, 3) 128 | .peek(); // Will return '(?:aaa){1,3}' 129 | ``` 130 | 131 | ### Simple Grouping 132 | 133 | ```javascript 134 | regex() 135 | .sequence() 136 | .literals('aaa') 137 | .f.digit() 138 | .literals('bbb') 139 | .endSequence() 140 | .repeat() 141 | .peek(); // Will return '(?:aaa\dbbb)*' 142 | 143 | regex().sequence('aaa', regex.flags.digit(), 'bbb') 144 | .repeat() 145 | .peek(); // Will return '(?:aaa\dbbb)*' 146 | 147 | ``` 148 | 149 | ### Character Sets 150 | 151 | ```javascript 152 | regex() 153 | .any('abcdefg') 154 | .peek(); // Will return '[abcdefg]' 155 | 156 | regex() 157 | .any() 158 | .literals('abc') 159 | .f.digit() 160 | .endAny() 161 | .peek(); // Will return '[abc\d]' 162 | 163 | regex() 164 | .none() 165 | .literals('abc') 166 | .f.whitespace() 167 | .endNone() 168 | .peek(); // Will return '[^abc\s]' 169 | ``` 170 | 171 | ### Or 172 | 173 | ```javascript 174 | regex() 175 | .either() 176 | .literals('abc') 177 | .literals('def') 178 | .endEither() 179 | .peek(); // Will return 'abc|def' 180 | 181 | regex() 182 | .either('abc', regex.any('def')) 183 | .peek(); // Will return 'abc|[def]' 184 | ``` 185 | 186 | ### Macros 187 | 188 | ```javascript 189 | regex.create(); // Alternate form of regex() 190 | 191 | regex 192 | .addMacro('any-quote') // Adding a global macro for single or double quote 193 | .any('\'"') 194 | .endMacro() 195 | .create() 196 | .macro('any-quote') 197 | .f.dot() 198 | .repeat() 199 | .macro('any-quote') 200 | .peek(); // Will return '['"].*['"]' 201 | 202 | regex 203 | .addMacro('quote') 204 | .any('\'"') 205 | .endMacro() 206 | .create() 207 | .addMacro('quote') // Local macros override global ones 208 | .literal('"') // Here, restricting to double quote only 209 | .endMacro() 210 | .macro('quote') 211 | .f.dot() 212 | .repeat() 213 | .macro('quote') 214 | .peek(); // Will return '".*"' 215 | ``` 216 | 217 | ### Followed By 218 | 219 | ```javascript 220 | regex() 221 | .literals('aaa') 222 | .followedBy('bbb') 223 | .peek(); // Will return 'aaa(?=bbb)' 224 | 225 | regex() 226 | .literals('ccc') 227 | .notFollowedBy('ddd') 228 | .peek(); // Will return 'ccc(?!ddd) 229 | ``` 230 | 231 | ### Named Capture Groups and Exec 232 | 233 | ```javascript 234 | regex() 235 | .flags.anything() 236 | .repeat() 237 | .capture('preamble') 238 | .either('cool!', 'awesome!') 239 | .capture('exclamation') 240 | .call(function (rb) { 241 | // Would print '(.*)(cool!|awesome!)' 242 | console.log(rb.peek()); 243 | 244 | // Would print 'this is ' 245 | console.log(rb.exec('this is cool! isn\'t it?').preamble); 246 | // Would print 'cool!' 247 | console.log(rb.exec('this is cool! isn\'t it?').exclamation); 248 | 249 | // Would print 'this is also ' 250 | console.log(rb.exec('this is also awesome!').preamble); 251 | // Would print 'awesome!' 252 | console.log(rb.exec('this is also awesome!').exclamation); 253 | }); 254 | ``` 255 | 256 | ### Named Backreferences 257 | 258 | You know how JS regular expressions are more powerful than [regular languages](https://en.wikipedia.org/wiki/Regular_language)? You can reference previous capture terms. js-regex supports this: 259 | 260 | ```javascript 261 | regex() 262 | .flags.anything() 263 | .repeat(1) 264 | .capture('anything') 265 | .literal('-') 266 | .reference('anything') 267 | .call(function (rb) { 268 | // Would print '(.+)-\1' 269 | console.log(rb.peek()); 270 | 271 | // Would print 'whatever' 272 | console.log(rb.exec('whatever-whatever').anything); 273 | 274 | // Would print false 275 | console.log(rb.test('whatever-whatev')); 276 | }); 277 | ``` 278 | 279 | 280 | Complicated Regexes 281 | ------------------- 282 | 283 | ### Example 1 284 | 285 | How quickly can you figure out what this is supposed to represent? 286 | 287 | ```javascript 288 | regex() 289 | .addMacro('0-255') 290 | .either() 291 | .sequence() 292 | .literals('25') 293 | .anyFrom('0', '5') 294 | .endSequence() 295 | .sequence() 296 | .literal('2') 297 | .anyFrom('0', '4') 298 | .anyFrom('0', '9') 299 | .endSequence() 300 | .sequence() 301 | .any('01').optional() 302 | .anyFrom('0', '9') 303 | .anyFrom('0', '9').optional() 304 | .endSequence() 305 | .endEither() 306 | .endMacro() 307 | .macro('0-255').capture() 308 | .literal('.') 309 | .macro('0-255').capture() 310 | .literal('.') 311 | .macro('0-255').capture() 312 | .literal('.') 313 | .macro('0-255').capture() 314 | .peek(); 315 | ``` 316 | 317 | (Hint: it's described [here](http://www.regular-expressions.info/examples.html), in the fourth section on the page.) 318 | 319 | (Also note: this example uses the 'verbose' usage form, always closing portions with endXXX(); the [Readme tests](https://github.com/wyantb/js-regex/blob/master/test/cases/readme_cases.js) cover the same using an alternate form) 320 | 321 | ### Business Logic Regex 322 | 323 | So our 'business logic' regex looks like this: 324 | 325 | ``` 326 | (SH|RE|MF)-((?:197[1-9]|19[89]\d|[2-9]\d{3})-(?:0[1-9]|1[012])-(?:0[1-9]|[12]\d|3[01]))-((?!0{5})\d{5}) 327 | ``` 328 | 329 | Written in human terms, that would be: one of three department codes, a dash, a YYYY-MM-DD date (after Jan 1, 1971), a dash, then a non 00000 5 digit number. 330 | 331 | In converting this regex to use js-regex, we make use of macros to define the department code, the date, and the trailing number. Note that most of this example is spent setting up the date regex - if your situation called for many dates being used in the application, the cost of setting up this most complicated portion of the regex would only need to be done once, after which it would be usable in other circumstances with no code changes, and far greater readability. 332 | 333 | Anyway, let's take a look: 334 | 335 | ```javascript 336 | regex 337 | // Setting up our macros... 338 | .addMacro('dept-prefix', regex.either('SH', 'RE', 'MF')) 339 | .addMacro('date', 340 | regex.either( 341 | regex.sequence( 342 | '197', 343 | regex.anyFrom('1', '9')), 344 | regex.sequence( 345 | '19', 346 | regex.any('89'), 347 | regex.flags.digit()), 348 | regex.sequence( 349 | regex.anyFrom('2', '9'), 350 | regex.flags.digit().repeat(3, 3))), 351 | '-', 352 | regex.either( 353 | regex.sequence( 354 | '0', 355 | regex.anyFrom('1', '9')), 356 | regex.sequence( 357 | '1', 358 | regex.any('012'))), 359 | '-', 360 | regex.either( 361 | regex.sequence( 362 | '0', 363 | regex.anyFrom('1', '9')), 364 | regex.sequence( 365 | regex.any('12'), 366 | regex.flags.digit()), 367 | regex.sequence( 368 | '3', 369 | regex.any('01')))) 370 | .addMacro('issuenum', 371 | regex.notFollowedBy() 372 | .literal('0') 373 | .repeat(5, 5), 374 | regex.flags.digit() 375 | .repeat(5, 5)) 376 | // Macros are setup, let's create our actual regex now: 377 | .create() 378 | .macro('dept-prefix').capture() 379 | .literal('-') 380 | .macro('date').capture() 381 | .literal('-') 382 | .macro('issuenum').capture() 383 | .peek(); // Returns the string shown above this code example 384 | ``` 385 | 386 | Conclusion 387 | ---------- 388 | 389 | Perhaps this library piques your interest. If so, cool! Let me know! Just make sure that nothing on [the issues page](https://github.com/wyantb/js-regex/issues) scares you before jumping in and actually using it. 390 | 391 | Really, Really Experimental Methods 392 | ----------------------------------- 393 | 394 | ### Simple Testing 395 | 396 | test() is still kinda pointless. 397 | 398 | ```javascript 399 | regex() 400 | .literal('a') 401 | .test('a'); // Will return true 402 | ``` 403 | 404 | ### Simple Replacing 405 | 406 | Needs more tests. 407 | 408 | ```javascript 409 | regex() 410 | .literals('abc') 411 | .replace('abc', function () { 412 | return 'def'; 413 | }); // Will return 'def' 414 | ``` 415 | -------------------------------------------------------------------------------- /test/cases/readme_cases.js: -------------------------------------------------------------------------------- 1 | /*global regex,test,strictEqual,ok,module*/ 2 | 3 | module('Readme examples'); 4 | 5 | test('API Demonstration', function () { 6 | 'use strict'; 7 | 8 | var result; 9 | 10 | //### Simple usage with peek() 11 | 12 | result = regex() 13 | .literals('abc') 14 | .peek(); 15 | 16 | strictEqual(result, 'abc', 'Simple abc'); 17 | 18 | //### Never stop chaining! 19 | 20 | var firstCall = false, secondCall = false; 21 | 22 | regex() 23 | .literals('abc') 24 | .call(function (curNode) { 25 | firstCall = true; 26 | ok(this === curNode, 'call uses both this and first func arg'); 27 | strictEqual(curNode.peek(), 'abc', 'Still just abc'); 28 | }) 29 | .literals('def') 30 | .call(function (curNode) { 31 | secondCall = true; 32 | strictEqual(curNode.peek(), 'abcdef', 'Added def'); 33 | }); 34 | 35 | ok(firstCall, 'Call was invoked'); 36 | ok(secondCall, 'Second call was invoked'); 37 | 38 | //### Special Flags 39 | 40 | result = regex() 41 | .f.digit() 42 | .f.whitespace() 43 | .peek(); 44 | 45 | strictEqual(result, '\\d\\s', 'Basic flags'); 46 | 47 | //### Capture Groups 48 | 49 | result = regex() 50 | .literals('aaa') 51 | .capture() 52 | .peek(); 53 | 54 | strictEqual(result, '(aaa)', 'capture()'); 55 | 56 | result = regex() 57 | .literals('aaa') 58 | .call(function (curNode) { 59 | strictEqual(curNode.peek(), 'aaa', 'Simple aaa before repeat'); 60 | }) 61 | .repeat(1, 3) 62 | .peek(); 63 | 64 | strictEqual(result, '(?:aaa){1,3}', 'repeat(1, 3)'); 65 | 66 | //### Simple Grouping 67 | 68 | result = regex() 69 | .sequence() 70 | .literals('aaa') 71 | .f.digit() 72 | .literals('bbb') 73 | .endSequence() 74 | .repeat() 75 | .peek(); // Will return '(?:aaa\dbbb)*' 76 | 77 | strictEqual(result, '(?:aaa\\dbbb)*', 'Simple grouping'); 78 | 79 | result = regex().sequence('aaa', regex.flags.digit(), 'bbb') 80 | .repeat() 81 | .peek(); // Will return '(?:aaa\dbbb)*' 82 | 83 | strictEqual(result, '(?:aaa\\dbbb)*', 'Simple grouping, alt form'); 84 | 85 | //### Character Sets 86 | 87 | result = regex() 88 | .any('abcdefg') 89 | .peek(); // Will return '[abcdefg]' 90 | 91 | strictEqual(result, '[abcdefg]', 'any()'); 92 | 93 | result = regex() 94 | .any() 95 | .literals('abc') 96 | .f.digit() 97 | .endAny() 98 | .peek(); // Will return '[abc\d]' 99 | 100 | strictEqual(result, '[abc\\d]', 'any() with f.digit()'); 101 | 102 | result = regex() 103 | .none() 104 | .literals('abc') 105 | .f.whitespace() 106 | .endNone() 107 | .peek(); // Will return '[^abc\s]' 108 | 109 | strictEqual(result, '[^abc\\s]', 'none()'); 110 | 111 | //### Or 112 | 113 | result = regex() 114 | .either() 115 | .literals('abc') 116 | .literals('def') 117 | .endEither() 118 | .peek(); // Will return 'abc|def' 119 | 120 | strictEqual(result, 'abc|def', 'either()'); 121 | 122 | result = regex() 123 | .either('abc', regex.any('def')) 124 | .peek(); // Will return 'abc|[def]' 125 | 126 | strictEqual(result, 'abc|[def]', 'either(lit, any(lit))'); 127 | 128 | //### Macros 129 | 130 | result = regex.create(); // Alternate form of regex() 131 | 132 | ok(result, 'regex.create() returns something'); 133 | 134 | result = regex 135 | .addMacro('any-quote') // Adding a global macro for single or double quote 136 | .any('\'"') 137 | .endMacro() 138 | .create() 139 | .macro('any-quote') 140 | .f.dot() 141 | .repeat() 142 | .macro('any-quote') 143 | .peek(); // Will return '['"].*['"]' 144 | 145 | strictEqual(result, '[\'"].*[\'"]', 'any-quote macro'); 146 | 147 | result = regex 148 | .addMacro('quote') 149 | .any('\'"') 150 | .endMacro() 151 | .create() 152 | .addMacro('quote') // Local macros override global ones 153 | .literal('"') // Here, restricting to double quote only 154 | .endMacro() 155 | .macro('quote') 156 | .f.dot() 157 | .repeat() 158 | .macro('quote') 159 | .peek(); // Will return '".*"' 160 | 161 | strictEqual(result, '".*"', 'local macros override global'); 162 | 163 | //### Followed By 164 | 165 | result = regex() 166 | .literals('aaa') 167 | .followedBy('bbb') 168 | .peek(); // Will return 'aaa(?=bbb)' 169 | 170 | strictEqual(result, 'aaa(?=bbb)', 'followedBy()'); 171 | 172 | result = regex() 173 | .literals('ccc') 174 | .notFollowedBy('ddd') 175 | .peek(); // Will return 'ccc(?!ddd) 176 | 177 | strictEqual(result, 'ccc(?!ddd)', 'notFollowedBy()'); 178 | }); 179 | 180 | test('Named Capture Groups & Exec', function () { 181 | 'use strict'; 182 | regex() 183 | .flags.anything() 184 | .repeat() 185 | .capture('preamble') 186 | .either('cool!', 'awesome!') 187 | .call(function (rb) { 188 | strictEqual(rb.peek(), '(.*)(?:cool!|awesome!)'); 189 | }) 190 | .capture('exclamation') 191 | .call(function (rb) { 192 | strictEqual(rb.peek(), '(.*)(cool!|awesome!)'); 193 | strictEqual(rb.exec('this is cool! isn\'t it?').match, 'this is cool!'); 194 | strictEqual(rb.exec('this is cool! isn\'t it?').preamble, 'this is '); 195 | strictEqual(rb.exec('this is cool! isn\'t it?').exclamation, 'cool!'); 196 | 197 | strictEqual(rb.exec('this is also awesome!').match, 'this is also awesome!'); 198 | strictEqual(rb.exec('this is also awesome!').preamble, 'this is also '); 199 | strictEqual(rb.exec('this is also awesome!').exclamation, 'awesome!'); 200 | }); 201 | }); 202 | 203 | test('Named Backreferences', function () { 204 | 'use strict'; 205 | regex() 206 | .flags.anything() 207 | .repeat(1) 208 | .capture('anything') 209 | .literal('-') 210 | .reference('anything') 211 | .call(function (rb) { 212 | strictEqual(rb.peek(), '(.+)-\\1'); 213 | strictEqual(rb.exec('whatever-whatever').anything, 'whatever'); 214 | ok(!rb.test('whatever-whatev')); 215 | }); 216 | }); 217 | 218 | test('Complex Examples', function () { 219 | 'use strict'; 220 | 221 | var result = ''; 222 | 223 | //### Example 1 224 | 225 | var portionWithoutQuotes = '25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?'; 226 | var portionWithQuotes = '(' + portionWithoutQuotes + ')'; 227 | result = regex() 228 | .addMacro('0-255') 229 | .either() 230 | .sequence() 231 | .literals('25') 232 | .anyFrom('0', '5') 233 | .endSequence() 234 | .sequence() 235 | .literal('2') 236 | .anyFrom('0', '4') 237 | .anyFrom('0', '9') 238 | .endSequence() 239 | .sequence() 240 | .any('01').optional() 241 | .anyFrom('0', '9') 242 | .anyFrom('0', '9').optional() 243 | .endSequence() 244 | .endEither() 245 | .endMacro() 246 | .macro('0-255') 247 | .call(function (rb) { 248 | strictEqual(rb.peek(), portionWithoutQuotes, 'invoking macro gave nice rendering'); 249 | }) 250 | .capture() 251 | .call(function (rb) { 252 | strictEqual(rb.peek(), portionWithQuotes, 'and got captured the same'); 253 | }) 254 | .literal('.') 255 | .call(function (rb) { 256 | strictEqual(rb.peek(), portionWithQuotes + '\\.', 'and didnt go crazy once a literal was added'); 257 | }) 258 | .macro('0-255') 259 | .call(function (rb) { 260 | var peeked = rb.peek(); 261 | strictEqual(peeked, portionWithQuotes + '\\.(?:' + portionWithoutQuotes + ')', 'and once second macro was added, appended in straightforward manner (though, it is a temporary TYPE_OR condition)'); 262 | }) 263 | .capture() 264 | .call(function (rb) { 265 | var peeked = rb.peek(); 266 | strictEqual(peeked, portionWithQuotes + '\\.' + portionWithQuotes, 'same with second capture'); 267 | }) 268 | .literal('.') 269 | .call(function (rb) { 270 | var peeked = rb.peek(); 271 | strictEqual(peeked, portionWithQuotes + '\\.' + portionWithQuotes + '\\.', 'same with second literal'); 272 | }) 273 | .macro('0-255').capture() 274 | .literal('.') 275 | .macro('0-255').capture() 276 | .peek(); 277 | 278 | // http://www.regular-expressions.info/examples.html 279 | var ipAddrRegex = '(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'; 280 | strictEqual(result, ipAddrRegex, 'IP Address Regex'); 281 | 282 | result = regex 283 | .addMacro('0-255', 284 | regex.either( 285 | regex.sequence( 286 | '25', 287 | regex.anyFrom('0', '5')), 288 | regex.sequence( 289 | '2', 290 | regex.anyFrom('0', '4'), 291 | regex.anyFrom('0', '9')), 292 | regex.sequence( 293 | regex.any('01').optional(), 294 | regex.anyFrom('0', '9'), 295 | regex.anyFrom('0', '9').optional()))) 296 | .create() 297 | .sequence( 298 | regex.macro('0-255').capture(), 299 | '.', 300 | regex.macro('0-255').capture(), 301 | '.', 302 | regex.macro('0-255').capture(), 303 | '.', 304 | regex.macro('0-255').capture()) 305 | .peek(); 306 | 307 | strictEqual(result, ipAddrRegex, 'IP Address, Alternate usage form'); 308 | 309 | //UNLISTED 310 | 311 | result = regex() 312 | .addMacro('dept-prefix') 313 | .either() 314 | .literals('SH') 315 | .literals('RE') 316 | .literals('MF') 317 | .endEither() 318 | .call(function (rb) { 319 | strictEqual(rb.peek(), 'SH|RE|MF'); 320 | }) 321 | .endMacro() 322 | .addMacro('date') 323 | .either() 324 | .sequence() 325 | .literals('197') 326 | .anyFrom('1', '9') 327 | .endSequence() 328 | .sequence() 329 | .literals('19') 330 | .any('89') 331 | .f.digit() 332 | .endSequence() 333 | .sequence() 334 | .anyFrom('2', '9') 335 | .f.digit().repeat(3, 3) 336 | .endSequence() 337 | .endEither() 338 | .literal('-') 339 | .either() 340 | .sequence() 341 | .literal('0') 342 | .anyFrom('1', '9') 343 | .endSequence() 344 | .sequence() 345 | .literal('1') 346 | .any('012') 347 | .endSequence() 348 | .endEither() 349 | .literal('-') 350 | .either() 351 | .sequence() 352 | .literal('0') 353 | .anyFrom('1', '9') 354 | .endSequence() 355 | .sequence() 356 | .any('12') 357 | .f.digit() 358 | .endSequence() 359 | .sequence() 360 | .literal('3') 361 | .any('01') 362 | .endSequence() 363 | .endEither() 364 | .call(function (rb) { 365 | strictEqual(rb.peek(), '(?:197[1-9]|19[89]\\d|[2-9]\\d{3})-(?:0[1-9]|1[012])-(?:0[1-9]|[12]\\d|3[01])', 'date portion of the overall macro'); 366 | }) 367 | .endMacro() 368 | .addMacro('issuenum') 369 | .notFollowedBy() 370 | .literal('0') 371 | .repeat(5, 5) 372 | .endNotFollowedBy() 373 | .f.digit() 374 | .repeat(5, 5) 375 | .call(function (rb) { 376 | strictEqual(rb.peek(), '(?!0{5})\\d{5}', 'issue number portion'); 377 | }) 378 | .endMacro() 379 | .macro('dept-prefix').capture() 380 | .literal('-') 381 | .macro('date').capture() 382 | .literal('-') 383 | .macro('issuenum').capture() 384 | .peek(); 385 | 386 | var businessLogicRegex = '(SH|RE|MF)-((?:197[1-9]|19[89]\\d|[2-9]\\d{3})-(?:0[1-9]|1[012])-(?:0[1-9]|[12]\\d|3[01]))-((?!0{5})\\d{5})'; 387 | 388 | strictEqual(result, businessLogicRegex, 'Business-like logic regex'); 389 | 390 | result = regex 391 | // Setting up our macros... 392 | .addMacro('dept-prefix', regex.either('SH', 'RE', 'MF')) 393 | .addMacro('date', 394 | regex.either( 395 | regex.sequence( 396 | '197', 397 | regex.anyFrom('1', '9')), 398 | regex.sequence( 399 | '19', 400 | regex.any('89'), 401 | regex.flags.digit()), 402 | regex.sequence( 403 | regex.anyFrom('2', '9'), 404 | regex.flags.digit().repeat(3, 3))), 405 | '-', 406 | regex.either( 407 | regex.sequence( 408 | '0', 409 | regex.anyFrom('1', '9')), 410 | regex.sequence( 411 | '1', 412 | regex.any('012'))), 413 | '-', 414 | regex.either( 415 | regex.sequence( 416 | '0', 417 | regex.anyFrom('1', '9')), 418 | regex.sequence( 419 | regex.any('12'), 420 | regex.flags.digit()), 421 | regex.sequence( 422 | '3', 423 | regex.any('01')))) 424 | .addMacro('issuenum', 425 | regex.notFollowedBy() 426 | .literal('0') 427 | .repeat(5, 5), 428 | regex.flags.digit() 429 | .repeat(5, 5)) 430 | // Macros are setup, let's create our actual regex now: 431 | .create() 432 | .macro('dept-prefix').capture() 433 | .literal('-') 434 | .macro('date').capture() 435 | .literal('-') 436 | .macro('issuenum').capture() 437 | .peek(); // Returns the string shown above this code example 438 | 439 | strictEqual(result, businessLogicRegex, 'Business-like logic regex, alternate usage form'); 440 | 441 | }); 442 | 443 | -------------------------------------------------------------------------------- /regex.js: -------------------------------------------------------------------------------- 1 | /*global define,module*/ 2 | 3 | /**! 4 | * js-regex: a chainable regex building library for Javascript. 5 | * 6 | * @author Brian Wyant 7 | * @license http://opensource.org/licenses/MIT 8 | **/ 9 | 10 | (function (root, factory) { 11 | 'use strict'; 12 | if (typeof define === 'function' && define.amd) { 13 | // AMD. Register as an anonymous module, also provide global 14 | define([], function () { 15 | /*jshint -W093*/ 16 | return (root.regex = factory()); 17 | /*jshint +W093*/ 18 | }); 19 | } else if (typeof exports === 'object') { 20 | // Node. Does not work with strict CommonJS, but 21 | // only CommonJS-like enviroments that support module.exports, 22 | // like Node. 23 | module.exports = factory(); 24 | } else { 25 | // Browser globals 26 | root.regex = factory(); 27 | } 28 | }(this, function () { 29 | 'use strict'; 30 | 31 | // ----------------------- 32 | // Root Regex 33 | // ----------------------- 34 | 35 | var regex = function () { 36 | return Object.create(RegexRoot)._init(regex); 37 | }; 38 | 39 | regex._macros = {}; 40 | regex._getMacro = function _getMacro(name) { 41 | if (!regex._macros[name]) { 42 | throw new Error('Attempted to use macro ' + name + ', which doesn\'t exist.'); 43 | } 44 | 45 | return regex._macros[name]; 46 | }; 47 | 48 | // Can use regex() or regex.create() 49 | regex.create = regex; 50 | 51 | regex.addMacro = function addMacro(name) { 52 | var macro; 53 | if (!arguments.length) { 54 | throw new Error('addMacro() must be given the name of the macro to create'); 55 | } 56 | else if (arguments.length === 1) { 57 | macro = regex._macros[name] = Object.create(RegexMacro); 58 | macro._init(regex); 59 | return macro; 60 | } 61 | else if (arguments.length > 1) { 62 | macro = regex._macros[name] = Object.create(RegexMacro); 63 | macro._init(regex); 64 | applyArgs(macro, rest(arguments)); 65 | macro.endMacro(); 66 | return regex; 67 | } 68 | }; 69 | 70 | // TODO separate logical states (some type of closed group) from concrete ones (any, star) 71 | 72 | /** catchall group state - when I know I have some kind of group, but don't care what type */ 73 | var STATE_CLOSEDGROUP = 'STATE_CLOSEDGROUP'; 74 | /** literally empty */ 75 | var STATE_EMPTY = 'STATE_EMPTY'; 76 | /** like *, or {}, or ? after a term */ 77 | var STATE_MODIFIEDTERM = 'STATE_MODIFIEDTERM'; 78 | /** [abc] - you know, character sets */ 79 | var STATE_ANY = 'STATE_ANY'; 80 | var STATE_CHARACTER = 'STATE_CHARACTER'; 81 | 82 | /** a term type, rather than identified state */ 83 | var TYPE_OR = 'TYPE_OR'; 84 | var TYPE_MULTITERM = 'TYPE_MULTITERM'; 85 | var TYPE_TERM = 'TYPE_TERM'; 86 | var TYPE_REPEAT = 'TYPE_REPEAT'; 87 | 88 | var RegexBase = {}; 89 | RegexBase._type = 'base'; 90 | 91 | RegexBase.clone = function clone() { 92 | var newRe = regex(); 93 | return deepExtend(newRe, this); 94 | }; 95 | 96 | RegexBase._initFields = function _initFields(_parent) { 97 | this._terms = []; 98 | this._parent = _parent || {}; 99 | this._macros = {}; 100 | return this; 101 | }; 102 | RegexBase._init = function _init(_parent) { 103 | this._initFields(_parent); 104 | makeFlagFns(this); 105 | return this; 106 | }; 107 | RegexBase._getMacro = function _getMacro(name) { 108 | return this._macros[name] || this._parent._getMacro(name); 109 | }; 110 | RegexBase._renderNodes = function _renderNodes() { 111 | return nodesToArray(this).join(''); 112 | }; 113 | RegexBase._toTerm = function _toTerm() { 114 | return { 115 | backrefs: orderedBackrefs(this), 116 | captures: orderedCaptures(this), 117 | term: this._renderNodes(), 118 | }; 119 | }; 120 | 121 | function typedToTerm(rb, multitermType) { 122 | if (rb._terms.length === 0) { 123 | return null; 124 | } 125 | if (rb._terms.length === 1) { 126 | return objectCopy(rb._terms[0]); 127 | } 128 | return { 129 | backrefs: orderedBackrefs(rb), 130 | captures: orderedCaptures(rb), 131 | type: multitermType, 132 | term: rb._renderNodes() 133 | }; 134 | } 135 | function nodesToArray(rb) { 136 | var parts = []; 137 | var nodes = rb._terms; 138 | for (var i = 0, len = nodes.length; i < len; i++) { 139 | var node = nodes[i]; 140 | var term = node.term; 141 | 142 | if (node.type === TYPE_OR && hasNonEmptyNeighborNode(nodes, i)) { 143 | parts.push('(?:' + term + ')'); 144 | } 145 | else { 146 | parts.push(term); 147 | } 148 | } 149 | return parts; 150 | } 151 | function addTerm(rb, term, typeOverride) { 152 | rb._terms.push({ 153 | captures: [], 154 | type: typeOverride || TYPE_TERM, 155 | term: term 156 | }); 157 | return rb; 158 | } 159 | function addBackref(rb, name) { 160 | var groupIdx = orderedCapturesWithParent(rb).indexOf(name); 161 | if (groupIdx === -1) { 162 | throw new Error('unrecognized group for backref: ' + name); 163 | } 164 | 165 | rb._terms.push({ 166 | captures: [], 167 | backrefs: [name], 168 | type: TYPE_TERM, 169 | term: '\\' + (groupIdx + 1) 170 | }); 171 | return rb; 172 | } 173 | function addBuilderTerm(rb, term) { 174 | if (term != null) { 175 | rb._terms.push(term); 176 | } 177 | return rb; 178 | } 179 | 180 | function currentTerm(rb) { 181 | if (rb._terms.length === 0) { 182 | return null; 183 | } 184 | return rb._terms[rb._terms.length - 1]; 185 | } 186 | function orderedCaptures(rb) { 187 | return flatten(pluck(rb._terms, 'captures')); 188 | } 189 | function orderedCapturesWithParent(rb) { 190 | var captures = [orderedCaptures(rb)]; 191 | if (rb._parent && rb._parent !== regex) { 192 | captures.push(orderedCapturesWithParent(rb._parent)); 193 | } 194 | return flatten(captures); 195 | } 196 | function orderedBackrefs(rb) { 197 | return flatten(pluck(rb._terms, 'backrefs')); 198 | } 199 | function wrapCurrentTerm(rb, pre, post, termType) { 200 | var curTerm = currentTerm(rb); 201 | curTerm.type = termType || TYPE_TERM; 202 | curTerm.term = pre + curTerm.term + post; 203 | return rb; 204 | } 205 | function identifyCurrentTerm(rb) { 206 | var term = currentTerm(rb); 207 | if (term == null) { 208 | return STATE_EMPTY; 209 | } 210 | return identifyState(term.term); 211 | } 212 | function addCapture(rb, capture) { 213 | var term = currentTerm(rb); 214 | var termCaptures = term.captures; 215 | var backrefs = term.backrefs; 216 | var indicesToBump, i, len; 217 | if (backrefs && backrefs.length) { 218 | var allCaptures = orderedCapturesWithParent(rb); 219 | indicesToBump = []; 220 | for (i = 0, len = backrefs.length; i < len; i++) { 221 | var backref = backrefs[i]; 222 | if (arrayContains(termCaptures, backref) && 223 | !arrayContains(pluck(indicesToBump, 'backref'), backref)) { 224 | 225 | var oldPos = allCaptures.indexOf(backref) + 1; 226 | indicesToBump.push({ 227 | backref: backref, 228 | pos: oldPos 229 | }); 230 | } 231 | } 232 | } 233 | termCaptures.unshift(capture); 234 | if (indicesToBump) { 235 | var termText = term.term; 236 | for (len = indicesToBump.length, i = len - 1; i >= 0; i--) { 237 | var indexToBump = indicesToBump[i].pos; 238 | term.term = termText.replace(new RegExp('\\\\' + indexToBump, 'g'), '\\' + (indexToBump + 1)); 239 | } 240 | } 241 | } 242 | function applyArgumentsToNode(proto, node, args) { 243 | var toApply = Object.create(proto)._init(node); 244 | applyArgs(toApply, args); 245 | return addBuilderTerm(node, toApply._toTerm()); 246 | } 247 | function applyArgumentsWithoutNode(proto, args) { 248 | var toApply = Object.create(proto)._init(regex); 249 | if (args.length) { 250 | applyArgs(toApply, args); 251 | } 252 | return toApply; 253 | } 254 | 255 | RegexBase.call = function call(callback) { 256 | var args = rest(arguments); 257 | args.unshift(this); 258 | callback.apply(this, args); 259 | return this; 260 | }; 261 | 262 | RegexBase.peek = function peek() { 263 | return this._renderNodes(this._terms); 264 | }; 265 | 266 | RegexBase.literal = function literal(character) { 267 | return addTerm(this, getNormalLiteral(character)); 268 | }; 269 | 270 | RegexBase.literals = RegexBase.then = function literals(string) { 271 | return addTerm(this, getLiterals(string)); 272 | }; 273 | 274 | RegexBase.macro = function macro(name) { 275 | var mac = this._getMacro(name); 276 | addBuilderTerm(this, mac._toTerm()); 277 | return this; 278 | }; 279 | 280 | regex.macro = function macro(name) { 281 | var reBase = Object.create(RegexBase)._init(regex); 282 | reBase.macro(name); 283 | return reBase; 284 | }; 285 | 286 | RegexBase.seq = RegexBase.sequence = function sequence() { 287 | if (!arguments.length) { 288 | return Object.create(RegexSequence)._init(this); 289 | } 290 | else { 291 | return applyArgumentsToNode(RegexSequence, this, arrayCopy(arguments)); 292 | } 293 | }; 294 | 295 | regex.seq = regex.sequence = function sequence() { 296 | return applyArgumentsWithoutNode(RegexSequence, arrayCopy(arguments)); 297 | }; 298 | 299 | RegexBase.capture = function capture(name) { 300 | if (name == null) { 301 | name = String(Math.random() * 1000000); 302 | } 303 | if (typeof name !== 'string') { 304 | throw new Error('named error groups for capture must be a String'); 305 | } 306 | if (identifyCurrentTerm(this) === STATE_EMPTY) { 307 | throw new Error('nothing to capture'); 308 | } 309 | if (name === 'match') { 310 | throw new Error('the capture group \'match\' represents the entire match group, and cannot be used as a custom named group'); 311 | } 312 | 313 | addCapture(this, name); 314 | return wrapCurrentTerm(this, '(', ')'); 315 | }; 316 | 317 | RegexBase.backref = RegexBase.reference = function backref(name) { 318 | if (name == null || typeof name !== 'string') { 319 | throw new Error('must give a capture group to reference'); 320 | } 321 | 322 | return addBackref(this, name); 323 | }; 324 | 325 | var TYPES_TO_WRAP = [TYPE_OR, TYPE_MULTITERM, TYPE_REPEAT]; 326 | function maybeWrapInOpennoncapture(rb) { 327 | if (arrayContains(TYPES_TO_WRAP, currentTerm(rb).type)) { 328 | wrapCurrentTerm(rb, '(?:', ')'); 329 | return; 330 | } 331 | switch (identifyCurrentTerm(rb)) { 332 | case STATE_CHARACTER: 333 | case STATE_CLOSEDGROUP: 334 | case STATE_ANY: 335 | break; 336 | default: 337 | wrapCurrentTerm(rb, '(?:', ')'); 338 | return; 339 | } 340 | 341 | } 342 | RegexBase.repeat = function repeat(min, max) { 343 | if (identifyCurrentTerm(this) === STATE_EMPTY) { 344 | throw new Error('nothing to repeat'); 345 | } 346 | 347 | maybeWrapInOpennoncapture(this); 348 | 349 | if (min == null || min === 0 || min === true) { 350 | return wrapCurrentTerm(this, '', '*', TYPE_REPEAT); 351 | } 352 | else if (min === false) { 353 | return wrapCurrentTerm(this, '', '*?', TYPE_REPEAT); 354 | } 355 | else if (min === 1 && (max == null || max === true)) { 356 | return wrapCurrentTerm(this, '', '+', TYPE_REPEAT); 357 | } 358 | else if (min === 1 && max === false) { 359 | return wrapCurrentTerm(this, '', '+?', TYPE_REPEAT); 360 | } 361 | else if (max == null) { 362 | return wrapCurrentTerm(this, '', '{' + min + ',}', TYPE_REPEAT); 363 | } 364 | else if (min === max) { 365 | return wrapCurrentTerm(this, '', '{' + min + '}', TYPE_REPEAT); 366 | } 367 | else { 368 | return wrapCurrentTerm(this, '', '{' + min + ',' + max + '}', TYPE_REPEAT); 369 | } 370 | }; 371 | 372 | RegexBase.optional = function optional() { 373 | if (identifyCurrentTerm(this) === STATE_EMPTY) { 374 | throw new Error('nothing to mark as optional'); 375 | } 376 | 377 | maybeWrapInOpennoncapture(this); 378 | return wrapCurrentTerm(this, '', '?'); 379 | }; 380 | 381 | RegexBase.followedBy = function followedBy(string) { 382 | if (arguments.length && typeof string !== 'string') { 383 | throw new Error('if specifying arguments for followedBy(), must be a String of literals'); 384 | } 385 | 386 | if (arguments.length) { 387 | return addTerm(this, '(?=' + getLiterals(string) + ')'); 388 | } 389 | else { 390 | return Object.create(RegexIsFollowedBy)._init(this); 391 | } 392 | }; 393 | 394 | regex.followedBy = function followedBy() { 395 | return applyArgumentsWithoutNode(RegexIsFollowedBy, arrayCopy(arguments)); 396 | }; 397 | 398 | RegexBase.notFollowedBy = function notFollowedBy(string) { 399 | if (arguments.length && typeof string !== 'string') { 400 | throw new Error('if specifying arguments for notFollowedBy(), must be a String of literals'); 401 | } 402 | 403 | if (arguments.length) { 404 | return addTerm(this, '(?!' + getLiterals(string) + ')'); 405 | } 406 | else { 407 | return Object.create(RegexNotFollowedBy)._init(this); 408 | } 409 | }; 410 | 411 | regex.notFollowedBy = function notFollowedBy(literals) { 412 | return applyArgumentsWithoutNode(RegexNotFollowedBy, arrayCopy(arguments)); 413 | }; 414 | 415 | RegexBase.anyFrom = function anyFrom(firstChar, secondChar) { 416 | if (typeof firstChar !== 'string' || typeof secondChar !== 'string') { 417 | throw new Error('must specify two characters for anyFrom() method'); 418 | } 419 | 420 | var term = '[' + getSetLiteral(firstChar) + '-' + getSetLiteral(secondChar) + ']'; 421 | return addTerm(this, term); 422 | }; 423 | 424 | regex.anyFrom = function anyFrom(firstChar, secondChar) { 425 | return Object.create(RegexBase)._init(regex).anyFrom(firstChar, secondChar); 426 | }; 427 | 428 | RegexBase.any = RegexBase.anyOf = function any(characters) { 429 | if (arguments.length && typeof characters !== 'string') { 430 | throw new Error('if specifying arguments for any(), must be a String of literals'); 431 | } 432 | 433 | if (arguments.length) { 434 | return addTerm(this, '[' + getSetLiterals(characters) + ']'); 435 | } 436 | else { 437 | return Object.create(RegexAny)._init(this); 438 | } 439 | }; 440 | 441 | regex.any = regex.anyOf = function any(literals) { 442 | return Object.create(RegexBase)._init(regex).any(literals); 443 | }; 444 | 445 | RegexBase.noneFrom = function noneFrom(firstChar, secondChar) { 446 | if (typeof firstChar !== 'string' || typeof secondChar !== 'string') { 447 | throw new Error('must specify two characters for noneFrom() method'); 448 | } 449 | 450 | var term = '[^' + getSetLiteral(firstChar) + '-' + getSetLiteral(secondChar) + ']'; 451 | return addTerm(this, term); 452 | }; 453 | 454 | regex.noneFrom = function noneFrom(firstChar, secondChar) { 455 | return Object.create(RegexBase)._init(regex).noneFrom(firstChar, secondChar); 456 | }; 457 | 458 | RegexBase.none = RegexBase.noneOf = function none(characters) { 459 | if (arguments.length && typeof characters !== 'string') { 460 | throw new Error('if specifying arguments for none(), must be a String of literals'); 461 | } 462 | 463 | if (arguments.length) { 464 | return addTerm(this, '[^' + getSetLiterals(characters) + ']'); 465 | } 466 | else { 467 | return Object.create(RegexNone)._init(this); 468 | } 469 | }; 470 | 471 | regex.none = regex.noneOf = function none(literals) { 472 | return Object.create(RegexBase)._init(regex).none(literals); 473 | }; 474 | 475 | RegexBase.or = RegexBase.either = function either(/* Optional: [literals|RegexBase] */) { 476 | if (!arguments.length) { 477 | return Object.create(RegexEither)._init(this); 478 | } 479 | else { 480 | return applyArgumentsToNode(RegexEither, this, arrayCopy(arguments)); 481 | } 482 | }; 483 | 484 | regex.or = regex.either = function either(/* Optional: [literals|RegexBase] */) { 485 | return applyArgumentsWithoutNode(RegexEither, arrayCopy(arguments)); 486 | }; 487 | 488 | var flagCharacters = { 489 | '.': '.', 490 | '^': '^', 491 | '$': '^', 492 | 'd': '\\d', 493 | 'D': '\\D', 494 | 's': '\\s', 495 | 'S': '\\S', 496 | 'f': '\\f', 497 | 'n': '\\n', 498 | 'r': '\\r', 499 | 't': '\\t', 500 | 'v': '\\v', 501 | 'w': '\\w', 502 | 'W': '\\W', 503 | '0': '\\0', 504 | }; 505 | 506 | function makeFlagFns(node) { 507 | function addFlag(flag) { 508 | return function flagFn() { 509 | return addTerm(node, flag); 510 | }; 511 | } 512 | 513 | var flags = function flags(flagsToAdd) { 514 | var newFlags = ''; 515 | for (var i = 0, len = flagsToAdd.length; i < len; i++) { 516 | var newFlag = flagsToAdd[i]; 517 | if (!flagCharacters[newFlag]) { 518 | throw new Error('unrecognized flag: ' + newFlag); 519 | } 520 | newFlags += flagCharacters[newFlag]; 521 | } 522 | 523 | return addTerm(node, newFlags); 524 | }; 525 | 526 | flags.start = addFlag('^'); 527 | flags.end = addFlag('$'); 528 | 529 | flags.any = flags.dot = 530 | flags.anything = addFlag('.'); 531 | flags.digit = addFlag('\\d'); 532 | flags.nonDigit = addFlag('\\D'); 533 | flags.whitespace = addFlag('\\s'); 534 | flags.nonWhitespace = addFlag('\\S'); 535 | 536 | flags.backspace = addFlag('[\\b]'); 537 | flags.wordBoundary = addFlag('\\b'); 538 | flags.nonWordBoundary = addFlag('\\B'); 539 | flags.formfeed = addFlag('\\f'); 540 | flags.newline = flags.linefeed = addFlag('\\n'); 541 | flags.carriageReturn = addFlag('\\r'); 542 | flags.tab = addFlag('\\t'); 543 | flags.verticalTab = addFlag('\\v'); 544 | flags.alphanumeric = addFlag('\\w'); 545 | flags.nonAlphanumberic = addFlag('\\W'); 546 | flags.nullCharacter = addFlag('\\0'); 547 | 548 | // TODO hexadecimal flags 549 | 550 | node.f = node.flags = flags; 551 | return node; 552 | } 553 | 554 | var RegexFlags = {}; 555 | RegexFlags._type = 'flags'; 556 | RegexFlags._initFields = RegexBase._initFields; 557 | RegexFlags._renderNodes = RegexBase._renderNodes; 558 | RegexFlags._toTerm = RegexBase._toTerm; 559 | RegexFlags.peek = RegexBase.peek; 560 | RegexFlags.repeat = RegexBase.repeat; 561 | RegexFlags.capture = RegexBase.capture; 562 | RegexFlags.optional = RegexBase.optional; 563 | 564 | Object.defineProperty(regex, 'flags', { 565 | get: function () { 566 | var reFlags = Object.create(RegexFlags)._initFields(regex); 567 | makeFlagFns(reFlags); 568 | return reFlags.flags; 569 | }, 570 | enumerable: true 571 | }); 572 | 573 | var RegexGroup = Object.create(RegexBase); 574 | RegexGroup._type = 'group'; 575 | RegexGroup.end = function end() { 576 | if (this._parent !== regex) { 577 | return addBuilderTerm(this._parent, this._toTerm()); 578 | } 579 | return this; 580 | }; 581 | 582 | var RegexSequence = Object.create(RegexGroup); 583 | RegexSequence._type = 'sequence'; 584 | RegexSequence.endSequence = RegexSequence.endSeq = RegexGroup.end; 585 | 586 | RegexSequence._toTerm = function _toTerm() { 587 | return typedToTerm(this, TYPE_MULTITERM); 588 | }; 589 | 590 | var RegexCharacterSet = Object.create(RegexBase); 591 | RegexCharacterSet._type = 'characterSet'; 592 | RegexCharacterSet.end = RegexGroup.end; 593 | 594 | RegexCharacterSet._renderNodes = function _renderNodes() { 595 | var pre = this._anyExclueFlag === true ? '[^' : '['; 596 | return pre + nodesToArray(this).join('') + ']'; 597 | }; 598 | 599 | // TODO am I really not creative enough to do better? Not to mention, liskov substitution principle... 600 | delete RegexCharacterSet.noneFrom; 601 | delete RegexCharacterSet.none; 602 | delete RegexCharacterSet.anyFrom; 603 | delete RegexCharacterSet.any; 604 | delete RegexCharacterSet.seq; 605 | delete RegexCharacterSet.sequence; 606 | delete RegexCharacterSet.capture; 607 | delete RegexCharacterSet.repeat; 608 | 609 | var RegexAny = Object.create(RegexCharacterSet); 610 | RegexAny._type = 'any'; 611 | RegexAny._anyExcludeFlag = false; 612 | RegexAny.endAny = RegexAny.end; 613 | 614 | var RegexNone = Object.create(RegexCharacterSet); 615 | RegexNone._type = 'none'; 616 | RegexNone._anyExclueFlag = true; 617 | RegexNone.endNone = RegexNone.end; 618 | 619 | var RegexEither = Object.create(RegexBase); 620 | RegexEither._type = 'either'; 621 | RegexEither.end = RegexEither.endEither = RegexEither.endOr = RegexGroup.end; 622 | 623 | RegexEither._renderNodes = function _renderNodes() { 624 | return nodesToArray(this).join('|'); 625 | }; 626 | RegexEither._toTerm = function _toTerm() { 627 | return typedToTerm(this, TYPE_OR); 628 | }; 629 | 630 | var RegexFollowedBy = Object.create(RegexBase); 631 | RegexFollowedBy._type = 'followedByBase'; 632 | RegexFollowedBy.end = RegexGroup.end; 633 | 634 | RegexFollowedBy._renderNodes = function _renderNodes() { 635 | var pre = this._notFlag === true ? '(?!' : '(?='; 636 | return pre + nodesToArray(this).join('') + ')'; 637 | }; 638 | 639 | var RegexIsFollowedBy = Object.create(RegexFollowedBy); 640 | RegexIsFollowedBy._type = 'isFollowedBy'; 641 | RegexIsFollowedBy._notFlag = false; 642 | RegexIsFollowedBy.endFollowedBy = RegexIsFollowedBy.end; 643 | 644 | var RegexNotFollowedBy = Object.create(RegexFollowedBy); 645 | RegexNotFollowedBy._type = 'notFollowedBy'; 646 | RegexNotFollowedBy._notFlag = true; 647 | RegexNotFollowedBy.endNotFollowedBy = RegexNotFollowedBy.end; 648 | 649 | var RegexMacro = Object.create(RegexGroup); 650 | RegexMacro._type = 'macro'; 651 | RegexMacro._toTerm = RegexSequence._toTerm; 652 | 653 | RegexMacro.endMacro = RegexMacro.end = function end() { 654 | return this._parent; 655 | }; 656 | 657 | delete RegexMacro.endSequence; 658 | delete RegexMacro.endSeq; 659 | 660 | // Represents the root object created by executing regex() 661 | var RegexRoot = Object.create(RegexBase); 662 | RegexRoot._type = 'root'; 663 | 664 | RegexRoot.addMacro = function addMacro(name) { 665 | /*jshint -W093*/ 666 | if (!arguments.length) { 667 | throw new Error('addMacro() must be given the name of the macro to create'); 668 | } 669 | else if (arguments.length === 1) { 670 | return this._macros[name] = Object.create(RegexMacro)._init(this); 671 | } 672 | else if (arguments.length > 1) { 673 | var macro = this._macros[name] = Object.create(RegexMacro)._init(this); 674 | applyArgs(macro, rest(arguments)); 675 | macro.endMacro(); 676 | return this; 677 | } 678 | /*jshint +W093*/ 679 | }; 680 | 681 | RegexRoot.test = function test(string) { 682 | return toRegExp(this).test(string); 683 | }; 684 | 685 | RegexRoot.replace = function replace(string, callback) { 686 | if (typeof string !== 'string') { 687 | throw new Error('can only call replace with a String and callback replace method'); 688 | } 689 | 690 | // TODO callback can be a string or function 691 | // TODO can handle capture never getting called 692 | 693 | var node = this; 694 | return string.replace(toRegExp(this), function () { 695 | var args = rest(arguments); 696 | 697 | var captures = orderedCaptures(node); 698 | var callbackHash = {}; 699 | 700 | for (var i = 0, len = args.length; i < len; i++) { 701 | var name = captures[i]; 702 | callbackHash[name] = args[i]; 703 | } 704 | 705 | return callback(callbackHash); 706 | }); 707 | }; 708 | 709 | RegexRoot.exec = function exec(string) { 710 | if (typeof string !== 'string') { 711 | throw new Error('can only call exec with a String'); 712 | } 713 | 714 | var execed = toRegExp(this).exec(string); 715 | 716 | if (!execed) { 717 | return null; 718 | } 719 | 720 | var captures = orderedCaptures(this); 721 | var result = { 722 | match: execed[0] 723 | }; 724 | 725 | for (var i = 1, len = execed.length; i < len; i++) { 726 | var name = captures[i - 1]; 727 | result[name] = execed[i]; 728 | } 729 | 730 | return result; 731 | }; 732 | 733 | // ----------------------- 734 | // Helpers 735 | // ----------------------- 736 | 737 | var specialCharacters = '\\^$*+?(){}[]|.'; 738 | var specialSetCharacters = specialCharacters + '-'; 739 | 740 | function getLiteral(character, specialSet) { 741 | if (typeof character !== 'string') { 742 | throw new Error('the literal() and literals() functions only takes Strings'); 743 | } 744 | if (character.length !== 1) { 745 | throw new Error('only one characteer can be given for literal()'); 746 | } 747 | return specialSet.indexOf(character) === -1 ? character : '\\' + character; 748 | } 749 | function getNormalLiteral(character) { 750 | return getLiteral(character, specialCharacters); 751 | } 752 | function getSetLiteral(character) { 753 | return getLiteral(character, specialSetCharacters); 754 | } 755 | 756 | function getLiterals(string) { 757 | var literals = ''; 758 | for (var i = 0, len = string.length; i < len; i++) { 759 | literals += getNormalLiteral(string[i]); 760 | } 761 | return literals; 762 | } 763 | function getSetLiterals(string) { 764 | var literals = ''; 765 | for (var i = 0, len = string.length; i < len; i++) { 766 | literals += getSetLiteral(string[i]); 767 | } 768 | return literals; 769 | } 770 | 771 | function deepExtend(target, src) { 772 | var value, prop; 773 | for (prop in src) { 774 | if (src.hasOwnProperty(prop)) { 775 | value = src[prop]; 776 | 777 | if (value instanceof Array) { 778 | target[prop] = deepExtend([], value); 779 | } 780 | else if (value instanceof Function) { 781 | // ignore; only used where target should win over source (i.e., bound fns) 782 | } 783 | else if (value instanceof Object) { 784 | target[prop] = deepExtend({}, value); 785 | } 786 | else { 787 | target[prop] = value; 788 | } 789 | } 790 | } 791 | return target; 792 | } 793 | 794 | function arrayContains(arry, value) { 795 | return arry.indexOf(value) !== -1; 796 | } 797 | function arrayCopyFrom(arry, idx) { 798 | var result = new Array(arry.length - idx); 799 | for (var i = 0, len = arry.length - idx; i < len; i++) { 800 | result[i] = arry[i + idx]; 801 | } 802 | return result; 803 | } 804 | function arrayCopy(arry) { 805 | return arrayCopyFrom(arry, 0); 806 | } 807 | function rest(arry) { 808 | return arrayCopyFrom(arry, 1); 809 | } 810 | function flatten(arry, accum) { 811 | accum = accum || []; 812 | for (var i = 0, len = arry.length; i < len; i++) { 813 | var val = arry[i]; 814 | if (val instanceof Array) { 815 | flatten(val, accum); 816 | } 817 | else { 818 | accum.push(val); 819 | } 820 | } 821 | return accum; 822 | } 823 | function objectCopy(obj) { 824 | return deepExtend({}, obj); 825 | } 826 | 827 | function toRegExp(node) { 828 | return new RegExp(node.peek()); 829 | } 830 | 831 | function applyArgs(reNode, args) { 832 | for (var i = 0, len = args.length; i < len; i++) { 833 | var arg = args[i]; 834 | if (typeof arg === 'string') { 835 | reNode.literals(arg); 836 | } 837 | else if (RegexBase.isPrototypeOf(arg) || RegexFlags.isPrototypeOf(arg)) { 838 | addBuilderTerm(reNode, arg._toTerm()); 839 | } 840 | else { 841 | throw new Error('if arguments are given to or(), must be either strings or js-regex objects.'); 842 | } 843 | } 844 | } 845 | 846 | function pluck(arry, field) { 847 | var res = []; 848 | for (var i = 0, len = arry.length; i < len; i++) { 849 | res.push(arry[i][field]); 850 | } 851 | return res; 852 | } 853 | function startsWith(str, match) { 854 | return str.indexOf(match) === 0; 855 | } 856 | function endsWith(str, match) { 857 | return str.lastIndexOf(match) === (str.length - match.length); 858 | } 859 | function endsWithNonEscaped(str, match) { 860 | return endsWith(str, match) && !endsWith(str, '\\' + match); 861 | } 862 | 863 | function identifyState(snippet) { 864 | if (snippet.length === 0) { 865 | return STATE_EMPTY; 866 | } 867 | if (snippet.length === 1 || (startsWith(snippet, '\\') && snippet.length === 2)) { 868 | // TODO FIXME could be true with unicode also 869 | return STATE_CHARACTER; 870 | } 871 | if (endsWithNonEscaped(snippet, '?')) { 872 | return STATE_MODIFIEDTERM; 873 | } 874 | if (startsWith(snippet, '[') && endsWithNonEscaped(snippet, ']')) { 875 | return STATE_ANY; 876 | } 877 | if (startsWith(snippet, '(') && endsWithNonEscaped(snippet, ')')) { 878 | return STATE_CLOSEDGROUP; 879 | } 880 | return null; // if I don't understand what the thing is, the behavior isn't reliable anyway 881 | } 882 | 883 | function hasNonEmptyNeighborNode(nodes, i) { 884 | if (i > 0 && identifyState(nodes[i - 1].term) !== STATE_EMPTY) { 885 | return true; 886 | } 887 | if (i < (nodes.length - 1) && identifyState(nodes[i + 1].term) !== STATE_EMPTY) { 888 | return true; 889 | } 890 | return false; 891 | 892 | } 893 | 894 | // TODO FIXME exclude from 'production' builds, if I make that a thing 895 | regex._identifyState = identifyState; 896 | 897 | return regex; 898 | })); 899 | 900 | -------------------------------------------------------------------------------- /test/resources/qunit.js: -------------------------------------------------------------------------------- 1 | /** 2 | * QUnit v1.12.0 - A JavaScript Unit Testing Framework 3 | * 4 | * http://qunitjs.com 5 | * 6 | * Copyright 2013 jQuery Foundation and other contributors 7 | * Released under the MIT license. 8 | * https://jquery.org/license/ 9 | */ 10 | 11 | (function( window ) { 12 | 13 | var QUnit, 14 | assert, 15 | config, 16 | onErrorFnPrev, 17 | testId = 0, 18 | fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""), 19 | toString = Object.prototype.toString, 20 | hasOwn = Object.prototype.hasOwnProperty, 21 | // Keep a local reference to Date (GH-283) 22 | Date = window.Date, 23 | setTimeout = window.setTimeout, 24 | defined = { 25 | setTimeout: typeof window.setTimeout !== "undefined", 26 | sessionStorage: (function() { 27 | var x = "qunit-test-string"; 28 | try { 29 | sessionStorage.setItem( x, x ); 30 | sessionStorage.removeItem( x ); 31 | return true; 32 | } catch( e ) { 33 | return false; 34 | } 35 | }()) 36 | }, 37 | /** 38 | * Provides a normalized error string, correcting an issue 39 | * with IE 7 (and prior) where Error.prototype.toString is 40 | * not properly implemented 41 | * 42 | * Based on http://es5.github.com/#x15.11.4.4 43 | * 44 | * @param {String|Error} error 45 | * @return {String} error message 46 | */ 47 | errorString = function( error ) { 48 | var name, message, 49 | errorString = error.toString(); 50 | if ( errorString.substring( 0, 7 ) === "[object" ) { 51 | name = error.name ? error.name.toString() : "Error"; 52 | message = error.message ? error.message.toString() : ""; 53 | if ( name && message ) { 54 | return name + ": " + message; 55 | } else if ( name ) { 56 | return name; 57 | } else if ( message ) { 58 | return message; 59 | } else { 60 | return "Error"; 61 | } 62 | } else { 63 | return errorString; 64 | } 65 | }, 66 | /** 67 | * Makes a clone of an object using only Array or Object as base, 68 | * and copies over the own enumerable properties. 69 | * 70 | * @param {Object} obj 71 | * @return {Object} New object with only the own properties (recursively). 72 | */ 73 | objectValues = function( obj ) { 74 | // Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392. 75 | /*jshint newcap: false */ 76 | var key, val, 77 | vals = QUnit.is( "array", obj ) ? [] : {}; 78 | for ( key in obj ) { 79 | if ( hasOwn.call( obj, key ) ) { 80 | val = obj[key]; 81 | vals[key] = val === Object(val) ? objectValues(val) : val; 82 | } 83 | } 84 | return vals; 85 | }; 86 | 87 | function Test( settings ) { 88 | extend( this, settings ); 89 | this.assertions = []; 90 | this.testNumber = ++Test.count; 91 | } 92 | 93 | Test.count = 0; 94 | 95 | Test.prototype = { 96 | init: function() { 97 | var a, b, li, 98 | tests = id( "qunit-tests" ); 99 | 100 | if ( tests ) { 101 | b = document.createElement( "strong" ); 102 | b.innerHTML = this.nameHtml; 103 | 104 | // `a` initialized at top of scope 105 | a = document.createElement( "a" ); 106 | a.innerHTML = "Rerun"; 107 | a.href = QUnit.url({ testNumber: this.testNumber }); 108 | 109 | li = document.createElement( "li" ); 110 | li.appendChild( b ); 111 | li.appendChild( a ); 112 | li.className = "running"; 113 | li.id = this.id = "qunit-test-output" + testId++; 114 | 115 | tests.appendChild( li ); 116 | } 117 | }, 118 | setup: function() { 119 | if ( 120 | // Emit moduleStart when we're switching from one module to another 121 | this.module !== config.previousModule || 122 | // They could be equal (both undefined) but if the previousModule property doesn't 123 | // yet exist it means this is the first test in a suite that isn't wrapped in a 124 | // module, in which case we'll just emit a moduleStart event for 'undefined'. 125 | // Without this, reporters can get testStart before moduleStart which is a problem. 126 | !hasOwn.call( config, "previousModule" ) 127 | ) { 128 | if ( hasOwn.call( config, "previousModule" ) ) { 129 | runLoggingCallbacks( "moduleDone", QUnit, { 130 | name: config.previousModule, 131 | failed: config.moduleStats.bad, 132 | passed: config.moduleStats.all - config.moduleStats.bad, 133 | total: config.moduleStats.all 134 | }); 135 | } 136 | config.previousModule = this.module; 137 | config.moduleStats = { all: 0, bad: 0 }; 138 | runLoggingCallbacks( "moduleStart", QUnit, { 139 | name: this.module 140 | }); 141 | } 142 | 143 | config.current = this; 144 | 145 | this.testEnvironment = extend({ 146 | setup: function() {}, 147 | teardown: function() {} 148 | }, this.moduleTestEnvironment ); 149 | 150 | this.started = +new Date(); 151 | runLoggingCallbacks( "testStart", QUnit, { 152 | name: this.testName, 153 | module: this.module 154 | }); 155 | 156 | /*jshint camelcase:false */ 157 | 158 | 159 | /** 160 | * Expose the current test environment. 161 | * 162 | * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead. 163 | */ 164 | QUnit.current_testEnvironment = this.testEnvironment; 165 | 166 | /*jshint camelcase:true */ 167 | 168 | if ( !config.pollution ) { 169 | saveGlobal(); 170 | } 171 | if ( config.notrycatch ) { 172 | this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert ); 173 | return; 174 | } 175 | try { 176 | this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert ); 177 | } catch( e ) { 178 | QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) ); 179 | } 180 | }, 181 | run: function() { 182 | config.current = this; 183 | 184 | var running = id( "qunit-testresult" ); 185 | 186 | if ( running ) { 187 | running.innerHTML = "Running:
" + this.nameHtml; 188 | } 189 | 190 | if ( this.async ) { 191 | QUnit.stop(); 192 | } 193 | 194 | this.callbackStarted = +new Date(); 195 | 196 | if ( config.notrycatch ) { 197 | this.callback.call( this.testEnvironment, QUnit.assert ); 198 | this.callbackRuntime = +new Date() - this.callbackStarted; 199 | return; 200 | } 201 | 202 | try { 203 | this.callback.call( this.testEnvironment, QUnit.assert ); 204 | this.callbackRuntime = +new Date() - this.callbackStarted; 205 | } catch( e ) { 206 | this.callbackRuntime = +new Date() - this.callbackStarted; 207 | 208 | QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) ); 209 | // else next test will carry the responsibility 210 | saveGlobal(); 211 | 212 | // Restart the tests if they're blocking 213 | if ( config.blocking ) { 214 | QUnit.start(); 215 | } 216 | } 217 | }, 218 | teardown: function() { 219 | config.current = this; 220 | if ( config.notrycatch ) { 221 | if ( typeof this.callbackRuntime === "undefined" ) { 222 | this.callbackRuntime = +new Date() - this.callbackStarted; 223 | } 224 | this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert ); 225 | return; 226 | } else { 227 | try { 228 | this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert ); 229 | } catch( e ) { 230 | QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) ); 231 | } 232 | } 233 | checkPollution(); 234 | }, 235 | finish: function() { 236 | config.current = this; 237 | if ( config.requireExpects && this.expected === null ) { 238 | QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack ); 239 | } else if ( this.expected !== null && this.expected !== this.assertions.length ) { 240 | QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack ); 241 | } else if ( this.expected === null && !this.assertions.length ) { 242 | QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack ); 243 | } 244 | 245 | var i, assertion, a, b, time, li, ol, 246 | test = this, 247 | good = 0, 248 | bad = 0, 249 | tests = id( "qunit-tests" ); 250 | 251 | this.runtime = +new Date() - this.started; 252 | config.stats.all += this.assertions.length; 253 | config.moduleStats.all += this.assertions.length; 254 | 255 | if ( tests ) { 256 | ol = document.createElement( "ol" ); 257 | ol.className = "qunit-assert-list"; 258 | 259 | for ( i = 0; i < this.assertions.length; i++ ) { 260 | assertion = this.assertions[i]; 261 | 262 | li = document.createElement( "li" ); 263 | li.className = assertion.result ? "pass" : "fail"; 264 | li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" ); 265 | ol.appendChild( li ); 266 | 267 | if ( assertion.result ) { 268 | good++; 269 | } else { 270 | bad++; 271 | config.stats.bad++; 272 | config.moduleStats.bad++; 273 | } 274 | } 275 | 276 | // store result when possible 277 | if ( QUnit.config.reorder && defined.sessionStorage ) { 278 | if ( bad ) { 279 | sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad ); 280 | } else { 281 | sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName ); 282 | } 283 | } 284 | 285 | if ( bad === 0 ) { 286 | addClass( ol, "qunit-collapsed" ); 287 | } 288 | 289 | // `b` initialized at top of scope 290 | b = document.createElement( "strong" ); 291 | b.innerHTML = this.nameHtml + " (" + bad + ", " + good + ", " + this.assertions.length + ")"; 292 | 293 | addEvent(b, "click", function() { 294 | var next = b.parentNode.lastChild, 295 | collapsed = hasClass( next, "qunit-collapsed" ); 296 | ( collapsed ? removeClass : addClass )( next, "qunit-collapsed" ); 297 | }); 298 | 299 | addEvent(b, "dblclick", function( e ) { 300 | var target = e && e.target ? e.target : window.event.srcElement; 301 | if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) { 302 | target = target.parentNode; 303 | } 304 | if ( window.location && target.nodeName.toLowerCase() === "strong" ) { 305 | window.location = QUnit.url({ testNumber: test.testNumber }); 306 | } 307 | }); 308 | 309 | // `time` initialized at top of scope 310 | time = document.createElement( "span" ); 311 | time.className = "runtime"; 312 | time.innerHTML = this.runtime + " ms"; 313 | 314 | // `li` initialized at top of scope 315 | li = id( this.id ); 316 | li.className = bad ? "fail" : "pass"; 317 | li.removeChild( li.firstChild ); 318 | a = li.firstChild; 319 | li.appendChild( b ); 320 | li.appendChild( a ); 321 | li.appendChild( time ); 322 | li.appendChild( ol ); 323 | 324 | } else { 325 | for ( i = 0; i < this.assertions.length; i++ ) { 326 | if ( !this.assertions[i].result ) { 327 | bad++; 328 | config.stats.bad++; 329 | config.moduleStats.bad++; 330 | } 331 | } 332 | } 333 | 334 | runLoggingCallbacks( "testDone", QUnit, { 335 | name: this.testName, 336 | module: this.module, 337 | failed: bad, 338 | passed: this.assertions.length - bad, 339 | total: this.assertions.length, 340 | duration: this.runtime 341 | }); 342 | 343 | QUnit.reset(); 344 | 345 | config.current = undefined; 346 | }, 347 | 348 | queue: function() { 349 | var bad, 350 | test = this; 351 | 352 | synchronize(function() { 353 | test.init(); 354 | }); 355 | function run() { 356 | // each of these can by async 357 | synchronize(function() { 358 | test.setup(); 359 | }); 360 | synchronize(function() { 361 | test.run(); 362 | }); 363 | synchronize(function() { 364 | test.teardown(); 365 | }); 366 | synchronize(function() { 367 | test.finish(); 368 | }); 369 | } 370 | 371 | // `bad` initialized at top of scope 372 | // defer when previous test run passed, if storage is available 373 | bad = QUnit.config.reorder && defined.sessionStorage && 374 | +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName ); 375 | 376 | if ( bad ) { 377 | run(); 378 | } else { 379 | synchronize( run, true ); 380 | } 381 | } 382 | }; 383 | 384 | // Root QUnit object. 385 | // `QUnit` initialized at top of scope 386 | QUnit = { 387 | 388 | // call on start of module test to prepend name to all tests 389 | module: function( name, testEnvironment ) { 390 | config.currentModule = name; 391 | config.currentModuleTestEnvironment = testEnvironment; 392 | config.modules[name] = true; 393 | }, 394 | 395 | asyncTest: function( testName, expected, callback ) { 396 | if ( arguments.length === 2 ) { 397 | callback = expected; 398 | expected = null; 399 | } 400 | 401 | QUnit.test( testName, expected, callback, true ); 402 | }, 403 | 404 | test: function( testName, expected, callback, async ) { 405 | var test, 406 | nameHtml = "" + escapeText( testName ) + ""; 407 | 408 | if ( arguments.length === 2 ) { 409 | callback = expected; 410 | expected = null; 411 | } 412 | 413 | if ( config.currentModule ) { 414 | nameHtml = "" + escapeText( config.currentModule ) + ": " + nameHtml; 415 | } 416 | 417 | test = new Test({ 418 | nameHtml: nameHtml, 419 | testName: testName, 420 | expected: expected, 421 | async: async, 422 | callback: callback, 423 | module: config.currentModule, 424 | moduleTestEnvironment: config.currentModuleTestEnvironment, 425 | stack: sourceFromStacktrace( 2 ) 426 | }); 427 | 428 | if ( !validTest( test ) ) { 429 | return; 430 | } 431 | 432 | test.queue(); 433 | }, 434 | 435 | // Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through. 436 | expect: function( asserts ) { 437 | if (arguments.length === 1) { 438 | config.current.expected = asserts; 439 | } else { 440 | return config.current.expected; 441 | } 442 | }, 443 | 444 | start: function( count ) { 445 | // QUnit hasn't been initialized yet. 446 | // Note: RequireJS (et al) may delay onLoad 447 | if ( config.semaphore === undefined ) { 448 | QUnit.begin(function() { 449 | // This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first 450 | setTimeout(function() { 451 | QUnit.start( count ); 452 | }); 453 | }); 454 | return; 455 | } 456 | 457 | config.semaphore -= count || 1; 458 | // don't start until equal number of stop-calls 459 | if ( config.semaphore > 0 ) { 460 | return; 461 | } 462 | // ignore if start is called more often then stop 463 | if ( config.semaphore < 0 ) { 464 | config.semaphore = 0; 465 | QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) ); 466 | return; 467 | } 468 | // A slight delay, to avoid any current callbacks 469 | if ( defined.setTimeout ) { 470 | setTimeout(function() { 471 | if ( config.semaphore > 0 ) { 472 | return; 473 | } 474 | if ( config.timeout ) { 475 | clearTimeout( config.timeout ); 476 | } 477 | 478 | config.blocking = false; 479 | process( true ); 480 | }, 13); 481 | } else { 482 | config.blocking = false; 483 | process( true ); 484 | } 485 | }, 486 | 487 | stop: function( count ) { 488 | config.semaphore += count || 1; 489 | config.blocking = true; 490 | 491 | if ( config.testTimeout && defined.setTimeout ) { 492 | clearTimeout( config.timeout ); 493 | config.timeout = setTimeout(function() { 494 | QUnit.ok( false, "Test timed out" ); 495 | config.semaphore = 1; 496 | QUnit.start(); 497 | }, config.testTimeout ); 498 | } 499 | } 500 | }; 501 | 502 | // `assert` initialized at top of scope 503 | // Assert helpers 504 | // All of these must either call QUnit.push() or manually do: 505 | // - runLoggingCallbacks( "log", .. ); 506 | // - config.current.assertions.push({ .. }); 507 | // We attach it to the QUnit object *after* we expose the public API, 508 | // otherwise `assert` will become a global variable in browsers (#341). 509 | assert = { 510 | /** 511 | * Asserts rough true-ish result. 512 | * @name ok 513 | * @function 514 | * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" ); 515 | */ 516 | ok: function( result, msg ) { 517 | if ( !config.current ) { 518 | throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) ); 519 | } 520 | result = !!result; 521 | msg = msg || (result ? "okay" : "failed" ); 522 | 523 | var source, 524 | details = { 525 | module: config.current.module, 526 | name: config.current.testName, 527 | result: result, 528 | message: msg 529 | }; 530 | 531 | msg = "" + escapeText( msg ) + ""; 532 | 533 | if ( !result ) { 534 | source = sourceFromStacktrace( 2 ); 535 | if ( source ) { 536 | details.source = source; 537 | msg += "

Source:	" + escapeText( source ) + "

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

" + escapeText( document.title ) + "

" + 820 | "" + 821 | "" + 822 | "

" + 823 | "

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

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

"; 952 | } 953 | 954 | runLoggingCallbacks( "log", QUnit, details ); 955 | 956 | config.current.assertions.push({ 957 | result: !!result, 958 | message: output 959 | }); 960 | }, 961 | 962 | pushFailure: function( message, source, actual ) { 963 | if ( !config.current ) { 964 | throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) ); 965 | } 966 | 967 | var output, 968 | details = { 969 | module: config.current.module, 970 | name: config.current.testName, 971 | result: false, 972 | message: message 973 | }; 974 | 975 | message = escapeText( message ) || "error"; 976 | message = "" + message + ""; 977 | output = message; 978 | 979 | output += ""; 980 | 981 | if ( actual ) { 982 | output += ""; 983 | } 984 | 985 | if ( source ) { 986 | details.source = source; 987 | output += ""; 988 | } 989 | 990 | output += "

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

"; 991 | 992 | runLoggingCallbacks( "log", QUnit, details ); 993 | 994 | config.current.assertions.push({ 995 | result: false, 996 | message: output 997 | }); 998 | }, 999 | 1000 | url: function( params ) { 1001 | params = extend( extend( {}, QUnit.urlParams ), params ); 1002 | var key, 1003 | querystring = "?"; 1004 | 1005 | for ( key in params ) { 1006 | if ( hasOwn.call( params, key ) ) { 1007 | querystring += encodeURIComponent( key ) + "=" + 1008 | encodeURIComponent( params[ key ] ) + "&"; 1009 | } 1010 | } 1011 | return window.location.protocol + "//" + window.location.host + 1012 | window.location.pathname + querystring.slice( 0, -1 ); 1013 | }, 1014 | 1015 | extend: extend, 1016 | id: id, 1017 | addEvent: addEvent, 1018 | addClass: addClass, 1019 | hasClass: hasClass, 1020 | removeClass: removeClass 1021 | // load, equiv, jsDump, diff: Attached later 1022 | }); 1023 | 1024 | /** 1025 | * @deprecated: Created for backwards compatibility with test runner that set the hook function 1026 | * into QUnit.{hook}, instead of invoking it and passing the hook function. 1027 | * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here. 1028 | * Doing this allows us to tell if the following methods have been overwritten on the actual 1029 | * QUnit object. 1030 | */ 1031 | extend( QUnit.constructor.prototype, { 1032 | 1033 | // Logging callbacks; all receive a single argument with the listed properties 1034 | // run test/logs.html for any related changes 1035 | begin: registerLoggingCallback( "begin" ), 1036 | 1037 | // done: { failed, passed, total, runtime } 1038 | done: registerLoggingCallback( "done" ), 1039 | 1040 | // log: { result, actual, expected, message } 1041 | log: registerLoggingCallback( "log" ), 1042 | 1043 | // testStart: { name } 1044 | testStart: registerLoggingCallback( "testStart" ), 1045 | 1046 | // testDone: { name, failed, passed, total, duration } 1047 | testDone: registerLoggingCallback( "testDone" ), 1048 | 1049 | // moduleStart: { name } 1050 | moduleStart: registerLoggingCallback( "moduleStart" ), 1051 | 1052 | // moduleDone: { name, failed, passed, total } 1053 | moduleDone: registerLoggingCallback( "moduleDone" ) 1054 | }); 1055 | 1056 | if ( typeof document === "undefined" || document.readyState === "complete" ) { 1057 | config.autorun = true; 1058 | } 1059 | 1060 | QUnit.load = function() { 1061 | runLoggingCallbacks( "begin", QUnit, {} ); 1062 | 1063 | // Initialize the config, saving the execution queue 1064 | var banner, filter, i, label, len, main, ol, toolbar, userAgent, val, 1065 | urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter, 1066 | numModules = 0, 1067 | moduleNames = [], 1068 | moduleFilterHtml = "", 1069 | urlConfigHtml = "", 1070 | oldconfig = extend( {}, config ); 1071 | 1072 | QUnit.init(); 1073 | extend(config, oldconfig); 1074 | 1075 | config.blocking = false; 1076 | 1077 | len = config.urlConfig.length; 1078 | 1079 | for ( i = 0; i < len; i++ ) { 1080 | val = config.urlConfig[i]; 1081 | if ( typeof val === "string" ) { 1082 | val = { 1083 | id: val, 1084 | label: val, 1085 | tooltip: "[no tooltip available]" 1086 | }; 1087 | } 1088 | config[ val.id ] = QUnit.urlParams[ val.id ]; 1089 | urlConfigHtml += "" + val.label + ""; 1095 | } 1096 | for ( i in config.modules ) { 1097 | if ( config.modules.hasOwnProperty( i ) ) { 1098 | moduleNames.push(i); 1099 | } 1100 | } 1101 | numModules = moduleNames.length; 1102 | moduleNames.sort( function( a, b ) { 1103 | return a.localeCompare( b ); 1104 | }); 1105 | moduleFilterHtml += "Module: "; 1116 | 1117 | // `userAgent` initialized at top of scope 1118 | userAgent = id( "qunit-userAgent" ); 1119 | if ( userAgent ) { 1120 | userAgent.innerHTML = navigator.userAgent; 1121 | } 1122 | 1123 | // `banner` initialized at top of scope 1124 | banner = id( "qunit-header" ); 1125 | if ( banner ) { 1126 | banner.innerHTML = "" + banner.innerHTML + " "; 1127 | } 1128 | 1129 | // `toolbar` initialized at top of scope 1130 | toolbar = id( "qunit-testrunner-toolbar" ); 1131 | if ( toolbar ) { 1132 | // `filter` initialized at top of scope 1133 | filter = document.createElement( "input" ); 1134 | filter.type = "checkbox"; 1135 | filter.id = "qunit-filter-pass"; 1136 | 1137 | addEvent( filter, "click", function() { 1138 | var tmp, 1139 | ol = document.getElementById( "qunit-tests" ); 1140 | 1141 | if ( filter.checked ) { 1142 | ol.className = ol.className + " hidepass"; 1143 | } else { 1144 | tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " "; 1145 | ol.className = tmp.replace( / hidepass /, " " ); 1146 | } 1147 | if ( defined.sessionStorage ) { 1148 | if (filter.checked) { 1149 | sessionStorage.setItem( "qunit-filter-passed-tests", "true" ); 1150 | } else { 1151 | sessionStorage.removeItem( "qunit-filter-passed-tests" ); 1152 | } 1153 | } 1154 | }); 1155 | 1156 | if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) { 1157 | filter.checked = true; 1158 | // `ol` initialized at top of scope 1159 | ol = document.getElementById( "qunit-tests" ); 1160 | ol.className = ol.className + " hidepass"; 1161 | } 1162 | toolbar.appendChild( filter ); 1163 | 1164 | // `label` initialized at top of scope 1165 | label = document.createElement( "label" ); 1166 | label.setAttribute( "for", "qunit-filter-pass" ); 1167 | label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." ); 1168 | label.innerHTML = "Hide passed tests"; 1169 | toolbar.appendChild( label ); 1170 | 1171 | urlConfigCheckboxesContainer = document.createElement("span"); 1172 | urlConfigCheckboxesContainer.innerHTML = urlConfigHtml; 1173 | urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input"); 1174 | // For oldIE support: 1175 | // * Add handlers to the individual elements instead of the container 1176 | // * Use "click" instead of "change" 1177 | // * Fallback from event.target to event.srcElement 1178 | addEvents( urlConfigCheckboxes, "click", function( event ) { 1179 | var params = {}, 1180 | target = event.target || event.srcElement; 1181 | params[ target.name ] = target.checked ? true : undefined; 1182 | window.location = QUnit.url( params ); 1183 | }); 1184 | toolbar.appendChild( urlConfigCheckboxesContainer ); 1185 | 1186 | if (numModules > 1) { 1187 | moduleFilter = document.createElement( "span" ); 1188 | moduleFilter.setAttribute( "id", "qunit-modulefilter-container" ); 1189 | moduleFilter.innerHTML = moduleFilterHtml; 1190 | addEvent( moduleFilter.lastChild, "change", function() { 1191 | var selectBox = moduleFilter.getElementsByTagName("select")[0], 1192 | selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value); 1193 | 1194 | window.location = QUnit.url({ 1195 | module: ( selectedModule === "" ) ? undefined : selectedModule, 1196 | // Remove any existing filters 1197 | filter: undefined, 1198 | testNumber: undefined 1199 | }); 1200 | }); 1201 | toolbar.appendChild(moduleFilter); 1202 | } 1203 | } 1204 | 1205 | // `main` initialized at top of scope 1206 | main = id( "qunit-fixture" ); 1207 | if ( main ) { 1208 | config.fixture = main.innerHTML; 1209 | } 1210 | 1211 | if ( config.autostart ) { 1212 | QUnit.start(); 1213 | } 1214 | }; 1215 | 1216 | addEvent( window, "load", QUnit.load ); 1217 | 1218 | // `onErrorFnPrev` initialized at top of scope 1219 | // Preserve other handlers 1220 | onErrorFnPrev = window.onerror; 1221 | 1222 | // Cover uncaught exceptions 1223 | // Returning true will suppress the default browser handler, 1224 | // returning false will let it run. 1225 | window.onerror = function ( error, filePath, linerNr ) { 1226 | var ret = false; 1227 | if ( onErrorFnPrev ) { 1228 | ret = onErrorFnPrev( error, filePath, linerNr ); 1229 | } 1230 | 1231 | // Treat return value as window.onerror itself does, 1232 | // Only do our handling if not suppressed. 1233 | if ( ret !== true ) { 1234 | if ( QUnit.config.current ) { 1235 | if ( QUnit.config.current.ignoreGlobalErrors ) { 1236 | return true; 1237 | } 1238 | QUnit.pushFailure( error, filePath + ":" + linerNr ); 1239 | } else { 1240 | QUnit.test( "global failure", extend( function() { 1241 | QUnit.pushFailure( error, filePath + ":" + linerNr ); 1242 | }, { validTest: validTest } ) ); 1243 | } 1244 | return false; 1245 | } 1246 | 1247 | return ret; 1248 | }; 1249 | 1250 | function done() { 1251 | config.autorun = true; 1252 | 1253 | // Log the last module results 1254 | if ( config.currentModule ) { 1255 | runLoggingCallbacks( "moduleDone", QUnit, { 1256 | name: config.currentModule, 1257 | failed: config.moduleStats.bad, 1258 | passed: config.moduleStats.all - config.moduleStats.bad, 1259 | total: config.moduleStats.all 1260 | }); 1261 | } 1262 | delete config.previousModule; 1263 | 1264 | var i, key, 1265 | banner = id( "qunit-banner" ), 1266 | tests = id( "qunit-tests" ), 1267 | runtime = +new Date() - config.started, 1268 | passed = config.stats.all - config.stats.bad, 1269 | html = [ 1270 | "Tests completed in ", 1271 | runtime, 1272 | " milliseconds.
", 1273 | "", 1274 | passed, 1275 | " assertions of ", 1276 | config.stats.all, 1277 | " passed, ", 1278 | config.stats.bad, 1279 | " failed." 1280 | ].join( "" ); 1281 | 1282 | if ( banner ) { 1283 | banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" ); 1284 | } 1285 | 1286 | if ( tests ) { 1287 | id( "qunit-testresult" ).innerHTML = html; 1288 | } 1289 | 1290 | if ( config.altertitle && typeof document !== "undefined" && document.title ) { 1291 | // show ✖ for good, ✔ for bad suite result in title 1292 | // use escape sequences in case file gets loaded with non-utf-8-charset 1293 | document.title = [ 1294 | ( config.stats.bad ? "\u2716" : "\u2714" ), 1295 | document.title.replace( /^[\u2714\u2716] /i, "" ) 1296 | ].join( " " ); 1297 | } 1298 | 1299 | // clear own sessionStorage items if all tests passed 1300 | if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) { 1301 | // `key` & `i` initialized at top of scope 1302 | for ( i = 0; i < sessionStorage.length; i++ ) { 1303 | key = sessionStorage.key( i++ ); 1304 | if ( key.indexOf( "qunit-test-" ) === 0 ) { 1305 | sessionStorage.removeItem( key ); 1306 | } 1307 | } 1308 | } 1309 | 1310 | // scroll back to top to show results 1311 | if ( window.scrollTo ) { 1312 | window.scrollTo(0, 0); 1313 | } 1314 | 1315 | runLoggingCallbacks( "done", QUnit, { 1316 | failed: config.stats.bad, 1317 | passed: passed, 1318 | total: config.stats.all, 1319 | runtime: runtime 1320 | }); 1321 | } 1322 | 1323 | /** @return Boolean: true if this test should be ran */ 1324 | function validTest( test ) { 1325 | var include, 1326 | filter = config.filter && config.filter.toLowerCase(), 1327 | module = config.module && config.module.toLowerCase(), 1328 | fullName = (test.module + ": " + test.testName).toLowerCase(); 1329 | 1330 | // Internally-generated tests are always valid 1331 | if ( test.callback && test.callback.validTest === validTest ) { 1332 | delete test.callback.validTest; 1333 | return true; 1334 | } 1335 | 1336 | if ( config.testNumber ) { 1337 | return test.testNumber === config.testNumber; 1338 | } 1339 | 1340 | if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) { 1341 | return false; 1342 | } 1343 | 1344 | if ( !filter ) { 1345 | return true; 1346 | } 1347 | 1348 | include = filter.charAt( 0 ) !== "!"; 1349 | if ( !include ) { 1350 | filter = filter.slice( 1 ); 1351 | } 1352 | 1353 | // If the filter matches, we need to honour include 1354 | if ( fullName.indexOf( filter ) !== -1 ) { 1355 | return include; 1356 | } 1357 | 1358 | // Otherwise, do the opposite 1359 | return !include; 1360 | } 1361 | 1362 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions) 1363 | // Later Safari and IE10 are supposed to support error.stack as well 1364 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack 1365 | function extractStacktrace( e, offset ) { 1366 | offset = offset === undefined ? 3 : offset; 1367 | 1368 | var stack, include, i; 1369 | 1370 | if ( e.stacktrace ) { 1371 | // Opera 1372 | return e.stacktrace.split( "\n" )[ offset + 3 ]; 1373 | } else if ( e.stack ) { 1374 | // Firefox, Chrome 1375 | stack = e.stack.split( "\n" ); 1376 | if (/^error$/i.test( stack[0] ) ) { 1377 | stack.shift(); 1378 | } 1379 | if ( fileName ) { 1380 | include = []; 1381 | for ( i = offset; i < stack.length; i++ ) { 1382 | if ( stack[ i ].indexOf( fileName ) !== -1 ) { 1383 | break; 1384 | } 1385 | include.push( stack[ i ] ); 1386 | } 1387 | if ( include.length ) { 1388 | return include.join( "\n" ); 1389 | } 1390 | } 1391 | return stack[ offset ]; 1392 | } else if ( e.sourceURL ) { 1393 | // Safari, PhantomJS 1394 | // hopefully one day Safari provides actual stacktraces 1395 | // exclude useless self-reference for generated Error objects 1396 | if ( /qunit.js$/.test( e.sourceURL ) ) { 1397 | return; 1398 | } 1399 | // for actual exceptions, this is useful 1400 | return e.sourceURL + ":" + e.line; 1401 | } 1402 | } 1403 | function sourceFromStacktrace( offset ) { 1404 | try { 1405 | throw new Error(); 1406 | } catch ( e ) { 1407 | return extractStacktrace( e, offset ); 1408 | } 1409 | } 1410 | 1411 | /** 1412 | * Escape text for attribute or text content. 1413 | */ 1414 | function escapeText( s ) { 1415 | if ( !s ) { 1416 | return ""; 1417 | } 1418 | s = s + ""; 1419 | // Both single quotes and double quotes (for attributes) 1420 | return s.replace( /['"<>&]/g, function( s ) { 1421 | switch( s ) { 1422 | case "'": 1423 | return "'"; 1424 | case "\"": 1425 | return """; 1426 | case "<": 1427 | return "<"; 1428 | case ">": 1429 | return ">"; 1430 | case "&": 1431 | return "&"; 1432 | } 1433 | }); 1434 | } 1435 | 1436 | function synchronize( callback, last ) { 1437 | config.queue.push( callback ); 1438 | 1439 | if ( config.autorun && !config.blocking ) { 1440 | process( last ); 1441 | } 1442 | } 1443 | 1444 | function process( last ) { 1445 | function next() { 1446 | process( last ); 1447 | } 1448 | var start = new Date().getTime(); 1449 | config.depth = config.depth ? config.depth + 1 : 1; 1450 | 1451 | while ( config.queue.length && !config.blocking ) { 1452 | if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) { 1453 | config.queue.shift()(); 1454 | } else { 1455 | setTimeout( next, 13 ); 1456 | break; 1457 | } 1458 | } 1459 | config.depth--; 1460 | if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) { 1461 | done(); 1462 | } 1463 | } 1464 | 1465 | function saveGlobal() { 1466 | config.pollution = []; 1467 | 1468 | if ( config.noglobals ) { 1469 | for ( var key in window ) { 1470 | if ( hasOwn.call( window, key ) ) { 1471 | // in Opera sometimes DOM element ids show up here, ignore them 1472 | if ( /^qunit-test-output/.test( key ) ) { 1473 | continue; 1474 | } 1475 | config.pollution.push( key ); 1476 | } 1477 | } 1478 | } 1479 | } 1480 | 1481 | function checkPollution() { 1482 | var newGlobals, 1483 | deletedGlobals, 1484 | old = config.pollution; 1485 | 1486 | saveGlobal(); 1487 | 1488 | newGlobals = diff( config.pollution, old ); 1489 | if ( newGlobals.length > 0 ) { 1490 | QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") ); 1491 | } 1492 | 1493 | deletedGlobals = diff( old, config.pollution ); 1494 | if ( deletedGlobals.length > 0 ) { 1495 | QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") ); 1496 | } 1497 | } 1498 | 1499 | // returns a new Array with the elements that are in a but not in b 1500 | function diff( a, b ) { 1501 | var i, j, 1502 | result = a.slice(); 1503 | 1504 | for ( i = 0; i < result.length; i++ ) { 1505 | for ( j = 0; j < b.length; j++ ) { 1506 | if ( result[i] === b[j] ) { 1507 | result.splice( i, 1 ); 1508 | i--; 1509 | break; 1510 | } 1511 | } 1512 | } 1513 | return result; 1514 | } 1515 | 1516 | function extend( a, b ) { 1517 | for ( var prop in b ) { 1518 | if ( hasOwn.call( b, prop ) ) { 1519 | // Avoid "Member not found" error in IE8 caused by messing with window.constructor 1520 | if ( !( prop === "constructor" && a === window ) ) { 1521 | if ( b[ prop ] === undefined ) { 1522 | delete a[ prop ]; 1523 | } else { 1524 | a[ prop ] = b[ prop ]; 1525 | } 1526 | } 1527 | } 1528 | } 1529 | 1530 | return a; 1531 | } 1532 | 1533 | /** 1534 | * @param {HTMLElement} elem 1535 | * @param {string} type 1536 | * @param {Function} fn 1537 | */ 1538 | function addEvent( elem, type, fn ) { 1539 | // Standards-based browsers 1540 | if ( elem.addEventListener ) { 1541 | elem.addEventListener( type, fn, false ); 1542 | // IE 1543 | } else { 1544 | elem.attachEvent( "on" + type, fn ); 1545 | } 1546 | } 1547 | 1548 | /** 1549 | * @param {Array|NodeList} elems 1550 | * @param {string} type 1551 | * @param {Function} fn 1552 | */ 1553 | function addEvents( elems, type, fn ) { 1554 | var i = elems.length; 1555 | while ( i-- ) { 1556 | addEvent( elems[i], type, fn ); 1557 | } 1558 | } 1559 | 1560 | function hasClass( elem, name ) { 1561 | return (" " + elem.className + " ").indexOf(" " + name + " ") > -1; 1562 | } 1563 | 1564 | function addClass( elem, name ) { 1565 | if ( !hasClass( elem, name ) ) { 1566 | elem.className += (elem.className ? " " : "") + name; 1567 | } 1568 | } 1569 | 1570 | function removeClass( elem, name ) { 1571 | var set = " " + elem.className + " "; 1572 | // Class name may appear multiple times 1573 | while ( set.indexOf(" " + name + " ") > -1 ) { 1574 | set = set.replace(" " + name + " " , " "); 1575 | } 1576 | // If possible, trim it for prettiness, but not necessarily 1577 | elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, ""); 1578 | } 1579 | 1580 | function id( name ) { 1581 | return !!( typeof document !== "undefined" && document && document.getElementById ) && 1582 | document.getElementById( name ); 1583 | } 1584 | 1585 | function registerLoggingCallback( key ) { 1586 | return function( callback ) { 1587 | config[key].push( callback ); 1588 | }; 1589 | } 1590 | 1591 | // Supports deprecated method of completely overwriting logging callbacks 1592 | function runLoggingCallbacks( key, scope, args ) { 1593 | var i, callbacks; 1594 | if ( QUnit.hasOwnProperty( key ) ) { 1595 | QUnit[ key ].call(scope, args ); 1596 | } else { 1597 | callbacks = config[ key ]; 1598 | for ( i = 0; i < callbacks.length; i++ ) { 1599 | callbacks[ i ].call( scope, args ); 1600 | } 1601 | } 1602 | } 1603 | 1604 | // Test for equality any JavaScript type. 1605 | // Author: Philippe Rathé 1606 | QUnit.equiv = (function() { 1607 | 1608 | // Call the o related callback with the given arguments. 1609 | function bindCallbacks( o, callbacks, args ) { 1610 | var prop = QUnit.objectType( o ); 1611 | if ( prop ) { 1612 | if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) { 1613 | return callbacks[ prop ].apply( callbacks, args ); 1614 | } else { 1615 | return callbacks[ prop ]; // or undefined 1616 | } 1617 | } 1618 | } 1619 | 1620 | // the real equiv function 1621 | var innerEquiv, 1622 | // stack to decide between skip/abort functions 1623 | callers = [], 1624 | // stack to avoiding loops from circular referencing 1625 | parents = [], 1626 | parentsB = [], 1627 | 1628 | getProto = Object.getPrototypeOf || function ( obj ) { 1629 | /*jshint camelcase:false */ 1630 | return obj.__proto__; 1631 | }, 1632 | callbacks = (function () { 1633 | 1634 | // for string, boolean, number and null 1635 | function useStrictEquality( b, a ) { 1636 | /*jshint eqeqeq:false */ 1637 | if ( b instanceof a.constructor || a instanceof b.constructor ) { 1638 | // to catch short annotation VS 'new' annotation of a 1639 | // declaration 1640 | // e.g. var i = 1; 1641 | // var j = new Number(1); 1642 | return a == b; 1643 | } else { 1644 | return a === b; 1645 | } 1646 | } 1647 | 1648 | return { 1649 | "string": useStrictEquality, 1650 | "boolean": useStrictEquality, 1651 | "number": useStrictEquality, 1652 | "null": useStrictEquality, 1653 | "undefined": useStrictEquality, 1654 | 1655 | "nan": function( b ) { 1656 | return isNaN( b ); 1657 | }, 1658 | 1659 | "date": function( b, a ) { 1660 | return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf(); 1661 | }, 1662 | 1663 | "regexp": function( b, a ) { 1664 | return QUnit.objectType( b ) === "regexp" && 1665 | // the regex itself 1666 | a.source === b.source && 1667 | // and its modifiers 1668 | a.global === b.global && 1669 | // (gmi) ... 1670 | a.ignoreCase === b.ignoreCase && 1671 | a.multiline === b.multiline && 1672 | a.sticky === b.sticky; 1673 | }, 1674 | 1675 | // - skip when the property is a method of an instance (OOP) 1676 | // - abort otherwise, 1677 | // initial === would have catch identical references anyway 1678 | "function": function() { 1679 | var caller = callers[callers.length - 1]; 1680 | return caller !== Object && typeof caller !== "undefined"; 1681 | }, 1682 | 1683 | "array": function( b, a ) { 1684 | var i, j, len, loop, aCircular, bCircular; 1685 | 1686 | // b could be an object literal here 1687 | if ( QUnit.objectType( b ) !== "array" ) { 1688 | return false; 1689 | } 1690 | 1691 | len = a.length; 1692 | if ( len !== b.length ) { 1693 | // safe and faster 1694 | return false; 1695 | } 1696 | 1697 | // track reference to avoid circular references 1698 | parents.push( a ); 1699 | parentsB.push( b ); 1700 | for ( i = 0; i < len; i++ ) { 1701 | loop = false; 1702 | for ( j = 0; j < parents.length; j++ ) { 1703 | aCircular = parents[j] === a[i]; 1704 | bCircular = parentsB[j] === b[i]; 1705 | if ( aCircular || bCircular ) { 1706 | if ( a[i] === b[i] || aCircular && bCircular ) { 1707 | loop = true; 1708 | } else { 1709 | parents.pop(); 1710 | parentsB.pop(); 1711 | return false; 1712 | } 1713 | } 1714 | } 1715 | if ( !loop && !innerEquiv(a[i], b[i]) ) { 1716 | parents.pop(); 1717 | parentsB.pop(); 1718 | return false; 1719 | } 1720 | } 1721 | parents.pop(); 1722 | parentsB.pop(); 1723 | return true; 1724 | }, 1725 | 1726 | "object": function( b, a ) { 1727 | /*jshint forin:false */ 1728 | var i, j, loop, aCircular, bCircular, 1729 | // Default to true 1730 | eq = true, 1731 | aProperties = [], 1732 | bProperties = []; 1733 | 1734 | // comparing constructors is more strict than using 1735 | // instanceof 1736 | if ( a.constructor !== b.constructor ) { 1737 | // Allow objects with no prototype to be equivalent to 1738 | // objects with Object as their constructor. 1739 | if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) || 1740 | ( getProto(b) === null && getProto(a) === Object.prototype ) ) ) { 1741 | return false; 1742 | } 1743 | } 1744 | 1745 | // stack constructor before traversing properties 1746 | callers.push( a.constructor ); 1747 | 1748 | // track reference to avoid circular references 1749 | parents.push( a ); 1750 | parentsB.push( b ); 1751 | 1752 | // be strict: don't ensure hasOwnProperty and go deep 1753 | for ( i in a ) { 1754 | loop = false; 1755 | for ( j = 0; j < parents.length; j++ ) { 1756 | aCircular = parents[j] === a[i]; 1757 | bCircular = parentsB[j] === b[i]; 1758 | if ( aCircular || bCircular ) { 1759 | if ( a[i] === b[i] || aCircular && bCircular ) { 1760 | loop = true; 1761 | } else { 1762 | eq = false; 1763 | break; 1764 | } 1765 | } 1766 | } 1767 | aProperties.push(i); 1768 | if ( !loop && !innerEquiv(a[i], b[i]) ) { 1769 | eq = false; 1770 | break; 1771 | } 1772 | } 1773 | 1774 | parents.pop(); 1775 | parentsB.pop(); 1776 | callers.pop(); // unstack, we are done 1777 | 1778 | for ( i in b ) { 1779 | bProperties.push( i ); // collect b's properties 1780 | } 1781 | 1782 | // Ensures identical properties name 1783 | return eq && innerEquiv( aProperties.sort(), bProperties.sort() ); 1784 | } 1785 | }; 1786 | }()); 1787 | 1788 | innerEquiv = function() { // can take multiple arguments 1789 | var args = [].slice.apply( arguments ); 1790 | if ( args.length < 2 ) { 1791 | return true; // end transition 1792 | } 1793 | 1794 | return (function( a, b ) { 1795 | if ( a === b ) { 1796 | return true; // catch the most you can 1797 | } else if ( a === null || b === null || typeof a === "undefined" || 1798 | typeof b === "undefined" || 1799 | QUnit.objectType(a) !== QUnit.objectType(b) ) { 1800 | return false; // don't lose time with error prone cases 1801 | } else { 1802 | return bindCallbacks(a, callbacks, [ b, a ]); 1803 | } 1804 | 1805 | // apply transition with (1..n) arguments 1806 | }( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) ); 1807 | }; 1808 | 1809 | return innerEquiv; 1810 | }()); 1811 | 1812 | /** 1813 | * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | 1814 | * http://flesler.blogspot.com Licensed under BSD 1815 | * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008 1816 | * 1817 | * @projectDescription Advanced and extensible data dumping for Javascript. 1818 | * @version 1.0.0 1819 | * @author Ariel Flesler 1820 | * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html} 1821 | */ 1822 | QUnit.jsDump = (function() { 1823 | function quote( str ) { 1824 | return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\""; 1825 | } 1826 | function literal( o ) { 1827 | return o + ""; 1828 | } 1829 | function join( pre, arr, post ) { 1830 | var s = jsDump.separator(), 1831 | base = jsDump.indent(), 1832 | inner = jsDump.indent(1); 1833 | if ( arr.join ) { 1834 | arr = arr.join( "," + s + inner ); 1835 | } 1836 | if ( !arr ) { 1837 | return pre + post; 1838 | } 1839 | return [ pre, inner + arr, base + post ].join(s); 1840 | } 1841 | function array( arr, stack ) { 1842 | var i = arr.length, ret = new Array(i); 1843 | this.up(); 1844 | while ( i-- ) { 1845 | ret[i] = this.parse( arr[i] , undefined , stack); 1846 | } 1847 | this.down(); 1848 | return join( "[", ret, "]" ); 1849 | } 1850 | 1851 | var reName = /^function (\w+)/, 1852 | jsDump = { 1853 | // type is used mostly internally, you can fix a (custom)type in advance 1854 | parse: function( obj, type, stack ) { 1855 | stack = stack || [ ]; 1856 | var inStack, res, 1857 | parser = this.parsers[ type || this.typeOf(obj) ]; 1858 | 1859 | type = typeof parser; 1860 | inStack = inArray( obj, stack ); 1861 | 1862 | if ( inStack !== -1 ) { 1863 | return "recursion(" + (inStack - stack.length) + ")"; 1864 | } 1865 | if ( type === "function" ) { 1866 | stack.push( obj ); 1867 | res = parser.call( this, obj, stack ); 1868 | stack.pop(); 1869 | return res; 1870 | } 1871 | return ( type === "string" ) ? parser : this.parsers.error; 1872 | }, 1873 | typeOf: function( obj ) { 1874 | var type; 1875 | if ( obj === null ) { 1876 | type = "null"; 1877 | } else if ( typeof obj === "undefined" ) { 1878 | type = "undefined"; 1879 | } else if ( QUnit.is( "regexp", obj) ) { 1880 | type = "regexp"; 1881 | } else if ( QUnit.is( "date", obj) ) { 1882 | type = "date"; 1883 | } else if ( QUnit.is( "function", obj) ) { 1884 | type = "function"; 1885 | } else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) { 1886 | type = "window"; 1887 | } else if ( obj.nodeType === 9 ) { 1888 | type = "document"; 1889 | } else if ( obj.nodeType ) { 1890 | type = "node"; 1891 | } else if ( 1892 | // native arrays 1893 | toString.call( obj ) === "[object Array]" || 1894 | // NodeList objects 1895 | ( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) ) 1896 | ) { 1897 | type = "array"; 1898 | } else if ( obj.constructor === Error.prototype.constructor ) { 1899 | type = "error"; 1900 | } else { 1901 | type = typeof obj; 1902 | } 1903 | return type; 1904 | }, 1905 | separator: function() { 1906 | return this.multiline ? this.HTML ? "
" : "\n" : this.HTML ? " " : " "; 1907 | }, 1908 | // extra can be a number, shortcut for increasing-calling-decreasing 1909 | indent: function( extra ) { 1910 | if ( !this.multiline ) { 1911 | return ""; 1912 | } 1913 | var chr = this.indentChar; 1914 | if ( this.HTML ) { 1915 | chr = chr.replace( /\t/g, " " ).replace( / /g, " " ); 1916 | } 1917 | return new Array( this.depth + ( extra || 0 ) ).join(chr); 1918 | }, 1919 | up: function( a ) { 1920 | this.depth += a || 1; 1921 | }, 1922 | down: function( a ) { 1923 | this.depth -= a || 1; 1924 | }, 1925 | setParser: function( name, parser ) { 1926 | this.parsers[name] = parser; 1927 | }, 1928 | // The next 3 are exposed so you can use them 1929 | quote: quote, 1930 | literal: literal, 1931 | join: join, 1932 | // 1933 | depth: 1, 1934 | // This is the list of parsers, to modify them, use jsDump.setParser 1935 | parsers: { 1936 | window: "[Window]", 1937 | document: "[Document]", 1938 | error: function(error) { 1939 | return "Error(\"" + error.message + "\")"; 1940 | }, 1941 | unknown: "[Unknown]", 1942 | "null": "null", 1943 | "undefined": "undefined", 1944 | "function": function( fn ) { 1945 | var ret = "function", 1946 | // functions never have name in IE 1947 | name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1]; 1948 | 1949 | if ( name ) { 1950 | ret += " " + name; 1951 | } 1952 | ret += "( "; 1953 | 1954 | ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" ); 1955 | return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" ); 1956 | }, 1957 | array: array, 1958 | nodelist: array, 1959 | "arguments": array, 1960 | object: function( map, stack ) { 1961 | /*jshint forin:false */ 1962 | var ret = [ ], keys, key, val, i; 1963 | QUnit.jsDump.up(); 1964 | keys = []; 1965 | for ( key in map ) { 1966 | keys.push( key ); 1967 | } 1968 | keys.sort(); 1969 | for ( i = 0; i < keys.length; i++ ) { 1970 | key = keys[ i ]; 1971 | val = map[ key ]; 1972 | ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) ); 1973 | } 1974 | QUnit.jsDump.down(); 1975 | return join( "{", ret, "}" ); 1976 | }, 1977 | node: function( node ) { 1978 | var len, i, val, 1979 | open = QUnit.jsDump.HTML ? "<" : "<", 1980 | close = QUnit.jsDump.HTML ? ">" : ">", 1981 | tag = node.nodeName.toLowerCase(), 1982 | ret = open + tag, 1983 | attrs = node.attributes; 1984 | 1985 | if ( attrs ) { 1986 | for ( i = 0, len = attrs.length; i < len; i++ ) { 1987 | val = attrs[i].nodeValue; 1988 | // IE6 includes all attributes in .attributes, even ones not explicitly set. 1989 | // Those have values like undefined, null, 0, false, "" or "inherit". 1990 | if ( val && val !== "inherit" ) { 1991 | ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" ); 1992 | } 1993 | } 1994 | } 1995 | ret += close; 1996 | 1997 | // Show content of TextNode or CDATASection 1998 | if ( node.nodeType === 3 || node.nodeType === 4 ) { 1999 | ret += node.nodeValue; 2000 | } 2001 | 2002 | return ret + open + "/" + tag + close; 2003 | }, 2004 | // function calls it internally, it's the arguments part of the function 2005 | functionArgs: function( fn ) { 2006 | var args, 2007 | l = fn.length; 2008 | 2009 | if ( !l ) { 2010 | return ""; 2011 | } 2012 | 2013 | args = new Array(l); 2014 | while ( l-- ) { 2015 | // 97 is 'a' 2016 | args[l] = String.fromCharCode(97+l); 2017 | } 2018 | return " " + args.join( ", " ) + " "; 2019 | }, 2020 | // object calls it internally, the key part of an item in a map 2021 | key: quote, 2022 | // function calls it internally, it's the content of the function 2023 | functionCode: "[code]", 2024 | // node calls it internally, it's an html attribute value 2025 | attribute: quote, 2026 | string: quote, 2027 | date: quote, 2028 | regexp: literal, 2029 | number: literal, 2030 | "boolean": literal 2031 | }, 2032 | // if true, entities are escaped ( <, >, \t, space and \n ) 2033 | HTML: false, 2034 | // indentation unit 2035 | indentChar: " ", 2036 | // if true, items in a collection, are separated by a \n, else just a space. 2037 | multiline: true 2038 | }; 2039 | 2040 | return jsDump; 2041 | }()); 2042 | 2043 | // from jquery.js 2044 | function inArray( elem, array ) { 2045 | if ( array.indexOf ) { 2046 | return array.indexOf( elem ); 2047 | } 2048 | 2049 | for ( var i = 0, length = array.length; i < length; i++ ) { 2050 | if ( array[ i ] === elem ) { 2051 | return i; 2052 | } 2053 | } 2054 | 2055 | return -1; 2056 | } 2057 | 2058 | /* 2059 | * Javascript Diff Algorithm 2060 | * By John Resig (http://ejohn.org/) 2061 | * Modified by Chu Alan "sprite" 2062 | * 2063 | * Released under the MIT license. 2064 | * 2065 | * More Info: 2066 | * http://ejohn.org/projects/javascript-diff-algorithm/ 2067 | * 2068 | * Usage: QUnit.diff(expected, actual) 2069 | * 2070 | * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the quick ~~brown~~ fox ~~jumped~~ jumps over" 2071 | */ 2072 | QUnit.diff = (function() { 2073 | /*jshint eqeqeq:false, eqnull:true */ 2074 | function diff( o, n ) { 2075 | var i, 2076 | ns = {}, 2077 | os = {}; 2078 | 2079 | for ( i = 0; i < n.length; i++ ) { 2080 | if ( !hasOwn.call( ns, n[i] ) ) { 2081 | ns[ n[i] ] = { 2082 | rows: [], 2083 | o: null 2084 | }; 2085 | } 2086 | ns[ n[i] ].rows.push( i ); 2087 | } 2088 | 2089 | for ( i = 0; i < o.length; i++ ) { 2090 | if ( !hasOwn.call( os, o[i] ) ) { 2091 | os[ o[i] ] = { 2092 | rows: [], 2093 | n: null 2094 | }; 2095 | } 2096 | os[ o[i] ].rows.push( i ); 2097 | } 2098 | 2099 | for ( i in ns ) { 2100 | if ( hasOwn.call( ns, i ) ) { 2101 | if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) { 2102 | n[ ns[i].rows[0] ] = { 2103 | text: n[ ns[i].rows[0] ], 2104 | row: os[i].rows[0] 2105 | }; 2106 | o[ os[i].rows[0] ] = { 2107 | text: o[ os[i].rows[0] ], 2108 | row: ns[i].rows[0] 2109 | }; 2110 | } 2111 | } 2112 | } 2113 | 2114 | for ( i = 0; i < n.length - 1; i++ ) { 2115 | if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null && 2116 | n[ i + 1 ] == o[ n[i].row + 1 ] ) { 2117 | 2118 | n[ i + 1 ] = { 2119 | text: n[ i + 1 ], 2120 | row: n[i].row + 1 2121 | }; 2122 | o[ n[i].row + 1 ] = { 2123 | text: o[ n[i].row + 1 ], 2124 | row: i + 1 2125 | }; 2126 | } 2127 | } 2128 | 2129 | for ( i = n.length - 1; i > 0; i-- ) { 2130 | if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null && 2131 | n[ i - 1 ] == o[ n[i].row - 1 ]) { 2132 | 2133 | n[ i - 1 ] = { 2134 | text: n[ i - 1 ], 2135 | row: n[i].row - 1 2136 | }; 2137 | o[ n[i].row - 1 ] = { 2138 | text: o[ n[i].row - 1 ], 2139 | row: i - 1 2140 | }; 2141 | } 2142 | } 2143 | 2144 | return { 2145 | o: o, 2146 | n: n 2147 | }; 2148 | } 2149 | 2150 | return function( o, n ) { 2151 | o = o.replace( /\s+$/, "" ); 2152 | n = n.replace( /\s+$/, "" ); 2153 | 2154 | var i, pre, 2155 | str = "", 2156 | out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ), 2157 | oSpace = o.match(/\s+/g), 2158 | nSpace = n.match(/\s+/g); 2159 | 2160 | if ( oSpace == null ) { 2161 | oSpace = [ " " ]; 2162 | } 2163 | else { 2164 | oSpace.push( " " ); 2165 | } 2166 | 2167 | if ( nSpace == null ) { 2168 | nSpace = [ " " ]; 2169 | } 2170 | else { 2171 | nSpace.push( " " ); 2172 | } 2173 | 2174 | if ( out.n.length === 0 ) { 2175 | for ( i = 0; i < out.o.length; i++ ) { 2176 | str += "~~" + out.o[i] + oSpace[i] + "~~"; 2177 | } 2178 | } 2179 | else { 2180 | if ( out.n[0].text == null ) { 2181 | for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) { 2182 | str += "~~" + out.o[n] + oSpace[n] + "~~"; 2183 | } 2184 | } 2185 | 2186 | for ( i = 0; i < out.n.length; i++ ) { 2187 | if (out.n[i].text == null) { 2188 | str += "" + out.n[i] + nSpace[i] + ""; 2189 | } 2190 | else { 2191 | // `pre` initialized at top of scope 2192 | pre = ""; 2193 | 2194 | for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) { 2195 | pre += "~~" + out.o[n] + oSpace[n] + "~~"; 2196 | } 2197 | str += " " + out.n[i].text + nSpace[i] + pre; 2198 | } 2199 | } 2200 | } 2201 | 2202 | return str; 2203 | }; 2204 | }()); 2205 | 2206 | // for CommonJS environments, export everything 2207 | if ( typeof exports !== "undefined" ) { 2208 | extend( exports, QUnit.constructor.prototype ); 2209 | } 2210 | 2211 | // get at whatever the global object is, like window in browsers 2212 | }( (function() {return this;}.call()) )); 2213 | --------------------------------------------------------------------------------