feat: add merge button (currently no squash and rebase)

Author: KnisterPeter

package.json

@@ -36,6 +36,10 @@
       {
         "command": "extension.browserPullRequest",
         "title": "GitHub: Browse open pull request..."
+      },
+      {
+        "command": "extension.mergePullRequest",
+        "title": "GitHub: Merge open pull request..."
       }
     ]
   },

src/extension.ts

@@ -2,7 +2,7 @@ import {join} from 'path';
 import * as sander from 'sander';
 import * as vscode from 'vscode';
 import * as git from './git';
-import {GitHubError, PullRequest} from './github';
+import {GitHubError, PullRequest, MergeMethod} from './github';
 import {StatusBarManager} from './status-bar-manager';
 import {GitHubManager} from './github-manager';
 
@@ -31,22 +31,20 @@ export function activate(context: vscode.ExtensionContext): void {
     vscode.commands.registerCommand('extension.setGitHubToken', createGithubTokenCommand(context)),
     vscode.commands.registerCommand('extension.createPullRequest', wrapCommand(createPullRequest)),
     vscode.commands.registerCommand('extension.checkoutPullRequests', wrapCommand(checkoutPullRequests)),
-    vscode.commands.registerCommand('extension.browserPullRequest', wrapCommand(browserPullRequest))
+    vscode.commands.registerCommand('extension.browserPullRequest', wrapCommand(browserPullRequest)),
+    vscode.commands.registerCommand('extension.mergePullRequest', wrapCommand(mergePullRequest))
   );
 }
 
-function checkVersionAndToken(context: vscode.ExtensionContext, token: string|undefined): void {
-  sander.readFile(join(context.extensionPath, 'package.json'))
-    .then(content => JSON.parse(content))
-    .then(json => json.version as string)
-    .then((version) => {
-      const storedVersion = context.globalState.get('version-test');
-      if (version !== storedVersion && !Boolean(token)) {
-        context.globalState.update('version-test', version);
-        vscode.window.showInformationMessage(
-          'To enable the Visual Studio Code GitHub Support, please set a Personal Access Token');
-      }
-    });
+async function checkVersionAndToken(context: vscode.ExtensionContext, token: string|undefined): Promise<void> {
+  const content = await sander.readFile(join(context.extensionPath, 'package.json'));
+  const version = JSON.parse(content).version as string;
+  const storedVersion = context.globalState.get<string|undefined>('version-test');
+  if (version !== storedVersion && !Boolean(token)) {
+    context.globalState.update('version-test', version);
+    vscode.window.showInformationMessage(
+      'To enable the Visual Studio Code GitHub Support, please set a Personal Access Token');
+  }
 }
 
 function wrapCommand<T>(command: T): T {
@@ -75,40 +73,38 @@ function logAndShowError(e: Error): void {
     }
 }
 
-function createGithubTokenCommand(context: vscode.ExtensionContext): () => PromiseLike<void> {
-  return () => {
+function createGithubTokenCommand(context: vscode.ExtensionContext): () => void {
+  return async () => {
     const options = {
       ignoreFocusOut: true,
       password: true,
       placeHolder: 'GitHub Personal Access Token'
     };
-    return vscode.window.showInputBox(options)
-      .then(input => {
-        context.globalState.update('token', input);
-        githubManager.connect(input);
-      });
+    const input = await vscode.window.showInputBox(options);
+    context.globalState.update('token', input);
+    githubManager.connect(input);
   };
 }
 
 async function createPullRequest(): Promise<void> {
   const pullRequest = await githubManager.createPullRequest();
   if (pullRequest) {
-    statusBarManager.updatePullRequestStatus(true);
+    statusBarManager.updatePullRequestStatus();
     vscode.window.showInformationMessage(`Successfully created #${pullRequest.number}`);
   }
 }
 
 async function selectPullRequest(doSomething: (pullRequest: PullRequest) => void): Promise<void> {
   const pullRequests = await githubManager.listPullRequests();
-  vscode.window.showQuickPick(pullRequests.map(pullRequest => ({
+  const items = pullRequests.map(pullRequest => ({
     label: pullRequest.title,
     description: `#${pullRequest.number}`,
     pullRequest
-  }))).then(selected => {
-    if (selected) {
-      doSomething(selected.pullRequest);
-    }
-  });
+  }));
+  const selected = await vscode.window.showQuickPick(items);
+  if (selected) {
+    doSomething(selected.pullRequest);
+  }
 }
 
 async function checkoutPullRequests(): Promise<void> {
@@ -123,3 +119,33 @@ async function browserPullRequest(): Promise<void> {
     vscode.commands.executeCommand('vscode.open', vscode.Uri.parse(pullRequest.html_url));
   });
 }
+
+type MergeOptionItems = { label: string; description: string; method: MergeMethod; };
+async function mergePullRequest(): Promise<void> {
+  const items: MergeOptionItems[] = [
+    {
+      label: 'Create merge commit',
+      description: '',
+      method: 'merge'
+    },
+    {
+      label: 'Squash and merge',
+      description: '',
+      method: 'squash'
+    },
+    {
+      label: 'Rebase and merge',
+      description: '',
+      method: 'rebase'
+    }
+  ];
+  const selected = await vscode.window.showQuickPick(items);
+  if (selected) {
+    if (await githubManager.mergePullRequest(selected.method)) {
+      statusBarManager.updatePullRequestStatus();
+      vscode.window.showInformationMessage(`Successfully merged`);
+    } else {
+      vscode.window.showInformationMessage(`Merge failed for unknown reason`);
+    }
+  }
+}

src/github-manager.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import * as git from './git';
-import {getClient, GitHub, PullRequest, ListPullRequestsParameters, CreatePullRequestBody} from './github';
+import {getClient, GitHub, GitHubError, PullRequest, ListPullRequestsParameters, CreatePullRequestBody,
+  PullRequestStatus, Merge, MergeMethod} from './github';
 
 export class GitHubManager {
 
@@ -23,25 +24,32 @@ export class GitHubManager {
     this.github = getClient(token);
   }
 
-  public async hasPullRequestForCurrentBranch(): Promise<boolean> {
+  public async getPullRequestForCurrentBranch(): Promise<PullRequest|undefined> {
     const [owner, repository] = await git.getGitHubOwnerAndRepository(this.cwd);
     const branch = await git.getCurrentBranch(this.cwd);
     const parameters: ListPullRequestsParameters = {
       state: 'open',
       head: `${owner}:${branch}`
     };
-    const response = await this.github.listPullRequests(owner, repository, parameters);
-    return response.length > 0;
+    const list = await this.github.listPullRequests(owner, repository, parameters);
+    if (list.body.length === 0) {
+      return undefined;
+    }
+    return (await this.github.getPullRequest(owner, repository, list.body[0].number)).body;
+  }
+
+  public async hasPullRequestForCurrentBranch(): Promise<boolean> {
+    return Boolean(await this.getPullRequestForCurrentBranch());
   }
 
-  public async getCombinedStatusForPullRequest(): Promise<'failure' | 'pending' | 'success' |undefined> {
+  public async getCombinedStatusForPullRequest(): Promise<PullRequestStatus |undefined> {
     const [owner, repository] = await git.getGitHubOwnerAndRepository(this.cwd);
     const branch = await git.getCurrentBranch(this.cwd);
     if (!branch) {
       return undefined;
     }
     const response = await this.github.getStatusForRef(owner, repository, branch);
-    return response.state;
+    return response.body.total_count > 0 ? response.body.state : undefined;
   }
 
   public async createPullRequest(): Promise<PullRequest|undefined> {
@@ -57,15 +65,43 @@ export class GitHubManager {
     };
     this.channel.appendLine('Create pull request:');
     this.channel.appendLine(JSON.stringify(body, undefined, ' '));
-    return this.github.createPullRequest(owner, repository, body);
+
+    const result = await this.github.createPullRequest(owner, repository, body);
+    // TODO: Pretend should optionally redirect
+    const number = result.headers['location'][0]
+      .match(/https:\/\/api.github.com\/repos\/[^\/]+\/[^\/]+\/pulls\/([0-9]+)/) as RegExpMatchArray;
+    return (await this.github.getPullRequest(owner, repository, parseInt(number[1] as string, 10))).body;
   }
 
   public async listPullRequests(): Promise<PullRequest[]> {
     const [owner, repository] = await git.getGitHubOwnerAndRepository(this.cwd);
     const parameters: ListPullRequestsParameters = {
       state: 'open'
     };
-    return await this.github.listPullRequests(owner, repository, parameters);
+    return (await this.github.listPullRequests(owner, repository, parameters)).body;
+  }
+
+  public async mergePullRequest(method: MergeMethod): Promise<boolean|undefined> {
+    try {
+      if (await this.hasPullRequestForCurrentBranch()) {
+        const [owner, repository] = await git.getGitHubOwnerAndRepository(this.cwd);
+        const pullRequest = await this.getPullRequestForCurrentBranch();
+        if (pullRequest) {
+          const body: Merge = {
+            merge_method: method
+          };
+          const result = await this.github.mergePullRequest(owner, repository, pullRequest.number, body);
+          return result.body.merged;
+        }
+      }
+      return undefined;
+    } catch (e) {
+      if (!(e instanceof GitHubError)) {
+        throw e;
+      }
+      // TODO...
+      return false;
+    }
   }
 
 }

src/github.ts

@@ -1,16 +1,48 @@
-import {Pretend, Get, Post, Interceptor, IPretendRequestInterceptor,
+import {Pretend, Get, Post, Put, Interceptor, IPretendRequestInterceptor,
   IPretendDecoder} from 'pretend';
 import * as LRUCache from 'lru-cache';
 
 export interface GitHub {
+
+  getPullRequest(owner: string, repo: string, number: number): Promise<GitHubResponse<PullRequest>>;
+
   listPullRequests(owner: string, repo: string, parameters?: ListPullRequestsParameters):
-    Promise<PullRequest[]>;
-  createPullRequest(owner: string, repo: string, body: any): Promise<PullRequest>;
-  getStatusForRef(owner: string, repo: string, ref: string): Promise<CombinedStatus>;
+    Promise<GitHubResponse<PullRequest[]>>;
+
+  createPullRequest(owner: string, repo: string, body: CreatePullRequestBody): Promise<GitHubResponse<PullRequest>>;
+
+  getStatusForRef(owner: string, repo: string, ref: string): Promise<GitHubResponse<CombinedStatus>>;
+
+  mergePullRequest(owner: string, repo: string, number: number, body: Merge): Promise<GitHubResponse<MergeResult>>;
+
+}
+
+export interface GitHubResponse<T> {
+  status: number;
+  headers: {[name: string]: string[]};
+  body: T;
+}
+
+export type MergeMethod = 'merge' | 'squash' | 'rebase';
+
+export interface Merge {
+  commit_title?: string;
+  commit_message?: string;
+  sha?: string;
+  merge_method?: MergeMethod;
 }
 
+export interface MergeResult {
+  sha?: string;
+  merged?: boolean;
+  message: string;
+  documentation_url?: string;
+}
+
+export type PullRequestStatus = 'failure' | 'pending' | 'success';
+
 export interface CombinedStatus {
-  state: 'failure' | 'pending' | 'success';
+  state: PullRequestStatus;
   total_count: number;
   statuses: any[];
 }
@@ -45,13 +77,15 @@ export interface PullRequest {
     label: string;
     ref: string;
   };
+  mergeable?: boolean|null;
 }
 
 export function getClient(token: string): GitHub {
   return Pretend
     .builder()
     .interceptor(impl.githubCache())
     .requestInterceptor(impl.githubTokenAuthenticator(token))
+    .interceptor(impl.logger())
     .decode(impl.githubDecoder())
     .target(impl.GitHubBlueprint, 'https://api.github.com');
 }
@@ -68,6 +102,15 @@ export class GitHubError extends Error {
 
 namespace impl {
 
+  export function logger(): Interceptor {
+    return async (chain, request) => {
+      // console.log('github-request: ', request);
+      const response = await chain(request);
+      // console.log('response', response);
+      return response;
+    };
+  }
+
   export function githubCache(): Interceptor {
     // Cache at most 100 requests
     const cache = LRUCache<{etag: string, response: any}>(100);
@@ -87,10 +130,10 @@ namespace impl {
           etag: response.headers.etag,
           response
         });
-        return response.body;
+        return response;
       }
       // Respond from cache
-      return entry.response.body;
+      return entry.response;
     };
   }
 
@@ -111,7 +154,7 @@ namespace impl {
       }
       let headers = {};
       response.headers.forEach((value, index) => {
-        headers[index] = value;
+        headers[index] = [...(headers[index] || []), value];
       });
       return {
         status: response.status,
@@ -123,20 +166,20 @@ namespace impl {
 
   export class GitHubBlueprint implements GitHub {
 
+    @Get('/repos/:owner/:repo/pulls/:number')
+    public getPullRequest(): any {/* */}
+
     @Get('/repos/:owner/:repo/pulls', true)
-    public listPullRequests(_owner: string, _repo: string, _parameters?: ListPullRequestsParameters): any {
-      //
-    }
+    public listPullRequests(): any {/* */}
 
     @Post('/repos/:owner/:repo/pulls')
-    public createPullRequest(_owner: string, _repo: string, _body: any): any {
-      //
-    }
+    public createPullRequest(): any {/* */}
 
     @Get('/repos/:owner/:repo/commits/:ref/status')
-    public getStatusForRef(_owner: string, _repo: string, _ref: string): any {
-      //
-    }
+    public getStatusForRef(): any {/* */}
+
+    @Put('/repos/:owner/:repo/pulls/:number/merge')
+    public mergePullRequest(): any {/* */}
 
   }
 }