🐛 fix: add more log and fix comment filter (#13)

Author: SigureMo

.github/workflows/example-workflow.yml

@@ -43,7 +43,7 @@ jobs:
                 },
                 {
                   "type": "commented",
-                  "comment-pattern": [".+/bypass example.+", ".+/bypass all.+"],
+                  "comment-pattern": [".*/bypass example.*", ".*/bypass all.*"],
                   "username": ["SigureMo"]
                 },
                 {

README.md

@@ -92,7 +92,7 @@ jobs:
                        },
                        {
                           "type": "commented",
-                          "comment-pattern": [".+/bypass example.+", ".+/bypass all.+"],
+                          "comment-pattern": [".*/bypass example.*", ".*/bypass all.*"],
                           "username": ["SigureMo"]
                        },
                        {

dist/index.js

@@ -28,7 +28,7 @@ function isNotComposite<T>(composite: Composite<T>): composite is NotComposite<T
   return (composite as NotComposite<T>).not !== undefined
 }
 
-function resolveAnyCompositeHighterOrder<T>(
+function resolveAnyComposite<T>(
   predicate: (value: T) => boolean
 ): (composite: AnyComposite<T>) => boolean {
   return (composite: AnyComposite<T>) => composite.any.some(predicate)
@@ -54,7 +54,7 @@ export function resolveComposite<T>(
   }
   return (composite: Composite<T>) => {
     if (isAnyComposite(composite)) {
-      return resolveAnyCompositeHighterOrder(predicateForComposite)(composite)
+      return resolveAnyComposite(predicateForComposite)(composite)
     } else if (isAllComposite(composite)) {
       return resolveAllComposite(predicateForComposite)(composite)
     } else if (isNotComposite(composite)) {

src/composite.ts

@@ -27,7 +27,7 @@ function parseRuleRawObjectFromInput(): any {
     case CommentRule.type:
       return {
         type: CommentRule.type,
-        'message-pattern': parseArrayInput(core.getInput('message-pattern'), '|'),
+        'comment-pattern': parseArrayInput(core.getInput('comment-pattern'), '|'),
         username: parseArrayInput(core.getInput('username'), '|'),
         'user-team': parseArrayInput(core.getInput('user-team'), '|'),
       }
@@ -73,10 +73,13 @@ function checkNonPullRequestEvent() {
  */
 export async function run(): Promise<void> {
   try {
-    if (checkNonPullRequestEvent()) return
+    if (checkNonPullRequestEvent()) {
+      core.info('Non-pull-request event, skipping the check')
+      return
+    }
     const githubToken: string = core.getInput('github-token')
     const rawRule = parseRuleRawObjectFromInput()
-    core.info(`rawRule: ${JSON.stringify(rawRule)}`)
+    core.debug(`rawRule: ${JSON.stringify(rawRule)}`)
 
     async function check(value: any): Promise<boolean> {
       const bypassChecker = new ByPassCheckerBuilder()
@@ -88,7 +91,7 @@ export async function run(): Promise<void> {
     }
 
     const result = await resolveCompositeAsync(check)(rawRule)
-    core.info(`check result: ${result}`)
+    core.info(`Setting can-skip output to ${result}`)
     // Set outputs for other workflow steps to use
     core.setOutput('can-skip', result)
   } catch (error) {

src/main.ts

@@ -15,16 +15,16 @@ function compilePattern(pattern: string): RegExp {
 
 export class CommentRule extends AbstractRule {
   public static type: string = 'commented'
-  public messagePatterns: RegExp[]
+  public commentPatterns: RegExp[]
   public userNames: string[]
   public userTeams: string[]
   constructor(
-    messagePattern: string | string[],
+    commentPattern: string | string[],
     userName: string | string[] | undefined,
     userTeam: string | string[] | undefined
   ) {
     super()
-    this.messagePatterns = resolveOneOrMoreOption(messagePattern).map(compilePattern)
+    this.commentPatterns = resolveOneOrMoreOption(commentPattern).map(compilePattern)
     this.userNames = resolveMaybeOneOrMoreOption(userName)
     this.userTeams = resolveMaybeOneOrMoreOption(userTeam)
   }
@@ -52,7 +52,7 @@ export class CommentRule extends AbstractRule {
         return { content: comment.body, actor: comment.user.login }
       })
       .filter((comment): comment is CommentWithActor => comment !== undefined)
-      .filter((comment) => this.messagePatterns.some((pattern) => pattern.test(comment.content)))
+      .filter((comment) => this.commentPatterns.some((pattern) => pattern.test(comment.content)))
     const IsValidComment = async (comment: CommentWithActor): Promise<Boolean> => {
       const currentCommentUserName = comment.actor
       return await isValidUser(
@@ -64,13 +64,13 @@ export class CommentRule extends AbstractRule {
       )
     }
     core.debug(`allCommentWithActors: ${JSON.stringify(allCommentWithActors)}`)
-    core.debug(`messagePatterns: ${JSON.stringify(this.messagePatterns)}`)
+    core.debug(`messagePatterns: ${JSON.stringify(this.commentPatterns)}`)
     return await Promise.all(allCommentWithActors.map(IsValidComment)).then((results) =>
       results.some((result) => result)
     )
   }
 
   public static fromObject(obj: any): CommentRule {
-    return new CommentRule(obj['message-pattern'], obj['username'], obj['user-team'])
+    return new CommentRule(obj['comment-pattern'], obj['username'], obj['user-team'])
   }
 }