redput 4.5.0 → 4.7.0

package/ChangeLog

@@ -1,3 +1,17 @@
+2026.08.30, v4.7.0
+
+feature:
+- 8748c6b redput: insert-rule-link: add
+
+2026.08.29, v4.6.0
+
+fix:
+- fb923e2 write-readme: code blocks
+- fa39c1f redput: write: write-readme: insert-rule-section: multiline fixtures
+
+feature:
+- bb59d23 insert-rule-section: add
+
 2026.06.26, v4.5.0
 
 feature:

package/lib/compile-rule/compile-rule.js

@@ -0,0 +1,56 @@
+import {putout} from 'putout';
+import * as pluginConvertEsmToCommonjs from '@putout/plugin-nodejs/convert-esm-to-commonjs';
+import * as pluginOptionalChaining from '@putout/plugin-optional-chaining';
+import * as pluginPutout from '@putout/plugin-putout';
+import * as pluginDeclare from '@putout/plugin-declare';
+import * as pluginTypes from '@putout/plugin-types';
+import * as pluginDeclareBeforeReference from '@putout/plugin-declare-before-reference';
+import * as pluginNodejs from '@putout/plugin-nodejs';
+import * as pluginDestructuring from '@putout/plugin-destructuring';
+import * as pluginMaybe from '@putout/plugin-maybe';
+import * as pluginVariables from '@putout/plugin-variables';
+import * as pluginConditions from '@putout/plugin-conditions';
+import protectFromLoops from './protect-from-loops/protect-from-loops.js';
+
+export const compileRule = (code, globals = {}) => {
+    const exports = {};
+    const module = {
+        exports,
+    };
+    
+    const keys = [
+        'module',
+        'exports',
+        ...Object.keys(globals),
+    ];
+    
+    const values = [
+        module,
+        exports,
+        ...Object.values(globals),
+    ];
+    
+    const {code: compiled} = putout(code, {
+        fixCount: 10,
+        plugins: [
+            ['declare', pluginDeclare],
+            ['declare-before-reference', pluginDeclareBeforeReference],
+            ['destructuring/merge-properties', pluginDestructuring.rules['merge-properties']],
+            ['variables/extract-keywords', pluginVariables.rules['extract-keywords']],
+            ['putout', pluginPutout],
+            ['maybe', pluginMaybe],
+            ['types', pluginTypes],
+            ['conditions', pluginConditions],
+            ['variables/convert-const-to-let', pluginVariables.rules['convert-const-to-let']],
+            ['optional-chaining', pluginOptionalChaining],
+            ['nodejs/declare-after-require', pluginNodejs.rules['declare-after-require']],
+            ['nodejs/convert-esm-to-commonjs', pluginConvertEsmToCommonjs],
+        ],
+    });
+    
+    const safe = protectFromLoops(compiled);
+    
+    new Function(keys.join(), safe).apply(exports, values);
+    
+    return module.exports;
+};

package/lib/compile-rule/protect-from-loops/protect-from-loops.js

@@ -0,0 +1,19 @@
+import halts, {loopProtect} from 'halting-problem';
+
+const TIMEOUT = 10 * 1000;
+
+export default function protectFromLoops(jsCode) {
+    halts(jsCode);
+    
+    const start = Date.now();
+    
+    jsCode = loopProtect(jsCode, [
+        '(function (line) {',
+        'if (Date.now() > ' + (start + TIMEOUT) + ') {',
+        '  throw new Error("Infinite loop detected on line " + line);',
+        '}',
+        '})',
+    ].join(''));
+    
+    return jsCode;
+}

package/lib/redput.js

@@ -40,6 +40,7 @@ export const redput = async (link, {token}) => {
         rule,
         fixture,
         report,
+        link,
     });
     
     if (errorWrite)

package/lib/run-rule/run-rule.js

@@ -0,0 +1,28 @@
+import path from 'node:path';
+import {putout} from 'putout';
+import {compileRule} from '../compile-rule/compile-rule.js';
+
+const noop = () => '';
+
+export const runRule = (ruleSource, source) => {
+    const plugin = compileRule(ruleSource, {
+        require: (name) => {
+            if (name === 'path' || name === 'node:path')
+                return path;
+            
+            return putout;
+        },
+    });
+    
+    plugin.report = plugin.report ?? noop;
+    
+    const {code} = putout(source, {
+        cache: false,
+        fixCount: 1,
+        plugins: [
+            ['run-rule', plugin],
+        ],
+    });
+    
+    return code;
+};

package/lib/write/index.js

@@ -1,6 +1,8 @@
 import {access} from 'node:fs/promises';
 import {tryToCatch} from 'try-to-catch';
 import {isTSCode} from './is-ts/index.js';
+import {runRule} from '../run-rule/run-rule.js';
+import {writeReadme} from './nested/write-readme/write-readme.js';
 import {
     updateNestedIndex,
     updateOverallNestedFixtures,
@@ -15,7 +17,7 @@ import {
     writeTests,
 } from './simple.js';
 
-export const writePlugin = async (name, {rule, fixture, report, options}) => {
+export const writePlugin = async (name, {rule, fixture, report, options, link}) => {
     const [isNested] = await tryToCatch(access, './package.json');
     
     if (isNested)
@@ -24,6 +26,7 @@ export const writePlugin = async (name, {rule, fixture, report, options}) => {
             fixture,
             report,
             options,
+            link,
         });
     
     await writeSimple(name, {
@@ -33,25 +36,29 @@ export const writePlugin = async (name, {rule, fixture, report, options}) => {
     });
 };
 
-export const writeNested = async (name, {rule, fixture, report, options}) => {
+export const writeNested = async (name, {rule, fixture, report, options, link}) => {
     const isTS = isTSCode(fixture);
     const ext = isTS ? 'ts' : 'js';
+    const correct = runRule(rule, fixture);
     
     await writeNestedRule(name, rule, options);
-    await writeNestedFixtures(name, fixture, ext);
+    await writeNestedFixtures(name, fixture, ext, correct);
     await writeNestedTests(name, report);
     
     await tryToCatch(writeNestedOptional, name, {
         options,
         fixture,
         ext,
+        correct,
+        link,
     });
 };
 
-export const writeNestedOptional = async (name, {options, fixture, ext}) => {
+export const writeNestedOptional = async (name, {options, fixture, ext, correct, link}) => {
     await updateNestedIndex(name, options);
-    await updateOverallNestedFixtures(name, fixture, ext);
+    await updateOverallNestedFixtures(name, fixture, ext, correct);
     await updateOverallNestedTest(name);
+    await writeReadme(name, link, correct, fixture);
 };
 
 export const writeSimple = async (name, {rule, fixture, report}) => {

package/lib/write/nested/nested.js

@@ -26,13 +26,18 @@ export const writeNestedRule = async (name, data) => {
     await writeFile(`./${name}/index.js`, code);
 };
 
-export const writeNestedFixtures = async (name, data, ext) => {
-    await mkdir(`./${name}/fixture`, {
+export const writeNestedFixtures = async (name, data, ext, correct, overrides = {}) => {
+    const {
+        write = writeFile,
+        mkdir: makeDir = mkdir,
+    } = overrides;
+    
+    await makeDir(`./${name}/fixture`, {
         recursive: true,
     });
     
-    await writeFile(`./${name}/fixture/${name}.${ext}`, data);
-    await writeFile(`./${name}/fixture/${name}-fix.${ext}`, data);
+    await write(`./${name}/fixture/${name}.${ext}`, data);
+    await write(`./${name}/fixture/${name}-fix.${ext}`, correct ?? data);
 };
 
 export const writeNestedTests = async (name, report) => {
@@ -86,7 +91,9 @@ export const updateOverallNestedTest = async (name) => {
     await writeFile(`../test/${plugin}.js`, code);
 };
 
-export const updateOverallNestedFixtures = async (name, data, ext) => {
-    await writeFile(`../test/fixture/${name}.${ext}`, data);
-    await writeFile(`../test/fixture/${name}-fix.${ext}`, data);
+export const updateOverallNestedFixtures = async (name, data, ext, correct, overrides = {}) => {
+    const {write = writeFile} = overrides;
+    
+    await write(`../test/fixture/${name}.${ext}`, data);
+    await write(`../test/fixture/${name}-fix.${ext}`, correct ?? data);
 };

package/lib/write/nested/write-readme/insert-rule-link/index.js

@@ -0,0 +1,58 @@
+import {template, operator} from 'putout';
+
+const {
+    compare,
+    __markdown,
+    insertAfter,
+} = operator;
+
+export const report = ({name}) => `insert '#${name}' link to Rules`;
+
+export const fix = ({name, rules}) => {
+    const nodeLink = template.ast(`ul(li('✅ ', link('${name}', '#${name}')))`);
+    insertAfter(rules, nodeLink);
+};
+
+export const traverse = ({options, push}) => {
+    const {name = 'hello'} = options;
+    
+    return {
+        [__markdown]: (path) => {
+            const elements = path.get('arguments.0.elements');
+            const {rules, link} = parseElements(elements, name);
+            
+            if (link)
+                return;
+            
+            if (!rules)
+                return;
+            
+            push({
+                path,
+                name,
+                rules,
+            });
+        },
+    };
+};
+
+function parseElements(elements, name) {
+    let link;
+    let rules;
+    
+    for (const element of elements) {
+        if (compare(element, `ul(li('✅ ', link('${name}', '#${name}')))`)) {
+            link = element;
+            continue;
+        }
+        
+        if (compare(element, `heading(2, 'Rules')`))
+            rules = element;
+    }
+    
+    return {
+        link,
+        rules,
+    };
+}
+

package/lib/write/nested/write-readme/insert-rule-section/index.js

@@ -0,0 +1,87 @@
+import {template, operator} from 'putout';
+
+const {
+    compare,
+    __markdown,
+    remove,
+} = operator;
+
+export const report = ({name}) => `Insert '${name}' to 'README.md'`;
+
+export const fix = ({name, link, license, correct, incorrect}) => {
+    const {elements} = license.parentPath.node;
+    
+    const heading = template.ast(`heading(2, '${name}')`);
+    const paragraph = template.ast(`paragraph('Checkout in 🐊', link(bold('Putout Editor'), '${link}'), '.')`);
+    const headingIncorrect = template.ast(`heading(3, '❌ Example of incorrect code')`);
+    const codeIncorrect = template.ast(`codeblock('js', \`${incorrect}\`)`);
+    const headingCorrect = template.ast(`heading(3, '✅ Example of correct code')`);
+    const codeCorrect = template.ast(`codeblock('js', \`${correct}\`)`);
+    
+    const licenseType = license.getNextSibling();
+    
+    elements.push(...[
+        heading,
+        paragraph,
+        headingIncorrect,
+        codeIncorrect,
+        headingCorrect,
+        codeCorrect,
+        license.node,
+        licenseType.node,
+    ]);
+    
+    remove(licenseType);
+    remove(license);
+};
+
+export const traverse = ({options, push}) => {
+    const {
+        name,
+        link,
+        correct = '',
+        incorrect = '',
+    } = options;
+    
+    return {
+        [__markdown]: (path) => {
+            const elements = path.get('arguments.0.elements');
+            const {license, ruleSection} = parseElements(elements, name);
+            
+            if (ruleSection)
+                return;
+            
+            if (!license)
+                return;
+            
+            push({
+                path,
+                name,
+                link,
+                license,
+                correct,
+                incorrect,
+            });
+        },
+    };
+};
+
+function parseElements(elements, name) {
+    let license;
+    let ruleSection;
+    
+    for (const element of elements) {
+        if (compare(element, 'heading(2, "License")')) {
+            license = element;
+            continue;
+        }
+        
+        if (compare(element, `heading(2, '${name}')`))
+            ruleSection = element;
+    }
+    
+    return {
+        license,
+        ruleSection,
+    };
+}

package/lib/write/nested/write-readme/write-readme.js

@@ -0,0 +1,55 @@
+import {readFile, writeFile} from 'node:fs/promises';
+import {join} from 'node:path';
+import process from 'node:process';
+import {putout} from 'putout';
+import {branch, merge} from '@putout/processor-markdown';
+import * as insertRuleSection from './insert-rule-section/index.js';
+import * as insertRuleLink from './insert-rule-link/index.js';
+
+const README = 'README.md';
+const getSource = (a) => a.source;
+
+export const writeReadme = async (name, link, correct, incorrect, overrides = {}) => {
+    const {
+        read = readFile,
+        write = writeFile,
+        cwd = process.cwd(),
+    } = overrides;
+    
+    const readmePath = join(cwd, '..', README);
+    const readme = await read(readmePath, 'utf8');
+    
+    const list = await branch(readme);
+    const [{source}] = list;
+    
+    const {code} = putout(source, {
+        rules: {
+            'insert-rule-section': ['on', {
+                name,
+                link,
+                correct,
+                incorrect,
+            }],
+            'insert-rule-link': ['on', {
+                name,
+            }],
+        },
+        plugins: [
+            ['insert-rule-section', insertRuleSection],
+            ['insert-rule-link', insertRuleLink],
+        ],
+    });
+    
+    const newList = [
+        code,
+        ...list
+            .slice(1)
+            .map(getSource),
+        incorrect,
+        correct,
+    ];
+    
+    const result = await merge(source, newList);
+    
+    await write(readmePath, result);
+};

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "redput",
-  "version": "4.5.0",
+  "version": "4.7.0",
   "description": "CLI tool to convert source from 🐊Putout Editor to files",
   "main": "lib/redput.js",
   "bin": {
     "redput": "bin/redput.js"
   },
   "exports": {
-    "./plugin/get-report": "./lib/get-report/plugin-get-report/index.js"
+    "./plugin/get-report": "./lib/get-report/plugin-get-report/index.js",
+    "./compile-rule": "./lib/compile-rule/compile-rule.js"
   },
   "type": "module",
   "scripts": {
@@ -55,10 +56,17 @@
   "dependencies": {
     "@putout/plugin-declare": "^8.0.0",
     "@putout/plugin-declare-before-reference": "^10.1.0",
+    "@putout/plugin-conditions": "^9.2.1",
+    "@putout/plugin-destructuring": "^2.1.1",
     "@putout/plugin-esm": "^10.0.0",
+    "@putout/plugin-maybe": "^5.1.0",
     "@putout/plugin-nodejs": "^21.0.0",
+    "@putout/plugin-optional-chaining": "^3.0.1",
     "@putout/plugin-putout": "^29.0.0",
+    "@putout/plugin-types": "^10.6.0",
     "@putout/plugin-variables": "^2.2.0",
+    "@putout/processor-markdown": "^14.0.5",
+    "halting-problem": "^1.1.0",
     "node-fetch": "^3.3.2",
     "octokit": "^5.0.3",
     "putout": "^42.0.5",