feat: port more string functions from lodash (#60)

alexkvak · web-flow · commit 4edc83db76ba · 2021-06-08T20:25:30.000+03:00
diff --git a/package.json b/package.json
@@ -4,7 +4,7 @@
   "author": "Tinkoff team",
   "scripts": {
     "release": "node ./releaseUtils/index.js",
-    "benchmark": "ts-node --skip-project runBenchmark.ts",
+    "benchmark": "ts-node --project tsconfig.benchmark.json runBenchmark.ts",
     "prebenchmark": "npm install --no-save ts-node lodash ramda lazy.js underscore",
     "docs": "node ./generate/docs/index.js",
     "test": "jest --coverage",
diff --git a/src/string/__benchmarks__/camelCaseName.ts b/src/string/__benchmarks__/camelCaseName.ts
@@ -0,0 +1,14 @@
+import camelCaseName from '../camelCaseName';
+
+const camelCaseLodash = require('lodash/camelCase');
+
+const testStr = 'very-log-foo-bar-string';
+
+export default {
+    lodash: () => {
+        camelCaseLodash(testStr);
+    },
+    utils: () => {
+        camelCaseName(testStr);
+    },
+};
diff --git a/src/string/__benchmarks__/kebabCaseName.ts b/src/string/__benchmarks__/kebabCaseName.ts
@@ -0,0 +1,14 @@
+import kebabCaseName from '../kebabCaseName';
+
+const kebabCaseLodash = require('lodash/kebabCase');
+
+const testStr = 'VeryLogFooBarString';
+
+export default {
+    lodash: () => {
+        kebabCaseLodash(testStr);
+    },
+    utils: () => {
+        kebabCaseName(testStr);
+    },
+};
diff --git a/src/string/__benchmarks__/snakeCaseName.ts b/src/string/__benchmarks__/snakeCaseName.ts
@@ -0,0 +1,14 @@
+import snakeCaseName from '../snakeCaseName';
+
+const snakeCaseLodash = require('lodash/snakeCase');
+
+const testStr = 'VeryLogFooBarString';
+
+export default {
+    lodash: () => {
+        snakeCaseLodash(testStr);
+    },
+    utils: () => {
+        snakeCaseName(testStr);
+    },
+};
diff --git a/src/string/__benchmarks__/upperFirst.ts b/src/string/__benchmarks__/upperFirst.ts
@@ -0,0 +1,13 @@
+const upperFirstLodash = require('lodash/upperFirst');
+import upperFirst from '../upperFirst';
+
+const testStr = 'very-log-foo-bar-string';
+
+export default {
+    lodash: () => {
+        upperFirstLodash(testStr);
+    },
+    utils: () => {
+        upperFirst(testStr);
+    },
+};
diff --git a/src/string/__benchmarks__/words.ts b/src/string/__benchmarks__/words.ts
@@ -0,0 +1,13 @@
+const wordsLodash = require('lodash/words');
+import words from '../words';
+
+const testStr = 'very-log-foo-bar-string';
+
+export default {
+    lodash: () => {
+        wordsLodash(testStr);
+    },
+    utils: () => {
+        words(testStr);
+    },
+};
diff --git a/src/string/__tests__/camelCaseName.ts b/src/string/__tests__/camelCaseName.ts
@@ -0,0 +1,16 @@
+import camelCaseName from '../camelCaseName';
+
+describe('utils/string/camelCaseName', () => {
+    it.each([
+        ['', ''],
+        ['abc', 'abc'],
+        ['Foo Bar', 'fooBar'],
+        ['foo-bar', 'fooBar'],
+        ['foo_bar', 'fooBar'],
+        ['FOO_BAR', 'fooBar'],
+        ['fooBar', 'fooBar'],
+        ['Foo Bär', 'fooBR'],
+    ])('should return camel cased string for %s: %s', (str, expected) => {
+        expect(camelCaseName(str)).toEqual(expected);
+    });
+});
diff --git a/src/string/__tests__/kebabCaseName.ts b/src/string/__tests__/kebabCaseName.ts
@@ -0,0 +1,16 @@
+import kebabCaseName from '../kebabCaseName';
+
+describe('utils/string/kebabCaseName', () => {
+    it.each([
+        ['', ''],
+        ['abc', 'abc'],
+        ['Foo Bar', 'foo-bar'],
+        ['fooBar', 'foo-bar'],
+        ['foo-bar', 'foo-bar'],
+        ['foo_Bar', 'foo-bar'],
+        ['FOO_BAR', 'foo-bar'],
+        ['Foo Bär', 'foo-b-r'],
+    ])('should return kebab cased string for %s: %s', (str, expected) => {
+        expect(kebabCaseName(str)).toEqual(expected);
+    });
+});
diff --git a/src/string/__tests__/snakeCaseName.ts b/src/string/__tests__/snakeCaseName.ts
@@ -0,0 +1,16 @@
+import snakeCaseName from '../snakeCaseName';
+
+describe('utils/string/snakeCaseName', () => {
+    it.each([
+        ['', ''],
+        ['abc', 'abc'],
+        ['Foo Bar', 'foo_bar'],
+        ['fooBar', 'foo_bar'],
+        ['foo_Bar', 'foo_bar'],
+        ['foo-Bar', 'foo_bar'],
+        ['FOO_BAR', 'foo_bar'],
+        ['Foo Bär', 'foo_b_r'],
+    ])('should return snake cased string for %s: %s', (str, expected) => {
+        expect(snakeCaseName(str)).toEqual(expected);
+    });
+});
diff --git a/src/string/__tests__/upperFirst.ts b/src/string/__tests__/upperFirst.ts
@@ -0,0 +1,12 @@
+import upperFirst from '../upperFirst';
+
+describe('utils/string/upperFirst', () => {
+    it.each([
+        ['', ''],
+        ['foo', 'Foo'],
+        ['FOO', 'FOO'],
+        ['über', 'Über'],
+    ])('should convert the first character of string to upper case for %s: %s', (str, expected) => {
+        expect(upperFirst(str)).toEqual(expected);
+    });
+});
diff --git a/src/string/__tests__/words.ts b/src/string/__tests__/words.ts
@@ -0,0 +1,16 @@
+import words from '../words';
+
+describe('utils/string/words', () => {
+    it.each([
+        ['', ['']],
+        ['foo', ['foo']],
+        ['fooBar', ['foo', 'Bar']],
+        ['fooBarZoo', ['foo', 'Bar', 'Zoo']],
+        ['foo_bar_zoo', ['foo', 'bar', 'zoo']],
+        ['foo-bar-zoo', ['foo', 'bar', 'zoo']],
+        ['foo bar zoo', ['foo', 'bar', 'zoo']],
+        ['fooBär', ['foo', 'B', 'r']],
+    ])('should split string %s into words: %s', (str, expected) => {
+        expect(words(str)).toEqual(expected);
+    });
+});
diff --git a/src/string/camelCaseName.ts b/src/string/camelCaseName.ts
@@ -0,0 +1,31 @@
+import words from './words';
+import upperFirst from './upperFirst';
+
+/**
+ * Converts string to camel case.
+ *
+ * This function convert only latin chars.
+ * The preferred purpose is to generate file or class names in your code generation tools.
+ *
+ * @param {String} str The string to convert.
+ * @return {String} The camel cased string.
+ * @example
+ *
+ *      camelCase('Foo Bar'); //=> 'fooBar'
+ *      camelCase('foo-bar'); //=> 'fooBar'
+ *      camelCase('foo_bar'); //=> 'fooBar'
+ *      camelCase('FOO_BAR'); //=> 'fooBar'
+ *      camelCase('fooBar');  //=> 'fooBar'
+ *      camelCase('Foo Bär'); //=> 'fooBR' only latin chars are supported
+ */
+export default function camelCaseName(str: string): string {
+    return words(str)
+        .map((word, index) => {
+            if (index === 0) {
+                return word.toLowerCase();
+            }
+
+            return upperFirst(word.toLowerCase());
+        })
+        .join('');
+}
diff --git a/src/string/kebabCaseName.ts b/src/string/kebabCaseName.ts
@@ -0,0 +1,23 @@
+import words from './words';
+
+/**
+ * Converts string to kebab case.
+ *
+ * This function convert only latin chars.
+ * The preferred purpose is to generate file or class names in your code generation tools.
+ *
+ * @param {String} str The string to convert.
+ * @return {String} The kebab cased string.
+ * @example
+ *
+ *      kebabCase('Foo Bar'); //=> 'foo-bar'
+ *      kebabCase('fooBar');  //=> 'foo-bar'
+ *      kebabCase('foo_bar'); //=> 'foo-bar'
+ *      kebabCase('FOO_BAR'); //=> 'foo-bar'
+ *      kebabCase('Foo Bär'); //=> 'foo-b-r' — only latin chars are supported
+ */
+export default function kebabCaseName(str: string): string {
+    return words(str)
+        .map((word) => word.toLowerCase())
+        .join('-');
+}
diff --git a/src/string/snakeCaseName.ts b/src/string/snakeCaseName.ts
@@ -0,0 +1,23 @@
+import words from './words';
+
+/**
+ * Returns the snake case version of a string.
+ *
+ * This function convert only latin chars.
+ * The preferred purpose is to generate file or class names in your code generation tools.
+ *
+ * @param {String} str The string to switch to snake case.
+ * @return {String} The snake case version of `str`.
+ * @example
+ *
+ *      snakeCaseName('Foo Bar'); //=> 'foo_bar'
+ *      snakeCaseName('fooBar');  //=> 'foo_bar'
+ *      snakeCaseName('foo-bar'); //=> 'foo_bar'
+ *      snakeCaseName('FOO-BAR'); //=> 'foo_bar'
+ *      snakeCaseName('Foo Bär'); //=> 'foo_b_r' only latin chars are supported
+ */
+export default function snakeCaseName(str: string): string {
+    return words(str)
+        .join('_')
+        .toLowerCase();
+}
diff --git a/src/string/upperFirst.ts b/src/string/upperFirst.ts
@@ -0,0 +1,16 @@
+/**
+ * Converts the first character of string to upper case and returns the new string.
+ *
+ * @param {String} str The string to convert.
+ * @return {String} The converted string.
+ * @example
+ *
+ *      upperFirst('foo');  //=> 'Foo'
+ *      upperFirst('über'); //=> 'Über'
+ *      upperFirst('FOO');  //=> 'FOO'
+ */
+function upperFirst(str: string): string {
+    return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+}
+
+export default upperFirst;
diff --git a/src/string/words.ts b/src/string/words.ts
@@ -0,0 +1,21 @@
+const camelCaseRegex = /([a-z])([A-Z])/g;
+const nonCharRegex = /[^a-zA-Z]+/g;
+
+/**
+ * Splits string into an array of its words.
+ *
+ * This function supports only latin chars.
+ *
+ * @param {String} str The string to split.
+ * @return {String[]} String' words.
+ * @example
+ *
+ *      words('fooBarZoo');   //=> ['foo', 'Bar', 'Zoo']
+ *      words('foo_bar_zoo'); //=> ['foo', 'bar', 'zoo']
+ *      words('foo-bar-zoo'); //=> ['foo', 'bar', 'zoo']
+ *      words('foo bar zoo'); //=> ['foo', 'bar', 'zoo']
+ *      words('fooBär');      //=> ['foo', 'B', 'r'] only latin chars are supported
+ */
+export default function words(str: string): string[] {
+    return str.replace(camelCaseRegex, (_, char1: string, char2: string) => `${char1} ${char2}`).split(nonCharRegex);
+}
diff --git a/tsconfig.benchmark.json b/tsconfig.benchmark.json
@@ -0,0 +1,11 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "module": "commonjs",
+        "declaration": false
+    },
+    "include": [
+        "src/**/*",
+    ],
+    "exclude": []
+}
