Haketilo

/**

 * This file is part of Haketilo.

 *

 * Function: Driving a list of editable entries. Used to make UI for management

 *           of repo URLs and script allowing/blocking rules.

 *

 * Copyright (C) 2022 Wojtek Kosior

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * As additional permission under GNU GPL version 3 section 7, you

 * may distribute forms of that code without the copy of the GNU

 * GPL normally required by section 4, provided you include this

 * license notice and, in case of non-source distribution, a URL

 * through which recipients can access the Corresponding Source.

 * If you modify file(s) with this exception, you may extend this

 * exception to your version of the file(s), but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * As a special exception to the GPL, any HTML file which merely

 * makes function calls to this code, and for that purpose

 * includes it by reference shall be deemed a separate work for

 * copyright law purposes. If you modify this code, you may extend

 * this exception to your version of the code, but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 *

 * I, Wojtek Kosior, thereby promise not to sue for violation of this file's

 * license. Although I request that you do not make use of this code in a

 * proprietary program, I am not going to enforce this in court.

 */

#IMPORT html/dialog.js

#IMPORT common/indexeddb.js AS haketilodb

#FROM html/DOM_helpers.js IMPORT clone_template

#FROM common/patterns.js  IMPORT validate_normalize_url_pattern

const coll = new Intl.Collator();

function Entry(text, list, entry_idx) {

    Object.assign(this, clone_template("text_entry"));

    const editable = () => list.active_entry === this;

    this.exists = () => text !== null;

    /*

     * Called in the constructor when creating a completely new entry and as a

     * result of clicking on an existing entry in the list.

     */

    this.make_editable = () => {

	if (editable())

	    return;

	if (list.active_entry !== null)

	    list.active_entry.make_noneditable();

	list.active_entry = this;

	this.editable_view.classList.remove("hide");

	this.noneditable_view.classList.add("hide");

	this.input.value = text || "";

    }

    /*

     * Called when 'Cancel' is clicked, when another entry becomes editable and

     * when an entry ends being modified.

     */

    this.make_noneditable = () => {

	if (!editable())

	    return;

	list.active_entry = null;

	if (!this.exists()) {

	    this.main_div.remove();

	    return;

	}

	this.editable_view.classList.add("hide");

	this.noneditable_view.classList.remove("hide");

    }

    /*

     * The *_cb() calls are allowed to throw if an error occurs. It is expected

     * *_cb() will show some dialog that will block other clicks until they

     * returns/throw.

     */

    const add_clicked = async () => {

	if (!editable() || this.exists())

	    return;

	await list.create_cb(this.input.value);

	this.make_noneditable();

    }

    /*

     * Changing entry's text is not handled here, instead we wait for subsequent

     * item removal and creation requests from the outside.

     */

    const save_clicked = async () => {

	if (!editable() || !this.exists())

	    return;

	await list.replace_cb(text, this.input.value);

	this.make_noneditable();

    }

    const enter_hit = () => add_clicked().then(save_clicked);

    /*

     * Removing entry from the list is not handled here, instead we wait for

     * subsequent item removal requests from the outside.

     */

    const remove_clicked = async () => {

	if (editable() || !this.exists())

	    return;

	await list.remove_cb(text);

    }

    /*

     * Called from the outside after the entry got removed from the database. It

     * is assumed entry_exists() is true when this is called.

     */

    this.remove = () => {

	if (editable()) {

	    text = null;

	    this.save_but.classList.add("hide");

	    this.add_but.classList.remove("hide");

	} else {

	    this.main_div.remove();

	}

    }

    if (this.exists()) {

	this.text.innerText = text;

    } else {

	this.save_but.classList.add("hide");

	this.add_but.classList.remove("hide");

	this.make_editable();

    }

    for (const [node, cb] of [

	[this.save_but,         save_clicked],

	[this.add_but,          add_clicked],

	[this.remove_but,       remove_clicked],

	[this.cancel_but,       this.make_noneditable],

	[this.noneditable_view, this.make_editable],

    ])

	node.addEventListener("click", list.dialog_ctx.when_hidden(cb));

    const enter_cb = e => (e.key === 'Enter') && enter_hit();

    this.input.addEventListener("keypress",

				list.dialog_ctx.when_hidden(enter_cb));

    if (entry_idx > 0) {

	const prev_text = list.shown_texts[entry_idx - 1];

	list.entries_by_text.get(prev_text).main_div.after(this.main_div);

    } else {

	if (!editable() && list.active_entry && !list.active_entry.exists())

	    list.active_entry.main_div.after(this.main_div);

	else

	    list.list_div.prepend(this.main_div);

    }

}

function TextEntryList(dialog_ctx, destroy_cb,

		       remove_cb, create_cb, replace_cb) {

    Object.assign(this, {dialog_ctx, remove_cb, create_cb, replace_cb});

    Object.assign(this, clone_template("text_entry_list"));

    this.ul = document.createElement("ul");

    this.shown_texts = [];

    this.entries_by_text = new Map();

    this.active_entry = null;

    const find_entry_idx = text => {

	let left = 0, right = this.shown_texts.length;

	while (left < right) {

	    const mid = (left + right) >> 1;

	    if (coll.compare(text, this.shown_texts[mid]) > 0)

		left = mid + 1;

	    else /* <= 0 */

		right = mid;

	}

	return left;

    }

    this.remove = text => {

	if (!this.entries_by_text.has(text))

	    return;

	this.shown_texts.splice(find_entry_idx(text), 1);

	this.entries_by_text.get(text).remove();

	this.entries_by_text.delete(text)

    }

    this.add = text => {

	if (this.entries_by_text.has(text))

	    return;

	const idx = find_entry_idx(text);

	this.entries_by_text.set(text, new Entry(text, this, idx));

	this.shown_texts.splice(idx, 0, text);

    }

    this.destroy = () => {

	this.main_div.remove();

	destroy_cb();

    }

    const add_new = () => new Entry(null, this, 0);

    this.new_but.addEventListener("click", dialog_ctx.when_hidden(add_new));

}

async function repo_list(dialog_ctx) {

    let list;

    function validate_normalize(repo_url) {

	let error_msg;

	/* In the future we might also try making a test connection. */

	if (!/^https:\/\/[^/.]+\.[^/.]+/.test(repo_url))

	    error_msg = "Provided URL is not valid.";

	if (!/^https:\/\//.test(repo_url))

	    error_msg = "Repository URLs shoud use https:// schema.";

	/* Make exception for localhost while disallowing http://. */

	if (/^http:\/\/(127\.0\.0\.1|localhost)([:/].*)?$/.test(repo_url))

	    error_msg = null;

	if (error_msg) {

	    dialog.error(dialog_ctx, error_msg);

	    throw error_msg;

	}

	return repo_url.replace(/\/*$/, "/");

    }

    async function remove_repo(repo_url) {

	dialog.loader(dialog_ctx, `Removing repository '${repo_url}'...`);

	try {

	    await haketilodb.del_repo(repo_url);

	    var removing_ok = true;

	} finally {

	    if (!removing_ok) {

		dialog.error(dialog_ctx,

			     `Failed to remove repository '${repo_url}' :(`);

	    }

	    dialog.close(dialog_ctx);

	}

    }

    async function create_repo(repo_url) {

	repo_url = validate_normalize(repo_url);

	dialog.loader(dialog_ctx, `Adding repository '${repo_url}'...`);

	try {

	    await haketilodb.set_repo(repo_url);

	    var adding_ok = true;

	} finally {

	    if (!adding_ok)

		dialog.error(dialog_ctx, `Failed to add repository '${repo_url}' :(`);

	    dialog.close(dialog_ctx);

	}

    }

    async function replace_repo(old_repo_url, new_repo_url) {

	if (old_repo_url === new_repo_url)

	    return;

	new_repo_url = validate_normalize(new_repo_url);

	dialog.loader(dialog_ctx, "Replacing repository...");

	try {

	    await haketilodb.set_repo(new_repo_url);

	    await haketilodb.del_repo(old_repo_url);

	    var replacing_ok = true;

	} finally {

	    if (!replacing_ok)

		dialog.error(dialog_ctx, "Failed to replace repository :(");

	    dialog.close(dialog_ctx);

	}

    }

    function onchange(change) {

	if (change.new_val)

	    list.add(change.key);

	else

	    list.remove(change.key);

    }

    dialog.loader(dialog_ctx, "Loading repositories...");

    const [tracking, items] = await haketilodb.track.repo(onchange);

    dialog.close(dialog_ctx);

    list = new TextEntryList(dialog_ctx, () => haketilodb.untrack(tracking),

			     remove_repo, create_repo, replace_repo);

    items.forEach(item => list.add(item.url));

    return list;

}

#EXPORT repo_list

async function blocking_allowing_lists(dialog_ctx) {

    function validate_normalize(url_pattern) {

	try {

	    return validate_normalize_url_pattern(url_pattern);

	} catch(e) {

	    dialog.error(dialog_ctx, e);

	    throw e;

	}

    }

    async function default_allowing_on(url_pattern, allow) {

	dialog.loader(dialog_ctx,

		      `Setting default scripts blocking policy on '${url_pattern}'...`);

	try {

	    await haketilodb.set_default_allowing(url_pattern);

	    var default_allowing_ok = true;

	} finally {

	    if (!default_allowing_ok) {

		dialog.error(dialog_ctx,

			     `Failed to remove rule for '${url_pattern}' :(`);

	    }

	    dialog.close(dialog_ctx);

	}

    }

    async function set_allowing_on(url_pattern, allow) {

	url_pattern = validate_normalize(url_pattern);

	const [action, action_cap] = allow ?

	      ["allowing", "Allowing"] : ["blocking", "Blocking"];

	dialog.loader(dialog_ctx, `${action_cap} scripts on '${url_pattern}'...`);

	try {

	    await haketilodb.set_allowed(url_pattern, allow);

	    var set_allowing_ok = true;

	} finally {

	    if (!set_allowing_ok)

		dialog.error(dialog_ctx,

			     `Failed to write ${action} rule for '${url_pattern}' :(`);

	    dialog.close(dialog_ctx);

	}

    }

    async function replace_allowing_on(old_pattern, new_pattern, allow) {

	new_pattern = validate_normalize(new_pattern);

	if (old_pattern === new_pattern)

	    return;

	const action = allow ? "allowing" : "blocking";

	dialog.loader(dialog_ctx, `Rewriting script ${action} rule...`);

	try {

	    await haketilodb.set_allowed(new_pattern, allow);

	    await haketilodb.set_default_allowing(old_pattern);

	    var replace_allowing_ok = true;

	} finally {

	    if (!replace_allowing_ok)

		dialog.error(dialog_ctx, `Failed to rewrite ${action} rule :(`);

	    dialog.close(dialog_ctx);

	}

    }

    let blocking_list, allowing_list;

    function onchange(change) {

	if (change.new_val) {

	    if (change.new_val.allow)

		var [to_add, to_remove] = [allowing_list, blocking_list];

	    else

		var [to_add, to_remove] = [blocking_list, allowing_list];

	    to_add.add(change.key);

	    to_remove.remove(change.key);

	} else {

	    blocking_list.remove(change.key);

	    allowing_list.remove(change.key);

	}

    }

    dialog.loader(dialog_ctx, "Loading script blocking settings...");

    const [tracking, items] = await haketilodb.track.blocking(onchange);

    dialog.close(dialog_ctx);

    let untrack_called = 0;

    function untrack() {

	if (++untrack_called === 2)

	    haketilodb.untrack(tracking);

    }

    const lists = [];

    for (const allow of [false, true]) {

	lists[allow + 0] =

	    new TextEntryList(dialog_ctx, untrack,

			      pattern => default_allowing_on(pattern),

			      pattern => set_allowing_on(pattern, allow),

			      (p1, p2) => replace_allowing_on(p1, p2, allow));

    }

    [blocking_list, allowing_list] = lists;

    for (const item of items) {

	if (item.allow)

	    allowing_list.add(item.pattern);

	else

	    blocking_list.add(item.pattern);

    }

    return lists;

}

#EXPORT blocking_allowing_lists