temp

flaska.mjs

@@ -63,6 +63,8 @@ const statuses = {
     304: true
   }
 }
+const __paramMapName = '__param'
+const __fullParamMapName = '__fullparam'
 
 function assertIsHandler(handler, name) {
   if (typeof(handler) !== 'function') {
@@ -426,6 +428,7 @@ const regCleanNonAschii = /(?![a-zA-Z_])./g
 const regCleanRest = /_+/g
 const regStarDoubleParam = /::[^:/]+/g
 const regStarSingleParam = /:[^:/]+/g
+const SlashCode = '/'.charCodeAt(0)
 const spaces = '                                                                                                                                                                                                                                                                '
 
 export class FlaskaRouter {
@@ -532,7 +535,6 @@ export class FlaskaRouter {
     let staticPaths = new Map()
     let paramsPaths = []
     let collator = new Intl.Collator('en', { sensitivity: 'accent' });
-    let sealed = Object.seal({})
 
     paths.forEach(function(entry) {
       if (entry.path[0] !== '/') throw new RouterError(entry, null, 'Specified route was missing forward slash at start')
@@ -541,7 +543,7 @@ export class FlaskaRouter {
       if (entry.path.indexOf('/:') < 0 && separateStatic) {
         return staticPaths.set(entry.path, {
           path: entry,
-          params: sealed,
+          params: {}
         })
       }
 
@@ -595,15 +597,13 @@ export class FlaskaRouter {
           : '')
   }
 
-  __treeIntoCompiledCodeReturnPath(indentString, paths, branch, params, pathParamMapIndex) {
+  __treeIntoCompiledCodeReturnPath(indentString, paths, branch, params) {
     let pathIndex = paths.indexOf(branch.path)
     if (pathIndex < 0) {
       throw new RouterError(branch.path, null, 'InternalError: Specified path was not found in paths')
     }
-    let mapIndex = pathParamMapIndex.size + 1
-    pathParamMapIndex.set(mapIndex, pathIndex)
     let output = '\n' + indentString + `return {`
-    output += '\n' + indentString + `  path: paths_${mapIndex},`
+    output += '\n' + indentString + `  path: paths[${pathIndex}],`
     if (params.length) {
       output += '\n' + indentString + `  params: {`
       for (let param of params) {
@@ -611,13 +611,13 @@ export class FlaskaRouter {
       }
       output += '\n' + indentString + `  },`
     } else {
-      output += '\n' + indentString + `  {},`
+      output += '\n' + indentString + `  params: {},`
     }
     output += '\n' + indentString + `}`
     return output
   }
 
-  __treeIntoCompiledCodeBranch(paths, branches, indent = 0, params = [], pathParamMapIndex) {
+  __treeIntoCompiledCodeBranch(paths, branches, indent = 0, params = []) {
     let output = ''
     let indentation = spaces.slice(0, (indent - params.length) * 2)
     let addEndBracket = true
@@ -637,8 +637,8 @@ export class FlaskaRouter {
         output += `if (str.charCodeAt(${this.__getIndex(indent, 0, params)}) === ${branch.char.charCodeAt(0)}) { // ${branch.char}`
 
         if (branch.path) {
-          output += '\n' + indentation + `  if (strLength === ${this.__getIndex(indent, 1, params)}) {`
+          output += '\n' + indentation + `  if (str.length === ${this.__getIndex(indent, 1, params)}) {`
-          output += this.__treeIntoCompiledCodeReturnPath(indentation + '    ', paths, branch, params, pathParamMapIndex)
+          output += this.__treeIntoCompiledCodeReturnPath(indentation + '    ', paths, branch, params)
           output += '\n' + indentation + `  }`
         }
       } else {
@@ -650,10 +650,10 @@ export class FlaskaRouter {
         params.push([branch.isParams || branch.isFullParams, paramVarName])
 
         if (branch.isFullParams) {
-          output += this.__treeIntoCompiledCodeReturnPath(indentation, paths, branch, params, pathParamMapIndex)
+          output += this.__treeIntoCompiledCodeReturnPath(indentation, paths, branch, params)
         } else if (branch.path) {
-          output += '\n' + indentation + `if (strLength === ${this.__getIndex(indent, 0, params)}) {`
+          output += '\n' + indentation + `if (str.length === ${this.__getIndex(indent, 0, params)}) {`
-          output += this.__treeIntoCompiledCodeReturnPath(indentation + '  ', paths, branch, params, pathParamMapIndex)
+          output += this.__treeIntoCompiledCodeReturnPath(indentation + '  ', paths, branch, params)
           output += '\n' + indentation + `}`
         }
       }
@@ -664,7 +664,7 @@ export class FlaskaRouter {
         } else {
           output += '\n' + indentation + '  '
         }
-        output += this.__treeIntoCompiledCodeBranch(paths, branch.children, indent + 1, params.slice(), pathParamMapIndex)
+        output += this.__treeIntoCompiledCodeBranch(paths, branch.children, indent + 1, params.slice())
       }
       if (addEndBracket) {
         output += '\n' + indentation + '} '
@@ -674,9 +674,7 @@ export class FlaskaRouter {
   }
 
   __treeIntoCompiledCodeClosure(paths, tree, staticList) {
-    let pathParamMapIndex = new Map()
+    let output = 'return function RBufferStrSliceClosure(str) {'
-    let output = ''
-    let prefix = ''
     if (staticList.size > 0) {
       output += '\n  let checkStatic = staticList.get(str)'
       output += '\n  if(checkStatic) {'
@@ -684,17 +682,11 @@ export class FlaskaRouter {
       output += '\n  }'
     }
     if (tree.length) {
-      output += '\n  let strLength = str.length'
+      output += '\n  ' + this.__treeIntoCompiledCodeBranch(paths, tree, 1, [])
-      output += '\n  ' + this.__treeIntoCompiledCodeBranch(paths, tree, 1, [], pathParamMapIndex)
-
     }
     output += '\n  return null'
     output += '\n}'
-    pathParamMapIndex.forEach(function (val, key) {
+    //console.log(output)
-      prefix += `let paths_${key} = paths[${val}]\n`
-    })
-    output = prefix + 'return function flaskaFastRouter(str) {\n  "use strict";' + output
-
     return new Function('paths', 'staticList', output)(paths, staticList)
   }
 
@@ -1231,7 +1223,6 @@ ctx.state.nonce = nonce;
         // Waiting 0.1 second for it to close down
         setTimeout(res, 100)
       })
-      this.server.closeAllConnections()
     })
   }
 }

router_v2.mjs

@@ -0,0 +1,242 @@
+
+class RouterError extends Error {
+  constructor(route1, route2, ...params) {
+    // Pass remaining arguments (including vendor specific ones) to parent constructor
+    super(...params);
+
+    // Maintains proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, RouterError);
+    }
+
+    this.name = "RouterError";
+    this.routeA = route1
+    this.routeB = route2
+  }
+}
+
+function Child(split, x, i) {
+  this.path = null
+  this.isParams = split[x].isParams ? split[x].word : null
+  this.isFullParams = split[x].isFullParams ? split[x].word : null
+  this.paramVarName = split[x].paramVarName ?? null
+  this.char = !this.isParams && !this.isFullParams ? split[x].word[i] || '/' : null
+  this.count = 0
+  this.children = []
+}
+
+function buildChild(x, i, splitPaths) {
+  let splitPath = splitPaths[0]
+  let letter = new Child(splitPath.split, x, i)
+
+  let consume = []
+  if (splitPath.split.length === x + 1
+      && (splitPath.split[x].isParams
+          || splitPath.split[x].isFullParams
+          || splitPath.split[x].word.length === i + 1)) {
+    letter.path = splitPath.entry
+    letter.count += 1
+  } else {
+    consume = [splitPath]
+  }
+
+  for (let y = 1; y < splitPaths.length; y++) {
+    let checkPath = splitPaths[y]
+    if (!checkPath.split[x]
+        || checkPath.split[x].isParams !== splitPath.split[x].isParams
+        || checkPath.split[x].isFullParams !== splitPath.split[x].isFullParams
+        || !checkPath.split[x].isParams
+            && !checkPath.split[x].isFullParams
+            && (checkPath.split[x].word[i] || '/') !== letter.char) break
+    consume.push(checkPath)
+  }
+
+  letter.count += consume.length
+  if (splitPath.split[x].word.length === i || splitPath.split[x].isParams || splitPath.split[x].isFullParams) {
+    x++
+    i = -1
+  }
+  while (consume.length) {
+    letter.children.push(buildChild(x, i + 1, consume))
+    consume.splice(0, letter.children[letter.children.length - 1].count)
+  }
+  return letter
+}
+
+function buildTree(splitPaths) {
+  let builder = []
+  while (splitPaths.length) {
+    builder.push(buildChild(0, 0, splitPaths))
+    splitPaths.splice(0, builder[builder.length - 1].count)
+  }
+  return builder
+}
+
+const regParamPrefix = /^::?/
+const regCleanNonAschii = /(?![a-zA-Z_])./g
+const regCleanRest = /_+/g
+
+function splitAndSortPaths(paths, separateStatic = true) {
+  let staticPaths = new Map()
+  let paramsPaths = []
+  let collator = new Intl.Collator('en', { sensitivity: 'accent' });
+
+  paths.forEach(function(entry) {
+    if (entry.path[0] !== '/') throw new RouterError(entry, null, 'Specified route was missing forward slash at start')
+
+    // Collect static paths separately
+    if (entry.path.indexOf('/:') < 0 && separateStatic) {
+      return staticPaths.set(entry.path, {
+        path: entry,
+        params: {}
+      })
+    }
+
+    // Collect params path separately
+    paramsPaths.push({
+      split: entry.path.slice(1).split(/\//g).map(function(word) {
+        let actualWord = word.replace(regParamPrefix, '')
+        return {
+          word: actualWord,
+          isParams: word[0] === ':' && word[1] !== ':',
+          isFullParams: word[0] === ':' && word[1] === ':',
+          paramVarName: word[0] === ':'
+            ? actualWord.replace(regCleanNonAschii, '_').replace(regCleanRest, '_')
+            : null
+        }
+      }),
+      entry,
+    })
+  })
+
+  paramsPaths.sort(function(aGroup, bGroup) {
+    let length = Math.max(aGroup.split.length, bGroup.split.length)
+    for (let x = 0; x < length; x++) {
+      let a = aGroup.split[x]
+      let b = bGroup.split[x]
+      if (!a) return -1
+      if (!b) return 1
+      // Full params go last
+      if (a.isFullParams && b.isFullParams) throw new RouterError(aGroup.entry, bGroup.entry, 'Two full path routes found on same level')
+      if (a.isFullParams) return 1
+      if (b.isFullParams) return -1
+      // Params go second last
+      if (a.isParams && !b.isParams) return 1
+      if (!a.isParams && b.isParams) return -1
+      // otherwise sort alphabetically if not identical
+      if (a.word !== b.word) return collator.compare(a.word, b.word)
+    }
+    throw new RouterError(aGroup, bGroup, 'Two identical paths were found')
+  })
+
+  return {
+    staticPaths,
+    paramsPaths,
+  }
+}
+
+const SlashCode = '/'.charCodeAt(0)
+
+function getIndex(offset, additions, params) {
+  return (offset + additions)
+    + (params.length
+        ? ' + ' + params.map(a => `offset${a[1]}`).join(' + ')
+        : '')
+}
+
+function treeIntoCompiledCodeReturnPath(indentString, paths, branch, params) {
+  let pathIndex = paths.indexOf(branch.path)
+  if (pathIndex < 0) {
+    throw new RouterError(branch.path, null, 'InternalError: Specified path was not found in paths')
+  }
+  let output = '\n' + indentString + `return {`
+  output += '\n' + indentString + `  path: paths[${pathIndex}],`
+  if (params.length) {
+    output += '\n' + indentString + `  params: {`
+    for (let param of params) {
+      output += '\n' + indentString + `    ${param[0]}: s${param[1]},`
+    }
+    output += '\n' + indentString + `  },`
+  } else {
+  output += '\n' + indentString + `  params: {},`
+  }
+  output += '\n' + indentString + `}`
+  return output
+}
+
+const spaces = '                                                                                                                                                                                                                                                                '
+
+function treeIntoCompiledCodeBranch(paths, branches, indent = 0, params = []) {
+  let output = ''
+  let indentation = spaces.slice(0, (indent - params.length) * 2)
+  let addEndBracket = true
+
+  for (let i = 0; i < branches.length; i++) {
+    let branch = branches[i]
+    if (i > 0) {
+      if (!branch.isParams && !branch.isFullParams) {
+        output += ' else '
+      } else {
+        // output += '} //'
+        output += '\n' + indentation
+      }
+    }
+
+    if (!branch.isParams && !branch.isFullParams) {
+      output += `if (buf[${getIndex(indent, 0, params)}] === ${branch.char.charCodeAt(0)}) { // ${branch.char}`
+
+      if (branch.path) {
+        output += '\n' + indentation + `  if (buf.length === ${getIndex(indent, 1, params)}) {`
+        output += treeIntoCompiledCodeReturnPath(indentation + '    ', paths, branch, params)
+        output += '\n' + indentation + `  }`
+      }
+    } else {
+      addEndBracket = false
+      let paramVarName = (params.length + 1) + '_' + branch.paramVarName
+      output += `let s${paramVarName} = str.slice(${getIndex(indent, 0, params)}${branch.isFullParams ? '' : `, buf.indexOf(${SlashCode}, ${getIndex(indent, 0, params)}) >>> 0`})`
+      output += '\n' + indentation + `let offset${paramVarName} = s${paramVarName}.length`
+      output += '\n' + indentation
+      params.push([branch.isParams || branch.isFullParams, paramVarName])
+
+      if (branch.isFullParams) {
+        output += treeIntoCompiledCodeReturnPath(indentation, paths, branch, params)
+      } else if (branch.path) {
+        output += '\n' + indentation + `if (buf.length === ${getIndex(indent, 0, params)}) {`
+        output += treeIntoCompiledCodeReturnPath(indentation + '  ', paths, branch, params)
+        output += '\n' + indentation + `}`
+      }
+    }
+
+    if (branch.children.length) {
+      if (branch.path) {
+        output += ' else '
+      } else {
+        output += '\n' + indentation + '  '
+      }
+      output += treeIntoCompiledCodeBranch(paths, branch.children, indent + 1, params.slice())
+    }
+    if (addEndBracket) {
+      output += '\n' + indentation + '} '
+    }
+  }
+  return output
+}
+
+function treeIntoCompiledCodeClosure(paths, tree, staticList) {
+  let output = 'return function RBufferStrSliceClosure(str) {'
+  output += '\n  let checkStatic = staticList.get(str)'
+  output += '\n  if(checkStatic) {'
+  output += '\n    return checkStatic'
+  output += '\n  }'
+  output += '\n  var buf = Buffer.from(str)'
+  output += '\n  ' + treeIntoCompiledCodeBranch(paths, tree, 1, [])
+  output += '\n  return null'
+  output += '\n}'
+  return new Function('paths', 'staticList', output)(paths, staticList)
+}
+
+export function compilePaths(paths) {
+  let splitPaths = splitAndSortPaths(paths)
+  let tree = buildTree(splitPaths.paramsPaths.slice())
+  return treeIntoCompiledCodeClosure(paths, tree, splitPaths.staticPaths)
+}

test.mjs

@@ -0,0 +1,26 @@
+import { Flaska } from './flaska.mjs'
+
+const port = 51026
+const flaska = new Flaska({}, )
+
+flaska.devMode()
+
+flaska.get('/', function(ctx) {
+  ctx.body = { status: true }
+})
+
+flaska.get('/:item/asdf/herp/:derp/bla', function(ctx) {
+  ctx.body = { item: ctx.params.item }
+})
+
+flaska.get('/a', function(ctx) {
+  ctx.body = { status: true }
+})
+
+flaska.get('/error', function(ctx) {
+  process.exit(1)
+})
+
+flaska.listen(port, function() {
+  console.log('listening on port', port)
+})

test/flaska.api.test.mjs

@@ -1072,23 +1072,10 @@ t.describe('#closeAsync()', function() {
     assert.strictEqual(err, assertError)
   })
 
-  t.test('it should call closeAllConnections', async function() {
-    const assertError = new Error('Pirate Fight')
-    let flaska = new Flaska()
-    flaska.server = {
-      close: stub(),
-      closeAllConnections: stub(),
-    }
-    flaska.server.closeAllConnections.throws(assertError)
-    let err = await assert.isRejected(flaska.closeAsync())
-    assert.strictEqual(err, assertError)
-  })
-
   t.test('should otherwise work', async function() {
     let flaska = new Flaska()
     flaska.server = {
-      close: stub(),
+      close: stub()
-      closeAllConnections: stub(),
     }
     flaska.server.close.returnWith(function(cb) {
       cb(null, { a: 1 })

test_fast.mjs

@@ -0,0 +1,20 @@
+import { Flaska } from './flaska_fast.mjs'
+
+const port = 51028
+const flaska = new Flaska({}, )
+
+flaska.get('/', function(ctx) {
+  ctx.body = { status: true }
+})
+
+flaska.get('/:item/asdf/herp/:derp/bla', function(ctx) {
+  ctx.body = { item: ctx.params.item }
+})
+
+flaska.get('/error', function(ctx) {
+  process.exit(1)
+})
+
+flaska.listen(port, function() {
+  console.log('listening on port', port)
+})

test_old.mjs

@@ -0,0 +1,20 @@
+import { Flaska } from './flaska_buffer.mjs'
+
+const port = 51027
+const flaska = new Flaska({}, )
+
+flaska.get('/', function(ctx) {
+  ctx.body = { status: true }
+})
+
+flaska.get('/:item/asdf/herp/:derp/bla', function(ctx) {
+  ctx.body = { item: ctx.params.item }
+})
+
+flaska.get('/error', function(ctx) {
+  process.exit(1)
+})
+
+flaska.listen(port, function() {
+  console.log('listening on port', port)
+})