294 lines
7.8 KiB
TypeScript
294 lines
7.8 KiB
TypeScript
/**
|
|
* Copyright 2013-2019 GenieACS Inc.
|
|
*
|
|
* This file is part of GenieACS.
|
|
*
|
|
* GenieACS is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as
|
|
* published by the Free Software Foundation, either version 3 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* GenieACS is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with GenieACS. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
type Segments = (string | Alias)[];
|
|
type Alias = [Path, string][];
|
|
|
|
let cache1 = new Map<string, Path>();
|
|
let cache2 = new Map<string, Path>();
|
|
|
|
const CHAR_SPACE = 32;
|
|
const CHAR_BACKSLASH = 92;
|
|
const CHAR_COLON = 58;
|
|
const CHAR_QUOTE = 34;
|
|
const CHAR_OPEN_BRACKET = 91;
|
|
const CHAR_CLOSE_BRACKET = 93;
|
|
const CHAR_ASTERISK = 42;
|
|
const CHAR_COMMA = 44;
|
|
const CHAR_DOT = 46;
|
|
|
|
function charCodeAt(str: string, index: number): number {
|
|
if (index >= str.length) return 0;
|
|
return str.charCodeAt(index);
|
|
}
|
|
|
|
function legalChar(c: number): boolean {
|
|
return (
|
|
(c >= 97 && c <= 122) ||
|
|
(c >= 65 && c <= 90) ||
|
|
(c >= 48 && c <= 57) ||
|
|
c === 95 ||
|
|
c === 45
|
|
);
|
|
}
|
|
|
|
export default class Path {
|
|
public declare readonly segments: Segments;
|
|
public declare readonly wildcard: number;
|
|
public declare readonly alias: number;
|
|
protected declare _string: string;
|
|
protected declare _stringIndex: number[];
|
|
|
|
protected static parseAliasValue(
|
|
pattern: string,
|
|
index: number,
|
|
): { index: number; value: string } {
|
|
let i = index;
|
|
while (charCodeAt(pattern, i) === CHAR_SPACE) ++i;
|
|
if (charCodeAt(pattern, i) === CHAR_QUOTE) {
|
|
for (let j = i + 1; j < pattern.length; ++j) {
|
|
if (
|
|
pattern.charCodeAt(j) === CHAR_QUOTE &&
|
|
pattern.charCodeAt(j - 1) !== CHAR_BACKSLASH
|
|
) {
|
|
try {
|
|
++j;
|
|
const v = JSON.parse(pattern.slice(i, j));
|
|
return { index: j, value: v };
|
|
} catch {
|
|
return { index, value: null };
|
|
}
|
|
}
|
|
}
|
|
return { index, value: null };
|
|
}
|
|
|
|
for (; i < pattern.length; ++i) {
|
|
const c = pattern.charCodeAt(i);
|
|
if (c === CHAR_CLOSE_BRACKET || c === CHAR_COMMA) break;
|
|
}
|
|
|
|
return { index: i, value: pattern.slice(index, i).trim() };
|
|
}
|
|
|
|
protected static parseAliasPath(
|
|
pattern: string,
|
|
index: number,
|
|
): { index: number; path: Path } {
|
|
let i = index;
|
|
while (charCodeAt(pattern, i) === CHAR_SPACE) ++i;
|
|
const { index: idx, segments } = Path.parsePath(pattern, i);
|
|
if (idx === i) return { index, path: null };
|
|
i = idx;
|
|
while (charCodeAt(pattern, i) === CHAR_SPACE) ++i;
|
|
if (charCodeAt(pattern, i) !== CHAR_COLON) return { index, path: null };
|
|
return { index: i + 1, path: new Path(segments) };
|
|
}
|
|
|
|
protected static parseAlias(
|
|
pattern: string,
|
|
index: number,
|
|
): { index: number; alias: Alias } {
|
|
const alias: Alias = [];
|
|
let i = index;
|
|
for (;;) {
|
|
let path: Path;
|
|
let value: string;
|
|
({ index: i, path } = Path.parseAliasPath(pattern, i));
|
|
if (!path) break;
|
|
({ index: i, value } = Path.parseAliasValue(pattern, i));
|
|
if (value == null) break;
|
|
alias.push([path, value]);
|
|
index = i;
|
|
|
|
if (charCodeAt(pattern, index) !== CHAR_COMMA) break;
|
|
++i;
|
|
}
|
|
|
|
// Ensure identical expressions have idential string representation
|
|
alias.sort((a, b) => {
|
|
if (a[0].toString() > b[0].toString()) return 1;
|
|
else if (a[0].toString() < b[0].toString()) return -1;
|
|
else if (a[1] > b[1]) return 1;
|
|
else if (a[1] < b[1]) return -1;
|
|
else return 0;
|
|
});
|
|
|
|
Object.freeze(alias);
|
|
return { index, alias };
|
|
}
|
|
|
|
protected static parsePath(
|
|
pattern: string,
|
|
index: number,
|
|
): { index: number; segments: Segments } {
|
|
const segments = [];
|
|
|
|
let segStart = index;
|
|
let wildcard = -1;
|
|
for (let i = index; i <= pattern.length; ++i) {
|
|
const c = charCodeAt(pattern, i);
|
|
if (c === CHAR_OPEN_BRACKET && i === segStart) {
|
|
const { index: idx, alias } = Path.parseAlias(pattern, i + 1);
|
|
if (charCodeAt(pattern, idx) !== CHAR_CLOSE_BRACKET) break;
|
|
segments.push(alias);
|
|
index = i = idx + 1;
|
|
segStart = i + 1;
|
|
} else if (c === CHAR_ASTERISK && i === segStart) {
|
|
wildcard = i + 1;
|
|
} else if (!legalChar(c) || i === wildcard) {
|
|
if (i === segStart) break;
|
|
const s = pattern.slice(segStart, i);
|
|
segments.push(s);
|
|
index = i;
|
|
if (c !== CHAR_DOT) break;
|
|
segStart = i + 1;
|
|
}
|
|
}
|
|
|
|
Object.freeze(segments);
|
|
return { index, segments };
|
|
}
|
|
|
|
protected constructor(segments: Segments) {
|
|
let alias = 0;
|
|
let wildcard = 0;
|
|
const arr = segments.map((s, i) => {
|
|
if (Array.isArray(s)) {
|
|
alias |= 1 << i;
|
|
const parts = s.map(
|
|
(al) => `${al[0].toString()}:${JSON.stringify(al[1])}`,
|
|
);
|
|
return `[${parts.join(",")}]`;
|
|
} else if (s === "*") {
|
|
wildcard |= 1 << i;
|
|
}
|
|
return s;
|
|
});
|
|
|
|
let offset = 0;
|
|
const stringIndex = arr.map((s, i) => (offset += s.length) + i);
|
|
|
|
this.segments = segments;
|
|
this.wildcard = wildcard;
|
|
this.alias = alias;
|
|
this._string = arr.join(".");
|
|
this._stringIndex = stringIndex;
|
|
}
|
|
|
|
public static parse(str: string): Path {
|
|
let path = cache1.get(str);
|
|
if (!path) {
|
|
path = cache2.get(str);
|
|
if (!path) {
|
|
const { index, segments } = Path.parsePath(str, 0);
|
|
if (index < str.length) throw new Error("Invalid parameter path");
|
|
path = new Path(segments);
|
|
if (path.toString() !== str) cache1.set(path.toString(), path);
|
|
}
|
|
cache1.set(str, path);
|
|
}
|
|
return path;
|
|
}
|
|
|
|
public get length(): number {
|
|
return this.segments.length;
|
|
}
|
|
|
|
public toString(): string {
|
|
return this._string;
|
|
}
|
|
|
|
public slice(start = 0, end: number = this.segments.length): Path {
|
|
if (start < 0) start = Math.max(0, this.segments.length + start);
|
|
if (end < 0) end = Math.max(0, this.segments.length + end);
|
|
|
|
let str;
|
|
if (start >= end) {
|
|
str = "";
|
|
} else {
|
|
const i1 = start > 0 ? this._stringIndex[start - 1] + 1 : 0;
|
|
const i2 =
|
|
end <= this.segments.length
|
|
? this._stringIndex[end - 1]
|
|
: this._string.length;
|
|
str = this._string.slice(i1, i2);
|
|
}
|
|
|
|
let path = cache1.get(str);
|
|
if (!path) {
|
|
path = cache2.get(str);
|
|
if (!path) {
|
|
const segments = this.segments.slice(start, end);
|
|
Object.freeze(segments);
|
|
path = new Path(segments);
|
|
}
|
|
cache1.set(str, path);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
public concat(path2: Path): Path {
|
|
if (!path2._string) return this;
|
|
else if (!this._string) return path2;
|
|
|
|
const str = `${this._string}.${path2._string}`;
|
|
|
|
let path = cache1.get(str);
|
|
if (!path) {
|
|
path = cache2.get(str);
|
|
if (!path) {
|
|
const segments = this.segments.concat(path2.segments);
|
|
Object.freeze(segments);
|
|
path = new Path(segments);
|
|
}
|
|
cache1.set(str, path);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
public stripAlias(): Path {
|
|
if (!this.alias) return this;
|
|
const segments = this.segments.map((s) => (Array.isArray(s) ? "*" : s));
|
|
const str = segments.join(".");
|
|
|
|
let path = cache1.get(str);
|
|
if (!path) {
|
|
path = cache2.get(str);
|
|
if (!path) {
|
|
Object.freeze(segments);
|
|
path = new Path(segments);
|
|
}
|
|
cache1.set(str, path);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
}
|
|
|
|
const interval = setInterval(() => {
|
|
cache2 = cache1;
|
|
cache1 = new Map();
|
|
}, 120000);
|
|
|
|
// Don't hold Node.js process
|
|
if (interval.unref) interval.unref();
|