AbstractSuperClassChangesRule(Map<String, Object> params) {
        super(params)
        final List<String> publicApiPatterns = (List<String>)params['publicApiPatterns'];
        this.publicApiPatterns = publicApiPatterns.collect { Pattern.compile(it) }
    }

    Violation maybeViolation(final JApiCompatibility member) {
        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {

        UpgradedProperties.maybeGetKeyOfOldAccessorOfUpgradedProperty(member, context).ifPresent { seenOldAccessorsOfUpgradedProperties.add(it) }

        def change = new ApiChange(
            context.className,
            Violation.describe(member),
            changes
        )
        String acceptationReason = acceptedApiChanges[change]

        Map<String, CtClass> result = [:]
        collect(result, c)
        return result
    }

    private void collect(Map<String, CtClass> result, CtClass c) {
        c.interfaces.each { result.put(it.name, it) }

        if (c.superclass != null) {
            collect(result, c.superclass)
        }
    }

                assert it.textContent != null : "Found null text element in <$element.tagName>"
            }

            List<Node> trimmedContent = element.childNodes.collect { it };
            boolean inlineContent = trimmedContent.find { it instanceof Text && it.textContent.trim() }

            if (prettyPrint && !inlineContent) {

    }

    String getKey() {
        return titleCell.textContent
    }

    List<Node> getTitle() {
        return titleCell.childNodes.collect { it }
    }

    List<Node> getValue() {
        return valueCell.childNodes.collect { it }
    }

                addSetupRule(BinaryCompatibilityRepositorySetupRule, [
                    (BinaryCompatibilityRepositorySetupRule.Params.sourceRoots): sourceRoots.collect { it.absolutePath } as Set,
                    (BinaryCompatibilityRepositorySetupRule.Params.sourceCompilationClasspath): newClasspath.collect { it.absolutePath } as Set
                ])
                addSetupRule(UpgradePropertiesRuleSetup, [

    def classDoc(Map<String, ?> args = [:], String name) {
        ClassDoc classDoc = Mock()
        def content = args.content ?: parse('<section></section>')
        def propertiesSection = withCategories { content.section.find { it.title[0].text().trim() == 'Properties' } }
        def propertyDetailsSection = withCategories { content.section.find { it.title[0].text().trim() == 'Property details' } }

        Set<CtMethod> result = [] as Set
        collect(result, c)
        return result
    }

    private void collect(Set<CtMethod> result, CtClass c) {
        if (c == null) {
            return
        }

        result.addAll(c.declaredMethods.findAll { isPublicApi(it) })

        collect(result, c.superclass)
    }

    private boolean isPublicApi(CtMethod method) {

        ClassDoc superClass = classDoc('org.gradle.SuperClass')
        ClassDoc superType1 = classDoc("org.gradle.SuperType1")
        ClassDoc superType2 = classDoc("org.gradle.SuperType2")

        def content = parse('''
<section>
    <section><title>Methods</title>
        <table>
            <thead><tr><td>Name</td></tr></thead>
            <tr><td>a</td></tr>
            <tr><td>b</td></tr>
        </table>

            .readLines()
            .collect { it.replace("*", "") } // remove the * from the current branch, e.g. * master -> master
            .collect { it.trim() }
            .grep { !it.isEmpty() }
    }

    static List<String> parentCommitsOf(String commit) {
        return getStdout("git show --format=%P --no-patch $commit")
            .split(" ").collect { it.trim() }.grep { !it.isEmpty() }
    }