inSectionElements.remove();

                if (next == null) {
                    break;
                } else {
                    inSection.clear();
                    inSection.add(next);
                    heading = next;
                }
            } else {
                inSection.add(next);
            }
            next = next.nextElementSibling();
        }
    }

        with:
          payload: |
            {
              "text": "<https://github.com/gradle/gradle/${{ github.event.ref }}|[gradle/gradle#${{ github.event.ref }}]> has been pushed",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",

        }

        @Override
        public void onText(String text) {
            boolean ws = text.matches("\\s*");
            if (!ws) {
                onInlineContent();
                visitor.onText(text);
            } else if (!elementStack.isEmpty() && !blockContent.contains(elementStack.getFirst())) {
                visitor.onText(text);
            }
        }

        @Override

            .select("span")
            .text()
            .substringBefore(" If you did this intentionally")
    }


private
fun Document.scrapeMessagesForSeverity(severity: String): List<ReportMessage> =

    select("tr.severity-$severity").map { tr ->
        val entry = tr.select("td")[1]
        ReportMessage(
            entry.select("span")
                .text().substringBefore(" If you did this intentionally"),

    public String getSignature() {
        final StringBuilder builder = new StringBuilder();

        visitSignature(new SignatureVisitor() {
            @Override
            public void visitText(String text) {
                builder.append(text);
            }

            @Override
            public void visitType(String name) {
                builder.append(name);
            }
        });
        return builder.toString();

                }
            }
        }
        return extensions
    }

    def mergeContent(Element typeTable, DslDocModel model) {
        def title = typeTable.title[0].text()

        //TODO below checks makes it harder to add new sections
        //because the new section will work correctly only when the section title ends with 'types' :)
        if (title.matches('(?i).* types')) {

        findLatest("guava", "com.google.guava:guava:(20,)", versionProperties)
        findLatest("commons-math", "org.apache.commons:commons-math3:latest.release", versionProperties)
        findLatest("commons-text", "org.apache.commons:commons-text:latest.release", versionProperties)
        findLatest("kotlin", "org.jetbrains.kotlin:kotlin-gradle-plugin:(1.4,)", versionProperties)

        store(versionProperties)
    }

    private

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.identity.model

import org.gradle.util.GradleVersion

import java.text.SimpleDateFormat
import java.util.Date
import java.util.TimeZone


data class ReleasedVersion(val version: String, val buildTime: String) {
    fun gradleVersion() = GradleVersion.version(version)

import org.gradle.api.Describable
import org.gradle.api.provider.Property
import org.gradle.api.provider.ValueSource
import org.gradle.api.provider.ValueSourceParameters
import org.gradle.api.tasks.Optional
import java.text.SimpleDateFormat
import java.util.Date
import java.util.TimeZone


abstract class BuildTimestampValueSource : ValueSource<String, BuildTimestampValueSource.Parameters>, Describable {

        def propertyDetailsSection = withCategories { content.section.find { it.title[0].text().trim() == 'Property details' } }
        def propertiesTable = withCategories { propertiesSection ? propertiesSection.table[0] : parse('<table/>')}
        def methodsSection = withCategories { content.section.find { it.title[0].text().trim() == 'Methods' } }