Polishing

Author: EmilianoSanchez

src/storages/AbstractSplitsCacheAsync.ts

@@ -8,15 +8,15 @@ import { objectAssign } from '../utils/lang/objectAssign';
  */
 export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
 
-  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
   protected abstract addSplit(split: ISplit): Promise<boolean>
   protected abstract removeSplit(name: string): Promise<boolean>
+  protected abstract setChangeNumber(changeNumber: number): Promise<boolean | void>
 
-  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): Promise<boolean> {
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean> {
     return Promise.all([
       this.setChangeNumber(changeNumber),
-      Promise.all(addedFFs.map(addedFF => this.addSplit(addedFF))),
-      Promise.all(removedFFs.map(removedFF => this.removeSplit(removedFF.name)))
+      Promise.all(toAdd.map(addedFF => this.addSplit(addedFF))),
+      Promise.all(toRemove.map(removedFF => this.removeSplit(removedFF.name)))
     ]).then(([, added, removed]) => {
       return added.some(result => result) || removed.some(result => result);
     });

src/storages/AbstractSplitsCacheSync.ts

@@ -9,14 +9,14 @@ import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
  */
 export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
-  protected abstract setChangeNumber(changeNumber: number): boolean | void
   protected abstract addSplit(split: ISplit): boolean
   protected abstract removeSplit(name: string): boolean
+  protected abstract setChangeNumber(changeNumber: number): boolean | void
 
-  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): boolean {
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
     this.setChangeNumber(changeNumber);
-    const updated = addedFFs.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    return removedFFs.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
+    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
   }
 
   abstract getSplit(name: string): ISplit | null

src/storages/types.ts

@@ -177,7 +177,7 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): MaybeThenable<boolean>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): MaybeThenable<boolean>,
   getSplit(name: string): MaybeThenable<ISplit | null>,
   getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
@@ -196,7 +196,7 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): boolean,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean,
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
   getChangeNumber(): number,
@@ -211,7 +211,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  update(addedFFs: ISplit[], removedFFs: ISplit[], changeNumber: number): Promise<boolean>,
+  update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): Promise<boolean>,
   getSplit(name: string): Promise<ISplit | null>,
   getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
   getChangeNumber(): Promise<number>,