Adhers to the specification

.circleci/config.yml

@@ -29,5 +29,9 @@ jobs:
           name: Build
           command: yarn build
       - run:
-          name: Tests
+          name: Unit tests
           command: yarn test
+
+      - run:
+          name: Spefication tests
+          command: yarn spec:all

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "cucumberautocomplete.steps": ["specification/support/steps.ts"],
+  "cucumberautocomplete.strictGherkinCompletion": true
+}

cucumber.js

@@ -0,0 +1,13 @@
+const options = [
+  '--require-module ts-node/register',
+  '--require specification/support/*.ts',
+  '--publish-quiet',
+]
+
+module.exports = {
+  default: [
+    'node_modules/@universal-path/specification/features/**/*.feature',
+    ...options,
+  ].join(' '),
+  only: options.join(' '),
+}

jest.config.js

@@ -1,5 +1,5 @@
 module.exports = {
   transform: {
-    '^.+\\.tsx?$': 'ts-jest',
+    '^.+\\.ts$': 'ts-jest',
   },
 }

package.json

@@ -28,13 +28,23 @@
   "scripts": {
     "test": "jest",
     "clean": "rimraf -rf lib",
+    "spec": "cucumber-js -p only",
+    "spec:all": "cucumber-js -p default",
+    "spec:watch": "ts-node specification/scripts/run.ts",
     "build": "yarn clean && rollup -c rollup.config.js",
     "prepublishOnly": "yarn test && yarn build"
   },
   "devDependencies": {
     "@babel/core": "^7.13.10",
     "@babel/preset-env": "^7.13.12",
+    "@cucumber/cucumber": "^7.3.1",
+    "@types/chai": "^4.2.21",
+    "@types/debug": "^4.1.7",
     "@types/jest": "^26.0.21",
+    "@universal-path/specification": "^0.2.1",
+    "chai": "^4.3.4",
+    "chokidar": "^3.5.2",
+    "debug": "^4.3.2",
     "jest": "^26.6.3",
     "rimraf": "^3.0.2",
     "rollup": "^2.42.3",
@@ -43,6 +53,8 @@
     "rollup-plugin-sourcemaps": "^0.6.3",
     "rollup-plugin-typescript2": "^0.30.0",
     "ts-jest": "^26.5.4",
+    "ts-node": "^10.2.1",
     "typescript": "^4.2.3"
-  }
+  },
+  "dependencies": {}
 }

specification/scripts/run.ts

@@ -0,0 +1,23 @@
+import { watch } from 'chokidar'
+import { spawnSync } from 'child_process'
+
+const runTests = (filePath: string) => {
+  console.clear()
+  spawnSync(
+    'cucumber-js',
+    [
+      filePath,
+      '--require-module=ts-node/register',
+      '--require=specification/support/*.ts',
+      '--publish-quiet',
+    ],
+    {
+      stdio: 'inherit',
+    },
+  )
+}
+
+watch('specification/**/*.feature')
+  .on('add', runTests)
+  .on('change', runTests)
+  .on('unlink', runTests)

specification/support/steps.ts

@@ -0,0 +1,39 @@
+import { expect } from 'chai'
+import { Given, When, Then } from '@cucumber/cucumber'
+
+Given('the path is {string}', function (path: string) {
+  this.path = path
+})
+
+When('the url is {string}', function (url: string) {
+  this.url = url
+  this.match(this.path, this.url)
+})
+
+Then('it matches', function () {
+  expect(this.result).to.have.property('matches', true)
+})
+
+Then(`it doesn't match`, function () {
+  expect(this.result).to.have.property('matches', false)
+  expect(this.result).to.have.deep.property('params', {})
+})
+
+Then('has no parameters', function () {
+  expect(this.result.params).to.deep.equal({})
+})
+
+Then(
+  'has the {string} parameter equal to {string}',
+  function (parameterName: string, value: string) {
+    expect(this.result.params).not.to.be.null
+
+    const normalizedValue = value.includes(',')
+      ? value.split(',').map((s) => s.trim())
+      : value
+    expect(this.result.params).to.have.deep.property(
+      parameterName,
+      normalizedValue,
+    )
+  },
+)

specification/support/world.ts

@@ -0,0 +1,14 @@
+import { setWorldConstructor } from '@cucumber/cucumber'
+import { Path, Match, match } from '../../src'
+
+class CustomWorld {
+  public path: Path
+  public url: string
+  public result: Match
+
+  match() {
+    this.result = match(this.path, this.url)
+  }
+}
+
+setWorldConstructor(CustomWorld)

src/index.ts

@@ -1,2 +1,2 @@
-export { Path, Match, match } from './match'
-export { pathToRegExp } from './pathToRegExp'
+export * from './match'
+export * from './toRegExp'

src/match.ts

@@ -1,27 +1,52 @@
-import { pathToRegExp } from './pathToRegExp'
+import { parse } from './parse'
+import { toRegExp } from './toRegExp'
+
+const log = require('debug')('match')
 
 export type Path = RegExp | string
+export type Params = Record<string, string | string[]>
 
 export interface Match {
   matches: boolean
-  params: Record<string, string> | null
+  params: Record<string, string>
 }
 
 /**
  * Matches a given url against a path.
  */
 export const match = (path: Path, url: string): Match => {
-  const expression = path instanceof RegExp ? path : pathToRegExp(path)
+  log('matching "%s" adainst "%s"...', path, url)
+
+  const expression = path instanceof RegExp ? path : toRegExp(parse(path))
+  log('using expression', expression)
+
   const match = expression.exec(url) || false
+  log('match result', match)
 
   // Matches in strict mode: match string should equal to input (url)
   // Otherwise loose matches will be considered truthy:
   // match('/messages/:id', '/messages/123/users') // true
   const matches =
     path instanceof RegExp ? !!match : !!match && match[0] === match.input
 
+  let params = {}
+
+  if (matches && match) {
+    params = Object.entries(match.groups || {}).reduce<Params>(
+      (params, [name, value]) => {
+        if (typeof value !== 'undefined') {
+          params[name] = value.includes('/') ? value.split('/') : value
+        }
+        return params
+      },
+      {},
+    )
+  }
+
+  log('parameters', params)
+
   return {
     matches,
-    params: match && matches ? match.groups || null : null,
+    params,
   }
 }

src/parse.test.ts

@@ -0,0 +1,5 @@
+import { parse } from './parse'
+
+it('parses', () => {
+  parse('https://api.site.com/user/:id/:role?')
+})

src/parse.ts

@@ -0,0 +1,45 @@
+const SEGMENT_EXP = /(?<![:\/])\//g
+const PARAM_EXP = /^:([\w_-]+)(\?|\*|\+)?$/
+
+export interface TokenType<Type extends string> {
+  type: Type
+  delimiter?: '/'
+}
+
+export interface StringToken extends TokenType<'string'> {
+  value: string
+}
+
+export interface ParameterToken extends TokenType<'parameter'> {
+  name: string
+  modifier: string
+}
+
+export type Token = StringToken | ParameterToken
+
+export function parse(path: string): Token[] {
+  const segments = path.split(SEGMENT_EXP)
+  const tokens = segments.map<Token>((segment, index) => {
+    const isLastToken = index === segments.length - 1
+    const delimiter = isLastToken ? undefined : '/'
+
+    const paramMatch = segment.match(PARAM_EXP)
+    if (paramMatch) {
+      const [, name, modifier] = paramMatch
+      return {
+        type: 'parameter',
+        name,
+        modifier,
+        delimiter,
+      }
+    }
+
+    return {
+      type: 'string',
+      value: segment,
+      delimiter,
+    }
+  })
+
+  return tokens
+}