chore: remote repository, svn resource, path normalizer api (#424)

Author: Yanpas

src/common/types.ts

@@ -42,7 +42,7 @@ export interface ISvnInfo {
     root: string;
     uuid: string;
   };
-  wcInfo: {
+  wcInfo?: {
     wcrootAbspath: string;
     uuid: string;
   };

src/model.ts

@@ -21,6 +21,7 @@ import {
 } from "./common/types";
 import { debounce, sequentialize } from "./decorators";
 import { configuration } from "./helpers/configuration";
+import { RemoteRepository } from "./remoteRepository";
 import { Repository } from "./repository";
 import { Svn, svnErrorCodes } from "./svn";
 import SvnError from "./svnError";
@@ -334,6 +335,10 @@ export class Model implements IDisposable {
     }
   }
 
+  public async getRemoteRepository(uri: Uri): Promise<RemoteRepository> {
+    return RemoteRepository.open(this.svn, uri);
+  }
+
   public getRepository(hint: any) {
     const liveRepository = this.getOpenRepository(hint);
     if (liveRepository && liveRepository.repository) {

src/pathNormalizer.ts

@@ -0,0 +1,90 @@
+import * as path from "path";
+import { Uri } from "vscode";
+import { ISvnInfo } from "./common/types";
+import { memoize } from "./decorators";
+import { SvnRI } from "./svnRI";
+
+enum ResourceKind {
+  LocalRelative,
+  LocalFull,
+  RemoteFull
+}
+
+/**
+ * create from Repository class
+ */
+export class PathNormalizer {
+  public readonly repoRoot: Uri;
+  public readonly branchRoot: Uri;
+  public readonly checkoutRoot?: Uri;
+
+  constructor(public readonly repoInfo: ISvnInfo) {
+    this.repoRoot = Uri.parse(repoInfo.repository.root);
+    this.branchRoot = Uri.parse(repoInfo.url);
+    if (repoInfo.wcInfo) {
+      this.checkoutRoot = Uri.file(repoInfo.wcInfo.wcrootAbspath);
+    }
+  }
+
+  /** svn://foo.org/domain/trunk/x -> trunk/x */
+  private getFullRepoPathFromUrl(fpath: string): string {
+    if (fpath.startsWith("/")) {
+      return fpath.substr(1);
+    } else if (fpath.startsWith("svn://") || fpath.startsWith("file://")) {
+      const target = Uri.parse(fpath).path;
+      return path.relative(this.repoRoot.path, target);
+    } else {
+      throw new Error("unknown path");
+    }
+  }
+
+  public parse(
+    fpath: string,
+    kind = ResourceKind.RemoteFull,
+    rev?: string
+  ): SvnRI {
+    let target: string;
+    if (kind === ResourceKind.RemoteFull) {
+      target = this.getFullRepoPathFromUrl(fpath);
+    } else if (kind === ResourceKind.LocalFull) {
+      if (!path.isAbsolute(fpath)) {
+        throw new Error("Path isn't absolute");
+      }
+      if (this.checkoutRoot === undefined) {
+        throw new Error("Local paths are not");
+      }
+      target = path.join(
+        this.fromRootToBranch(),
+        path.relative(this.checkoutRoot.path, fpath)
+      );
+    } else if (kind === ResourceKind.LocalRelative) {
+      if (path.isAbsolute(fpath)) {
+        throw new Error("Path is absolute");
+      }
+      if (this.checkoutRoot === undefined) {
+        throw new Error("Local paths are not");
+      }
+      target = path.join(this.fromRootToBranch(), fpath);
+    } else {
+      throw new Error("unsupported kind");
+    }
+
+    return new SvnRI(
+      this.repoRoot,
+      this.branchRoot,
+      this.checkoutRoot,
+      target,
+      rev
+    );
+  }
+
+  @memoize
+  public fromRootToBranch(): string {
+    return path.relative(this.repoRoot.path, this.branchRoot.path);
+  }
+
+  @memoize
+  public fromBranchToRoot(): string {
+    return path.relative(this.branchRoot.path, this.repoRoot.path);
+  }
+}

src/remoteRepository.ts

@@ -0,0 +1,56 @@
+import { Uri } from "vscode";
+import { ISvnInfo, ISvnLogEntry } from "./common/types";
+import { PathNormalizer } from "./pathNormalizer";
+import { Svn } from "./svn";
+import { Repository as BaseRepository } from "./svnRepository";
+
+export interface IRemoteRepository {
+  branchRoot: Uri;
+
+  getPathNormalizer(): PathNormalizer;
+
+  log(
+    rfrom: string,
+    rto: string,
+    limit: number,
+    target?: string | Uri
+  ): Promise<ISvnLogEntry[]>;
+
+  show(filePath: string | Uri, revision?: string): Promise<string>;
+}
+
+export class RemoteRepository implements IRemoteRepository {
+  private info: ISvnInfo;
+  private constructor(private repo: BaseRepository) {
+    this.info = repo.info;
+  }
+
+  public static async open(svn: Svn, uri: Uri): Promise<RemoteRepository> {
+    const repo = await svn.open(uri.toString(true), "");
+    return new RemoteRepository(repo);
+  }
+
+  public getPathNormalizer(): PathNormalizer {
+    return new PathNormalizer(this.info);
+  }
+
+  public get branchRoot(): Uri {
+    return Uri.parse(this.info.url);
+  }
+
+  public async log(
+    rfrom: string,
+    rto: string,
+    limit: number,
+    target?: string | Uri
+  ): Promise<ISvnLogEntry[]> {
+    return this.repo.log(rfrom, rto, limit, target);
+  }
+
+  public async show(
+    filePath: string | Uri,
+    revision?: string
+  ): Promise<string> {
+    return this.repo.show(filePath, revision);
+  }
+}

src/repository.ts

@@ -29,6 +29,8 @@ import {
 import { debounce, memoize, throttle } from "./decorators";
 import { configuration } from "./helpers/configuration";
 import OperationsImpl from "./operationsImpl";
+import { PathNormalizer } from "./pathNormalizer";
+import { IRemoteRepository } from "./remoteRepository";
 import { Resource } from "./resource";
 import { SvnStatusBar } from "./statusBar";
 import { svnErrorCodes } from "./svn";
@@ -56,7 +58,7 @@ function shouldShowProgress(operation: Operation): boolean {
   }
 }
 
-export class Repository {
+export class Repository implements IRemoteRepository {
   public sourceControl: SourceControl;
   public statusBar: SvnStatusBar;
   public changes: ISvnResourceGroup;
@@ -144,7 +146,7 @@ export class Repository {
   }
 
   /** 'svn://repo.x/branches/b1' e.g. */
-  get remoteRoot(): Uri {
+  get branchRoot(): Uri {
     return Uri.parse(this.repository.info.url);
   }
 
@@ -902,6 +904,10 @@ export class Repository {
     );
   }
 
+  public getPathNormalizer(): PathNormalizer {
+    return new PathNormalizer(this.repository.info);
+  }
+
   public async promptAuth(): Promise<IAuth | undefined> {
     // Prevent multiple prompts for auth
     if (this.lastPromptAuth) {

src/svnRI.ts

@@ -0,0 +1,56 @@
+import * as path from "path";
+import { Uri } from "vscode";
+import { memoize } from "./decorators";
+
+export class SvnRI {
+  constructor(
+    private readonly remoteRoot: Uri,
+    private readonly branchRoot: Uri,
+    private readonly checkoutRoot: Uri | undefined,
+    /** path relative from remoteRoot */
+    private readonly _path: string,
+    private readonly _revision?: string
+  ) {
+    if (_path.length === 0 || _path.charAt(0) === "/") {
+      throw new Error("Invalid _path " + _path);
+    }
+  }
+
+  @memoize
+  get remoteFullPath(): Uri {
+    return Uri.parse(this.remoteRoot.toString() + "/" + this._path);
+  }
+
+  @memoize
+  get localFullPath(): Uri | undefined {
+    if (this.checkoutRoot === undefined) {
+      return undefined;
+    }
+    return Uri.file(
+      path.join(
+        this.checkoutRoot.path,
+        path.relative(this.fromRepoToBranch, this._path)
+      )
+    );
+  }
+
+  @memoize
+  get relativeFromBranch(): string {
+    return path.relative(this.fromRepoToBranch, this._path);
+  }
+
+  @memoize
+  get fromRepoToBranch(): string {
+    return path.relative(this.remoteRoot.path, this.branchRoot.path);
+  }
+
+  @memoize
+  get revision(): string | undefined {
+    return this._revision;
+  }
+
+  @memoize
+  public toString(withRevision?: boolean): string {
+    return this.remoteFullPath + (withRevision ? this._revision || "" : "");
+  }
+}

src/svnRepository.ts

@@ -522,7 +522,7 @@ export class Repository {
       "-v"
     ];
     if (target !== undefined) {
-      args.push(target.toString());
+      args.push(target instanceof Uri ? target.toString(true) : target);
     }
     const result = await this.exec(args);
 

src/test/pathNormalizer.test.ts

@@ -0,0 +1,56 @@
+/* tslint:disable */
+
+//
+// Note: This example test is leveraging the Mocha test framework.
+// Please refer to their documentation on https://mochajs.org/ for help.
+//
+
+// The module 'assert' provides assertion methods from node
+import * as assert from "assert";
+import * as path from "path";
+import { PathNormalizer } from "../pathNormalizer";
+import { Uri } from "vscode";
+import { ISvnInfo } from "../common/types";
+
+// Defines a Mocha test suite to group tests of similar kind together
+suite("Url parsing", () => {
+  const ri1 = {
+    repository: {
+      root: "svn://somedomain.x.org/public/devs"
+    },
+    url: "svn://somedomain.x.org/public/devs/branches/features/F1",
+    wcInfo: {
+      wcrootAbspath: "/home/user/dev/mypero"
+    }
+  };
+  const nm1 = new PathNormalizer(ri1 as ISvnInfo);
+
+  suiteSetup(async () => {
+    // do nothing
+  });
+
+  suiteTeardown(async () => {
+    // do nothing
+  });
+
+  test("r1 ops", function() {
+    assert.equal(nm1.branchRoot.toString(), Uri.parse(ri1.url).toString());
+    assert.equal(
+      nm1.repoRoot.toString(),
+      Uri.parse(ri1.repository.root).toString()
+    );
+    if (!nm1.checkoutRoot) {
+      throw new Error("impossible");
+    }
+    assert.equal(
+      nm1.checkoutRoot.toString(),
+      Uri.file(ri1.wcInfo.wcrootAbspath).toString()
+    );
+    const x1 = nm1.parse("/d1/f1");
+    assert.equal(x1.remoteFullPath.toString(), ri1.repository.root + "/d1/f1");
+    if (!x1.localFullPath) {
+      throw new Error("impossible");
+    }
+    assert.equal(x1.localFullPath.toString(), "file:///home/d1/f1");
+  });
+});