Rename interfaces to I...

2015-11-25 21:47:10 -08:00 · 2015-11-25 21:47:10 -08:00 · 00494217c7
--- a/adapter/lineNumberTransformer.ts
+++ b/adapter/lineNumberTransformer.ts
@ -21,11 +21,11 @@ export class LineNumberTransformer implements IDebugTransformer  {
        args.lines = args.lines.map(line => this.convertClientLineToTarget(line));
    }

-    public setBreakpointsResponse(response: SetBreakpointsResponseBody): void {
+    public setBreakpointsResponse(response: ISetBreakpointsResponseBody): void {
        response.breakpoints.forEach(bp => bp.line = this.convertTargetLineToClient(bp.line));
    }

-    public stackTraceResponse(response: StackTraceResponseBody): void {
+    public stackTraceResponse(response: IStackTraceResponseBody): void {
        response.stackFrames.forEach(frame => frame.line = this.convertTargetLineToClient(frame.line));
    }

--- a/adapter/pathTransformer.ts
+++ b/adapter/pathTransformer.ts
@ -74,7 +74,7 @@ export class PathTransformer implements IDebugTransformer {
        }
    }

-    public stackTraceResponse(response: StackTraceResponseBody): void {
+    public stackTraceResponse(response: IStackTraceResponseBody): void {
        response.stackFrames.forEach(frame => {
            // Try to resolve the url to a path in the workspace. If it's not in the workspace,
            // just use the script.url as-is.
--- a/adapter/sourceMaps/sourceMapTransformer.ts
+++ b/adapter/sourceMaps/sourceMapTransformer.ts
@ -87,7 +87,7 @@ export class SourceMapTransformer implements IDebugTransformer {
    /**
     * Apply sourcemapping back to authored files from the response
     */
-    public setBreakpointsResponse(response: SetBreakpointsResponseBody, requestSeq: number): void {
+    public setBreakpointsResponse(response: ISetBreakpointsResponseBody, requestSeq: number): void {
        if (this._sourceMaps && this._requestSeqToSetBreakpointsArgs.has(requestSeq)) {
            const args = this._requestSeqToSetBreakpointsArgs.get(requestSeq);
            response.breakpoints.forEach(bp => {
@ -111,7 +111,7 @@ export class SourceMapTransformer implements IDebugTransformer {
    /**
     * Apply sourcemapping to the stacktrace response
     */
-    public stackTraceResponse(response: StackTraceResponseBody): void {
+    public stackTraceResponse(response: IStackTraceResponseBody): void {
        if (this._sourceMaps) {
            response.stackFrames.forEach(stackFrame => {
                const mapped = this._sourceMaps.MapToSource(stackFrame.source.path, stackFrame.line, stackFrame.column);
--- a/test/adapter/lineNumberTransformer.test.ts
+++ b/test/adapter/lineNumberTransformer.test.ts
@ -51,7 +51,7 @@ suite('LineNumberTransformer', () => {
    });

    suite('setBreakpointsResponse()', () => {
-        function getResponse(lines: number[]): SetBreakpointsResponseBody {
+        function getResponse(lines: number[]): ISetBreakpointsResponseBody {
            return {
                breakpoints: lines.map(line => ({ verified: true, line: line }))
            };
@ -72,7 +72,7 @@ suite('LineNumberTransformer', () => {
    });

    suite('stackTraceResponse()', () => {
-        function getResponse(lines: number[]): StackTraceResponseBody {
+        function getResponse(lines: number[]): IStackTraceResponseBody {
            return {
                stackFrames: lines.map(line => ({ id: 0, name: '', line, column: 0 }))
            };
--- a/test/adapter/sourceMaps/sourceMapTransformer.test.ts
+++ b/test/adapter/sourceMaps/sourceMapTransformer.test.ts
@ -108,7 +108,7 @@ suite('SourceMapTransformer', () => {
        });

        suite('setBreakpointsResponse()', () => {
-            function getResponseBody(lines: number[], column?: number): SetBreakpointsResponseBody {
+            function getResponseBody(lines: number[], column?: number): ISetBreakpointsResponseBody {
                return {
                    breakpoints: lines.map(line => {
                        const bp = { line, verified: true };
@ -150,7 +150,7 @@ suite('SourceMapTransformer', () => {
    });

    suite('stackTraceResponse', () => {
-        function getResponseBody(path: string, lines: number[]): StackTraceResponseBody {
+        function getResponseBody(path: string, lines: number[]): IStackTraceResponseBody {
            return {
                stackFrames: lines.map((line, i) => ({
                    id: i,
--- a/test/webkit/webKitDebugAdapter.test.ts
+++ b/test/webkit/webKitDebugAdapter.test.ts
@ -108,7 +108,7 @@ suite('WebKitDebugAdapter', () => {
            });
        }

-        function makeExpectedResponse(lines: number[], cols?: number[]): SetBreakpointsResponseBody {
+        function makeExpectedResponse(lines: number[], cols?: number[]): ISetBreakpointsResponseBody {
            const breakpoints = lines.map((line, i) => ({
                line,
                column: cols ? cols[i] : 0,
--- a/webkit/webKitAdapterInterfaces.d.ts
+++ b/webkit/webKitAdapterInterfaces.d.ts
@ -28,31 +28,31 @@ interface ISetBreakpointsArgs extends DebugProtocol.SetBreakpointsArguments {
 * The ResponseBody interfaces are copied from debugProtocol.d.ts which defines these inline in the Response interfaces.
 * They should always match those interfaces, see the original for comments.
 */
-interface SetBreakpointsResponseBody {
+interface ISetBreakpointsResponseBody {
    breakpoints: DebugProtocol.Breakpoint[];
 }

-interface SourceResponseBody {
+interface ISourceResponseBody {
    content: string;
 }

-interface ThreadsResponseBody {
+interface IThreadsResponseBody {
    threads: DebugProtocol.Thread[];
 }

-interface StackTraceResponseBody {
+interface IStackTraceResponseBody {
    stackFrames: DebugProtocol.StackFrame[];
 }

-interface ScopesResponseBody {
+interface IScopesResponseBody {
    scopes: DebugProtocol.Scope[];
 }

-interface VariablesResponseBody {
+interface IVariablesResponseBody {
    variables: DebugProtocol.Variable[];
 }

-interface EvaluateResponseBody {
+interface IEvaluateResponseBody {
    result: string;
    variablesReference: number;
 }
@ -65,7 +65,7 @@ interface IDebugAdapter {
    launch(args: ILaunchRequestArgs): PromiseOrNot<void>;
    disconnect(): PromiseOrNot<void>;
    attach(args: IAttachRequestArgs): PromiseOrNot<void>;
-    setBreakpoints(args: DebugProtocol.SetBreakpointsArguments): PromiseOrNot<SetBreakpointsResponseBody>;
+    setBreakpoints(args: DebugProtocol.SetBreakpointsArguments): PromiseOrNot<ISetBreakpointsResponseBody>;
    setExceptionBreakpoints(args: DebugProtocol.SetExceptionBreakpointsArguments): PromiseOrNot<void>;

    continue(): PromiseOrNot<void>;
@ -74,12 +74,12 @@ interface IDebugAdapter {
    stepOut(): PromiseOrNot<void>;
    pause(): PromiseOrNot<void>;

-    stackTrace(args: DebugProtocol.StackTraceArguments): PromiseOrNot<StackTraceResponseBody>;
-    scopes(args: DebugProtocol.ScopesArguments): PromiseOrNot<ScopesResponseBody>;
-    variables(args: DebugProtocol.VariablesArguments): PromiseOrNot<VariablesResponseBody>;
-    source(args: DebugProtocol.SourceArguments): PromiseOrNot<SourceResponseBody>;
-    threads(): PromiseOrNot<ThreadsResponseBody>;
-    evaluate(args: DebugProtocol.EvaluateArguments): PromiseOrNot<EvaluateResponseBody>;
+    stackTrace(args: DebugProtocol.StackTraceArguments): PromiseOrNot<IStackTraceResponseBody>;
+    scopes(args: DebugProtocol.ScopesArguments): PromiseOrNot<IScopesResponseBody>;
+    variables(args: DebugProtocol.VariablesArguments): PromiseOrNot<IVariablesResponseBody>;
+    source(args: DebugProtocol.SourceArguments): PromiseOrNot<ISourceResponseBody>;
+    threads(): PromiseOrNot<IThreadsResponseBody>;
+    evaluate(args: DebugProtocol.EvaluateArguments): PromiseOrNot<IEvaluateResponseBody>;
 }

 interface IDebugTransformer {
@ -95,13 +95,13 @@ interface IDebugTransformer {
    source?(args: DebugProtocol.SourceArguments, requestSeq?: number): PromiseOrNot<void>;
    evaluate?(args: DebugProtocol.EvaluateArguments, requestSeq?: number): PromiseOrNot<void>;

-    setBreakpointsResponse?(response: SetBreakpointsResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    stackTraceResponse?(response: StackTraceResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    scopesResponse?(response: ScopesResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    variablesResponse?(response: VariablesResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    sourceResponse?(response: SourceResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    threadsResponse?(response: ThreadsResponseBody, requestSeq?: number): PromiseOrNot<void>;
-    evaluateResponse?(response: EvaluateResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    setBreakpointsResponse?(response: ISetBreakpointsResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    stackTraceResponse?(response: IStackTraceResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    scopesResponse?(response: IScopesResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    variablesResponse?(response: IVariablesResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    sourceResponse?(response: ISourceResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    threadsResponse?(response: IThreadsResponseBody, requestSeq?: number): PromiseOrNot<void>;
+    evaluateResponse?(response: IEvaluateResponseBody, requestSeq?: number): PromiseOrNot<void>;

    scriptParsed?(event: DebugProtocol.Event);
 }
--- a/webkit/webKitDebugAdapter.ts
+++ b/webkit/webKitDebugAdapter.ts
@ -283,7 +283,7 @@ export class WebKitDebugAdapter implements IDebugAdapter {
        return Promise.resolve<void>();
    }

-    public setBreakpoints(args: ISetBreakpointsArgs): Promise<SetBreakpointsResponseBody> {
+    public setBreakpoints(args: ISetBreakpointsArgs): Promise<ISetBreakpointsResponseBody> {
        let targetScriptUrl: string;
        if (args.source.path) {
            targetScriptUrl = args.source.path;
@ -412,7 +412,7 @@ export class WebKitDebugAdapter implements IDebugAdapter {
            .then(() => { });
    }

-    public stackTrace(args: DebugProtocol.StackTraceArguments): StackTraceResponseBody {
+    public stackTrace(args: DebugProtocol.StackTraceArguments): IStackTraceResponseBody {
        // Only process at the requested number of frames, if 'levels' is specified
        let stack = this._currentStack;
        if (args.levels) {
@ -455,7 +455,7 @@ export class WebKitDebugAdapter implements IDebugAdapter {
        return { stackFrames };
    }

-    public scopes(args: DebugProtocol.ScopesArguments): ScopesResponseBody {
+    public scopes(args: DebugProtocol.ScopesArguments): IScopesResponseBody {
        const scopes = this._currentStack[args.frameId].scopeChain.map((scope: WebKitProtocol.Debugger.Scope, i: number) => {
            const scopeHandle: IScopeVarHandle = { objectId: scope.object.objectId };
            if (i === 0) {
@ -473,7 +473,7 @@ export class WebKitDebugAdapter implements IDebugAdapter {
        return { scopes };
    }

-    public variables(args: DebugProtocol.VariablesArguments): Promise<VariablesResponseBody> {
+    public variables(args: DebugProtocol.VariablesArguments): Promise<IVariablesResponseBody> {
        const handle = this._variableHandles.get(args.variablesReference);
        if (handle.objectId === WebKitDebugAdapter.EXCEPTION_VALUE_ID) {
            // If this is the special marker for an exception value, create a fake property descriptor so the usual route can be used
@ -511,13 +511,13 @@ export class WebKitDebugAdapter implements IDebugAdapter {
        }
    }

-    public source(args: DebugProtocol.SourceArguments): Promise<SourceResponseBody> {
+    public source(args: DebugProtocol.SourceArguments): Promise<ISourceResponseBody> {
        return this._webKitConnection.debugger_getScriptSource(sourceReferenceToScriptId(args.sourceReference)).then(webkitResponse => {
            return { content: webkitResponse.result.scriptSource };
        });
    }

-    public threads(): ThreadsResponseBody {
+    public threads(): IThreadsResponseBody {
        return {
            threads: [
                {
@ -528,7 +528,7 @@ export class WebKitDebugAdapter implements IDebugAdapter {
        };
    }

-    public evaluate(args: DebugProtocol.EvaluateArguments): Promise<EvaluateResponseBody> {
+    public evaluate(args: DebugProtocol.EvaluateArguments): Promise<IEvaluateResponseBody> {
        let evalPromise: Promise<any>;
        if (this.paused) {
            const callFrameId = this._currentStack[args.frameId].callFrameId;