Added StringBuilder class and tests

Author: jamesmcroft

MADE.Runtime/src/Text/StringBuilder.ts

@@ -0,0 +1,109 @@
+/**
+ * Defines a builder for constructing a string from values.
+ */
+export class StringBuilder {
+    private _strings: string[];
+
+    /**
+     * Initializes a new instance of the StringBuilder class with an optional starting string value.
+     * @param value The optional starting string value.
+     */
+    constructor(value: string | StringBuilder | null = null) {
+        this._strings = [];
+        this.append(value);
+    }
+
+    /**
+     * Appends the value to this instance.
+     * @param value The value to append.
+     * @returns {StringBuilder} A reference to this instance after the append operation has completed.
+     */
+    public append(value: string | StringBuilder | null): StringBuilder {
+        if (value === undefined || value === null) {
+            return this;
+        }
+
+        if (value instanceof StringBuilder) {
+            this._strings.push(...value._strings);
+        } else {
+            if (/^\s*$/.test(value)) {
+                return this;
+            }
+
+            this._strings.push(value);
+        }
+
+        return this;
+    }
+
+    /**
+     * Inserts the value to this instance at the specified index.
+     * @param index The position in this instance where the value should be inserted.
+     * @param value The value to insert.
+     * @returns {StringBuilder} A reference to this instance after the insert operation has completed.
+     */
+    public insert(index: number, value: string | StringBuilder | null): StringBuilder {
+        if (value === undefined || value === null) {
+            return this;
+        }
+
+        if (value instanceof StringBuilder) {
+            this._strings.splice(index, 0, ...value._strings);
+        } else {
+            if (/^\s*$/.test(value)) {
+                return this;
+            }
+
+            this._strings.splice(index, 0, value);
+        }
+
+        return this;
+    }
+
+    /**
+     * Replaces all occurrences of a specified string or value based on a regular expression in this instance with another specified string.
+     * @param search The string or regular expression to find values to replace.
+     * @param replace The string to replace values with.
+     * @returns {StringBuilder} A reference to this instance after the replace operation has completed.
+     */
+    public replace(search: string | RegExp, replace: string): StringBuilder {
+        for (let i = 0; i < this._strings.length; i++) {
+            this._strings[i] = this._strings[i].replace(search, replace);
+        }
+
+        return this;
+    }
+
+    /**
+     * Removes the specified range of characters from this instance.
+     * @param startIndex The zero-based position in this instance where removal begins.
+     * @param length The number of characters to remove.
+     * @returns {StringBuilder} A reference to this instance after the remove operation has completed.
+     */
+    public remove(startIndex: number, length: number): void {
+        this._strings.splice(startIndex, length);
+    }
+
+    /**
+     * Checks whether this instance is empty.
+     * @returns {boolean} True if this instance is empty; otherwise, false.
+     */
+    public isEmpty(): boolean {
+        return this._strings.length === 0;
+    }
+
+    /**
+     * Clears all strings from this instance.
+     */
+    public clear(): void {
+        this._strings = [];
+    }
+
+    /**
+     * Returns a string representation of the value of this instance with a join.
+     * @returns {string} The strings with a join.
+     */
+    public toString(join: string): string {
+        return this._strings.join(join);
+    }
+}

MADE.Runtime/src/Text/index.ts

@@ -0,0 +1 @@
+export * from './StringBuilder'

MADE.Runtime/src/index.ts

@@ -1,2 +1,3 @@
+export * from "./Text";
 export * from "./Guid";
 export * from "./IEquatable";

MADE.Runtime/tests/Text/StringBuilder.spec.ts

@@ -0,0 +1,185 @@
+import { StringBuilder } from '../../src'
+
+describe("when appending a value", () => {
+    it("should accept a string value", () => {
+        // Arrange
+        const builder = new StringBuilder();
+
+        // Act
+        builder.append("Hello");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("Hello");
+    });
+
+    it("should accept a populated StringBuilder", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("Hello");
+
+        const otherBuilder = new StringBuilder();
+
+        // Act
+        otherBuilder.append(builder);
+
+        // Assert
+        expect(otherBuilder.toString(" ")).toBe("Hello");
+    });
+
+    it("should not add a null value", () => {
+        // Arrange
+        const builder = new StringBuilder();
+
+        // Act
+        builder.append(null);
+
+        // Assert
+        expect(builder.toString(" ")).toBe("");
+    });
+
+    it("should not add an empty string", () => {
+        // Arrange
+        const builder = new StringBuilder();
+
+        // Act
+        builder.append("");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("");
+    });
+});
+
+describe("when inserting a value", () => {
+    it("should accept a string value", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("World");
+
+        // Act
+        builder.insert(0, "Hello");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("Hello World");
+    });
+
+    it("should accept a populated StringBuilder", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("Hello");
+
+        const otherBuilder = new StringBuilder();
+        otherBuilder.append("World");
+
+        // Act
+        otherBuilder.insert(0, builder);
+
+        // Assert
+        expect(otherBuilder.toString(" ")).toBe("Hello World");
+    });
+
+    it("should not insert a null value", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("World");
+
+        // Act
+        builder.insert(0, null);
+
+        // Assert
+        expect(builder.toString(" ")).toBe("World");
+    });
+
+    it("should not insert an empty string", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("World");
+
+        // Act
+        builder.insert(0, "");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("World");
+    });
+});
+
+describe("when replacing a value", () => {
+    it("should replace by a string", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("World");
+
+        // Act
+        builder.replace("World", "Hello");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("Hello");
+    });
+
+    it("should replace by a regular expression", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("World");
+
+        // Act
+        builder.replace(/World/g, "Hello");
+
+        // Assert
+        expect(builder.toString(" ")).toBe("Hello");
+    });
+});
+
+describe("when removing by range", () => {
+    it("should remove items in range", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("Hello");
+        builder.append("Digital");
+        builder.append("World");
+
+        // Act
+        builder.remove(1, 1);
+
+        // Assert
+        expect(builder.toString(" ")).toBe("Hello World");
+    });
+});
+
+describe("when checking is empty", () => {
+    it("should return true if empty", () => {
+        // Arrange
+        const builder = new StringBuilder();
+
+        // Act
+        const result = builder.isEmpty();
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return false if populated", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("Hello");
+
+        // Act
+        const result = builder.isEmpty();
+
+        // Assert
+        expect(result).toBe(false);
+    });
+});
+
+describe("when clearing", () => {
+    it("should be empty", () => {
+        // Arrange
+        const builder = new StringBuilder();
+        builder.append("Hello");
+        builder.append("World");
+
+        // Act
+        builder.clear();
+
+        // Assert
+        expect(builder.isEmpty()).toBe(true);
+    });
+});