@nirguna/plugin-nemesis 1.0.0

package/README.md

@@ -0,0 +1,17 @@
+## putout-plugin-nemesis
+
+Transforms:
+
+- ✅[`convert-get-char-to-int-0xff`](https://putout.cloudcmd.io/#/gist/42fe266583e24b282f0d96e6c9756ac1/8fed2362fa547c025a3cd93b95542747dcebccf3);
+- ✅[`convert-printf-to-int-0xff`](https://putout.cloudcmd.io/#/gist/1d20463027c9f8ef0926d0031a602b5c/c347707d4b5bc41bc764705b36679e55203d7204);
+- ✅[`remove-useless-imports`](https://putout.cloudcmd.io/#/gist/7d513c2f0b80435db5c6191ebd535efe/8c7c6075eb0a9878d223637b0fd86c7d50ea535a);
+- ✅[`convert-set-cursor-to-int-0xff`](https://putout.cloudcmd.io/#/gist/e35f9d22c2e219227e2b06caf9be08d4/81cbdb1367607e9dda83594958ac0d6b346e67eb);
+- ✅[`convert-read-sector-to-int-0xff`](https://putout.cloudcmd.io/#/gist/6ae8820756ba1af043f93f3bdb49360e/0be46185f32f36c3f5126a1af753c3f741388cd0);
+- ✅[`convert-find-file-to-int-0xff`](https://putout.cloudcmd.io/#/gist/2418e874e298b187a04d245a8351f66f/2d2e4b1f8caa652aab613162bd81f0b6e460a1fa);
+- ✅[`convert-set-screen-size-to-0xff`](https://putout.cloudcmd.io/#/gist/38fafd9ef79f96fccbf78966ad912508/a75089d6a7fcd3c96efe36dc1890a54b02ad40e0);
+- ✅[`convert-read-first-to-0xff`](https://putout.cloudcmd.io/#/gist/473ebf06c3a5b17523adca09ca3240a9/dc4e3d59a06be51985d0b002f8199e0f3618274e);
+- ✅[`convert-set-color-to-int-0xff`](https://putout.cloudcmd.io/#/gist/a2dfbe8d6cf1f79328c572d5f10b201c/7b0f12fb1e4a61bac0914e3697eff75678bcb707);
+- ✅[`convert-gets-to-0xff`](https://putout.cloudcmd.io/#/gist/ac0146b899433d90ba83214a20865db0/4fce39e0d68031b05a65a68aa817c29d46560f4f);
+- ✅[`convert-debug-to-printf`](https://putout.cloudcmd.io/#/gist/2bc7d9ead127236ae4593c8abe150538/5993e8fe1355acbab1778f1cf70b2311c21913b1);
+- ✅[`convert-clear-screen-to-int-0xff`](https://putout.cloudcmd.io/#/gist/693fcd438d105d74a243636662d79011/a722a5729204527189e5dc1b2a867e053cf2e0f5);
+- ✅[`remove-useless-declarations`](https://putout.cloudcmd.io/#/gist/9045b99fbb58a53047dec060d3f143cf/646d41281b8010f6b4429b81cc4ba6987c12a041);

package/lib/api.js

@@ -0,0 +1,31 @@
+import {operator, types} from 'putout';
+
+const {isArrayExpression} = types;
+const {extract} = operator;
+
+export const GET_CHAR = 1;
+export const PRINTF = 2;
+export const FIND_FILE = 3;
+export const FIND_FIRST = 5;
+export const SET_COLOR = 6;
+export const SET_CURSOR = 7;
+export const GETS = 8;
+export const SET_MIN_MAX_COL_LINE = 0xb;
+export const READ_SECTOR = 0xc;
+
+export function parseArgs({properties}) {
+    const result = {};
+    
+    for (const {key, value} of properties) {
+        const extracted = extract(value);
+        
+        if (isArrayExpression(value)) {
+            result[key.name] = `[${extracted}]`;
+            continue;
+        }
+        
+        result[key.name] = extracted;
+    }
+    
+    return result;
+}

package/lib/convert-clear-screen-to-int-0xff/index.js

@@ -0,0 +1,12 @@
+export const report = () => `Use '0xff' instead of 'nemesis.clearScreen()'`;
+
+const CLEAR_SCREEN = 9;
+
+export const replace = () => ({
+    'nemesis.clearScreen()': () => {
+        return `{
+            al = ${CLEAR_SCREEN};
+            int(0xff);
+        }`;
+    },
+});

package/lib/convert-debug-to-printf/index.js

@@ -0,0 +1,29 @@
+import {types} from 'putout';
+
+const {isIdentifier} = types;
+
+export const report = () => `Use 'nemesis.printf()' instead of 'debug()'`;
+
+export const match = () => ({
+    'debug(__a)': ({__a}) => isIdentifier(__a),
+});
+
+export const replace = ({options}) => {
+    const {
+        color = 4,
+        background = 0,
+    } = options;
+    
+    return {
+        'debug(__a)': `{
+            pusha();
+            nemesis.setColor({
+                color: ${color},
+                background: ${background},
+            });
+            nemesis.printf(__a);
+            nemesis.setColor();
+            popa();
+        }`,
+    };
+};

package/lib/convert-exec-to-int-0xff/index.js

@@ -0,0 +1,9 @@
+export const report = () => `Use 'int(0xff)' instead of 'nemesis.exec()'`;
+
+export const replace = () => ({
+    'nemesis.exec(__a)': `{
+    	al = 4;
+        bx = __a;
+        int(0xff);
+    }`,
+});

package/lib/convert-find-file-to-int-0xff/index.js

@@ -0,0 +1,12 @@
+import {FIND_FILE} from '../api.js';
+
+export const report = () => `Use 'int(0xff)' instead of 'nemesis.findFile()'`;
+
+export const replace = () => ({
+    '__a = nemesis.findFile(__b)': `{
+        al = ${FIND_FILE};
+        bx = __b;
+        int(0xff);
+        __a = ax;
+    }`,
+});

package/lib/convert-find-first-to-int-0xff/index.js

@@ -0,0 +1,27 @@
+import {FIND_FIRST} from '../api.js';
+
+export const report = () => `Use '0xff' instead of 'nemesis.readSector()'`;
+
+export const match = () => ({
+    'nemesis.findFirst(__a)': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    '__a = nemesis.findFirst(__b)': `{
+        al = ${FIND_FIRST};
+        bx = __b;
+        int(0xff);
+        __a = ax;
+    }`,
+    'nemesis.findFirst(__a)': `{
+        al = ${FIND_FIRST};
+        bx = __a;
+        int(0xff);
+    }`,
+    'nemesis.findFirst()': `{
+        al = ${FIND_FIRST};
+        int(0xff);
+    }`,
+});

package/lib/convert-get-char-to-int-0xff/index.js

@@ -0,0 +1,10 @@
+import {GET_CHAR} from '../api.js';
+
+export const report = () => `Use 'int(0xff)' instead of 'nemesis.getChar()'`;
+
+export const replace = () => ({
+    'nemesis.getChar()': `{
+        al = ${GET_CHAR}
+        int(0xff);
+    }`,
+});

package/lib/convert-gets-to-0xff/index.js

@@ -0,0 +1,16 @@
+import {GETS, parseArgs} from '../api.js';
+
+export const report = () => `Use '0xff' instead of 'nemesis.gets()'`;
+
+export const replace = () => ({
+    'nemesis.gets(__a)': ({__a}) => {
+        const {buffer, size} = parseArgs(__a);
+        
+        return `{
+            bx = ${buffer};
+            cx = ${size};
+            al = ${GETS};
+            int(0xff);
+        }`;
+    },
+});

package/lib/convert-printf-to-int-0xff/index.js

@@ -0,0 +1,11 @@
+export const report = () => `Use 'int(0xff)' instead of 'nemesis.printf()'`;
+
+import {PRINTF} from '../api.js';
+
+export const replace = () => ({
+    'nemesis.printf(__a)': `{
+        al = ${PRINTF}
+        bx = __a;
+        int(0xff);
+    }`,
+});

package/lib/convert-read-sector-to-int-0xff/index.js

@@ -0,0 +1,91 @@
+import {types, operator} from 'putout';
+import {is8bit} from '@nirguna/operator-fasm/regs';
+import {READ_SECTOR} from '../api.js';
+
+export const report = () => `Use '0xff' instead of 'nemesis.readSector()'`;
+
+const {isArrayExpression} = types;
+const {extract} = operator;
+
+export const match = () => ({
+    'nemesis.readSector()': (vars, path) => {
+        return path.parentPath.isExpressionStatement();
+    },
+});
+
+export const replace = () => ({
+    '__a = nemesis.readSector(__object)': ({__object, __a}, path) => {
+        const {line} = path.node.loc.start;
+        const reg = parseReg(__a.name);
+        const {
+            count = 1,
+            buffer = 0,
+            sector = 0,
+            track = 0,
+            disk = 0,
+            head = 0,
+        } = parseArgs(__object.properties);
+        
+        return `{
+            ah = ${count};
+            bx = ${buffer};
+            cl = ${sector};
+            ch = ${track};
+            dl = ${disk};
+            dh = ${head}; 
+            ${createReadSector(line)}
+            mov(__a, ${reg});
+        }`;
+    },
+    '__a = nemesis.readSector()': ({__a}, path) => {
+        const {line} = path.node.loc.start;
+        const reg = parseReg(__a.name);
+        
+        return `{
+            ${createReadSector(line)}
+            mov(__a, ${reg});
+        }`;
+    },
+    'nemesis.readSector()': (vars, path) => {
+        const {line} = path.node.loc.start;
+        return createReadSector(line);
+    },
+});
+
+function createReadSector(line) {
+    return `{
+        al = ${READ_SECTOR};
+        int(0x0ff);
+        jnc(__nirguna_read_sector_ok_${line});
+        al = 1;
+        jmp(__nirguna_read_sector_end_${line});
+        __nirguna_read_sector_ok_${line}:
+        ax = 0
+        __nirguna_read_sector_end_${line}:
+        clc();
+    }`;
+}
+
+function parseReg(name) {
+    if (is8bit(name))
+        return 'al';
+    
+    return 'ax';
+}
+
+function parseArgs(properties) {
+    const result = {};
+    
+    for (const {key, value} of properties) {
+        const extracted = extract(value);
+        
+        if (isArrayExpression(value)) {
+            result[key.name] = `[${extracted}]`;
+            continue;
+        }
+        
+        result[key.name] = extracted;
+    }
+    
+    return result;
+}

package/lib/convert-set-color-to-0xff/index.js

@@ -0,0 +1,49 @@
+import {parseArgs, SET_COLOR} from '../api.js';
+
+const GREEN = 2;
+const BLACK = 0;
+const RED = 12;
+const WHITE = 15;
+const YELLOW = 14;
+
+const prepareColor = (color) => {
+    if (color === 'red')
+        return RED;
+    
+    if (color === 'white')
+        return WHITE;
+    
+    if (color === 'yellow')
+        return YELLOW;
+    
+    return color;
+};
+
+export const report = () => `Use '0xff' instead of 'nemesis.setColor()'`;
+
+export const replace = () => ({
+    'nemesis.setColor()': () => {
+        return `{
+        	cl = ${GREEN}
+            ch = ${BLACK};
+            al = 6;
+            int(0xff);
+        }`;
+    },
+    'nemesis.setColor(__object)': ({__object}) => {
+        const {
+            color = GREEN,
+            background = BLACK,
+        } = parseArgs(__object);
+        
+        const preparedColor = prepareColor(color);
+        const preparedBackground = prepareColor(background);
+        
+        return `{
+        	cl = ${preparedColor}
+            ch = ${preparedBackground};
+            al = ${SET_COLOR};
+            int(0xff);
+        }`;
+    },
+});

package/lib/convert-set-cursor-to-int-0xff/index.js

@@ -0,0 +1,16 @@
+import {parseArgs, SET_CURSOR} from '../api.js';
+
+export const report = () => `Use '0xff' instead of 'nemesis.setCursor'`;
+
+export const replace = () => ({
+    'nemesis.setCursor(__object)': ({__object}) => {
+        const {column, line} = parseArgs(__object);
+        
+        return `{
+            bl = ${column};
+            bh = ${line};
+            al = ${SET_CURSOR};
+            int(0xff);
+        }`;
+    },
+});

package/lib/convert-set-screen-size-to-0xff/index.js

@@ -0,0 +1,25 @@
+import {
+    parseArgs,
+    SET_MIN_MAX_COL_LINE,
+} from '../api.js';
+
+const {parse} = JSON;
+
+export const report = () => `Use '0xff' instead of 'nemesis.setScreenSize()'`;
+
+export const replace = () => ({
+    'nemesis.setScreenSize(__a)': ({__a}) => {
+        const {columns, lines} = parseArgs(__a);
+        const [minColumn, maxColumn] = parse(columns);
+        const [minLine, maxLine] = parse(lines);
+        
+        return `{
+            cl = ${maxColumn};
+            ch = ${maxLine};
+            bl = ${minColumn};
+        	bh = ${minLine};
+            al = ${SET_MIN_MAX_COL_LINE};
+            int(0xff);
+        }`;
+    },
+});

package/lib/index.js

@@ -0,0 +1,31 @@
+import * as convertGetCharToInt0xff from './convert-get-char-to-int-0xff/index.js';
+import * as removeUselessDeclarations from './remove-useless-declarations/index.js';
+import * as convertFindFirstToInt0xff from './convert-find-first-to-int-0xff/index.js';
+import * as convertClearScreenToInt0xff from './convert-clear-screen-to-int-0xff/index.js';
+import * as convertGetsTo0xff from './convert-gets-to-0xff/index.js';
+import * as convertSetScreenSizeTo0xff from './convert-set-screen-size-to-0xff/index.js';
+import * as convertSetColorTo0xff from './convert-set-color-to-0xff/index.js';
+import * as convertDebugToPrintf from './convert-debug-to-printf/index.js';
+import * as convertFindFileToInt0xff from './convert-find-file-to-int-0xff/index.js';
+import * as convertReadSectorToInt0xff from './convert-read-sector-to-int-0xff/index.js';
+import * as convertExecToInt0xff from './convert-exec-to-int-0xff/index.js';
+import * as convertSetCursorToInt0xff from './convert-set-cursor-to-int-0xff/index.js';
+import * as removeUselessImports from './remove-useless-imports/index.js';
+import * as convertPrintfToInt0xff from './convert-printf-to-int-0xff/index.js';
+
+export const rules = {
+    'convert-printf-to-int-0xff': convertPrintfToInt0xff,
+    'remove-useless-imports': removeUselessImports,
+    'convert-set-cursor-to-int-0xff': convertSetCursorToInt0xff,
+    'convert-exec-to-int-0xff': convertExecToInt0xff,
+    'convert-read-sector-to-int-0xff': convertReadSectorToInt0xff,
+    'convert-find-file-to-int-0xff': convertFindFileToInt0xff,
+    'convert-debug-to-printf': convertDebugToPrintf,
+    'convert-set-color-to-0xff': convertSetColorTo0xff,
+    'convert-set-screen-size-to-0xff': convertSetScreenSizeTo0xff,
+    'convert-gets-to-0xff': convertGetsTo0xff,
+    'convert-clear-screen-to-int-0xff': convertClearScreenToInt0xff,
+    'convert-find-first-to-int-0xff': convertFindFirstToInt0xff,
+    'remove-useless-declarations': removeUselessDeclarations,
+    'convert-get-char-to-int-0xff': convertGetCharToInt0xff,
+};

package/lib/remove-useless-declarations/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Avoid useless import of '@nirguna/operator-nemesis'`;
+
+export const replace = () => ({
+    'import __imports from "@nirguna/operator-nemesis"': '',
+});

package/lib/remove-useless-imports/index.js

@@ -0,0 +1,5 @@
+export const report = () => `Avoid imports`;
+
+export const replace = () => ({
+    'import __imports from "@nirguna/operator-nemesis"': '',
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@nirguna/plugin-nemesis",
+  "version": "1.0.0",
+  "type": "module",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "Nirguna plugin adds ability to transform Nemesis",
+  "homepage": "https://github.com/putoutjs/nirguna/tree/master/packages/plugin-nemesis#readme",
+  "main": "lib/index.js",
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/putout.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {
+    "@nirguna/operator-fasm": "^1.0.0"
+  },
+  "keywords": [
+    "putout",
+    "putout-plugin",
+    "plugin",
+    "madrun"
+  ],
+  "devDependencies": {
+    "@putout/test": "^15.1.1",
+    "c8": "^10.0.0",
+    "eslint": "^10.0.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^30.0.2",
+    "madrun": "^12.1.3",
+    "nodemon": "^3.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=41"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}