Parse string array into common heads

Author: wimpyprogrammer

package.json

@@ -32,13 +32,16 @@
       "ts"
     ]
   },
-  "dependencies": {},
+  "dependencies": {
+    "lodash": "^4.17.10"
+  },
   "devDependencies": {
     "@babel/cli": "^7.0.0-beta.54",
     "@babel/core": "^7.0.0-beta.54",
     "@babel/preset-env": "^7.0.0-beta.54",
     "@babel/preset-typescript": "^7.0.0-beta.54",
     "@types/jest": "^23.3.1",
+    "@types/lodash": "^4.14.114",
     "husky": "^0.14.3",
     "jest": "^23.4.1",
     "prettier": "^1.13.7",

src/utils/string.spec.ts

@@ -0,0 +1,81 @@
+import { groupByCommonHead } from './string';
+
+describe('groupByCommonHead', () => {
+	it('returns empty object when no words', () => {
+		expect(groupByCommonHead([])).toEqual({});
+	});
+
+	it('returns the entirety of words when no common head', () => {
+		const words = ['bar', 'foo'];
+		expect(groupByCommonHead(words)).toEqual({
+			bar: {},
+			foo: {},
+		});
+	});
+
+	it('returns the entirety of repeated equal words', () => {
+		const words = ['foo', 'foo', 'foo', 'foo'];
+		expect(groupByCommonHead(words)).toEqual({
+			foo: {},
+		});
+	});
+
+	it('returns the entirety of multiple, repeated equal words', () => {
+		const words = ['bar', 'bar', 'bar', 'bar', 'foo', 'foo', 'foo', 'foo'];
+		expect(groupByCommonHead(words)).toEqual({
+			bar: {},
+			foo: {},
+		});
+	});
+
+	it('returns an empty string for partial words', () => {
+		const words = ['foo', 'foobar'];
+		expect(groupByCommonHead(words)).toEqual({
+			foo: { '': {}, bar: {} },
+		});
+	});
+
+	it('returns the common head of two words', () => {
+		const words = ['bar', 'baz'];
+		expect(groupByCommonHead(words)).toEqual({
+			ba: { r: {}, z: {} },
+		});
+	});
+
+	it('returns multiple depths of partial words', () => {
+		const words = ['foo', 'foobar', 'foobaz'];
+		expect(groupByCommonHead(words)).toEqual({
+			foo: { '': {}, ba: { r: {}, z: {} } },
+		});
+	});
+
+	it('returns the common head of multiple words', () => {
+		const words = ['bar', 'baz', 'quux', 'quuz'];
+		expect(groupByCommonHead(words)).toEqual({
+			ba: { r: {}, z: {} },
+			quu: { x: {}, z: {} },
+		});
+	});
+
+	it('preserves leading whitespace', () => {
+		const words = [' foo', 'foo'];
+		expect(groupByCommonHead(words)).toEqual({
+			' foo': {},
+			foo: {},
+		});
+	});
+
+	it('preserves trailing whitespace', () => {
+		const words = ['foo ', 'foo'];
+		expect(groupByCommonHead(words)).toEqual({
+			foo: { '': {}, ' ': {} },
+		});
+	});
+
+	it('preserves mid-word whitespace', () => {
+		const words = ['foo bar', 'foobar'];
+		expect(groupByCommonHead(words)).toEqual({
+			foo: { ' bar': {}, bar: {} },
+		});
+	});
+});

src/utils/string.ts

@@ -0,0 +1,65 @@
+import { keys, map, partition, uniq } from 'lodash';
+
+type Char = string;
+interface ICharTree extends Record<Char, CharLeaf> {}
+type CharLeaf = ICharTree;
+
+const terminator: ICharTree = {};
+
+/**
+ * Arrange a head character and its suffixes into a tree.
+ * Flatten leaves of the character tree containing a single letter.
+ * For example, { f: { o: { o: { '': {}, bar: {} } } } } flattens
+ * to { foo: { '': {}, bar: {} } }
+ *
+ * @param headChar A character prefix
+ * @param tailGroup A character tree of suffixes to headChar
+ * @returns A character tree with tailGroup branching from headChar
+ */
+function mergeGroups(headChar: Char, tailGroup: ICharTree): ICharTree {
+	const tails = keys(tailGroup);
+	if (tails.length > 1) {
+		return { [headChar]: tailGroup };
+	}
+
+	const onlyTail = tails[0];
+	return { [headChar + onlyTail]: tailGroup[onlyTail] };
+}
+
+/**
+ * Parse a list of words to build a tree of common prefixes
+ *
+ * @param words A list of words to parse
+ * @returns A tree of words grouped by the initial characters they share
+ */
+function groupUniqueByCommonHead(words: string[]): ICharTree {
+	if (words.length === 0) {
+		return terminator;
+	}
+
+	const wordToMatch = words[0];
+
+	if (wordToMatch === '') {
+		// End of the target word reached. Include an empty string to signify that
+		// a word ends at this spot, and group any remaining words in the tree.
+		const [, nonEmptyWords] = partition(words, word => word === '');
+		return { '': terminator, ...groupByCommonHead(nonEmptyWords) };
+	}
+
+	// Begin a new tree containing all words starting with the same letter as wordToMatch
+	const charToMatch = wordToMatch[0];
+	const [wordsMatched, wordsMissed] = partition(words, ['[0]', charToMatch]);
+
+	const tailsMatched = map(wordsMatched, word => word.substring(1));
+	const tailsMatchedGrouped = groupByCommonHead(tailsMatched);
+
+	const groupWithChildren = mergeGroups(charToMatch, tailsMatchedGrouped);
+
+	return { ...groupWithChildren, ...groupByCommonHead(wordsMissed) };
+}
+
+/** @borrows groupUniqueByCommonHead as groupByCommonHead */
+export function groupByCommonHead(words: string[]): ICharTree {
+	const uniqueWords = uniq(words);
+	return groupUniqueByCommonHead(uniqueWords);
+}

yarn.lock

@@ -547,6 +547,10 @@
   version "23.3.1"
   resolved "https://registry.yarnpkg.com/@types/jest/-/jest-23.3.1.tgz#a4319aedb071d478e6f407d1c4578ec8156829cf"
 
+"@types/lodash@^4.14.114":
+  version "4.14.114"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.114.tgz#e6f251af5994dd0d7ce141f9241439b4f40270f6"
+
 abab@^1.0.4:
   version "1.0.4"
   resolved "https://registry.yarnpkg.com/abab/-/abab-1.0.4.tgz#5faad9c2c07f60dd76770f71cf025b62a63cfd4e"