/ var / www / html / cqt / server / node_modules / joi / lib / [ HOME SHELL ]

Name	Size	Permission	Action
types	[ DIR ]	drwxr-xr-x
annotate.js	5.09 KB	-rwxr-xr-x
base.js	30.69 KB	-rwxr-xr-x
cache.js	2.46 KB	-rwxr-xr-x
common.js	4.81 KB	-rwxr-xr-x
compile.js	7.84 KB	-rwxr-xr-x
errors.js	5.92 KB	-rwxr-xr-x
extend.js	7.34 KB	-rwxr-xr-x
index.d.ts	80.34 KB	-rw-r--r--
index.js	6.76 KB	-rwxr-xr-x
manifest.js	11.5 KB	-rwxr-xr-x
messages.js	4.16 KB	-rwxr-xr-x
modify.js	6.68 KB	-rwxr-xr-x
ref.js	9.93 KB	-rwxr-xr-x
schemas.js	7.92 KB	-rwxr-xr-x
state.js	3.39 KB	-rwxr-xr-x
template.js	10.98 KB	-rwxr-xr-x
trace.js	8.01 KB	-rwxr-xr-x
validator.js	20.54 KB	-rwxr-xr-x
values.js	5.68 KB	-rwxr-xr-x

Code Editor : trace.js

'use strict';

const { deepEqual } = require('@hapi/hoek');
const Pinpoint = require('@hapi/pinpoint');

const Errors = require('./errors');

const internals = {
    codes: {
        error: 1,
        pass: 2,
        full: 3
    },
    labels: {
        0: 'never used',
        1: 'always error',
        2: 'always pass'
    }
};

exports.setup = function (root) {

const trace = function () {

root._tracer = root._tracer || new internals.Tracer();
        return root._tracer;
    };

root.trace = trace;
    root[Symbol.for('@hapi/lab/coverage/initialize')] = trace;

root.untrace = () => {

root._tracer = null;
    };
};

exports.location = function (schema) {

return schema.$_setFlag('_tracerLocation', Pinpoint.location(2));                       // base.tracer(), caller
};

internals.Tracer = class {

constructor() {

this.name = 'Joi';
        this._schemas = new Map();
    }

_register(schema) {

const existing = this._schemas.get(schema);
        if (existing) {
            return existing.store;
        }

const store = new internals.Store(schema);
        const { filename, line } = schema._flags._tracerLocation || Pinpoint.location(5);   // internals.tracer(), internals.entry(), exports.entry(), validate(), caller
        this._schemas.set(schema, { filename, line, store });
        return store;
    }

_combine(merged, sources) {

for (const { store } of this._schemas.values()) {
            store._combine(merged, sources);
        }
    }

report(file) {

const coverage = [];

// Process each registered schema

for (const { filename, line, store } of this._schemas.values()) {
            if (file &&
                file !== filename) {

continue;
            }

// Process sub schemas of the registered root

const missing = [];
            const skipped = [];

for (const [schema, log] of store._sources.entries()) {

// Check if sub schema parent skipped

if (internals.sub(log.paths, skipped)) {
                    continue;
                }

// Check if sub schema reached

if (!log.entry) {
                    missing.push({
                        status: 'never reached',
                        paths: [...log.paths]
                    });

skipped.push(...log.paths);
                    continue;
                }

// Check values

for (const type of ['valid', 'invalid']) {
                    const set = schema[`_${type}s`];
                    if (!set) {
                        continue;
                    }

const values = new Set(set._values);
                    const refs = new Set(set._refs);
                    for (const { value, ref } of log[type]) {
                        values.delete(value);
                        refs.delete(ref);
                    }

if (values.size ||
                        refs.size) {

missing.push({
                            status: [...values, ...[...refs].map((ref) => ref.display)],
                            rule: `${type}s`
                        });
                    }
                }

// Check rules status

const rules = schema._rules.map((rule) => rule.name);
                for (const type of ['default', 'failover']) {
                    if (schema._flags[type] !== undefined) {
                        rules.push(type);
                    }
                }

for (const name of rules) {
                    const status = internals.labels[log.rule[name] || 0];
                    if (status) {
                        const report = { rule: name, status };
                        if (log.paths.size) {
                            report.paths = [...log.paths];
                        }

missing.push(report);
                    }
                }
            }

if (missing.length) {
                coverage.push({
                    filename,
                    line,
                    missing,
                    severity: 'error',
                    message: `Schema missing tests for ${missing.map(internals.message).join(', ')}`
                });
            }
        }

return coverage.length ? coverage : null;
    }
};

internals.Store = class {

constructor(schema) {

this.active = true;
        this._sources = new Map();          // schema -> { paths, entry, rule, valid, invalid }
        this._combos = new Map();           // merged -> [sources]
        this._scan(schema);
    }

debug(state, source, name, result) {

state.mainstay.debug && state.mainstay.debug.push({ type: source, name, result, path: state.path });
    }

entry(schema, state) {

internals.debug(state, { type: 'entry' });

this._record(schema, (log) => {

log.entry = true;
        });
    }

filter(schema, state, source, value) {

internals.debug(state, { type: source, ...value });

this._record(schema, (log) => {

log[source].add(value);
        });
    }

log(schema, state, source, name, result) {

internals.debug(state, { type: source, name, result: result === 'full' ? 'pass' : result });

this._record(schema, (log) => {

log[source][name] = log[source][name] || 0;
            log[source][name] |= internals.codes[result];
        });
    }

resolve(state, ref, to) {

if (!state.mainstay.debug) {
            return;
        }

const log = { type: 'resolve', ref: ref.display, to, path: state.path };
        state.mainstay.debug.push(log);
    }

value(state, by, from, to, name) {

if (!state.mainstay.debug ||
            deepEqual(from, to)) {

return;
        }

const log = { type: 'value', by, from, to, path: state.path };
        if (name) {
            log.name = name;
        }

state.mainstay.debug.push(log);
    }

_record(schema, each) {

const log = this._sources.get(schema);
        if (log) {
            each(log);
            return;
        }

const sources = this._combos.get(schema);
        for (const source of sources) {
            this._record(source, each);
        }
    }

_scan(schema, _path) {

const path = _path || [];

let log = this._sources.get(schema);
        if (!log) {
            log = {
                paths: new Set(),
                entry: false,
                rule: {},
                valid: new Set(),
                invalid: new Set()
            };

this._sources.set(schema, log);
        }

if (path.length) {
            log.paths.add(path);
        }

const each = (sub, source) => {

const subId = internals.id(sub, source);
            this._scan(sub, path.concat(subId));
        };

schema.$_modify({ each, ref: false });
    }

_combine(merged, sources) {

this._combos.set(merged, sources);
    }
};

internals.message = function (item) {

const path = item.paths ? Errors.path(item.paths[0]) + (item.rule ? ':' : '') : '';
    return `${path}${item.rule || ''} (${item.status})`;
};

internals.id = function (schema, { source, name, path, key }) {

if (schema._flags.id) {
        return schema._flags.id;
    }

if (key) {
        return key;
    }

name = `@${name}`;

if (source === 'terms') {
        return [name, path[Math.min(path.length - 1, 1)]];
    }

return name;
};

internals.sub = function (paths, skipped) {

for (const path of paths) {
        for (const skip of skipped) {
            if (deepEqual(path.slice(0, skip.length), skip)) {
                return true;
            }
        }
    }

return false;
};

internals.debug = function (state, event) {

if (state.mainstay.debug) {
        event.path = state.debug ? [...state.path, state.debug] : state.path;
        state.mainstay.debug.push(event);
    }
};

Urban Research Lab

Urban Research Lab

The Urban Research Lab (URL) at IIIT-Delhi was established in 2020, during a time when the pandemic brought the complexities of urban life more visible than ever. What started as an initiative by faculty and students has grown into a collaborative space for critically exploring and reimagining the urban questions through research, dialogue, and interdisciplinary engagement.