Added formatter to release

Author: RobertJGabriel

.github/workflows/npm-publish.yml

@@ -16,6 +16,7 @@ jobs:
         with:
           node-version: 16
       - run: npm ci
+      - run: npm run format
       - run: npm test
 
   publish-npm:

.prettierrc.json

@@ -1 +1,9 @@
-{}
+{
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "printWidth": 80,
+  "arrowParens": "always",
+  "endOfLine": "auto"
+}

README.md

@@ -1,4 +1,4 @@
-![alt text](.github/readme.png "Logo Title Text 1")
+![alt text](.github/readme.png 'Logo Title Text 1')
 
 ## Description
 
@@ -19,11 +19,11 @@ npm install @coffeeandfun/google-profanity-words
 To use the `@coffeeandfun/google-profanity-words`, first, import the module and create an instance:
 
 ```javascript
-import { ProfanityEngine } from "@coffeeandfun/google-profanity-words";
+import { ProfanityEngine } from '@coffeeandfun/google-profanity-words';
 
 // Pass the 'language' parameter to specify the language (optional).
 // Defaults to 'en' if no valid language code is provided.
-const profanity = new ProfanityEngine({ language: "es" });
+const profanity = new ProfanityEngine({ language: 'es' });
 ```
 
 The language parameter is optional and can be used to specify the language for the profanity list. It defaults to 'en' if no valid language code is provided. If the specified language file is not found, it will fall back to the 'en' language file and display a console warning.
@@ -43,7 +43,7 @@ const allWords = profanity.all();
 Checks if a given word is considered profane.
 
 ```javascript
-const searchWord = profanity.search("shit");
+const searchWord = profanity.search('shit');
 // Returns true if the word is profane, otherwise false.
 ```
 
@@ -52,7 +52,7 @@ const searchWord = profanity.search("shit");
 Checks if a given sentence contains any profanity words.
 
 ```javascript
-const sentence = "Do not use bad words like mierda or idiota.";
+const sentence = 'Do not use bad words like mierda or idiota.';
 const hasCurseWords = profanity.hasCurseWords(sentence);
 // Returns true if the sentence contains profanity words, otherwise false.
 ```
@@ -62,8 +62,8 @@ const hasCurseWords = profanity.hasCurseWords(sentence);
 The `search` and `hasCurseWords` functions will return false for any empty string.
 
 ```javascript
-const searchWord = profanity.search("");
-const hasCurseWords = profanity.hasCurseWords("");
+const searchWord = profanity.search('');
+const hasCurseWords = profanity.hasCurseWords('');
 // Returns false for an empty string.
 ```
 

__tests__/engine.test.js

@@ -1,47 +1,47 @@
-import { ProfanityEngine } from "../index.js";
+import { ProfanityEngine } from '../index.js';
 
-const language = process.env.LANGUAGE || "en"; // Default to 'en' if the LANGUAGE environment variable is not set
+const language = process.env.LANGUAGE || 'en'; // Default to 'en' if the LANGUAGE environment variable is not set
 let profanity;
 
-describe("ProfanityEngine Functions tests", () => {
+describe('ProfanityEngine Functions tests', () => {
   beforeAll(async () => {
     profanity = new ProfanityEngine({
-      language: "en",
+      language: 'en',
       testMode: true,
     });
     await profanity.initialize(); // Initialize the profanity instance with the English language
   });
 
-  it("Should get the correct language file path", async () => {
-    const filePath = await profanity.getLanguageFilePath("es");
-    expect(filePath).toContain("es.txt");
+  it('Should get the correct language file path', async () => {
+    const filePath = await profanity.getLanguageFilePath('es');
+    expect(filePath).toContain('es.txt');
   });
 
-  it("Should return the default language file path for unknown language", async () => {
-    const filePath = await profanity.getLanguageFilePath("fr");
-    expect(filePath).toContain("en.txt");
+  it('Should return the default language file path for unknown language', async () => {
+    const filePath = await profanity.getLanguageFilePath('fr');
+    expect(filePath).toContain('en.txt');
   });
 
-  it("Should check if a file exists and return true", async () => {
-    const filePath = await profanity.getLanguageFilePath("en");
+  it('Should check if a file exists and return true', async () => {
+    const filePath = await profanity.getLanguageFilePath('en');
     const fileExists = await profanity.fileExists(filePath);
     expect(fileExists).toEqual(true);
   });
 
-  it("Should check if a file exists and return false", async () => {
-    const filePath = "nonexistent.txt"; // Assume the file doesn't exist
+  it('Should check if a file exists and return false', async () => {
+    const filePath = 'nonexistent.txt'; // Assume the file doesn't exist
     const fileExists = await profanity.fileExists(filePath);
     expect(fileExists).toEqual(false);
   });
 
-  it("Should read and split the file content correctly", async () => {
-    const filePath = await profanity.getLanguageFilePath("en");
+  it('Should read and split the file content correctly', async () => {
+    const filePath = await profanity.getLanguageFilePath('en');
     const terms = await profanity.readFileAndSplit(filePath);
     expect(terms.length).toBeGreaterThan(0);
   });
 
-  it("Should handle read error and set terms to the english terms", async () => {
-    const filePath = "nonexistent.txt"; // Assume the file doesn't exist
+  it('Should handle read error and set terms to the english terms', async () => {
+    const filePath = 'nonexistent.txt'; // Assume the file doesn't exist
     await profanity.readFileAndSplit(filePath);
     let terms = await profanity.all();
     expect(terms.length).toEqual(959);

__tests__/english.test.js

@@ -1,45 +1,45 @@
-import { ProfanityEngine } from "../index.js";
+import { ProfanityEngine } from '../index.js';
 
-const language = process.env.LANGUAGE || "en"; // Default to 'en' if the LANGUAGE environment variable is not set
+const language = process.env.LANGUAGE || 'en'; // Default to 'en' if the LANGUAGE environment variable is not set
 let profanity;
 
-describe("English Profanity tests", () => {
+describe('English Profanity tests', () => {
   beforeAll(async () => {
     profanity = new ProfanityEngine({
-      language: "en",
+      language: 'en',
       testMode: true,
     });
     await profanity.initialize(); // Initialize the profanity instance with the English language
   });
 
-  it("Should get all the profanity words in an array", async () => {
+  it('Should get all the profanity words in an array', async () => {
     const allWords = await profanity.all();
     expect(allWords.length).toEqual(959);
   });
 
-  it("Should return true for profanity words", async () => {
-    const searchWord = await profanity.search("shit");
+  it('Should return true for profanity words', async () => {
+    const searchWord = await profanity.search('shit');
     expect(searchWord).toEqual(true);
   });
 
-  it("Should return false for normal words", async () => {
-    const searchWord = await profanity.search("ka");
+  it('Should return false for normal words', async () => {
+    const searchWord = await profanity.search('ka');
     expect(searchWord).toEqual(false);
   });
 
-  it("Should return false for any empty string", async () => {
-    const searchWord = await profanity.search("");
+  it('Should return false for any empty string', async () => {
+    const searchWord = await profanity.search('');
     expect(searchWord).toEqual(true);
   });
 
-  it("Should return true for a sentence containing a profanity word", async () => {
-    const sentence = "Do not use bad words like shit or asshole.";
+  it('Should return true for a sentence containing a profanity word', async () => {
+    const sentence = 'Do not use bad words like shit or asshole.';
     const hasCurseWords = await profanity.hasCurseWords(sentence);
     expect(hasCurseWords).toEqual(true);
   });
 
-  it("Should return false for a sentence with no profanity word", async () => {
-    const sentence = "This is a clean and polite sentence.";
+  it('Should return false for a sentence with no profanity word', async () => {
+    const sentence = 'This is a clean and polite sentence.';
     const hasCurseWords = await profanity.hasCurseWords(sentence);
     expect(hasCurseWords).toEqual(false);
   });

__tests__/spanish.test.js

@@ -1,44 +1,44 @@
-import { ProfanityEngine } from "../index.js";
+import { ProfanityEngine } from '../index.js';
 
-const language = process.env.LANGUAGE || "en"; // Default to 'en' if the LANGUAGE environment variable is not set
+const language = process.env.LANGUAGE || 'en'; // Default to 'en' if the LANGUAGE environment variable is not set
 let profanity;
 
-describe("Spanish Profanity tests", () => {
+describe('Spanish Profanity tests', () => {
   beforeAll(async () => {
     profanity = new ProfanityEngine({
-      language: "es",
+      language: 'es',
       testMode: true,
     });
     await profanity.initialize(); // Initialize the profanity instance with the English language
   });
-  it("Should get all the profanity words in an array", async () => {
+  it('Should get all the profanity words in an array', async () => {
     const allWords = await profanity.all();
     expect(allWords.length).toEqual(565);
   });
 
-  it("Should return true for profanity words", async () => {
-    const searchWord = await profanity.search("labios");
+  it('Should return true for profanity words', async () => {
+    const searchWord = await profanity.search('labios');
     expect(searchWord).toEqual(true);
   });
 
-  it("Should return false for normal words", async () => {
-    const searchWord = await profanity.search("ka");
+  it('Should return false for normal words', async () => {
+    const searchWord = await profanity.search('ka');
     expect(searchWord).toEqual(false);
   });
 
-  it("Should return false for any empty string", async () => {
-    const searchWord = await profanity.search("");
+  it('Should return false for any empty string', async () => {
+    const searchWord = await profanity.search('');
     expect(searchWord).toEqual(true);
   });
 
-  it("Should return true for a sentence containing a profanity word", async () => {
-    const sentence = "No deberías decir malas culo palabras como mierda.";
+  it('Should return true for a sentence containing a profanity word', async () => {
+    const sentence = 'No deberías decir malas culo palabras como mierda.';
     const hasCurseWords = await profanity.hasCurseWords(sentence);
     expect(hasCurseWords).toEqual(true);
   });
 
-  it("Should return false for a sentence with no profanity word", async () => {
-    const sentence = "Esta es una oración limpia y educada.";
+  it('Should return false for a sentence with no profanity word', async () => {
+    const sentence = 'Esta es una oración limpia y educada.';
     const hasCurseWords = await profanity.hasCurseWords(sentence);
     expect(hasCurseWords).toEqual(false);
   });

index.js

@@ -1,13 +1,13 @@
-import { readFile } from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
 export class ProfanityEngine {
   constructor(config) {
     this.isTestMode = config && config.testMode ? config.testMode : false;
-    this.language = config && config.language ? config.language : "en";
+    this.language = config && config.language ? config.language : 'en';
     this.terms = [];
-    this.filePath = "";
+    this.filePath = '';
   }
 
   async initialize() {
@@ -18,24 +18,24 @@ export class ProfanityEngine {
     } catch (err) {
       if (this.isTestMode === false) {
         let message = `Error reading file: ${err.message}`;
-        console.warn("Profanity words issue:", message);
+        console.warn('Profanity words issue:', message);
       }
       this.terms = [];
     }
   }
 
   async getLanguageFilePath(language) {
     const currentFilePath = fileURLToPath(import.meta.url);
-    const dataFolderPath = path.join(path.dirname(currentFilePath), "data");
+    const dataFolderPath = path.join(path.dirname(currentFilePath), 'data');
     const languageFilePath = path.join(dataFolderPath, `${language}.txt`);
     const fileExists = await this.fileExists(languageFilePath);
 
     if (!fileExists) {
       if (this.isTestMode === false) {
         let message = `Warning: The ${language} language file could not be found. Defaulting to 'en' language.`;
-        console.warn("Profanity words issue:", message);
+        console.warn('Profanity words issue:', message);
       }
-      return path.join(dataFolderPath, "en.txt");
+      return path.join(dataFolderPath, 'en.txt');
     }
 
     return languageFilePath;
@@ -52,11 +52,11 @@ export class ProfanityEngine {
 
   async readFileAndSplit(filePath) {
     try {
-      const fileContent = await readFile(filePath, "utf8");
-      return fileContent.split("\n");
+      const fileContent = await readFile(filePath, 'utf8');
+      return fileContent.split('\n');
     } catch (err) {
       if (this.isTestMode === false) {
-        console.warn("Profanity words issue:", err);
+        console.warn('Profanity words issue:', err);
       }
       return [];
     }

package.json

@@ -5,6 +5,7 @@
   "main": "index.js",
   "type": "module",
   "scripts": {
+    "format": "npx prettier . --write",
     "test": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 jest",
     "en": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 jest english.test.js",
     "es": "NODE_OPTIONS=--experimental-vm-modules NODE_NO_WARNINGS=1 jest spanish.test.js",