London| Elhadj Abdoul Diallo| Module-Tools | WEEK3 - Implement-shell-tools

implement-shell-tools/cat/cat.js

@@ -0,0 +1,55 @@
+import { promises as fs, read } from "node:fs";
+import process from "node:process";
+import { program } from "commander";
+
+program
+  .name("Implement cat")
+  .description("Implement a version of the cat program")
+  .option("-n, --number", "Number the output lines, starting at 1")
+  .option("-b, --number2", "Number the nonempty lines, starting at 1")
+  .argument("<paths...>", "The file paths to process")
+  .parse(process.argv);
+
+let args = program.args;
+
+const nOption = program.opts().number;
+const bOption = program.opts().number2;
+let lineNumber = 1;
+
+async function readAndPrintFileContent(path) {
+  try {
+    const content = await fs.readFile(path, { encoding: "utf-8" });
+    const lines = extractLinesFromContent(content);
+    printLinesWithOptions(lines);
+  } catch (err) {
+    console.error(err.message);
+  }
+}
+
+function extractLinesFromContent(content) {
+  const lines = content.split("\n");
+  if (lines[lines.length - 1] === "") {
+    lines.pop(); // excludes last line if empty
+  }
+  return lines;
+}
+
+function printLinesWithOptions(lines) {
+  lines.forEach((line) => {
+    if (nOption) {
+      console.log(`${lineNumber++} ${line}`);
+      return;
+    }
+
+    if (bOption) {
+      if (line !== "") {
+        console.log(`${lineNumber++} ${line}`);
+        return;
+      }
+    }
+
+    console.log(line);
+  });
+}
+// display file/s contents with line numbers.
+await Promise.all(args.map(readAndPrintFileContent));

implement-shell-tools/ls/ls.js

@@ -0,0 +1,47 @@
+/**
+ * Reads the contents of the specified directories and outputs the file names.
+ * Supports options for displaying hidden files and listing each file on a new line.
+ *
+ * @param {string[]} filePaths - The paths to be processed. Defaults to the current directory if no argument is provided.
+ * @param {boolean} one - If true, outputs each file and directory on a new line.
+ * @param {boolean} hidden - If true, includes hidden files and directories in the output.
+ */
+import process from "node:process";
+import { promises as fs } from "node:fs";
+import { program } from "commander";
+
+program
+  .name("Implement ls")
+  .description("Implements a version of the ls command")
+  .option("-1, --one", "Output all files and directories each in a line")
+  .option("-a, --hidden", "Output hidden files/directories")
+  .argument("[paths...]", "the paths to be processed")
+  .parse(process.argv);
+
+const filePaths = program.args.length ? program.args : ["."];
+
+const one = program.opts().one;
+const hidden = program.opts().hidden;
+
+async function listDirectoryContents(filePath) {
+  try {
+    const files = await fs.readdir(filePath, { withFileTypes: true }); // is returned as a Dirent
+    const filteredFiles = files
+      .filter((file) => hidden || !file.name.startsWith("."))
+      .map((file) => file.name);
+
+    if (hidden) {
+      filteredFiles.unshift(".", "..");
+    }
+
+    if (one) {
+      filteredFiles.forEach((file) => console.log(file));
+    } else {
+      console.log(filteredFiles.join(" "));
+    }
+  } catch (err) {
+    console.error(`Error reading directory ${filePath}:`, err.message);
+  }
+}
+
+filePaths.map(listDirectoryContents);

implement-shell-tools/wc/wc.js

@@ -0,0 +1,103 @@
+import { program } from "commander";
+import process from "node:process";
+import { promises as fs } from "node:fs";
+
+program
+  .name("Implement wc")
+  .description("Implements a version of the wc command")
+  .option("-l, --line", "Counts file lines")
+  .option("-c, --char", "Counts characters in file")
+  .option("-w, --word", "Counts words in file")
+  .argument("[paths...]", "The path/s to process")
+  .parse(process.argv);
+
+const args = program.args;
+
+function removeEndEmptyLine(arr) {
+  return arr[arr.length - 1] === "" ? arr.slice(0, -1) : arr;
+}
+
+const lineOption = program.opts().line;
+const charOption = program.opts().char;
+const wordOption = program.opts().word;
+
+async function countLinesWordsCharsInFile(path) {
+  const content = await fs.readFile(path, { encoding: "utf-8" });
+
+  const lines = removeEndEmptyLine(content.split("\n"));
+
+  const words = lines.flatMap((element) =>
+    element.split(" ").filter((word) => word !== "")
+  );
+
+  const chars = content.split("");
+
+  const numberOfLines = lines.length;
+  const numberOfWords = words.length;
+  const numberOFChars = chars.length;
+
+  if (lineOption) {
+    return `${numberOfLines} ${path}`;
+  }
+
+  if (charOption) {
+    return `${numberOFChars} ${path}`;
+  }
+
+  if (wordOption) {
+    return `${numberOfWords} ${path}`;
+  }
+
+  return `${numberOfLines} ${numberOfWords} ${numberOFChars} ${path}`;
+}
+
+async function processFilesAndDisplayCounts() {
+  const fileCounts = await Promise.all(args.map(countLinesWordsCharsInFile));
+  fileCounts.forEach((fileCount) => console.log(fileCount));
+
+  const aggregatedFilesData = aggregateFileData(fileCounts);
+
+  if (aggregatedFilesData !== 0 && lineOption) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+  if (aggregatedFilesData !== 0 && wordOption) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+  if (aggregatedFilesData !== 0 && charOption) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+  aggregatedFilesData !== 0
+    ? console.log(
+        `${aggregatedFilesData[0]} ${aggregatedFilesData[1]} ${aggregatedFilesData[2]} total`
+      )
+    : null;
+}
+
+/**
+ * Aggregates numerical data from an array of file content strings.
+ *
+ * @param {string[]} files - An array of strings, each representing the content of a file.
+ * Each string should contain space-separated numbers.
+ * @returns {number[]|number} - An array of sums for each column of numbers if there are multiple files,
+ * or 0 if there is only one file.
+ */
+function aggregateFileData(fileCounts) {
+  const digits = fileCounts.map((element) =>
+    element.split(" ").slice(0, -1).map(Number)
+  );
+  const sums =
+    digits.length > 1
+      ? digits[0].map((_, colIndex) =>
+          digits.reduce((sum, row) => sum + row[colIndex], 0)
+        )
+      : 0;
+  return sums;
+}
+
+processFilesAndDisplayCounts();

package.json

@@ -0,0 +1,6 @@
+{
+    "type": "module",
+    "dependencies": {
+        "commander": "^13.1.0"
+    }
+}