From e39ad59589af455fc839f9cb3e402fa8f9dbf995 Mon Sep 17 00:00:00 2001 From: Elco Brouwer von Gonzenbach Date: Tue, 12 Jun 2018 09:11:54 +0700 Subject: [PATCH 1/4] Add regexp option to routes --- src/core/create_routes.ts | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/src/core/create_routes.ts b/src/core/create_routes.ts index a6239ff52..d3431e5d4 100644 --- a/src/core/create_routes.ts +++ b/src/core/create_routes.ts @@ -63,6 +63,22 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { (a_sub_part.content < b_sub_part.content ? -1 : 1) ); } + // If both parts dynamic, check for regexp patterns + if (a_sub_part.dynamic && b_sub_part.dynamic) { + const regexp_pattern = /\((.*?)\)/; + const a_match = regexp_pattern.exec(a_sub_part.content); + const b_match = regexp_pattern.exec(b_sub_part.content); + + if (!a_match && b_match) { + return 1; // No regexp, so less specific than b + } + if (!b_match && a_match) { + return -1; + } + if (a_match && b_match) { + return b_match[1].length - a_match[1].length; + } + } } } @@ -74,10 +90,14 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { ) || '_'; const params: string[] = []; - const param_pattern = /\[([^\]]+)\]/g; + const match_patterns: string[] = []; + const param_pattern = /\[([^\(]+)(?:\((.+?)\))?\]/g; let match; while (match = param_pattern.exec(base)) { params.push(match[1]); + if (typeof match[2] !== 'undefined') { + match_patterns.push(`(${match[2]}?)`); + } } // TODO can we do all this with sub-parts? or does @@ -90,7 +110,7 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { const dynamic = ~part.indexOf('['); if (dynamic) { - const matcher = part.replace(param_pattern, `([^\/]+?)`); + const matcher = part.replace(param_pattern, match_patterns[i] || `([^/]+?)`); pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; } else { nested = false; @@ -142,7 +162,7 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { } function get_sub_parts(part: string) { - return part.split(/[\[\]]/) + return part.split(/\[(.+)\]/) .map((content, i) => { if (!content) return null; return { From 8015be806939ed09fc04da8c3ea5a03f3262e596 Mon Sep 17 00:00:00 2001 From: Elco Brouwer von Gonzenbach Date: Tue, 12 Jun 2018 09:15:54 +0700 Subject: [PATCH 2/4] Correct spacing --- src/core/create_routes.ts | 328 +++++++++++++++++++------------------- 1 file changed, 164 insertions(+), 164 deletions(-) diff --git a/src/core/create_routes.ts b/src/core/create_routes.ts index d3431e5d4..e216c3b76 100644 --- a/src/core/create_routes.ts +++ b/src/core/create_routes.ts @@ -4,171 +4,171 @@ import { locations } from '../config'; import { Route } from '../interfaces'; export default function create_routes({ files } = { files: glob.sync('**/*.*', { cwd: locations.routes(), dot: true, nodir: true }) }) { - const routes: Route[] = files - .filter((file: string) => !/(^|\/|\\)_/.test(file)) - .map((file: string) => { - if (/(^|\/|\\)(_|\.(?!well-known))/.test(file)) return; - - if (/]\[/.test(file)) { - throw new Error(`Invalid route ${file} — parameters must be separated`); - } - - const base = file.replace(/\.[^/.]+$/, ''); - const parts = base.split('/'); // glob output is always posix-style - if (parts[parts.length - 1] === 'index') parts.pop(); - - return { - files: [file], - base, - parts - }; - }) - .filter(Boolean) - .filter((a, index, array) => { - const found = array.slice(index + 1).find(b => a.base === b.base); - if (found) found.files.push(...a.files); - return !found; - }) - .sort((a, b) => { - if (a.parts[0] === '4xx' || a.parts[0] === '5xx') return -1; - if (b.parts[0] === '4xx' || b.parts[0] === '5xx') return 1; - - const max = Math.max(a.parts.length, b.parts.length); - - for (let i = 0; i < max; i += 1) { - const a_part = a.parts[i]; - const b_part = b.parts[i]; - - if (!a_part) return -1; - if (!b_part) return 1; - - const a_sub_parts = get_sub_parts(a_part); - const b_sub_parts = get_sub_parts(b_part); - const max = Math.max(a_sub_parts.length, b_sub_parts.length); - - for (let i = 0; i < max; i += 1) { - const a_sub_part = a_sub_parts[i]; - const b_sub_part = b_sub_parts[i]; - - if (!a_sub_part) return 1; // b is more specific, so goes first - if (!b_sub_part) return -1; - - if (a_sub_part.dynamic !== b_sub_part.dynamic) { - return a_sub_part.dynamic ? 1 : -1; - } - - if (!a_sub_part.dynamic && a_sub_part.content !== b_sub_part.content) { - return ( - (b_sub_part.content.length - a_sub_part.content.length) || - (a_sub_part.content < b_sub_part.content ? -1 : 1) - ); - } - // If both parts dynamic, check for regexp patterns - if (a_sub_part.dynamic && b_sub_part.dynamic) { - const regexp_pattern = /\((.*?)\)/; - const a_match = regexp_pattern.exec(a_sub_part.content); - const b_match = regexp_pattern.exec(b_sub_part.content); - - if (!a_match && b_match) { - return 1; // No regexp, so less specific than b - } - if (!b_match && a_match) { - return -1; - } - if (a_match && b_match) { - return b_match[1].length - a_match[1].length; - } - } - } - } - - throw new Error(`The ${a.base} and ${b.base} routes clash`); - }) - .map(({ files, base, parts }) => { - const id = ( - parts.join('_').replace(/[[\]]/g, '$').replace(/^\d/, '_$&').replace(/[^a-zA-Z0-9_$]/g, '_') - ) || '_'; - - const params: string[] = []; - const match_patterns: string[] = []; - const param_pattern = /\[([^\(]+)(?:\((.+?)\))?\]/g; - let match; - while (match = param_pattern.exec(base)) { - params.push(match[1]); - if (typeof match[2] !== 'undefined') { - match_patterns.push(`(${match[2]}?)`); - } - } - - // TODO can we do all this with sub-parts? or does - // nesting make that impossible? - let pattern_string = ''; - let i = parts.length; - let nested = true; - while (i--) { - const part = encodeURI(parts[i].normalize()).replace(/\?/g, '%3F').replace(/#/g, '%23').replace(/%5B/g, '[').replace(/%5D/g, ']'); - const dynamic = ~part.indexOf('['); - - if (dynamic) { - const matcher = part.replace(param_pattern, match_patterns[i] || `([^/]+?)`); - pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; - } else { - nested = false; - pattern_string = `\\/${part}${pattern_string}`; - } - } - - const pattern = new RegExp(`^${pattern_string}\\/?$`); - - const test = (url: string) => pattern.test(url); - - const exec = (url: string) => { - const match = pattern.exec(url); - if (!match) return; - - const result: Record = {}; - params.forEach((param, i) => { - result[param] = match[i + 1]; - }); - - return result; - }; - - return { - id, - handlers: files.map(file => ({ - type: path.extname(file) === '.html' ? 'page' : 'route', - file - })).sort((a, b) => { - if (a.type === 'page' && b.type === 'route') { - return 1; - } - - if (a.type === 'route' && b.type === 'page') { - return -1; - } - - return 0; - }), - pattern, - test, - exec, - parts, - params - }; - }); - - return routes; + const routes: Route[] = files + .filter((file: string) => !/(^|\/|\\)_/.test(file)) + .map((file: string) => { + if (/(^|\/|\\)(_|\.(?!well-known))/.test(file)) return; + + if (/]\[/.test(file)) { + throw new Error(`Invalid route ${file} — parameters must be separated`); + } + + const base = file.replace(/\.[^/.]+$/, ''); + const parts = base.split('/'); // glob output is always posix-style + if (parts[parts.length - 1] === 'index') parts.pop(); + + return { + files: [file], + base, + parts + }; + }) + .filter(Boolean) + .filter((a, index, array) => { + const found = array.slice(index + 1).find(b => a.base === b.base); + if (found) found.files.push(...a.files); + return !found; + }) + .sort((a, b) => { + if (a.parts[0] === '4xx' || a.parts[0] === '5xx') return -1; + if (b.parts[0] === '4xx' || b.parts[0] === '5xx') return 1; + + const max = Math.max(a.parts.length, b.parts.length); + + for (let i = 0; i < max; i += 1) { + const a_part = a.parts[i]; + const b_part = b.parts[i]; + + if (!a_part) return -1; + if (!b_part) return 1; + + const a_sub_parts = get_sub_parts(a_part); + const b_sub_parts = get_sub_parts(b_part); + const max = Math.max(a_sub_parts.length, b_sub_parts.length); + + for (let i = 0; i < max; i += 1) { + const a_sub_part = a_sub_parts[i]; + const b_sub_part = b_sub_parts[i]; + + if (!a_sub_part) return 1; // b is more specific, so goes first + if (!b_sub_part) return -1; + + if (a_sub_part.dynamic !== b_sub_part.dynamic) { + return a_sub_part.dynamic ? 1 : -1; + } + + if (!a_sub_part.dynamic && a_sub_part.content !== b_sub_part.content) { + return ( + (b_sub_part.content.length - a_sub_part.content.length) || + (a_sub_part.content < b_sub_part.content ? -1 : 1) + ); + } + // If both parts dynamic, check for regexp patterns + if (a_sub_part.dynamic && b_sub_part.dynamic) { + const regexp_pattern = /\((.*?)\)/; + const a_match = regexp_pattern.exec(a_sub_part.content); + const b_match = regexp_pattern.exec(b_sub_part.content); + + if (!a_match && b_match) { + return 1; // No regexp, so less specific than b + } + if (!b_match && a_match) { + return -1; + } + if (a_match && b_match) { + return b_match[1].length - a_match[1].length; + } + } + } + } + + throw new Error(`The ${a.base} and ${b.base} routes clash`); + }) + .map(({ files, base, parts }) => { + const id = ( + parts.join('_').replace(/[[\]]/g, '$').replace(/^\d/, '_$&').replace(/[^a-zA-Z0-9_$]/g, '_') + ) || '_'; + + const params: string[] = []; + const match_patterns: string[] = []; + const param_pattern = /\[([^\(]+)(?:\((.+?)\))?\]/g; + let match; + while (match = param_pattern.exec(base)) { + params.push(match[1]); + if (typeof match[2] !== 'undefined') { + match_patterns.push(`(${match[2]}?)`); + } + } + + // TODO can we do all this with sub-parts? or does + // nesting make that impossible? + let pattern_string = ''; + let i = parts.length; + let nested = true; + while (i--) { + const part = encodeURI(parts[i].normalize()).replace(/\?/g, '%3F').replace(/#/g, '%23').replace(/%5B/g, '[').replace(/%5D/g, ']'); + const dynamic = ~part.indexOf('['); + + if (dynamic) { + const matcher = part.replace(param_pattern, match_patterns[i] || `([^/]+?)`); + pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; + } else { + nested = false; + pattern_string = `\\/${part}${pattern_string}`; + } + } + + const pattern = new RegExp(`^${pattern_string}\\/?$`); + + const test = (url: string) => pattern.test(url); + + const exec = (url: string) => { + const match = pattern.exec(url); + if (!match) return; + + const result: Record = {}; + params.forEach((param, i) => { + result[param] = match[i + 1]; + }); + + return result; + }; + + return { + id, + handlers: files.map(file => ({ + type: path.extname(file) === '.html' ? 'page' : 'route', + file + })).sort((a, b) => { + if (a.type === 'page' && b.type === 'route') { + return 1; + } + + if (a.type === 'route' && b.type === 'page') { + return -1; + } + + return 0; + }), + pattern, + test, + exec, + parts, + params + }; + }); + + return routes; } function get_sub_parts(part: string) { - return part.split(/\[(.+)\]/) - .map((content, i) => { - if (!content) return null; - return { - content, - dynamic: i % 2 === 1 - }; - }) - .filter(Boolean); + return part.split(/\[(.+)\]/) + .map((content, i) => { + if (!content) return null; + return { + content, + dynamic: i % 2 === 1 + }; + }) + .filter(Boolean); } \ No newline at end of file From 0e2c2ca101b1261d967fd401bbabb43f209f92da Mon Sep 17 00:00:00 2001 From: Elco Brouwer von Gonzenbach Date: Wed, 13 Jun 2018 10:00:39 +0700 Subject: [PATCH 3/4] Correct errors in param pattern and matching patterns --- src/core/create_routes.ts | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/core/create_routes.ts b/src/core/create_routes.ts index e216c3b76..a0d9b8973 100644 --- a/src/core/create_routes.ts +++ b/src/core/create_routes.ts @@ -90,13 +90,14 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { ) || '_'; const params: string[] = []; - const match_patterns: string[] = []; - const param_pattern = /\[([^\(]+)(?:\((.+?)\))?\]/g; + const match_patterns: object = {}; + const param_pattern = /\[([^\(\]]+)(?:\((.+?)\))?\]/g; let match; while (match = param_pattern.exec(base)) { params.push(match[1]); if (typeof match[2] !== 'undefined') { - match_patterns.push(`(${match[2]}?)`); + // Make a map of the regexp patterns + match_patterns[match[1]] = `(${match[2]}?)`; } } @@ -110,7 +111,13 @@ export default function create_routes({ files } = { files: glob.sync('**/*.*', { const dynamic = ~part.indexOf('['); if (dynamic) { - const matcher = part.replace(param_pattern, match_patterns[i] || `([^/]+?)`); + // Get keys from part and replace with stored match patterns + const keys = part.replace(/\(.*?\)/, '').split(/[\[\]]/).filter((x, i) => { if (i % 2) return x }); + let matcher = part; + keys.forEach(k => { + const key_pattern = new RegExp('\\[' + k + '(?:\\((.+?)\\))?\\]'); + matcher = matcher.replace(key_pattern, match_patterns[k] || `([^/]+?)`); + }) pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; } else { nested = false; From 4f011bfc37c83272ed0410de7db9c738e5d452d7 Mon Sep 17 00:00:00 2001 From: Elco Brouwer von Gonzenbach Date: Mon, 2 Jul 2018 11:52:17 +0700 Subject: [PATCH 4/4] Convert whitespace to tabs. Add some unit tests for create routes --- src/core/create_routes.ts | 357 ++++++++++++++++---------------- test/unit/create_routes.test.js | 65 +++++- 2 files changed, 244 insertions(+), 178 deletions(-) diff --git a/src/core/create_routes.ts b/src/core/create_routes.ts index e527abceb..2dc0c10a7 100644 --- a/src/core/create_routes.ts +++ b/src/core/create_routes.ts @@ -4,184 +4,187 @@ import { locations } from '../config'; import { Route } from '../interfaces'; export default function create_routes({ files } = { files: glob.sync('**/*.*', { cwd: locations.routes(), dot: true, nodir: true }) }) { - const routes: Route[] = files - .filter((file: string) => !/(^|\/|\\)(_(?!error\.html)|\.(?!well-known))/.test(file)) - .map((file: string) => { - if (/]\[/.test(file)) { - throw new Error(`Invalid route ${file} — parameters must be separated`); - } - - if (file === '4xx.html' || file === '5xx.html') { - throw new Error('As of Sapper 0.14, 4xx.html and 5xx.html should be replaced with _error.html'); - } - - const base = file.replace(/\.[^/.]+$/, ''); - const parts = base.split('/'); // glob output is always posix-style - if (/^index(\..+)?/.test(parts[parts.length - 1])) { - const part = parts.pop(); - if (parts.length > 0) parts[parts.length - 1] += part.slice(5); - } - - return { - files: [file], - base, - parts - }; - }) - .filter(Boolean) - .filter((a, index, array) => { - const found = array.slice(index + 1).find(b => a.base === b.base); - if (found) found.files.push(...a.files); - return !found; - }) - .sort((a, b) => { - if (a.parts[0] === '_error') return -1; - if (b.parts[0] === '_error') return 1; - - const max = Math.max(a.parts.length, b.parts.length); - - for (let i = 0; i < max; i += 1) { - const a_part = a.parts[i]; - const b_part = b.parts[i]; - - if (!a_part) return -1; - if (!b_part) return 1; - - const a_sub_parts = get_sub_parts(a_part); - const b_sub_parts = get_sub_parts(b_part); - const max = Math.max(a_sub_parts.length, b_sub_parts.length); - - for (let i = 0; i < max; i += 1) { - const a_sub_part = a_sub_parts[i]; - const b_sub_part = b_sub_parts[i]; - - if (!a_sub_part) return 1; // b is more specific, so goes first - if (!b_sub_part) return -1; - - if (a_sub_part.dynamic !== b_sub_part.dynamic) { - return a_sub_part.dynamic ? 1 : -1; - } - - if (!a_sub_part.dynamic && a_sub_part.content !== b_sub_part.content) { - return ( - (b_sub_part.content.length - a_sub_part.content.length) || - (a_sub_part.content < b_sub_part.content ? -1 : 1) - ); - } - - // If both parts dynamic, check for regexp patterns - if (a_sub_part.dynamic && b_sub_part.dynamic) { - const regexp_pattern = /\((.*?)\)/; - const a_match = regexp_pattern.exec(a_sub_part.content); - const b_match = regexp_pattern.exec(b_sub_part.content); - - if (!a_match && b_match) { - return 1; // No regexp, so less specific than b - } - if (!b_match && a_match) { - return -1; - } - if (a_match && b_match) { - return b_match[1].length - a_match[1].length; - } - } - } - } - - throw new Error(`The ${a.base} and ${b.base} routes clash`); - }) - .map(({ files, base, parts }) => { - const id = ( - parts.join('_').replace(/[[\]]/g, '$').replace(/^\d/, '_$&').replace(/[^a-zA-Z0-9_$]/g, '_') - ) || '_'; - - const params: string[] = []; - const match_patterns: object = {}; - const param_pattern = /\[([^\(\]]+)(?:\((.+?)\))?\]/g; - let match; - while (match = param_pattern.exec(base)) { - params.push(match[1]); - if (typeof match[2] !== 'undefined') { - // Make a map of the regexp patterns - match_patterns[match[1]] = `(${match[2]}?)`; - } - } - - // TODO can we do all this with sub-parts? or does - // nesting make that impossible? - let pattern_string = ''; - let i = parts.length; - let nested = true; - while (i--) { - const part = encodeURI(parts[i].normalize()).replace(/\?/g, '%3F').replace(/#/g, '%23').replace(/%5B/g, '[').replace(/%5D/g, ']'); - const dynamic = ~part.indexOf('['); - - if (dynamic) { - // Get keys from part and replace with stored match patterns - const keys = part.replace(/\(.*?\)/, '').split(/[\[\]]/).filter((x, i) => { if (i % 2) return x }); - let matcher = part; - keys.forEach(k => { - const key_pattern = new RegExp('\\[' + k + '(?:\\((.+?)\\))?\\]'); - matcher = matcher.replace(key_pattern, match_patterns[k] || `([^/]+?)`); - }) - pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; - } else { - nested = false; - pattern_string = `\\/${part}${pattern_string}`; - } - } - - const pattern = new RegExp(`^${pattern_string}\\/?$`); - - const test = (url: string) => pattern.test(url); - - const exec = (url: string) => { - const match = pattern.exec(url); - if (!match) return; - - const result: Record = {}; - params.forEach((param, i) => { - result[param] = match[i + 1]; - }); - - return result; - }; - - return { - id, - handlers: files.map(file => ({ - type: path.extname(file) === '.html' ? 'page' : 'route', - file - })).sort((a, b) => { - if (a.type === 'page' && b.type === 'route') { - return 1; - } - - if (a.type === 'route' && b.type === 'page') { - return -1; - } - - return 0; - }), - pattern, - test, - exec, - parts, - params - }; - }); - - return routes; + const routes: Route[] = files + .filter((file: string) => !/(^|\/|\\)(_(?!error\.html)|\.(?!well-known))/.test(file)) + .map((file: string) => { + if (/]\[/.test(file)) { + throw new Error(`Invalid route ${file} — parameters must be separated`); + } + + if (file === '4xx.html' || file === '5xx.html') { + throw new Error('As of Sapper 0.14, 4xx.html and 5xx.html should be replaced with _error.html'); + } + + const base = file.replace(/\.[^/.]+$/, ''); + const parts = base.split('/'); // glob output is always posix-style + if (/^index(\..+)?/.test(parts[parts.length - 1])) { + const part = parts.pop(); + if (parts.length > 0) parts[parts.length - 1] += part.slice(5); + } + + return { + files: [file], + base, + parts + }; + }) + .filter(Boolean) + .filter((a, index, array) => { + const found = array.slice(index + 1).find(b => a.base === b.base); + if (found) found.files.push(...a.files); + return !found; + }) + .sort((a, b) => { + if (a.parts[0] === '_error') return -1; + if (b.parts[0] === '_error') return 1; + + const max = Math.max(a.parts.length, b.parts.length); + + for (let i = 0; i < max; i += 1) { + const a_part = a.parts[i]; + const b_part = b.parts[i]; + + if (!a_part) return -1; + if (!b_part) return 1; + + const a_sub_parts = get_sub_parts(a_part); + const b_sub_parts = get_sub_parts(b_part); + const max = Math.max(a_sub_parts.length, b_sub_parts.length); + + for (let i = 0; i < max; i += 1) { + const a_sub_part = a_sub_parts[i]; + const b_sub_part = b_sub_parts[i]; + + if (!a_sub_part) return 1; // b is more specific, so goes first + if (!b_sub_part) return -1; + + if (a_sub_part.dynamic !== b_sub_part.dynamic) { + return a_sub_part.dynamic ? 1 : -1; + } + + if (!a_sub_part.dynamic && a_sub_part.content !== b_sub_part.content) { + return ( + (b_sub_part.content.length - a_sub_part.content.length) || + (a_sub_part.content < b_sub_part.content ? -1 : 1) + ); + } + + // If both parts dynamic, check for regexp patterns + if (a_sub_part.dynamic && b_sub_part.dynamic) { + const regexp_pattern = /\((.*?)\)/; + const a_match = regexp_pattern.exec(a_sub_part.content); + const b_match = regexp_pattern.exec(b_sub_part.content); + + if (!a_match && b_match) { + return 1; // No regexp, so less specific than b + } + if (!b_match && a_match) { + return -1; + } + if (a_match && b_match && a_match[1] !== b_match[1]) { + return b_match[1].length - a_match[1].length; + } + } + } + } + + throw new Error(`The ${a.base} and ${b.base} routes clash`); + }) + .map(({ files, base, parts }) => { + const id = ( + parts.join('_').replace(/[[\]]/g, '$').replace(/^\d/, '_$&').replace(/[^a-zA-Z0-9_$]/g, '_') + ) || '_'; + + const params: string[] = []; + const match_patterns: object = {}; + const param_pattern = /\[([^\(\]]+)(?:\((.+?)\))?\]/g; + let match; + while (match = param_pattern.exec(base)) { + params.push(match[1]); + if (typeof match[2] !== 'undefined') { + if (/[\(\)\?\:]/.exec(match[2])) { + throw new Error('Sapper does not allow (, ), ? or : in RegExp routes yet'); + } + // Make a map of the regexp patterns + match_patterns[match[1]] = `(${match[2]}?)`; + } + } + + // TODO can we do all this with sub-parts? or does + // nesting make that impossible? + let pattern_string = ''; + let i = parts.length; + let nested = true; + while (i--) { + const part = encodeURI(parts[i].normalize()).replace(/\?/g, '%3F').replace(/#/g, '%23').replace(/%5B/g, '[').replace(/%5D/g, ']'); + const dynamic = ~part.indexOf('['); + + if (dynamic) { + // Get keys from part and replace with stored match patterns + const keys = part.replace(/\(.*?\)/, '').split(/[\[\]]/).filter((x, i) => { if (i % 2) return x }); + let matcher = part; + keys.forEach(k => { + const key_pattern = new RegExp('\\[' + k + '(?:\\((.+?)\\))?\\]'); + matcher = matcher.replace(key_pattern, match_patterns[k] || `([^/]+?)`); + }) + pattern_string = nested ? `(?:\\/${matcher}${pattern_string})?` : `\\/${matcher}${pattern_string}`; + } else { + nested = false; + pattern_string = `\\/${part}${pattern_string}`; + } + } + + const pattern = new RegExp(`^${pattern_string}\\/?$`); + + const test = (url: string) => pattern.test(url); + + const exec = (url: string) => { + const match = pattern.exec(url); + if (!match) return; + + const result: Record = {}; + params.forEach((param, i) => { + result[param] = match[i + 1]; + }); + + return result; + }; + + return { + id, + handlers: files.map(file => ({ + type: path.extname(file) === '.html' ? 'page' : 'route', + file + })).sort((a, b) => { + if (a.type === 'page' && b.type === 'route') { + return 1; + } + + if (a.type === 'route' && b.type === 'page') { + return -1; + } + + return 0; + }), + pattern, + test, + exec, + parts, + params + }; + }); + + return routes; } function get_sub_parts(part: string) { - return part.split(/\[(.+)\]/) - .map((content, i) => { - if (!content) return null; - return { - content, - dynamic: i % 2 === 1 - }; - }) - .filter(Boolean); + return part.split(/\[(.+)\]/) + .map((content, i) => { + if (!content) return null; + return { + content, + dynamic: i % 2 === 1 + }; + }) + .filter(Boolean); } \ No newline at end of file diff --git a/test/unit/create_routes.test.js b/test/unit/create_routes.test.js index cae5dc20e..32f2b86aa 100644 --- a/test/unit/create_routes.test.js +++ b/test/unit/create_routes.test.js @@ -45,7 +45,17 @@ describe('create_routes', () => { it('sorts routes correctly', () => { const routes = create_routes({ - files: ['index.html', 'about.html', 'post/f[xx].html', '[wildcard].html', 'post/foo.html', 'post/[id].html', 'post/bar.html', 'post/[id].json.js'] + files: [ + 'index.html', + 'about.html', + 'post/f[xx].html', + '[wildcard].html', + 'post/foo.html', + 'post/[id].html', + 'post/bar.html', + 'post/[id].json.js', + 'post/[id([0-9-a-z]{3,})].html', + ] }); assert.deepEqual( @@ -56,6 +66,7 @@ describe('create_routes', () => { 'post/bar.html', 'post/foo.html', 'post/f[xx].html', + 'post/[id([0-9-a-z]{3,})].html', // RegExp is more specific 'post/[id].json.js', 'post/[id].html', '[wildcard].html' @@ -63,6 +74,25 @@ describe('create_routes', () => { ); }); + it('distinguishes and sorts regexp routes correctly', () => { + const routes = create_routes({ + files: [ + '[slug].html', + '[slug([a-z]{2})].html', + '[slug([0-9-a-z]{3,})].html', + ] + }); + + assert.deepEqual( + routes.map(r => r.handlers[0].file), + [ + '[slug([0-9-a-z]{3,})].html', + '[slug([a-z]{2})].html', + '[slug].html', + ] + ); + }); + it('prefers index page to nested route', () => { let routes = create_routes({ files: [ @@ -131,6 +161,24 @@ describe('create_routes', () => { 'api/blog/[slug].js', ] ); + + // RegExp routes + routes = create_routes({ + files: [ + 'blog/[slug].html', + 'blog/index.html', + 'blog/[slug([^0-9]+)].html', + ] + }); + + assert.deepEqual( + routes.map(r => r.handlers[0].file), + [ + 'blog/index.html', + 'blog/[slug([^0-9]+)].html', + 'blog/[slug].html', + ] + ); }); it('generates params', () => { @@ -204,8 +252,15 @@ describe('create_routes', () => { files: ['[foo].html', '[bar]/index.html'] }); }, /The \[foo\] and \[bar\]\/index routes clash/); + + assert.throws(() => { + create_routes({ + files: ['[foo([0-9-a-z]+)].html', '[bar([0-9-a-z]+)]/index.html'] + }); + }, /The \[foo\(\[0-9-a-z\]\+\)\] and \[bar\(\[0-9-a-z\]\+\)\]\/index routes clash/); }); + it('matches nested routes', () => { const route = create_routes({ files: ['settings/[submenu].html'] @@ -281,6 +336,14 @@ describe('create_routes', () => { }, /Invalid route \[foo\]\[bar\]\.js — parameters must be separated/); }); + it('errors when trying to use reserved characters in route regexp', () => { + assert.throws(() => { + create_routes({ + files: ['[lang([a-z]{2}(?:-[a-z]{2,4})?)]'] + }); + }, /Sapper does not allow \(, \), \? or \: in RegExp routes yet/); + }); + it('errors on 4xx.html', () => { assert.throws(() => { create_routes({