async function toggleProxy() {
const httpProxy: IHTTP_ProxyConf = getHttpProxy();
// let settingsTmpDir = (process.platform == 'win32' ? process.env.TMP : process.env.TMPDIR);
let settingsTmpDir = os.tmpdir();
let settingsTmpFile = path.join(settingsTmpDir, path.basename(settingsPath + '.tmp.' + Math.random()));
// debug
// console.log(settingsTmpDir);
// console.log(settingsTmpFile);
let line: string;
let array = await fs.readFileSync(settingsPath, 'utf8').toString().split("\n");
// Backup to extensionPath
let backupTmpFile = path.join(vscode.extensions.getExtension("satokaz.vscode-toggleproxy").extensionPath, path.basename(settingsPath + '.tmp'));
if(fs.statSync(settingsPath).size !== 0){
await fs.writeFileSync(backupTmpFile, array.join('\n'));
}
for (line in array) {
const matchResult = regExpMatchHttpProxy(array[line]);
// console.log('matchResult =', matchResult)
if (matchResult !== null) {
if (!matchResult.http_proxyEnabled) {
// should enable proxy
array[line] = array[line].replace(/\/\/\W/, "");
vscode.window.setStatusBarMessage('Enabled http.proxy', 2000);
} else {
// should disable proxy
array[line] = array[line].replace(/^/, "// ");
vscode.window.setStatusBarMessage('Disabled http.proxy', 2000);
}
}
}
await fs.writeFileSync(settingsTmpFile, array.join('\n'));
// copy tmp settings file to vscode settings
// console.log("fs.writeFileSync(settingsPath, fs.readFileSync(settingsTmpFile,\"utf-8\"), 'utf8');")
await fs.writeFileSync(settingsPath, await fs.readFileSync(settingsTmpFile,"utf-8"));
// console.log("fs.unlink(settingsTmpFile);");
await fs.unlink(settingsTmpFile);
// node-notifier
if (vscode.workspace.getConfiguration('toggleproxy')['notifier'] === true) {
notifier.notify({
'title': 'Visual Studio Code - Proxy Notification',
'message': !httpProxy.http_proxyEnabled ? 'Proxy Enabled: ' + httpProxy.http_proxy : 'Proxy Disabled',
'appName': 'Visual Studio Code',
'icon': path.join(vscode.extensions.getExtension("satokaz.vscode-toggleproxy").extensionPath, path.join('images', 'octicon-globe_128_0_7c05c9_none.png')) ,
timeout: 5
});
}
vscode.workspace.onDidChangeConfiguration(e => configureHttpRequest());
return void 0;
}
async function testCompletion(fileToTest: string, testCases: Array<[vscode.Position, string[]]>) {
const casesPath = path.join(rootDir!, 'fixtures', 'e2e-cases', fileToTest);
const ext = vscode.extensions.getExtension('wix.stylable-intelligence');
let testDoc: vscode.TextDocument;
if (ext) {
const doc = await vscode.workspace.openTextDocument(casesPath);
testDoc = doc;
await vscode.window.showTextDocument(testDoc);
await ext.activate();
return Promise.all(testCases.map(async ([position, expected]) => {
const list = await vscode.commands.executeCommand<vscode.CompletionList>(
'vscode.executeCompletionItemProvider',
testDoc.uri,
position
);
const labels = list!.items.map(x => x.label);
for (const entry of expected) {
if (!~labels.indexOf(entry)) {
assert.fail('', entry, 'missing expected item in completion list', '');
}
}
}));
} else {
throw new Error('Where is my extension?!!');
}
}
export async function getExtension() {
const cmt = vscode.extensions.getExtension<CMakeTools>('vector-of-bool.cmake-tools');
if (!cmt) {
throw new Error('Extension doesn\'t exist');
}
return cmt.isActive ? Promise.resolve(cmt.exports) : cmt.activate();
}
export function activate(context: vscode.ExtensionContext): any {
const extensionId = 'ms-vscode.csharp';
const extension = vscode.extensions.getExtension(extensionId);
const extensionVersion = extension.packageJSON.version;
const aiKey = extension.packageJSON.contributes.debuggers[0].aiKey;
const reporter = new TelemetryReporter(extensionId, extensionVersion, aiKey);
util.setExtensionPath(extension.extensionPath);
_channel = vscode.window.createOutputChannel('C#');
let logger = new Logger(text => _channel.append(text));
ensureRuntimeDependencies(extension, logger, reporter)
.then(() => {
// activate language services
OmniSharp.activate(context, reporter);
// register JSON completion & hover providers for project.json
context.subscriptions.push(addJSONProviders());
// activate coreclr-debug
coreclrdebug.activate(context, reporter, logger, _channel);
});
}
export function setup(context: ExtensionContext, entries: [Entry])
{
update_entries(entries)
const prettify_symbols_mode =
extensions.getExtension<PrettifySymbolsMode>("siegebell.prettify-symbols-mode")
if (prettify_symbols_mode) {
prettify_symbols_mode.activate().then(() =>
{
const substitutions = [] as [Substitution]
for (const entry of names) {
const sym = entry[0]
substitutions.push(
{
ugly: library.escape_regex(sym),
pretty: library.escape_regex(get_unicode(sym))
})
}
for (const language of ["isabelle", "isabelle-ml", "isabelle-output"]) {
context.subscriptions.push(
prettify_symbols_mode.exports.registerSubstitutions(
{
language: language,
substitutions: substitutions
}))
}
})
}
else {
window.showWarningMessage("Please install extension \"Prettify Symbols Model\" and restart!")
}
}
export function thisExtension() {
const ext = vscode.extensions.getExtension('vector-of-bool.cmake-tools');
if (!ext) {
throw new Error('Out own extension is null! What gives?');
}
return ext;
}
export async function activate(context: vscode.ExtensionContext) {
const formatter = new HTMLDocumentFormatter();
context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider('nornj', formatter));
const extension = vscode.extensions.getExtension(typeScriptExtensionId);
if (!extension) {
return;
}
await extension.activate();
if (!extension.exports || !extension.exports.getAPI) {
return;
}
const api = extension.exports.getAPI(0);
if (!api) {
return;
}
vscode.workspace.onDidChangeConfiguration(
e => {
if (e.affectsConfiguration(configurationSection)) {
synchronizeConfiguration(api);
}
},
undefined,
context.subscriptions
);
synchronizeConfiguration(api);
}
async function getRenderedSourceCode(): Promise<string> {
let printConfig = vscode.workspace.getConfiguration("print", null);
let printAndClose = printConfig.printAndClose ? " onload = \"window.print();window.close();\"" : "";
if (printConfig.renderMarkdown && commandArgs.fsPath.split('.').pop().toLowerCase() === "md") {
let markdownConfig = vscode.workspace.getConfiguration("markdown", null);
return `<!DOCTYPE html><html><head><title>${commandArgs.fsPath}</title>
<meta charset="utf-8"/>
<style>
html, body {
font-family: ${markdownConfig.preview.fontFamily};
font-size: ${markdownConfig.preview.fontSize}px;
line-height: ${markdownConfig.preview.lineHeight}em;
}
img {
max-width: 100%;
}
h1,h2,h3,h4,h5,h6 {
page-break-after:avoid;
page-break-inside:avoid;
}
</style>
${markdownConfig.styles.map((cssFilename: string) => `<link href="${cssFilename}" rel="stylesheet" />`).join("\n")}
</head>
<body${printAndClose}>${markdown_it().render(fs.readFileSync(commandArgs.fsPath).toString())}</body></html>`;
}
let x = vscode.extensions.getExtension("pdconsec.vscode-print");
if (!x) { throw new Error("Cannot resolve extension. Has the name changed? It is defined by the publisher and the extension name defined in package.json"); }
let stylePath = `${x.extensionPath}/node_modules/highlight.js/styles`;
let defaultCss = getFileText(`${stylePath}/default.css`);
let swatchCss = getFileText(`${stylePath}/${printConfig.colourScheme}.css`);
let sourceCode = await getSourceCode();
let renderedCode = "";
try {
renderedCode = hljs.highlight(sourceCode[0], sourceCode[1]).value;
}
catch (err) {
renderedCode = hljs.highlightAuto(sourceCode[1]).value;
}
var addLineNumbers = printConfig.lineNumbers === "on" || (printConfig.lineNumbers === "inherit" && vscode.window.activeTextEditor && (vscode.window.activeTextEditor.options.lineNumbers || 0) > 0);
if (addLineNumbers) {
var startLine = selection && !(selection.isEmpty || selection.isSingleLine) ? selection.start.line + 1 : 1;
renderedCode = renderedCode
.split("\n")
.map((line, i) => `<tr><td class="line-number">${startLine + i}</td><td class="line-text">${line}</td></tr>`)
.join("\n")
.replace("\n</td>", "</td>")
;
} else {
renderedCode = renderedCode
.split("\n")
.map((line, i) => `<tr><td class="line-text">${line}</td></tr>`)
.join("\n")
.replace("\n</td>", "</td>")
;
}
let editorConfig = vscode.workspace.getConfiguration("print", null);
let html = `<html><head><title>${commandArgs.fsPath}</title><style>body{margin:0;padding:0;tab-size:${editorConfig.tabSize}}\n${defaultCss}\r${swatchCss}\n${lineNumberCss.replace("{lineSpacing}", (printConfig.lineSpacing - 1).toString())}\n.hljs { max-width:100%; width:100%; font-family: Consolas, monospace; font-size: ${printConfig.fontSize}; }\n</style></head><body${printAndClose}><table class="hljs">${renderedCode}</table></body></html>`;
return html;
}
start() {
let projectPath: string = "";
if(vscode.workspace.rootPath !== undefined) {
projectPath = path.join(vscode.workspace.rootPath);
} else {
const savedFiles: vscode.TextDocument[] = vscode.workspace.textDocuments.filter((value) => {
return value.uri.scheme === 'file';
});
if(savedFiles.length > 0) {
projectPath = path.dirname(savedFiles[0].fileName);
} else {
// Bail out, lets use our extensionPath as projectPath
projectPath = vscode.extensions.getExtension("mjmcloug.vscode-elixir").extensionPath;
}
}
const optionsWin = { cwd: projectPath, windowsVerbatimArguments: true, stdio: 'pipe' };
const optionsUnix = { cwd: projectPath, stdio: 'pipe' };
if (process.platform === 'win32') {
this.p = cp.spawn('cmd', ['/s', '/c', '"' + [this.command].concat(this.args).concat(this.env).join(' ') + '"'], optionsWin);
}
else {
this.p = cp.spawn(this.command, this.args.concat(this.env), optionsUnix);
}
console.log('[vscode-elixir] server started', this.p);
this.p.on('message', (message) => {
console.log('message', message);
});
this.p.on('error', (error) => {
console.log('[vscode-elixir]', error.toString());
});
this.p.on('close', (exitCode) => {
console.log('[vscode-elixir] exited', exitCode);
});
this.p.stdout.on('data', (chunk) => {
if (chunk.indexOf(`END-OF-${this.lastRequestType}`) > -1) {
const chunkString: string = chunk.toString();
const splitStrings: string[] = chunkString.split(`END-OF-${this.lastRequestType}`);
const result = (this.buffer + splitStrings[0]).trim();
this.resultCallback(result);
this.buffer = '';
this.busy = false;
} else {
this.buffer += chunk.toString();
}
});
this.p.stderr.on('data', (chunk: Buffer) => {
const errorString = chunk.toString();
if (!errorString.startsWith('Initializing')) {
console.log('[vscode-elixir] error: arboting command', chunk.toString());
//TODO: this could be handled better.
this.resultCallback('');
this.busy = false;
} else {
console.log('[vscode-elixir]', chunk.toString());
this.ready = true;
}
});
}
constructor() {
const extensionPath: string = vscode.extensions.getExtension("mjmcloug.vscode-elixir").extensionPath;
this.command = 'elixir';
this.args = [path.join(extensionPath, 'alchemist-server/run.exs')];
this.env = 'dev';
this.buffer = '';
this.busy = false;
}
