Merge pull request #43 from edgardmessias/support_svn_location

Added support to configure the path to the svn executable

Author: JohnstonCode

package.json

@@ -123,6 +123,15 @@
           "type": "boolean",
           "description": "Whether svn is enabled",
           "default": true
+        },
+        "svn.path": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "description": "Path to the svn executable",
+          "default": null,
+          "isExecutable": true
         }
       }
     }

src/extension.ts

@@ -1,23 +1,26 @@
-import { ExtensionContext, Disposable, window } from "vscode";
-import { Svn } from "./svn";
+import { ExtensionContext, Disposable, workspace, window } from "vscode";
+import { Svn, findSvn } from "./svn";
 import { SvnContentProvider } from "./svnContentProvider";
 import { SvnCommands } from "./commands";
 import { Model } from "./model";
 import { toDisposable } from "./util";
 
-function activate(context: ExtensionContext) {
-  const disposables: Disposable[] = [];
-
+async function init(context: ExtensionContext, disposables: Disposable[]): Promise<void> {
   const outputChannel = window.createOutputChannel("Svn");
   disposables.push(outputChannel);
 
-  const svn = new Svn();
+  const config = workspace.getConfiguration('svn');
+  const enabled = config.get<boolean>('enabled') === true;
+  const pathHint = workspace.getConfiguration('svn').get<string>('path');
+  const info = await findSvn(pathHint);
+
+  const svn = new Svn({svnPath: info.path, version: info.version});
   const model = new Model(svn);
   const contentProvider = new SvnContentProvider(model);
   const commands = new SvnCommands(model);
   disposables.push(model);
 
-  outputChannel.appendLine("svn-scm is now active!");
+  outputChannel.appendLine("Using svn " + info.version + " from " + info.path);
 
   context.subscriptions.push(
     new Disposable(() => Disposable.from(...disposables).dispose())
@@ -29,6 +32,16 @@ function activate(context: ExtensionContext) {
     toDisposable(() => svn.onOutput.removeListener("log", onOutput))
   );
 }
+
+function activate(context: ExtensionContext): any {
+  const disposables: Disposable[] = [];
+  context.subscriptions.push(new Disposable(() => Disposable.from(...disposables).dispose()));
+
+  init(context, disposables)
+    .catch(err => console.error(err));
+}
+
+
 exports.activate = activate;
 
 // this method is called when your extension is deactivated

src/svn.ts

@@ -1,21 +1,127 @@
+import { EventEmitter } from "events";
 import { window } from "vscode";
 import * as cp from "child_process";
 import * as iconv from "iconv-lite";
 import * as jschardet from "jschardet";
-import { EventEmitter } from "events";
+import * as path from 'path';
 
 interface CpOptions {
   cwd?: string;
   encoding?: string;
   log?: boolean;
 }
 
+export interface ISvn {
+  path: string;
+  version: string;
+}
+
+function parseVersion(raw: string): string {
+  const match = raw.match(/(\d+\.\d+\.\d+ \(r\d+\))/);
+
+  if(match && match[0]) {
+    return match[0];
+  }
+  return raw.split(/[\r\n]+/)[0];
+}
+
+function findSpecificSvn(path: string): Promise<ISvn> {
+  return new Promise<ISvn>((c, e) => {
+    const buffers: Buffer[] = [];
+    const child = cp.spawn(path, ['--version']);
+    child.stdout.on('data', (b: Buffer) => buffers.push(b));
+    // child.on('error', cpErrorHandler(e));
+    child.on('exit', code => code ? e(new Error('Not found')) : c({ path, version: parseVersion(Buffer.concat(buffers).toString('utf8').trim()) }));
+  });
+}
+
+function findSvnDarwin(): Promise<ISvn> {
+  return new Promise<ISvn>((c, e) => {
+    cp.exec('which svn', (err, svnPathBuffer) => {
+      if (err) {
+        return e('svn not found');
+      }
+
+      const path = svnPathBuffer.toString().replace(/^\s+|\s+$/g, '');
+
+      function getVersion(path: string) {
+        // make sure svn executes
+        cp.exec('svn --version', (err, stdout) => {
+          if (err) {
+            return e('svn not found');
+          }
+
+          return c({ path, version: parseVersion(stdout.trim()) });
+        });
+      }
+
+      if (path !== '/usr/bin/svn') {
+        return getVersion(path);
+      }
+
+      // must check if XCode is installed
+      cp.exec('xcode-select -p', (err: any) => {
+        if (err && err.code === 2) {
+          // svn is not installed, and launching /usr/bin/svn
+          // will prompt the user to install it
+
+          return e('svn not found');
+        }
+
+        getVersion(path);
+      });
+    });
+  });
+}
+
+function findSystemSvnWin32(base: string): Promise<ISvn> {
+  if (!base) {
+    return Promise.reject<ISvn>('Not found');
+  }
+
+  return findSpecificSvn(path.join(base, 'TortoiseSVN', 'bin', 'svn.exe'));
+}
+
+function findSvnWin32(): Promise<ISvn> {
+  return findSystemSvnWin32(process.env['ProgramW6432'])
+    .then(void 0, () => findSystemSvnWin32(process.env['ProgramFiles(x86)']))
+    .then(void 0, () => findSystemSvnWin32(process.env['ProgramFiles']))
+    .then(void 0, () => findSpecificSvn('svn'));
+}
+
+export function findSvn(hint: string | undefined): Promise<ISvn> {
+  var first = hint ? findSpecificSvn(hint) : Promise.reject<ISvn>(null);
+
+  return first
+    .then(void 0, () => {
+      switch (process.platform) {
+        case 'darwin': return findSvnDarwin();
+        case 'win32': return findSvnWin32();
+        default: return findSpecificSvn('svn');
+      }
+    })
+    .then(null, () => Promise.reject(new Error('Svn installation not found.')));
+}
+
+export interface ISvnOptions {
+  svnPath: string;
+  version: string;
+}
+
 export class Svn {
+  private svnPath: string;
+  private version: string;
+
   private _onOutput = new EventEmitter();
   get onOutput(): EventEmitter {
     return this._onOutput;
   }
 
+  constructor(options: ISvnOptions) {
+    this.svnPath = options.svnPath;
+    this.version = options.version;
+  }
+
   private log(output: string): void {
     this._onOutput.emit("log", output);
   }
@@ -29,7 +135,7 @@ export class Svn {
       this.log(`svn ${args.join(" ")}\n`);
     }
 
-    let process = cp.spawn("svn", args, options);
+    let process = cp.spawn(this.svnPath, args, options);
 
     let [exitCode, stdout, stderr] = await Promise.all<any>([
       new Promise<number>((resolve, reject) => {