Merge pull request #10 from matmanjs/bugfix_increase_cov

Bugfix increase cov

Author: helinjiang

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "incremental-coverage",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "Merge lcov.info and get incremental coverage and full coverage",
   "main": "lib/index.js",
   "bin": {

package.json

@@ -21,7 +21,7 @@ export class IncreaseProcess<T extends keyof Mapper> extends BaseProcess<T> {
     stream: {},
   };
 
-  private firstGitMessage: CommitInfo = {};
+  private baseDiffCommitInfo: CommitInfo | undefined;
 
   constructor(lcovPath: string | string[], opts: IncreaseProcessOpts<T> = { stream: {} }) {
     super();
@@ -45,11 +45,14 @@ export class IncreaseProcess<T extends keyof Mapper> extends BaseProcess<T> {
   }
 
   async exec(): Promise<IncreaseResult> {
-    // 得到本次 diff 信息
+    // 如果传递了 hash，则得到该提交记录
     if (this.opts.hash) {
-      await this.getInfoByHash(this.opts.hash);
-    } else {
-      await this.getLog();
+      this.baseDiffCommitInfo = await this.getCommitInfoByHash(this.opts.hash);
+    }
+
+    // 如果通过 hash 无法获得，则自动获取指定日期的那次代码提交
+    if (!this.baseDiffCommitInfo) {
+      this.baseDiffCommitInfo = await this.getCommitInfoByLogSince();
     }
 
     if (!this.opts.cwd) {
@@ -59,9 +62,6 @@ export class IncreaseProcess<T extends keyof Mapper> extends BaseProcess<T> {
     // 将首次提交的代码信息当做创建信息
     const createInfo = await this.getCreateInfo() as CommitInfo;
 
-    // 得到创建信息
-    this.firstGitMessage = createInfo;
-
     // 得到增量合并结果
     await this.getLcov();
 
@@ -70,14 +70,14 @@ export class IncreaseProcess<T extends keyof Mapper> extends BaseProcess<T> {
     if (this.opts.output) {
       this.output({
         data: this.formatData,
-        commit: this.firstGitMessage,
+        commit: this.baseDiffCommitInfo,
         createInfo,
       });
     }
 
     return {
       data: this.formatData,
-      commit: this.firstGitMessage,
+      commit: this.baseDiffCommitInfo as CommitInfo,
       createInfo,
       gitRepoInfo: this.getGitRepoInfo()
     };
@@ -90,36 +90,41 @@ export class IncreaseProcess<T extends keyof Mapper> extends BaseProcess<T> {
     // 解析获得 lcov.info 的信息，这里是全量覆盖率信息
     const res = await getLcovFile(this.lcovPath);
 
-    this.lcov = (
-      await new IncreaseConcat({
-        cwd: this.opts.cwd,
-        hash: this.firstGitMessage?.hash,
-      }).concat(...res)
-    ).getRes();
+    // 合并多个 lcov 文件
+    const increaseConcat = await new IncreaseConcat({
+      cwd: this.opts.cwd,
+      hash: this.baseDiffCommitInfo?.hash,
+    }).concat(...res);
+
+    // 获得合并结果
+    this.lcov = increaseConcat.getRes();
   }
 
   /**
-   * 得到 GitLog 结果
+   * 通过 GitLog 的 since 值得到本次提交的记录
    */
-  private async getLog() {
+  private async getCommitInfoByLogSince(): Promise<(CommitInfo | undefined)> {
+    // 获得当月1号
     const subDate = dayjs(this.opts.since).subtract(1, 'day').format('YYYY-MM-DD');
 
     const res = await new LogParser({
       repo: this.opts.cwd as string,
-      until: subDate,
+
+      // before: 该日期之前的记录，更新的排在前面
+      // after: 该日期之后的记录，更新的排在前面
+      before: subDate,
     }).run();
 
-    [this.firstGitMessage] = res;
+    // 返回第一个值
+    return res[0];
   }
 
   /**
    * 通过 hash 值得到本次提交的记录
    */
-  private async getInfoByHash(hash: string) {
+  private async getCommitInfoByHash(hash: string): Promise<(CommitInfo | undefined)> {
     const result = await getGitRepoCommitInfoByHash(hash, this.opts.cwd);
 
-    if (result) {
-      this.firstGitMessage = result;
-    }
+    return result || undefined;
   }
 }

src/apis/process/increase.ts

@@ -14,6 +14,12 @@ export interface IncreaseConcatOpts {
   hash?: string;
 }
 
+interface LineNumberCheckItem {
+  delete?: string,
+  insert?: string,
+  normal?: string,
+}
+
 export class IncreaseConcat implements Concat {
   // 配置
   private opts: IncreaseConcatOpts = {};
@@ -101,15 +107,47 @@ export class IncreaseConcat implements Concat {
           };
 
           // 统计变换了的行号
-          const diffLineArr: Array<number> = [];
+          const diffInsertLineArr: Array<number> = [];
+          const lineNumberCheckMap: { [key: number]: LineNumberCheckItem } = {};
+
           diffItem.hunks.forEach((hunk) => {
             hunk.changes.forEach((change) => {
-              if (change.type === 'insert' && change.lineNumber) {
-                diffLineArr.push(change.lineNumber);
+              if (!change.lineNumber) {
+                return;
+              }
+
+              // 以行号为key，缓存下该行号 insert 或 delete 时的内容
+              const lineNumberCheckItem: LineNumberCheckItem = lineNumberCheckMap[change.lineNumber] || {};
+              lineNumberCheckItem[change.type] = change.content;
+              lineNumberCheckMap[change.lineNumber] = lineNumberCheckItem;
+
+              // 只需要判断 insert 类型且有行号的的结果即可，
+              // 毕竟计算增量的目的是为了看存在，所以 delete 类型的不需要计算
+              if ((change.type === 'insert')) {
+                diffInsertLineArr.push(change.lineNumber);
               }
             });
           });
 
+          // 注意一种特殊情况，如果某行既是 insert 且又是 delete，且 content 内容还是一模一样，则忽略该情况
+          // 公司内的增量覆盖率算法为上述处理策略，因此此处做统一，
+          // 虽然个人觉得不太合理，感觉只要是 delete 和 insert 应该都算增量变化，但需进一步研究
+          // 统计变换了的行号
+          const diffLineArr: Array<number> = [];
+          diffInsertLineArr.forEach((lineNumber) => {
+            const lineNumberCheckItem: LineNumberCheckItem = lineNumberCheckMap[lineNumber];
+
+            if (!lineNumberCheckItem) {
+              return;
+            }
+
+            if (lineNumberCheckItem.insert && lineNumberCheckItem.delete && (lineNumberCheckItem.insert === lineNumberCheckItem.delete)) {
+              return;
+            }
+
+            diffLineArr.push(lineNumber);
+          });
+
           // 统计每行对应的hit数
           const lcovLineHit: Record<string, number> = {};