Cross-Check. File-Manager

README.md

@@ -1 +1,90 @@
-# node-nodejs-FileManager
+# node-nodejs: File Manager 
+
+### Description 
+The file manager can do the following:
+- Operate using the CLI
+- Perform basic file operations (copy, move, delete, rename, etc.)
+- Use Streams API
+- Get information about the operating system of the host machine
+- Perform hash calculations
+- Compress and decompress files
+### How to run
+```bash
+npm run start -- --username=your_username
+```
+### List of operations and their syntax:
+- Navigation & working directory (nwd)
+    - Go upper from current directory 
+    ```bash
+    up
+    ```
+    - Go to dedicated folder from current directory (`path_to_directory` can be relative or absolute)
+    ```bash
+    cd path_to_directory
+    ```
+    - List all files and folder in current directory and print it to console
+    ```bash
+    ls
+    ```
+- Basic operations with files
+    - Read file and print it's content in console:
+    ```bash
+    cat path_to_file
+    ```
+    - Create empty file in current working directory:
+    ```bash
+    add new_file_name
+    ```
+    - Rename file:
+    ```bash
+    rn path_to_file new_filename
+    ```
+    - Copy file:
+    ```bash
+    cp path_to_file path_to_new_directory
+    ```
+    - Move file (same as copy but initial file is deleted):
+    ```bash
+    mv path_to_file path_to_new_directory
+    ```
+    - Delete file:
+    ```bash
+    rm path_to_file
+    ```
+- Operating system info (prints following information in console)
+    - Get EOL (default system End-Of-Line)
+    ```bash
+    os --EOL
+    ```
+    - Get host machine CPUs info (overall amount of CPUS plus model and clock rate (in GHz) for each of them)
+    ```bash
+    os --cpus
+    ```
+    - Get home directory:
+    ```bash
+    os --homedir
+    ```
+    - Get current *system user name* 
+    ```bash
+    os --username
+    ```
+    - Get CPU architecture for which Node.js binary has compiled
+    ```bash
+    os --architecture
+    ```
+- Hash calculation
+    - Calculate hash for file and print it into console
+    ```bash
+    hash path_to_file
+    ```
+- Compress and decompress operations
+    - Compress file (using Brotli algorithm)
+    ```bash
+    compress path_to_file path_to_destination
+    ```
+    - Decompress file (using Brotli algorithm)
+    ```bash
+    decompress path_to_file path_to_destination
+    ```
+  _If the second `path_to_destination` parameter is not specified, the operation will be performed in the current directory_
+

index.js

@@ -0,0 +1,102 @@
+import * as readline from 'node:readline';
+import { getUserName } from './src/cli/getUserName.js';
+import { goUpDirectory,goToDirectory, getListDirectory } from "./src/nav/navigation.js";
+import { readFile } from "./src/files/readFile.js";
+import { createFile } from "./src/files/createFile.js";
+import { renameFile } from "./src/files/renameFile.js";
+import { copyFile } from "./src/files/copyFile.js";
+import { moveFile } from "./src/files/moveFile.js";
+import { osCommandHandler } from "./src/os/os.js";
+import { calcHash } from "./src/hash/calcHash.js";
+import { compressFile } from "./src/zip/compress.js";
+import { decompressFile } from "./src/zip/decompress.js";
+import { deleteFile } from "./src/files/deleteFile.js";
+
+const { stdin, stdout, cwd } = process;
+const homeDirectory = process.env["HOME"];
+const userName = getUserName();
+const readLineInterface = readline.createInterface({ input: stdin, output: stdout });
+
+const printCurrentDir = () => process.stdout.write(`You are currently in \x1b[33m${cwd()}\n\x1b[0m`);
+
+(function sayHi () {
+    process.chdir(homeDirectory);
+    stdout.write(`Welcome to the File Manager, \x1b[35m${userName}!\n\x1b[0m`);
+    printCurrentDir();
+})();
+
+
+readLineInterface.on('line', async (line) => {
+
+    const path = line.split(' ').slice(1);
+    const pathFile = path[0] || false;
+    const fileName = path[1] || false;
+    const pathDestination = path[1] || path[0];
+
+    const command = line.split(' ')[0];
+
+    switch (command) {
+        case 'up' :
+            await goUpDirectory();
+            printCurrentDir();
+           break;
+        case 'cd' :
+            await goToDirectory(pathFile);
+            printCurrentDir();
+            break;
+        case 'ls' :
+            await getListDirectory();
+            printCurrentDir();
+            break;
+        case 'cat' :
+            await readFile(pathFile);
+            printCurrentDir();
+            break;
+        case 'add' :
+            await createFile(pathFile);
+            printCurrentDir();
+            break;
+        case 'rn' :
+            await renameFile(pathFile, fileName);
+            printCurrentDir();
+            break;
+        case 'cp' :
+            await copyFile(pathFile, pathDestination);
+            printCurrentDir();
+            break;
+        case 'mv' :
+            await moveFile(pathFile, pathDestination);
+            printCurrentDir();
+            break;
+        case 'rm' :
+            await deleteFile(pathFile);
+            printCurrentDir();
+            break;
+        case 'os' :
+            await osCommandHandler(pathFile);
+            printCurrentDir();
+            break;
+        case 'hash' :
+            await calcHash(pathFile);
+            printCurrentDir();
+            break;
+        case 'compress' :
+            await compressFile(pathFile, pathDestination);
+            printCurrentDir();
+            break;
+        case 'decompress' :
+            await decompressFile(pathFile, pathDestination);
+            printCurrentDir();
+            break;
+        case '.exit' :
+            process.exit();
+            break;
+        default:
+            process.stdout.write('Invalid input\n');
+            printCurrentDir();
+    }
+
+})
+
+process.on('exit', () => process.stdout.write(`Thank you for using File Manager, ${userName}!`));
+process.on('SIGINT', () => process.exit());

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nodejs-filemanager",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Shuvalovrus/node-nodejs-FileManager.git"
+  },
+  "author": "Shuvalov Konstantin",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Shuvalovrus/node-nodejs-FileManager/issues"
+  },
+  "homepage": "https://github.com/Shuvalovrus/node-nodejs-FileManager#readme"
+}

src/cli/getUserName.js

@@ -0,0 +1,14 @@
+export const getUserName = () => {
+
+    let result = 'Stranger';
+
+    process.argv.forEach((item) => {
+
+        const name = item.split('=').pop();
+
+        if (item.startsWith('--username')) result = name ? result : name;
+
+    })
+
+    return result;
+}

src/files/copyFile.js

@@ -0,0 +1,21 @@
+import { createWriteStream, createReadStream } from "fs";
+import { pipeline } from 'stream';
+import { isAbsolute, join, parse } from "path";
+
+export const copyFile = async (toReadPath,toWritePath) => {
+
+    if (!isAbsolute(toReadPath)) toReadPath = join(process.cwd(), toReadPath);
+    toWritePath = join( toWritePath, parse(toReadPath).base) ;
+
+
+    const readStream = createReadStream(toReadPath);
+    const writeStream = createWriteStream(toWritePath);
+
+    await pipeline (
+        readStream,
+        writeStream,
+        (err) => {
+            if (err) console.error('Operation failed');
+        }
+    )
+}

src/files/createFile.js

@@ -0,0 +1,15 @@
+import { createWriteStream } from 'fs';
+import { join } from "path";
+
+export const createFile = async (file) => {
+    try {
+        const path = join( process.cwd(), file );
+
+        await createWriteStream(path).end();
+
+    } catch (err) {
+        console.error('Operation failed');
+    }
+
+
+}

src/files/deleteFile.js

@@ -0,0 +1,13 @@
+import { unlink } from "fs/promises";
+import { isAbsolute, join } from "path";
+
+export const deleteFile = async (path) => {
+    if (!isAbsolute(path)) path = join(process.cwd(), path);
+
+    try {
+        await unlink(path)
+
+    } catch (err) {
+        console.error('Operation failed');
+    }
+}

src/files/moveFile.js

@@ -0,0 +1,12 @@
+import { copyFile } from "./copyFile.js";
+import { deleteFile } from "./deleteFile.js";
+
+export const moveFile = async (toCopyPath, toDestinationPath) => {
+    try {
+        await copyFile(toCopyPath, toDestinationPath);
+        await deleteFile(toCopyPath);
+
+    } catch (err) {
+        console.error('Operation failed');
+    }
+}

src/files/readFile.js

@@ -0,0 +1,18 @@
+import { createReadStream } from 'fs';
+import { finished } from 'stream/promises'
+import { join } from "path";
+
+export const readFile = async (file) => {
+    try {
+        const streamPath = join( process.cwd(), file );
+
+        const readStream = createReadStream(streamPath);
+
+        readStream.on('data', (chunk) => process.stdout.write(chunk + '\n'));
+
+        await finished(readStream);
+
+    } catch (err) {
+        console.error('Operation failed');
+    }
+}

src/files/renameFile.js

@@ -0,0 +1,12 @@
+import { rename } from "fs/promises"
+
+export const renameFile = async (path, fileName) => {
+
+    try {
+
+        await rename(path, fileName);
+
+    } catch (err) {
+        console.error('Operation failed');
+    }
+}

src/hash/calcHash.js

@@ -0,0 +1,28 @@
+import { createReadStream } from "fs";
+import { createHash } from 'crypto'
+import { join } from "path";
+import { finished } from "stream/promises";
+
+export const calcHash = async (path) => {
+
+        try {
+            const readPath = join( process.cwd(), path );
+            const readStream = createReadStream(readPath);
+
+            readStream.on('data', (chunk) => {
+
+                let hash = createHash('sha256');
+                let updateHash = hash.update(chunk);
+                let hexHash = updateHash.digest('hex');
+
+                process.stdout.write(hexHash + '\n');
+
+            })
+
+            await finished(readStream);
+
+        } catch (err) {
+
+            console.error('Operation failed');
+        }
+}

src/nav/navigation.js

@@ -0,0 +1,34 @@
+import { join } from 'path';
+import { readdir } from 'fs/promises';
+import { isAbsolute } from 'path';
+
+export const goUpDirectory = async () => {
+
+    try {
+       await process.chdir(join(process.cwd(), '../'));
+    } catch (err) {
+        console.error('Operation failed');
+    }
+
+}
+
+export const goToDirectory = async (path) => {
+    try {
+        if (!isAbsolute(path)) path = join(process.cwd(), path);
+        await process.chdir(path)
+    } catch (err) {
+        console.error('Operation failed');
+    }
+
+}
+
+export const getListDirectory = async () => {
+
+    try {
+        const result = await readdir(process.cwd());
+        console.log(result);
+    } catch (err) {
+        console.error('Operation failed');
+    }
+
+}