@putout/test 15.0.0 → 15.1.0

package/README.md

@@ -555,6 +555,58 @@ test('putout: processor: css: places', async ({comparePlaces}) => {
 });
 ```
 
+## Filesystem API
+
+```js
+import {test} from '@putout/test/filesystem';
+```
+
+### `equalFilesystem(ast, expected)`
+
+```js
+test('putout: operator: filesystem: findFile: exclude', (t) => {
+    const ast = parseFilesystem([
+        '/',
+        '/hello/',
+        '/hello/world.txt',
+        '/hello/hello.txt',
+    ]);
+    
+    findFile(ast, '*.txt', ['hello.txt']).map(removeFile);
+    
+    const expected = {
+        type: 'directory',
+        filename: '/',
+        files: [{
+            type: 'directory',
+            filename: '/hello',
+            files: [{
+                type: 'file',
+                filename: '/hello/hello.txt',
+            }],
+        }],
+    };
+    
+    t.equalFilesystems(ast, expected);
+    t.end();
+});
+```
+
+### `parseFilesystem(array)`
+
+```js
+test('putout: operator: filesystem: writeFileContent: emoji', (t) => {
+    const ast = parseFilesystem(['/hello/world/', '/hello/world/README.md']);
+    
+    const [filePath] = findFile(ast, 'README.md');
+    writeFileContent(filePath, 'hello 🐊');
+    const content = readFileContent(filePath);
+    
+    t.equal(content, 'hello 🐊');
+    t.end();
+});
+```
+
 ## License
 
 MIT

package/lib/create-error.js

@@ -1,10 +1,9 @@
-'use strict';
+import {codeframe} from 'putout';
 
-const {codeframe} = require('putout');
 const {stringify} = JSON;
 const {entries} = Object;
 
-module.exports.createError = (help, source, values) => {
+export const createError = (help, source, values) => {
     const argsBoxStart = '\n    ╔══\n';
     const argsBoxLine = '    ║';
     const argsBoxEnd = '\n    ╚══\n';

package/lib/filesystem/index.js

@@ -0,0 +1,53 @@
+import {extend} from 'supertape';
+import {parse, print} from 'putout';
+import {
+    toJS,
+    fromJS,
+    __filesystem,
+} from '@putout/operator-json';
+import {parseSimpleFilesystem} from './parse-simple-filesystem.js';
+
+const {isArray} = Array;
+const {stringify} = JSON;
+
+const PRINTER = ['putout', {
+    format: {
+        quote: '"',
+        endOfFile: '',
+    },
+    semantics: {
+        trailingComma: false,
+    },
+}];
+
+export const test = extend({
+    equalFilesystems: ({equal}) => (a, b) => {
+        return equal(printFilesystem(a), formatFilesystem(b));
+    },
+    filesystem: ({deepEqual}) => (a, b) => deepEqual(a, b),
+});
+
+export function parseFilesystem(fs) {
+    if (isArray(fs))
+        fs = parseSimpleFilesystem(fs);
+    
+    const source = toJS(stringify(fs, null, 4), __filesystem);
+    
+    return parse(source);
+}
+
+export function printFilesystem(ast) {
+    const source = print(ast, {
+        printer: PRINTER,
+    });
+    
+    return fromJS(source, __filesystem);
+}
+
+export function formatFilesystem(fs) {
+    const source = print(parseFilesystem(fs), {
+        printer: PRINTER,
+    });
+    
+    return fromJS(source, __filesystem);
+}

package/lib/filesystem/parse-simple-filesystem.js

@@ -0,0 +1,85 @@
+import {dirname} from 'node:path';
+import {operator} from 'putout';
+import {parse, print} from '@putout/engine-parser';
+import {toJS, fromJS} from '@putout/operator-json';
+import {moveFile, findFile} from '@putout/operator-filesystem';
+
+const {replaceWith} = operator;
+const {isArray} = Array;
+const {stringify} = JSON;
+
+const noTrailingSlash = (a) => {
+    if (a === '/')
+        return a;
+    
+    return a.endsWith('/') ? a.slice(0, -1) : a;
+};
+
+const createFile = (filename) => ({
+    type: 'file',
+    filename,
+});
+
+const createFileWithContent = (filename, content) => ({
+    type: 'file',
+    filename,
+    content,
+});
+
+const createDirectory = (filename) => ({
+    type: 'directory',
+    filename,
+    files: [],
+});
+
+const parseFirst = (a) => isArray(a) ? a[0] : a;
+
+export const parseSimpleFilesystem = (list) => {
+    const files = createFlatFiles(list);
+    const js = toJS(stringify(files));
+    const ast = parse(js);
+    
+    const filenames = list
+        .map(parseFirst)
+        .map(noTrailingSlash);
+    
+    const [rootName] = filenames;
+    
+    for (const filename of filenames) {
+        const [filePath] = findFile(ast, filename);
+        const dir = dirname(filename);
+        const [dirPath] = findFile(ast, dir);
+        
+        if (!dirPath)
+            continue;
+        
+        moveFile(filePath, dirPath);
+    }
+    
+    const [rootPath] = findFile(ast, rootName);
+    
+    replaceWith(rootPath.parentPath, rootPath);
+    
+    return JSON.parse(fromJS(print(ast)));
+};
+
+function createFlatFiles(list) {
+    const result = [];
+    
+    for (const file of list) {
+        if (isArray(file)) {
+            const [filename, content] = file;
+            result.push(createFileWithContent(filename, content));
+            continue;
+        }
+        
+        if (file.endsWith('/')) {
+            result.push(createDirectory(noTrailingSlash(file)));
+            continue;
+        }
+        
+        result.push(createFile(file));
+    }
+    
+    return result;
+}

package/lib/fixture.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const process = require('node:process');
-const {tryCatch} = require('try-catch');
+import process from 'node:process';
+import {tryCatch} from 'try-catch';
 
 const isUpdate = () => Boolean(Number(process.env.UPDATE));
 const TS = {
@@ -9,7 +7,7 @@ const TS = {
     DISABLED: false,
 };
 
-module.exports.readFixture = (name, extension) => {
+export const readFixture = (name, extension) => {
     const {readFileSync} = globalThis.__putout_test_fs;
     const [eTS, dataTS] = tryCatch(readFileSync, `${name}.ts`, 'utf8');
     
@@ -43,27 +41,27 @@ module.exports.readFixture = (name, extension) => {
     throw eJS;
 };
 
-module.exports.writeFixFixture = ({full, code, extension}) => {
+export const writeFixFixture = ({full, code, extension}) => {
     const {writeFileSync} = globalThis.__putout_test_fs;
     writeFileSync(`${full}-fix.${extension}`, code);
 };
 
-module.exports.writeFormatFixture = (full, code) => {
+export const writeFormatFixture = (full, code) => {
     const {writeFileSync} = globalThis.__putout_test_fs;
     writeFileSync(`${full}-format`, code);
 };
 
-module.exports.readFormatFixture = (full) => {
+export const readFormatFixture = (full) => {
     const {readFileSync} = globalThis.__putout_test_fs;
     return readFileSync(`${full}-format`, 'utf8');
 };
 
-module.exports.writeFixture = ({full, code, extension}) => {
+export const writeFixture = ({full, code, extension}) => {
     const {writeFileSync} = globalThis.__putout_test_fs;
     writeFileSync(`${full}.${extension}`, code);
 };
 
-module.exports.rmFixture = (name, extension) => {
+export const rmFixture = (name, extension) => {
     const {unlinkSync} = globalThis.__putout_test_fs;
     
     if (!isUpdate())

package/lib/format/index.js

@@ -1,22 +1,18 @@
-'use strict';
-
-const process = require('node:process');
-const {join} = require('node:path');
-
-const putout = require('putout');
-const currify = require('currify');
-const {initReport} = require('@putout/engine-reporter/report');
-
-const {
+import process from 'node:process';
+import {join} from 'node:path';
+import putout from 'putout';
+import currify from 'currify';
+import {initReport} from '@putout/engine-reporter/report';
+import {
     readFixture,
     writeFormatFixture,
     readFormatFixture,
-} = require('../fixture');
+} from '../fixture.js';
 
 const isUpdate = () => Boolean(Number(process.env.UPDATE));
 const {isArray} = Array;
 
-module.exports.format = currify((dir, options, t) => async (formatter, name, formatterOptions = {}) => {
+export const format = currify((dir, options, t) => async (formatter, name, formatterOptions = {}) => {
     const full = join(dir, name);
     const [input, isTS] = readFixture(full);
     
@@ -51,7 +47,7 @@ module.exports.format = currify((dir, options, t) => async (formatter, name, for
     };
 });
 
-module.exports.noFormat = currify((dir, options, t) => async (formatter, name, formatterOptions = {}) => {
+export const noFormat = currify((dir, options, t) => async (formatter, name, formatterOptions = {}) => {
     const full = join(dir, name);
     const [input] = readFixture(full);
     const {places} = putout(input, options);
@@ -73,7 +69,7 @@ module.exports.noFormat = currify((dir, options, t) => async (formatter, name, f
     };
 });
 
-module.exports.formatMany = currify((dir, options, t) => async (formatter, names, formatterOptions = {}) => {
+export const formatMany = currify((dir, options, t) => async (formatter, names, formatterOptions = {}) => {
     const joinTwo = (a) => (b) => join(a, b);
     
     if (!isArray(names))

package/lib/is-correct-plugin.js

@@ -1,10 +1,8 @@
-'use strict';
-
 const isFn = (a) => typeof a === 'function';
 
-module.exports.getIsCorrectPluginMessage = () => `should export 'replace', 'find', 'traverse', 'include', 'exclude', 'declare' or 'scan' function`;
+export const getIsCorrectPluginMessage = () => `should export 'replace', 'find', 'traverse', 'include', 'exclude', 'declare' or 'scan' function`;
 
-module.exports.isCorrectPlugin = (plugin) => {
+export const isCorrectPlugin = (plugin) => {
     const {
         find,
         fix,

package/lib/maybe-directory.js

@@ -0,0 +1,11 @@
+import {fileURLToPath} from 'node:url';
+import {dirname} from 'node:path';
+
+export function maybeDirectory(url) {
+    if (url.startsWith('file:')) {
+        const __filename = fileURLToPath(url);
+        return dirname(__filename);
+    }
+    
+    return url;
+}

package/lib/pre-test.js

@@ -1,9 +1,7 @@
-'use strict';
-
-const {
+import {
     isCorrectPlugin,
     getIsCorrectPluginMessage,
-} = require('./is-correct-plugin');
+} from './is-correct-plugin.js';
 
 const {entries} = Object;
 const {isArray} = Array;
@@ -11,10 +9,10 @@ const {isArray} = Array;
 const maybeTuple = (a) => isArray(a) ? a : ['on', a];
 const maybeEntries = (a) => isArray(a) ? a : entries(a).pop();
 
-module.exports._maybeEntries = maybeEntries;
-module.exports._maybeTuple = maybeTuple;
+export const _maybeEntries = maybeEntries;
+export const _maybeTuple = maybeTuple;
 
-module.exports.preTest = function preTest(test, plugin) {
+export function preTest(test, plugin) {
     const [name, {
         report,
         find,
@@ -82,4 +80,4 @@ module.exports.preTest = function preTest(test, plugin) {
         t.ok(result, getIsCorrectPluginMessage());
         t.end();
     }, options);
-};
+}

package/lib/processor/index.js

@@ -1,22 +1,18 @@
-'use strict';
-
-const {
+import {
     readFile,
     writeFile,
     unlink,
-} = require('node:fs/promises');
-
-const {
+} from 'node:fs/promises';
+import {
     join,
     extname,
     basename,
-} = require('node:path');
-
-const {tryToCatch} = require('try-to-catch');
-
-const test = require('supertape');
-const {initProcessFile} = require('@putout/cli-process-file');
-const {runProcessors} = require('@putout/engine-processor');
+} from 'node:path';
+import {tryToCatch} from 'try-to-catch';
+import test from 'supertape';
+import {initProcessFile} from '@putout/cli-process-file';
+import {runProcessors} from '@putout/engine-processor';
+import {maybeDirectory} from '../maybe-directory.js';
 
 const isStr = (a) => typeof a === 'string';
 const isUpdate = () => Number(globalThis.process.env.UPDATE);
@@ -52,9 +48,11 @@ const fail = (t, message) => {
     return __putout_test_fail(message);
 };
 
-module.exports._addDot = addDot;
+export const _addDot = addDot;
 
-module.exports.createTest = (dir, options) => {
+export const createTest = (url, options) => {
+    const dir = maybeDirectory(url);
+    
     return test.extend({
         process: createProcess(dir, options),
         noProcess: createNoProcess(dir, options),
@@ -89,7 +87,7 @@ const createProcess = (dir, options) => (operator) => async (filename, plugins,
     return operator.equal(processedSource, output, 'fixtures should equal');
 };
 
-module.exports._createProcess = createProcess;
+export const _createProcess = createProcess;
 
 const createNoProcess = (dir, options) => (operator) => async (filename, plugins, processors) => {
     if (!isStr(filename))
@@ -110,7 +108,7 @@ const createNoProcess = (dir, options) => (operator) => async (filename, plugins
     return operator.equal(processedSource, rawSource, 'fixtures should equal');
 };
 
-module.exports._createNoProcess = createNoProcess;
+export const _createNoProcess = createNoProcess;
 
 const createComparePlaces = (dir, options) => (operator) => async (filename, expectedPlaces) => {
     if (!isStr(filename))
@@ -124,7 +122,7 @@ const createComparePlaces = (dir, options) => (operator) => async (filename, exp
     return operator.deepEqual(places, expectedPlaces, 'places should equal');
 };
 
-module.exports._createComparePlaces = createComparePlaces;
+export const _createComparePlaces = createComparePlaces;
 
 async function process(filename, dir, config) {
     let {extension} = config;

package/lib/test.js

@@ -1,36 +1,30 @@
-'use strict';
-
-const process = require('node:process');
-const {join} = require('node:path');
-const {once} = require('node:events');
-
-const {
+import process from 'node:process';
+import {join} from 'node:path';
+import {once} from 'node:events';
+import {
     readFileSync,
     writeFileSync,
     existsSync,
     unlinkSync,
-} = require('node:fs');
-
-const test = require('supertape');
-const putout = require('putout');
-const currify = require('currify');
-const {createProgress} = require('@putout/engine-runner/progress');
-
-const {createError} = require('./create-error');
-const {preTest} = require('./pre-test');
-
-const {
+} from 'node:fs';
+import test from 'supertape';
+import putout from 'putout';
+import currify from 'currify';
+import {createProgress} from '@putout/engine-runner/progress';
+import {createError} from './create-error.js';
+import {preTest} from './pre-test.js';
+import {
     format,
     noFormat,
     formatMany,
-} = require('./format');
-
-const {
+} from './format/index.js';
+import {maybeDirectory} from './maybe-directory.js';
+import {
     readFixture,
     writeFixture,
     writeFixFixture,
     rmFixture,
-} = require('./fixture');
+} from './fixture.js';
 
 const {isArray} = Array;
 const isString = (a) => typeof a === 'string';
@@ -55,8 +49,7 @@ const fail = (t, message) => {
     return __putout_test_fail(message);
 };
 
-module.exports = createTest;
-module.exports.createTest = createTest;
+export default createTest;
 
 const parsePlugin = (plugins) => {
     if (isArray(plugins))
@@ -65,9 +58,8 @@ const parsePlugin = (plugins) => {
     return plugins;
 };
 
-function createTest(dir, maybeOptions, maybeExtends = {}) {
-    dir = join(dir, 'fixture');
-    
+export function createTest(url, maybeOptions, maybeExtends = {}) {
+    const dir = join(maybeDirectory(url), 'fixture');
     const {
         extension = '',
         lint = putout,
@@ -359,7 +351,7 @@ const noReport = (dir, linterOptions, options) => (t) => (name, addons = []) =>
     }, t, source);
 };
 
-module.exports._createNoReport = noReport;
+export const _createNoReport = noReport;
 
 const noReportAfterTransform = currify((dir, linterOptions, options, t, name, addons = {}) => {
     const {lint, extension} = linterOptions;
@@ -372,7 +364,7 @@ const noReportAfterTransform = currify((dir, linterOptions, options, t, name, ad
     }, t, source, addons);
 });
 
-module.exports._createNoReportAfterTransform = noReportAfterTransform;
+export const _createNoReportAfterTransform = noReportAfterTransform;
 
 const noReportAfterTransformWithOptions = currify((dir, linterOptions, options, t, name, ruleOptions) => {
     const {lint, extension} = linterOptions;
@@ -394,7 +386,7 @@ const noReportAfterTransformWithOptions = currify((dir, linterOptions, options,
     }, t, source);
 });
 
-module.exports._createNoReportAfterTransformWithOptions = noReportAfterTransformWithOptions;
+export const _createNoReportAfterTransformWithOptions = noReportAfterTransformWithOptions;
 
 const reportWithOptions = currify((dir, linterOptions, options, t, name, message, ruleOptions) => {
     const {lint, extension} = linterOptions;

package/package.json

@@ -1,24 +1,19 @@
 {
   "name": "@putout/test",
-  "version": "15.0.0",
-  "type": "commonjs",
+  "version": "15.1.0",
+  "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Test runner for 🐊Putout plugins ",
   "homepage": "https://github.com/coderaiser/putout/tree/master/packages/test#readme",
   "main": "lib/test.js",
   "bin": {
-    "tape": "bin/test.mjs"
+    "tape": "bin/test.js"
   },
   "exports": {
-    ".": {
-      "require": "./lib/test.js",
-      "import": "./lib/test.mjs"
-    },
-    "./processor": {
-      "require": "./lib/processor/index.js",
-      "import": "./lib/processor/index.mjs"
-    },
-    "./eslint": "./lib/eslint/eslint.mjs"
+    ".": "./lib/test.js",
+    "./processor": "./lib/processor/index.js",
+    "./eslint": "./lib/eslint/eslint.js",
+    "./filesystem": "./lib/filesystem/index.js"
   },
   "release": false,
   "tag": false,
@@ -39,15 +34,18 @@
   },
   "dependencies": {
     "@putout/cli-process-file": "^6.0.0",
+    "@putout/engine-parser": "^15.0.7",
     "@putout/engine-processor": "*",
     "@putout/engine-reporter": "^8.0.1",
     "@putout/engine-runner": "*",
     "@putout/eslint": "^5.0.0",
+    "@putout/operator-filesystem": "^10.0.4",
+    "@putout/operator-json": "^3.1.0",
     "@putout/plugin-filesystem": "*",
     "currify": "^4.0.0",
     "montag": "^1.2.1",
     "putout": "*",
-    "supertape": "^11.0.3",
+    "supertape": "^12.0.0",
     "try-catch": "^4.0.0",
     "try-to-catch": "^4.0.0"
   },
@@ -72,7 +70,7 @@
     "eslint": "^10.0.0-alpha.0",
     "eslint-plugin-n": "^17.0.0",
     "eslint-plugin-putout": "^29.0.0",
-    "madrun": "^11.0.0",
+    "madrun": "^12.0.0",
     "nodemon": "^3.0.1"
   },
   "license": "MIT",

package/lib/processor/index.mjs

@@ -1,10 +0,0 @@
-import {dirname} from 'node:path';
-import {fileURLToPath} from 'node:url';
-import * as processor from './index.js';
-
-export const createTest = (url, plugins) => {
-    const __filename = fileURLToPath(url);
-    const __dirname = dirname(__filename);
-    
-    return processor.createTest(__dirname, plugins);
-};

package/lib/test.mjs

@@ -1,12 +0,0 @@
-import {dirname} from 'node:path';
-import {fileURLToPath} from 'node:url';
-import create from './test.js';
-
-export default create;
-
-export const createTest = (url, plugins, maybeExtends) => {
-    const __filename = fileURLToPath(url);
-    const __dirname = dirname(__filename);
-    
-    return create(__dirname, plugins, maybeExtends);
-};