Rename string library and its export

Author: wimpyprogrammer

src/utils/string.spec.ts renamed to src/utils/trie.spec.ts

@@ -1,95 +1,95 @@
-import { groupByCommonHead } from './string';
+import { build } from './trie';
 
-describe('groupByCommonHead', () => {
-	it('returns empty object when no words', () => {
-		expect(groupByCommonHead([])).toEqual({});
+describe('build', () => {
+	it('returns empty trie when no words', () => {
+		expect(build([])).toEqual({});
 	});
 
 	it('returns the entirety of words when no common head', () => {
 		const words = ['bar', 'foo'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			bar: {},
 			foo: {},
 		});
 	});
 
 	it('returns the entirety of repeated equal words', () => {
 		const words = ['foo', 'foo', 'foo', 'foo'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(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({
+		expect(build(words)).toEqual({
 			bar: {},
 			foo: {},
 		});
 	});
 
 	it('returns an empty string for partial words', () => {
 		const words = ['foo', 'foobar'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			foo: { '': {}, bar: {} },
 		});
 	});
 
 	it('returns the common head of two words', () => {
 		const words = ['bar', 'baz'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			ba: { r: {}, z: {} },
 		});
 	});
 
 	it('returns multiple depths of partial words', () => {
 		const words = ['foo', 'foobar', 'foobaz'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			foo: { '': {}, ba: { r: {}, z: {} } },
 		});
 	});
 
 	it('returns the common head of multiple words', () => {
 		const words = ['bar', 'baz', 'quux', 'quuz'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			ba: { r: {}, z: {} },
 			quu: { x: {}, z: {} },
 		});
 	});
 
 	it('preserves leading whitespace', () => {
 		const words = [' foo', 'foo'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			' foo': {},
 			foo: {},
 		});
 	});
 
 	it('preserves trailing whitespace', () => {
 		const words = ['foo ', 'foo'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			foo: { '': {}, ' ': {} },
 		});
 	});
 
 	it('preserves mid-word whitespace', () => {
 		const words = ['foo bar', 'foobar'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			foo: { ' bar': {}, bar: {} },
 		});
 	});
 
 	it('is case-sensitive with string heads', () => {
 		const words = ['Foo', 'foo'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			Foo: {},
 			foo: {},
 		});
 	});
 
 	it('is case-sensitive with string tails', () => {
 		const words = ['foo', 'foO'];
-		expect(groupByCommonHead(words)).toEqual({
+		expect(build(words)).toEqual({
 			fo: { o: {}, O: {} },
 		});
 	});

src/utils/string.ts renamed to src/utils/trie.ts

@@ -32,7 +32,7 @@ function mergeGroups(headChar: Char, tailGroup: ICharTrie): ICharTrie {
  * @param words A list of words to parse
  * @returns A trie of words grouped by the initial characters they share
  */
-function groupUniqueByCommonHead(words: string[]): ICharTrie {
+function buildUnique(words: string[]): ICharTrie {
 	if (words.length === 0) {
 		return leafNode;
 	}
@@ -43,23 +43,23 @@ function groupUniqueByCommonHead(words: string[]): ICharTrie {
 		// 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 trie.
 		const [, nonEmptyWords] = partition(words, word => word === '');
-		return { '': leafNode, ...groupByCommonHead(nonEmptyWords) };
+		return { '': leafNode, ...build(nonEmptyWords) };
 	}
 
 	// Begin a new trie 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 tailsMatchedGrouped = build(tailsMatched);
 
 	const groupWithChildren = mergeGroups(charToMatch, tailsMatchedGrouped);
 
-	return { ...groupWithChildren, ...groupByCommonHead(wordsMissed) };
+	return { ...groupWithChildren, ...build(wordsMissed) };
 }
 
-/** @borrows groupUniqueByCommonHead as groupByCommonHead */
-export function groupByCommonHead(words: string[]): ICharTrie {
+/** @borrows buildUnique as build */
+export function build(words: string[]): ICharTrie {
 	const uniqueWords = uniq(words);
-	return groupUniqueByCommonHead(uniqueWords);
+	return buildUnique(uniqueWords);
 }