* @param historyDays days number of days to store build history .
 * @param artifactsDays number of days to store artifacts. In the stored history, artifacts older than this number will be cleaned up.
 * @param artifactPatterns patterns for artifacts clean-up. If not specified, all artifacts will be removed.
 */
fun Project.cleanupRule(historyDays: Int, artifactsDays: Int, artifactsPatterns: String? = null) {
    features {

                        testClassesDirs += sharedArchTestClasses.filter { it.isDirectory }
                        classpath += sourceSets.main.get().output.classesDirs
                        systemProperty("package.cycle.exclude.patterns", packageCyclesExtension.excludePatterns.get().joinToString(","))
                        extensions.findByType<DevelocityTestConfiguration>()?.apply {

const checkPattern = pattern => pattern
    && isString(pattern)
    && !REGEX_TEST_BLANK_LINE.test(pattern)
    && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)

    // > A line starting with # serves as a comment.
    && pattern.indexOf('#') !== 0

const splitPattern = pattern => pattern.split(REGEX_SPLITALL_CRLF)

class IgnoreRule {
    constructor (

<component name="DependencyValidationManager">
    <!-- The source of truth for this pattern is `build-logic/basics/src/main/kotlin/gradlebuild/basics/PublicApi.kt` file, please keep them in sync -->
    <scope name="Gradle public API"

            task.dependsOn(extension.getUserManual().getStagedDocumentation());

            task.sources(patternSet -> {
                patternSet.include("**/*.adoc");
                patternSet.exclude("javaProject*Layout.adoc");
                patternSet.exclude("userguide_single.adoc");
                patternSet.exclude("snippets/**/*.adoc");
            });

            // TODO: This breaks the provider

    // NEVER
    "MissingSummary", // We have another mechanism to check Javadocs on public API
    "InjectOnConstructorOfAbstractClass", // We use abstract injection as a pattern
    "JavaxInjectOnAbstractMethod", // We use abstract injection as a pattern
    "JavaUtilDate", // We are fine with using Date
)

project.plugins.withType<JavaBasePlugin> {
    project.extensions.getByName<SourceSetContainer>("sourceSets").configureEach {

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SourceMetaDataVisitor extends VoidVisitorAdapter<ClassMetaDataRepository<ClassMetaData>> {
    private static final Pattern GETTER_METHOD_NAME = Pattern.compile("(get|is)(.+)");
    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();

        private
        const val RELEASE_BRANCH = "release"

        private
        const val EXPERIMENTAL_BRANCH = "experimental"

        private
        val OLD_RELEASE_PATTERN = "release(\\d+)x".toRegex()

        fun fromDslContext(): VersionedSettingsBranch {
            val branch = DslContext.getParameter("Branch")
            // TeamCity uses a dummy name when first running the DSL

        private
        val isoTimestampFormat = newSimpleDateFormatUTC("yyyy-MM-dd HH:mm:ss z")

        private
        fun newSimpleDateFormatUTC(pattern: String) = SimpleDateFormat(pattern).apply {
            timeZone = TimeZone.getTimeZone("UTC")
        }

        fun readBuildReceiptFromString(buildReceipt: String) =
            Properties().apply { load(buildReceipt.reader()) }

    }

    private static final Pattern UNIX_PID_PATTERN = Pattern.compile("([0-9]+)");
    private static final Pattern WINDOWS_PID_PATTERN = Pattern.compile("([0-9]+)\\s*$");
    private static final String MY_PID = String.valueOf(ProcessHandle.current().pid());
    private static final String JAVA_EXECUTABLE_PATTERN_STR = "java(?:\\.exe)?";
    private static final String GRADLE_MAIN_CLASS_PATTERN_STR = "(org\\.gradle\\.[a-zA-Z]+)";