- Resolved #9

Author: zero88

dist/index.js

@@ -1,3 +1,4 @@
+import * as core from '@actions/core';
 import { Context } from '@actions/github/lib/context';
 import { exec, strictExec } from './exec';
 import { CIContext, GitContextOutput } from './output';
@@ -198,72 +199,71 @@ export class GitInteractorInput {
  */
 export class GitInteractor {
 
-  readonly interactorInput: GitInteractorInput;
-  readonly contextInput: GitContextInput;
-
-  constructor(interactorInput: GitInteractorInput, gitContextInput: GitContextInput) {
-    this.interactorInput = interactorInput;
-    this.contextInput = gitContextInput;
-  }
-
-  commitPushIfNeed = async (branch: string, version: string, mustFixVersion: boolean,
-                            dryRun: boolean): Promise<CIContext> => {
-    const committable = this.interactorInput.allowCommit && mustFixVersion && !dryRun;
+  commitPushIfNeed = async (iInput: GitInteractorInput, branch: string, version: string,
+                            mustFixVersion: boolean, dryRun: boolean): Promise<CIContext> => {
+    const committable = iInput.allowCommit && mustFixVersion && !dryRun;
     let commitMsg = '';
     let commitId = '';
     if (committable) {
-      commitMsg = `${this.interactorInput.prefixCiMsg} ${this.interactorInput.correctVerMsg} ${version}`;
+      commitMsg = `${iInput.prefixCiMsg} ${iInput.correctVerMsg} ${version}`;
       await strictExec('git', ['fetch', '--depth=1'], 'Cannot fetch');
       await strictExec('git', ['checkout', branch], 'Cannot checkout');
-      await this.globalConfig()
-                .then(gc => strictExec('git', [...gc, ...this.commitArgs(commitMsg)], `Cannot commit`));
+      await this.globalConfig(iInput.userName, iInput.userEmail)
+                .then(gc => strictExec('git', [...gc, ...this.commitArgs(iInput, commitMsg)], `Cannot commit`));
       await strictExec('git', ['show', '--shortstat', '--show-signature'], `Cannot show recently commit`, false);
       await strictExec('git', ['push'], `Cannot push`, false);
       commitId = (await strictExec('git', ['rev-parse', 'HEAD'], 'Cannot show last commit')).stdout;
     }
     return Promise.resolve({ mustFixVersion, isPushed: committable, commitMsg, commitId });
   };
 
-  tagThenPush = async (version: string, needTag: boolean, dryRun: boolean): Promise<CIContext> => {
-    const taggable = this.interactorInput.allowTag && needTag && !dryRun;
-    const v = `${this.contextInput.tagPrefix}${version}`;
+  tagThenPush = async (iInput: GitInteractorInput, gInput: GitContextInput, version: string, needTag: boolean,
+                       dryRun: boolean): Promise<CIContext> => {
+    const taggable = iInput.allowTag && needTag && !dryRun;
+    const v = `${gInput.tagPrefix}${version}`;
     let commitMsg = '';
     let commitId = '';
     if (taggable) {
-      commitMsg = `${this.interactorInput.releaseVerMsg} ${v}`;
+      commitMsg = `${iInput.releaseVerMsg} ${v}`;
       commitId = (await strictExec('git', ['rev-parse', '--short', 'HEAD'], 'Cannot show last commit')).stdout;
       await strictExec('git', ['fetch', '--depth=1'], 'Cannot fetch');
-      await this.globalConfig()
-                .then(gc => strictExec('git', [...gc, ...this.tagArgs(commitMsg, v, commitId)], `Cannot tag`));
+      await this.globalConfig(iInput.userName, iInput.userEmail)
+                .then(gc => strictExec('git', [...gc, ...this.tagArgs(iInput, commitMsg, v, commitId)], `Cannot tag`));
       await strictExec('git', ['show', '--shortstat', '--show-signature', v], `Cannot show tag`, false);
       await strictExec('git', ['push', '-uf', 'origin', v], `Cannot push`, false);
     }
     return Promise.resolve({ needTag, isPushed: taggable, commitMsg, commitId });
   };
 
-  getCommitMsg = async (commitId: string): Promise<string> => {
-    return await exec('git', ['log', '--format=%B', '-n', '1', commitId]).then(r => r.success ? r.stdout : '');
-  };
+  getCommitMsg = async (commitId: string): Promise<string> => this.execSilent(['log', '--format=%B', '-n', '1',
+                                                                               commitId]);
+
+  removeRemoteBranch = async (branch: string): Promise<string> => this.execSilent(['push', 'origin', `:${branch}`]);
 
-  private commitArgs(commitMsg: string) {
-    return ['commit', ...this.gpgSign(true), '-a', '-m', commitMsg];
+  private commitArgs(iInput: GitInteractorInput, commitMsg: string) {
+    return ['commit', ...this.gpgSign(iInput, true), '-a', '-m', commitMsg];
   }
 
-  private tagArgs(commitMsg: string, version: string, commitId: string) {
-    return ['tag', ...this.gpgSign(false), '-a', '-m', `${commitMsg}`, version, commitId];
+  private tagArgs(iInput: GitInteractorInput, commitMsg: string, version: string, commitId: string) {
+    return ['tag', ...this.gpgSign(iInput, false), '-a', '-m', `${commitMsg}`, version, commitId];
   }
 
-  private gpgSign(isCommit: boolean): string[] {
-    return this.interactorInput.mustSign ? (isCommit ? [`-S`] : [`-s`]) : [];
+  private gpgSign(iInput: GitInteractorInput, isCommit: boolean): string[] {
+    return iInput.mustSign ? (isCommit ? [`-S`] : [`-s`]) : [];
   }
 
-  private async globalConfig(): Promise<string[]> {
-    const userName = (await this.getConfig('user.name', this.interactorInput.userName));
-    const userEmail = (await this.getConfig('user.email', this.interactorInput.userEmail));
+  private async globalConfig(uName: string, uEmail: string): Promise<string[]> {
+    const userName = (await this.execSilent(['config', 'user.name'], uName));
+    const userEmail = (await this.execSilent(['config', 'user.email'], uEmail));
     return Promise.resolve(['-c', `user.name=${userName}`, '-c', `user.email=${userEmail}`]);
   }
 
-  private async getConfig(key: string, fallback: string): Promise<string> {
-    return await exec('git', ['config', key]).then(r => r.success ? r.stdout : fallback);
+  private async execSilent(args: string[], fallback: string = ''): Promise<string> {
+    return await exec('git', args).then(r => {
+      if (!r.success) {
+        core.warning(`Cannot exec GIT ${args[0]}: ${r.stderr}`);
+      }
+      return r.success ? r.stdout : fallback;
+    });
   }
 }

dist/index.js.map

@@ -26,7 +26,8 @@ function process(context: Context, ghInput: GitContextInput, interactorInput: Gi
             .then(r => ops.checkCommitMsg(ghOutput).then(output => ops.ciStep(r, output, dryRun)))
             .then(output => ({ ...output, decision: ops.makeDecision(output) }))
             .then(output => ({ ...output, ver: ops.nextVersion(output) }))
-            .then(output => ops.tweakVersion(output));
+            .then(output => ops.tweakVersion(output))
+            .then(output => ops.removeBranchIfNeed(output));
 }
 
 function addActionOutputs(ghOutput: GitContextOutput) {

src/git.ts

@@ -87,8 +87,8 @@ export class ProjectContextOps {
     if (ghOutput.commitMsg && ghOutput.commitMsg.trim().length > 0) {
       return Promise.resolve(ghOutput);
     }
-    return new GitInteractor(this.iInput, this.gInput).getCommitMsg(ghOutput.commitId)
-                                                      .then(commitMsg => ({ ...ghOutput, commitMsg }));
+    return new GitInteractor().getCommitMsg(ghOutput.commitId)
+                              .then(commitMsg => ({ ...ghOutput, commitMsg }));
   }
 
   fixOrSearchVersion(ghOutput: GitContextOutput, dryRun: boolean = true): Promise<FileVersionResult> {
@@ -120,14 +120,14 @@ export class ProjectContextOps {
     if (ghOutput.isTag && mustFixVersion) {
       throw `Git tag version doesn't meet with current version in files. Invalid files: [${versionResult.files}]`;
     }
-    const interactor = new GitInteractor(this.iInput, this.gInput);
+    const interactor = new GitInteractor();
     if (mustFixVersion) {
-      return interactor.commitPushIfNeed(ghOutput.branch, ghOutput.version, mustFixVersion, dryRun)
+      return interactor.commitPushIfNeed(this.iInput, ghOutput.branch, ghOutput.version, mustFixVersion, dryRun)
                        .then(ci => ({ ...ghOutput, ci, ver }));
     }
     if (ghOutput.isReleasePR && ghOutput.isMerged) {
       core.info(`Tag new version ${ghOutput.version}...`);
-      return interactor.tagThenPush(ghOutput.version, ghOutput.isMerged, dryRun)
+      return interactor.tagThenPush(this.iInput, this.gInput, ghOutput.version, ghOutput.isMerged, dryRun)
                        .then(ci => ({ ...ghOutput, ci }));
     }
     return Promise.resolve({ ...ghOutput, ver });
@@ -153,6 +153,13 @@ export class ProjectContextOps {
     }
     return { ...output, ...{ version: output.ver?.current ?? output.version } };
   }
+
+  removeBranchIfNeed(output: GitContextOutput): Promise<GitContextOutput> {
+    if (output.isPR && output.isMerged) {
+      return new GitInteractor().removeRemoteBranch(output.branch).then(ignore => output);
+    }
+    return Promise.resolve(output);
+  }
 }
 
 export interface FileVersionResult {