feat(package-rules): add matchRepositories / excludeRepositories

docs/usage/configuration-options.md

@@ -2038,6 +2038,21 @@ Use this field to restrict rules to a particular language. e.g.
 }
 ```
 
+### matchRepositoryPatterns
+
+Use this field to restrict rules to a particular repository. e.g.
+
+```json
+{
+  "packageRules": [
+    {
+      "matchRepositoryPatterns": ["^literal/repo$", "-archived$"],
+      "enabled": false
+    }
+  ]
+}
+```
+
 ### matchBaseBranches
 
 Use this field to restrict rules to a particular branch. e.g.

lib/config/options/index.ts

@@ -1006,6 +1006,20 @@ const options: RenovateOptions[] = [
     cli: false,
     env: false,
   },
+  {
+    name: 'matchRepositoryPatterns',
+    description:
+      'List of repositories to match (e.g. `["-archived$"]`). Valid only within a `packageRules` object.',
+    type: 'array',
+    subType: 'string',
+    format: 'regex',
+    allowString: true,
+    stage: 'package',
+    parent: 'packageRules',
+    mergeable: true,
+    cli: false,
+    env: false,
+  },
   {
     name: 'matchBaseBranches',
     description:

lib/config/types.ts

@@ -330,6 +330,7 @@ export interface PackageRule
   matchPackageNames?: string[];
   matchPackagePatterns?: string[];
   matchPackagePrefixes?: string[];
+  matchRepositoryPatterns?: string[];
   excludeDepNames?: string[];
   excludeDepPatterns?: string[];
   excludePackageNames?: string[];
@@ -480,6 +481,7 @@ export interface PackageRuleInputConfig extends Record<string, unknown> {
   manager?: string;
   datasource?: string;
   packageRules?: (PackageRule & PackageRuleInputConfig)[];
+  repository?: string;
 }
 
 export interface ConfigMigration {

lib/config/validation.ts

@@ -325,6 +325,7 @@ export async function validateConfig(
               'matchSourceUrls',
               'matchUpdateTypes',
               'matchConfidence',
+              'matchRepositoryPatterns',
             ];
             if (key === 'packageRules') {
               for (const [subIndex, packageRule] of val.entries()) {

lib/util/package-rules/matchers.ts

@@ -13,6 +13,7 @@ import { PackageNameMatcher } from './package-names';
 import { PackagePatternsMatcher } from './package-patterns';
 import { PackagePrefixesMatcher } from './package-prefixes';
 import { PathsMatcher } from './paths';
+import { RepositoryPatternsMatcher } from './repository-patterns';
 import { SourceUrlPrefixesMatcher } from './sourceurl-prefixes';
 import { SourceUrlsMatcher } from './sourceurls';
 import type { MatcherApi } from './types';
@@ -41,3 +42,4 @@ matchers.push([new MergeConfidenceMatcher()]);
 matchers.push([new SourceUrlsMatcher(), new SourceUrlPrefixesMatcher()]);
 matchers.push([new CurrentValueMatcher()]);
 matchers.push([new CurrentVersionMatcher()]);
+matchers.push([new RepositoryPatternsMatcher()]);

lib/util/package-rules/repository-patterns.spec.ts

@@ -0,0 +1,43 @@
+import { RepositoryPatternsMatcher } from './repository-patterns';
+
+describe('util/package-rules/repository-patterns', () => {
+  const packageNameMatcher = new RepositoryPatternsMatcher();
+
+  describe('match', () => {
+    it('should return false if repository is not defined', () => {
+      const result = packageNameMatcher.matches(
+        {
+          repository: undefined,
+        },
+        {
+          matchRepositoryPatterns: ['org/repo'],
+        }
+      );
+      expect(result).toBeFalse();
+    });
+
+    it('should return false if repository does not match pattern', () => {
+      const result = packageNameMatcher.matches(
+        {
+          repository: 'org/repo',
+        },
+        {
+          matchRepositoryPatterns: ['org/other-repo'],
+        }
+      );
+      expect(result).toBeFalse();
+    });
+
+    it('should return true if repository matches pattern', () => {
+      const result = packageNameMatcher.matches(
+        {
+          repository: 'org/repo-archived',
+        },
+        {
+          matchRepositoryPatterns: ['-archived$'],
+        }
+      );
+      expect(result).toBeTrue();
+    });
+  });
+});

lib/util/package-rules/repository-patterns.ts

@@ -0,0 +1,44 @@
+import is from '@sindresorhus/is';
+import type { PackageRule, PackageRuleInputConfig } from '../../config/types';
+import { logger } from '../../logger';
+import { regEx } from '../regex';
+import { Matcher } from './base';
+import { massagePattern } from './utils';
+
+export class RepositoryPatternsMatcher extends Matcher {
+  override matches(
+    { repository }: PackageRuleInputConfig, // TODO - need correct fields
+    { matchRepositoryPatterns }: PackageRule
+  ): boolean | null {
+    if (is.undefined(matchRepositoryPatterns)) {
+      return null;
+    }
+
+    if (is.undefined(repository)) {
+      return false;
+    }
+
+    const reposToMatchAgainst = [repository];
+
+    let isMatch = false;
+    for (const repositoryPattern of matchRepositoryPatterns) {
+      if (
+        reposToMatchAgainst.some((repo) =>
+          isRepositoryMatch(repositoryPattern, repo)
+        )
+      ) {
+        isMatch = true;
+      }
+    }
+    return isMatch;
+  }
+}
+
+function isRepositoryMatch(repoPattern: string, repo: string): boolean {
+  const re = regEx(massagePattern(repoPattern));
+  if (re.test(repo)) {
+    logger.trace(`${repo} matches against ${String(re)}`);
+    return true;
+  }
+  return false;
+}