Refactor 'cat', 'ls', and 'wc' commands for improved readability and functionality

Author: Geraldine-Edwards

implement-shell-tools/cat/cat.js

@@ -2,33 +2,36 @@ import { program } from "commander";
 import { promises as fs } from "node:fs";
 import process from "node:process";
 
+// configure the CLI program with its name, description, arguments, options, and actions (the help instructions)
 // configure the CLI program with its name, description, arguments, options, and actions (the help instructions)
 program
     .name("cat")
     .description("An alternative to the 'cat' command")
     .argument("<files...>", "The file(s) to process") 
     .option("-n, --number", "Number all output lines")
     .option("-b, --number-nonblank", "Number non-blank output lines")
-    // actions to process the provided files with the specified options (-n, -b)
     .action(async (files, options) => {
         try {
-            // call newCat for all files
-            await newCat(files, options.number, options.numberNonblank)
+            await newCat(files, options);
         } catch (err) {
-        console.error(`Error: ${err.message}`);
+            console.error(`Error: ${err.message}`);
         }
-  });
+    });
 
-// parse command-line file arguments using the process.argv array
 program.parse(process.argv);
 
-function printNumberedLine(line, lineNumber) {
-    console.log(`${lineNumber.toString().padStart(6, ' ')}  ${line}`);
-    return lineNumber + 1; 
+//helper function to format output
+function printLine(line, lineNumber, padWidth) {
+    if (lineNumber !== null) {
+        console.log(`${lineNumber.toString().padStart(padWidth, '  ')}  ${line}`);
+    } else {
+        console.log(line);
+    }
 }
 
-async function newCat(files, numberLines, numberNonBlank) {
+async function newCat(files, options) {
     let lineNumber = 1;
+    const padWidth = 6;
 
     for (const file of files) {
         // read each file into a single text string
@@ -43,24 +46,21 @@ async function newCat(files, numberLines, numberNonBlank) {
                 lines.pop();
             }
 
-            for (const line of lines) {
-                if (numberNonBlank) {
-                    // check what is left on the line after trimming (truthy = text, falsy = blank)
-                    if (line.trim()) {
-                    lineNumber = printNumberedLine(line, lineNumber);
-                    }  else {
-                        console.log(line)
-                    } 
-                } else if (numberLines) {
+            lines.forEach(line => {
+                //line trim: truthy = text, falsy = blank
+                if (options.numberNonblank && line.trim()) {
+                    // number non-blank lines only
+                    printLine(line, lineNumber++, padWidth);
+                }  else if (options.number){
                     // number all lines
-                   lineNumber = printNumberedLine(line, lineNumber);
+                    printLine(line, lineNumber++, padWidth);
                 } else {
-                    // if neither flag print normally
-                    console.log(line)
+                    // neither flag, print normally
+                   printLine(line, null, padWidth)
                 }
-            }
+            });
         } catch (err) {
-              console.error(`Error reading file ${file}: ${err.message}`);
+            console.error(`Error reading file ${file}: ${err.message}`);
         }
     }
 }

implement-shell-tools/ls/ls.js

@@ -11,77 +11,80 @@ program
     .option("-1", "List all files, one per line")
     .option("-a, --all", "Include hidden files (those starting with .) in the listing")
     .action(async (directory, options) => {
-      if (program.args.length > 1) {
-          console.error(`Expected no more than 1 argument (sample-files) but got ${program.args.length}.`);
-          process.exit(1);
-      }
+        try {
+            // default to current directory if none is specified
+            const dir = directory || ".";
 
-      // default directory to current folder
-      directory = directory || ".";
-
-      await newLs(directory, options['1'], options.all);
+            await newLs(dir, options['1'], options.all);
+        } catch (err) {
+            console.error(`Error: ${err.message}`);
+        }
     });
 
 program.parse(process.argv);
 
 
+// filter files based on visibility (includeHidden = true includes all files)
+function filterFiles(entries, includeHidden) {
+    return entries.filter(name =>
+        includeHidden ? true : !name.startsWith(".")
+    );
+}
 
+// sort entries: directories first, then files,
 function sortEntries(entries) {
+    const dirs = entries.filter(entry => {
+        try {
+            return fs.statSync(entry).isDirectory();
+        } catch (err) {
+            return false;
+        }
+    });
+
+    const files = entries.filter(entry => {
+        try {
+            return fs.statSync(entry).isFile();
+        } catch (err) {
+            return false;
+        }
+    });
     // localeCompare = take into account rules of system language/region for ordering 
     // undefined = uses the system default, numeric = regular number sorting, base = ignore case & accents
-    return entries.sort((a, b) => 
-        a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' })
+    return entries.sort((a, b) =>
+        a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" })
     );
 }
 
 
+// print entries either one per line (-1 flag)
+function printEntries(entries) {
+    entries.forEach(entry => console.log(entry));
+}
+
+
 async function newLs(directory, oneFlag, allFlag) {
     try {
-        // check if the path exists
+        // check if path exists and determine if file or directory
         const stats = await fs.stat(directory);
-
-        // if it’s a file, just print its name
+        
+        // if a file, just print the name
         if (stats.isFile()) {
             console.log(directory);
             return;
-        } 
+        }
 
-        // read directory contents
+        // reads directory contents 
         const entries = await fs.readdir(directory);
 
-        let finalEntries;
-        
-        // organize -a output (visible files (doesn't start with a .) and hidden files (starts with a .))
-        const visibleFiles = entries.filter(name => !name.startsWith('.'));
-        const hiddenFiles = entries.filter(name => name.startsWith('.') && name !== '.' && name !== '..');
-
-        if (allFlag) {
-            // add visible and hidden files to the new ['.', '..'] array literal
-            finalEntries = ['.', '..']
-                .concat(sortEntries(visibleFiles))
-                .concat(sortEntries(hiddenFiles));
-        } else {
-            // return sorted array with visible files
-            finalEntries = sortEntries(visibleFiles);
-        }
-
-        // organize -1 output
-        if (oneFlag) {
-            for (const entry of finalEntries) {
-                console.log(entry);
-            }
-        } else {
-            //no flags (separated by 2 spaces)
-            console.log(finalEntries.join('  '));
-        }
+        // Filter out hidden files if no -a flag
+        const filteredEntries = filterFiles(entries, allFlag);
 
+        // Sort the entries using the sortEntries helper
+        const sortedEntries = sortEntries(filteredEntries);
+        
+        // print entries for -1 flag (one per line)
+        printEntries(sortedEntries);
     } catch (err) {
-        console.error(`ls: cannot access '${directory}': No such file or directory`);
+        console.error(`ls: cannot access '${directory}': ${err.message}`);
     }
-}
-
-
-
-    
-    
-    
+}

implement-shell-tools/wc/wc.js

@@ -23,7 +23,8 @@ program
 
 //helper function to format string for output
 function formatCount(count) {
-    return count.toString().padStart(3);
+    const paddingStart = 3
+    return count.toString().padStart(paddingStart);
 }
 
 
@@ -52,7 +53,6 @@ async function newWc(files, options) {
     let totalBytes = 0;
 
     for (const file of files) {
-
         try {
             // read each file into a single text string
             const content = await fs.readFile(file, "utf8");