bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/node.ts

@@ -0,0 +1,159 @@
+const LABEL_REG_EXP_STR = '[^/]+'
+const ONLY_WILDCARD_REG_EXP_STR = '.*'
+const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)'
+export const PATH_ERROR = Symbol()
+
+export type ParamAssocArray = [string, number][]
+export interface Context {
+  varIndex: number
+}
+
+const regExpMetaChars = new Set('.\\+*[^]$()')
+
+/**
+ * Sort order:
+ * 1. literal
+ * 2. special pattern (e.g. :label{[0-9]+})
+ * 3. common label pattern (e.g. :label)
+ * 4. wildcard
+ */
+function compareKey(a: string, b: string): number {
+  if (a.length === 1) {
+    return b.length === 1 ? (a < b ? -1 : 1) : -1
+  }
+  if (b.length === 1) {
+    return 1
+  }
+
+  // wildcard
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1
+  }
+
+  // label
+  if (a === LABEL_REG_EXP_STR) {
+    return 1
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1
+  }
+
+  return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length
+}
+
+export class Node {
+  index?: number
+  varIndex?: number
+  children: Record<string, Node> = Object.create(null)
+
+  insert(
+    tokens: readonly string[],
+    index: number,
+    paramMap: ParamAssocArray,
+    context: Context,
+    pathErrorCheckOnly: boolean
+  ): void {
+    if (tokens.length === 0) {
+      if (this.index !== undefined) {
+        throw PATH_ERROR
+      }
+      if (pathErrorCheckOnly) {
+        return
+      }
+
+      this.index = index
+      return
+    }
+
+    const [token, ...restTokens] = tokens
+    const pattern =
+      token === '*'
+        ? restTokens.length === 0
+          ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
+          : ['', '', LABEL_REG_EXP_STR]
+        : token === '/*'
+        ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
+        : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/)
+
+    let node
+    if (pattern) {
+      const name = pattern[1]
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR
+      if (name && pattern[2]) {
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, '(?:') // (a|b) => (?:a|b)
+        if (/\((?!\?:)/.test(regexpStr)) {
+          // prefix(?:a|b) is allowed, but prefix(a|b) is not
+          throw PATH_ERROR
+        }
+      }
+
+      node = this.children[regexpStr]
+      if (!node) {
+        if (
+          Object.keys(this.children).some(
+            (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+          )
+        ) {
+          throw PATH_ERROR
+        }
+        if (pathErrorCheckOnly) {
+          return
+        }
+        node = this.children[regexpStr] = new Node()
+        if (name !== '') {
+          node.varIndex = context.varIndex++
+        }
+      }
+      if (!pathErrorCheckOnly && name !== '') {
+        paramMap.push([name, node.varIndex as number])
+      }
+    } else {
+      node = this.children[token]
+      if (!node) {
+        if (
+          Object.keys(this.children).some(
+            (k) =>
+              k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+          )
+        ) {
+          throw PATH_ERROR
+        }
+        if (pathErrorCheckOnly) {
+          return
+        }
+        node = this.children[token] = new Node()
+      }
+    }
+
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly)
+  }
+
+  buildRegExpStr(): string {
+    const childKeys = Object.keys(this.children).sort(compareKey)
+
+    const strList = childKeys.map((k) => {
+      const c = this.children[k]
+      return (
+        (typeof c.varIndex === 'number'
+          ? `(${k})@${c.varIndex}`
+          : regExpMetaChars.has(k)
+          ? `\\${k}`
+          : k) + c.buildRegExpStr()
+      )
+    })
+
+    if (typeof this.index === 'number') {
+      strList.unshift(`#${this.index}`)
+    }
+
+    if (strList.length === 0) {
+      return ''
+    }
+    if (strList.length === 1) {
+      return strList[0]
+    }
+
+    return '(?:' + strList.join('|') + ')'
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/router.ts

@@ -0,0 +1,274 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import type { ParamIndexMap, Result, Router } from '../../router'
+import {
+  MESSAGE_MATCHER_IS_ALREADY_BUILT,
+  METHOD_NAME_ALL,
+  UnsupportedPathError,
+} from '../../router'
+import { checkOptionalParameter } from '../../utils/url'
+import { PATH_ERROR } from './node'
+import type { ParamAssocArray } from './node'
+import { Trie } from './trie'
+
+type HandlerData<T> = [T, ParamIndexMap][]
+type StaticMap<T> = Record<string, Result<T>>
+type Matcher<T> = [RegExp, HandlerData<T>[], StaticMap<T>]
+type HandlerWithMetadata<T> = [T, number] // [handler, paramCount]
+
+const emptyParam: string[] = []
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const nullMatcher: Matcher<any> = [/^$/, [], Object.create(null)]
+
+let wildcardRegExpCache: Record<string, RegExp> = Object.create(null)
+function buildWildcardRegExp(path: string): RegExp {
+  return (wildcardRegExpCache[path] ??= new RegExp(
+    path === '*'
+      ? ''
+      : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) =>
+          metaChar ? `\\${metaChar}` : '(?:|/.*)'
+        )}$`
+  ))
+}
+
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = Object.create(null)
+}
+
+function buildMatcherFromPreprocessedRoutes<T>(
+  routes: [string, HandlerWithMetadata<T>[]][]
+): Matcher<T> {
+  const trie = new Trie()
+  const handlerData: HandlerData<T>[] = []
+  if (routes.length === 0) {
+    return nullMatcher
+  }
+
+  const routesWithStaticPathFlag = routes
+    .map(
+      (route) => [!/\*|\/:/.test(route[0]), ...route] as [boolean, string, HandlerWithMetadata<T>[]]
+    )
+    .sort(([isStaticA, pathA], [isStaticB, pathB]) =>
+      isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+    )
+
+  const staticMap: StaticMap<T> = Object.create(null)
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i]
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, Object.create(null)]), emptyParam]
+    } else {
+      j++
+    }
+
+    let paramAssoc: ParamAssocArray
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly)
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e
+    }
+
+    if (pathErrorCheckOnly) {
+      continue
+    }
+
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap: ParamIndexMap = Object.create(null)
+      paramCount -= 1
+      for (; paramCount >= 0; paramCount--) {
+        const [key, value] = paramAssoc[paramCount]
+        paramIndexMap[key] = value
+      }
+      return [h, paramIndexMap]
+    })
+  }
+
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp()
+  for (let i = 0, len = handlerData.length; i < len; i++) {
+    for (let j = 0, len = handlerData[i].length; j < len; j++) {
+      const map = handlerData[i][j]?.[1]
+      if (!map) {
+        continue
+      }
+      const keys = Object.keys(map)
+      for (let k = 0, len = keys.length; k < len; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]]
+      }
+    }
+  }
+
+  const handlerMap: HandlerData<T>[] = []
+  // using `in` because indexReplacementMap is a sparse array
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]]
+  }
+
+  return [regexp, handlerMap, staticMap] as Matcher<T>
+}
+
+function findMiddleware<T>(
+  middleware: Record<string, T[]> | undefined,
+  path: string
+): T[] | undefined {
+  if (!middleware) {
+    return undefined
+  }
+
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]]
+    }
+  }
+
+  return undefined
+}
+
+export class RegExpRouter<T> implements Router<T> {
+  name: string = 'RegExpRouter'
+  middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
+  routes?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
+
+  constructor() {
+    this.middleware = { [METHOD_NAME_ALL]: Object.create(null) }
+    this.routes = { [METHOD_NAME_ALL]: Object.create(null) }
+  }
+
+  add(method: string, path: string, handler: T) {
+    const { middleware, routes } = this
+
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
+    }
+
+    if (!middleware[method]) {
+      ;[middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = Object.create(null)
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]]
+        })
+      })
+    }
+
+    if (path === '/*') {
+      path = '*'
+    }
+
+    const paramCount = (path.match(/\/:/g) || []).length
+
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path)
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||=
+            findMiddleware(middleware[m], path) ||
+            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+            []
+        })
+      } else {
+        middleware[method][path] ||=
+          findMiddleware(middleware[method], path) ||
+          findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+          []
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount])
+          })
+        }
+      })
+
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
+          )
+        }
+      })
+
+      return
+    }
+
+    const paths = checkOptionalParameter(path) || [path]
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path = paths[i]
+
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path] ||= [
+            ...(findMiddleware(middleware[m], path) ||
+              findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+              []),
+          ]
+          routes[m][path].push([handler, paramCount - len + i + 1])
+        }
+      })
+    }
+  }
+
+  match(method: string, path: string): Result<T> {
+    clearWildcardRegExpCache() // no longer used.
+
+    const matchers = this.buildAllMatchers()
+
+    this.match = (method, path) => {
+      const matcher = (matchers[method] || matchers[METHOD_NAME_ALL]) as Matcher<T>
+
+      const staticMatch = matcher[2][path]
+      if (staticMatch) {
+        return staticMatch
+      }
+
+      const match = path.match(matcher[0])
+      if (!match) {
+        return [[], emptyParam]
+      }
+
+      const index = match.indexOf('', 1)
+      return [matcher[1][index], match]
+    }
+
+    return this.match(method, path)
+  }
+
+  private buildAllMatchers(): Record<string, Matcher<T> | null> {
+    const matchers: Record<string, Matcher<T> | null> = Object.create(null)
+
+    ;[...Object.keys(this.routes!), ...Object.keys(this.middleware!)].forEach((method) => {
+      matchers[method] ||= this.buildMatcher(method)
+    })
+
+    // Release cache
+    this.middleware = this.routes = undefined
+
+    return matchers
+  }
+
+  private buildMatcher(method: string): Matcher<T> | null {
+    const routes: [string, HandlerWithMetadata<T>[]][] = []
+
+    let hasOwnRoute = method === METHOD_NAME_ALL
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ;[this.middleware!, this.routes!].forEach((r) => {
+      const ownRoute = r[method]
+        ? Object.keys(r[method]).map((path) => [path, r[method][path]])
+        : []
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true
+        routes.push(...(ownRoute as [string, HandlerWithMetadata<T>[]][]))
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...(Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]) as [
+            string,
+            HandlerWithMetadata<T>[]
+          ][])
+        )
+      }
+    })
+
+    if (!hasOwnRoute) {
+      return null
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes)
+    }
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/router/reg-exp-router/trie.ts

@@ -0,0 +1,74 @@
+import type { Context, ParamAssocArray } from './node'
+import { Node } from './node'
+
+export type ReplacementMap = number[]
+
+export class Trie {
+  context: Context = { varIndex: 0 }
+  root: Node = new Node()
+
+  insert(path: string, index: number, pathErrorCheckOnly: boolean): ParamAssocArray {
+    const paramAssoc: ParamAssocArray = []
+
+    const groups: [string, string][] = [] // [mark, original string]
+    for (let i = 0; ; ) {
+      let replaced = false
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`
+        groups[i] = [mark, m]
+        i++
+        replaced = true
+        return mark
+      })
+      if (!replaced) {
+        break
+      }
+    }
+
+    /**
+     *  - pattern (:label, :label{0-9]+}, ...)
+     *  - /* wildcard
+     *  - character
+     */
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || []
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i]
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1])
+          break
+        }
+      }
+    }
+
+    this.root.insert(tokens, index, paramAssoc, this.context, pathErrorCheckOnly)
+
+    return paramAssoc
+  }
+
+  buildRegExp(): [RegExp, ReplacementMap, ReplacementMap] {
+    let regexp = this.root.buildRegExpStr()
+    if (regexp === '') {
+      return [/^$/, [], []] // never match
+    }
+
+    let captureIndex = 0
+    const indexReplacementMap: ReplacementMap = []
+    const paramReplacementMap: ReplacementMap = []
+
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (typeof handlerIndex !== 'undefined') {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex)
+        return '$()'
+      }
+      if (typeof paramIndex !== 'undefined') {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex
+        return ''
+      }
+
+      return ''
+    })
+
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap]
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/router/smart-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * SmartRouter for Hono.
+ */
+
+export { SmartRouter } from './router'

package/tests/fixtures/corpus/oss-repos/hono/src/router/smart-router/router.ts

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import type { Result, Router } from '../../router'
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from '../../router'
+
+export class SmartRouter<T> implements Router<T> {
+  name: string = 'SmartRouter'
+  routers: Router<T>[] = []
+  routes?: [string, string, T][] = []
+
+  constructor(init: Pick<SmartRouter<T>, 'routers'>) {
+    Object.assign(this, init)
+  }
+
+  add(method: string, path: string, handler: T) {
+    if (!this.routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
+    }
+
+    this.routes.push([method, path, handler])
+  }
+
+  match(method: string, path: string): Result<T> {
+    if (!this.routes) {
+      throw new Error('Fatal error')
+    }
+
+    const { routers, routes } = this
+    const len = routers.length
+    let i = 0
+    let res
+    for (; i < len; i++) {
+      const router = routers[i]
+      try {
+        routes.forEach((args) => {
+          router.add(...args)
+        })
+        res = router.match(method, path)
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue
+        }
+        throw e
+      }
+
+      this.match = router.match.bind(router)
+      this.routers = [router]
+      this.routes = undefined
+      break
+    }
+
+    if (i === len) {
+      // not found
+      throw new Error('Fatal error')
+    }
+
+    // e.g. "SmartRouter + RegExpRouter"
+    this.name = `SmartRouter + ${this.activeRouter.name}`
+
+    return res as Result<T>
+  }
+
+  get activeRouter(): Router<T> {
+    if (this.routes || this.routers.length !== 1) {
+      throw new Error('No active router has been determined yet.')
+    }
+
+    return this.routers[0]
+  }
+}

package/tests/fixtures/corpus/oss-repos/hono/src/router/trie-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * TrieRouter for Hono.
+ */
+
+export { TrieRouter } from './router'