Building a Command-Line Tool in JavaScript

Welcome to this guide where we’ll tackle a coding challenge by building a command-line tool using JavaScript. Our goal is to create a versatile tool capable of analyzing text files and providing various metrics such as the number of lines, words, characters, and more.

You can find the challenge we’ll be addressing here. We’ll be using JavaScript (JS) for this task. Let’s dive straight into the implementation details.

Setting Up the Environment

When building a command-line tool, one of the initial hurdles is determining where to write the code. Unlike traditional development in an Integrated Development Environment (IDE), scripting involves a slightly different process.

First, ensure you have Node.js installed on your machine. Then, follow these steps:

Navigate to the root directory of your project. Create a new folder named ‘bin’ using mkdir bin. Within the ‘bin’ folder, create a new file. You can use touch <filename>\ to create it. Open the file in a text editor using nano <filename>. Add the following shebang line at the top of your file: #!/usr/local/bin/node. This line tells your compiler to interpret the code using Node.js. Save your changes by pressing Ctrl + O, then Enter, and exit the editor with Ctrl + X. Give executable permissions to your script using chmod +x <filename>. Type export PATH=”$HOME/bin:$PATH” in your bin folder Now, whenever you execute this script, it will be interpreted as a Node.js script.

Solving the Challenge

Step 1: Counting Bytes in a File

Our first task is to create a function that calculates the number of bytes in a file and detects if the argument provided is ‘-c’ from the terminal. Here’s how we can achieve this:

const fs = require('fs');
function readFileContent(fileName) {
 if (!fs.existsSync(fileName)) {
 console.log(`File not found: ${fileName}`);
 process.exit(1);
 }
 
 fs.readFile(fileName, 'utf8', (err, data) => {
 if (err) throw err;
 const fileSizeInBytes = Buffer.byteLength(data, 'utf8');
 displayResult(fileSizeInBytes);
 });
}
function displayResult(fileSizeInBytes) {
 if (commandLineOption === '-c') {
 console.log(`${fileSizeInBytes} ${fileName}`);
 }
}
let fileName = process.argv[2];
const commandLineOption = process.argv[3];
readFileContent(fileName);

In this code snippet, we read the file content using the fs.readFile method and calculate the file size in bytes using Buffer.byteLength. We then display the result if the command-line option matches ‘-c’.

function readFileContent(fileName) {
 // Same as before
 fs.readFile(fileName, 'utf8', (err, data) => {
 if (err) throw err;
 const { charactersCount, wordsCount, numberOfLines } = parseFile(data);
 displayResult(charactersCount, wordsCount, numberOfLines);
 });
}
function parseFile(data) {
 const charactersCount = data.length;
 const wordsCount = data.split(' ').length;
 const numberOfLines = data.split('\n').length;
 return { charactersCount, wordsCount, numberOfLines };
}
function displayResult(charactersCount, wordsCount, numberOfLines) {
 // Same as before with additional conditions for '-l', '-w', '-m'
}
let fileName = process.argv[2];
const commandLineOption = process.argv[3];
readFileContent(fileName);

In this revised code, we parse the file content to count the number of lines, words, and characters. We then display the respective counts based on the command-line option provided.

Step 3: Handling Standard Input

To support reading from standard input when no filename is specified, we need to modify our code to detect when input is piped from another command (e.g., cat test.txt | ccwc -l). Here’s how we can achieve this:

if (!process.stdin.isTTY) {
 let data = '';
 process.stdin.setEncoding('utf8');
 process.stdin.on("data", chunk => {
 data += chunk;
 });
 process.stdin.on("end", () => {
 const { charactersCount, wordsCount, numberOfLines } = parseFile(data);
 displayResult(charactersCount, wordsCount, numberOfLines);
 });
} else {
 // Same as before with minor modifications
}

By checking if standard input is provided (!process.stdin.isTTY), we can handle piped input appropriately.

Conclusion

Despite—or perhaps because of—its learning curve, Vim has cultivated a passionate and active community. Online forums, dedicated websites, and plugins abound, offering support, advice, and improvements.

This community not only helps newcomers climb the steep learning curve but also continually contributes to Vim's evolution, ensuring it remains adaptable and up-to-date with the latest programming trends and technologies.

Conclusion

In this guide, we’ve walked through the process of building a command-line tool in JavaScript to solve a coding challenge. We’ve covered setting up the environment,

implementing functionality to count bytes, lines, words, and characters in a file, and handling standard input.

By following this tutorial, you’ve gained insights into building CLI tools, file processing in Node.js, and handling command-line arguments dynamically.

Feel free to explore the complete code solution and test files on GitHub.