Haketilo

/**

 * Hydrilla/Lernette operations on page url patterns

 *

 * Copyright (C) 2021 Wojtek Kosior

 * Redistribution terms are gathered in the `copyright' file.

 */

const proto_re = "[a-zA-Z]*:\/\/";

const domain_re = "[^/?#]+";

const segments_re = "/[^?#]*";

const query_re = "\\?[^#]*";

const url_regex = new RegExp(`\

^\

(${proto_re})\

(${domain_re})\

(${segments_re})?\

(${query_re})?\

#?.*\$\

`);

function deconstruct_url(url)

{

    const regex_match = url_regex.exec(url);

    if (regex_match === null)

	return undefined;

    let [_, proto, domain, path, query] = regex_match;

    domain = domain.split(".");

    let path_trailing_dash =

	path && path[path.length - 1] === "/";

    path = (path || "").split("/").filter(s => s !== "");

    path.unshift("");

    return {proto, domain, path, query, path_trailing_dash};

}

/* Be sane: both arguments should be arrays of length >= 2 */

function domain_matches(url_domain, pattern_domain)

{

    const length_difference = url_domain.length - pattern_domain.length;

    for (let i = 1; i <= url_domain.length; i++) {

	const url_part = url_domain[url_domain.length - i];

	const pattern_part = pattern_domain[pattern_domain.length - i];

	if (pattern_domain.length === i) {

	    if (pattern_part === "*")

		return length_difference === 0;

	    if (pattern_part === "**")

		return length_difference > 0;

	    if (pattern_part === "***")

		return true;

	    return length_difference === 0 && pattern_part === url_part;

	}

	if (pattern_part !== url_part)

	    return false;

    }

    return pattern_domain.length === url_domain.length + 1 &&

	pattern_domain[0] === "***";

}

function path_matches(url_path, url_trailing_dash,

		      pattern_path, pattern_trailing_dash)

{

    const dashes_ok = !(pattern_trailing_dash && !url_trailing_dash);

    if (pattern_path.length === 0)

	return url_path.length === 0 && dashes_ok;

    const length_difference = url_path.length - pattern_path.length;

    for (let i = 0; i < url_path.length; i++) {

	if (pattern_path.length === i + 1) {

	    if (pattern_path[i] === "*")

		return length_difference === 0;

	    if (pattern_path[i] === "**") {

		return length_difference > 0 ||

		    (url_path[i] === "**" && dashes_ok);

	    }

	    if (pattern_path[i] === "***")

		return length_difference >= 0;

	    return length_difference === 0 &&

		pattern_path[i] === url_path[i] && dashes_ok;

	}

	if (pattern_path[i] !== url_path[i])

	    return false;

    }

    return false;

}

function url_matches(url, pattern)

{

    const url_deco = deconstruct_url(url);

    const pattern_deco = deconstruct_url(pattern);

    if (url_deco === undefined || pattern_deco === undefined) {

	console.log(`bad comparison: ${url} and ${pattern}`);

	return false

    }

    if (pattern_deco.proto !== url_deco.proto)

	return false;

    return domain_matches(url_deco.domain, pattern_deco.domain) &&

	path_matches(url_deco.path, url_deco.path_trailing_dash,

		     pattern_deco.path, pattern_deco.path_trailing_dash);

}

/*

 * Call callback for every possible pattern that matches url. Return when there

 * are no more patterns or callback returns false.

 */

function for_each_possible_pattern(url, callback)

{

    const deco = deconstruct_url(url);

    if (deco === undefined) {

	console.log("bad url format", url);

	return;

    }

    for (let d_slice = 0; d_slice < deco.domain.length; d_slice++) {

	const domain_part = deco.domain.slice(d_slice).join(".");

	const domain_wildcards = [];

	if (d_slice === 0)

	    domain_wildcards.push("");

	if (d_slice === 1)

	    domain_wildcards.push("*.");

	if (d_slice > 0)

	    domain_wildcards.push("**.");

	domain_wildcards.push("***.");

	for (const domain_wildcard of domain_wildcards) {

	    const domain_pattern = domain_wildcard + domain_part;

	    for (let s_slice = deco.path.length; s_slice > 0; s_slice--) {

		const path_part = deco.path.slice(0, s_slice).join("/");

		const path_wildcards = [];

		if (s_slice === deco.path.length) {

		    if (deco.path_trailing_dash)

			path_wildcards.push("/");

		    path_wildcards.push("");

		}

		if (s_slice === deco.path.length - 1 &&

		    deco.path[s_slice] !== "*")

		    path_wildcards.push("/*");

		if (s_slice < deco.path.length &&

		    (deco.path[s_slice] !== "**" ||

		     s_slice < deco.path.length - 1))

		    path_wildcards.push("/**");

		if (deco.path[s_slice] !== "***" || s_slice < deco.path.length)

		    path_wildcards.push("/***");

		for (const path_wildcard of path_wildcards) {

		    const path_pattern = path_part + path_wildcard;

		    const pattern = deco.proto + domain_pattern + path_pattern;

		    if (callback(pattern) === false)

			return;

		}

	    }

	}

    }

}

function possible_patterns(url)

{

    const patterns = [];

    for_each_possible_pattern(url, patterns.push);

    return patterns;

}

/*

 * EXPORTS_START

 * EXPORT url_matches

 * EXPORT for_each_possible_pattern

 * EXPORT possible_patterns

 * EXPORTS_END

 */