Improve perfomance: implement RecordsSet (#232)

* improve proxy creation function

* use node contexts to simplify node logic

* implement custom records set

RecordsSet implements the higher order filter and map methods which get applied when retrieving the iterator. This increases performance as it doesn't create arrays on each .map or .filter -> the iterator yields only the end values with one iteration

Author: notanengineercom

src/Recorder.ts

@@ -1,40 +1,44 @@
 import { inspect, InspectOptions } from 'util'
 import { SubstituteNodeBase } from './SubstituteNodeBase'
+import { RecordsSet } from './RecordsSet'
 
 export class Recorder {
-  private _records: SubstituteNodeBase[]
-  private _indexedRecords: Map<PropertyKey, SubstituteNodeBase[]>
+  private _records: RecordsSet<SubstituteNodeBase>
+  private _indexedRecords: Map<PropertyKey, RecordsSet<SubstituteNodeBase>>
 
   constructor() {
-    this._records = []
+    this._records = new RecordsSet()
     this._indexedRecords = new Map()
   }
 
-  public get records(): SubstituteNodeBase[] {
+  public get records(): RecordsSet<SubstituteNodeBase> {
     return this._records
   }
 
-  public get indexedRecords(): Map<PropertyKey, SubstituteNodeBase[]> {
+  public get indexedRecords(): Map<PropertyKey, RecordsSet<SubstituteNodeBase>> {
     return this._indexedRecords
   }
 
   public addIndexedRecord(node: SubstituteNodeBase): void {
+    this.addRecord(node)
     const existingNodes = this.indexedRecords.get(node.key)
-    if (typeof existingNodes === 'undefined') this._indexedRecords.set(node.key, [node])
-    else existingNodes.push(node)
+    if (typeof existingNodes === 'undefined') this._indexedRecords.set(node.key, new RecordsSet([node]))
+    else existingNodes.add(node)
   }
 
   public addRecord(node: SubstituteNodeBase): void {
-    this._records.push(node)
+    this._records.add(node)
   }
 
-  public getSiblingsOf(node: SubstituteNodeBase): SubstituteNodeBase[] {
-    const siblingNodes = this.indexedRecords.get(node.key) ?? []
+  public getSiblingsOf(node: SubstituteNodeBase): RecordsSet<SubstituteNodeBase> {
+    const siblingNodes = this.indexedRecords.get(node.key) ?? new RecordsSet()
     return siblingNodes.filter(siblingNode => siblingNode !== node)
   }
 
   public [inspect.custom](_: number, options: InspectOptions): string {
     const entries = [...this.indexedRecords.entries()]
-    return entries.map(([key, value]) => `\n  ${key.toString()}: {\n${value.map(v => `    ${inspect(v, options)}`).join(',\n')}\n  }`).join()
+    return entries.map(
+      ([key, value]) => `\n  ${key.toString()}: {\n${[...value.map(v => `    ${inspect(v, options)}`)].join(',\n')}\n  }`
+    ).join()
   }
 }

src/RecordsSet.ts

@@ -0,0 +1,43 @@
+type FilterFunction<T> = (item: T) => boolean
+type MapperFunction<T, R> = (item: T) => R
+type Transformer<T, R> = { type: 'filter', fnc: FilterFunction<T> } | { type: 'mapper', fnc: MapperFunction<T, R> }
+
+export class RecordsSet<T> extends Set<T> {
+  private _transformer: Transformer<any, any>
+  private _prevIter: RecordsSet<T>
+
+  constructor(value?: Iterable<T> | readonly T[]) {
+    super(value instanceof RecordsSet ? undefined : value)
+    if (value instanceof RecordsSet) this._prevIter = value
+  }
+
+  filter(predicate: (item: T) => boolean): RecordsSet<T> {
+    const newInstance = new RecordsSet<T>(this)
+    newInstance._transformer = { type: 'filter', fnc: predicate }
+    return newInstance
+  }
+
+  map<R>(predicate: (item: T) => R): RecordsSet<R> {
+    const newInstance = new RecordsSet<R | T>(this)
+    newInstance._transformer = { type: 'mapper', fnc: predicate }
+    return newInstance as RecordsSet<R>
+  }
+
+  *[Symbol.iterator](): IterableIterator<T> {
+    yield* this.values()
+  }
+
+  private *applyTransform(itarable: Iterable<T>): IterableIterator<T> {
+    const transform = this._transformer
+    if (typeof transform === 'undefined') return yield* itarable
+    for (const value of itarable) {
+      if (transform.type === 'mapper') yield transform.fnc(value)
+      if (transform.type === 'filter' && transform.fnc(value)) yield value
+    }
+  }
+
+  *values(): IterableIterator<T> {
+    if (this._prevIter instanceof RecordsSet) yield* this.applyTransform(this._prevIter)
+    yield* this.applyTransform(super.values())
+  }
+}

src/Substitute.ts

@@ -15,18 +15,17 @@ export class Substitute extends SubstituteBase {
 
   constructor() {
     super()
-    this._proxy = new Proxy(
+    this._proxy = createSubstituteProxy(
       this,
-      createSubstituteProxy<Substitute>({
+      {
         get: (target, _property, _, node) => {
           if (target.context.disableAssertions) node.disableAssertions()
-        },
-        set: () => { }
+        }
         // apply: (target, _, args, __, proxy) => {
         // const rootProperty = proxy.get(target, '()', proxy) TODO: Implement to support callable interfaces
         // return Reflect.apply(rootProperty, rootProperty, args)
         // }
-      })
+      }
     )
   }
 

src/SubstituteNode.ts

@@ -1,59 +1,60 @@
 import { inspect, InspectOptions } from 'util'
 
-import { PropertyType, isSubstitutionMethod, isAssertionMethod, SubstitutionMethod, textModifier } from './Utilities'
+import { PropertyType, isSubstitutionMethod, isAssertionMethod, AssertionMethod, SubstitutionMethod, textModifier, isSubstituteMethod } from './Utilities'
 import { SubstituteException } from './SubstituteException'
 import { RecordedArguments } from './RecordedArguments'
 import { SubstituteNodeBase } from './SubstituteNodeBase'
 import { SubstituteBase } from './SubstituteBase'
 import { createSubstituteProxy } from './SubstituteProxy'
 
+type SubstituteContext = SubstitutionMethod | AssertionMethod | 'none'
+
 export class SubstituteNode extends SubstituteNodeBase<SubstituteNode> {
   private _proxy: SubstituteNode
   private _propertyType: PropertyType = PropertyType.property
   private _accessorType: 'get' | 'set' = 'get'
   private _recordedArguments: RecordedArguments = RecordedArguments.none()
 
-  private _hasSubstitution: boolean = false
-  private _isSubstitution: boolean = false
-
+  private _context: SubstituteContext = 'none'
   private _disabledAssertions: boolean = false
-  private _isAssertion: boolean = false
 
   constructor(property: PropertyKey, parent: SubstituteNode | SubstituteBase) {
     super(property, parent)
-    this._proxy = new Proxy(
+    this._proxy = createSubstituteProxy(
       this,
-      createSubstituteProxy<SubstituteNode>({
-        get: (target, _, __, node) => {
-          if (target.isAssertion) node.executeAssertion()
+      {
+        get: (node, _, __, nextNode) => {
+          if (node.isAssertion) nextNode.executeAssertion()
         },
-        set: (target, _, __, ___, node) => {
-          if (target.isAssertion) node.executeAssertion()
+        set: (node, _, __, ___, nextNode) => {
+          if (node.isAssertion) nextNode.executeAssertion()
         },
-        apply: (target, _, rawArguments) => {
-          target.handleMethod(rawArguments)
-          return target.isIntermediateNode() && target.parent.isAssertion
-            ? target.executeAssertion()
-            : target.read()
+        apply: (node, _, rawArguments) => {
+          node.handleMethod(rawArguments)
+          return node.parent?.isAssertion ?? false ? node.executeAssertion() : node.read()
         }
-      })
+      }
     )
   }
 
   public get proxy() {
     return this._proxy
   }
 
-  get isSubstitution(): boolean {
-    return this._isSubstitution
+  get context(): SubstituteContext {
+    return this._context
   }
 
-  get hasSubstitution(): boolean {
-    return this._hasSubstitution
+  get hasContext(): boolean {
+    return this.context !== 'none'
+  }
+
+  get isSubstitution(): boolean {
+    return isSubstitutionMethod(this.context)
   }
 
   get isAssertion(): boolean {
-    return this._isAssertion
+    return isAssertionMethod(this.context)
   }
 
   get property() {
@@ -76,24 +77,16 @@ export class SubstituteNode extends SubstituteNodeBase<SubstituteNode> {
     return this._disabledAssertions
   }
 
-  public labelAsSubstitution(): void {
-    this._isSubstitution = true
-  }
-
-  public enableSubstitution(): void {
-    this._hasSubstitution = true
-  }
-
-  public labelAsAssertion(): void {
-    this._isAssertion = true
+  public assignContext(context: SubstituteContext): void {
+    this._context = context
   }
 
   public disableAssertions() {
     this._disabledAssertions = true
   }
 
   public read(): SubstituteNode | void | never {
-    if (this.isSubstitution) return
+    if (this.parent?.isSubstitution ?? false) return
     if (this.isAssertion) return this.proxy
 
     const mostSuitableSubstitution = this.getMostSuitableSubstitution()
@@ -108,7 +101,7 @@ export class SubstituteNode extends SubstituteNodeBase<SubstituteNode> {
   }
 
   public executeSubstitution(contextArguments: RecordedArguments) {
-    const substitutionMethod = this.child.property as SubstitutionMethod
+    const substitutionMethod = this.context as SubstitutionMethod
     const substitutionValue = this.child.recordedArguments.value.length > 1
       ? this.child.recordedArguments.value.shift()
       : this.child.recordedArguments.value[0]
@@ -130,8 +123,7 @@ export class SubstituteNode extends SubstituteNodeBase<SubstituteNode> {
   }
 
   public executeAssertion(): void | never {
-    const siblings = this.getAllSiblings().filter(n => !n.isAssertion && !n.hasSubstitution && n.accessorType === this.accessorType) // isSubstitution should return this.parent.hasSubstitution
-
+    const siblings = [...this.getAllSiblings().filter(n => !n.hasContext && n.accessorType === this.accessorType)]
     if (!this.isIntermediateNode()) throw new Error('Not possible')
 
     const expectedCount = this.parent.recordedArguments.value[0] ?? undefined
@@ -165,40 +157,37 @@ export class SubstituteNode extends SubstituteNodeBase<SubstituteNode> {
   public handleMethod(rawArguments: any[]): void {
     this._propertyType = PropertyType.method
     this._recordedArguments = RecordedArguments.from(rawArguments)
+    if (!isSubstituteMethod(this.property)) return
 
-    if (!this.disabledAssertions && isAssertionMethod(this.property)) {
-      if (this.property === 'didNotReceive') this._recordedArguments = RecordedArguments.from([0])
-      this.labelAsAssertion()
-    }
+    if (this.isIntermediateNode() && isSubstitutionMethod(this.property)) return this.parent.assignContext(this.property)
+    if (this.disabledAssertions || !this.isHead()) return
 
-    if (isSubstitutionMethod(this.property)) {
-      this.labelAsSubstitution()
-      if (this.isIntermediateNode()) this.parent.enableSubstitution()
-    }
+    this.assignContext(this.property)
+    if (this.context === 'didNotReceive') this._recordedArguments = RecordedArguments.from([0])
   }
 
   private getMostSuitableSubstitution(): SubstituteNode {
-    const nodes = this.getAllSiblings().filter(node => node.hasSubstitution &&
+    const nodes = this.getAllSiblings().filter(node => node.isSubstitution &&
       node.propertyType === this.propertyType &&
       node.recordedArguments.match(this.recordedArguments)
     )
-    const sortedNodes = RecordedArguments.sort(nodes)
+    const sortedNodes = RecordedArguments.sort([...nodes])
     return sortedNodes[0]
   }
 
   protected printableForm(_: number, options: InspectOptions): string {
-    const isMockNode = this.hasSubstitution || this.isAssertion
+    const hasContext = this.hasContext
     const args = inspect(this.recordedArguments, options)
-    const label = this.hasSubstitution
+    const label = this.isSubstitution
       ? '=> '
       : this.isAssertion
         ? `${this.child.property.toString()}`
         : ''
-    const s = isMockNode
-      ? ` ${label}${inspect(this.child.recordedArguments, options)}`
+    const s = hasContext
+      ? ` ${label}${inspect(this.child?.recordedArguments, options)}`
       : ''
 
     const printableNode = `${this.propertyType}<${this.property.toString()}>: ${args}${s}`
-    return isMockNode ? textModifier.italic(printableNode) : printableNode
+    return hasContext ? textModifier.italic(printableNode) : printableNode
   }
 }

src/SubstituteNodeBase.ts

@@ -1,27 +1,25 @@
 import { SubstituteBase } from './SubstituteBase'
 import { Substitute } from './Substitute'
+import { RecordsSet } from './RecordsSet'
 
 export abstract class SubstituteNodeBase<T extends SubstituteNodeBase = SubstituteNodeBase<any>> extends SubstituteBase {
-  private _parent?: T = undefined
+  private _parent?: T
   private _child?: T
   private _head: T & { parent: undefined }
   private _root: Substitute
 
-  constructor(private _key: PropertyKey, caller: T | SubstituteBase) {
+  constructor(private _key: PropertyKey, caller: SubstituteBase) {
     super()
 
     if (caller instanceof Substitute) {
       caller.recorder.addIndexedRecord(this)
       this._root = caller
     }
+    if (!(caller instanceof SubstituteNodeBase)) return
 
-    if (caller instanceof SubstituteNodeBase) {
-      this._parent = caller
-      this._head = caller.head as T & { parent: undefined }
-      caller.child = this
-    }
-
-    this.root.recorder.addRecord(this)
+    this._parent = caller as T
+    this._head = caller.head as T & { parent: undefined }
+    caller.child = this
   }
 
   get key(): PropertyKey {
@@ -60,12 +58,8 @@ export abstract class SubstituteNodeBase<T extends SubstituteNodeBase = Substitu
     return !this.isHead()
   }
 
-  protected getAllSiblings(): T[] {
-    return this.root.recorder.getSiblingsOf(this) as T[]
-  }
-
-  protected getAllSiblingsOfHead(): T[] {
-    return this.root.recorder.getSiblingsOf(this.head) as T[]
+  protected getAllSiblings(): RecordsSet<T> {
+    return this.root.recorder.getSiblingsOf(this) as RecordsSet<T>
   }
 
   public abstract read(): void