Release v2.3.0

.github/workflows/cd.yml

@@ -1,10 +1,13 @@
 name: Node.js CD
 
 on:
-  push:
-    branches: ['main']
+  pull_request:
+    branches:
+      - main
+    types: [closed]
 
 jobs:
+  if: ${{ github.event.pull_request.merged }}
   publish-npm:
     runs-on: ubuntu-latest
     steps:

CHANGELOG.md

@@ -1,3 +1,31 @@
+# Version 2.3.0
+
+- `Enhancement`:
+  - `Case convertion`: Previously algorithms responsible of converting a string to another case was obviously to light, so, the range of managed uses was too poor, i reworked those algorithms and they're now better from far that was they were. The new ones got tested and passes tests, it's more than sure that i didn't test all of cases, but an enhancement of this feature is truely brang to package.
+- `Added`:
+  - `Case` abstract class is now used to reliably create case objects.
+    - `CamelCase` class implement logic of previous correspondant object.
+    - `PascalCase` class implement logic of previous correspondant object.
+    - `SnakeCase` class implement logic of previous correspondant object.
+    - `LowerCase` class implement logic of previous correspondant object.
+    - `UpperCase` class implement logic of previous correspondant object.
+  - `StringUtils (main.ts)`
+    - `isConsiderableCharSequence(str: string): boolean` method has been implemented and used to check if a given string contains atleast 2 chars (excepted blanks ones).
+    - `containsConsiderableCharSequence(stringTable: string[]): boolean` method has been implemented and used to check if a given table of string contains atleast one considerable (determined by `isConsiderableCharSequence` criterias) element.
+    - `containsOnlyConsiderableCharSequences(stringTable: string[]): boolean` method has been implemented and used to check if a given table of string contains only considerable (determined by `isConsiderableCharSequence` criterias) elements.
+    - `removeBlankChars(str): string` method has been implemented and could be use to remove blank chars from a given string.
+    - `blendIrrelevantStringsInRelevantOnes(str: string): string[]` method has been implemented and should be used to blend orphan chars (a char adjacent to blank chars) to the last considerable subsequence of char (determined by `isConsiderableCharSequence` criterias) in a given string.
+- `Removed`:
+  - `[BREAKING CHANGES]`:
+    - `Case` type has been renamed `CaseName` to avoid collision between new `Case` object type and previous `Case` type.
+    - `ICase` interface has been removed, it was useless to keep working with it.
+- `Refactor`:
+  - `[BREAKING CHANGES]`:
+    - `determineCase(str: string): ICase` method signature changed to `determineCase(str: string): Case`.
+  - `convertToCase(str: string, caseToConvert: Case): string` method signature moved to `convertToCase(str: string, caseToConvert: CaseName): string`.
+  - `knownCases` table is now a `:Case[]` instead of `:ICase[]`.
+  - Tests has been refactored to avoid rewriting loops again and again, they now use `JestRunner` utils class.
+
 # Version 2.2.0
 
 - `Added`:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "string-utils-ts",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Provide some useful functions for strings",
   "main": "./lib",
   "scripts": {

src/case.ts

@@ -1,63 +1,32 @@
-import StringUtilsWord from './word-ending-utils';
-
-/**
- * This interface provide a structure for literal objects
- * It brings reliable way to add unmanaged cases without any other code writing
- *
- * @interface ICase
- * @field {string} name is used to represent a matcher & splitter for case
- * @field {RegExp} matcher is used with Regex operations to check if a given string match
- * @field {RegExp | string} splitter is used to split given string who match `matcher`
- *
- */
-interface ICase {
-  name: Case;
-  matcher: RegExp;
-  splitter: RegExp | string;
-}
+import CamelCase from './case/camel-case';
+import Case from './case/Case';
+import LowerCase from './case/lower-case';
+import PascalCase from './case/pascal-case';
+import SnakeCase from './case/snake-case';
+import UpperCase from './case/upper-case';
+import { StringUtils } from './main';
 
 /**
  * This type is used to ensure case selection is reliable
  */
-
-export type Case =
-  | 'snakeCase'
-  | 'pascalCase'
-  | 'lowerCase'
-  | 'upperCase'
-  | 'camelCase';
+export type CaseName =
+  | 'SnakeCase'
+  | 'PascalCase'
+  | 'LowerCase'
+  | 'UpperCase'
+  | 'CamelCase';
 
 /**
  * This table store few basics cases.
  *
  * @method StringUtilsCase.determineCase <- Use it
  */
-const knownCases: ICase[] = [
-  {
-    name: 'snakeCase',
-    matcher: /(\w+)_(\w+)/,
-    splitter: '_',
-  },
-  {
-    name: 'pascalCase',
-    matcher: /^[A-Z][a-z]+(?:[A-Z][a-z]+)*$/,
-    splitter: /([A-Z]+[a-z]*)/,
-  },
-  {
-    name: 'lowerCase',
-    matcher: /^[a-z0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?\s]*$/,
-    splitter: '',
-  },
-  {
-    name: 'upperCase',
-    matcher: /^[A-Z0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?\s]*$/,
-    splitter: '',
-  },
-  {
-    name: 'camelCase',
-    matcher: /^[a-z]+(?:[A-Z][a-z]+)*$/,
-    splitter: /([A-Z]+[a-z]*)/,
-  },
+const knownCases: Case[] = [
+  new SnakeCase(),
+  new PascalCase(),
+  new LowerCase(),
+  new UpperCase(),
+  new CamelCase(),
 ];
 
 export default class StringUtilsCase {
@@ -68,7 +37,7 @@ export default class StringUtilsCase {
    *
    * @returns {ICase} - The case of given string
    */
-  public static determineCase(str: string): ICase | undefined {
+  public static determineCase(str: string): Case | undefined {
     return knownCases.find((caseObject) => caseObject.matcher.test(str));
   }
 
@@ -105,31 +74,99 @@ export default class StringUtilsCase {
    * case: snakeCase
    * returns: this_is_a_test
    */
-  public static convertToCase(str: string, caseToConvert: Case): string {
-    if (str.trim().replaceAll(' ', '').length < 2) return str;
+  public static convertToCase(str: string, caseToConvert: CaseName): string {
+    switch (caseToConvert) {
+      case 'LowerCase':
+        return this.convertToCaseLogic('LowerCase', str);
+      case 'UpperCase':
+        return this.convertToCaseLogic('UpperCase', str);
+      case 'CamelCase':
+        return this.convertToCaseLogic('CamelCase', str);
+      case 'PascalCase':
+        return this.convertToCaseLogic('PascalCase', str);
+      case 'SnakeCase':
+        return this.convertToCaseLogic('SnakeCase', str);
+    }
+  }
 
-    const splittedByCaseString = this.splitByCase(str);
-    if (splittedByCaseString.length == 1) return str; // Case was unsucessfully determinated
+  /**
+   * Returns a given string converted to camelCase
+   *
+   * @param {string} str - The string to convert
+   *
+   * @example
+   * str: ThisIsMyExample
+   * returns: thisIsMyExample
+   * @example
+   * str: thisIsMyExample
+   * returns: thisIsMyExample
+   */
+  public static toCamelCase(str: string): string {
+    return this.convertToCaseLogic('CamelCase', str);
+  }
 
-    switch (caseToConvert) {
-      case 'lowerCase':
-        return splittedByCaseString.join('').toLowerCase();
-      case 'upperCase':
-        return splittedByCaseString.join('').toUpperCase();
-      case 'camelCase':
-        return splittedByCaseString
-          .map((subSequence, index) =>
-            index == 0
-              ? subSequence.toLowerCase()
-              : StringUtilsWord.formatWord(subSequence),
-          )
-          .join('');
-      case 'pascalCase':
-        return splittedByCaseString
-          .map((subSequence) => StringUtilsWord.formatWord(subSequence))
-          .join('');
-      case 'snakeCase':
-        return splittedByCaseString.join('_').toLowerCase();
+  /**
+   * Returns a given string converted to PamelCase
+   *
+   * @param {string} str - The string to convert
+   *
+   * @example
+   * str: ThisIsMyExample
+   * returns: ThisIsMyExample
+   * @example
+   * str: thisIsMyExample
+   * returns: ThisIsMyExample
+   */
+  public static toPascalCase(str: string): string {
+    return this.convertToCaseLogic('PascalCase', str);
+  }
+
+  /**
+   * Returns a given string converted to snakeCase
+   *
+   * @param {string} str - The string to convert
+   *
+   * @example
+   * str: ThisIsMyExample
+   * returns: this_is_my_example
+   * @example
+   * str: thisIsMyExample
+   * returns: this_is_my_example
+   */
+  public static toSnakeCase(str: string): string {
+    return this.convertToCaseLogic('SnakeCase', str);
+  }
+
+  private static convertToCaseLogic(toCase: CaseName, str: string): string {
+    const correspondantKnownCase = knownCases.find(
+      (caseInstance: Case) => caseInstance.name == toCase,
+    );
+
+    // do not apply any process overload for nothing
+    if (!StringUtils.isConsiderableCharSequence(str)) return str;
+
+    if (!str.includes(' ')) {
+      // str do not need blending operation
+      if (!this.determineCase(str)) return str;
+
+      return correspondantKnownCase.basicConversionReturnFn(
+        this.splitByCase(str),
+        str,
+      ); //Apply stored behavior of correspondantKnownCase and return the processed value
     }
+
+    // str need blending operation
+
+    const removedBlankChars = StringUtils.removeBlankChars(str);
+    if (this.determineCase(removedBlankChars).name == toCase) {
+      //str is per any chance alraedy cased as wanted but needed to be cleanedFrom any blank chars
+      return removedBlankChars;
+    }
+
+    return correspondantKnownCase.blendedConversionReturnFn(
+      this.splitByCase(str),
+      StringUtils.blendIrrelevantStringsInRelevantOnes(str),
+      str,
+    ); //Apply stored behavior of correspondantKnownCase and return the processed value
   }
 }

src/case/Case.ts

@@ -0,0 +1,42 @@
+export default abstract class Case {
+  protected abstract _matcher: RegExp;
+  protected abstract _splitter: RegExp | string;
+
+  /**
+   * This method is a wrapper for conversion to targeted case (when `str` is already cased in managed one)
+   */
+  public abstract basicConversionReturnFn(
+    splittedByCase: string[],
+    str: string,
+  ): string;
+
+  /**
+   * This method is a wrapper for conversion to targeted case (when `str` contains spaces)
+   */
+  public abstract blendedConversionReturnFn(
+    splittedByCase: string[],
+    blended: string[],
+    str: string,
+  ): string;
+
+  /**
+   * Returns the name of class
+   */
+  public get name(): string {
+    return this.constructor.name;
+  }
+
+  /**
+   * Returns the matcher for Regex linked to targeted case class
+   */
+  public get matcher(): RegExp {
+    return this._matcher;
+  }
+
+  /**
+   * Returns the splitter for Regex or string linked to targeted case class
+   */
+  public get splitter(): RegExp | string {
+    return this._splitter;
+  }
+}

src/case/camel-case.ts

@@ -0,0 +1,54 @@
+import Case from './Case';
+import StringUtilsCase from '../case';
+import StringUtilsWord from '../word';
+import { StringUtils } from '../main';
+
+export default class CamelCase extends Case {
+  protected _matcher = /^[a-z]+(?:[A-Z][a-z]+)*$/;
+  protected _splitter = /([A-Z]+[a-z]*)/;
+
+  /*
+   * `str` do not need blending operation (there's no spaces into it)
+   * from `splittedByCase`, for each subsequence
+   * (at this step, it should be atleast a subSequence of length >= 2: because of check if it's a considerable str)
+   * if current subSequence index is index 0, then lower it
+   * otherwise format the current subSequence as a word (c.f: with first char uppered and the rest lowered)
+   */
+  public basicConversionReturnFn(
+    splittedByCase: string[],
+    str: string,
+  ): string {
+    return splittedByCase
+      .map((subSequence, index) =>
+        index == 0
+          ? subSequence.toLowerCase()
+          : StringUtilsWord.formatWord(subSequence),
+      )
+      .join('');
+  }
+
+  /*
+   * `str` was blent (see StringUtils.blendIrrelevantStringsInRelevantOnes) and stored in `blended`
+   * if blended length < 2 (c.f: blend operation didn't produce more than 1 relevant string) then
+   * the table to work with in previous statement will be the result of splitted removed from blank chars
+   * version of `str` (which is never modified).
+   * Otherwise use the result of blend operation as table to work with (blended)
+   */
+  public blendedConversionReturnFn(
+    splittedByCase: string[],
+    blended: string[],
+    str: string,
+  ): string {
+    return (
+      blended.length < 2
+        ? StringUtilsCase.splitByCase(StringUtils.removeBlankChars(str))
+        : blended
+    )
+      .map((subSequence, index) =>
+        index == 0
+          ? subSequence.toLowerCase()
+          : StringUtilsWord.formatWord(subSequence),
+      )
+      .join('');
+  }
+}

src/case/lower-case.ts

@@ -0,0 +1,21 @@
+import Case from './Case';
+
+export default class LowerCase extends Case {
+  protected _matcher = /^[a-z0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?\s]*$/;
+  protected _splitter = '';
+
+  public basicConversionReturnFn(
+    splittedByCase: string[],
+    str: string,
+  ): string {
+    return str.toLowerCase();
+  }
+
+  public blendedConversionReturnFn(
+    splittedByCase: string[],
+    blended: string[],
+    str: string,
+  ): string {
+    return str.toLowerCase();
+  }
+}