forked from DonJayamanne/pythonVSCode
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathproxy.ts
More file actions
143 lines (135 loc) · 6.1 KB
/
proxy.ts
File metadata and controls
143 lines (135 loc) · 6.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
'use strict';
import * as vscode from 'vscode';
import * as path from 'path';
import * as fs from 'fs';
import * as child_process from 'child_process';
import {ExtractResult} from './contracts';
import {execPythonFile} from '../common/utils';
import {IPythonSettings} from '../common/configSettings';
import {REFACTOR} from '../common/telemetryContracts';
import {sendTelemetryEvent, Delays} from '../common/telemetry';
const ROPE_PYTHON_VERSION = 'Currently code refactoring is only supported in Python 2.x';
const ERROR_PREFIX = '$ERROR';
export class RefactorProxy extends vscode.Disposable {
private _process: child_process.ChildProcess;
private _extensionDir: string;
private _previousOutData: string = '';
private _previousStdErrData: string = '';
private _startedSuccessfully: boolean = false;
private _commandResolve: (value?: any | PromiseLike<any>) => void;
private _commandReject: (reason?: any) => void;
private _initializeReject: (reason?: any) => void;
constructor(extensionDir: string, private pythonSettings: IPythonSettings, private workspaceRoot: string = vscode.workspace.rootPath) {
super(() => { });
this._extensionDir = extensionDir;
}
dispose() {
try {
this._process.kill();
}
catch (ex) {
}
this._process = null;
}
extractVariable<T>(document: vscode.TextDocument, name: string, filePath: string, range: vscode.Range): Promise<T> {
let command = { "lookup": "extract_variable", "file": filePath, "start": document.offsetAt(range.start).toString(), "end": document.offsetAt(range.end).toString(), "id": "1", "name": name };
return this.sendCommand<T>(JSON.stringify(command), REFACTOR.ExtractVariable);
}
extractMethod<T>(document: vscode.TextDocument, name: string, filePath: string, range: vscode.Range): Promise<T> {
let command = { "lookup": "extract_method", "file": filePath, "start": document.offsetAt(range.start).toString(), "end": document.offsetAt(range.end).toString(), "id": "1", "name": name };
return this.sendCommand<T>(JSON.stringify(command), REFACTOR.ExtractVariable);
}
private sendCommand<T>(command: string, telemetryEvent: string): Promise<T> {
let timer = new Delays();
return this.initialize(this.pythonSettings.pythonPath).then(() => {
return new Promise<T>((resolve, reject) => {
this._commandResolve = resolve;
this._commandReject = reject;
this._process.stdin.write(command + '\n');
});
}).then(value => {
timer.stop();
sendTelemetryEvent(telemetryEvent, null, timer.toMeasures());
return value;
}).catch(reason => {
timer.stop();
sendTelemetryEvent(telemetryEvent, null, timer.toMeasures());
return Promise.reject(reason);
});
}
private initialize(pythonPath: string): Promise<string> {
return new Promise<any>((resolve, reject) => {
this._initializeReject = reject;
let environmentVariables = { 'PYTHONUNBUFFERED': '1' };
for (let setting in process.env) {
if (!environmentVariables[setting]) {
environmentVariables[setting] = process.env[setting];
}
}
this._process = child_process.spawn(pythonPath, ['refactor.py', this.workspaceRoot],
{
cwd: path.join(this._extensionDir, 'pythonFiles'),
env: environmentVariables
});
this._process.stderr.on('data', this.handleStdError.bind(this));
this._process.on('error', this.handleError.bind(this));
let that = this;
this._process.stdout.on('data', data => {
let dataStr: string = data + '';
if (!that._startedSuccessfully && dataStr.startsWith('STARTED')) {
that._startedSuccessfully = true;
return resolve();
}
that.onData(data);
});
});
}
private handleStdError(data: string) {
// Possible there was an exception in parsing the data returned
// So append the data then parse it
let dataStr = this._previousStdErrData = this._previousStdErrData + data + '';
let errorResponse: { message: string, traceback: string }[];
try {
errorResponse = dataStr.split(/\r?\n/g).filter(line => line.length > 0).map(resp => JSON.parse(resp));
this._previousStdErrData = '';
}
catch (ex) {
// Possible we've only received part of the data, hence don't clear previousData
return;
}
if (typeof errorResponse[0].message !== 'string' || errorResponse[0].message.length === 0) {
errorResponse[0].message = errorResponse[0].traceback.split(/\r?\n/g).pop();
}
let errorMessage = errorResponse[0].message + '\n' + errorResponse[0].traceback;
if (this._startedSuccessfully) {
this._commandReject(`Refactor failed. ${errorMessage}`);
}
else {
this._initializeReject(`Refactor failed. ${errorMessage}`);
}
}
private handleError(error: Error) {
if (this._startedSuccessfully) {
return this._commandReject(error);
}
this._initializeReject(error);
}
private onData(data: string) {
if (!this._commandResolve) { return; }
// Possible there was an exception in parsing the data returned
// So append the data then parse it
let dataStr = this._previousOutData = this._previousOutData + data + '';
let response: any;
try {
response = dataStr.split(/\r?\n/g).filter(line => line.length > 0).map(resp => JSON.parse(resp));
this._previousOutData = '';
}
catch (ex) {
// Possible we've only received part of the data, hence don't clear previousData
return;
}
this.dispose();
this._commandResolve(response[0]);
this._commandResolve = null;
}
}