├── index.html
├── README.md
├── .gitignore
├── .eslintrc.yaml
├── LICENSE.txt
├── docs
    ├── intro
    │   ├── XCeptor.png
    │   ├── index.html
    │   └── README.md
    └── index.html
├── tests
    ├── upload.html
    ├── abort.html
    ├── overrided.html
    ├── amd.html
    ├── without-new.html
    ├── responsetype.html
    ├── extends-from-xhr.html
    ├── header-case.html
    ├── illegal-invocation.html
    ├── consts.html
    ├── ng-file-upload.html
    ├── ng-file-upload-xceptor-first.html
    ├── thenable.html
    ├── sync.html
    ├── inject-with-prop.html
    ├── sync-load-event.html
    ├── loaded-duplicately.html
    ├── match-request.html
    ├── jquery2.html
    ├── full-sections-get.html
    ├── basic.html
    ├── addeventlistener.html
    └── all-methods.html
├── package.json
└── src
    └── xceptor.js


/index.html:
--------------------------------------------------------------------------------
1 | docs/index.html


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | docs -> https://yanagieiichi.github.io/xceptor/
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .*
2 | .gitignore
3 | node_modules
4 | /xceptor.js
5 | 


--------------------------------------------------------------------------------
/.eslintrc.yaml:
--------------------------------------------------------------------------------
1 | ---
2 | extends: eslint:recommended
3 | env:
4 |   browser: true
5 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
1 | MIT LICENSE
2 | Copyright 2015 YanagiEiichi, yanagieiichi@web-tinker.com
3 | 
4 | 


--------------------------------------------------------------------------------
/docs/intro/XCeptor.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/YanagiEiichi/xceptor/HEAD/docs/intro/XCeptor.png


--------------------------------------------------------------------------------
/tests/upload.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | var xhr = new XMLHttpRequest();
 5 | xhr.open('POST', '?');
 6 | xhr.upload.onprogress = () => {
 7 |   Tester.feedback(true);
 8 | };
 9 | xhr.send('a');
10 | </script>
11 | 


--------------------------------------------------------------------------------
/tests/abort.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | let xhr = new XMLHttpRequest();
 5 | xhr.open('GET', '?');
 6 | xhr.onabort = () => {
 7 |   Tester.feedback(true);
 8 | };
 9 | xhr.send();
10 | xhr.abort();
11 | </script>
12 | 


--------------------------------------------------------------------------------
/tests/overrided.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | let XHR = XMLHttpRequest;
 5 | XMLHttpRequest = function(...args) {
 6 |   return new XHR(...args);
 7 | };
 8 | new XMLHttpRequest();
 9 | Tester.feedback(true);
10 | </script>
11 | 


--------------------------------------------------------------------------------
/tests/amd.html:
--------------------------------------------------------------------------------
1 | <script src="/tester.js"></script>
2 | <script src="//cdn.bootcss.com/require.js/2.3.2/require.min.js"></script>
3 | <script>
4 | require.config({ paths: { XCeptor: '../xceptor' } });
5 | require(['XCeptor'], function(XCeptor) {
6 |   Tester.feedback(XCeptor === XMLHttpRequest.XCeptor);
7 | });
8 | </script>
9 | 


--------------------------------------------------------------------------------
/tests/without-new.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | try {
 5 |   XMLHttpRequest();
 6 | } catch (error) {
 7 |   Tester.assert(error instanceof TypeError);
 8 |   Tester.assert(/XMLHttpRequest/.test(error.message));
 9 |   Tester.feedback(true);
10 | }
11 | </script>
12 | 


--------------------------------------------------------------------------------
/tests/responsetype.html:
--------------------------------------------------------------------------------
 1 | XCeptor
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | var xhr = new XMLHttpRequest();
 6 | xhr.open('GET', '?');
 7 | xhr.responseType = 'arraybuffer';
 8 | xhr.addEventListener('load', function() {
 9 |   var bytes = [].slice.call(new Uint8Array(xhr.response), 0, 7);
10 |   Tester.feedback(String.fromCharCode.apply(String, bytes) === 'XCeptor');
11 | });
12 | xhr.send();
13 | </script>
14 | 


--------------------------------------------------------------------------------
/tests/extends-from-xhr.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script>
 4 | window.OriginalXHR = XMLHttpRequest;
 5 | </script>
 6 | <script src="/xceptor.js"></script>
 7 | <script>
 8 | Tester.assert(window.OriginalXHR !== XMLHttpRequest);
 9 | let xhr = new XMLHttpRequest();
10 | Tester.assert(xhr instanceof XMLHttpRequest);
11 | Tester.assert(xhr instanceof window.OriginalXHR);
12 | Tester.feedback(true);
13 | </script>
14 | 


--------------------------------------------------------------------------------
/tests/header-case.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | XCeptor.get(/^/, function(req, res) {
 5 |   res.status = 200;
 6 |   res.statusText = 'OK';
 7 |   res.responseText = 'hehe';
 8 |   res.headers = [ { header: 'HehE', value: 'hehe' } ];
 9 |   return false;
10 | });
11 | 
12 | var xhr = new XMLHttpRequest();
13 | xhr.open('GET', '/');
14 | xhr.onload = function() {
15 |   Tester.feedback(xhr.getResponseHeader('hehe') === 'hehe');
16 | };
17 | xhr.send();
18 | </script>
19 | 


--------------------------------------------------------------------------------
/tests/illegal-invocation.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | [
 5 |   'abort',
 6 |   'getAllResponseHeaders',
 7 |   'getResponseHeader',
 8 |   'overrideMimeType',
 9 |   'open',
10 |   'send',
11 |   'setRequestHeader'
12 | ].forEach(key => {
13 |   try {
14 |     XMLHttpRequest.prototype[key]()
15 |     Tester.assert(false);
16 |   } catch (error) {
17 |     Tester.assert(error instanceof TypeError);
18 |     Tester.log(key + ' => ' + error.message);
19 |   }
20 | });
21 | Tester.feedback(true);
22 | </script>
23 | 


--------------------------------------------------------------------------------
/tests/consts.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | let keys = Object.keys(XMLHttpRequest);
 6 | 
 7 | Tester.assert(keys.length >= 5, `keys.length must not be less than 5, but ${keys.length}`);
 8 | 
 9 | keys.forEach((name, index) => {
10 |   if (index >= 5) return;
11 |   Tester.assert(XMLHttpRequest[name] === index, `XMLHttpRequest.${name} must be ${index}`);
12 |   Tester.assert(XMLHttpRequest[name] === index, `XMLHttpRequest.${name} must be ${index}`);
13 |   Tester.log(`${name} is ${index}`);
14 | });
15 | 
16 | Tester.feedback(true);
17 | </script>
18 | 


--------------------------------------------------------------------------------
/tests/ng-file-upload.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/angular.js/1.5.8/angular.min.js"></script>
 2 | <script src="//github.elemecdn.com/danialfarid/ng-file-upload/12.2.13/dist/ng-file-upload.js"></script>
 3 | <script src="/tester.js"></script>
 4 | <script src="/xceptor.js"></script>
 5 | <script>
 6 | XCeptor.when(/^/, /^/, () => {});
 7 | angular.module('app', [ 'ngFileUpload' ]).run(($rootScope, Upload) => {
 8 |   let file = new Blob([ 'abc' ], { type: 'text/plain' });
 9 |   Upload.upload({
10 |     url: '?',
11 |     data: { file: file, 'username': $rootScope.username }
12 |   }).then(function () {
13 |     Tester.feedback(true);
14 |   }, function (resp) {
15 |     Tester.feedback(true);
16 |   });
17 | });
18 | </script>
19 | <body ng-app="app"></body>
20 | 


--------------------------------------------------------------------------------
/tests/ng-file-upload-xceptor-first.html:
--------------------------------------------------------------------------------
 1 | <script src="/xceptor.js"></script>
 2 | <script src="//cdn.bootcss.com/angular.js/1.5.8/angular.min.js"></script>
 3 | <script src="//github.elemecdn.com/danialfarid/ng-file-upload/12.2.13/dist/ng-file-upload.js"></script>
 4 | <script src="/tester.js"></script>
 5 | <script>
 6 | XCeptor.when(/^/, /^/, () => {});
 7 | angular.module('app', [ 'ngFileUpload' ]).run(($rootScope, Upload) => {
 8 |   let file = new Blob([ 'abc' ], { type: 'text/plain' });
 9 |   Upload.upload({
10 |     url: '?',
11 |     data: { file: file, 'username': $rootScope.username }
12 |   }).then(function () {
13 |     Tester.feedback(true);
14 |   }, function (resp) {
15 |     Tester.feedback(true);
16 |   });
17 | });
18 | </script>
19 | <body ng-app="app"></body>
20 | 


--------------------------------------------------------------------------------
/tests/thenable.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | var expection = new Tester.Expection(100, 200);
 6 | 
 7 | expection.then(function() {
 8 |   Tester.feedback(true);
 9 | }, function() {
10 |   Tester.feedback(false);
11 | });
12 | 
13 | XCeptor.get(/^/, function(req, res) {
14 |   res.status = 204;
15 |   return { then: function(resolve) {
16 |     setTimeout(function() {
17 |       resolve(false);
18 |     }, 200);
19 |   } };
20 | });
21 | 
22 | setTimeout(function() {
23 |   Tester.log(100);
24 |   expection.answer(100);
25 | }, 100);
26 | 
27 | $.get('?').then(function() {
28 |   Tester.log(200);
29 |   expection.answer(200);
30 | });
31 | </script>
32 | 


--------------------------------------------------------------------------------
/tests/sync.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | XCeptor.get('/hello', function(req, res) {
 5 |   res.responseText = 'hello';
 6 |   return false;
 7 | });
 8 | 
 9 | XCeptor.get('?', null, function(req, res) {
10 |   res.responseText = String(res.responseText.length);
11 | });
12 | 
13 | var xhr1 = new XMLHttpRequest();
14 | xhr1.open('GET', '/hello', false);
15 | xhr1.send();
16 | Tester.log(xhr1.responseText);
17 | Tester.assert(xhr1.responseText === 'hello', 'Must be "hello"');
18 | 
19 | var xhr2 = new XMLHttpRequest();
20 | xhr2.open('GET', '?', false);
21 | xhr2.send();
22 | Tester.log(xhr2.responseText);
23 | Tester.assert(xhr2.responseText === '692', 'Must be "692"');
24 | 
25 | setTimeout(function() {
26 |   Tester.feedback(true);
27 | }, 200);
28 | </script>
29 | 


--------------------------------------------------------------------------------
/tests/inject-with-prop.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | let expection = new Tester.Expection(
 6 |   1, 1,
 7 |   2, 2,
 8 |   3, 3,
 9 |   4, 4
10 | ).feedback();
11 | 
12 | let desc = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, 'readyState');
13 | Object.defineProperty(XMLHttpRequest.prototype, 'readyState', {
14 |   set: value => Tester.feedback(false),
15 |   get: function() {
16 |     let value = desc.get.call(this);
17 |     expection.answer(value);
18 |     return value;
19 |   }
20 | });
21 | 
22 | let xhr = new XMLHttpRequest();
23 | xhr.onreadystatechange = () => {
24 |   expection.answer(xhr.readyState);
25 | };
26 | xhr.open('GET', '/');
27 | xhr.send();
28 | </script>
29 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <meta http-equiv="X-UA-Compatible" content="chrome=1" />
 6 |     <meta name="renderer" content="webkit" />
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no, maximum-scale=1.0, minimum-scale=1.0" />
 8 |     <script>
 9 |       if (!window.fetch) document.write('<script src="//github.elemecdn.com/uglifyjs!github/fetch/v0.11.0/fetch.js"><\/script>');
10 |     </script>
11 |     <script src="//yanagieiichi.github.io/reciper/index.js"></script>
12 |     <script>
13 |       fetch('/xceptor/package.json').then(function(response) { return response.json(); }).then(function(pkg) {
14 |         var config = pkg.reciperConfig;
15 |         config.name = pkg.name;
16 |         config.description = pkg.description;
17 |         reciper(config);
18 |       });
19 |     </script>
20 |   </head>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/docs/intro/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8" />
 5 |     <meta http-equiv="X-UA-Compatible" content="chrome=1" />
 6 |     <meta name="renderer" content="webkit" />
 7 |     <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no, maximum-scale=1.0, minimum-scale=1.0" />
 8 |     <script>
 9 |       if (!window.fetch) document.write('<script src="//github.elemecdn.com/uglifyjs!github/fetch/v0.11.0/fetch.js"><\/script>');
10 |     </script>
11 |     <script src="//yanagieiichi.github.io/reciper/index.js"></script>
12 |     <script>
13 |       fetch('/xceptor/package.json').then(function(response) { return response.json(); }).then(function(pkg) {
14 |         var config = pkg.reciperConfig;
15 |         config.name = pkg.name;
16 |         config.description = pkg.description;
17 |         reciper(config);
18 |       });
19 |     </script>
20 |   </head>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/tests/sync-load-event.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | XCeptor.get('/hello', function(req, res) {
 5 |   res.responseText = 'hello';
 6 |   return false;
 7 | });
 8 | 
 9 | XCeptor.get('/hehe', null, function(req, res) {
10 |   res.responseText = 'hehe';
11 | });
12 | 
13 | var expection = new Tester.Expection(1, 2, 3).feedback();
14 | 
15 | var xhr1 = new XMLHttpRequest();
16 | xhr1.open('GET', '/hello', false);
17 | xhr1.addEventListener('load', function() {
18 |   Tester.log(xhr1.responseText);
19 |   Tester.assert(xhr1.responseText === 'hello', 'Must be "hello"');
20 |   expection.answer(1);
21 | });
22 | xhr1.send();
23 | 
24 | var xhr2 = new XMLHttpRequest();
25 | xhr2.open('GET', '/hehe', false);
26 | xhr2.addEventListener('load', function() {
27 |   Tester.log(xhr2.responseText);
28 |   Tester.assert(xhr2.responseText === 'hehe', 'Must be "hehe"');
29 |   expection.answer(2);
30 | });
31 | xhr2.send();
32 | 
33 | expection.answer(3);
34 | </script>
35 | 


--------------------------------------------------------------------------------
/tests/loaded-duplicately.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | XCeptor.get(/^\/api/, function(req, res) {
 6 |   res.responseText = 'Hello';
 7 | });
 8 | </script>
 9 | <script src="/xceptor.js"></script>
10 | <script>
11 | XCeptor.get(/^\/api/, function(req, res) {
12 |   res.status = 200;
13 |   res.statusText = 'OK';
14 |   res.responseText += ' World';
15 |   return false;
16 | });
17 | </script>
18 | <script src="/xceptor.js"></script>
19 | <script>
20 | $.when(
21 |   $.get('/api').then(function(text, state, response) {
22 |     Tester.assert(response.status === 200);
23 |     Tester.assert(response.responseText === 'Hello World');
24 |   }),
25 |   $.get('/api').then(function(text, state, response) {
26 |     Tester.assert(response.status === 200);
27 |     Tester.assert(response.responseText === 'Hello World');
28 |   })
29 | ).then(function() {
30 |   Tester.feedback(true);
31 | }, function() {
32 |   Tester.feedback(false);
33 | });
34 | </script>
35 | 


--------------------------------------------------------------------------------
/tests/match-request.html:
--------------------------------------------------------------------------------
 1 | <html ng-app="test">
 2 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 3 | <script src="/tester.js"></script>
 4 | <script src="/xceptor.js"></script>
 5 | <script>
 6 | var answer;
 7 | 
 8 | XCeptor.when('GET', /^\/fuck/, function(req, res) {
 9 |   Tester.log(0);
10 |   answer = [];
11 |   res.headers = [
12 |     { header: 'Content-Type', value: 'application/json' }
13 |   ];
14 |   res.responseText = JSON.stringify(answer);
15 |   req.url = '/xxxx';
16 | });
17 | 
18 | XCeptor.when('GET', /^\/xxxx/, function(req, res) {
19 |   Tester.log(1);
20 |   answer.push(1);
21 |   res.status = 200;
22 |   res.responseText = JSON.stringify(answer);
23 |   return false;
24 | });
25 | 
26 | XCeptor.when('GET', /^\/fuck/, function(req, res) {
27 |   Tester.log(2);
28 |   answer.push(2);
29 |   res.responseText = JSON.stringify(answer);
30 |   return false;
31 | });
32 | 
33 | $.ajax({ method: 'get', url: '/fuck' }).then(function(data) {
34 |   Tester.assert(JSON.stringify(data) === '[1]', 'response data must be [1]');
35 |   Tester.feedback(true);
36 | }, function() {
37 |   Tester.feedback(false);
38 | });
39 | </script>
40 | 


--------------------------------------------------------------------------------
/tests/jquery2.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script>
 3 | if(!-[1,]) {
 4 |   Tester.log('IE 8 ignore');
 5 |   Tester.feedback(true);
 6 |   document.write('<!--');
 7 | }
 8 | </script>
 9 | <script src="//cdn.bootcss.com/jquery/2.2.4/jquery.min.js"></script>
10 | <script src="/xceptor.js"></script>
11 | <script>
12 | XCeptor.get(/^\/api/, function(req, res) {
13 |   res.responseText = 'Hello';
14 | });
15 | 
16 | XCeptor.get(/^\/api/, function(req, res) {
17 |   // Set a 200 response
18 |   res.status = 200;
19 |   res.statusText = 'OK';
20 |   // Set data
21 |   res.responseText += ' World';
22 |   // Do not launch
23 |   return false;
24 | });
25 | 
26 | $.when(
27 |   $.get('?'),
28 |   $.get('/api').then(function(text, state, response) {
29 |     Tester.assert(response.status === 200);
30 |     Tester.assert(response.responseText === 'Hello World');
31 |   }),
32 |   $.get('/api').then(function(text, state, response) {
33 |     Tester.assert(response.status === 200);
34 |     Tester.assert(response.responseText === 'Hello World');
35 |   })
36 | ).then(function() {
37 |   Tester.feedback(true);
38 | }, function() {
39 |   Tester.feedback(false);
40 | });
41 | </script>
42 | 


--------------------------------------------------------------------------------
/tests/full-sections-get.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | var answer;
 6 | 
 7 | XCeptor.get(/^\/api/, function(req, res) {
 8 |   Tester.log(1);
 9 |   answer = [1];
10 | }, function(req, res) {
11 |   Tester.log(4);
12 |   answer.push(4);
13 | });
14 | 
15 | XCeptor.get(/^\/api/, function(req, res) {
16 |   Tester.log(2);
17 |   answer.push(2);
18 | }, function(req, res) {
19 |   Tester.log(5);
20 |   answer.push(5);
21 | });
22 | 
23 | XCeptor.get(/^\/api/, function(req, res) {
24 |   Tester.log(3);
25 |   answer.push(3);
26 |   // Do not launch
27 |   return false;
28 | }, function(req, res) {
29 |   Tester.log(6);
30 |   answer.push(6);
31 |   // Set status to 200
32 |   res.status = 200;
33 |   res.statusText = 'OK';
34 |   res.headers = [
35 |     { header: 'Content-Type', value: 'application/json' }
36 |   ];
37 |   res.responseText = JSON.stringify(answer);
38 | });
39 | 
40 | $.get('/api').then(function(data, state, response) {
41 |   Tester.assert(data.join('') === '123456', 'the result must be 123456');
42 |   Tester.feedback(true);
43 | }).then(null, function(e) {
44 |   Tester.feedback(false);
45 | });
46 | </script>
47 | 


--------------------------------------------------------------------------------
/tests/basic.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | XCeptor.get(/^\/api/, function(req, res) {
 6 |   res.responseText = 'Hello';
 7 |   Tester.log(res.responseText);
 8 | });
 9 | 
10 | XCeptor.get(/^\/api/, function(req, res) {
11 |   // Set a 200 response
12 |   res.status = 200;
13 |   res.statusText = 'OK';
14 |   // Set data
15 |   res.responseText += ' World';
16 |   Tester.log(res.responseText);
17 |   // Do not launch
18 |   return false;
19 | });
20 | 
21 | $.when(
22 |   $.get('?').then(function() {
23 |     Tester.log('?');
24 |   }),
25 |   $.get('/api').then(function(text, state, response) {
26 |     Tester.log('/api 1');
27 |     Tester.assert(response.status === 200, 'status must be 200');
28 |     Tester.assert(response.responseText === 'Hello World', 'responseText error');
29 |   }),
30 |   $.get('/api').then(function(text, state, response) {
31 |     Tester.log('/api 2');
32 |     Tester.assert(response.status === 200, 'status must be 200');
33 |     Tester.assert(response.responseText === 'Hello World', 'responseText error');
34 |   })
35 | ).then(function() {
36 |   Tester.feedback(true);
37 | }, function() {
38 |   Tester.feedback(false);
39 | });
40 | </script>
41 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "xceptor",
 3 |   "version": "0.4.0",
 4 |   "description": "AN INTERCEPTOR OF XHR",
 5 |   "main": "xceptor.js",
 6 |   "directories": {
 7 |     "test": "tests"
 8 |   },
 9 |   "scripts": {
10 |     "prepublish": "global2umd src/xceptor.js XCeptor > xceptor.js",
11 |     "test": "npm run lint && npm run prepublish && ui-tester-start tests",
12 |     "lint": "eslint src"
13 |   },
14 |   "repository": {
15 |     "type": "git",
16 |     "url": "git+https://github.com/YanagiEiichi/xceptor.git"
17 |   },
18 |   "author": "YanagiEiichi",
19 |   "license": "MIT",
20 |   "bugs": {
21 |     "url": "https://github.com/YanagiEiichi/xceptor/issues"
22 |   },
23 |   "homepage": "https://github.com/YanagiEiichi/xceptor#readme",
24 |   "devDependencies": {
25 |     "eslint": "^5.15.3",
26 |     "global2umd": "0.0.1",
27 |     "ui-tester": "^1.2.2"
28 |   },
29 |   "reciperConfig": {
30 |     "darkColor": "#333",
31 |     "normalColor": "#666",
32 |     "primaryColor": "#000",
33 |     "logoUrl": "",
34 |     "languages": [
35 |       "xml",
36 |       "markdown",
37 |       "bash"
38 |     ],
39 |     "home": "/xceptor/",
40 |     "items": [
41 |       {
42 |         "text": "Introduction",
43 |         "href": "/xceptor/docs/intro/"
44 |       },
45 |       {
46 |         "text": "Github",
47 |         "href": "//github.com/YanagiEiichi/xceptor/",
48 |         "target": "_blank"
49 |       }
50 |     ]
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/tests/addeventlistener.html:
--------------------------------------------------------------------------------
 1 | <script src="/tester.js"></script>
 2 | <script src="/xceptor.js"></script>
 3 | <script>
 4 | XCeptor.get('/', function(req, res) {
 5 |   res.responseText = 'Hello';
 6 |   return false;
 7 | });
 8 | 
 9 | var expection = new Tester.Expection(
10 |   'send',
11 |   'readystatechange to 4',
12 |   'load event 1',
13 |   'load event 2',
14 |   'onload',
15 |   'done'
16 | );
17 | 
18 | expection.then(function() {
19 |   Tester.feedback(true);
20 | }, function() {
21 |   Tester.feedback(false);
22 | });
23 | 
24 | setTimeout(function() {
25 |   expection.answer('done');
26 | }, 200);
27 | 
28 | var xhr = new XMLHttpRequest();
29 | xhr.open('GET', '/');
30 | 
31 | xhr.send();
32 | 
33 | Tester.log('after send');
34 | expection.answer('send');
35 | 
36 | xhr.addEventListener('load', function() {
37 |   Tester.log('load event 1');
38 |   expection.answer('load event 1');
39 | });
40 | 
41 | xhr.addEventListener('load', function() {
42 |   Tester.log('load event 2');
43 |   expection.answer('load event 2');
44 | });
45 | 
46 | var handler3 = function() {
47 |   Tester.log('load event 3');
48 |   expection.answer('load event 3');
49 | };
50 | xhr.addEventListener('load', handler3);
51 | xhr.removeEventListener('load', handler3);
52 | 
53 | xhr.onload = function() {
54 |   Tester.log('onload');
55 |   expection.answer('onload');
56 | };
57 | 
58 | xhr.addEventListener('readystatechange', function() {
59 |   if(xhr.readyState < 4) return;
60 |   Tester.log('readystatechange to 4');
61 |   expection.answer('readystatechange to 4');
62 | });
63 | </script>
64 | 


--------------------------------------------------------------------------------
/tests/all-methods.html:
--------------------------------------------------------------------------------
 1 | <script src="//cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
 2 | <script src="/tester.js"></script>
 3 | <script src="/xceptor.js"></script>
 4 | <script>
 5 | XCeptor.when(/^/, /^\/api/, function(req, res) {
 6 |   res.status = 200;
 7 |   res.responseText = req.method;
 8 |   return false;
 9 | });
10 | 
11 | var requests = [
12 |   $.ajax({ method: 'get', url: '/api' }).then(function(method) {
13 |     Tester.log(method);
14 |     Tester.assert(method === 'GET', 'method must be GET');
15 |   }),
16 |   $.ajax({ method: 'post', url: '/api' }).then(function(method) {
17 |     Tester.log(method);
18 |     Tester.assert(method === 'POST', 'method must be POST');
19 |   }),
20 |   $.ajax({ method: 'delete', url: '/api' }).then(function(method) {
21 |     Tester.log(method);
22 |     Tester.assert(method === 'DELETE', 'method must be DELETE');
23 |   }),
24 |   $.ajax({ method: 'put', url: '/api' }).then(function(method) {
25 |     Tester.log(method);
26 |     Tester.assert(method === 'PUT', 'method must be PUT');
27 |   }),
28 |   $.ajax({ method: 'head', url: '/api' }).then(function(response) {
29 |     Tester.log('head');
30 |     Tester.assert(response === void 0, 'response must be undefined');
31 |   })
32 | ];
33 | 
34 | if(!-[1,]) {
35 |   Tester.log('IE 8 ignore');
36 | } else {
37 |   requests.push(
38 |     $.ajax({ method: 'patch', url: '/api' }).then(function(method) {
39 |       Tester.log(method);
40 |       Tester.assert(method === 'PATCH', 'method must be PATCH');
41 |     })
42 |   );
43 | }
44 | 
45 | $.when.apply($, requests).then(function() {
46 |   Tester.feedback(true);
47 | }, function() {
48 |   Tester.feedback(false);
49 | });
50 | </script>
51 | 


--------------------------------------------------------------------------------
/docs/intro/README.md:
--------------------------------------------------------------------------------
 1 | ## XCeptor
 2 | 
 3 | An interceptor of [XHR](https://xhr.spec.whatwg.org/).
 4 | 
 5 | ## Install
 6 | 
 7 | ```bash
 8 | npm install xceptor
 9 | ```
10 | 
11 | ## Usage
12 | 
13 | ```javascript
14 | XCeptor.when(method, route, requestHandler, responseHandler);
15 | ```
16 | 
17 | | name            | type             | meaning               |
18 | | --------------- | ---------------- | --------------------- |
19 | | method          | RegExp or String | HTTP Method Matcher   |
20 | | route           | RegExp or String | Request Path Matcher  |
21 | | requestHandler  | Function         | Request Hook Handler  |
22 | | responseHandler | Function         | Response Hook Handler |
23 | 
24 | In addition, some shortcut methods are provided:
25 | 
26 | ```javascript
27 | XCeptor.get(...args);
28 | XCeptor.post(...args);
29 | XCeptor.put(...args);
30 | XCeptor.delete(...args);
31 | XCeptor.patch(...args);
32 | ```
33 | 
34 | ## Schematic Diagram
35 | 
36 | <img src="XCeptor.png" width="538" height="458" />
37 | 
38 | ## Demo
39 | 
40 | ### 1. Mock a resource
41 | 
42 | ```html
43 | <script src="/node_modules/xceptor/xceptor.js"></script>
44 | <script>
45 | XCeptor.get(new RegExp('^/hello$'), (req, res) => {
46 |   res.responseText = 'Hello XCeptor';
47 |   return false;
48 | });
49 | 
50 | var xhr = new XMLHttpRequest();
51 | xhr.open('GET', '/hello');
52 | xhr.onload = () => {
53 |   alert(xhr.responseText);
54 | };
55 | xhr.send();
56 | </script>
57 | ```
58 | 
59 | ### 2. Go to login on 401
60 | 
61 | ```html
62 | <script src="/node_modules/xceptor/xceptor.js"></script>
63 | <script>
64 | XCeptor.when(/^/, new RegExp('^/login$'), null, (req, res) => { 
65 |   if(res.status !== 401) return;
66 |   location.href = '/login';
67 | });
68 | </script>
69 | ```
70 | 


--------------------------------------------------------------------------------
/src/xceptor.js:
--------------------------------------------------------------------------------
  1 | var XCeptor = (function() { // eslint-disable-line no-unused-vars
  2 | 
  3 |   'use strict';
  4 | 
  5 |   // Avoid duplicate runing
  6 |   if (XMLHttpRequest.XCeptor) return XMLHttpRequest.XCeptor;
  7 | 
  8 |   // Save original XMLHttpRequest class
  9 |   var OriginalXMLHttpRequest = XMLHttpRequest;
 10 | 
 11 |   // Handlers internal class
 12 |   var Handlers = function() {};
 13 |   // To use equivalence Checking
 14 |   Handlers.check = function(what, value) {
 15 |     // Note, use a '==' here, match 'null' or 'undefined'
 16 |     if (what === null || what === value) return true;
 17 |     // Check 'test' method, match RegExp or RegExp-like
 18 |     if (typeof what.test === 'function') return what.test(value);
 19 |     if (typeof what === 'function') return what(value);
 20 |   };
 21 |   Handlers.prototype = [];
 22 |   Handlers.prototype.solve = function(args, resolve, reject) {
 23 |     var handlers = this;
 24 |     // This is an asynchronous recursion to traverse handlers
 25 |     var iterator = function(cursor) {
 26 |       // This is an asynchronous recursion to resolve thenable resolve
 27 |       var fixResule = function(result) {
 28 |         switch (true) {
 29 |           case result === true: return resolve && resolve();
 30 |           case result === false: return reject && reject();
 31 |           // Resolve recursively thenable result
 32 |           case result && typeof result.then === 'function':
 33 |             return result.then(fixResule, function(error) { throw error; });
 34 |           default: iterator(cursor + 1);
 35 |         }
 36 |       };
 37 |       if (cursor < handlers.length) {
 38 |         fixResule(handlers[cursor].apply(null, args));
 39 |       } else {
 40 |         resolve && resolve();
 41 |       }
 42 |     };
 43 |     iterator(0);
 44 |   };
 45 |   Handlers.prototype.add = function(handler, method, route) {
 46 |     if (typeof handler !== 'function') return;
 47 |     this.push(function(request, response) {
 48 |       if (Handlers.check(method, request.method) && Handlers.check(route, request.url)) {
 49 |         return handler(request, response);
 50 |       }
 51 |     });
 52 |   };
 53 | 
 54 |   // Create two handlers objects
 55 |   var requestHandlers = new Handlers();
 56 |   var responseHandlers = new Handlers();
 57 | 
 58 |   var propPrefix = '__internal_';
 59 |   var propKeys = [
 60 |     'readyState',
 61 |     'timeout',
 62 |     'upload',
 63 |     'withCredentials',
 64 |     'status',
 65 |     'statusText',
 66 |     'responseURL',
 67 |     'responseType',
 68 |     'response',
 69 |     'responseText',
 70 |     'responseXML'
 71 |   ];
 72 | 
 73 |   // To sync object keys with xhr
 74 |   var updateKeys = function(from, to, filter) {
 75 |     for (var i = 0, key; (key = propKeys[i]); i++) {
 76 |       if (filter && !filter.test(key)) continue;
 77 |       var xKey = propPrefix + key;
 78 |       var toKey = xKey in to ? xKey : key;
 79 |       var fromKey = xKey in from ? xKey : key;
 80 |       /**/ try { /* Fuck Android 4.3- and IE */ // eslint-disable-line no-multi-spaces
 81 |       /**/   void to[toKey], void from[fromKey]; // eslint-disable-line no-multi-spaces, indent
 82 |       /**/ } catch (error) { // eslint-disable-line no-multi-spaces
 83 |       /**/   continue; // eslint-disable-line no-multi-spaces, indent
 84 |       /**/ } // eslint-disable-line no-multi-spaces
 85 |       to[toKey] = from[fromKey];
 86 |     }
 87 |   };
 88 | 
 89 |   // Event internal class
 90 |   var Event = function(type, target) {
 91 |     this.type = type;
 92 |     this.target = target;
 93 |   };
 94 | 
 95 |   // SimpleEventModel internal decorator
 96 |   var SimpleEventDecorator = function(Constructor) {
 97 |     var heap = function(object, name) {
 98 |       var events = object.__events__;
 99 |       return name in events ? events[name] : events[name] = [];
100 |     };
101 |     var addEventListener = function(name, handler) {
102 |       heap(this, name).push(handler);
103 |     };
104 |     var removeEventListener = function(name, handler) {
105 |       var list = heap(this, name);
106 |       for (var i = 0; i < list.length; i++) {
107 |         if (list[i] === handler) list.splice(i, 1), i = 0 / 0;
108 |       }
109 |     };
110 |     var wrapDispatchEvent = function(context) {
111 |       var dispatchEvent = function(event) {
112 |         var list = heap(this, event.type);
113 |         for (var i = 0; i < list.length; i++) list[i].call(context, event);
114 |         var key = 'on' + event.type;
115 |         if (typeof this[key] === 'function') this[key].call(context, event);
116 |       };
117 |       return dispatchEvent;
118 |     };
119 |     var SimpleEventModel = function() {
120 |       Constructor.apply(this, arguments);
121 |       var nullDesc = { value: null, writable: true, configurable: true };
122 |       Object.defineProperties(this, {
123 |         onabort: nullDesc,
124 |         onerror: nullDesc,
125 |         onload: nullDesc,
126 |         onloadend: nullDesc,
127 |         onloadstart: nullDesc,
128 |         onprogress: nullDesc,
129 |         onreadystatechange: nullDesc,
130 |         ontimeout: nullDesc,
131 |         addEventListener: { value: addEventListener, configurable: true },
132 |         removeEventListener: { value: removeEventListener, configurable: true },
133 |         dispatchEvent: { value: wrapDispatchEvent(this), configurable: true },
134 |         __events__: { value: {}, configurable: true }
135 |       });
136 |     };
137 |     SimpleEventModel.prototype = Constructor.prototype;
138 |     return SimpleEventModel;
139 |   };
140 | 
141 |   /* Main Process */
142 | 
143 |   // Create interceptor
144 |   var HijackedXHR = function() {
145 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Failed to construct \'XMLHttpRequest\': Please use the \'new\' operator, this DOM object constructor cannot be called as a function.');
146 |     var xceptor = this;
147 |     var xhr = new OriginalXMLHttpRequest();
148 |     // Init prop slots
149 |     void function() {
150 |       for (var i = 0, key; (key = propKeys[i]); i++) {
151 |         Object.defineProperty(xceptor, propPrefix + key, {
152 |           configurable: true, writable: true, value: xhr[key]
153 |         });
154 |       }
155 |     }();
156 |     // Update default values
157 |     var request = {
158 |       method: null,
159 |       url: null,
160 |       isAsync: true,
161 |       username: void 0,
162 |       password: void 0,
163 |       headers: [],
164 |       overridedMimeType: void 0,
165 |       timeout: xceptor.timeout,
166 |       withCredentials: xceptor.withCredentials,
167 |       responseType: ''
168 |     };
169 |     var response = { status: xceptor.status, statusText: xceptor.statusText, headers: [] };
170 |     var trigger = function(name) { xceptor.dispatchEvent(new Event(name, xceptor)); };
171 |     var complete = function() {
172 |       responseHandlers.solve([xceptor.__request, xceptor.__response], function() {
173 |         updateKeys(xceptor.__response, xceptor);
174 |       });
175 |     };
176 |     Object.defineProperty(xceptor, '__originalXHR', { value: xhr, configurable: true });
177 |     Object.defineProperty(xceptor, '__request', { value: request, configurable: true });
178 |     Object.defineProperty(xceptor, '__response', { value: response, configurable: true });
179 |     Object.defineProperty(xceptor, '__trigger', { value: trigger, configurable: true });
180 |     Object.defineProperty(xceptor, '__complete', { value: complete, configurable: true });
181 |     var updateResponseHeaders = function() {
182 |       if (updateResponseHeaders.disabled) return;
183 |       updateResponseHeaders.disabled = true;
184 |       response.headers.splice(0, response.headers.length);
185 |       response.status = xhr.status;
186 |       response.statusText = xhr.statusText;
187 |       xhr.getAllResponseHeaders().replace(/.+/g, function($0) {
188 |         var result = $0.match(/(^.*?): (.*$)/);
189 |         if (!result) return;
190 |         response.headers.push({ header: result[1], value: result[2] });
191 |       });
192 |     };
193 |     // Mapping response
194 |     updateKeys(xhr, response, /^response/);
195 |     // Mapping events
196 |     void function() {
197 |       xhr.onreadystatechange = function() {
198 |         updateKeys(xhr, xceptor);
199 |         updateKeys(xhr, response);
200 |         if (xhr.readyState > 1) updateResponseHeaders();
201 |         if (xhr.readyState === 4) {
202 |           complete();
203 |           if (request.isAsync) {
204 |             setTimeout(function() { trigger('load'); });
205 |           } else {
206 |             trigger('load');
207 |           }
208 |         }
209 |         trigger('readystatechange');
210 |       };
211 |       var events = [ 'error', 'timeout', 'abort' ];
212 |       var buildEvent = function(name) {
213 |         xhr['on' + name] = function() {
214 |           xceptor.readyState = xhr.readyState;
215 |           trigger(name);
216 |         };
217 |       };
218 |       for (var i = 0; i < events.length; i++) buildEvent(events[i]);
219 |     }();
220 |   };
221 |   HijackedXHR.prototype = Object.create(OriginalXMLHttpRequest.prototype);
222 | 
223 |   // Methods mapping
224 |   HijackedXHR.prototype.open = function(method, url, isAsync, username, password) {
225 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
226 |     var request = this.__request;
227 |     // Save to 'request'
228 |     request.method = (method + '').toUpperCase();
229 |     request.url = url + '';
230 |     if (isAsync !== void 0) request.isAsync = !!(isAsync * 1);
231 |     if (username !== void 0) request.username = username + '';
232 |     if (password !== void 0) request.password = password + '';
233 |   };
234 | 
235 |   HijackedXHR.prototype.setRequestHeader = function(header, value) {
236 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
237 |     // Save to 'headers'
238 |     this.__request.headers.push({ header: header + '', value: value });
239 |   };
240 | 
241 |   HijackedXHR.prototype.overrideMimeType = function(mimetype) {
242 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
243 |     // Save to 'request'
244 |     this.__request.overridedMimeType = mimetype;
245 |   };
246 | 
247 |   HijackedXHR.prototype.getResponseHeader = function(header) {
248 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
249 |     // Read from 'response'
250 |     var headers = this.__response.headers;
251 |     header = String(header).toLowerCase();
252 |     for (var i = 0; i < headers.length; i++) {
253 |       if (headers[i].header.toLowerCase() === header) return headers[i].value;
254 |     }
255 |     return null;
256 |   };
257 | 
258 |   HijackedXHR.prototype.getAllResponseHeaders = function() {
259 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
260 |     // Read from 'response'
261 |     var response = this.__response;
262 |     var headers = response.headers;
263 |     var allHeaders = [];
264 |     for (var i = 0; i < response.headers.length; i++) {
265 |       allHeaders.push(headers[i].header + ': ' + headers[i].value);
266 |     }
267 |     return allHeaders.join('\r\n');
268 |   };
269 | 
270 |   HijackedXHR.prototype.send = function(data) {
271 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
272 |     // Copy setter properties to 'request'
273 |     var request = this.__request;
274 |     var response = this.__response;
275 |     request.data = data;
276 |     request.withCredentials = this.withCredentials;
277 |     request.timeout = this.timeout;
278 |     request.responseType = this.responseType;
279 |     var that = this;
280 |     // Invoke interceptor
281 |     requestHandlers.solve([request, response], function() {
282 |       // Actual actions
283 |       var xhr = that.__originalXHR;
284 |       xhr.open(request.method, request.url, request.isAsync, request.username, request.password);
285 |       for (var i = 0; i < request.headers.length; i++) {
286 |         xhr.setRequestHeader(request.headers[i].header, request.headers[i].value);
287 |       }
288 |       if (request.overridedMimeType !== void 0) xhr.overrideMimeType(request.overridedMimeType);
289 |       // Assigning before changes, because it may be thrown in sync mode
290 |       if (xhr.withCredentials !== request.withCredentials) xhr.withCredentials = request.withCredentials;
291 |       if (xhr.timeout !== request.timeout) xhr.timeout = request.timeout;
292 |       if (xhr.responseType !== request.responseType) xhr.responseType = request.responseType;
293 |       xhr.send(request.data);
294 |     }, function() {
295 |       // Fake actions
296 |       var action = function() {
297 |         response.readyState = 3;
298 |         updateKeys(response, that);
299 |         that.__trigger('readystatechange');
300 |         response.readyState = 4;
301 |         updateKeys(response, that);
302 |         that.__complete();
303 |         that.__trigger('readystatechange');
304 |         that.__trigger('load');
305 |       };
306 |       // Fake async
307 |       if (request.isAsync) {
308 |         setTimeout(action);
309 |       } else {
310 |         action();
311 |       }
312 |     });
313 |   };
314 | 
315 |   HijackedXHR.prototype.abort = function() {
316 |     if (!(this instanceof HijackedXHR)) throw new TypeError('Illegal invocation');
317 |     this.__originalXHR.abort();
318 |   };
319 | 
320 |   // Set accessor props
321 |   void function() {
322 |     for (var i = 0, key; (key = propKeys[i]); i++) void function(key) {
323 |       Object.defineProperty(HijackedXHR.prototype, key, {
324 |         configurable: true,
325 |         enumerable: true,
326 |         set: function(value) { this[propPrefix + key] = value; },
327 |         get: function() { return this[propPrefix + key]; }
328 |       });
329 |     }(key);
330 |   }();
331 | 
332 |   HijackedXHR = SimpleEventDecorator(HijackedXHR);
333 | 
334 |   // Copy constant names to constructor and prototype
335 |   var constantNames = [ 'UNSENT', 'OPENED', 'HEADERS_RECEIVED', 'LOADING', 'DONE' ];
336 |   for (var i = 0; i < constantNames.length; i++) {
337 |     Object.defineProperty(HijackedXHR, constantNames[i], {
338 |       value: OriginalXMLHttpRequest[constantNames[i]],
339 |       enumerable: true,
340 |       configurable: true
341 |     });
342 |   }
343 | 
344 |   // Exports
345 |   window.XMLHttpRequest = HijackedXHR;
346 | 
347 |   // Define xceptor methods
348 |   var XCeptor = new function() {
349 |     var that = this;
350 |     this.when = function(method, route, requestHandler, responseHandler) {
351 |       requestHandlers.add(requestHandler, method, route);
352 |       responseHandlers.add(responseHandler, method, route);
353 |     };
354 |     void function() {
355 |       var methods = [ 'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEADER', 'OPTIONS' ];
356 |       for (var i = 0; i < methods.length; i++) void function(method) {
357 |         that[method.toLowerCase()] = function() {
358 |           var args = Array.prototype.slice.call(arguments);
359 |           return that.when.apply(that, [method].concat(args));
360 |         };
361 |       }(methods[i]);
362 |     }();
363 |   };
364 | 
365 |   Object.defineProperty(HijackedXHR, 'XCeptor', { value: XCeptor, configurable: true });
366 | 
367 |   return XCeptor;
368 | 
369 | })();
370 | 


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