Haketilo

    deco.trailing_slash = deco.path[deco.path.length - 1] === "/";

	    if (deco.trailing_slash)

function empty_node() {

	const child = tree_node.children[current_segment] || empty_node();

/* Helper function for modify_tree(). */

function modify_path(tree_node, deco, item_modifier)

{

    tree_node = tree_node || empty_node();

    modify_sequence(tree_node, deco.path, item_modifier);

    return is_empty_node(tree_node) ? null : tree_node;

}

/* Helper function for modify_tree(). */

function modify_domain(tree_node, deco, item_modifier)

{

    const path_modifier = branch => modify_path(branch, deco, item_modifier);

    tree_node = tree_node || empty_node();

    /* We need an array of domain labels ordered most-significant-first. */

    modify_sequence(tree_node, [...deco.domain].reverse(), path_modifier);

    return is_empty_node(tree_node) ? null : tree_node;

}

/* Helper function for pattern_tree_register() and pattern_tree_deregister(). */

function modify_tree(patterns_by_proto, pattern, item_modifier)

    let tree_for_proto = patterns_by_proto[deco.proto];

    tree_for_proto = deco.domain === undefined ?

	modify_path(tree_for_proto, deco, item_modifier) :

	modify_domain(tree_for_proto, deco, item_modifier);

    patterns_by_proto[deco.proto] = tree_for_proto;

    if (tree_for_proto === null)

	delete patterns_by_proto[deco.proto];

}

/*

 * Make item queryable through the Pattern Tree that starts with the protocols

 * dictionary object passed in the first argument.

 */

function pattern_tree_register(patterns_by_proto, pattern, item_name, item)

{

    const key_prefix = pattern[pattern.length - 1] === '/' ? '/' : '_';

    item_name = key_prefix + item_name;

    const add_item = obj => Object.assign(obj || {}, {[item_name]: item});

    modify_tree(patterns_by_proto, pattern, add_item);

}

/* Helper function for pattern_tree_deregister(). */

function _remove_item(obj, item_name)

{

    obj = obj || {};

    delete obj[item_name];

    for (const key in obj)

	return obj;

    return null;

/*

 * Remove registered item from the Pattern Tree that starts with the protocols

 * dictionary object passed in the first argument. The remaining 2 arguments

 * should be pattern and name that have been earlier passed to

 * pattern_tree_register().

 */

function pattern_tree_deregister(patterns_by_proto, pattern, item_name)

{

    const key_prefix = pattern[pattern.length - 1] === '/' ? '/' : '_';

    item_name = key_prefix + item_name;

    const remove_item = obj => _remove_item(obj, item_name);

    modify_tree(patterns_by_proto, pattern, remove_item);

}

 * Yield registered items that match url. Each yielded value is an object with

 * key being matched item names and values being the items. One such object

 * shall contain all items matched with given pattern specificity. Objects are

 * yielded in order from greatest to lowest pattern specificity.

    const tree_for_proto = patterns_by_proto[deco.proto] || empty_node();

    let by_path = [tree_for_proto];

    /* We need an array of domain labels ordered most-significant-first. */

    if (deco.domain !== undefined)

	by_path = search_sequence(tree_for_proto, [...deco.domain].reverse());

    for (const path_tree of by_path) {

	    let result_obj_slash    = null;

	    let result_obj_no_slash = null;

	    for (const [key, item] of Object.entries(match_obj)) {

		if (deco.trailing_slash && key[0] === '/') {

		    result_obj_slash = result_obj_slash || {};

		    result_obj_slash[key.substring(1)] = item;

		} else if (key[0] !== '/') {

		    result_obj_no_slash = result_obj_no_slash || {};

		    result_obj_no_slash[key.substring(1)] = item;

		}

	    }

	    if (deco.trailing_slash && result_obj_slash)

		yield result_obj_slash;

	    if (result_obj_no_slash)

		yield result_obj_no_slash;

    make:       () => ({}),

    register:   pattern_tree_register,

    deregister: pattern_tree_deregister,

    search:     pattern_tree_search

class HaketiloFirefox(webdriver.Firefox):

    """

    This wrapper class around selenium.webdriver.Firefox adds a `loaded_scripts`

    instance property that gets resetted to an empty array every time the

    `get()` method is called.

    """

    def __init__(self, *args, **kwargs):

        super().__init__(*args, **kwargs)

        self.reset_loaded_scripts()

    def reset_loaded_scripts(self):

        self.loaded_scripts = []

    def get(self, *args, **kwargs):

        self.reset_loaded_scripts()

        super().get(*args, **kwargs)

    """

    Create a Firefox profile that uses the specified HTTP proxy for all

    protocols.

    """

    """

    Initialize a Firefox instance controlled by selenium. The instance is

    started in safe mode.

    """

    return HaketiloFirefox(options=options, firefox_profile=profile,

                           firefox_binary=firefox_binary)

    """

    Initialize a Firefox instance controlled by selenium. The instance is

    started using an empty profile (either the default one or the one passed to

    `configure` script). The empty profile is meant to make Firefox start with

    globally-installed extensions disabled.

    """

    return HaketiloFirefox(firefox_profile=profile,

                           firefox_binary=firefox_binary)

    driver.loaded_scripts.append(script)

        print("Scripts loaded since driver's last get() method call:",

              file=sys.stderr)

        for script in driver.loaded_scripts:

            lines = enumerate(script.split('\n'), 1)

            for err_info in [('===',), *lines]:

                print(*err_info, file=sys.stderr)

    assert deco['trailing_slash'] == False

    assert deco['proto']          == 'https'

    assert deco['domain']         == ['example', 'com']

    assert deco['path']           == ['a', 'b']

    assert deco['trailing_slash'] == True

    assert deco['proto']          == 'http'

    assert deco['domain']         == ['**', 'example', 'com']

    assert deco['path']           == []

    assert deco['trailing_slash'] == True

    assert deco['proto']          == 'ftp'

    assert deco['domain']         == ['ftp', 'example', 'com']

    assert deco['path']           == ['all', 'passwords.txt']

    assert deco['trailing_slash'] == False

    assert deco['proto']          == 'ftp'

    assert deco['domain']         == ['mirror', 'edu', 'pl', 'eu', 'org']

    assert deco['path']           == []

    assert deco['trailing_slash'] == False

    assert deco['proto']          == 'file'

    assert deco['path']           == ['mnt', 'parabola_chroot', 'etc', 'passwd']

    assert 'domain' not in deco

    patterns_query_tree.js contains Pattern Tree data structure that allows

        const branch = empty_node();

    patterns_query_tree.js contains Pattern Tree data structure that allows

        var branch = empty_node();

def test_pattern_tree(execute_in_page, patterns_tree_code):

    """

    patterns_query_tree.js contains Pattern Tree data structure that allows

    arrays of string labels to be mapped to items.

    Verify operations on entire such tree work properly.

    """

    execute_in_page(patterns_tree_code, page='https://gotmyowndoma.in')

    # Perform tests with all possible patterns for a simple URL.

    url = 'https://example.com'

    patterns = [

        'https://example.com',

        'https://example.com/***',

        'https://***.example.com',

        'https://***.example.com/***'

    ]

    bad_patterns = [

        'http://example.com',

        'https://a.example.com',

        'https://*.example.com',

        'https://**.example.com',

        'https://example.com/a',

        'https://example.com/*',

        'https://example.com/**',

    ]

    expected = [{'key': p} for p in patterns]

    tree, result = execute_in_page(

        '''{

        const tree = pattern_tree.make();

        for (const pattern of arguments[0].concat(arguments[1])) {

            pattern_tree.register(tree, pattern,       'key', pattern);

            pattern_tree.register(tree, pattern + '/', 'key', pattern + '/');

        }

        returnval([tree, [...pattern_tree.search(tree, arguments[2])]]);

        }''',

        patterns, bad_patterns, url)

    assert expected == result

    # Also verify that deregistering half of the good patterns works correctly.

    patterns_removed = [pattern for i, pattern in enumerate(patterns) if i % 2]

    patterns = [pattern for i, pattern in enumerate(patterns) if not (i % 2)]

    expected = [{'key': p} for p in patterns]

    tree, result = execute_in_page(

        '''{

        const tree = arguments[0];

        for (const pattern of arguments[1]) {

            pattern_tree.deregister(tree, pattern,       'key');

            pattern_tree.deregister(tree, pattern + '/', 'key');

        }

        returnval([tree, [...pattern_tree.search(tree, arguments[2])]]);

        }''',

        tree, patterns_removed, url)

    assert expected == result

    # Also verify that deregistering all the patterns works correctly.

    tree = execute_in_page(

        '''{

        const tree = arguments[0];

        for (const pattern of arguments[1].concat(arguments[2])) {

            pattern_tree.deregister(tree, pattern,       'key');

            pattern_tree.deregister(tree, pattern + '/', 'key');

        }

        returnval(tree);

        }''',

        tree, patterns, bad_patterns)

    assert tree == {}

    # Perform tests with all possible patterns for a complex URL.

    url = 'http://settings.query.example.com/google/tries/destroy/adblockers//'

    patterns = [

        'http://settings.query.example.com/google/tries/destroy/adblockers',

        'http://settings.query.example.com/google/tries/destroy/adblockers/***',

        'http://settings.query.example.com/google/tries/destroy/*',

        'http://settings.query.example.com/google/tries/destroy/***',

        'http://settings.query.example.com/google/tries/**',

        'http://settings.query.example.com/google/tries/***',

        'http://settings.query.example.com/google/**',

        'http://settings.query.example.com/google/***',

        'http://settings.query.example.com/**',

        'http://settings.query.example.com/***',

        'http://***.settings.query.example.com/google/tries/destroy/adblockers',

        'http://***.settings.query.example.com/google/tries/destroy/adblockers/***',

        'http://***.settings.query.example.com/google/tries/destroy/*',

        'http://***.settings.query.example.com/google/tries/destroy/***',

        'http://***.settings.query.example.com/google/tries/**',

        'http://***.settings.query.example.com/google/tries/***',

        'http://***.settings.query.example.com/google/**',

        'http://***.settings.query.example.com/google/***',

        'http://***.settings.query.example.com/**',

        'http://***.settings.query.example.com/***',

        'http://*.query.example.com/google/tries/destroy/adblockers',

        'http://*.query.example.com/google/tries/destroy/adblockers/***',

        'http://*.query.example.com/google/tries/destroy/*',

        'http://*.query.example.com/google/tries/destroy/***',

        'http://*.query.example.com/google/tries/**',

        'http://*.query.example.com/google/tries/***',

        'http://*.query.example.com/google/**',

        'http://*.query.example.com/google/***',

        'http://*.query.example.com/**',

        'http://*.query.example.com/***',

        'http://***.query.example.com/google/tries/destroy/adblockers',

        'http://***.query.example.com/google/tries/destroy/adblockers/***',

        'http://***.query.example.com/google/tries/destroy/*',

        'http://***.query.example.com/google/tries/destroy/***',

        'http://***.query.example.com/google/tries/**',

        'http://***.query.example.com/google/tries/***',

        'http://***.query.example.com/google/**',

        'http://***.query.example.com/google/***',

        'http://***.query.example.com/**',

        'http://***.query.example.com/***',

        'http://**.example.com/google/tries/destroy/adblockers',

        'http://**.example.com/google/tries/destroy/adblockers/***',

        'http://**.example.com/google/tries/destroy/*',

        'http://**.example.com/google/tries/destroy/***',

        'http://**.example.com/google/tries/**',

        'http://**.example.com/google/tries/***',

        'http://**.example.com/google/**',

        'http://**.example.com/google/***',

        'http://**.example.com/**',

        'http://**.example.com/***',

        'http://***.example.com/google/tries/destroy/adblockers',

        'http://***.example.com/google/tries/destroy/adblockers/***',

        'http://***.example.com/google/tries/destroy/*',

        'http://***.example.com/google/tries/destroy/***',

        'http://***.example.com/google/tries/**',

        'http://***.example.com/google/tries/***',

        'http://***.example.com/google/**',

        'http://***.example.com/google/***',

        'http://***.example.com/**',

        'http://***.example.com/***'

    ]

    bad_patterns = [

        'https://settings.query.example.com/google/tries/destroy/adblockers',

        'http://settings.query.example.com/google/tries/destroy/adblockers/a',

        'http://settings.query.example.com/google/tries/destroy/adblockers/*',

        'http://settings.query.example.com/google/tries/destroy/adblockers/**',

        'http://settings.query.example.com/google/tries/destroy/a',

        'http://settings.query.example.com/google/tries/destroy/**',

        'http://settings.query.example.com/google/tries/*',

        'http://a.settings.query.example.com/google/tries/destroy/adblockers',

        'http://*.settings.query.example.com/google/tries/destroy/adblockers',

        'http://**.settings.query.example.com/google/tries/destroy/adblockers',

        'http://a.query.example.com/google/tries/destroy/adblockers',

        'http://**.query.example.com/google/tries/destroy/adblockers',

        'http://*.example.com/google/tries/destroy/adblockers'

    ]

    expected = [{'key': p + s} for p in patterns for s in ['/', '']]

    tree, result = execute_in_page(

        '''{

        const tree = pattern_tree.make();

        for (const pattern of arguments[0].concat(arguments[1])) {

            pattern_tree.register(tree, pattern,       'key', pattern);

            pattern_tree.register(tree, pattern + '/', 'key', pattern + '/');

        }

        returnval([tree, [...pattern_tree.search(tree, arguments[2])]]);

        }''',

        patterns, bad_patterns, url)

    assert expected == result

    # Also verify that deregistering all patterns with trailing slash works

    # correctly.

    expected = [{'key': p} for p in patterns]

    tree, result = execute_in_page(

        '''{

        const tree = arguments[0];

        for (const pattern of arguments[1])

            pattern_tree.deregister(tree, pattern + '/', 'key');

        returnval([tree, [...pattern_tree.search(tree, arguments[2])]]);

        }''',

        tree, patterns, url)

    assert expected == result

    # Also verify that deregistering all the patterns works correctly.

    tree = execute_in_page(

        '''{

        const tree = arguments[0];

        for (const pattern of arguments[1])

            pattern_tree.deregister(tree, pattern,       'key');

        for (const pattern of arguments[2]) {

            pattern_tree.deregister(tree, pattern,       'key');

            pattern_tree.deregister(tree, pattern + '/', 'key');

        }

        returnval(tree);

        }''',

        tree, patterns, bad_patterns)

    assert tree == {}