first commit

Author: lsongdev

.github/FUNDING.yml

@@ -0,0 +1,8 @@
+# These are supported funding model platforms
+
+github: song940
+patreon: song940
+open_collective: song940
+ko_fi: song940
+tidelift: npm/kanary
+custom: https://git.io/fjRcB

.gitignore

@@ -0,0 +1,6 @@
+
+*.log
+yarn.lock
+package-lock.json
+
+node_modules/

.npmignore

@@ -0,0 +1,4 @@
+
+*.log
+
+node_modules/

.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - "stable"

LICENSE

@@ -0,0 +1,13 @@
+ISC License (ISC)
+Copyright 2017 
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+ with or without fee is hereby granted, provided that the above copyright notice
+ and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND 
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, 
+OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
+ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

README.md

@@ -0,0 +1,63 @@
+## routing2
+
+> Parse HTTP Routing definition with no dependencies, just ~3kb!
+
+[![routing2](https://img.shields.io/npm/v/routing2.svg)](https://npmjs.org/routing2)
+[![Build Status](https://travis-ci.org/song940/routing2.svg?branch=master)](https://travis-ci.org/song940/routing2)
+
+### Define
+
+<img src="./define.png" width="50%" >
+
+### Installation
+
+```bash
+$ npm install routing2
+```
+
+### Example
+
+```js
+const routing = require('routing2');
+
+const routes = routing.parse(`
+get / => home#index
+get /:name => user#index, { "foo": "bar" }
+post /user => user#create
+`);
+
+const request = {
+  method: 'get',
+  url: '/lsong?foo=bar'
+};
+
+const route = routing.find(routes, request);
+
+console.log(route);
+// { status: 200,
+//   route:
+//    { domain: undefined,
+//      path: '/:name',
+//      action: 'index',
+//      controller: 'user',
+//      options: { foo: "bar" },
+//      method: 'GET' },
+//   params: { name: 'lsong' },
+//   query: { foo: 'bar' } }
+```
+
+### Contributing
+- Fork this Repo first
+- Clone your Repo
+- Install dependencies by `$ npm install`
+- Checkout a feature branch
+- Feel free to add your features
+- Make sure your features are fully tested
+- Publish your local branch, Open a pull request
+- Enjoy hacking <3
+
+### MIT
+
+This work is licensed under the [MIT license](./LICENSE).
+
+---

define.png

@@ -0,0 +1,17 @@
+const routing = require('..');
+
+const routes = routing.parse(`
+get / => home#index, { "foo": "bar" }
+get /:name => user#index
+post /user => user#create
+`);
+
+const request = {
+  method: 'get',
+  url: '/lsong?foo=bar'
+};
+
+const route = routing.find(routes, request);
+
+console.log(route);
+

example/index.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const url = require('url');
+
+function removeQuotes(str){
+  return str.trim().replace(/"|'/ig, '');
+};
+
+const parseLine = line => {
+  if (!line.trim() || /^(#|\/\/)/.test(line)) return;
+  const m = /(\w+)\s+(.+)\s*=>\s*(.+)#(\w+)(\s*,(.+))?/.exec(line);
+  if (!m) throw new SyntaxError('Unexpected token', line);
+  let domain, path = removeQuotes(m[2].trim());
+  const i = path.indexOf('/');
+  if (i > 0) {
+    domain = path.substr(0, i);
+    path = path.substr(i);
+  }
+  return {
+    domain,
+    path,
+    action: removeQuotes(m[4].trim()),
+    controller: removeQuotes(m[3].trim()),
+    options: m[6] && JSON.parse(m[6]),
+    method: m[1].trim().toUpperCase(),
+  }
+};
+
+const parse = content =>
+  content.split(/\r?\n/g)
+  .map(parseLine)
+  .filter(Boolean)
+  .map(create);
+
+const load = filename =>
+  parse(fs.readFileSync(filename, 'utf8'));
+
+const pathToRegexp = path => {
+  if(path instanceof RegExp) return path;
+  let arr = path.split('/'), pattern = '', keys = [];
+  (arr[0] === '') && arr.shift();
+  arr.forEach((p, i) => {
+    switch(p[0]){
+      case '*':
+        pattern += '/(.+)';
+        keys.push(p.substring(1) || `$${i}`);
+        break;
+      case ':':
+        const o = p.substr(-1);
+        const r = '([^/]+?)';
+        const m = {
+          '?': `(?:/${r})?`,
+          '*': '(?:/)(.*)'
+        };
+        pattern += m[o] || `/${r}`;
+        keys.push(p.substring(1, p.length - !!m[o]));
+        break;
+      default:
+        pattern += `/${p}`;
+        break;
+    }
+  });
+  keys.length && (pattern += '(?:/)?');
+  pattern = new RegExp(`^${pattern}\/?$`, 'i');
+  pattern.keys = keys;
+  pattern.parse = function(pathname) {
+    if(this.test(pathname) === false) return null;
+    return this.exec(pathname).slice(1).reduce((params, param, i) => {
+      params[ this.keys[i] ] = param && decodeURIComponent(param);
+      return params;
+    }, {});
+  };
+  return pattern;
+};
+
+const find = (routes, req) => {
+  const [ domain ] = (req.host || '').split(':');// omit port
+  const { pathname, query } = url.parse(req.url, true);
+  const m = routes
+    .filter(route =>
+      (route.domain ? route.domain === domain : true) &&
+      route.regexp.test(pathname))
+    .sort((a, b) => {
+      const { priority: aPriority = 0 } = a;
+      const { priority: bPriority = 0 } = b;
+      return bPriority - aPriority;
+    });
+  if (!m.length) return { status: 404 };
+  const allowMethods = m.map(route => route.method.toUpperCase());
+  const methodIndex = allowMethods.findIndex(x => x === '*' || x === req.method.toUpperCase());
+  if (!~methodIndex && req.method === 'OPTIONS')
+    return { status: 204, allowMethods, routes: m };
+  if (!~methodIndex) return { status: 405, allowMethods, routes: m };
+  const route = m[ methodIndex ];
+  const params = route.regexp.parse(pathname);
+  // will deprecated in future
+  route.params = params;
+  return { status: 200, route, params, query };
+};
+
+const create = route => {
+  if(typeof route === 'string')
+    route = parseLine(route);
+  route.method = (route.method || '*');
+  route.regexp = pathToRegexp(route.path);
+  return route;
+};
+
+module.exports = {
+  find,
+  load,
+  parse,
+  create,
+  parseLine,
+  pathToRegexp
+};

index.js

@@ -0,0 +1,26 @@
+{
+  "name": "routing2",
+  "version": "0.0.15",
+  "description": "Parse HTTP Routing definition with no dependencies, just ~3kb!",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test"
+  },
+  "keywords": [
+    "route",
+    "http"
+  ],
+  "author": "lsong",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/song940/routing2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/song940/routing2/issues"
+  },
+  "homepage": "https://github.com/song940/routing2#readme",
+  "directories": {
+    "example": "example"
+  }
+}

package.json

@@ -0,0 +1,58 @@
+const assert = require('assert');
+const test = require('./test');
+const { parse, pathToRegexp, find, load } = require('..');
+
+var r, s;
+
+test('normal path', () => {
+  r = pathToRegexp('/normal/path');
+  assert.ok(r.parse('/normal/path'));
+  assert.equal(r.parse('/aaa'), null);
+});
+
+test('optional parameter', () => {
+  r = pathToRegexp('/v1/:name*');
+  assert.deepEqual(r.parse('/v1/aaa/bbb'), { name: 'aaa/bbb'})
+});
+
+test('named and optional parameter', () => {
+  r = pathToRegexp('/:a/:b*');
+  s = '/test/';
+  assert.ok(r.test(s));
+  assert.deepEqual(r.parse(s), { a: 'test', b: '' });
+});
+
+const routes = parse(`
+  get / => home#index
+  get /:name => user#user
+`);
+
+test('parse routing rules', () => {
+  assert.equal(routes[0].path, '/');
+  assert.equal(routes[0].action, 'index');
+  assert.equal(routes[1].action, 'user');
+  assert.equal(routes[1].controller, 'user');
+});
+
+test('find match rule in routes', () => {
+  r = find(routes, {
+    host: 'google.com',
+    method: 'GET',
+    url: '/1?a=b'
+  });
+  assert.equal(r.status, 200);
+  assert.equal(r.route.action, 'user');
+  assert.equal(r.route.controller, 'user');
+  assert.deepEqual(r.query, { a: 'b' });
+  assert.deepEqual(r.params, { name: '1' });
+});
+
+test('load routes from file', () => {
+  const routes = load(__dirname + '/routes.txt');
+  assert.ok(Array.isArray(routes));
+  assert.equal(routes.length, 2);
+  assert.equal(routes[0].controller, 'home');
+  assert.equal(routes[0].action, 'index');
+  assert.equal(routes[1].controller, 'user');
+  assert.equal(routes[1].action, 'create');
+});

test/index.js

@@ -0,0 +1,7 @@
+
+
+// home controller
+get / => home#index
+
+# user
+post /user => user#create

test/routes.txt

@@ -0,0 +1,26 @@
+const { inspect } = require('util');
+/**
+ * super tiny testing framework
+ * 
+ * @author Liu song <hi@lsong.org>
+ * @github https://github.com/song940
+ */
+const test = async (title, fn) => {
+  try {
+    await fn();
+    console.log(color(` ✔  ${title}`, 32));
+  } catch (err) {
+    console.error(color(` ✘  ${title}`, 31));
+    console.log();
+    console.log(color(`   ${err.name} ${err.message}`, 31));
+    console.error(color(`   expected: ${inspect(err.expected)}`, 32));
+    console.error(color(`     actual: ${inspect(err.actual)}`, 31));
+    console.log();
+  }
+};
+
+function color(str, c) {
+  return "\x1b[" + c + "m" + str + "\x1b[0m";
+};
+
+module.exports = test;