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

.gitignore

@@ -1 +1 @@
-node_modules
+node_modules

implement-shell-tools/cat/cat.js

@@ -0,0 +1,40 @@
+import { promises as fs } 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);
+
+const args = program.args;
+
+const displayLineNumber = program.opts().number;
+const displayNonEmptyLineNumber = program.opts().number2;
+let lineNumber = 1;
+
+async function readAndPrintFileContent(path) {
+  try {
+    const content = await fs.readFile(path, { encoding: "utf-8" });
+    const lines = content.split("\n");
+    lines[lines.length - 1] === "" ? lines.pop() : lines;
+    printLinesWithOptions(lines);
+  } catch (err) {
+    console.error(err.message);
+  }
+}
+
+function printLinesWithOptions(lines) {
+  lines.forEach((line) => {
+    displayLineNumber
+      ? console.log(`${lineNumber++} ${line}`)
+      : displayNonEmptyLineNumber && line !== ""
+      ? console.log(`${lineNumber++} ${line}`)
+      : console.log(line);
+  });
+}
+// display file/s contents with line numbers.
+args.map(readAndPrintFileContent);

implement-shell-tools/ls/ls.js

@@ -0,0 +1,51 @@
+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);
+
+/**
+ * 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.
+ */
+
+const filePaths = program.args.length ? program.args : ["."];
+
+const outputOnePerLine = program.opts().one;
+const includeHiddenFiles = program.opts().hidden;
+
+async function listDirectoryContents(filePath) {
+  try {
+    const files = await fs.readdir(filePath, { withFileTypes: true }); // is returned as a Dirent
+    const output = [];
+
+    files.forEach((file) => {
+      if (includeHiddenFiles || !file.name.startsWith(".")) {
+        output.push(file.name);
+      }
+    });
+
+    if (includeHiddenFiles) {
+      output.unshift(".", "..");
+    }
+
+    outputOnePerLine === true
+      ? output.forEach((file) => console.log(file))
+      : console.log(output.join(" "));
+  } catch (err) {
+    console.error(`Error reading directory ${filePath}:`, err.message);
+  }
+}
+
+//filePaths.map(listDirectoryContents);fi
+filePaths.forEach(listDirectoryContents);

implement-shell-tools/wc/wc.js

@@ -0,0 +1,121 @@
+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;
+
+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 = content.split("\n")
+  lines[lines.length - 1] === "" ? lines.pop() : lines;
+
+  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 && charOption) {
+    return `${numberOfLines} ${numberOfChars} ${path}`;
+  }
+
+  if (lineOption && wordOption) {
+    return `${numberOfLines} ${numberOfWords} ${path}`;
+  }
+
+  if (wordOption && charOption) {
+    return `${numberOfWords} ${numberOfChars} ${path}`;
+  }
+
+  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 && !(wordOption || charOption)) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+  if (aggregatedFilesData !== 0 && charOption && !(wordOption || lineOption)) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+  if (aggregatedFilesData !== 0 && wordOption && !(lineOption || charOption)) {
+    console.log(`${aggregatedFilesData[0]} total`);
+    return;
+  }
+
+
+  if (
+    aggregatedFilesData !== 0 &&
+    ((lineOption && charOption) || (lineOption && wordOption) || (wordOption && charOption))
+  ) {
+    console.log(`${aggregatedFilesData[0]} ${aggregatedFilesData[1]} 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)
+        )
+      : digits[0];
+  return sums;
+}
+
+processFilesAndDisplayCounts();

package.json

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