├── .gitignore
├── test
    ├── callback-exported.js
    ├── non-jsbin.test.js
    ├── imported.test.js
    ├── callback.test.js
    └── loop-protect.test.js
├── .travis.yml
├── bower.json
├── package.json
├── LICENSE.md
├── lib
    └── index.js
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | node_modules
3 | tmp
4 | dist
5 | 


--------------------------------------------------------------------------------
/test/callback-exported.js:
--------------------------------------------------------------------------------
1 | export default function(line) {
2 |   console.log(`ok: ${line}`);
3 | }
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | sudo: false
2 | language: node_js
3 | notifications:
4 |   email: false
5 | node_js:
6 | - 8
7 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "loop-protect",
 3 |   "main": "dist/loop-protect.min.js",
 4 |   "version": "1.0.0",
 5 |   "homepage": "https://github.com/jsbin/loop-protect",
 6 |   "authors": [
 7 |     "Remy Sharp <remy@remysharp.com>"
 8 |   ],
 9 |   "description": "Prevent infinite loops in dynamically eval'd JavaScript.",
10 |   "moduleType": [
11 |     "globals",
12 |     "node"
13 |   ],
14 |   "keywords": [
15 |     "loop",
16 |     "jsbin"
17 |   ],
18 |   "license": "MIT",
19 |   "ignore": [
20 |     "**/.*",
21 |     "node_modules",
22 |     "bower_components",
23 |     "test"
24 |   ]
25 | }
26 | 


--------------------------------------------------------------------------------
/test/non-jsbin.test.js:
--------------------------------------------------------------------------------
 1 | /* eslint-env node, jest */
 2 | const Babel = require('babel-standalone');
 3 | Babel.registerPlugin('loopProtection', require('../lib')(100));
 4 | const assert = e => console.assert(e);
 5 | 
 6 | const loopProtect = code =>
 7 |   Babel.transform(new Function(code).toString(), {
 8 |     plugins: ['loopProtection'],
 9 |   }).code; // eslint-disable-line no-new-func
10 | const run = code => eval(`(${code})()`); // eslint-disable-line no-eval
11 | 
12 | describe('non-JS Bin use', () => {
13 |   it('should catch infinite loop', () => {
14 |     var code = 'var i = 0; while (true) {\ni++;\n}\nreturn "∞"';
15 | 
16 |     var processed = loopProtect(code);
17 | 
18 |     var result = run(processed);
19 |     assert(result === '∞', 'code ran and returned ' + result);
20 |   });
21 | });
22 | 


--------------------------------------------------------------------------------
/test/imported.test.js:
--------------------------------------------------------------------------------
 1 | /* eslint-env node, jest */
 2 | const Babel = require('babel-standalone');
 3 | const plugin = require('../lib');
 4 | import callback from './callback-exported';
 5 | 
 6 | const transform = id => code =>
 7 |   Babel.transform(new Function(code).toString(), {
 8 |     plugins: [id],
 9 |   }).code; // eslint-disable-line no-new-func
10 | 
11 | const run = code => {
12 |   // console.log(code);
13 |   eval(`(${code})()`); // eslint-disable-line no-eval
14 | };
15 | 
16 | describe('imported anonymous callback', () => {
17 |   it('uses imported callbacks', () => {
18 |     const id = 'i1';
19 | 
20 |     const code = `let i = 0;
21 |     while (true) {
22 |       i++;
23 |     }`;
24 | 
25 |     const spy = jest.fn();
26 |     global.console = { log: spy };
27 | 
28 |     // const spy = jest.spyOn(global.console, 'log');
29 | 
30 |     Babel.registerPlugin(id, plugin(100, callback));
31 |     const after = transform(id)(code);
32 |     run(after);
33 |     expect(spy).toHaveBeenCalledWith(`ok: 3`);
34 |   });
35 | });
36 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "Remy Sharp",
 3 |   "name": "loop-protect",
 4 |   "description": "Prevent infinite loops in dynamically eval'd JavaScript.",
 5 |   "main": "dist/",
 6 |   "version": "2.1.6",
 7 |   "homepage": "https://github.com/jsbin/loop-protect",
 8 |   "repository": {
 9 |     "type": "git",
10 |     "url": "git://github.com/jsbin/loop-protect.git"
11 |   },
12 |   "scripts": {
13 |     "test": "jest test/*.test.js",
14 |     "build": "NODE_ENV=production babel lib/ --out-dir dist --copy-files",
15 |     "prepublishOnly": "npm run build"
16 |   },
17 |   "files": [
18 |     "dist"
19 |   ],
20 |   "babel": {
21 |     "presets": [
22 |       "stage-0",
23 |       "env"
24 |     ]
25 |   },
26 |   "devDependencies": {
27 |     "babel-cli": "^6.26.0",
28 |     "babel-preset-env": "^1.6.1",
29 |     "babel-preset-stage-0": "^6.24.1",
30 |     "babel-runtime": "^6.26.0",
31 |     "babel-standalone": "^6.26.0",
32 |     "jest": "^22.0.6"
33 |   },
34 |   "licenses": [
35 |     {
36 |       "type": "MIT",
37 |       "url": "http://jsbin.mit-license.org"
38 |     }
39 |   ]
40 | }
41 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 JS Bin Ltd
 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 all
13 | 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 THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/test/callback.test.js:
--------------------------------------------------------------------------------
 1 | /* eslint-env node, jest */
 2 | const Babel = require('babel-standalone');
 3 | 
 4 | const code = `let i = 0; while (true) { i++; }; done(i)`;
 5 | 
 6 | let done = jest.fn();
 7 | 
 8 | beforeEach(() => {
 9 |   done = jest.fn();
10 | });
11 | 
12 | const transform = id => code =>
13 |   Babel.transform(new Function(code).toString(), {
14 |     plugins: [id],
15 |   }).code; // eslint-disable-line no-new-func
16 | 
17 | const run = code => {
18 |   // console.log(code);
19 |   eval(`(${code})()`); // eslint-disable-line no-eval
20 | };
21 | 
22 | test('no callback', () => {
23 |   const id = 'lp1';
24 |   Babel.registerPlugin(id, require('../lib')(100));
25 |   const after = transform(id)(code);
26 |   run(after);
27 |   expect(done).toBeCalledWith(expect.any(Number));
28 | });
29 | 
30 | test('anonymous callback', () => {
31 |   const id = 'lp2';
32 |   Babel.registerPlugin(
33 |     id,
34 |     require('../lib')(100, line => done(`line: ${line}`))
35 |   );
36 |   const after = transform(id)(code);
37 |   run(after);
38 |   expect(done).toHaveBeenCalledWith('line: 2');
39 | });
40 | 
41 | test('arrow function callback', () => {
42 |   const id = 'lp3';
43 |   const callback = line => done(`lp3: ${line}`);
44 | 
45 |   Babel.registerPlugin(id, require('../lib')(100, callback));
46 |   const after = transform(id)(code);
47 |   run(after);
48 |   expect(done).toHaveBeenCalledWith(`${id}: 2`);
49 | });
50 | 
51 | test('named function callback', () => {
52 |   const id = 'lp4';
53 |   function callback(line) {
54 |     done(`lp4: ${line}`);
55 |   }
56 | 
57 |   Babel.registerPlugin(id, require('../lib')(100, callback));
58 |   const after = transform(id)(code);
59 |   run(after);
60 |   expect(done).toHaveBeenCalledWith(`${id}: 2`);
61 | });
62 | 


--------------------------------------------------------------------------------
/lib/index.js:
--------------------------------------------------------------------------------
  1 | const generateBefore = (t, id) =>
  2 |   t.variableDeclaration('var', [
  3 |     t.variableDeclarator(
  4 |       id,
  5 |       t.callExpression(
  6 |         t.memberExpression(t.identifier('Date'), t.identifier('now')),
  7 |         []
  8 |       )
  9 |     ),
 10 |   ]);
 11 | 
 12 | const generateInside = ({ t, id, line, ch, timeout, extra } = {}) => {
 13 |   return t.ifStatement(
 14 |     t.binaryExpression(
 15 |       '>',
 16 |       t.binaryExpression(
 17 |         '-',
 18 |         t.callExpression(
 19 |           t.memberExpression(t.identifier('Date'), t.identifier('now')),
 20 |           []
 21 |         ),
 22 |         id
 23 |       ),
 24 |       t.numericLiteral(timeout)
 25 |     ),
 26 |     extra
 27 |       ? t.blockStatement([
 28 |           t.expressionStatement(
 29 |             t.callExpression(extra, [
 30 |               t.numericLiteral(line),
 31 |               t.numericLiteral(ch),
 32 |             ])
 33 |           ),
 34 |           t.breakStatement(),
 35 |         ])
 36 |       : t.breakStatement()
 37 |   );
 38 | };
 39 | 
 40 | const protect = (t, timeout, extra) => path => {
 41 |   if (!path.node.loc) {
 42 |     // I don't really know _how_ we get into this state
 43 |     // but https://jsbin.com/mipesawapi/1/ triggers it
 44 |     // and the node, I'm guessing after translation,
 45 |     // doesn't have a line in the code, so this blows up.
 46 |     return;
 47 |   }
 48 |   const id = path.scope.generateUidIdentifier('LP');
 49 |   const before = generateBefore(t, id);
 50 |   const inside = generateInside({
 51 |     t,
 52 |     id,
 53 |     line: path.node.loc.start.line,
 54 |     ch: path.node.loc.start.column,
 55 |     timeout,
 56 |     extra,
 57 |   });
 58 |   const body = path.get('body');
 59 | 
 60 |   // if we have an expression statement, convert it to a block
 61 |   if (!t.isBlockStatement(body)) {
 62 |     body.replaceWith(t.blockStatement([body.node]));
 63 |   }
 64 |   path.insertBefore(before);
 65 |   body.unshiftContainer('body', inside);
 66 | };
 67 | 
 68 | module.exports = (timeout = 100, extra = null) => {
 69 |   if (typeof extra === 'string') {
 70 |     const string = extra;
 71 |     extra = `() => console.error("${string.replace(/"/g, '\\"')}")`;
 72 |   } else if (extra !== null) {
 73 |     extra = extra.toString();
 74 |     if (extra.startsWith('function (')) {
 75 |       // fix anonymous functions as they'll cause
 76 |       // the callback transform to blow up
 77 |       extra = extra.replace(/^function \(/, 'function callback(');
 78 |     }
 79 |   }
 80 | 
 81 |   return ({ types: t, transform }) => {
 82 |     const node = extra ?
 83 |       transform(extra, { ast: true }).ast.program.body[0] : null;
 84 | 
 85 |     let callback = null;
 86 |     if (t.isExpressionStatement(node)) {
 87 |       callback = node.expression;
 88 |     } else if (t.isFunctionDeclaration(node)) {
 89 |       callback = t.functionExpression(null, node.params, node.body);
 90 |     }
 91 | 
 92 |     return {
 93 |       visitor: {
 94 |         WhileStatement: protect(t, timeout, callback),
 95 |         ForStatement: protect(t, timeout, callback),
 96 |         DoWhileStatement: protect(t, timeout, callback),
 97 |       },
 98 |     };
 99 |   };
100 | };
101 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Test status](https://api.travis-ci.org/jsbin/loop-protect.svg?branch=master)](https://travis-ci.org/jsbin/loop-protect)
  2 | 
  3 | # loop-protect
  4 | 
  5 | JS Bin's loop protection implementation as a reusable library.
  6 | 
  7 | This code protects use cases where user code includes an infinite loop using a `while`, `for` or `do` loop.
  8 | 
  9 | Note that this does *not* solve the [halting problem](http://en.wikipedia.org/wiki/Halting_problem) but simply rewrites JavaScript (using Babel's AST) wrapping loops with a conditional break. This also *does not* protect against recursive loops.
 10 | 
 11 | ## Example
 12 | 
 13 | With loop protection in place, it means that a user can enter the code as follows on JS Bin, and the final `console.log` will still work.
 14 | 
 15 | The code is transformed from this:
 16 | 
 17 | ```js
 18 | while (true) {
 19 |   doSomething();
 20 | }
 21 | 
 22 | console.log('All finished');
 23 | ```
 24 | 
 25 | …to this:
 26 | 
 27 | ```js
 28 | let i = 0;
 29 | var _LP = Date.now();
 30 | while (true) {
 31 |   if (Date.now() - _LP > 100)
 32 |     break;
 33 | 
 34 |   doSomething();
 35 | }
 36 | 
 37 | console.log('All finished');
 38 | ```
 39 | 
 40 | ## Usage
 41 | 
 42 | The loop protection is a babel transform, so can be used on the server or in the client.
 43 | 
 44 | The previous implementation used an injected library to handle tracking loops - this version does not.
 45 | 
 46 | ### Example (client) implementation
 47 | 
 48 | ```js
 49 | import Babel from 'babel-standalone';
 50 | import protect from 'loop-protect';
 51 | 
 52 | const timeout = 100; // defaults to 100ms
 53 | Babel.registerPlugin('loopProtection', protect(timeout));
 54 | 
 55 | const transform = source => Babel.transform(source, {
 56 |   plugins: ['loopProtection'],
 57 | }).code;
 58 | 
 59 | // rewrite the user's JavaScript to protect loops
 60 | var processed = transform(getUserCode());
 61 | 
 62 | // run in an iframe, and expose the loopProtect variable under a new name
 63 | var iframe = getNewFrame();
 64 | 
 65 | // append the iframe to allow our code to run as soon as .close is called
 66 | document.body.appendChild(iframe);
 67 | 
 68 | // open the iframe and write the code to it
 69 | var win = iframe.contentWindow;
 70 | var doc = win.document;
 71 | doc.open();
 72 | 
 73 | doc.write('<script>' + processed + '<' + '/script>');
 74 | doc.close();
 75 | 
 76 | // code now runs, and if there's an infinite loop, it's cleanly exited
 77 | ```
 78 | 
 79 | ### Optional Second Argument 
 80 | In the above implementation, when code transformed by loop-protect contains an infinite loop, the loop is cleanly exited with a `break` statement, and any code after the loop is executed normally. See [example](https://github.com/jsbin/loop-protect#example). 
 81 | 
 82 | But what if you want to log an error to the console to warn the user, or throw an error instead, to stop execution when an infinite loop is encountered? The `protect` function takes an optional second argument which can handle both behaviors. 
 83 | 
 84 | 1. To log an error to the console, but continue exectution after the loop, pass `protect` a string as a second argument. When an infinite loop is encountered, this string will be logged with `console.error()`, letting the user know of their mistake. 
 85 | 
 86 | 2. To throw an error and stop execution, pass `protect` a simple callback function which throws a new error. Note that if you define the callback with a `line` parameter, you can use this with a template literal for a more specific error message. For example:
 87 | 
 88 | ```js
 89 | import Babel from 'babel-standalone';
 90 | import protect from 'loop-protect';
 91 | 
 92 | const callback = line => {
 93 |   throw new Error(`Bad loop on line ${line}`);
 94 | };
 95 | 
 96 | const timeout = 100;
 97 | Babel.registerPlugin('loopProtection', protect(timeout, callback));
 98 | 
 99 | const transform = source => Babel.transform(source, {
100 |   plugins: ['loopProtection'],
101 | }).code;
102 |   
103 | var processed = transform(getUserCode());
104 | 
105 | // do more stuff with processed code here
106 | ```
107 | 
108 | With this implementation, the following would result:
109 | 
110 | ```js
111 | while (true) {
112 |   doSomething();
113 | }
114 | 
115 | console.log('All finished'); // does not execute
116 | 
117 | // Error: Bad loop on line 1
118 | ```
119 | 
120 | ## Contributors
121 | 
122 | - Author: [Remy Sharp](https://github.com/remy)
123 | - [All contributors](https://github.com/jsbin/loop-protect/graphs/contributors)
124 | 
125 | ## License
126 | 
127 | MIT / [http://jsbin.mit-license.org](http://jsbin.mit-license.org)
128 | 


--------------------------------------------------------------------------------
/test/loop-protect.test.js:
--------------------------------------------------------------------------------
  1 | /* eslint-env node, jest */
  2 | const Babel = require('babel-standalone');
  3 | Babel.registerPlugin('loopProtection', require('../lib')(100));
  4 | const assert = e => console.assert(e);
  5 | 
  6 | const code = {
  7 |   simple: 'return "remy";',
  8 |   simplefor:
  9 |     'var mul = 1; for (var i = 0; i < 10; i++) {\nmul = i;\n}\nreturn i',
 10 |   simplefor2:
 11 |     'var mul = 1; for (var i = 0; i < 10; i++) {\nmul = i;\n}\nreturn i',
 12 |   onelinefor: 'var i = 0, j = 0;\nfor (; i < 10; i++) j = i * 10;\nreturn i;',
 13 |   onelinefor2: 'var i=0;\nfor(i=0; i<10; ++i){ break; }\nreturn i;',
 14 |   simplewhile: 'var i = 0; while (i < 100) {\ni += 10;\n}\nreturn i;',
 15 |   onelinewhile: 'var i = 0; while (i < 100) i += 10;\nreturn i;',
 16 |   onelinewhile2: 'function noop(){}; while (1) noop("Ha.");',
 17 |   whiletrue: 'var i = 0;\nwhile(true) {\ni++;\n}\nreturn true;',
 18 |   irl1:
 19 |     'var nums = [0,1];\n var total = 8;\n for(var i = 0; i <= total; i++){\n var newest = nums[i--]\n nums.push(newest);\n }\n return i;',
 20 |   irl2:
 21 |     'var a = 0;\n for(var j=1;j<=2;j++)\n for(var i=1;i<=30000;i++) {\n a += 1;\n }\n return a;',
 22 |   notloops:
 23 |     'console.log("do");\nconsole.log("while");\nconsole.log(" foo do bar ");\nconsole.log(" foo while bar ");\nreturn true;',
 24 |   notprops:
 25 |     'var foo = { "do": "bar" }; if (foo["do"] && foo.do) {}\nreturn true;',
 26 |   notcomments: 'var foo = {}; // do the awesome-ness!\nreturn true;',
 27 |   dirtybraces:
 28 |     'var a = 0; for(var i=1;i<=10000; i++)\n {\n a += 1;\n }\nreturn a;',
 29 |   onelinenewliner:
 30 |     'var b=0;\n function f(){b+=1;}\n for(var j=1;j<10000; j++)\n f();\nreturn j;',
 31 |   irl3:
 32 |     'Todos.Todo = DS.Model.extend({\n title: DS.attr("string"),\n isCompleted: DS.attr("boolean")\n });',
 33 |   brackets:
 34 |     'var NUM=103, i, sqrt;\nfor(i=2; i<=Math.sqrt(NUM); i+=1){\n if(NUM % i === 0){\n  console.log(NUM + " can be divided by " + i + ".");\n  break;\n }\n}\nreturn i;',
 35 |   lotolines:
 36 |     'var LIMIT = 10;\nvar num, lastNum, tmp;\nfor(num = 1, lastNum = 0;\n  num < LIMIT;\n  lastNum = num, num = tmp){\n\n    tmp = num + lastNum;\n}\nreturn lastNum;',
 37 |   ignorecomments:
 38 |     '\n/**\n * This function handles the click for every button.\n *\n * Using the same function reduces code duplication and makes the\n */\nreturn true;',
 39 |   dowhile: 'var x=0;\ndo\n {\n x++;\n } while (x < 3);\nreturn x;',
 40 |   dowhilenested:
 41 |     'var x=0;\n do\n {\n x++;\n var b = 0;\n do {\n b++; \n } while (b < 3);\n } while (x < 3);\nreturn x;',
 42 |   infinitedowhile: 'var x=0;\ndo\n {\n x=0;\n } while (x < 3);\n return x;',
 43 |   disabled:
 44 |     '// noprotect\nvar x=0;\ndo\n {\n x++;\n } while (x < 3);\nreturn x;',
 45 |   continues:
 46 |     'var n = 0,\n i = 0,\n j = 0;\n \n outside:\n for (i; i < 10; i += 1) {\n for (j; j < 10; j += 1) {\n if (i === 5 && j === 5) {\n continue outside;\n }\n n += 1;\n }\n }\n \n return n;\n;',
 47 |   labelWithComment: `label:\n// here be a label\n/*\n and there's some good examples in the loop - poop\n*/\nfor (var i = 0; i < 10; i++) {\n}\nreturn i;`,
 48 |   continues2:
 49 |     'var x = 0;\nLABEL1: do {\n  x = x + 2;\n  if (x < 100) break LABEL1;\n  if (x < 100) continue LABEL1;\n} \nwhile(0);\n\nreturn x;',
 50 |   onelineforinline:
 51 |     'function init() {\n  for (var i=0;i<2;i++) (function(n) {\nconsole.log(i)})(i);\n}return true;',
 52 |   notlabels:
 53 |     'var foo = {\n bar: 1\n };\n \n function doit(i){}\n \n for (var i=0; i<10; i++) {\n doit(i);\n }\n return i;',
 54 |   notlabels2: '// Weird:\nfor (var i = 0; i < 10; i++) {}\nreturn i;',
 55 |   cs:
 56 |     'var bar, foo;\n\nfoo = function(i) {\n  return {\n    id: i\n  };\n};\n\nbar = function(i) {\n\n  var j, _i, _results;\n\n  _results = [];\n  for (j = _i = 1; 1 <= i ? _i < i : _i > i; j = 1 <= i ? ++_i : --_i) {\n    _results.push(j);\n  }\n  return _results;\n};',
 57 |   loopbehindif: 'if (false) {for (var i = 1; i--;) {throw Error;}}',
 58 |   badloopbehindif: 'if (false) for (var i = 1; i--;) {throw Error;}',
 59 |   loopwithoutbody: 'var i = 0;\nwhile(++i < 10);\n return i;',
 60 | };
 61 | 
 62 | const sinon = {
 63 |   spy: fn => jest.fn(fn),
 64 | };
 65 | 
 66 | var spy;
 67 | 
 68 | const loopProtect = code =>
 69 |   Babel.transform(new Function(code).toString(), {
 70 |     plugins: ['loopProtection'],
 71 |   }).code; // eslint-disable-line no-new-func
 72 | const run = code => eval(`(${code})()`); // eslint-disable-line no-eval
 73 | 
 74 | describe('loop', function() {
 75 |   beforeEach(function() {
 76 |     spy = sinon.spy(run);
 77 |   });
 78 | 
 79 |   // https://github.com/jsbin/loop-protect/issues/16
 80 |   it('should handle nested for', () => {
 81 |     const code = `for (var i = 0; i < 10; i = i + 1) {
 82 |           for (var j = 0; j < 10; i = i + 1) {
 83 |           }
 84 |       }
 85 |       return true`;
 86 | 
 87 |     const compiled = loopProtect(code);
 88 |     assert(run(compiled) === true);
 89 |   });
 90 | 
 91 |   it('console error when passing string', () => {
 92 |     const code = `var i = 0; while (true) i++; return true`;
 93 | 
 94 |     const spy = jest.fn();
 95 |     global.console.error = spy;
 96 | 
 97 |     Babel.registerPlugin(
 98 |       'loopProtectionAlt2',
 99 |       require('../lib')(100, 'Loop broken')
100 |     );
101 | 
102 |     const compiled = Babel.transform(new Function(code).toString(), {
103 |       plugins: ['loopProtectionAlt2'],
104 |     }).code; // eslint-disable-line no-new-func
105 |     expect(run(compiled)).toBe(true);
106 |     expect(spy).toHaveBeenCalled();
107 |   });
108 | 
109 |   it('throws when giving a custom function', () => {
110 |     const code = `var i = 0; while (true) i++; return true`;
111 |     const callback = line => {
112 |       throw new Error(`Bad loop on line ${line}`);
113 |     };
114 | 
115 |     Babel.registerPlugin('loopProtectionAlt', require('../lib')(100, callback));
116 | 
117 |     const compiled = Babel.transform(new Function(code).toString(), {
118 |       plugins: ['loopProtectionAlt'],
119 |     }).code; // eslint-disable-line no-new-func
120 | 
121 |     expect(() => {
122 |       run(compiled);
123 |     }).toThrowError('Bad loop on line 2');
124 |   });
125 | 
126 |   // https://github.com/jsbin/loop-protect/issues/5
127 |   it('blank line', () => {
128 |     const code = `const log = () => {};while (1)
129 | 
130 |     log('Hello')
131 |     return true`;
132 | 
133 |     const compiled = loopProtect(code);
134 |     assert(run(compiled) === true);
135 |   });
136 | 
137 |   it('with if', () => {
138 |     const code = `if (false) for (var i = 1; i--;) {
139 |       throw Error;
140 |   }
141 | 
142 |   return true;`;
143 | 
144 |     const compiled = loopProtect(code);
145 |     assert(run(compiled) === true);
146 |   });
147 | 
148 |   it('should ignore comments', function() {
149 |     var c = code.ignorecomments;
150 |     var compiled = loopProtect(c);
151 |     // console.log('\n---------\n' + c + '\n---------\n' + compiled);
152 |     var result = run(compiled);
153 |     assert(result === true);
154 |   });
155 | 
156 |   it('should rewrite for loops', function() {
157 |     var c = code.simplefor;
158 |     var compiled = loopProtect(c);
159 |     assert(compiled !== c);
160 |     var result = run(compiled);
161 |     assert(result === 10);
162 | 
163 |     c = code.simplefor2;
164 |     compiled = loopProtect(c);
165 |     assert(compiled !== c);
166 |     result = run(compiled);
167 |     assert(result === 10);
168 |   });
169 | 
170 |   it('should handle one liner for with an inline function', function() {
171 |     var c = code.onelineforinline;
172 |     var compiled = loopProtect(c);
173 |     assert(compiled !== c);
174 |     var result = run(compiled);
175 |     assert(result === true, 'value is ' + result);
176 |   });
177 | 
178 |   it('should rewrite one line for loops', function() {
179 |     var c = code.onelinefor;
180 |     var compiled = loopProtect(c);
181 |     assert(compiled !== c);
182 |     var result = run(compiled);
183 |     assert(result === 10);
184 | 
185 |     c = code.onelinefor2;
186 |     compiled = loopProtect(c);
187 |     assert(compiled !== c);
188 | 
189 |     // console.log('\n---------\n' + c + '\n---------\n' + compiled);
190 | 
191 |     result = run(compiled);
192 |     assert(result === 0);
193 |   });
194 | 
195 |   it('should rewrite one line while loops', function() {
196 |     var c = code.onelinewhile2;
197 |     var compiled = loopProtect(c);
198 |     assert(compiled !== c);
199 |     // console.log('\n---------\n' + c + '\n---------\n' + compiled);
200 |     var result = run(compiled);
201 |     assert(result === undefined);
202 |   });
203 | 
204 |   it('should protect infinite while', function() {
205 |     var c = code.whiletrue;
206 |     var compiled = loopProtect(c);
207 | 
208 |     assert(compiled !== c);
209 |     assert(spy(compiled) === true);
210 |   });
211 | 
212 |   it('should protect infinite for', function() {
213 |     var c = code.irl1;
214 |     var compiled = loopProtect(c);
215 |     assert(compiled !== c);
216 |     // assert(spy(compiled) === 0);
217 |   });
218 | 
219 |   it('should allow nested loops to run', function() {
220 |     var c = code.irl2;
221 |     var compiled = loopProtect(c);
222 |     // console.log('\n---------\n' + c + '\n---------\n' + compiled);
223 |     var r = run(compiled);
224 |     expect(compiled).not.toBe(c);
225 |     expect(r).toBe(60000);
226 |   });
227 | 
228 |   it('should rewrite loops when curlies are on the next line', function() {
229 |     var c = code.dirtybraces;
230 |     var compiled = loopProtect(c);
231 |     var r = spy(compiled);
232 |     assert(compiled !== c);
233 |     assert(r === 10000, r);
234 |   });
235 | 
236 |   it('should find one liners on multiple lines', function() {
237 |     var c = code.onelinenewliner;
238 |     var compiled = loopProtect(c);
239 |     var r = spy(compiled);
240 |     // console.log('\n----------');
241 |     // console.log(c);
242 |     // console.log('\n----------');
243 |     // console.log(compiled);
244 |     assert(compiled !== c, compiled);
245 |     assert(r === 10000, 'return value does not match 10000: ' + r);
246 |   });
247 | 
248 |   it('should handle brackets inside of loop conditionals', function() {
249 |     var c = code.brackets;
250 |     var compiled = loopProtect(c);
251 |     assert(compiled !== c);
252 |     assert(spy(compiled) === 11);
253 |   });
254 | 
255 |   it('should not corrupt multi-line (on more than one line) loops', function() {
256 |     var c = code.lotolines;
257 |     var compiled = loopProtect(c);
258 |     assert(compiled !== c);
259 |     assert(spy(compiled) === 8);
260 |   });
261 | 
262 |   it('should protect do loops', function() {
263 |     var c = code.dowhile;
264 |     var compiled = loopProtect(c);
265 |     assert(compiled !== c);
266 |     assert(spy(compiled) === 3);
267 | 
268 |     c = code.dowhilenested;
269 |     compiled = loopProtect(c);
270 |     // console.log('\n----------');
271 |     // console.log(c);
272 |     // console.log('\n----------');
273 |     // console.log(compiled);
274 |     assert(compiled !== c);
275 |     // assert(spy(compiled) === 3);
276 | 
277 |     c = code.infinitedowhile;
278 |     compiled = loopProtect(c);
279 |     assert(compiled !== c);
280 |     assert(spy(compiled) === 0);
281 |   });
282 | 
283 |   it('should handle loop statement without {}', function() {
284 |     var c = code.loopwithoutbody;
285 |     var compiled = loopProtect(c);
286 |     // console.log('\n---------\n' + c + '\n---------\n' + compiled);
287 |     assert(compiled !== c);
288 |     var result = run(compiled);
289 |     assert(result === 10);
290 |   });
291 | });
292 | 
293 | describe('labels', function() {
294 |   beforeEach(function() {
295 |     spy = sinon.spy(run);
296 |   });
297 | 
298 |   it('should handle continue statements and gotos', function() {
299 |     var c = code.continues;
300 |     var compiled = loopProtect(c);
301 |     assert(spy(compiled) === 10);
302 | 
303 |     c = code.continues2;
304 |     compiled = loopProtect(c);
305 |     assert(spy(compiled) === 2);
306 |   });
307 | 
308 |   it('should handle labels with comments', function() {
309 |     var c = code.labelWithComment;
310 |     var compiled = loopProtect(c);
311 |     assert(spy(compiled) === 10);
312 |   });
313 | 
314 |   it('should handle things that *look* like labels', function() {
315 |     var c = code.notlabels2;
316 |     var compiled = loopProtect(c);
317 |     assert(compiled !== c);
318 |     var result = run(compiled);
319 |     assert(result === 10, 'actual ' + result);
320 | 
321 |     c = code.notlabels;
322 |     compiled = loopProtect(c);
323 |     assert(compiled !== c);
324 |     result = run(compiled);
325 |     assert(result === 10, 'actual ' + result);
326 | 
327 |     // c = code.cs;
328 |     // compiled = loopProtect(c);
329 |     // assert(compiled !== c);
330 |     // result = run(compiled);
331 |     // assert(result === 10, 'actual ' + result);
332 |   });
333 | 
334 |   it('should handle if statement without {}', function() {
335 |     var c = code.loopbehindif;
336 |     var compiled = loopProtect(c);
337 |     assert(compiled !== c);
338 |     run(compiled);
339 | 
340 |     c = code.badloopbehindif;
341 |     compiled = loopProtect(c);
342 |     assert(compiled !== c);
343 |     run(compiled);
344 |   });
345 | });
346 | 


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