@putout/plugin-putout 29.25.0 → 29.26.1

package/lib/add-traverse-args/index.js

@@ -88,7 +88,7 @@ const checkArgs = (names, push) => (path) => {
                 name,
             });
         },
-        ['__a(__args)']: (path) => {
+        '__a(__args)': (path) => {
             const {callee} = path.node;
             const {name} = callee;
             

package/lib/declare-template-variables/index.js

@@ -4,9 +4,14 @@ const {
     objectPattern,
     isIdentifier,
     objectProperty,
+    isObjectProperty,
+    isObjectExpression,
 } = types;
 
-const {getBindingPath} = operator;
+const {
+    getBindingPath,
+    getTemplateValues,
+} = operator;
 
 const SHORTHAND = true;
 const COMPUTED = false;
@@ -41,11 +46,20 @@ export const fix = ({path, node}) => {
 export const traverse = ({push}) => ({
     '(__a, path) => __b': process(push),
     '(__a) => __b': process(push),
-    '() => __a': process(push),
+    '() => __b': process(push),
 });
 
 const process = (push) => (path) => {
-    if (!path.parentPath.isObjectProperty())
+    const {parentPath} = path;
+    const {__b} = getTemplateValues(path, '(__args) => __b');
+    
+    if (isObjectExpression(__b))
+        return;
+    
+    if (!parentPath.isObjectProperty())
+        return;
+    
+    if (!isReplacer(path))
         return;
     
     path.traverse({
@@ -66,3 +80,16 @@ const process = (push) => (path) => {
         },
     });
 };
+
+function isReplacer({parentPath}) {
+    const currentPath = parentPath.parentPath.parentPath.parentPath;
+    
+    if (!isObjectProperty(currentPath))
+        return true;
+    
+    const {key} = currentPath.node;
+    
+    return isIdentifier(key, {
+        name: 'replace',
+    });
+}

package/lib/index.js

@@ -1,3 +1,4 @@
+import * as sortReadmeFile from './sort-readme-file/index.js';
 import * as applyStringToPropertyKey from './apply-string-to-property-key/index.js';
 import * as convertTraverseToSuperTraverse from './convert-traverse-to-super-traverse/index.js';
 import * as applyDestructuringToOptions from './apply-destructuring-to-options/index.js';
@@ -176,4 +177,5 @@ export const rules = {
     'apply-destructuring-to-options': applyDestructuringToOptions,
     'convert-traverse-to-super-traverse': convertTraverseToSuperTraverse,
     'apply-string-to-property-key': applyStringToPropertyKey,
+    'sort-readme-file': sortReadmeFile,
 };

package/lib/sort-readme-file/index.js

@@ -0,0 +1,30 @@
+import {operator} from 'putout';
+import * as sortContents from './sort-contents/index.js';
+import * as sortHeadings from './sort-headings/index.js';
+
+const {
+    matchFiles,
+    getFilename,
+    getParentDirectory,
+} = operator;
+
+export const {
+    report,
+    scan,
+    fix,
+} = matchFiles({
+    files: {
+        'README.md': {
+            plugins: [
+                ['sort-contents', sortContents],
+                ['sort-headings', sortHeadings],
+            ],
+        },
+    },
+    exclude: (file) => {
+        const dir = getParentDirectory(file);
+        const dirname = getFilename(dir);
+        
+        return !/plugin-.*$/.test(dirname);
+    },
+});

package/lib/sort-readme-file/sort-contents/index.js

@@ -0,0 +1,69 @@
+import {operator} from 'putout';
+
+const {compareAny} = operator;
+const {entries} = Object;
+
+export const report = () => `Sort 'contents'`;
+
+export const fix = ({path, list}) => {
+    path.node.arguments = list;
+};
+
+export const traverse = ({listStore, push}) => ({
+    'li("✅ ", link(__b, __c), ";")': (path) => {
+        const {parentPath} = path;
+        const prev = parentPath.getPrevSibling();
+        
+        if (!compareAny(prev, [
+            `heading(2, 'Rules')`,
+            `heading(2, 'File rules')`,
+        ]))
+            return;
+        
+        listStore(path);
+    },
+    'Program': {
+        exit() {
+            const list = {};
+            const ids = {};
+            
+            for (const {node, parentPath} of listStore()) {
+                const {line} = parentPath.node.loc.start;
+                
+                ids[line] = parentPath;
+                
+                list[line] = list[line] || [];
+                list[line].push(node);
+            }
+            
+            const sortedList = {};
+            const resultList = [];
+            
+            for (const [ul, currentList] of entries(list)) {
+                sortedList[ul] = currentList.toSorted(asc);
+                
+                for (const [i, current] of sortedList[ul].entries()) {
+                    if (current !== currentList[i]) {
+                        resultList[ul] = sortedList[ul];
+                        break;
+                    }
+                }
+            }
+            
+            for (const [id, list] of entries(resultList)) {
+                push({
+                    path: ids[id],
+                    list,
+                });
+            }
+        },
+    },
+});
+
+function asc(a, b) {
+    return getValue(a).localeCompare(getValue(b));
+}
+
+function getValue(node) {
+    return node.arguments[1].arguments[0].value;
+}

package/lib/sort-readme-file/sort-headings/index.js

@@ -0,0 +1,166 @@
+import {operator, types} from 'putout';
+
+const {
+    getTemplateValues,
+    replaceWithMultiple,
+    remove,
+    compare,
+    __markdown,
+} = operator;
+
+const {arrayExpression} = types;
+
+const MAX_RULE_HEADING = 2;
+const LINK = `li('✅ ', link(__a, __b), ';')`;
+const LIST = 'ul(__args)';
+const HEADING = 'heading(__a, __b)';
+const compareOne = (a) => (b) => compare(b, a);
+
+export const report = ({invalid}) => {
+    if (invalid.length)
+        return `Avoid using rules with heading level more then 2: '### ${invalid[0]}' -> '## ${invalid[0]}'`;
+    
+    return `Sort 'contents'`;
+};
+
+export const fix = ({path, sorted, rulesHeadings, invalid}) => {
+    if (invalid.length)
+        return;
+    
+    packHeadings(path.get('arguments.0.elements'));
+    const {elements} = path.node.arguments[0];
+    
+    for (const [i, current] of rulesHeadings.entries()) {
+        elements.splice(current.key, 1, sorted[i].node);
+    }
+    
+    extractHeadings(path.get('arguments.0.elements'));
+};
+
+export const traverse = ({push}) => ({
+    [__markdown](path) {
+        const elements = path.get('arguments.0.elements');
+        const rules = getRules(elements);
+        
+        const rulesHeadings = getRulesHeadings({
+            elements,
+            rules,
+        });
+        
+        const sorted = rulesHeadings.toSorted(asc);
+        let is = false;
+        
+        for (const [index, heading] of rulesHeadings.entries()) {
+            if (heading !== sorted[index]) {
+                is = true;
+                break;
+            }
+        }
+        
+        if (!is)
+            return;
+        
+        const invalid = validateRulesHeadings({
+            rules,
+            elements,
+        });
+        
+        push({
+            path,
+            rulesHeadings,
+            sorted,
+            invalid,
+        });
+    },
+});
+
+function validateRulesHeadings({rules, elements}) {
+    const invalid = [];
+    
+    for (const element of elements) {
+        if (compare(element, HEADING)) {
+            const {__a, __b} = getTemplateValues(element, HEADING);
+            const {value} = __b;
+            
+            if (!rules.has(value))
+                continue;
+            
+            if (__a.value !== MAX_RULE_HEADING) {
+                invalid.push(value);
+                return invalid;
+            }
+        }
+    }
+    
+    return invalid;
+}
+
+function asc(a, b) {
+    return getValue(a).localeCompare(getValue(b));
+}
+
+const getValue = (path) => path.node.arguments[1].value;
+
+function packHeadings(elements) {
+    let argument;
+    
+    for (const element of elements) {
+        if (isRuleHeading(element)) {
+            argument = arrayExpression([]);
+            element.node.arguments.push(argument);
+            continue;
+        }
+        
+        argument.elements.push(element.node);
+        remove(element);
+    }
+}
+
+function extractHeadings(elements) {
+    for (const element of elements.filter(isRuleHeading)) {
+        const args = element.node.arguments;
+        const argument = args.pop();
+        
+        replaceWithMultiple(element, [element, ...argument.elements]);
+    }
+}
+
+function isRuleHeading(element) {
+    if (!compare(element, 'heading(__args)'))
+        return false;
+    
+    const {__a} = getTemplateValues(element, 'heading(__a, __b)');
+    
+    return __a.value <= MAX_RULE_HEADING;
+}
+
+function getRules(elements) {
+    const rules = new Set();
+    
+    for (const element of elements.filter(compareOne(LIST))) {
+        const args = element.node.arguments;
+        
+        for (const li of args.filter(compareOne(LINK))) {
+            const {__a} = getTemplateValues(li, LINK);
+            rules.add(__a.value);
+        }
+    }
+    
+    return rules;
+}
+
+function getRulesHeadings({rules, elements}) {
+    const headings = [];
+    
+    for (const element of elements) {
+        if (compare(element, HEADING)) {
+            const {__b} = getTemplateValues(element, HEADING);
+            const {value} = __b;
+            
+            if (rules.has(value))
+                headings.push(element);
+        }
+    }
+    
+    return headings;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-putout",
-  "version": "29.25.0",
+  "version": "29.26.1",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin helps with plugins development",