Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

path-to-regex

Package Overview
Dependencies
Maintainers
1
Versions
16
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

path-to-regex - npm Package Compare versions

Comparing version 1.2.2 to 1.3.0

index.js.01

187

index.js

@@ -11,4 +11,4 @@ module.exports = Regex;

*/
function Regex( path, options ) {
this.init( path, options );
function Regex(path, options) {
this.init(path, options);
return this;

@@ -18,16 +18,17 @@ }

Regex.prototype.init = function(
path = "/",
path = "/",
options = {}
) {
this.options = {
case: options.case||true,
separators: options.separators||"/",
fromStart: options.fromStart||true,
toEnd: options.toEnd||true
case: options.case || true,
separators: options.separators || "/",
fromStart: options.fromStart || true,
toEnd: options.toEnd || true
}
this.options.separator = "[" + this.escape(this.options.separators) + "]";
if( path instanceof RegExp ){
this.restructureRegExp(path);
}else if( typeof path === "string" ){
this.restructurePath(path);
if (path instanceof RegExp) {
this.restructureRegExp(path);
} else if (typeof path === "string") {
this.restructurePath(path);
}

@@ -41,12 +42,12 @@ };

*/
Regex.prototype.restructureRegExp = function (regexp=/.*/) {
Regex.prototype.restructureRegExp = function(regexp = /.*/) {
this.keys = [];
this.path = undefined;
this.regstr = (""+regexp);
this.regstr =this.regstr.substr(1, this.regstr.length-2);
this.regexp = new RegExp(
this.regstr,
this.options.case?"":"i"
);
this.regstr = ("" + regexp);
this.regstr = this.regstr.substr(1, this.regstr.length - 2);
this.regexp = new RegExp(
this.regstr,
this.options.case ? "" : "i"
);
}

@@ -59,3 +60,3 @@

*/
Regex.prototype.restructurePath = function (path="/") {
Regex.prototype.restructurePath = function(path = "/") {
this.keys = [];

@@ -65,6 +66,11 @@ this.path = path;

const separator = this.options.separator;
const notseparator = "[^" + this.escape(this.options.separators) + "]";
let offset = 0;
let count = 0;
path.replace(/:([a-z]\w*)(\((.*?)\))?([\?\*\+])?/gi,(str,key,a,pat,quant,index,string)=>{
path = path.replace(new RegExp("^" + separator + "*(.*?)" + separator + "*$"), "$1");
path.replace(/:([a-z]\w*)(\((.*?)\))?([\?\*\+])?/gi, (str, key, a, pat, quant, index, string) => {
// console.log("-----------------------------");

@@ -78,37 +84,37 @@ // console.log("str:", str);

// console.log("string:",string);
count++;
// let pq = pat?pat[pat.length-1]:"";
// pq = (pq==="+"||pq==="*")?"?":"";
const pattern = (pat ? pat : notseparator + "+");
const isMultiple = (quant === "*" || quant === "+") ? true : false;
const isRequired = (quant !== "*" && quant !== "?") ? true : false;
const quantifier = quant ? quant : "";
const pattern = (pat?pat:"[^"+this.escape(this.options.separators)+"]+");
const isMultiple = (quant==="*" || quant==="+")?true:false;
const isRequired = (quant!=="*" && quant!=="?")?true:false;
const quantifier = quant?quant:"";
const startChar = path.charAt(index-1);
const isStarted = this.separator(startChar);
// const startChar = path.charAt(index-1);
const isStarted = (!index)?true:this.separator(path.charAt(index-1));
const isStoped = (index+str.length>=path.length)?true:this.separator(path.charAt(index+str.length));
const isToken = isStarted && isStoped;
if( index > offset ){
const text = path.substring(offset,index);
if (index > offset) {
const text = path.substring(offset, index);
const regstr = this.escape(text);
this.regstr+=regstr;
this.regstr += regstr;
}
count++;
if( isToken && index && ( !isMultiple || !isRequired) )
this.regstr+="?";
if( !isRequired && isStarted || isMultiple ){
if(index)
this.regstr+="?";
}
const regstr =
isMultiple?
const regstr =
isMultiple ?
isToken?
"((?:\\"+startChar+""+pattern+")"+quantifier+")":
"((?:"+pattern+"\\"+startChar+"?)"+quantifier+")":
"((?:" + separator + "?" + pattern + ")" + quantifier + ")" :
"((?:" + notseparator + "*" + pattern + ")" + quantifier + ")" :
isToken?
"("+pattern+")"+quantifier:
"("+pattern+")"+quantifier;
this.regstr+=regstr;
"(" + pattern + "?)" + quantifier:
"(" + pattern + (pat?"":"?")+")" + quantifier;
this.regstr += regstr;
// /^[\/]?foo\/?((?:[\/]?.+)+)[\/]?$/
const data = {

@@ -121,25 +127,25 @@ key: key,

};
if( isMultiple )
data.regexp = new RegExp(pattern, this.options.case?"g":"gi" );
if (isMultiple)
data.regexp = new RegExp(pattern, this.options.case ? "g" : "gi");
this.keys.push(data);
offset = index+str.length;
offset = index + str.length;
return str;
});
if( offset < path.length-1 ){
if (offset < path.length - 1) {
const text = path.substring(offset);
const regstr = this.escape(text);
this.regstr+=regstr;
}
this.regstr += regstr;
}
this.regexp = new RegExp(
(this.options.fromStart?"^":"")+
this.regstr+
"["+this.escape(this.options.separators)+"]?"+
(this.options.toEnd?"$":"")
,
this.options.case?"":"i"
);
this.regexp = new RegExp(
(this.options.fromStart ? "^" : "") +
separator + "?" +
this.regstr +
separator + "?" +
(this.options.toEnd ? "$" : ""),
this.options.case ? "" : "i"
);
}

@@ -155,3 +161,5 @@

Regex.prototype.escape = function(text) {
return text.replace(escapeRe,s=>{return "\\"+s});
return text.replace(escapeRe, s => {
return "\\" + s
});
}

@@ -165,3 +173,3 @@

Regex.prototype.separator = function(char) {
return !!(this.options.separators.indexOf(char)+1);
return !!(this.options.separators.indexOf(char) + 1);
}

@@ -172,27 +180,30 @@

Regex.prototype.match = function(path) {
// console.log("Regex.match 01");
if( typeof path !== "string" ) return;
// console.log("Regex.match 02");
// console.log("match 01");
if (typeof path !== "string") return;
// console.log("match 02");
const result = path.match(this.regexp);
if(!result) return;
// console.log("Regex.match 03", result);
if(result.groups)
return result.groups;
// console.log("match 03");
if (!result) return;
// console.log("match 04");
const data = {};
this.keys.forEach(item=>{
// console.log("match 05");
this.keys.forEach(item => {
// console.log("match foreach 01");
let isMultiple = false;
// console.log("--------------");
// console.log(result[item.index]);
if( data[item.key] )
if (data[item.key])
isMultiple = true;
if( data[item.key] && !Array.isArray(data[item.key]) ){
if (data[item.key] && !Array.isArray(data[item.key])) {
isMultiple = true;
data[item.key] = [data[item.key]];
}
if( item.multiple && !data[item.key] ){
if (item.multiple && !data[item.key]) {
isMultiple = true;

@@ -202,26 +213,24 @@ data[item.key] = [];

// console.log("key match 01", item.key, item.multiple, isMultiple);
if( !isMultiple && !item.multiple){
data[item.key] = result[item.index];
let value = result[item.index]?result[item.index]:undefined;
if (!isMultiple && !item.multiple) {
data[item.key] = value;
return;
}
// console.log("key match 02");
if( isMultiple && !item.multiple && result[item.index] ){
data[item.key].push(result[item.index]);
if (isMultiple && !item.multiple && result[item.index]) {
data[item.key].push(value);
return;
}
// console.log("key match 03", result);
if(result[item.index])
result[item.index].replace(item.regexp, str=>{
data[item.key].push(str);
if (result[item.index])
result[item.index].replace(item.regexp, str => {
if(str) data[item.key].push(
str.replace(new RegExp(this.options.separator+"*$"), "")
);
});
});
// console.log("match 06");
return data;
};

2

package.json
{
"name": "path-to-regex",
"version": "1.2.2",
"version": "1.3.0",
"description": "Turn a path string such as /user/:id or /user/:id(\\d+) into a regular expression",

@@ -5,0 +5,0 @@ "main": "index.js",

229

README.md

@@ -41,87 +41,48 @@ # path-to-regex

```javascript
let parser = new pathToRegex(':path*');
// parser.regexp: /^((?:\[^\/]+)*)[\/]?$/
let parser = new pathToRegex(':path*'); // parser.regexp: /^[\/]?((?:[\/]?[^\/]+)*)[\/]?$/
let result = parser.match('user'); // result: undefined
let result = parser.match('user/id'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('/user/id'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('user/id/'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('/user/id/'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('/user'); // result: undefined
let parser = new pathToRegex('/:path*'); // parser.regexp: /^[\/]?((?:[\/]?[^\/]+)*)[\/]?$/
let result = parser.match('user/'); // result: undefined
let result = parser.match('/user/'); // result: undefined
let result = parser.match('user/id'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('/user/id'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('user/id/'); // result: { path: [ 'user', 'id' ] }
let result = parser.match('/user/id/'); // result: { path: [ 'user', 'id' ] }
```
```javascript
let parser = new pathToRegex('/:path*');
// parser.regexp: /^\/?((?:\/[^\/]+)*)[\/]?$/
let result = parser.match('user'); // result: undefined
let result = parser.match('/user'); // result: { path: [ 'user' ] }
let result = parser.match('user/'); // result: undefined
let result = parser.match('/user/'); // result: { path: [ 'user' ] }
```
#### Pattern `(...)`, in contrast quantifier, allows you to directly determine the valid key pattern. Such pattern `(.*)` will capture everything, including the splitter.
```javascript
let parser = new pathToRegex(':path(.*)');
// parser.regexp: /^(.*)[\/]?$/
let parser = new pathToRegex(':path(.*)'); // parser.regexp: /^[\/]?(.*?)[\/]?$/
let result = parser.match('user'); // result: { path: 'user' }
let result = parser.match('user/id'); // result: { path: 'user/id' }
let result = parser.match('/user/id'); // result: { path: 'user/id' }
let result = parser.match('user/id/'); // result: { path: 'user/id' }
let result = parser.match('/user/id/'); // result: { path: 'user/id' }
let result = parser.match('/user'); // result: { path: '/user' }
let parser = new pathToRegex('/:path(.*)'); // parser.regexp: /^[\/]?(.*?)[\/]?$/
let result = parser.match('user/'); // result: { path: 'user/' }
let result = parser.match('/user/'); // result: { path: '/user/' }
let result = parser.match('user/id'); // result: { path: 'user/id' }
let result = parser.match('/user/id'); // result: { path: 'user/id' }
let result = parser.match('user/id/'); // result: { path: 'user/id' }
let result = parser.match('/user/id/'); // result: { path: 'user/id' }
```
#### But it does not capture parts of the path that are clearly indicated.
```javascript
let parser = new pathToRegex('/:path(.*)');
// parser.regexp: /^\/(.*)[\/]?$/
let result = parser.match('user'); // result: undefined
let result = parser.match('/user'); // result: { path: 'user' }
let result = parser.match('user/'); // result: undefined
let result = parser.match('/user/'); // result: { path: 'user/' }
```
## Samples
The following examples clearly demonstrate the use of keys, their pattern quantifiers.
#### Demonstration of processing a simple key identifier `:keyname`
```javascript
let parser = new pathToRegex('/foo/:bar');
// parser.regexp: /^\/foo\/([^\/]+)[\/]?$/
let result = parser.match('/foo/asd'); // result: { bar: 'asd' }
let result = parser.match('/foo/123'); // result: { bar: '123' }
let result = parser.match('/foo/123/bar'); // result: undefined
```
#### Demonstration of processing a key identifier with a specific content `:keyname(\\d+)`
```javascript
let parser = new pathToRegex('/foo/:bar(\\d+)');
// parser.regexp: /^\/foo\/(\d+)[\/]?$/
let parser = new pathToRegex('/foo/:bar(\\d+)'); // parser.regexp: /^[\/]?foo\/?(\d+?)[\/]?$/
let result = parser.match('/foo/123'); // result: { bar: '123' }
let result = parser.match('/foo/asd'); // result: undefined
let result = parser.match('/foo/123asd'); // result: undefined
let result = parser.match('/foo/123/bar'); // result: undefined
let result = parser.match('/foo/123'); // result: { bar: '123' }
let result = parser.match('/foo/asd'); // result: undefined
let result = parser.match('/foo/123asd'); // result: undefined
let result = parser.match('/foo/123/bar'); // result: undefined
```

@@ -134,8 +95,6 @@

```javascript
let parser = new pathToRegex('/user/:foo/:bar');
// parser.regexp: /^\/user\/([^\/]+)\/([^\/]+)[\/]?$/
let parser = new pathToRegex('/user/:foo/:bar'); // parser.regexp: /^[\/]?user\/?([^\/]+?)\/?([^\/]+?)[\/]?$/
let result = parser.match('/user/123/asd'); // result: { foo: '123', bar: 'asd' }
let result = parser.match('/user/asd/123'); // result: { foo: 'asd', bar: '123' }
let result = parser.match('/user/123/asd'); // result: { foo: '123', bar: 'asd' }
let result = parser.match('/user/asd/123'); // result: { foo: 'asd', bar: '123' }
```

@@ -148,8 +107,6 @@

```javascript
let parser = new pathToRegex('/foo/:bar/:bar');
// parser.regexp: /^\/foo\/([^\/]+)\/([^\/]+)[\/]?$/
let parser = new pathToRegex('/foo/:bar/:bar'); // parser.regexp: /^[\/]?foo\/?([^\/]+?)\/?([^\/]+?)[\/]?$/
let result = parser.match('/foo/123/asd'); // result: { bar: [ '123', 'asd' ] }
let result = parser.match('/foo/asd/123'); // result: { bar: [ 'asd', '123' ] }
let result = parser.match('/foo/123/asd'); // result: { bar: [ '123', 'asd' ] }
let result = parser.match('/foo/asd/123'); // result: { bar: [ 'asd', '123' ] }
```

@@ -162,10 +119,7 @@

```javascript
let parser = new pathToRegex('/foo/:bar?');
// parser.regexp: /^\/foo\/?([^\/]+)?[\/]?$/
let parser = new pathToRegex('/foo/:bar?'); // parser.regexp: /^[\/]?foo\/?([^\/]+?)?[\/]?$/
let result = parser.match('/foo/123'); // result: { bar: '123' }
let result = parser.match('/foo/'); // result: { bar: undefined }
let result = parser.match('/foo'); // result: { bar: undefined }
let result = parser.match('/foo/123'); // result: { bar: '123' }
let result = parser.match('/foo/'); // result: { bar: undefined }
let result = parser.match('/foo'); // result: { bar: undefined }
```

@@ -176,104 +130,41 @@

#### Demonstration of processing a key identifier with a quantifiers `*` and `+`
```javascript
let parser = new pathToRegex('/foo/:bar*');
// parser.regexp: /^\/foo\/?((?:\/[^\/]+)*)[\/]?$/
let result = parser.match('/foo'); // result: { bar: [] }
let result = parser.match('/foo/'); // result: { bar: [] }
let result = parser.match('/foo/123'); // result: { bar: [ '123' ] }
let result = parser.match('/foo/123/456'); // result: { bar: [ '123', '456' ] }
let result = parser.match('/foo/123/456/'); // result: { bar: [ '123', '456' ] }
let parser = new pathToRegex('/foo/ids: :bar*/:count?');
// parser.regexp: /^\/foo\/ids\: ?((?:[^\/]+\ ?)*)\/?([^\/]+)?[\/]?$/
let result = parser.match('/foo/ids: 123 456 789'); // result: { bar: [ '123 456 789' ], count: undefined }
let result = parser.match('/foo/ids: 123 456 789/3'); // result: { bar: [ '123 456 789' ], count: '3' }
let parser = new pathToRegex('/foo/:bar+');
// parser.regexp: /^\/foo\/?((?:\/[^\/]+)+)[\/]?$/
let result = parser.match('/foo'); // result: undefined
let result = parser.match('/foo/'); // result: undefined
let result = parser.match('/foo/123'); // result: { bar: [ '123' ] }
let result = parser.match('/foo/123/456'); // result: { bar: [ '123', '456' ] }
let result = parser.match('/foo/123/456/'); // result: { bar: [ '123', '456' ] }
let parser = new pathToRegex('/foo/ids-,:bar+/:count?');
// parser.regexp: /^\/foo\/ids-,?((?:[^\/]+\,?)+)\/?([^\/]+)?[\/]?$/
let result = parser.match('/foo/ids-123,456,789'); // result: { bar: [ '123,456,789' ], count: undefined }
let result = parser.match('/foo/ids-123,456,789/3'); // result: { bar: [ '123,456,789' ], count: '3' }
```
#### Demonstration of processing a key identifier with all features
```javascript
let parser = new pathToRegex('/user/:id/bar/:key(\\d+):post?fak/:key(\d+)*:foo+/test/pictures-,:multi(\w+?\.png)*/:key?');
// parser.regexp: /^\/user\/([^\/]+)\/bar\/(\d+)([^\/]+)?fak\/?((?:\d+\/?)*)?((?:[^\/]+\*?)+)\/test\/pictures-,?((?:\w+?\.png\,?)*)\/?([^\/]+)?[\/]?$/
let parser = new pathToRegex('/user/:id/bar/:key(\\d+):post?fak/:key(\d+)*:foo+/test/pictures-:multi(\w+?\.png)*/:key?'); // parser.r/]+?)?fak\/((?:[^\/]*\d+)*)((?:[^\/]*[^\/]+)+)\/test\/pictures-((?:[^\/]*\w+?\.png)*)\/?([^\/]+?)?[\/]?$/
let result = parser.match('/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png,p02.png,p03.png');
/* result:
{ id: '123',
key: [ '111', '222' ],
let result = parser.match('/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png,p02.png,p03.png/333'); // result: { id: '123',
key: [ '111', '222', '333' ],
post: 'qwerty',
foo: [ 'foo' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
*/
let result = parser.match('/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png,p02.png,p03.png/333');
/* result:
{ id: '123',
key: [ '111', '222', '333' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
let result = parser.match('/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png-p02.png-p03.png'); // result: { id: '123',
key: [ '111', '222' ],
post: 'qwerty',
foo: [ 'foo' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
*/
let parser = new pathToRegex('/user/:id/bar/:key(\\d+):post?fak/:key(\d+)*:foo+/test/pictures- :multi(\w+?\.png)*/:key*');
// parser.regexp: /^\/user\/([^\/]+)\/bar\/(\d+)([^\/]+)?fak\/?((?:\d+\/?)*)?((?:[^\/]+\*?)+)\/test\/pictures- ?((?:\w+?\.png\ ?)*)\/?((?:\/[^\/]+)*)[\/]?$/
let result = parser.match('/user/123/bar/111fak/222foo/test/pictures-p01.png p02.png p03.png');
/* result:
{ id: '123',
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
let result = parser.match('/user/123/bar/111fak/222foo/test/pictures-p01.png,p02.png,p03.png'); // result: { id: '123',
key: [ '111', '222' ],
post: undefined,
foo: [ 'foo' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
*/
let result = parser.match('/user/123/bar/111fak/222foo/test/pictures-p01.png p02.png p03.png/333');
/* result:
{ id: '123',
key: [ '111', '222', '333' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
let result = parser.match('/user/123/bar/111fak/foo/test/pictures-p01.png;p02.png;p03.png'); // result: { id: '123',
key: [ '111' ],
post: undefined,
foo: [ 'foo' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
*/
let result = parser.match('/user/123/bar/111fak/222foo/test/pictures-p01.png p02.png p03.png/333/444/');
/* result:
{ id: '123',
key: [ '111', '222', '333', '444' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
let result = parser.match('/user/123/bar/111fak/foo/test/pictures-p01.png p02.png'); // result: { id: '123',
key: [ '111' ],
post: undefined,
foo: [ 'foo' ],
multi: [ 'p01.png', 'p02.png', 'p03.png' ] }
*/
multi: [ 'p01.png', 'p02.png' ] }
let result = parser.match('/user/123/bar/111fak/foo/test/pictures-p01.png'); // result: { id: '123',
key: [ '111' ],
post: undefined,
foo: [ 'foo' ],
multi: [ 'p01.png' ] }
let result = parser.match('/user/123/bar/111fak/foo/test/pictures-'); // result: { id: '123',
key: [ '111' ],
post: undefined,
foo: [ 'foo' ],
multi: [] }
```

@@ -280,0 +171,0 @@

668

test/01.path-to-regex.js

@@ -5,49 +5,592 @@ const PathToRegex = require("../index.js");

const assert = chai.assert;
// const expect = chai.expect;
const expect = chai.expect;
// const should = chai.should;
describe("Тестируем модуль преобразования пути в RegExp", function() {
let parser = new PathToRegex(":path*");
let path = "user";
describe("01. Тестируем шаблон '/:path'", function() {
const re = new PathToRegex("/:path");
console.log("01. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'user'. результат: `{path:'user'}`", function() {
expect( re.match("user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:'user'}`", function() {
expect( re.match("/user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:'user'}`", function() {
expect( re.match("user/") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:'user'}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:'user'});
});
it("шаблон не совпадает со строкой 'user/12345'. результат: `undefined`", function() {
assert.equal( re.match("user/12345"), undefined);
});
it("шаблон не совпадает со строкой '/user/12345'. результат: `undefined`", function() {
assert.equal( re.match("/user/12345"), undefined);
});
it("шаблон не совпадает со строкой 'user/12345/'. результат: `undefined`", function() {
assert.equal( re.match("user/12345/"), undefined);
});
it("шаблон не совпадает со строкой '/user/12345/'. результат: `undefined`", function() {
assert.equal( re.match("/user/12345/"), undefined);
});
let re = parser.regexp;
//let re = /^\/?((?:\/[^\/]+)*)[\/]?$/;
//let re = /^\/?((?:\/[^\/]+)*)[\/]?$/;
});
let result = path.match(re);
describe("02. Тестируем шаблон '/:path*'", function() {
const re = new PathToRegex("/:path*");
console.log("02. REGEXP:",re.regexp);
it("шаблон совпадает со строкой ''. результат: `{path:[]}`", function() {
expect( re.match("") ).to.deep.equal({path:[]});
});
it("шаблон совпадает со строкой '/'. результат: `{path:[]}`", function() {
expect( re.match("/") ).to.deep.equal({path:[]});
});
it("шаблон совпадает со строкой 'user'. результат: `{path:['user']}`", function() {
expect( re.match("user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:['user']}`", function() {
expect( re.match("/user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:['user']}`", function() {
expect( re.match("user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:['user']}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:['user','12345']});
});
});
console.log("REGEXP:", "\t\t", re);
console.log("RESULT:", "\t\t", result);
describe("03. Тестируем шаблон '/:path+'", function() {
const re = new PathToRegex("/:path+");
console.log("03. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'user'. результат: `{path:['user']}`", function() {
expect( re.match("user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:['user']}`", function() {
expect( re.match("/user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:['user']}`", function() {
expect( re.match("user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:['user'}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:['user','12345']});
});
});
describe("Тестируем модуль преобразования пути в RegExp", function() {
describe("04. Тестируем шаблон '/:path(.*)'", function() {
const re = new PathToRegex("/:path(.*)");
console.log("04. REGEXP:",re.regexp);
it("шаблон совпадает со строкой ''. результат: `{path: undefined}`", function() {
expect( re.match("") ).to.deep.equal({path:undefined});
});
it("шаблон совпадает со строкой '/'. результат: `{path: undefined}`", function() {
expect( re.match("/") ).to.deep.equal({path:undefined});
});
// it("проверяем пооддержку именовынных групп в RegExp", function() {
// let re = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u;
// let result = re.exec('2015-01-02');
// assert.equal( result.groups.year, '2015');
// assert.equal( result.groups.month, '01');
// assert.equal( result.groups.day, '02');
// });
it("шаблон совпадает со строкой 'user'. результат: `{path:'user'}`", function() {
expect( re.match("user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:'user'}`", function() {
expect( re.match("/user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:'user'}`", function() {
expect( re.match("user/") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:'user'}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:'user'});
});
// const re1 = new PathToRegex("/:path*");
// console.log("REGEX:", "\t\t"+re1.regexp, "\t\t", re1.regexp, "\t\t", re1.regstr, "\t\t", re1.path);
// it("создаем RegExp из '/:path*'", function() {
// assert.equal( re1 instanceof PathToRegex, true);
// assert.equal( ""+re1.regexp, ""+/^\/?((?:\/[^\/]+)*)[\/]?$/ );
// });
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:'user/12345'}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:'user/12345'}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:'user/12345'}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:'user/12345'}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:'user/12345'});
});
});
// it("соотносим шаблон '/:path*' со строками '/' '/user' '/user/12345' ", function() {
// assert.equal( re1.match("/"), ""+{path:''});
// assert.equal( re1.match("/user"), ""+{path:'user'});
// assert.equal( re1.match("/user/12345"), ""+{path:'user/12345'});
// });
describe("05. Тестируем шаблон ':path'", function() {
const re = new PathToRegex(":path");
console.log("05. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
// it("соотносим шаблон '/:path*' со строками '' 'user' 'user/12345' ", function() {
// assert.equal( ""+re1.match("") , { path: [] });
// assert.equal( ""+re1.match("user/"), { path: [] });
// assert.equal( ""+re1.match("user/12345"), { path: [] });
// });
it("шаблон совпадает со строкой 'user'. результат: `{path:'user'}`", function() {
expect( re.match("user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:'user'}`", function() {
expect( re.match("/user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:'user'}`", function() {
expect( re.match("user/") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:'user'}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:'user'});
});
it("шаблон не совпадает со строкой 'user/12345'. результат: `undefined`", function() {
assert.equal( re.match("user/12345"), undefined);
});
it("шаблон не совпадает со строкой '/user/12345'. результат: `undefined`", function() {
assert.equal( re.match("/user/12345"), undefined);
});
it("шаблон не совпадает со строкой 'user/12345/'. результат: `undefined`", function() {
assert.equal( re.match("user/12345/"), undefined);
});
it("шаблон не совпадает со строкой '/user/12345/'. результат: `undefined`", function() {
assert.equal( re.match("/user/12345/"), undefined);
});
});
describe("06. Тестируем шаблон ':path*'", function() {
const re = new PathToRegex(":path*");
console.log("06. REGEXP:",re.regexp);
it("шаблон совпадает со строкой ''. результат: `{path:[]}", function() {
expect( re.match("") ).to.deep.equal({path:[]});
});
it("шаблон совпадает со строкой '/'. результат: `{path:[]}", function() {
expect( re.match("/") ).to.deep.equal({path:[]});
});
it("шаблон совпадает со строкой 'user'. результат: `{path:['user']}`", function() {
expect( re.match("user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:['user']}`", function() {
expect( re.match("/user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:['user']}`", function() {
expect( re.match("user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:['user']}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:['user','12345']});
});
});
describe("07. Тестируем шаблон ':path+'", function() {
const re = new PathToRegex(":path+");
console.log("07. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'user'. результат: `{path:['user']}`", function() {
expect( re.match("user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:['user']}`", function() {
expect( re.match("/user") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:['user']}`", function() {
expect( re.match("user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:['user']}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:['user']});
});
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:['user','12345']});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:['user','12345']}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:['user','12345']});
});
});
describe("08. Тестируем шаблон ':path(.*)'", function() {
const re = new PathToRegex(":path(.*)");
console.log("08. REGEXP:",re.regexp);
it("шаблон совпадает со строкой '/'. результат: `{path: undefined}`", function() {
expect( re.match("/") ).to.deep.equal({path:undefined});
});
it("шаблон совпадает со строкой ''. результат: `{path:undefined}`", function() {
expect( re.match("") ).to.deep.equal({path:undefined});
});
it("шаблон совпадает со строкой 'user'. результат: `{path:'user'}`", function() {
expect( re.match("user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user'. результат: `{path:'user'}`", function() {
expect( re.match("/user") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой 'user/'. результат: `{path:'user'}`", function() {
expect( re.match("user/") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой '/user/'. результат: `{path:'user'}`", function() {
expect( re.match("/user/") ).to.deep.equal({path:'user'});
});
it("шаблон совпадает со строкой 'user/12345'. результат: `{path:'user/12345'}`", function() {
expect( re.match("user/12345") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой '/user/12345'. результат: `{path:'user/12345'}`", function() {
expect( re.match("/user/12345") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой 'user/12345/'. результат: `{path:'user/12345'}`", function() {
expect( re.match("user/12345/") ).to.deep.equal({path:'user/12345'});
});
it("шаблон совпадает со строкой '/user/12345/'. результат: `{path:'user/12345'}`", function() {
expect( re.match("/user/12345/") ).to.deep.equal({path:'user/12345'});
});
});
describe("09. Тестируем шаблон '/foo/:bar'", function() {
const re = new PathToRegex("/foo/:bar");
console.log("09. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон не совпадает со строкой 'foo'. результат: `undefined`", function() {
assert.equal( re.match("foo"), undefined);
});
it("шаблон не совпадает со строкой '/foo'. результат: `undefined`", function() {
assert.equal( re.match("/foo"), undefined);
});
it("шаблон не совпадает со строкой 'foo/'. результат: `undefined`", function() {
assert.equal( re.match("foo/"), undefined);
});
it("шаблон не совпадает со строкой '/foo/'. результат: `undefined`", function() {
assert.equal( re.match("/foo/"), undefined);
});
it("шаблон совпадает со строкой 'foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой 'foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон не совпадает со строкой 'foo/bar/baz'. результат: `undefined`", function() {
assert.equal( re.match("foo/bar/baz"), undefined);
});
it("шаблон не совпадает со строкой '/foo/bar/baz'. результат: `undefined`", function() {
assert.equal( re.match("/foo/bar/baz"), undefined);
});
it("шаблон не совпадает со строкой 'foo/bar/baz/'. результат: `undefined`", function() {
assert.equal( re.match("foo/bar/baz/"), undefined);
});
it("шаблон не совпадает со строкой '/foo/bar/baz/'. результат: `undefined`", function() {
assert.equal( re.match("/foo/bar/baz/"), undefined);
});
});
describe("10. Тестируем шаблон '/foo/:bar?'", function() {
const re = new PathToRegex("/foo/:bar?");
console.log("10. REGEXP:",re.regexp);
it("шаблон совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'foo'. результат: `{ bar: undefined }`", function() {
expect( re.match("foo") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой '/foo'. результат: `{ bar: undefined }`", function() {
expect( re.match("/foo") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой 'foo/'. результат: `{ bar: undefined }`", function() {
expect( re.match("foo/") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой '/foo/'. результат: `{ bar: undefined }`", function() {
expect( re.match("/foo/") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой 'foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой 'foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон не совпадает со строкой 'foo/bar/baz'. результат: `undefined`", function() {
assert.equal( re.match("foo/bar/baz"), undefined);
});
it("шаблон не совпадает со строкой '/foo/bar/baz'. результат: `undefined`", function() {
assert.equal( re.match("/foo/bar/baz"), undefined);
});
it("шаблон не совпадает со строкой 'foo/bar/baz/'. результат: `undefined`", function() {
assert.equal( re.match("foo/bar/baz/"), undefined);
});
it("шаблон не совпадает со строкой '/foo/bar/baz/'. результат: `undefined`", function() {
assert.equal( re.match("/foo/bar/baz/"), undefined);
});
});
describe("11. Тестируем шаблон '/foo/:bar(.*)'", function() {
const re = new PathToRegex("/foo/:bar(.*)");
console.log("11. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'foo'. результат: `{ bar: undefined }`", function() {
expect( re.match("foo") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой '/foo'. результат: `{ bar: undefined }`", function() {
expect( re.match("/foo") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой 'foo/'. результат: `{ bar: undefined }`", function() {
expect( re.match("foo/") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой '/foo/'. результат: `{ bar: undefined }`", function() {
expect( re.match("/foo/") ).to.deep.equal({bar: undefined});
});
it("шаблон совпадает со строкой 'foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой 'foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой '/foo/bar/'. результат: `{bar:'bar'}`", function() {
expect( re.match("/foo/bar/") ).to.deep.equal({bar:'bar'});
});
it("шаблон совпадает со строкой 'foo/bar/baz'. результат: `{bar:['bar','baz']}`", function() {
expect( re.match("foo/bar/baz") ).to.deep.equal({ bar: 'bar/baz' });
});
it("шаблон совпадает со строкой '/foo/bar/baz'. результат: `{bar:['bar','baz']}`", function() {
expect( re.match("/foo/bar/baz") ).to.deep.equal({ bar: 'bar/baz' });
});
it("шаблон совпадает со строкой 'foo/bar/baz/'. результат: `{bar:['bar','baz']}`", function() {
expect( re.match("foo/bar/baz/") ).to.deep.equal({ bar: 'bar/baz' });
});
it("шаблон совпадает со строкой '/foo/bar/baz/'. результат: `{bar:['bar','baz']}`", function() {
expect( re.match("/foo/bar/baz/") ).to.deep.equal({ bar: 'bar/baz' });
});
});
describe("12. Тестируем шаблон '/foo/:bar(.*)*'", function() {
const re = new PathToRegex("/foo/:bar(.*)*");
console.log("12. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'foo'. результат: `{ bar: [] }`", function() {
expect( re.match("foo") ).to.deep.equal({bar: []});
});
it("шаблон совпадает со строкой '/foo'. результат: `{ bar: [] }`", function() {
expect( re.match("/foo") ).to.deep.equal({bar: []});
});
it("шаблон совпадает со строкой 'foo/'. результат: `{ bar: [] }`", function() {
expect( re.match("foo/") ).to.deep.equal({bar: []});
});
it("шаблон совпадает со строкой '/foo/'. результат: `{ bar: [] }`", function() {
expect( re.match("/foo/") ).to.deep.equal({bar: []});
});
it("шаблон совпадает со строкой 'foo/bar'. результат: `{bar:['bar']}`", function() {
expect( re.match("foo/bar") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой '/foo/bar'. результат: `{bar:['bar']}`", function() {
expect( re.match("/foo/bar") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой 'foo/bar/'. результат: `{bar:['bar']}`", function() {
expect( re.match("foo/bar/") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой '/foo/bar/'. результат: `{bar:['bar']}`", function() {
expect( re.match("/foo/bar/") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой 'foo/bar/baz'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("foo/bar/baz") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой '/foo/bar/baz'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("/foo/bar/baz") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой 'foo/bar/baz/'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("foo/bar/baz/") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой '/foo/bar/baz/'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("/foo/bar/baz/") ).to.deep.equal({ bar: ['bar/baz'] });
});
});
describe("13. Тестируем шаблон '/foo/:bar(.+)+'", function() {
const re = new PathToRegex("/foo/:bar(.+)+");
console.log("13. REGEXP:",re.regexp);
it("шаблон не совпадает со строкой ''. результат: `undefined`", function() {
assert.equal( re.match(""), undefined);
});
it("шаблон не совпадает со строкой '/'. результат: `undefined`", function() {
assert.equal( re.match("/"), undefined);
});
it("шаблон совпадает со строкой 'foo'. результат: `undefined`", function() {
assert.equal( re.match("foo"), undefined);
});
it("шаблон совпадает со строкой '/foo'. результат: `undefined`", function() {
assert.equal( re.match("/foo"), undefined);
});
it("шаблон совпадает со строкой 'foo/'. результат: `undefined`", function() {
assert.equal( re.match("foo/"), undefined);
});
it("шаблон совпадает со строкой '/foo/'. результат: `undefined`", function() {
assert.equal( re.match("/foo/"), undefined);
});
it("шаблон совпадает со строкой 'foo/bar'. результат: `{bar:['bar']}`", function() {
expect( re.match("foo/bar") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой '/foo/bar'. результат: `{bar:['bar']}`", function() {
expect( re.match("/foo/bar") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой 'foo/bar/'. результат: `{bar:['bar']}`", function() {
expect( re.match("foo/bar/") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой '/foo/bar/'. результат: `{bar:['bar']}`", function() {
expect( re.match("/foo/bar/") ).to.deep.equal({bar:['bar']});
});
it("шаблон совпадает со строкой 'foo/bar/baz'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("foo/bar/baz") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой '/foo/bar/baz'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("/foo/bar/baz") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой 'foo/bar/baz/'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("foo/bar/baz/") ).to.deep.equal({ bar: ['bar/baz'] });
});
it("шаблон совпадает со строкой '/foo/bar/baz/'. результат: `{bar:['bar/baz']}`", function() {
expect( re.match("/foo/bar/baz/") ).to.deep.equal({ bar: ['bar/baz'] });
});
});
describe("14. Тестируем шаблон '/user/:id/bar/:key(\\d+):post?fak/:key(\\d+)*:foo+/test/pictures-:multi(\\w+?\\.png)*/:key?'", function() {
const re = new PathToRegex("/user/:id/bar/:key(\\d+):post?fak/:key(\\d+)*:foo+/test/pictures-:multi(\\w+?\\.png)*/:key?");
console.log("14. REGEXP:",re.regexp);
it("шаблон совпадает со строкой '/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png, p02.png, p03.png/333'. \n\tрезультат: `{ id: '123', key: [ '111', '222', '333' ], post: 'qwerty', foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] }`", function() {
expect( re.match("/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png, p02.png, p03.png/333") ).to.deep.equal({ id: '123', key: [ '111', '222', '333' ], post: 'qwerty', foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] });
});
it("шаблон совпадает со строкой '/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png, p02.png, p03.png'. \n\tрезультат: `{ id: '123', key: [ '111', '222' ], post: 'qwerty', foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] }`", function() {
expect( re.match("/user/123/bar/111qwertyfak/222foo/test/pictures-p01.png, p02.png, p03.png") ).to.deep.equal({ id: '123', key: [ '111', '222' ], post: 'qwerty', foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] });
});
it("шаблон совпадает со строкой '/user/123/bar/111fak/foo/test/pictures-p01.png, p02.png, p03.png'. \n\tрезультат: `{ id: '123', key: [ '111' ], post: undefined, foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] }`", function() {
expect( re.match("/user/123/bar/111fak/foo/test/pictures-p01.png, p02.png, p03.png") ).to.deep.equal({ id: '123', key: [ '111' ], post: undefined, foo: [ 'foo' ], multi: [ 'p01.png', 'p02.png', 'p03.png' ] });
});
it("шаблон совпадает со строкой '/user/123/bar/111fak/foo/test/pictures-p01.png'. \n\tрезультат: `{ id: '123', key: [ '111' ], post: undefined, foo: [ 'foo' ], multi: [ 'p01.png' ] }`", function() {
expect( re.match("/user/123/bar/111fak/foo/test/pictures-p01.png") ).to.deep.equal({ id: '123', key: [ '111' ], post: undefined, foo: [ 'foo' ], multi: [ 'p01.png' ] });
});
});
// const re2 = new PathToRegex("/user/:id");

@@ -57,18 +600,16 @@ // // console.log("REGEX:", "\t\t"+re2.regexp, "\t\t", re2.regexp, "\t\t", re2.regstr, "\t\t", re2.path);

// assert.equal( re2 instanceof PathToRegex, true);
// assert.equal( ""+re2.regexp, ""+/^\/user\/(?<id>[^\/]+?)$/ );
// assert.equal( ""+re2.regexp, ""+/^\/user\/([^\/]+)[\/]?$/ );
// });
// it("соотносим RegExp /^\\/user\\/(?<id>[^\\/]+?)$/ (путь \"/user/:id\" ) со строками \"/\" \"/user\" \"/user/12345\" \"/user/12345/foo\" ", function() {
// assert.equal( !!re2.match("/"), false);
// assert.equal( !!re2.match("/user"), false);
// assert.equal( !!re2.match("/user/12345"), true);
// assert.equal( !!re2.match("/user/12345/foo"), false);
// it("соотносим шаблон \"/user/:id\" со строками \"/\" \"/user\" \"/user/12345\" \"/user/12345/foo\" ", function() {
// assert.equal( re2.match("/"), undefined);
// assert.equal( re2.match("/user"), undefined);
// expect( re2.match("/user/12345") ).to.deep.equal({id:'12345'});
// assert.equal( re2.match("/user/12345/foo"), undefined);
// });
// it("соотносим RegExp /^\\/user\\/(?<id>[^\\/]+?)$/ (путь \"/user/:id\" ) со строками \"/user/12345\" \"/user/abcd\" и проверяем наличие ключа id и соответствие его значения", function() {
// const params1 = re2.match("/user/12345");
// const params2 = re2.match("/user/abcd");
// assert.equal( params1.id, "12345");
// assert.equal( params2.id, "abcd");
// it("соотносим шаблон \"/user/:id\" со строками \"/user/12345\" \"/user/abcd\" и проверяем наличие ключа id и соответствие его значения", function() {
// expect( re2.match("/user/12345") ).to.deep.equal({id:'12345'});
// expect( re2.match("/user/abcd") ).to.deep.equal({id:'abcd'});
// });

@@ -80,30 +621,23 @@

// assert.equal( re3 instanceof PathToRegex, true);
// assert.equal( ""+re3.regexp, ""+/^\/foo\/(?<fooid>[^\/]+?)\/bar\/(?<barid>[^\/]+?)$/ );
// assert.equal( ""+re3.regexp, ""+/^\/foo\/([^\/]+)\/bar\/([^\/]+)[\/]?$/ );
// });
// it("соотносим RegExp /^\\/foo\\/(?<fooid>[^\\/]+?)\\/bar\\/(?<barid>[^\\/]+?)$/ (путь \"/foo/:fooid/bar/:barid\" ) со строками \"/\" \"/foo\" \"/foo/123\" \"/foo/123/bar\" \"/foo/123/bar/456\" ", function() {
// assert.equal( !!re3.match("/"), false);
// assert.equal( !!re3.match("/foo"), false);
// assert.equal( !!re3.match("/foo/123"), false);
// assert.equal( !!re3.match("/foo/123/bar"), false);
// const params = re3.match("/foo/123/bar/456");
// assert.equal( !!params, true);
// assert.equal( re3.match("/"), undefined);
// assert.equal( re3.match("/foo"), undefined);
// assert.equal( re3.match("/foo/123"), undefined);
// assert.equal( re3.match("/foo/123/bar"), undefined);
// expect( re3.match("/foo/123/bar/456") ).to.deep.equal({fooid:'123',barid:'456'});
// });
// it("соотносим RegExp /^\\/foo\\/(?<fooid>[^\\/]+?)\\/bar\\/(?<barid>[^\\/]+?)$/ (путь \"/foo/:fooid/bar/:barid\" ) со строками \"/foo/111/bar/222\" \"/foo/id1/bar/id22\" и проверяем наличие ключей fooid и barid и соответствие их значений", function() {
// const params1 = re3.match("/foo/111/bar/222");
// const params2 = re3.match("/foo/id1/bar/id22");
// assert.equal( params1.fooid, "111");
// assert.equal( params1.barid, "222");
// assert.equal( params2.fooid, "id1");
// assert.equal( params2.barid, "id22");
// expect( re3.match("/foo/111/bar/222") ).to.deep.equal({fooid:'111',barid:'222'});
// expect( re3.match("/foo/id1/bar/id22") ).to.deep.equal({fooid:'id1',barid:'id22'});
// });
// const re4 = new PathToRegex("/user/:id(\\d+)");
// console.log("REGEX:", "\t\t"+re4.regexp, "\t\t", re4.regexp, "\t\t", re4.regstr, "\t\t", re4.path);
// // console.log("REGEX:", "\t\t"+re3.regexp, "\t\t", re3.regexp, "\t\t", re3.regstr, "\t\t", re3.path, "\t\t", re3.keys);
// // console.log("REGEX:", "\t\t", params);
// // console.log("REGEX:", "\t\t"+re4.regexp, "\t\t", re4.regexp, "\t\t", re4.regstr, "\t\t", re4.path);
// it("создаем RegExp из \"/user/:id(\\\\d+)\"", function() {
// assert.equal( re4 instanceof PathToRegex, true);
// assert.equal( ""+re4.regexp, ""+/^\/user\/(?<id>\d+)$/ );
// assert.equal( ""+re4.regexp, ""+/^\/user\/(\d+)[\/]?$/ );
// });

@@ -113,9 +647,7 @@

// it("соотносим RegExp /^\\/user\\/(?<id>\\d+)$/ (путь \"/user/:id(\\\\d+)\" ) со строками \"/\" \"/user\" \"/user/123\" \"/user/123/foo\" \"/user/aaa\" ", function() {
// assert.equal( !!re4.match("/"), false);
// assert.equal( !!re4.match("/user"), false);
// const params = re4.match("/user/123");
// assert.equal( !!params, true);
// assert.equal( params.id, "123");
// assert.equal( !!re4.match("/user/123/foo"), false);
// assert.equal( !!re4.match("/user/aaa"), false);
// assert.equal( re4.match("/"), undefined);
// assert.equal( re4.match("/user"), undefined);
// expect( re4.match("/user/123") ).to.deep.equal({id:'123'});
// assert.equal( re4.match("/user/123/foo"), undefined);
// assert.equal( re4.match("/user/aaa"), undefined);
// });

@@ -122,0 +654,0 @@

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc