vladx 1.0.0

package/src/runtime/linter.js

@@ -0,0 +1,374 @@
+/**
+ * Linter — Линтер для кода VladX
+ */
+
+import { Lexer } from '../lexer/lexer.js';
+import { Parser } from '../parser/parser.js';
+
+export class Linter {
+    constructor(options = {}) {
+        this.rules = new Map();
+        this.config = options.config || {};
+        this.severity = options.severity || 'error'; // error, warning, info
+        this.autoFix = options.autoFix || false;
+
+        this.registerDefaultRules();
+    }
+
+    /**
+     * Добавить правило
+     */
+    addRule(name, rule) {
+        this.rules.set(name, rule);
+        return this;
+    }
+
+    /**
+     * Удалить правило
+     */
+    removeRule(name) {
+        return this.rules.delete(name);
+    }
+
+    /**
+     * Проверить файл
+     */
+    lint(source, filename = '<anonymous>') {
+        const results = [];
+
+        // Лексический анализ
+        const lexer = new Lexer(source, filename);
+        const tokens = lexer.tokenize();
+
+        // Синтаксический анализ
+        const parser = new Parser(tokens);
+        const ast = parser.parse();
+
+        // Применить правила
+        for (const [ruleName, rule] of this.rules) {
+            if (rule.checkTokens) {
+                const tokenResults = rule.checkTokens(tokens, filename);
+                results.push(...tokenResults.map(r => ({ ...r, rule: ruleName })));
+            }
+
+            if (rule.checkAST) {
+                const astResults = rule.checkAST(ast, filename);
+                results.push(...astResults.map(r => ({ ...r, rule: ruleName })));
+            }
+
+            if (rule.checkSource) {
+                const sourceResults = rule.checkSource(source, filename);
+                results.push(...sourceResults.map(r => ({ ...r, rule: ruleName })));
+            }
+        }
+
+        return {
+            errors: results.filter(r => r.severity === 'error'),
+            warnings: results.filter(r => r.severity === 'warning'),
+            info: results.filter(r => r.severity === 'info'),
+            all: results,
+            hasErrors: results.some(r => r.severity === 'error')
+        };
+    }
+
+    /**
+     * Автофикс проблем
+     */
+    fix(source, filename = '<anonymous>') {
+        const results = this.lint(source, filename);
+        let fixedSource = source;
+
+        if (!this.autoFix) {
+            return {
+                source,
+                results,
+                fixed: false
+            };
+        }
+
+        for (const [ruleName, rule] of this.rules) {
+            if (rule.fix && results.some(r => r.rule === ruleName)) {
+                fixedSource = rule.fix(fixedSource, filename);
+            }
+        }
+
+        const newResults = this.lint(fixedSource, filename);
+
+        return {
+            source: fixedSource,
+            originalResults: results,
+            results: newResults,
+            fixed: newResults.all.length < results.all.length
+        };
+    }
+
+    /**
+     * Зарегистрировать правила по умолчанию
+     */
+    registerDefaultRules() {
+        // Правило: unused variables
+        this.addRule('no-unused-vars', {
+            checkAST: (ast, filename) => {
+                const results = [];
+                const usedVars = new Set();
+                const declaredVars = new Set();
+
+                const traverse = (node) => {
+                    if (!node) return;
+
+                    if (node.type === 'LetStatement' || node.type === 'ConstStatement') {
+                        declaredVars.add(node.name);
+                    }
+
+                    if (node.type === 'Identifier') {
+                        usedVars.add(node.name);
+                    }
+
+                    for (const key in node) {
+                        if (Array.isArray(node[key])) {
+                            node[key].forEach(traverse);
+                        } else if (typeof node[key] === 'object') {
+                            traverse(node[key]);
+                        }
+                    }
+                };
+
+                traverse(ast);
+
+                for (const varName of declaredVars) {
+                    if (!usedVars.has(varName)) {
+                        results.push({
+                            message: `Переменная "${varName}" не используется`,
+                            line: ast.body?.[0]?.line || 0,
+                            column: 0,
+                            severity: 'warning',
+                            filename
+                        });
+                    }
+                }
+
+                return results;
+            }
+        });
+
+        // Правило: console.log в production
+        this.addRule('no-console', {
+            checkAST: (ast, filename) => {
+                const results = [];
+
+                const traverse = (node) => {
+                    if (!node) return;
+
+                    if (node.type === 'CallExpression') {
+                        if (node.callee === 'печать' || node.callee === 'console.log') {
+                            results.push({
+                                message: 'Не используйте console.log в production коде',
+                                line: node.line || 0,
+                                column: 0,
+                                severity: 'warning',
+                                filename
+                            });
+                        }
+                    }
+
+                    for (const key in node) {
+                        if (Array.isArray(node[key])) {
+                            node[key].forEach(traverse);
+                        } else if (typeof node[key] === 'object') {
+                            traverse(node[key]);
+                        }
+                    }
+                };
+
+                traverse(ast);
+                return results;
+            }
+        });
+
+        // Правило: empty blocks
+        this.addRule('no-empty-blocks', {
+            checkAST: (ast, filename) => {
+                const results = [];
+
+                const traverse = (node) => {
+                    if (!node) return;
+
+                    if (node.type === 'IfStatement' || node.type === 'WhileStatement') {
+                        const body = node.thenBranch?.body || node.body;
+                        if (body && body.length === 0) {
+                            results.push({
+                                message: 'Пустой блок кода',
+                                line: node.line || 0,
+                                column: 0,
+                                severity: 'warning',
+                                filename
+                            });
+                        }
+                    }
+
+                    for (const key in node) {
+                        if (Array.isArray(node[key])) {
+                            node[key].forEach(traverse);
+                        } else if (typeof node[key] === 'object') {
+                            traverse(node[key]);
+                        }
+                    }
+                };
+
+                traverse(ast);
+                return results;
+            },
+            fix: (source) => {
+                return source.replace(/(?:если|if)\s*\([^)]*\)\s*{\s*}/g, '');
+            }
+        });
+
+        // Правило: trailing whitespace
+        this.addRule('no-trailing-whitespace', {
+            checkSource: (source, filename) => {
+                const results = [];
+                const lines = source.split('\n');
+
+                lines.forEach((line, index) => {
+                    if (line !== line.trimEnd()) {
+                        results.push({
+                            message: 'Trailing whitespace в конце строки',
+                            line: index + 1,
+                            column: line.length,
+                            severity: 'info',
+                            filename
+                        });
+                    }
+                });
+
+                return results;
+            },
+            fix: (source) => {
+                return source.split('\n').map(line => line.trimEnd()).join('\n');
+            }
+        });
+
+        // Правило: line length
+        this.addRule('max-line-length', {
+            checkSource: (source, filename) => {
+                const results = [];
+                const maxLength = this.config.maxLineLength || 100;
+                const lines = source.split('\n');
+
+                lines.forEach((line, index) => {
+                    if (line.length > maxLength) {
+                        results.push({
+                            message: `Строка слишком длинная: ${line.length} > ${maxLength}`,
+                            line: index + 1,
+                            column: maxLength,
+                            severity: 'warning',
+                            filename
+                        });
+                    }
+                });
+
+                return results;
+            }
+        });
+
+        // Правило: no var
+        this.addRule('no-var', {
+            checkTokens: (tokens, filename) => {
+                const results = [];
+
+                tokens.forEach(token => {
+                    if (token.type === 'VAR' || token.value === 'переменная') {
+                        results.push({
+                            message: 'Используйте "пусть" или "константа" вместо "переменная"',
+                            line: token.line,
+                            column: token.column,
+                            severity: 'error',
+                            filename
+                        });
+                    }
+                });
+
+                return results;
+            }
+        });
+
+        // Правило: curly braces
+        this.addRule('curly', {
+            checkAST: (ast, filename) => {
+                const results = [];
+
+                const traverse = (node) => {
+                    if (!node) return;
+
+                    if (node.type === 'IfStatement') {
+                        const thenBranch = node.thenBranch;
+                        if (thenBranch && thenBranch.type !== 'BlockStatement') {
+                            results.push({
+                                message: 'Используйте фигурные скобки для if блоков',
+                                line: node.line || 0,
+                                column: 0,
+                                severity: 'error',
+                                filename
+                            });
+                        }
+                    }
+
+                    for (const key in node) {
+                        if (Array.isArray(node[key])) {
+                            node[key].forEach(traverse);
+                        } else if (typeof node[key] === 'object') {
+                            traverse(node[key]);
+                        }
+                    }
+                };
+
+                traverse(ast);
+                return results;
+            }
+        });
+    }
+
+    /**
+     * Получить результаты в формате JSON
+     */
+    getResultsJSON(lintResults) {
+        return JSON.stringify(lintResults, null, 2);
+    }
+
+    /**
+     * Получить результаты в формате JUnit
+     */
+    getResultsJUnit(lintResults) {
+        const errors = lintResults.errors;
+        const warnings = lintResults.warnings;
+
+        let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+        xml += `<testsuites errors="${errors.length}" failures="0" tests="${errors.length + warnings.length}">\n`;
+        xml += '  <testsuite name="VladX Linter">\n';
+
+        for (const error of errors) {
+            xml += `    <testcase name="${error.rule}">\n`;
+            xml += `      <error message="${error.message}" line="${error.line}"/>\n`;
+            xml += '    </testcase>\n';
+        }
+
+        for (const warning of warnings) {
+            xml += `    <testcase name="${warning.rule}"/>\n`;
+        }
+
+        xml += '  </testsuite>\n';
+        xml += '</testsuites>';
+
+        return xml;
+    }
+
+    /**
+     * Очистить правила
+     */
+    clearRules() {
+        this.rules.clear();
+        return this;
+    }
+}
+
+export default Linter;

package/src/runtime/logging.js

@@ -0,0 +1,314 @@
+/**
+ * Logging — Система логирования
+ */
+
+import { existsSync, writeFileSync, appendFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+
+export class Logging {
+    constructor(options = {}) {
+        this.level = options.level || 'info'; // debug, info, warn, error
+        this.format = options.format || 'text'; // text, json
+        this.file = options.file || null;
+        this.console = options.console !== false;
+        this.colors = options.colors !== false;
+        this.timestamp = options.timestamp !== false;
+
+        this.levels = {
+            debug: 0,
+            info: 1,
+            warn: 2,
+            error: 3
+        };
+
+        this.colorsMap = {
+            debug: '\x1b[36m', // cyan
+            info: '\x1b[32m',  // green
+            warn: '\x1b[33m',  // yellow
+            error: '\x1b[31m', // red
+            reset: '\x1b[0m'
+        };
+
+        this.logBuffer = [];
+        this.maxBufferSize = options.maxBufferSize || 1000;
+    }
+
+    /**
+     * Логирование
+     */
+    log(level, message, context = {}) {
+        if (this.levels[level] < this.levels[this.level]) {
+            return;
+        }
+
+        const logEntry = {
+            level,
+            message,
+            context,
+            timestamp: this.timestamp ? new Date().toISOString() : undefined
+        };
+
+        this.logBuffer.push(logEntry);
+
+        if (this.logBuffer.length > this.maxBufferSize) {
+            this.logBuffer.shift();
+        }
+
+        const formatted = this.formatLogEntry(logEntry);
+
+        if (this.console) {
+            console.log(formatted);
+        }
+
+        if (this.file) {
+            this.writeToFile(formatted);
+        }
+    }
+
+    /**
+     * Format log entry
+     */
+    formatLogEntry(entry) {
+        if (this.format === 'json') {
+            return JSON.stringify(entry);
+        }
+
+        let output = '';
+
+        // Timestamp
+        if (entry.timestamp) {
+            output += `[${entry.timestamp}] `;
+        }
+
+        // Level
+        const levelUpper = entry.level.toUpperCase();
+        if (this.colors) {
+            output += `${this.colorsMap[entry.level]}${levelUpper}${this.colorsMap.reset} `;
+        } else {
+            output += `${levelUpper} `;
+        }
+
+        // Message
+        output += entry.message;
+
+        // Context
+        if (Object.keys(entry.context).length > 0) {
+            output += ` ${JSON.stringify(entry.context)}`;
+        }
+
+        return output;
+    }
+
+    /**
+     * Записать в файл
+     */
+    writeToFile(formatted) {
+        try {
+            if (!existsSync(this.file)) {
+                mkdirSync(dirname(this.file), { recursive: true });
+            }
+            appendFileSync(this.file, formatted + '\n', 'utf-8');
+        } catch (error) {
+            console.error('Ошибка записи лога:', error);
+        }
+    }
+
+    /**
+     * Debug
+     */
+    debug(message, context) {
+        this.log('debug', message, context);
+    }
+
+    /**
+     * Info
+     */
+    info(message, context) {
+        this.log('info', message, context);
+    }
+
+    /**
+     * Warn
+     */
+    warn(message, context) {
+        this.log('warn', message, context);
+    }
+
+    /**
+     * Error
+     */
+    error(message, context) {
+        this.log('error', message, context);
+    }
+
+    /**
+     * Создать child logger с контекстом
+     */
+    child(context) {
+        const child = new Logging({
+            level: this.level,
+            format: this.format,
+            file: this.file,
+            console: this.console,
+            colors: this.colors,
+            timestamp: this.timestamp
+        });
+
+        child.defaultContext = { ...this.defaultContext, ...context };
+
+        const originalLog = child.log.bind(child);
+        child.log = (level, message, context) => {
+            originalLog(level, message, { ...this.defaultContext, ...context });
+        };
+
+        return child;
+    }
+
+    /**
+     * Создать logger с уровнем
+     */
+    withLevel(level) {
+        const logger = new Logging({
+            level,
+            format: this.format,
+            file: this.file,
+            console: this.console,
+            colors: this.colors,
+            timestamp: this.timestamp
+        });
+
+        return logger;
+    }
+
+    /**
+     * Установить уровень логирования
+     */
+    setLevel(level) {
+        this.level = level;
+        return this;
+    }
+
+    /**
+     * Получить буфер логов
+     */
+    getLogs() {
+        return [...this.logBuffer];
+    }
+
+    /**
+     * Очистить буфер логов
+     */
+    clearLogs() {
+        this.logBuffer = [];
+        return this;
+    }
+
+    /**
+     * Экспорт логов
+     */
+    exportLogs(format = 'json') {
+        if (format === 'json') {
+            return JSON.stringify(this.logBuffer, null, 2);
+        } else {
+            return this.logBuffer.map(entry => this.formatLogEntry(entry)).join('\n');
+        }
+    }
+
+    /**
+     * Фильтр логов по уровню
+     */
+    filterLogs(level) {
+        const minLevel = this.levels[level];
+        return this.logBuffer.filter(entry => this.levels[entry.level] >= minLevel);
+    }
+
+    /**
+     * Фильтр логов по времени
+     */
+    filterLogsByTime(startTime, endTime) {
+        return this.logBuffer.filter(entry => {
+            if (!entry.timestamp) return true;
+            const time = new Date(entry.timestamp).getTime();
+            return time >= startTime.getTime() && time <= endTime.getTime();
+        });
+    }
+
+    /**
+     * Создать logger с метриками
+     */
+    static withMetrics(logger) {
+        const metrics = {
+            debug: 0,
+            info: 0,
+            warn: 0,
+            error: 0
+        };
+
+        const originalLog = logger.log.bind(logger);
+        logger.log = (level, message, context) => {
+            metrics[level]++;
+            originalLog(level, message, context);
+        };
+
+        logger.getMetrics = () => metrics;
+
+        return logger;
+    }
+
+    /**
+     * Создать logger с ротацией файлов
+     */
+    static withFileRotation(logger, options = {}) {
+        const maxSize = options.maxSize || 1024 * 1024; // 1MB
+        const maxFiles = options.maxFiles || 5;
+
+        const checkAndRotate = () => {
+            if (!logger.file) return;
+
+            try {
+                const stats = require('fs').statSync(logger.file);
+                if (stats.size > maxSize) {
+                    // Ротация файлов
+                    for (let i = maxFiles - 1; i >= 1; i--) {
+                        const oldFile = i === 1 ? logger.file : `${logger.file}.${i - 1}`;
+                        const newFile = `${logger.file}.${i}`;
+
+                        try {
+                            require('fs').renameSync(oldFile, newFile);
+                        } catch (e) {}
+                    }
+
+                    // Создать новый файл
+                    require('fs').writeFileSync(logger.file, '', 'utf-8');
+                }
+            } catch (e) {}
+        };
+
+        // Перехватить writeToFile
+        const originalWrite = logger.writeToFile.bind(logger);
+        logger.writeToFile = (formatted) => {
+            checkAndRotate();
+            originalWrite(formatted);
+        };
+
+        return logger;
+    }
+
+    /**
+     * Создать logger с цветным выводом
+     */
+    static withColors(logger) {
+        logger.colors = true;
+        return logger;
+    }
+
+    /**
+     * Создать logger без цветов
+     */
+    static withoutColors(logger) {
+        logger.colors = false;
+        return logger;
+    }
+}
+
+export default Logging;