@diplodoc/transform 4.0.0

package/src/transform/liquid/conditions.ts

@@ -0,0 +1,259 @@
+import {bold} from 'chalk';
+
+import evalExp from './evaluation';
+import {tagLine} from './lexical';
+import {log} from '../log';
+import {getPreparedLeftContent, removeIndentBlock} from './utils';
+import {createSourceMapApi, getLineNumber} from './sourceMap';
+
+type Options = {
+    firstLineNumber: number;
+    lastLineNumber: number;
+    resFirstLineNumber: number;
+    resLastLineNumber: number;
+    linesTotal: number;
+    sourceMap: Record<number, number>;
+};
+
+function changeSourceMap({
+    firstLineNumber,
+    lastLineNumber,
+    resFirstLineNumber,
+    resLastLineNumber,
+    linesTotal,
+    sourceMap,
+}: Options) {
+    if (!sourceMap) {
+        return;
+    }
+
+    const {isInlineTag, getSourceMapValue, moveLines, removeLines} = createSourceMapApi({
+        firstLineNumber,
+        lastLineNumber,
+        sourceMap,
+    });
+
+    if (isInlineTag) {
+        return;
+    }
+
+    let offsetRestLines;
+    if (resFirstLineNumber) {
+        // Move condition's content to the top
+        const offsetContentLines = firstLineNumber - resFirstLineNumber;
+        moveLines({
+            start: resFirstLineNumber,
+            end: resLastLineNumber - 1,
+            offset: offsetContentLines,
+            withReplace: true,
+        });
+
+        // Remove the rest lines of the condition block
+        removeLines({start: firstLineNumber, end: resFirstLineNumber - 1});
+        removeLines({start: resLastLineNumber, end: lastLineNumber});
+
+        // Calculate an offset of the rest lines
+        offsetRestLines = getSourceMapValue(resLastLineNumber - 1) - lastLineNumber;
+    } else {
+        // Remove the whole condition block
+        removeLines({start: firstLineNumber, end: lastLineNumber});
+
+        // Calculate offset of the rest lines
+        offsetRestLines = firstLineNumber - lastLineNumber - 1;
+    }
+
+    // Offset the rest lines
+    moveLines({start: lastLineNumber + 1, end: linesTotal, offset: offsetRestLines});
+}
+
+function getElseProp<B extends keyof Elses>({elses}: {elses: Elses[]}, propName: B, index = 0) {
+    if (!elses.length || index >= elses.length) {
+        return undefined;
+    }
+
+    return elses[index][propName];
+}
+
+type Opts = {
+    ifTag: Tag;
+    vars: Record<string, unknown>;
+    content: string;
+    match: RegExpExecArray;
+    lastIndex: number;
+    sourceMap: Record<number, number>;
+    linesTotal: number;
+};
+
+function inlineConditions({ifTag, vars, content, match, lastIndex, sourceMap, linesTotal}: Opts) {
+    let res = '';
+    const firstLineNumber = getLineNumber(content, ifTag.startPos);
+    const lastLineNumber = getLineNumber(content, lastIndex);
+    let resFirstLineNumber = 0;
+    let resLastLineNumber = 0;
+
+    if (evalExp(ifTag.condition, vars)) {
+        const ifRawLastIndex = ifTag.startPos + ifTag.ifRaw.length;
+        const contentLastIndex = getElseProp(ifTag, 'startPos') || match.index;
+
+        res = content.substring(ifRawLastIndex, contentLastIndex);
+        resFirstLineNumber = getLineNumber(content, ifRawLastIndex + 1);
+        resLastLineNumber = getLineNumber(content, contentLastIndex + 1);
+    } else {
+        ifTag.elses.some(({condition, startPos, raw}, index) => {
+            const isTruthy = !condition || evalExp(condition, vars);
+
+            if (isTruthy) {
+                const elseRawLastIndex = startPos + raw.length;
+                const contentLastIndex = getElseProp(ifTag, 'startPos', index + 1) || match.index;
+
+                res = content.substring(elseRawLastIndex, contentLastIndex);
+                resFirstLineNumber = getLineNumber(content, elseRawLastIndex + 1);
+                resLastLineNumber = getLineNumber(content, contentLastIndex + 1);
+
+                return true;
+            }
+
+            return false;
+        });
+    }
+
+    changeSourceMap({
+        firstLineNumber,
+        lastLineNumber,
+        resFirstLineNumber,
+        resLastLineNumber,
+        linesTotal,
+        sourceMap,
+    });
+
+    const preparedLeftContent = getPreparedLeftContent({
+        content,
+        tagStartPos: ifTag.startPos,
+        tagContent: res,
+    });
+
+    let shift = 0;
+    if (
+        res === '' &&
+        preparedLeftContent[preparedLeftContent.length - 1] === '\n' &&
+        content[lastIndex] === '\n'
+    ) {
+        shift = 1;
+    }
+
+    if (res !== '') {
+        if (res[0] === '\n') {
+            res = res.substring(1);
+        }
+
+        res = removeIndentBlock(res);
+
+        if (res[res.length - 1] === '\n') {
+            res = res.slice(0, -1);
+        }
+    }
+
+    const leftPart = preparedLeftContent + res;
+
+    return {
+        result: leftPart + content.substring(lastIndex + shift),
+        idx: leftPart.length,
+    };
+}
+
+type Elses = {startPos: number; raw: string; condition?: string};
+
+type Tag = {
+    isOpen: Boolean;
+    condition: string;
+    startPos: number;
+    ifRaw: string;
+    elses: Elses[];
+};
+
+export = function conditions(
+    originInput: string,
+    vars: Record<string, unknown>,
+    path?: string,
+    settings?: {
+        sourceMap: Record<number, number>;
+    },
+) {
+    const sourceMap = settings?.sourceMap || {};
+
+    const R_LIQUID = /({%-?([\s\S]*?)-?%})/g;
+
+    let match;
+    const tagStack: Tag[] = [];
+    let input = originInput;
+    let linesTotal = originInput.split('\n').length;
+
+    while ((match = R_LIQUID.exec(input)) !== null) {
+        if (!match[1]) {
+            continue;
+        }
+
+        const tagMatch = match[2].trim().match(tagLine);
+        if (!tagMatch) {
+            continue;
+        }
+
+        const [type, args] = tagMatch.slice(1);
+
+        switch (type) {
+            case 'if':
+                tagStack.push({
+                    isOpen: true,
+                    condition: args,
+                    startPos: match.index,
+                    ifRaw: match[1],
+                    elses: [],
+                });
+                break;
+            case 'else':
+                tagStack[tagStack.length - 1].elses.push({
+                    startPos: match.index,
+                    raw: match[1],
+                });
+                break;
+            case 'elsif':
+                tagStack[tagStack.length - 1].elses.push({
+                    condition: args,
+                    startPos: match.index,
+                    raw: match[1],
+                });
+                break;
+            case 'endif': {
+                const ifTag = tagStack.pop();
+
+                if (!ifTag) {
+                    log.error(
+                        `If block must be opened before close${path ? ` in ${bold(path)}` : ''}`,
+                    );
+                    break;
+                }
+
+                const {idx, result} = inlineConditions({
+                    ifTag,
+                    vars,
+                    content: input,
+                    match,
+                    lastIndex: R_LIQUID.lastIndex,
+                    sourceMap,
+                    linesTotal,
+                });
+                R_LIQUID.lastIndex = idx;
+                input = result;
+                linesTotal = result.split('\n').length;
+
+                break;
+            }
+        }
+    }
+
+    if (tagStack.length !== 0) {
+        log.error(`Condition block must be closed${path ? ` in ${bold(path)}` : ''}`);
+    }
+
+    return input;
+};

package/src/transform/liquid/cycles.ts

@@ -0,0 +1,244 @@
+import {bold} from 'chalk';
+
+import {evalExp} from './evaluation';
+import {tagLine, variable} from './lexical';
+import {log} from '../log';
+import {getPreparedLeftContent} from './utils';
+import {createSourceMapApi, getLineNumber} from './sourceMap';
+import applyLiquid from './index';
+
+type Options = {
+    firstLineNumber: number;
+    lastLineNumber: number;
+    resFirstLineNumber: number;
+    resLastLineNumber: number;
+    contentLinesTotal: number;
+    linesTotal: number;
+    sourceMap: Record<number, number>;
+};
+
+function changeSourceMap({
+    firstLineNumber,
+    lastLineNumber,
+    resFirstLineNumber,
+    resLastLineNumber,
+    contentLinesTotal,
+    linesTotal,
+    sourceMap,
+}: Options) {
+    if (!sourceMap) {
+        return;
+    }
+
+    const {isInlineTag, moveLines, removeLine} = createSourceMapApi({
+        firstLineNumber,
+        lastLineNumber,
+        sourceMap,
+    });
+
+    if (isInlineTag || !resFirstLineNumber) {
+        return;
+    }
+
+    const offsetRestLines = contentLinesTotal - (lastLineNumber - firstLineNumber + 1);
+
+    // Move condition's content to the top
+    const offsetContentLines = firstLineNumber - resFirstLineNumber;
+    moveLines({
+        start: resFirstLineNumber,
+        end: resLastLineNumber - 1,
+        offset: offsetContentLines,
+        withReplace: true,
+    });
+
+    // Remove tags
+    removeLine(firstLineNumber);
+    removeLine(lastLineNumber);
+
+    // Offset the rest lines
+    moveLines({start: lastLineNumber + 1, end: linesTotal, offset: offsetRestLines});
+}
+
+type Args2 = {
+    forTag: Tag;
+    vars: Record<string, unknown>;
+    content: string;
+    match: RegExpExecArray;
+    path?: string;
+    lastIndex: number;
+    sourceMap: Record<number, number>;
+    linesTotal: number;
+};
+
+function inlineConditions({
+    forTag,
+    vars,
+    content,
+    match,
+    path,
+    lastIndex,
+    sourceMap,
+    linesTotal,
+}: Args2) {
+    let res = '';
+    const firstLineNumber = getLineNumber(content, forTag.startPos);
+    const lastLineNumber = getLineNumber(content, lastIndex);
+
+    const forRawLastIndex = forTag.startPos + forTag.forRaw.length;
+    const contentLastIndex = match.index;
+
+    const forTemplate = content.substring(forRawLastIndex, contentLastIndex);
+    const resFirstLineNumber = getLineNumber(content, forRawLastIndex + 1);
+    const resLastLineNumber = getLineNumber(content, contentLastIndex + 1);
+
+    let collection = evalExp(forTag.collectionName, vars);
+    if (!collection || !Array.isArray(collection)) {
+        collection = [];
+        log.error(`${bold(forTag.collectionName)} is undefined or not iterable`);
+    }
+
+    collection.forEach((item) => {
+        const newVars = {...vars, [forTag.variableName]: item};
+        res += applyLiquid(forTemplate, newVars, path).trimRight();
+    });
+
+    const contentLinesTotal = res.split('\n').length - 1;
+
+    changeSourceMap({
+        firstLineNumber,
+        lastLineNumber,
+        resFirstLineNumber,
+        resLastLineNumber,
+        linesTotal,
+        sourceMap,
+        contentLinesTotal,
+    });
+
+    const preparedLeftContent = getPreparedLeftContent({
+        content,
+        tagStartPos: forTag.startPos,
+        tagContent: res,
+    });
+
+    let shift = 0;
+    if (
+        res === '' &&
+        preparedLeftContent[preparedLeftContent.length - 1] === '\n' &&
+        content[lastIndex] === '\n'
+    ) {
+        shift = 1;
+    }
+
+    if (res !== '') {
+        if (res[0] === ' ' || res[0] === '\n') {
+            res = res.substring(1);
+        }
+    }
+
+    const leftPart = preparedLeftContent + res;
+
+    return {
+        result: leftPart + content.substring(lastIndex + shift),
+        idx: leftPart.length,
+    };
+}
+
+type Tag = {
+    item: string;
+    variableName: string;
+    collectionName: string;
+    startPos: number;
+    forRaw: string;
+};
+
+export = function cycles(
+    originInput: string,
+    vars: Record<string, unknown>,
+    path?: string,
+    settings: {sourceMap?: Record<number, number>} = {},
+) {
+    const {sourceMap} = settings;
+
+    const R_LIQUID = /({%-?([\s\S]*?)-?%})/g;
+    const FOR_SYNTAX = new RegExp(`(\\w+)\\s+in\\s+(${variable.source})`);
+
+    let match;
+    const tagStack: Tag[] = [];
+    let input = originInput;
+    let countSkippedInnerTags = 0;
+    let linesTotal = originInput.split('\n').length;
+
+    while ((match = R_LIQUID.exec(input)) !== null) {
+        if (!match[1]) {
+            continue;
+        }
+
+        const tagMatch = match[2].trim().match(tagLine);
+        if (!tagMatch) {
+            continue;
+        }
+
+        const [type, args] = tagMatch.slice(1);
+
+        switch (type) {
+            case 'for': {
+                if (tagStack.length) {
+                    countSkippedInnerTags += 1;
+                    break;
+                }
+
+                const matches = args.match(FOR_SYNTAX);
+                if (!matches) {
+                    log.error(`Incorrect syntax in if condition${path ? ` in ${bold(path)}` : ''}`);
+                    break;
+                }
+
+                const [variableName, collectionName] = matches.slice(1);
+                tagStack.push({
+                    item: args,
+                    variableName,
+                    collectionName,
+                    startPos: match.index,
+                    forRaw: match[1],
+                });
+                break;
+            }
+            case 'endfor': {
+                if (countSkippedInnerTags > 0) {
+                    countSkippedInnerTags -= 1;
+                    break;
+                }
+                const forTag = tagStack.pop();
+
+                if (!forTag) {
+                    log.error(
+                        `For block must be opened before close${path ? ` in ${bold(path)}` : ''}`,
+                    );
+                    break;
+                }
+
+                const {idx, result} = inlineConditions({
+                    forTag,
+                    vars,
+                    content: input,
+                    match,
+                    path,
+                    lastIndex: R_LIQUID.lastIndex,
+                    sourceMap: sourceMap || {},
+                    linesTotal,
+                });
+                R_LIQUID.lastIndex = idx;
+                input = result;
+                linesTotal = result.split('\n').length;
+
+                break;
+            }
+        }
+    }
+
+    if (tagStack.length !== 0) {
+        log.error(`For block must be closed${path ? ` in ${bold(path)}` : ''}`);
+    }
+
+    return input;
+};

package/src/transform/liquid/errors.ts

@@ -0,0 +1,10 @@
+import {bold} from 'chalk';
+
+export class SkippedEvalError extends Error {
+    constructor(message: string, exp: string) {
+        super();
+
+        this.name = 'SkippedEvalError';
+        this.message = `${message}: ${bold(exp)}`;
+    }
+}

package/src/transform/liquid/evaluation.ts

@@ -0,0 +1,145 @@
+import * as lexical from './lexical';
+import getObject from '../getObject';
+import {log} from '../log';
+import filters from './filters';
+import {SkippedEvalError} from './errors';
+
+type Scope = Record<string, unknown>;
+
+type WithFilter = (l: string, filter: (s: string) => boolean, exp: string) => boolean;
+type NoFilter = (l: string, r: string, exp: string) => boolean;
+type DotOperator = (
+    l: Record<string, (...args: unknown[]) => unknown>,
+    r: string,
+    exp: string,
+) => boolean;
+
+const operators: Record<string, WithFilter | NoFilter | DotOperator> = {
+    '==': ((l, r) => l === r) as NoFilter,
+    '!=': ((l, r) => l !== r) as NoFilter,
+    '>': ((l, r) => l !== null && r !== null && l > r) as NoFilter,
+    '<': ((l, r) => l !== null && r !== null && l < r) as NoFilter,
+    '>=': ((l, r) => l !== null && r !== null && l >= r) as NoFilter,
+    '<=': ((l, r) => l !== null && r !== null && l <= r) as NoFilter,
+    contains: ((l, r) => l !== null && r !== null && l.includes(r)) as NoFilter,
+    and: ((l, r) => isTruthy(l) && isTruthy(r)) as NoFilter,
+    or: ((l, r) => isTruthy(l) || isTruthy(r)) as NoFilter,
+    '|': ((l, filter, exp) => {
+        try {
+            return filter(l);
+        } catch (e) {
+            if (!filter) {
+                throw new SkippedEvalError('Cannot apply an unsupported filter', exp);
+            }
+
+            throw new SkippedEvalError('There are some problems with the filter', exp);
+        }
+    }) as WithFilter,
+    '.': ((l, r, exp) => {
+        const parsed = lexical.getParsedMethod(r);
+
+        try {
+            if (!parsed) throw new Error();
+            const {name, args} = parsed;
+
+            return l[name](...args);
+        } catch (e) {
+            if (!l) {
+                throw new SkippedEvalError(
+                    `Cannot apply the function '${name}' on an undefined variable`,
+                    exp,
+                );
+            }
+
+            throw new SkippedEvalError('There are some problems with the function', exp);
+        }
+    }) as DotOperator,
+};
+
+function evalValue(originStr: string, scope: Scope) {
+    const str = originStr && originStr.trim();
+    if (!str) {
+        return undefined;
+    }
+
+    if (lexical.isLiteral(str)) {
+        return lexical.parseLiteral(str);
+    }
+    if (lexical.isVariable(str)) {
+        return getObject(str, scope);
+    }
+
+    throw new TypeError(`cannot eval '${str}' as value`);
+}
+
+function isTruthy(val: unknown) {
+    return !isFalsy(val);
+}
+
+function isFalsy(val: unknown) {
+    return val === false || undefined === val || val === null;
+}
+
+export function evalExp(
+    exp: string,
+    scope: Record<string, unknown>,
+): string[] | boolean | string | undefined | ((input: string) => number | string) {
+    const operatorREs = lexical.operators;
+    let match;
+
+    if (Object.getOwnPropertyNames(filters).includes(exp.trim())) {
+        return filters[exp.trim() as keyof typeof filters];
+    }
+
+    if (lexical.isSupportedMethod(exp)) {
+        return exp;
+    }
+
+    try {
+        for (let i = 0; i < operatorREs.length; i++) {
+            const operatorRE = operatorREs[i];
+            const expRE = new RegExp(
+                `^(${lexical.quoteBalanced.source})(${operatorRE.source})(${lexical.quoteBalanced.source})$`,
+            );
+            if ((match = exp.match(expRE))) {
+                const l = evalExp(match[1], scope);
+                const operator = match[2].trim();
+                const op = operators[operator];
+                const r = evalExp(match[3], scope);
+
+                if (
+                    operator !== '.' ||
+                    (operator === '.' && lexical.isSupportedMethod(r as string))
+                ) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    return op(l as any, r as any, exp);
+                }
+            }
+        }
+
+        if ((match = exp.match(lexical.rangeLine))) {
+            const low = evalValue(match[1], scope);
+            const high = evalValue(match[2], scope);
+            const range = [];
+
+            for (let j = low; j <= high; j++) {
+                range.push(j);
+            }
+
+            return range;
+        }
+
+        return evalValue(exp, scope);
+    } catch (e) {
+        if (e instanceof SkippedEvalError) {
+            log.warn(`Skip error: ${e}`);
+            return undefined;
+        }
+
+        log.error(`Error: ${e}`);
+    }
+
+    return undefined;
+}
+
+export default (exp: string, scope: Record<string, unknown>) => Boolean(evalExp(exp, scope));

package/src/transform/liquid/filters.ts

@@ -0,0 +1,19 @@
+export function length(input: string) {
+    return input.length;
+}
+
+export function capitalize(input: string) {
+    return String(input).replace(/^([a-z])/, (_m, chr) => chr.toUpperCase());
+}
+
+export function escapeMarkdown(input: string) {
+    return String(input).replace(/([\\`*_{}[\]()#+\-.!|])/g, '\\$1');
+}
+
+const index = {
+    length,
+    capitalize,
+    escapeMarkdown,
+};
+
+export default index;