refactor(project): remove all interfaces

lifenautjoe · Nov 6, 2017 · 85353ef · 85353ef
1 parent 2b00091
commit 85353ef
Show file tree

Hide file tree

Showing 7 changed files with 35 additions and 103 deletions.
diff --git a/src/errors.ts b/src/errors.ts
@@ -3,7 +3,7 @@
  */
 
 import { BaseError } from 'make-error';
-import { NoelEventImp } from './event';
+import { NoelEvent } from './event';
 
 export class NoelError extends BaseError {
     constructor(message: string) {
@@ -27,7 +27,7 @@ export class NoelEventError extends NoelError {
 }
 
 export class NoelEventReplayNotEnabled extends NoelEventError {
-    constructor(event: NoelEventImp) {
+    constructor(event: NoelEvent) {
         super(`Replay for event "${event.getName()}" is not enabled`);
         this.name = 'NoelEventReplayNotEnabled';
     }

diff --git a/src/event-listener-manager.ts b/src/event-listener-manager.ts
@@ -2,14 +2,13 @@
  * @author Joel Hernandez <[email protected]>
  */
 
-import { NoelEventListenerManager } from './interfaces';
 import { NoelEventListener } from './types';
-import { NoelEventImp } from './event';
+import { NoelEvent } from './event';
 import { NoelEventReplayNotEnabled } from './errors';
 import NoelImp from './noel';
 
-export class NoelEventListenerManagerImp implements NoelEventListenerManager {
-    constructor(private listener: NoelEventListener, private event: NoelEventImp, private noel: NoelImp) {}
+export class NoelEventListenerManager {
+    constructor(private listener: NoelEventListener, private event: NoelEvent, private noel: NoelImp) {}
 
     remove() {
         // We remove it from noel instead of the event itself because noel will remove it

diff --git a/src/event.ts b/src/event.ts
@@ -1,13 +1,14 @@
 /**
  * @author Joel Hernandez <[email protected]>
  */
-import { NoelEvent, NoelEventConfig, NoelEventListenerManager, NoelLogger } from './interfaces';
+import { NoelEventConfig } from './interfaces';
 import { NoelEventListener } from './types';
-import { NoelEventListenerManagerImp } from './event-listener-manager';
+import { NoelEventListenerManager } from './event-listener-manager';
 import { NoelBufferSizeNotValidError, NoelEventConfigError, NoelEventListenerError, NoelEventReplayNotEnabled } from './errors';
 import NoelImp from './noel';
+import { NoelLogger } from './logger';
 
-export class NoelEventImp implements NoelEvent {
+export class NoelEvent {
     private noel: NoelImp;
     private name: string;
     private replayEnabled: boolean;
@@ -61,7 +62,7 @@ export class NoelEventImp implements NoelEvent {
         if (typeof listener !== 'function') throw new NoelEventListenerError('Given listener is not a function');
         const listeners = this.getListeners();
         listeners.add(listener);
-        return new NoelEventListenerManagerImp(listener, this, this.noel);
+        return new NoelEventListenerManager(listener, this, this.noel);
     }
 
     removeListener(listener: NoelEventListener): void {

diff --git a/src/interfaces.ts b/src/interfaces.ts
@@ -1,40 +1,8 @@
 /**
  * @author Joel Hernandez <[email protected]>
  */
-import { NoelEventListener } from './types';
 import NoelImp from './noel';
-
-export interface Noel {
-    replayIsEnabled(): boolean;
-
-    enableReplay(): void;
-
-    disableReplay(): void;
-
-    setReplayBufferSize(buffer: number): void;
-
-    clearReplayBufferForEvent(eventName: string): void;
-
-    clearEventsReplayBuffers(): void;
-
-    setLogger(logger: NoelLogger): void;
-
-    enableNoEventListenersWarning(): void;
-
-    disableNoEventListenersWarning(): void;
-
-    on(eventName: string, listener: NoelEventListener): NoelEventListenerManager;
-
-    emit(eventName: string, ...eventArgs: Array<any>): void;
-
-    removeListener(eventName: string, listener: NoelEventListener): void;
-
-    removeAllListeners(eventName: string): void;
-
-    getEvent(eventName: string): NoelEvent;
-
-    removeEvent(eventName: string): void;
-}
+import { NoelLogger } from './logger';
 
 export interface NoelConfig {
     replay?: boolean;
@@ -43,38 +11,6 @@ export interface NoelConfig {
     logger?: NoelLogger;
 }
 
-export interface NoelEventListenerManager {
-    remove(): void;
-
-    replay(bufferSize?: number): NoelEventListenerManager;
-}
-
-export interface NoelEvent {
-    setLogger(logger: NoelLogger): void;
-
-    enableNoListenersWarning(): void;
-
-    disableNoListenersWarning(): void;
-
-    enableReplay(): void;
-
-    disableReplay(): void;
-
-    emit(...eventArgs: Array<any>): void;
-
-    on(listener: NoelEventListener): NoelEventListenerManager;
-
-    removeListener(listener: NoelEventListener): void;
-
-    clearReplayBuffer(): void;
-
-    removeAllListeners(): void;
-
-    setReplayBufferSize(replayBufferSize: number): void;
-
-    getReplayBufferAmount(replayBufferAmount: number): Array<any>;
-}
-
 export interface NoelEventConfig {
     name: string;
     logger?: NoelLogger;
@@ -83,7 +19,3 @@ export interface NoelEventConfig {
     noListenersWarning?: boolean;
     noel: NoelImp;
 }
-
-export interface NoelLogger {
-    warn(warn: string): void;
-}
diff --git a/src/logger.ts b/src/logger.ts
@@ -1,14 +1,13 @@
 /**
  * @author Joel Hernandez <[email protected]>
  */
-import { NoelLogger } from './interfaces';
 
 const consolePoly = {
     warn: () => {}
 };
 
-export class NoelLoggerImp implements NoelLogger {
-    private console: any;
+export class NoelLogger {
+    private console?: any;
 
     constructor() {
         this.console = typeof console === 'undefined' ? consolePoly : console;

diff --git a/src/noel.ts b/src/noel.ts
@@ -2,18 +2,19 @@
 // import "core-js/fn/array.find"
 // ...
 
-import { Noel, NoelConfig, NoelEvent, NoelEventListenerManager, NoelLogger } from './interfaces';
+import { NoelConfig } from './interfaces';
 import { NoelEventListener } from './types';
 import { NoelBufferSizeNotValidError, NoelReplayNotEnabledError } from './errors';
-import { NoelEventImp } from './event';
-import { NoelLoggerImp } from './logger';
+import { NoelEvent } from './event';
+import { NoelLogger } from './logger';
+import { NoelEventListenerManager } from './event-listener-manager';
 
-const defaultLogger = new NoelLoggerImp();
+const defaultLogger = new NoelLogger();
 
-export class NoelImp implements Noel {
+export class Noel {
     private noEventListenersWarning: boolean;
 
-    private eventsMap: Map<string, NoelEventImp> | null = null;
+    private eventsMap: Map<string, NoelEvent> | null = null;
 
     private logger: NoelLogger;
 
@@ -53,7 +54,7 @@ export class NoelImp implements Noel {
         }
     }
 
-    removeEventListener(event: NoelEventImp, listener: NoelEventListener) {
+    removeEventListener(event: NoelEvent, listener: NoelEventListener) {
         event.removeListener(listener);
         const eventListenersCount = event.countListeners();
         if (eventListenersCount === 0) this.removeEvent(event.getName());
@@ -153,8 +154,8 @@ export class NoelImp implements Noel {
         }
     }
 
-    private makeEvent(eventName: string): NoelEventImp {
-        return new NoelEventImp({
+    private makeEvent(eventName: string): NoelEvent {
+        return new NoelEvent({
             name: eventName,
             replay: this.replayEnabled,
             replayBufferSize: this.replayBufferSize,
@@ -194,12 +195,12 @@ export class NoelImp implements Noel {
         }
     }
 
-    private getEvents(): IterableIterator<NoelEventImp> {
+    private getEvents(): IterableIterator<NoelEvent> {
         const eventsMap = this.getEventsMap();
         return eventsMap.values();
     }
 
-    private getEventsMap(): Map<string, NoelEventImp> {
+    private getEventsMap(): Map<string, NoelEvent> {
         return this.eventsMap || (this.eventsMap = new Map());
     }
 }
@@ -210,4 +211,4 @@ export * from './interfaces';
 
 export * from './types';
 
-export default NoelImp;
+export default Noel;
diff --git a/test/noel.test.ts b/test/noel.test.ts
@@ -1,8 +1,8 @@
 import Noel from '../src/noel';
-import { NoelLoggerImp } from '../src/logger';
+import { NoelLogger } from '../src/logger';
 import { NoelBufferSizeNotValidError, NoelEventConfigError, NoelEventListenerError, NoelEventReplayNotEnabled, NoelReplayNotEnabledError } from '../src/errors';
-import { NoelEventListenerManagerImp } from '../src/event-listener-manager';
-import { NoelEventImp } from '../src/event';
+import { NoelEventListenerManager } from '../src/event-listener-manager';
+import { NoelEvent } from '../src/event';
 
 describe('Noel', () => {
     const defaultReplayEnabledVal = true;
@@ -38,7 +38,7 @@ describe('Noel', () => {
 
     describe('constructor(config)', () => {
         it('should override default config', () => {
-            const logger = new NoelLoggerImp();
+            const logger = new NoelLogger();
             const replay = false;
             const replayBufferSize = 20;
             const noEventListenersWarning = false;
@@ -89,7 +89,7 @@ describe('Noel', () => {
                 const noel = new Noel();
                 const eventName = generateRandomString();
                 const event = noel.getEvent(eventName);
-                expect(event).toBeInstanceOf(NoelEventImp);
+                expect(event).toBeInstanceOf(NoelEvent);
                 expect(noel['eventsMap'].get(eventName)).toBe(event);
             });
         });
@@ -136,7 +136,7 @@ describe('Noel', () => {
                 noel.on(eventName, listener);
                 noel.removeListener(eventName, listener);
                 const event = noel['eventsMap'].get(eventName);
-                expect(event).toBeInstanceOf(NoelEventImp);
+                expect(event).toBeInstanceOf(NoelEvent);
                 expect(event['listeners'].has(listener)).toBe(false);
             });
         });
@@ -623,15 +623,15 @@ describe('Noel', () => {
                 const eventListener = () => {};
                 noel.on(eventName, eventListener);
                 const event = noel['eventsMap'].get(eventName);
-                expect(event).toBeInstanceOf(NoelEventImp);
+                expect(event).toBeInstanceOf(NoelEvent);
                 expect(event['name']).toBe(eventName);
                 expect(event['listeners'].has(eventListener)).toBeTruthy();
             });
 
             it('should return an EventListenerManager', () => {
                 const noel = new Noel();
                 const eventListenerManager = noel.on('anotherEvent', () => {});
-                expect(eventListenerManager).toBeInstanceOf(NoelEventListenerManagerImp);
+                expect(eventListenerManager).toBeInstanceOf(NoelEventListenerManager);
             });
         });
 
@@ -666,7 +666,7 @@ describe('Noel', () => {
                         eventListenerManager.remove();
 
                         const event = noel['eventsMap'].get(eventName);
-                        expect(event).toBeInstanceOf(NoelEventImp);
+                        expect(event).toBeInstanceOf(NoelEvent);
 
                         const eventListeners = event['listeners'];
                         otherListeners.forEach(otherListener => {