natural 0.2.1 → 0.4.0

package/spec/sentence_analyzer_spec.js

@@ -1,277 +0,0 @@
-/*
-Copyright (c) 2011, Rob Ellis, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-var SentenceAnalyzer = require('../lib/natural/analyzers/sentence_analyzer');
-
-describe('sentence analyzer', function() {
-    it('should load', function() {
-        var analyzer = new SentenceAnalyzer(null, function() { });
-    });
-
-    it('should determine PP and SP, given a POS', function () {
-        var sentenceTags = [
-            {token: 'The', pos: 'DT'},
-            {token: 'angry', pos: 'JJ'},
-            {token: 'bear', pos: 'NN'},
-            {token: 'chased', pos: 'VB'},
-            {token: 'the', pos: 'DT'},
-            {token: 'frightened', pos: 'JJ'},
-            {token: 'little', pos: 'JJ'},
-            {token: 'squirrel', pos: 'NN'}
-        ];
-        new SentenceAnalyzer({tags: sentenceTags}, function (analyzer) {
-            analyzer.part(function (part) {
-                var posTags = part.posObj.tags;
-                for (var tagNum = 0; tagNum < posTags.length; tagNum++) {
-                    var posTag = posTags[tagNum];
-                    if (posTag.token === 'angry') {
-                        expect(posTag.spos).toEqual('SP');
-                    } else if (posTag.token === 'squirrel') {
-                        expect(posTag.spos).toEqual('PP');
-                    }
-                }
-                expect(analyzer.subjectToString().trim()).toEqual('The angry bear');
-                expect(analyzer.predicateToString().trim()).toEqual('chased the frightened little squirrel');
-                expect(analyzer.toString().trim()).toEqual('The angry bear chased the frightened little squirrel');
-                expect(analyzer.implicitYou()).toEqual(false);
-            });
-        });
-    });
-
-    it('should determine PP and SP given a POS that begins with a verb', function () {
-        var sentenceTags = [
-            {token: 'Vote', pos: 'VB'},
-            {token: 'for', pos: 'IN'},
-            {token: 'me', pos: 'PRP'}
-        ];
-        new SentenceAnalyzer({tags: sentenceTags}, function (analyzer) {
-            analyzer.part(function (part) {
-                var posTags = part.posObj.tags;
-                for (var tagNum = 0; tagNum < posTags.length; tagNum++) {
-                    var posTag = posTags[tagNum];
-                    if (posTag.token === 'Vote') {
-                        expect(posTag.spos).toEqual('PP');
-                    } else if (posTag.token === 'me') {
-                        expect(posTag.pp).toEqual(true);
-                    }
-                }
-                // Adds implicit you.
-                var lastTagNum = posTags.length - 1;
-                expect(posTags[lastTagNum].token).toEqual('You');
-                expect(posTags[lastTagNum].pos).toEqual('PRP');
-                expect(posTags[lastTagNum].added).toEqual(true);
-                expect(analyzer.implicitYou()).toEqual(true);
-            });
-        });
-    });
-
-    it('should look for EX before VB', function () {
-        var sentenceTags = [
-            {token: 'There', pos: 'EX'},
-            {token: 'is', pos: 'VB'},
-            {token: 'a', pos: 'DT'},
-            {token: 'house', pos: 'NN'},
-            {token: 'in', pos: 'IN'},
-            {token: 'the', pos: 'DT'},
-            {token: 'valley', pos: 'DT'}
-        ];
-        new SentenceAnalyzer({tags: sentenceTags}, function (analyzer) {
-            analyzer.part(function (part) {
-                var posTags = part.posObj.tags;
-                for (var tagNum = 0; tagNum < posTags.length; tagNum++) {
-                    var posTag = posTags[tagNum];
-                    if (posTag.token === 'There') {
-                        expect(posTag.spos).toEqual('SP');
-                    } else if (posTag.token === 'is') {
-                        expect(posTag.spos).toEqual('SP');
-                    }
-                }
-                expect(analyzer.subjectToString().trim()).toEqual('There is a house');
-                expect(analyzer.predicateToString().trim()).toEqual('');
-                expect(analyzer.toString().trim()).toEqual('There is a house in the valley');
-                expect(analyzer.implicitYou()).toEqual(false);
-            });
-        });
-    });
-
-    describe('#type', function () {
-
-        it('should determine a command without punctuation', function () {
-            var sentenceTags = [
-                {token: 'Vote', pos: 'VB'},
-                {token: 'for', pos: 'IN'},
-                {token: 'me', pos: 'PRP'}
-            ];
-            var punct = function () {
-                return [];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('COMMAND');
-                    });
-                });
-            });
-        });
-
-        it('should determine an interrogative beginning with who', function () {
-            var sentenceTags = [
-                {token: 'Who', pos: 'WP'},
-                {token: 'voted', pos: 'VB'}
-            ];
-            var punct = function () {
-                return [];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('INTERROGATIVE');
-                    });
-                });
-            });
-        });
-
-        it('should determine an interrogative ending with a personal pronoun', function () {
-            var sentenceTags = [
-                {token: 'Should', pos: 'MD'},
-                {token: 'we', pos: 'PRP'}
-            ];
-            var punct = function () {
-                return '';
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('INTERROGATIVE');
-                    });
-                });
-            });
-        });
-
-        it('should classify other sentences as unknown', function () {
-            var sentenceTags = [
-                {token: 'I', pos: 'PRP'},
-                {token: 'am', pos: 'VB'},
-                {token: 'unsure', pos: 'JJ'}
-            ];
-            var punct = function () {
-                return '';
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('UNKNOWN');
-                    });
-                });
-            });
-        });
-
-        it('should determine an interrogative ending with a question mark', function () {
-            var sentenceTags = [
-                {token: 'Do', pos: 'VB'},
-                {token: 'I', pos: 'PRP'},
-                {token: 'care', pos: 'VB'}
-            ];
-            var punct = function () {
-                return [{token: '?', pos: '.'}];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('INTERROGATIVE');
-                    });
-                });
-            });
-        });
-
-        it('should determine a command ending in an exclamation point', function () {
-            var sentenceTags = [
-                {token: 'Vote', pos: 'VB'},
-                {token: 'for', pos: 'IN'},
-                {token: 'me', pos: 'PRP'}
-            ];
-            var punct = function () {
-                return [{token: '!', pos: '.'}];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('COMMAND');
-                    });
-                });
-            });
-        });
-
-        it('should determine an exclamation ending in an exclamation point', function () {
-            var sentenceTags = [
-                {token: 'We', pos: 'PRP'},
-                {token: 'like', pos: 'VB'},
-                {token: 'sheep', pos: 'NN'}
-            ];
-            var punct = function () {
-                return [{token: '!', pos: '.'}];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('EXCLAMATORY');
-                    });
-                });
-            });
-        });
-
-        it('should determine a command ending with .', function () {
-            var sentenceTags = [
-                {token: 'Vote', pos: 'VB'},
-                {token: 'for', pos: 'IN'},
-                {token: 'me', pos: 'PRP'}
-            ];
-            var punct = function () {
-                return [{token: '.', pos: '.'}];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    analyzer.type(function (type) {
-                        expect(analyzer.senType).toEqual('COMMAND');
-                    });
-                });
-            });
-        });
-
-        it('should determine a declaration ending with a .', function () {
-            var sentenceTags = [
-                {token: 'We', pos: 'PRP'},
-                {token: 'like', pos: 'VB'},
-                {token: 'sheep', pos: 'NN'}
-            ];
-            var punct = function () {
-                return [{token: '.', pos: '.'}];
-            };
-            new SentenceAnalyzer({tags: sentenceTags, punct: punct}, function (analyzer) {
-                analyzer.part(function () {
-                    type = analyzer.type();
-                    expect(type).toEqual('DECLARATIVE');
-                });
-            });
-        });
-    });
-});

package/spec/shortest_path_tree_spec.js

@@ -1,132 +0,0 @@
-/*
- Copyright (c) 2014, Lee Wenzhu
-
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- */
-'use strict';
-
-var SPT = require('../lib/natural/util/shortest_path_tree'),
-    Topological = require('../lib/natural/util/topological'),
-    EdgeWeightedDigraph = require('../lib/natural/util/edge_weighted_digraph');
-
-describe("shortest path tree", function() {
-    var digraph = new EdgeWeightedDigraph();
-    digraph.add(5,4,0.35);
-    digraph.add(4,7,0.37);
-    digraph.add(5,7,0.28);
-    digraph.add(5,1,0.32);
-    digraph.add(4,0,0.38);
-    digraph.add(0,2,0.26);
-    digraph.add(3,7,0.39);
-    digraph.add(1,3,0.29);
-    digraph.add(7,2,0.34);
-    digraph.add(6,2,0.40);
-    digraph.add(3,6,0.52);
-    digraph.add(6,0,0.58);
-    digraph.add(6,4,0.93);
-    describe("edge weighted digraph normal operations", function() {
-        it("should get the numbers of vertexs", function() {
-            expect(digraph.v()).toBe(8);
-        });
-        it("should get the numbers of edges", function() {
-            expect(digraph.e()).toBe(13);
-        });
-        it("should print all item in digraph", function() {
-            expect(digraph.toString()).toBe('0 -> 2, 0.26\n' +
-                                            '1 -> 3, 0.29\n' +
-                                            '3 -> 7, 0.39\n' +
-                                            '3 -> 6, 0.52\n' +
-                                            '4 -> 7, 0.37\n' +
-                                            '4 -> 0, 0.38\n' +
-                                            '5 -> 4, 0.35\n' +
-                                            '5 -> 7, 0.28\n' +
-                                            '5 -> 1, 0.32\n' +
-                                            '6 -> 2, 0.4\n' +
-                                            '6 -> 0, 0.58\n' +
-                                            '6 -> 4, 0.93\n' +
-                                            '7 -> 2, 0.34');
-        });
-    });
-
-    describe("topo sort for digraph", function() {
-        it("should sort all the vertexs", function() {
-            var topoSort = new Topological(digraph);
-            expect(topoSort.isDAG()).toBe(true);
-            expect(topoSort.order()).toEqual([ 5, 1, 3, 6, 4, 7, 0, 2 ]);
-        });
-    });
-
-    describe("shortest path tree normal operations", function() {
-        var lpt = new SPT(digraph, 5);
-        expect(lpt.hasPathTo(0)).toBe(true);
-        expect(lpt.hasPathTo(1)).toBe(true);
-        expect(lpt.hasPathTo(2)).toBe(true);
-        expect(lpt.hasPathTo(3)).toBe(true);
-        expect(lpt.hasPathTo(4)).toBe(true);
-        expect(lpt.hasPathTo(5)).toBe(false);
-        expect(lpt.hasPathTo(6)).toBe(true);
-        expect(lpt.hasPathTo(7)).toBe(true);
-        expect(lpt.pathTo(0)).toEqual([ 5, 4, 0 ]);
-        expect(lpt.pathTo(1)).toEqual([ 5, 1 ]);
-        expect(lpt.pathTo(2)).toEqual([ 5, 7, 2 ]);
-        expect(lpt.pathTo(3)).toEqual([ 5, 1, 3 ]);
-        expect(lpt.pathTo(4)).toEqual([ 5, 4 ]);
-        expect(lpt.pathTo(5)).toEqual([ ]);
-        expect(lpt.pathTo(6)).toEqual([ 5, 1, 3, 6 ]);
-        expect(lpt.pathTo(7)).toEqual([ 5, 7 ]);
-        expect(lpt.getDistTo(0)).toBe(0.73);
-        expect(lpt.getDistTo(1)).toBe(0.32);
-        expect(lpt.getDistTo(2)).toBe(0.62);
-        expect(lpt.getDistTo(3)).toBe(0.61);
-        expect(lpt.getDistTo(4)).toBe(0.35);
-        expect(lpt.getDistTo(5)).toBe(0);
-        expect(lpt.getDistTo(6)).toBe(1.13);
-        expect(lpt.getDistTo(7)).toBe(0.28);
-    });
-
-    /**
-     * Check the issue #150
-     **/
-     describe("lightest weight path", function(){
-        it("should find the lightest weight path", function(){
-            var digraph = new EdgeWeightedDigraph();
-
-            digraph.add(1,3,0.29);
-            digraph.add(1,6,0);
-            digraph.add(3,6,0);
-
-            var spt = new SPT(digraph, 1);
-            var path = spt.pathTo(6);
-            expect(path).toEqual([1,6]);
-        });
-        it("should find the lightest weight path", function(){
-            var digraph = new EdgeWeightedDigraph();
-
-            digraph.add(1,3,-1);
-            digraph.add(1,6,0);
-            digraph.add(3,6,0);
-
-            var spt = new SPT(digraph, 1);
-            var path = spt.pathTo(6);
-            var hasPath = spt.hasPathTo(6);
-            expect(hasPath).toBe(true);
-            expect(path).toEqual([1,3,6]);
-        });
-     });
-});

package/spec/soundex_spec.js

@@ -1,158 +0,0 @@
-/*
-Copyright (c) 2011, Chris Umbel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-var soundex = require('../lib/natural/phonetics/soundex');
-
-describe('soundex', function() {   
-    describe('transformLipps', function() {
-        it('should replace B, F, P, and V with 1', function() {
-            expect(soundex.transformLipps('bopper')).toBe('1o11er');
-            expect(soundex.transformLipps('valumf')).toBe('1alum1');
-        });
-    });
-    
-    describe('transformThroats', function() {
-        it('should replace C, G, J, K, Q, S, X, Z with 2', function() {
-            expect(soundex.transformLipps('bopper')).toBe('1o11er');
-            expect(soundex.transformLipps('valumf')).toBe('1alum1');
-        });
-    });
-    
-    describe('transformTongue', function() {
-        it('should replace D and T with 3', function() {
-            expect(soundex.transformToungue('dat')).toBe('3a3');
-        });
-    });
-
-    describe('transformL', function() {
-        it('should replace L with 4', function() {
-            expect(soundex.transformL('lala')).toBe('4a4a');
-        });
-    });
-    
-    describe('transformHum', function() {
-        it('should replace M and N with 5', function() {
-            expect(soundex.transformHum('mummification')).toBe('5u55ificatio5');
-        });
-    });
-    
-    describe('transformR', function() {
-        it('should replace R with 6', function() {
-            expect(soundex.transformR('render')).toBe('6ende6');
-        });
-    });
-    
-    describe('condense', function() {
-        it('sound condense sequences', function() {
-            expect(soundex.condense('11222556')).toBe('1256');
-        });
-    });
-    
-    describe('padRight0', function() {
-        it('sound padd zeros on the right to a lenght of 3', function() {
-            expect(soundex.padRight0('1')).toBe('100');
-            expect(soundex.padRight0('11')).toBe('110');
-            expect(soundex.padRight0('111')).toBe('111');            
-        });        
-    });
-    
-    it('should not code the first character', function() {
-        expect(soundex.process('render').charAt(0)).toBe('R');
-    });
-    
-    it('should pad right with zeros', function() {
-        expect(soundex.process('super')).toBe('S160');
-        expect(soundex.process('butt')).toBe('B300');
-        expect(soundex.process('a')).toBe('A000');        
-    });
-    
-    it('should pad right with zeros', function() {
-        expect(soundex.process('but')).toBe('B300');
-    });
-    
-    it('should perform soundex', function() {
-        expect(soundex.process('BLACKBERRY')).toBe('B421');
-        expect(soundex.process('blackberry')).toBe('B421');
-        expect(soundex.process('calculate')).toBe('C424');
-        expect(soundex.process('CALCULATE')).toBe('C424');
-        expect(soundex.process('fox')).toBe('F200');
-        expect(soundex.process('FOX')).toBe('F200');
-        expect(soundex.process('jump')).toBe('J510');
-        expect(soundex.process('JUMP')).toBe('J510');
-        expect(soundex.process('phonetics')).toBe('P532');
-        expect(soundex.process('PHONETICS')).toBe('P532');
-
-    });
-    
-    it('should perform soundex via compare method', function() {
-        expect(soundex.compare('ant', 'and')).toBeTruthy();
-        expect(soundex.compare('ant', 'anne')).toBeFalsy();
-        expect(soundex.compare('band', 'bant')).toBeTruthy();
-        expect(soundex.compare('band', 'gand')).toBeFalsy();
-    });
-    
-    it('should perform soundex via attached soundsLike String patch', function() {
-        soundex.attach();
-        expect('ant'.soundsLike('ant')).toBeTruthy();
-        expect('ant'.soundsLike('anne')).toBeFalsy();
-        expect('band'.soundsLike('bant')).toBeTruthy();
-        expect('band'.soundsLike('gand')).toBeFalsy();
-    });
-    
-    it('should return string phonetics with string patch', function() {
-        soundex.attach();
-        expect('phonetics'.phonetics()).toBe('P532');
-        expect('PHONETICS'.phonetics()).toBe('P532');        
-    });
-
-    it('issue 221 -- inital vowels that duplicate cons codes', function() {
-        soundex.attach();
-        expect('Lloyd'.phonetics()).toBe('L300');
-        expect('Pfister'.phonetics()).toBe('P236');
-
-        expect('manhattan'.phonetics()).toBe('M535');
-        expect('Lukasiewicz'.phonetics()).toBe('L222');        
-
-        expect('Gauss'.phonetics()).toBe('G200');        
-        expect('Tymczak'.phonetics()).toBe('T522');        
-        expect('Jackson'.phonetics()).toBe('J250');                                
-    });    
-    
-    it('should tokenize and return string phonetics with string patch', function() {
-        soundex.attach();
-        expect('phonetics'.tokenizeAndPhoneticize()).toEqual(['P532']);
-        expect('phonetics jump'.tokenizeAndPhoneticize()).toEqual(['P532', 'J510']);
-        expect('phonetics jump calculate'.tokenizeAndPhoneticize()).toEqual(['P532', 'J510', 'C424']);        
-    });      
-
-    it('should max out at four characters long by default', function() {
-        expect(soundex.process('supercalifragilisticexpialidocious').length).toBe(4);
-    });    
-
-    it('should truncate to specified length if maxLength passed', function() {
-        expect(soundex.process('supercalifragilisticexpialidocious', 8).length).toBe(8);
-    });    
-
-    it('should handle a maxLength beyond code length', function() {
-        expect(soundex.process('JUMP', 8)).toBe('J510');
-    });
-});

package/spec/spellcheck_spec.js

@@ -1,92 +0,0 @@
-
-
-var Spellcheck = require('../lib/natural/spellcheck/spellcheck.js');
-
-describe('spellcheck', function() {
-    
-    describe('distance 1 corrections', function() {
-        var spellcheck = new Spellcheck(['something']);
-        
-        it('should fix deletions', function() {
-            expect(spellcheck.getCorrections('smething')).toContain('something');
-        });
-        it('should fix insertions', function() {
-            expect(spellcheck.getCorrections('somethhing')).toContain('something');
-        });
-        it('should fix transpositions', function() {
-            expect(spellcheck.getCorrections('somehting')).toContain('something');
-        });
-        it('should fix replacements', function() {
-            expect(spellcheck.getCorrections('sometzing')).toContain('something');
-        });
-    });
-
-    describe('distance 2 corrections', function() {
-        var spellcheck = new Spellcheck(['something']);
-
-        it('should fix a deletion then a transposition', function() {
-            expect(spellcheck.getCorrections('smtehing', 2)).toContain('something');
-        });
-    });
-
-    describe('edits', function() {
-        var spellcheck = new Spellcheck([]);
-        var edits = spellcheck.edits('ab');
-
-        it('should compute insertions', function() {
-            var insertions = ['xab', 'axb', 'abx'];
-            for(var i in insertions) {
-                expect(edits.indexOf(insertions[i])).toBeGreaterThan(-1);
-            }
-        });
-        it('should compute deletions', function() {
-            var deletions = ['a', 'b']; 
-            for(var i in deletions) {
-                expect(edits.indexOf(deletions[i])).toBeGreaterThan(-1);
-            }
-        });
-        it('should compute transpositions', function() {
-            var transpositions = ['ba']
-            for(var i in transpositions) {
-                expect(edits.indexOf(transpositions[i])).toBeGreaterThan(-1);
-            }
-        });
-        it('should compute replacements', function() {
-            var replacements = ['zb', 'af']
-            for(var i in replacements) {
-                expect(edits.indexOf(replacements[i])).toBeGreaterThan(-1);
-            }
-        });
-    });
-
-    describe('edits up to distance', function() {
-        var spellcheck = new Spellcheck([]);
-        
-        it('should correctly compute edits at distance', function() {
-            var edits = spellcheck.editsWithMaxDistance('abc', 2);
-            expect(edits[1].indexOf('abzc')).toBeGreaterThan(-1); // 1 insertion
-            expect(edits[2].indexOf('a')).toBeGreaterThan(-1); // 2 deletions 
-        });
-    });
-
-    describe('boolean spellcheck', function() {
-        var spellcheck = new Spellcheck(['cat']);
-
-        it('should consider cat a word', function() {
-            expect(spellcheck.isCorrect('cat')).toBe(true);
-        });
-
-        it('should not consider dog a word', function() {
-            expect(spellcheck.isCorrect('dog')).toBe(false);
-        });
-    });
-
-    describe('special cases', function() {
-        var spellcheck = new Spellcheck(['cat']);
-
-        it('should return the input word as the most probable correction if it is already correct', function() {
-            expect(spellcheck.getCorrections('cat').indexOf('cat')).toBe(0);
-        });
-
-    });
-});