pax_global_header00006660000000000000000000000064134552517030014517gustar00rootroot0000000000000052 comment=0a5323370b02f4eff4069472d1e96a0094aef621 parseurl-1.3.3/000077500000000000000000000000001345525170300133605ustar00rootroot00000000000000parseurl-1.3.3/.eslintignore000066400000000000000000000000261345525170300160610ustar00rootroot00000000000000coverage node_modules parseurl-1.3.3/.eslintrc.yml000066400000000000000000000000351345525170300160020ustar00rootroot00000000000000root: true extends: standard parseurl-1.3.3/.gitignore000066400000000000000000000001071345525170300153460ustar00rootroot00000000000000.DS_Store* coverage node_modules npm-debug.log package-lock.json *.log parseurl-1.3.3/.travis.yml000066400000000000000000000053421345525170300154750ustar00rootroot00000000000000language: node_js node_js: - "0.8" - "0.10" - "0.12" - "1.8" - "2.5" - "3.3" - "4.9" - "5.12" - "6.17" - "7.10" - "8.15" - "9.11" - "10.15" - "11.14" sudo: false cache: directories: - node_modules before_install: - | # Setup utility functions function node_version_lt () { [[ "$(v "$TRAVIS_NODE_VERSION")" -lt "$(v "${1}")" ]] } function npm_module_installed () { npm -lsp ls | grep -Fq "$(pwd)/node_modules/${1}:${1}@" } function npm_remove_module_re () { node -e ' fs = require("fs"); p = JSON.parse(fs.readFileSync("package.json", "utf8")); r = RegExp(process.argv[1]); for (k in p.devDependencies) { if (r.test(k)) delete p.devDependencies[k]; } fs.writeFileSync("package.json", JSON.stringify(p, null, 2) + "\n"); ' "$@" } function npm_use_module () { node -e ' fs = require("fs"); p = JSON.parse(fs.readFileSync("package.json", "utf8")); p.devDependencies[process.argv[1]] = process.argv[2]; fs.writeFileSync("package.json", JSON.stringify(p, null, 2) + "\n"); ' "$@" } function v () { tr '.' '\n' <<< "${1}" \ | awk '{ printf "%03d", $0 }' \ | sed 's/^0*//' } # Configure npm - | # Skip updating shrinkwrap / lock npm config set shrinkwrap false # Remove all non-test dependencies - | # Remove benchmark dependencies npm_remove_module_re '(^|-)benchmark$' npm_remove_module_re '^fast-url-parser$' # Setup Node.js version-specific dependencies - | # Configure eslint for linting if node_version_lt '6.0'; then npm_remove_module_re '^eslint(-|$)' fi - | # Configure istanbul for coverage if node_version_lt '0.10'; then npm_remove_module_re '^istanbul$' fi - | # Configure mocha for testing if node_version_lt '0.10'; then npm_use_module 'mocha' '2.5.3' elif node_version_lt '4.0' ; then npm_use_module 'mocha' '3.5.3' elif node_version_lt '6.0' ; then npm_use_module 'mocha' '5.2.0' fi # Update Node.js modules - | # Prune & rebuild node_modules if [[ -d node_modules ]]; then npm prune npm rebuild fi before_scrpt: - | # Contents of node_modules npm -s ls ||: script: - | # Run test script, depending on istanbul install if npm_module_installed 'istanbul'; then npm run-script test-travis else npm test fi - | # Run linting, if eslint exists if npm_module_installed 'eslint'; then npm run-script lint fi after_script: - | # Upload coverage to coveralls if exists if [[ -e ./coverage/lcov.info ]]; then npm install --save-dev coveralls@2 coveralls < ./coverage/lcov.info fi parseurl-1.3.3/HISTORY.md000066400000000000000000000020231345525170300150400ustar00rootroot000000000000001.3.3 / 2019-04-15 ================== * Fix Node.js 0.8 return value inconsistencies 1.3.2 / 2017-09-09 ================== * perf: reduce overhead for full URLs * perf: unroll the "fast-path" `RegExp` 1.3.1 / 2016-01-17 ================== * perf: enable strict mode 1.3.0 / 2014-08-09 ================== * Add `parseurl.original` for parsing `req.originalUrl` with fallback * Return `undefined` if `req.url` is `undefined` 1.2.0 / 2014-07-21 ================== * Cache URLs based on original value * Remove no-longer-needed URL mis-parse work-around * Simplify the "fast-path" `RegExp` 1.1.3 / 2014-07-08 ================== * Fix typo 1.1.2 / 2014-07-08 ================== * Seriously fix Node.js 0.8 compatibility 1.1.1 / 2014-07-08 ================== * Fix Node.js 0.8 compatibility 1.1.0 / 2014-07-08 ================== * Incorporate URL href-only parse fast-path 1.0.1 / 2014-03-08 ================== * Add missing `require` 1.0.0 / 2014-03-08 ================== * Genesis from `connect` parseurl-1.3.3/LICENSE000066400000000000000000000022251345525170300143660ustar00rootroot00000000000000 (The MIT License) Copyright (c) 2014 Jonathan Ong Copyright (c) 2014-2017 Douglas Christopher Wilson Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. parseurl-1.3.3/README.md000066400000000000000000000077761345525170300146600ustar00rootroot00000000000000# parseurl [![NPM Version][npm-version-image]][npm-url] [![NPM Downloads][npm-downloads-image]][npm-url] [![Node.js Version][node-image]][node-url] [![Build Status][travis-image]][travis-url] [![Test Coverage][coveralls-image]][coveralls-url] Parse a URL with memoization. ## Install This is a [Node.js](https://nodejs.org/en/) module available through the [npm registry](https://www.npmjs.com/). Installation is done using the [`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): ```sh $ npm install parseurl ``` ## API ```js var parseurl = require('parseurl') ``` ### parseurl(req) Parse the URL of the given request object (looks at the `req.url` property) and return the result. The result is the same as `url.parse` in Node.js core. Calling this function multiple times on the same `req` where `req.url` does not change will return a cached parsed object, rather than parsing again. ### parseurl.original(req) Parse the original URL of the given request object and return the result. This works by trying to parse `req.originalUrl` if it is a string, otherwise parses `req.url`. The result is the same as `url.parse` in Node.js core. Calling this function multiple times on the same `req` where `req.originalUrl` does not change will return a cached parsed object, rather than parsing again. ## Benchmark ```bash $ npm run-script bench > parseurl@1.3.3 bench nodejs-parseurl > node benchmark/index.js http_parser@2.8.0 node@10.6.0 v8@6.7.288.46-node.13 uv@1.21.0 zlib@1.2.11 ares@1.14.0 modules@64 nghttp2@1.32.0 napi@3 openssl@1.1.0h icu@61.1 unicode@10.0 cldr@33.0 tz@2018c > node benchmark/fullurl.js Parsing URL "http://localhost:8888/foo/bar?user=tj&pet=fluffy" 4 tests completed. fasturl x 2,207,842 ops/sec ±3.76% (184 runs sampled) nativeurl - legacy x 507,180 ops/sec ±0.82% (191 runs sampled) nativeurl - whatwg x 290,044 ops/sec ±1.96% (189 runs sampled) parseurl x 488,907 ops/sec ±2.13% (192 runs sampled) > node benchmark/pathquery.js Parsing URL "/foo/bar?user=tj&pet=fluffy" 4 tests completed. fasturl x 3,812,564 ops/sec ±3.15% (188 runs sampled) nativeurl - legacy x 2,651,631 ops/sec ±1.68% (189 runs sampled) nativeurl - whatwg x 161,837 ops/sec ±2.26% (189 runs sampled) parseurl x 4,166,338 ops/sec ±2.23% (184 runs sampled) > node benchmark/samerequest.js Parsing URL "/foo/bar?user=tj&pet=fluffy" on same request object 4 tests completed. fasturl x 3,821,651 ops/sec ±2.42% (185 runs sampled) nativeurl - legacy x 2,651,162 ops/sec ±1.90% (187 runs sampled) nativeurl - whatwg x 175,166 ops/sec ±1.44% (188 runs sampled) parseurl x 14,912,606 ops/sec ±3.59% (183 runs sampled) > node benchmark/simplepath.js Parsing URL "/foo/bar" 4 tests completed. fasturl x 12,421,765 ops/sec ±2.04% (191 runs sampled) nativeurl - legacy x 7,546,036 ops/sec ±1.41% (188 runs sampled) nativeurl - whatwg x 198,843 ops/sec ±1.83% (189 runs sampled) parseurl x 24,244,006 ops/sec ±0.51% (194 runs sampled) > node benchmark/slash.js Parsing URL "/" 4 tests completed. fasturl x 17,159,456 ops/sec ±3.25% (188 runs sampled) nativeurl - legacy x 11,635,097 ops/sec ±3.79% (184 runs sampled) nativeurl - whatwg x 240,693 ops/sec ±0.83% (189 runs sampled) parseurl x 42,279,067 ops/sec ±0.55% (190 runs sampled) ``` ## License [MIT](LICENSE) [coveralls-image]: https://badgen.net/coveralls/c/github/pillarjs/parseurl/master [coveralls-url]: https://coveralls.io/r/pillarjs/parseurl?branch=master [node-image]: https://badgen.net/npm/node/parseurl [node-url]: https://nodejs.org/en/download [npm-downloads-image]: https://badgen.net/npm/dm/parseurl [npm-url]: https://npmjs.org/package/parseurl [npm-version-image]: https://badgen.net/npm/v/parseurl [travis-image]: https://badgen.net/travis/pillarjs/parseurl/master [travis-url]: https://travis-ci.org/pillarjs/parseurl parseurl-1.3.3/benchmark/000077500000000000000000000000001345525170300153125ustar00rootroot00000000000000parseurl-1.3.3/benchmark/fullurl.js000066400000000000000000000027311345525170300173400ustar00rootroot00000000000000 /** * Globals for benchmark.js */ global.assert = require('assert') global.createReq = createReq global.fasturl = require('fast-url-parser') global.nativeurl = require('url') global.parseurl = require('..') global.url = 'http://localhost:8888/foo/bar?user=tj&pet=fluffy' /** * Module dependencies. */ var benchmark = require('benchmark') var benchmarks = require('beautify-benchmark') var assertValues = 'assert.strictEqual(obj.pathname, "/foo/bar"); assert.strictEqual(obj.search, "?user=tj&pet=fluffy");' var suite = new benchmark.Suite() suite.add({ name: 'fasturl', minSamples: 100, fn: 'var obj = fasturl.parse(createReq(url).url);' + assertValues }) suite.add({ name: 'nativeurl' + (global.nativeurl.URL ? ' - legacy' : ''), minSamples: 100, fn: 'var obj = nativeurl.parse(createReq(url).url);' + assertValues }) if (global.nativeurl.URL) { suite.add({ name: 'nativeurl - whatwg', minSamples: 100, fn: 'var obj = new nativeurl.URL(createReq(url).url);' + assertValues }) } suite.add({ name: 'parseurl', minSamples: 100, fn: 'var obj = parseurl(createReq(url));' + assertValues }) suite.on('start', function onCycle (event) { process.stdout.write(' Parsing URL ' + JSON.stringify(global.url) + '\n\n') }) suite.on('cycle', function onCycle (event) { benchmarks.add(event.target) }) suite.on('complete', function onComplete () { benchmarks.log() }) suite.run({ async: false }) function createReq (url) { return { url: url } } parseurl-1.3.3/benchmark/index.js000066400000000000000000000013751345525170300167650ustar00rootroot00000000000000var fs = require('fs') var path = require('path') var spawn = require('child_process').spawn var exe = process.argv[0] var cwd = process.cwd() for (var dep in process.versions) { console.log(' %s@%s', dep, process.versions[dep]) } console.log('') runScripts(fs.readdirSync(__dirname)) function runScripts (fileNames) { var fileName = fileNames.shift() if (!fileName) return if (!/\.js$/i.test(fileName)) return runScripts(fileNames) if (fileName.toLowerCase() === 'index.js') return runScripts(fileNames) var fullPath = path.join(__dirname, fileName) console.log('> %s %s', exe, path.relative(cwd, fullPath)) var proc = spawn(exe, [fullPath], { 'stdio': 'inherit' }) proc.on('exit', function () { runScripts(fileNames) }) } parseurl-1.3.3/benchmark/pathquery.js000066400000000000000000000027301345525170300176740ustar00rootroot00000000000000 /** * Globals for benchmark.js */ global.assert = require('assert') global.createReq = createReq global.fasturl = require('fast-url-parser') global.nativeurl = require('url') global.parseurl = require('..') global.url = '/foo/bar?user=tj&pet=fluffy' /** * Module dependencies. */ var benchmark = require('benchmark') var benchmarks = require('beautify-benchmark') var assertValues = 'assert.strictEqual(obj.pathname, "/foo/bar"); assert.strictEqual(obj.search, "?user=tj&pet=fluffy");' var suite = new benchmark.Suite() suite.add({ name: 'fasturl', minSamples: 100, fn: 'var obj = fasturl.parse(createReq(url).url);' + assertValues }) suite.add({ name: 'nativeurl' + (global.nativeurl.URL ? ' - legacy' : ''), minSamples: 100, fn: 'var obj = nativeurl.parse(createReq(url).url);' + assertValues }) if (global.nativeurl.URL) { suite.add({ name: 'nativeurl - whatwg', minSamples: 100, fn: 'var obj = new nativeurl.URL(createReq(url).url, "http://localhost");' + assertValues }) } suite.add({ name: 'parseurl', minSamples: 100, fn: 'var obj = parseurl(createReq(url));' + assertValues }) suite.on('start', function onCycle (event) { process.stdout.write(' Parsing URL ' + JSON.stringify(global.url) + '\n\n') }) suite.on('cycle', function onCycle (event) { benchmarks.add(event.target) }) suite.on('complete', function onComplete () { benchmarks.log() }) suite.run({ async: false }) function createReq (url) { return { url: url } } parseurl-1.3.3/benchmark/samerequest.js000066400000000000000000000031111345525170300202020ustar00rootroot00000000000000 /** * Globals for benchmark.js */ global.assert = require('assert') global.createReq = createReq global.fasturl = require('fast-url-parser') global.nativeurl = require('url') global.parseurl = require('..') global.url = '/foo/bar?user=tj&pet=fluffy' /** * Module dependencies. */ var benchmark = require('benchmark') var benchmarks = require('beautify-benchmark') var assertValues = 'assert.strictEqual(obj.pathname, "/foo/bar"); assert.strictEqual(obj.search, "?user=tj&pet=fluffy");' var suite = new benchmark.Suite() suite.add({ name: 'fasturl', minSamples: 100, fn: 'var obj = fasturl.parse(req.url);' + assertValues, setup: 'req = createReq(url)' }) suite.add({ name: 'nativeurl' + (global.nativeurl.URL ? ' - legacy' : ''), minSamples: 100, fn: 'var obj = nativeurl.parse(req.url);' + assertValues, setup: 'req = createReq(url)' }) if (global.nativeurl.URL) { suite.add({ name: 'nativeurl - whatwg', minSamples: 100, fn: 'var obj = new nativeurl.URL(req.url, "http://localhost");' + assertValues, setup: 'req = createReq(url)' }) } suite.add({ name: 'parseurl', minSamples: 100, fn: 'var obj = parseurl(req);' + assertValues, setup: 'req = createReq(url)' }) suite.on('start', function onCycle (event) { process.stdout.write(' Parsing URL ' + JSON.stringify(global.url) + ' on same request object\n\n') }) suite.on('cycle', function onCycle (event) { benchmarks.add(event.target) }) suite.on('complete', function onComplete () { benchmarks.log() }) suite.run({ async: false }) function createReq (url) { return { url: url } } parseurl-1.3.3/benchmark/simplepath.js000066400000000000000000000027111345525170300200170ustar00rootroot00000000000000 /** * Globals for benchmark.js */ global.assert = require('assert') global.createReq = createReq global.fasturl = require('fast-url-parser') global.nativeurl = require('url') global.parseurl = require('..') global.url = '/foo/bar' /** * Module dependencies. */ var benchmark = require('benchmark') var benchmarks = require('beautify-benchmark') var assertValues = 'assert.strictEqual(obj.pathname, "/foo/bar"); assert.ok(!obj.search);' var suite = new benchmark.Suite() suite.add({ name: 'fasturl', minSamples: 100, fn: 'var obj = fasturl.parse(createReq(url).url);' + assertValues }) suite.add({ name: 'nativeurl' + (global.nativeurl.URL ? ' - legacy' : ''), minSamples: 100, fn: 'var obj = nativeurl.parse(createReq(url).url);' + assertValues }) if (global.nativeurl.URL) { suite.add({ name: 'nativeurl - whatwg', minSamples: 100, fn: 'var obj = new nativeurl.URL(createReq(url).url, "http://localhost");' + assertValues, setup: 'req = createReq(url)' }) } suite.add({ name: 'parseurl', minSamples: 100, fn: 'var obj = parseurl(createReq(url));' + assertValues }) suite.on('start', function onCycle (event) { process.stdout.write(' Parsing URL ' + JSON.stringify(global.url) + '\n\n') }) suite.on('cycle', function onCycle (event) { benchmarks.add(event.target) }) suite.on('complete', function onComplete () { benchmarks.log() }) suite.run({ async: false }) function createReq (url) { return { url: url } } parseurl-1.3.3/benchmark/slash.js000066400000000000000000000026301345525170300167630ustar00rootroot00000000000000 /** * Globals for benchmark.js */ global.assert = require('assert') global.createReq = createReq global.fasturl = require('fast-url-parser') global.nativeurl = require('url') global.parseurl = require('..') global.url = '/' /** * Module dependencies. */ var benchmark = require('benchmark') var benchmarks = require('beautify-benchmark') var assertValues = 'assert.strictEqual(obj.pathname, "/"); assert.ok(!obj.search);' var suite = new benchmark.Suite() suite.add({ name: 'fasturl', minSamples: 100, fn: 'var obj = fasturl.parse(createReq(url).url);' + assertValues }) suite.add({ name: 'nativeurl' + (global.nativeurl.URL ? ' - legacy' : ''), minSamples: 100, fn: 'var obj = nativeurl.parse(createReq(url).url);' + assertValues }) if (global.nativeurl.URL) { suite.add({ name: 'nativeurl - whatwg', minSamples: 100, fn: 'var obj = new nativeurl.URL(createReq(url).url, "http://localhost");' + assertValues }) } suite.add({ name: 'parseurl', minSamples: 100, fn: 'var obj = parseurl(createReq(url));' + assertValues }) suite.on('start', function onCycle (event) { process.stdout.write(' Parsing URL ' + JSON.stringify(global.url) + '\n\n') }) suite.on('cycle', function onCycle (event) { benchmarks.add(event.target) }) suite.on('complete', function onComplete () { benchmarks.log() }) suite.run({ async: false }) function createReq (url) { return { url: url } } parseurl-1.3.3/index.js000066400000000000000000000053711345525170300150330ustar00rootroot00000000000000/*! * parseurl * Copyright(c) 2014 Jonathan Ong * Copyright(c) 2014-2017 Douglas Christopher Wilson * MIT Licensed */ 'use strict' /** * Module dependencies. * @private */ var url = require('url') var parse = url.parse var Url = url.Url /** * Module exports. * @public */ module.exports = parseurl module.exports.original = originalurl /** * Parse the `req` url with memoization. * * @param {ServerRequest} req * @return {Object} * @public */ function parseurl (req) { var url = req.url if (url === undefined) { // URL is undefined return undefined } var parsed = req._parsedUrl if (fresh(url, parsed)) { // Return cached URL parse return parsed } // Parse the URL parsed = fastparse(url) parsed._raw = url return (req._parsedUrl = parsed) }; /** * Parse the `req` original url with fallback and memoization. * * @param {ServerRequest} req * @return {Object} * @public */ function originalurl (req) { var url = req.originalUrl if (typeof url !== 'string') { // Fallback return parseurl(req) } var parsed = req._parsedOriginalUrl if (fresh(url, parsed)) { // Return cached URL parse return parsed } // Parse the URL parsed = fastparse(url) parsed._raw = url return (req._parsedOriginalUrl = parsed) }; /** * Parse the `str` url with fast-path short-cut. * * @param {string} str * @return {Object} * @private */ function fastparse (str) { if (typeof str !== 'string' || str.charCodeAt(0) !== 0x2f /* / */) { return parse(str) } var pathname = str var query = null var search = null // This takes the regexp from https://github.com/joyent/node/pull/7878 // Which is /^(\/[^?#\s]*)(\?[^#\s]*)?$/ // And unrolls it into a for loop for (var i = 1; i < str.length; i++) { switch (str.charCodeAt(i)) { case 0x3f: /* ? */ if (search === null) { pathname = str.substring(0, i) query = str.substring(i + 1) search = str.substring(i) } break case 0x09: /* \t */ case 0x0a: /* \n */ case 0x0c: /* \f */ case 0x0d: /* \r */ case 0x20: /* */ case 0x23: /* # */ case 0xa0: case 0xfeff: return parse(str) } } var url = Url !== undefined ? new Url() : {} url.path = str url.href = str url.pathname = pathname if (search !== null) { url.query = query url.search = search } return url } /** * Determine if parsed is still fresh for url. * * @param {string} url * @param {object} parsedUrl * @return {boolean} * @private */ function fresh (url, parsedUrl) { return typeof parsedUrl === 'object' && parsedUrl !== null && (Url === undefined || parsedUrl instanceof Url) && parsedUrl._raw === url } parseurl-1.3.3/package.json000066400000000000000000000022341345525170300156470ustar00rootroot00000000000000{ "name": "parseurl", "description": "parse a url with memoization", "version": "1.3.3", "contributors": [ "Douglas Christopher Wilson ", "Jonathan Ong (http://jongleberry.com)" ], "repository": "pillarjs/parseurl", "license": "MIT", "devDependencies": { "beautify-benchmark": "0.2.4", "benchmark": "2.1.4", "eslint": "5.16.0", "eslint-config-standard": "12.0.0", "eslint-plugin-import": "2.17.1", "eslint-plugin-node": "7.0.1", "eslint-plugin-promise": "4.1.1", "eslint-plugin-standard": "4.0.0", "fast-url-parser": "1.1.3", "istanbul": "0.4.5", "mocha": "6.1.3" }, "files": [ "LICENSE", "HISTORY.md", "README.md", "index.js" ], "engines": { "node": ">= 0.8" }, "scripts": { "bench": "node benchmark/index.js", "lint": "eslint .", "test": "mocha --check-leaks --bail --reporter spec test/", "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- --check-leaks --reporter dot test/", "test-travis": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly -- --check-leaks --reporter spec test/" } } parseurl-1.3.3/test/000077500000000000000000000000001345525170300143375ustar00rootroot00000000000000parseurl-1.3.3/test/.eslintrc.yml000066400000000000000000000000231345525170300167560ustar00rootroot00000000000000env: mocha: true parseurl-1.3.3/test/test.js000066400000000000000000000166141345525170300156640ustar00rootroot00000000000000 var assert = require('assert') var parseurl = require('..') var url = require('url') var URL_EMPTY_VALUE = url.Url ? null : undefined describe('parseurl(req)', function () { it('should parse the requrst URL', function () { var req = createReq('/foo/bar') var url = parseurl(req) assert.strictEqual(url.host, URL_EMPTY_VALUE) assert.strictEqual(url.hostname, URL_EMPTY_VALUE) assert.strictEqual(url.href, '/foo/bar') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, URL_EMPTY_VALUE) assert.strictEqual(url.query, URL_EMPTY_VALUE) assert.strictEqual(url.search, URL_EMPTY_VALUE) }) it('should parse with query string', function () { var req = createReq('/foo/bar?fizz=buzz') var url = parseurl(req) assert.strictEqual(url.host, URL_EMPTY_VALUE) assert.strictEqual(url.hostname, URL_EMPTY_VALUE) assert.strictEqual(url.href, '/foo/bar?fizz=buzz') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, URL_EMPTY_VALUE) assert.strictEqual(url.query, 'fizz=buzz') assert.strictEqual(url.search, '?fizz=buzz') }) it('should parse a full URL', function () { var req = createReq('http://localhost:8888/foo/bar') var url = parseurl(req) assert.strictEqual(url.host, 'localhost:8888') assert.strictEqual(url.hostname, 'localhost') assert.strictEqual(url.href, 'http://localhost:8888/foo/bar') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, '8888') assert.strictEqual(url.query, URL_EMPTY_VALUE) assert.strictEqual(url.search, URL_EMPTY_VALUE) }) it('should not choke on auth-looking URL', function () { var req = createReq('//todo@txt') assert.strictEqual(parseurl(req).pathname, '//todo@txt') }) it('should return undefined missing url', function () { var req = createReq() var url = parseurl(req) assert.strictEqual(url, undefined) }) describe('when using the same request', function () { it('should parse multiple times', function () { var req = createReq('/foo/bar') assert.strictEqual(parseurl(req).pathname, '/foo/bar') assert.strictEqual(parseurl(req).pathname, '/foo/bar') assert.strictEqual(parseurl(req).pathname, '/foo/bar') }) it('should reflect url changes', function () { var req = createReq('/foo/bar') var url = parseurl(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') req.url = '/bar/baz' url = parseurl(req) assert.strictEqual(url._token, undefined) assert.strictEqual(parseurl(req).pathname, '/bar/baz') }) it('should cache parsing', function () { var req = createReq('/foo/bar') var url = parseurl(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') url = parseurl(req) assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') }) it('should cache parsing where href does not match', function () { var req = createReq('/foo/bar ') var url = parseurl(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') url = parseurl(req) assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') }) }) }) describe('parseurl.original(req)', function () { it('should parse the request original URL', function () { var req = createReq('/foo/bar', '/foo/bar') var url = parseurl.original(req) assert.strictEqual(url.host, URL_EMPTY_VALUE) assert.strictEqual(url.hostname, URL_EMPTY_VALUE) assert.strictEqual(url.href, '/foo/bar') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, URL_EMPTY_VALUE) assert.strictEqual(url.query, URL_EMPTY_VALUE) assert.strictEqual(url.search, URL_EMPTY_VALUE) }) it('should parse originalUrl when different', function () { var req = createReq('/bar', '/foo/bar') var url = parseurl.original(req) assert.strictEqual(url.host, URL_EMPTY_VALUE) assert.strictEqual(url.hostname, URL_EMPTY_VALUE) assert.strictEqual(url.href, '/foo/bar') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, URL_EMPTY_VALUE) assert.strictEqual(url.query, URL_EMPTY_VALUE) assert.strictEqual(url.search, URL_EMPTY_VALUE) }) it('should parse req.url when originalUrl missing', function () { var req = createReq('/foo/bar') var url = parseurl.original(req) assert.strictEqual(url.host, URL_EMPTY_VALUE) assert.strictEqual(url.hostname, URL_EMPTY_VALUE) assert.strictEqual(url.href, '/foo/bar') assert.strictEqual(url.pathname, '/foo/bar') assert.strictEqual(url.port, URL_EMPTY_VALUE) assert.strictEqual(url.query, URL_EMPTY_VALUE) assert.strictEqual(url.search, URL_EMPTY_VALUE) }) it('should return undefined missing req.url and originalUrl', function () { var req = createReq() var url = parseurl.original(req) assert.strictEqual(url, undefined) }) describe('when using the same request', function () { it('should parse multiple times', function () { var req = createReq('/foo/bar', '/foo/bar') assert.strictEqual(parseurl.original(req).pathname, '/foo/bar') assert.strictEqual(parseurl.original(req).pathname, '/foo/bar') assert.strictEqual(parseurl.original(req).pathname, '/foo/bar') }) it('should reflect changes', function () { var req = createReq('/foo/bar', '/foo/bar') var url = parseurl.original(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') req.originalUrl = '/bar/baz' url = parseurl.original(req) assert.strictEqual(url._token, undefined) assert.strictEqual(parseurl.original(req).pathname, '/bar/baz') }) it('should cache parsing', function () { var req = createReq('/foo/bar', '/foo/bar') var url = parseurl.original(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') url = parseurl.original(req) assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') }) it('should cache parsing if req.url changes', function () { var req = createReq('/foo/bar', '/foo/bar') var url = parseurl.original(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') req.url = '/baz' url = parseurl.original(req) assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') }) it('should cache parsing where href does not match', function () { var req = createReq('/foo/bar ', '/foo/bar ') var url = parseurl.original(req) var val = Math.random() url._token = val assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') url = parseurl.original(req) assert.strictEqual(url._token, val) assert.strictEqual(url.pathname, '/foo/bar') }) }) }) function createReq (url, originalUrl) { return { originalUrl: originalUrl, url: url } }