onlyIf("Do not run the task if there are no java sources") {
        // Javadoc task will complain if we only have package-info.java files and no
        // other java files (as is with some Kotlin projects)
        !source.matching {
            exclude("**/package-info.java")
        }.isEmpty
    }

    options {
        this as StandardJavadocDocletOptions

        encoding = "utf-8"
        docEncoding = "utf-8"

            return objects.fileCollection().from(projectBaseDirs.map {
                it.flatMap { projectDir -> listOf(File(projectDir, "src/main/java"), File(projectDir, "src/main/groovy")) }
            }).asFileTree.matching {
                include("**/package-info.java")
            }.filter {
                it.isFile
            }
        }
    }

    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)

 * This class provides functionality to load, cache, and retrieve related content
 * based on search queries and virtual host configurations. It supports both exact
 * term matching and regex pattern matching for flexible content association.
 */
public class RelatedContentHelper extends AbstractConfigHelper {

    /**
     * Default constructor for RelatedContentHelper.

    /**
     * Retrieves a paginated list of related content entities.
     *
     * @param relatedContentPager the pager object containing pagination and search parameters
     * @return a list of RelatedContent entities matching the specified criteria
     */
    public List<RelatedContent> getRelatedContentList(final RelatedContentPager relatedContentPager) {

    }

    /**
     * Retrieves related queries for a given search term.
     * The search is performed using the current virtual host context and
     * the query term is converted to lowercase for case-insensitive matching.
     *
     * @param query the search term to find related queries for
     * @return an array of related query strings, or empty array if none found
     */
    public String[] getRelatedQueries(final String query) {

        assertTrue(tag.matches(divUpperNode));
    }

    @Test
    public void test_matches_withId() {
        PrunedTag tag = new PrunedTag("div");
        tag.setId("test-id");

        // Node with matching id
        MockNode nodeWithId = new MockNode("div");
        nodeWithId.addAttribute("id", "test-id");
        assertTrue(tag.matches(nodeWithId));

        // Node with different id

import org.opensearch.script.Script;

/**
 * Job class for updating label information in the search index.
 * This job processes documents and updates their label fields based on URL pattern matching.
 */
public class UpdateLabelJob {

    private static final Logger logger = LogManager.getLogger(UpdateLabelJob.class);

    /**
     * Query builder for filtering documents to be processed.
     */

/**
 * Clean up daemon log files produced in integration tests.
 */
fun FileSystemOperations.removeDaemonLogFiles(dir: Directory) {
    if (dir.asFile.isDirectory) {
        val daemonLogFiles = dir.asFileTree.matching {
            include("**/*.log")
        }
        delete { delete(daemonLogFiles) }
    }

     */
    @InputFiles
    @SkipWhenEmpty
    public FileCollection getFiles() {
        return getSources().get()
            .stream()
            .map(sourceTree -> sourceTree.matching(filesFilter))
            .reduce(FileTree::plus)
            .orElse(projectLayout.files().getAsFileTree());
    }

    @TaskAction
    public void checkInvalidPermissions() throws IOException {

        getFs().delete(spec -> spec.delete(destinationDirectory));
        destinationDirectory.mkdirs();

        Path adocDir = getDocumentationRoot().get().getAsFile().toPath();
        getDocumentationFiles().getAsFileTree().matching(pattern -> pattern.include("**/*.adoc")).forEach(adocFile -> {
            String adocFileName = adocFile.getName();
            // getting_started.adoc -> getting_started-docinfo.html