feat: add regex support to requiredLabels and blockingLabels (#818)

README.md

@@ -107,6 +107,16 @@ blockingLabels:
 - blocked
 ```
 
+The above example denotes literal label names. Regular expressions can be used to
+partially match labels. This can be specified by the `regex:` property in the
+configuration. The following example will block merging when a label is added that
+starts with the text `blocked`:
+
+```yaml
+blockingLabels:
+- regex: ^blocked
+```
+
 Note: remove the whole section when you're not using blocking labels.
 
 ### `requiredLabels` (condition, default: none)
@@ -122,6 +132,15 @@ requiredLabels:
 - merge
 ```
 
+The above example denotes literal label names. Regular expressions can be used to
+partially match labels. This requires `regex:` property in the configuration. The
+following example will requires at least one label that starts with `merge`:
+
+```yaml
+requiredLabels:
+- regex: ^merge
+```
+
 Note: remove the whole section when you're not using required labels.
 
 ### `blockingTitleRegex` (condition, default: none)

src/conditions/blockingLabels.ts

@@ -1,14 +1,16 @@
 import { ConditionConfig } from './../config'
 import { PullRequestInfo } from '../models'
 import { ConditionResult } from '../condition'
+import { matchesPattern } from '../pattern'
 
 export default function doesNotHaveBlockingLabels (
   config: ConditionConfig,
   pullRequestInfo: PullRequestInfo
 ): ConditionResult {
-  const pullRequestLabels = new Set(pullRequestInfo.labels.nodes.map(label => label.name))
-  const foundBlockingLabels = config.blockingLabels
-    .filter(blockingLabel => pullRequestLabels.has(blockingLabel))
+  const pullRequestLabels = pullRequestInfo.labels.nodes.map(label => label.name)
+
+  const foundBlockingLabels = pullRequestLabels
+    .filter(pullRequestLabel => config.blockingLabels.some(blockingLabelPattern => matchesPattern(blockingLabelPattern, pullRequestLabel)))
 
   if (foundBlockingLabels.length > 0) {
     return {

src/conditions/requiredLabels.ts

@@ -1,21 +1,22 @@
 import { ConditionConfig } from './../config'
 import { PullRequestInfo } from '../models'
 import { ConditionResult } from '../condition'
+import { matchesPattern, stringifyPattern } from '../pattern'
 
 export default function hasRequiredLabels (
   config: ConditionConfig,
   pullRequestInfo: PullRequestInfo
 ): ConditionResult {
-  const pullRequestLabels = new Set(pullRequestInfo.labels.nodes.map(label => label.name))
+  const pullRequestLabels = pullRequestInfo.labels.nodes.map(label => label.name)
 
-  const missingRequiredLabels = config.requiredLabels
-    .filter(requiredLabel => !pullRequestLabels.has(requiredLabel))
+  const missingRequiredLabelPatterns = config.requiredLabels
+    .filter(requiredLabelPattern => !pullRequestLabels.some(pullRequestLabel => matchesPattern(requiredLabelPattern, pullRequestLabel)))
 
-  if (missingRequiredLabels.length > 0) {
+  if (missingRequiredLabelPatterns.length > 0) {
     return {
       status: 'fail',
       message: `Required labels are missing (${
-        missingRequiredLabels.join(', ')
+        missingRequiredLabelPatterns.map(stringifyPattern).join(', ')
       })`
     }
   }

src/config.ts

@@ -2,6 +2,7 @@ import { CommentAuthorAssociation } from './github-models'
 import { Context } from 'probot'
 import getConfig from 'probot-config'
 import { Decoder, object, string, optional, number, boolean, array, oneOf, constant } from '@mojotech/json-type-validation'
+import { Pattern, patternDecoder } from './pattern'
 
 export class ConfigNotFoundError extends Error {
   constructor (
@@ -28,8 +29,8 @@ export class ConfigValidationError extends Error {
 export type ConditionConfig = {
   minApprovals: { [key in CommentAuthorAssociation]?: number },
   maxRequestedChanges: { [key in CommentAuthorAssociation]?: number },
-  requiredLabels: string[],
-  blockingLabels: string[],
+  requiredLabels: Pattern[],
+  blockingLabels: Pattern[],
   blockingBodyRegex: string | undefined
   requiredBodyRegex: string | undefined
   blockingTitleRegex: string | undefined
@@ -81,8 +82,8 @@ const reviewConfigDecover: Decoder<{ [key in CommentAuthorAssociation]: number |
 const conditionConfigDecoder: Decoder<ConditionConfig> = object({
   minApprovals: reviewConfigDecover,
   maxRequestedChanges: reviewConfigDecover,
-  requiredLabels: array(string()),
-  blockingLabels: array(string()),
+  requiredLabels: array(patternDecoder),
+  blockingLabels: array(patternDecoder),
   blockingTitleRegex: optional(string()),
   blockingBodyRegex: optional(string()),
   requiredTitleRegex: optional(string()),
@@ -93,8 +94,8 @@ const configDecoder: Decoder<Config> = object({
   rules: array(conditionConfigDecoder),
   minApprovals: reviewConfigDecover,
   maxRequestedChanges: reviewConfigDecover,
-  requiredLabels: array(string()),
-  blockingLabels: array(string()),
+  requiredLabels: array(patternDecoder),
+  blockingLabels: array(patternDecoder),
   blockingTitleRegex: optional(string()),
   blockingBodyRegex: optional(string()),
   requiredTitleRegex: optional(string()),

src/pattern.ts

@@ -0,0 +1,36 @@
+import { string, oneOf, object } from "@mojotech/json-type-validation"
+
+export interface RegexPattern {
+  regex: RegExp
+}
+export type LiteralPattern = string
+export type Pattern = RegexPattern | LiteralPattern
+
+export function matchesPattern (pattern: Pattern, input: string) {
+  if (typeof pattern === 'string') {
+    return pattern === input
+  } else if ('regex' in pattern) {
+    return pattern.regex.test(input)
+  } else {
+    throw new Error(`Invalid pattern at runtime: ${typeof pattern}`)
+  }
+}
+
+export function stringifyPattern (pattern: Pattern) {
+  if (typeof pattern === 'string') {
+    return pattern;
+  } else if ('regex' in pattern) {
+    return `{regex: ${pattern.regex}}`
+  } else {
+    return '[invalid pattern]'
+  }
+}
+
+export const regexDecoder = string().map(value => new RegExp(value))
+
+export const patternDecoder = oneOf<Pattern>(
+  string(),
+  object({
+    regex: regexDecoder
+  })
+)

test/conditions/blockingLabels.test.ts

@@ -63,4 +63,36 @@ describe('blockingLabels', () => {
     )
     expect(result.status).toBe('fail')
   })
+
+  it('returns fail with label matching regex in configuration', () => {
+    const result = blockingLabels(
+      createConditionConfig({
+        blockingLabels: [{ regex: /blocking/ }]
+      }),
+      createPullRequestInfo({
+        labels: {
+          nodes: [{
+            name: 'blocking label'
+          }]
+        }
+      })
+    )
+    expect(result.status).toBe('fail')
+  })
+
+  it('returns success with label not matching regex in configuration', () => {
+    const result = blockingLabels(
+      createConditionConfig({
+        blockingLabels: [{ regex: /^blocking$/ }]
+      }),
+      createPullRequestInfo({
+        labels: {
+          nodes: [{
+            name: 'blocking label'
+          }]
+        }
+      })
+    )
+    expect(result.status).toBe('success')
+  })
 })

test/conditions/requiredLabels.test.ts

@@ -97,4 +97,36 @@ describe('open', () => {
     )
     expect(result.status).toBe('fail')
   })
+
+  it('returns success with label matching regex in configuration', () => {
+    const result = requiredLabels(
+      createConditionConfig({
+        requiredLabels: [{ regex: /required/ }]
+      }),
+      createPullRequestInfo({
+        labels: {
+          nodes: [{
+            name: 'required label'
+          }]
+        }
+      })
+    )
+    expect(result.status).toBe('success')
+  })
+
+  it('returns fail with label matching regex in configuration', () => {
+    const result = requiredLabels(
+      createConditionConfig({
+        requiredLabels: [{ regex: /non matching/ }]
+      }),
+      createPullRequestInfo({
+        labels: {
+          nodes: [{
+            name: 'label'
+          }]
+        }
+      })
+    )
+    expect(result.status).toBe('fail')
+  })
 })

test/config.test.ts

@@ -20,6 +20,13 @@ describe('Config', () => {
     expect(config.rules[0].maxRequestedChanges.NONE).toBe(defaultConfig.maxRequestedChanges.NONE)
   })
 
+  it('will parse regex patterns', () => {
+    const config = getConfigFromUserConfig({
+      requiredLabels: [{ regex: 'regex' }]
+    }) as any
+    expect(config.requiredLabels[0].regex).toBeInstanceOf(RegExp)
+  })
+
   it('will throw validation error on incorrect configuration', () => {
     const userConfig = {
       blockingLabels: ['labela', { labelb: 'labelc' }]
@@ -33,7 +40,6 @@ describe('Config', () => {
     })()
     expect(validationError).not.toBeUndefined()
     expect(validationError.config.blockingLabels[1]).toEqual(userConfig.blockingLabels[1])
-    expect(validationError.decoderError.message).toEqual('expected a string, got an object')
     expect(validationError.decoderError.at).toEqual('input.blockingLabels[1]')
   })
 })

test/pattern.test.ts

@@ -0,0 +1,36 @@
+import { matchesPattern, stringifyPattern } from '../src/pattern'
+
+describe('matchesPattern', () => {
+  describe('while using literal pattern', () => {
+    it('should return true when pattern equals input', () => {
+      expect(matchesPattern('word', 'word')).toBe(true)
+    })
+    it('should return false when input matches only partially', () => {
+      expect(matchesPattern('word', 'abc word abc')).toBe(false)
+    })
+    it('should return false when input has different casing', () => {
+      expect(matchesPattern('word', 'Word')).toBe(false)
+    })
+  })
+
+  describe('while using regex pattern', () => {
+    it('should return true when pattern matches input', () => {
+      expect(matchesPattern({ regex: /word/ }, 'word')).toBe(true)
+    })
+    it('should return true when input has part of pattern', () => {
+      expect(matchesPattern({ regex: /word/ }, 'abc word abc')).toBe(true)
+    })
+    it('should return false when input has different casing', () => {
+      expect(matchesPattern({ regex: /word/ }, 'Word')).toBe(false)
+    })
+  })
+})
+
+describe('stringifyPattern', () => {
+  it('should stringify literal patterns', () => {
+    expect(stringifyPattern('pattern')).toBe('pattern')
+  })
+  it('should stringify regex patterns', () => {
+    expect(stringifyPattern({ regex: /pattern/ })).toBe('{regex: /pattern/}')
+  })
+})