pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Copyright 2020 Tim Veil
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~     http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License.
  -->

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>io.bloviate</groupId>
    <artifactId>bloviate-parent</artifactId>
    <version>3.2.0</version>

    <packaging>pom</packaging>

    <name>Bloviate Parent</name>
    <description>Reproducible, foreign-key-aware test-data generator for JDBC databases and flat files</description>
    <url>https://github.com/timveil/bloviate</url>
    <inceptionYear>2020</inceptionYear>
    <licenses>
        <license>
            <name>Apache License, Version 2.0</name>
            <url>https://www.apache.org/licenses/LICENSE-2.0.txt</url>
            <distribution>repo</distribution>
            <comments>A business-friendly OSS license</comments>
        </license>
    </licenses>
    <developers>
        <developer>
            <id>timveil</id>
            <name>Tim Veil</name>
            <url>https://github.com/timveil</url>
        </developer>
    </developers>

    <modules>
        <module>bloviate-core</module>
        <module>bloviate-junit</module>
        <module>bloviate-testcontainers</module>
        <module>bloviate-datafaker</module>
        <module>bloviate-benchmarks</module>
    </modules>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- fallback so the pluginManagement reference always resolves (e.g. in this parent's own
             static analysis); every jar-producing module overrides this with its real module name -->
        <automatic.module.name>io.bloviate</automatic.module.name>

        <!-- compile dependency versions -->
        <commons-lang3.version>3.20.0</commons-lang3.version>
        <commons-csv.version>1.14.1</commons-csv.version>
        <jackson.version>2.22.1</jackson.version>
        <slf4j.version>2.0.18</slf4j.version>
        <jgrapht.version>1.5.3</jgrapht.version>
        <jspecify.version>1.0.0</jspecify.version>
        <junit-jupiter.version>6.1.2</junit-jupiter.version>
        <datafaker.version>2.7.0</datafaker.version>

        <!-- transitive-only: jackson-dataformat-yaml and datafaker disagree (2.5 vs 2.6).
             Pinned to the higher so enforcer's dependencyConvergence rule has a single
             answer instead of relying on Maven's nearest-wins tiebreak. -->
        <snakeyaml.version>2.6</snakeyaml.version>

        <!-- test / integration dependency versions -->
        <testcontainers.version>1.21.4</testcontainers.version>
        <hikaricp.version>7.1.0</hikaricp.version>
        <postgresql.version>42.7.13</postgresql.version>
        <mysql.version>9.7.0</mysql.version>
        <mariadb.version>3.5.9</mariadb.version>
        <h2.version>2.4.240</h2.version>
        <sqlite.version>3.53.2.0</sqlite.version>
        <!--
          BigQuery driver. NOT on Maven Central yet, so this is deliberately only referenced from
          bloviate-core's opt-in `bigquery` profile: a default build never resolves it and CI stays
          green without it. To run the BigQuery integration test, either `./mvnw clean install` the
          driver repo or drop its GitHub Releases jar into ~/.m2. Dependabot and versions:display
          cannot resolve this coordinate; bump it by hand.

          4.3.0 is the functional floor. 4.4.0 collapses a batch whose VALUES tuple wraps a
          placeholder (PARSE_JSON(?), CAST(? AS DATETIME)), which BigQuerySupport emits for JSON,
          GEOGRAPHY, INTERVAL and DATETIME columns; without it those tables still fill correctly,
          just one query job per row. 4.4.0 is merged but unreleased, so this stays at 4.3.0;
          bump it once 4.4.0 ships.
        -->
        <tbc-bq-jdbc.version>4.3.0</tbc-bq-jdbc.version>

        <!-- benchmark dependency versions -->
        <jmh.version>1.37</jmh.version>

        <!-- plugin versions -->
        <maven-jar-plugin.version>3.5.1</maven-jar-plugin.version>
        <maven-shade-plugin.version>3.6.2</maven-shade-plugin.version>
        <maven-compiler-plugin.version>3.15.0</maven-compiler-plugin.version>
        <maven-surefire-plugin.version>3.5.6</maven-surefire-plugin.version>
        <jacoco-maven-plugin.version>0.8.15</jacoco-maven-plugin.version>
        <maven-source-plugin.version>3.4.0</maven-source-plugin.version>
        <maven-javadoc-plugin.version>3.12.0</maven-javadoc-plugin.version>
        <versions-maven-plugin.version>2.21.0</versions-maven-plugin.version>
        <maven-enforcer-plugin.version>3.6.3</maven-enforcer-plugin.version>
        <spotless-maven-plugin.version>3.8.0</spotless-maven-plugin.version>
        <spotbugs-maven-plugin.version>4.10.3.0</spotbugs-maven-plugin.version>
        <maven-pmd-plugin.version>3.28.0</maven-pmd-plugin.version>
        <cyclonedx-maven-plugin.version>2.9.2</cyclonedx-maven-plugin.version>

        <!-- Per-package test-coverage floor enforced by jacoco:check (bound to verify). Set just
             below current coverage to lock in no-regression; ratchet upward over time. Modules that
             cannot yet meet the default override these properties in their own pom. -->
        <jacoco.line.min>0.83</jacoco.line.min>
        <jacoco.branch.min>0.68</jacoco.branch.min>
    </properties>

    <distributionManagement>
        <repository>
            <id>github</id>
            <name>GitHub timveil Apache Maven Packages</name>
            <url>https://maven.pkg.github.com/timveil/bloviate</url>
        </repository>
    </distributionManagement>

    <dependencyManagement>
        <dependencies>

            <!-- modules -->
            <dependency>
                <groupId>io.bloviate</groupId>
                <artifactId>bloviate-core</artifactId>
                <version>${project.version}</version>
            </dependency>

            <!-- compile -->
            <dependency>
                <groupId>net.datafaker</groupId>
                <artifactId>datafaker</artifactId>
                <version>${datafaker.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons-lang3.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-csv</artifactId>
                <version>${commons-csv.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.dataformat</groupId>
                <artifactId>jackson-dataformat-yaml</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <dependency>
                <groupId>org.yaml</groupId>
                <artifactId>snakeyaml</artifactId>
                <version>${snakeyaml.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-simple</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.jgrapht</groupId>
                <artifactId>jgrapht-core</artifactId>
                <version>${jgrapht.version}</version>
            </dependency>
            <dependency>
                <groupId>org.jgrapht</groupId>
                <artifactId>jgrapht-io</artifactId>
                <version>${jgrapht.version}</version>
            </dependency>
            <dependency>
                <groupId>org.jspecify</groupId>
                <artifactId>jspecify</artifactId>
                <version>${jspecify.version}</version>
            </dependency>
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-api</artifactId>
                <version>${junit-jupiter.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>jdbc</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>

            <!-- test / integration -->
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter-engine</artifactId>
                <version>${junit-jupiter.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>junit-jupiter</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>postgresql</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>mysql</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>cockroachdb</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>
            <dependency>
                <groupId>org.testcontainers</groupId>
                <artifactId>mariadb</artifactId>
                <version>${testcontainers.version}</version>
            </dependency>
            <dependency>
                <groupId>com.zaxxer</groupId>
                <artifactId>HikariCP</artifactId>
                <version>${hikaricp.version}</version>
            </dependency>
            <dependency>
                <groupId>org.postgresql</groupId>
                <artifactId>postgresql</artifactId>
                <version>${postgresql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mariadb.jdbc</groupId>
                <artifactId>mariadb-java-client</artifactId>
                <version>${mariadb.version}</version>
            </dependency>
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <version>${h2.version}</version>
            </dependency>
            <dependency>
                <groupId>org.xerial</groupId>
                <artifactId>sqlite-jdbc</artifactId>
                <version>${sqlite.version}</version>
            </dependency>
            <dependency>
                <groupId>vc.tbc</groupId>
                <artifactId>tbc-bq-jdbc</artifactId>
                <version>${tbc-bq-jdbc.version}</version>
            </dependency>

            <!-- benchmarks -->
            <dependency>
                <groupId>org.openjdk.jmh</groupId>
                <artifactId>jmh-core</artifactId>
                <version>${jmh.version}</version>
            </dependency>
            <dependency>
                <groupId>org.openjdk.jmh</groupId>
                <artifactId>jmh-generator-annprocess</artifactId>
                <version>${jmh.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>${maven-compiler-plugin.version}</version>
                </plugin>
                <!-- stamps a stable JPMS module name into each jar's manifest so module-path
                     consumers get a guaranteed name instead of one derived from the filename;
                     each module supplies its own ${automatic.module.name} -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>${maven-jar-plugin.version}</version>
                    <configuration>
                        <archive>
                            <manifestEntries>
                                <Automatic-Module-Name>${automatic.module.name}</Automatic-Module-Name>
                            </manifestEntries>
                        </archive>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>${maven-surefire-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-shade-plugin</artifactId>
                    <version>${maven-shade-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>versions-maven-plugin</artifactId>
                    <version>${versions-maven-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-enforcer-plugin</artifactId>
                    <version>${maven-enforcer-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>com.diffplug.spotless</groupId>
                    <artifactId>spotless-maven-plugin</artifactId>
                    <version>${spotless-maven-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>com.github.spotbugs</groupId>
                    <artifactId>spotbugs-maven-plugin</artifactId>
                    <version>${spotbugs-maven-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-pmd-plugin</artifactId>
                    <version>${maven-pmd-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.cyclonedx</groupId>
                    <artifactId>cyclonedx-maven-plugin</artifactId>
                    <version>${cyclonedx-maven-plugin.version}</version>
                </plugin>
            </plugins>
        </pluginManagement>

        <plugins>

            <!-- Build-environment guard rails. Runs at validate in every module, so a
                 stale JDK or a duplicated dependency version fails before anything is
                 compiled rather than midway through the reactor. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-enforcer-plugin</artifactId>
                <executions>
                    <execution>
                        <id>enforce-build-environment</id>
                        <goals>
                            <goal>enforce</goal>
                        </goals>
                        <configuration>
                            <rules>
                                <!-- matches the pinned wrapper (3.9.16); the floor is the
                                     oldest Maven that still resolves this reactor -->
                                <requireMavenVersion>
                                    <version>[3.9.0,)</version>
                                </requireMavenVersion>
                                <!-- maven.compiler.release is 25; building on an older JDK
                                     fails later and less legibly than it does here -->
                                <requireJavaVersion>
                                    <version>[25,)</version>
                                </requireJavaVersion>
                                <banDuplicatePomDependencyVersions/>
                                <!-- Bloviate is not shaded, so every transitive version is one
                                     a consumer actually inherits. Enforced rather than left to
                                     Maven's nearest-wins tiebreak; resolving a new conflict
                                     means an explicit dependencyManagement pin (see snakeyaml). -->
                                <dependencyConvergence/>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- License-header enforcement. Header-only by design: all 213 source files
                 already carry a byte-identical Apache-2.0 header, so this locks in what is
                 already true without a reformat that would rewrite every line's git blame.
                 Adding a full Java formatter is a separate, deliberate decision. -->
            <plugin>
                <groupId>com.diffplug.spotless</groupId>
                <artifactId>spotless-maven-plugin</artifactId>
                <configuration>
                    <java>
                        <licenseHeader>
                            <!-- multiModuleProjectDirectory, not basedir: one shared header
                                 file at the reactor root serves all five modules -->
                            <file>${maven.multiModuleProjectDirectory}/license-header.txt</file>
                        </licenseHeader>
                        <trimTrailingWhitespace/>
                        <endWithNewline/>
                    </java>
                </configuration>
                <executions>
                    <execution>
                        <id>spotless-check</id>
                        <!-- validate, not verify: a missing header fails in seconds instead
                             of after Testcontainers has spun up the integration suite -->
                        <phase>validate</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- Bytecode static analysis. Reports to target/spotbugsXml.xml; the check goal
                 fails the build on any finding that survives config/spotbugs/exclude.xml.
                 Enforcing rather than advisory because the whole baseline (27 findings across
                 two well-understood patterns) was triaged when this was introduced. -->
            <plugin>
                <groupId>com.github.spotbugs</groupId>
                <artifactId>spotbugs-maven-plugin</artifactId>
                <configuration>
                    <effort>Max</effort>
                    <threshold>Medium</threshold>
                    <xmlOutput>true</xmlOutput>
                    <spotbugsXmlOutputDirectory>${project.build.directory}</spotbugsXmlOutputDirectory>
                    <!-- one shared filter for all modules; resolves to the reactor root, which
                         Maven derives from the directory holding .mvn/ -->
                    <excludeFilterFile>${maven.multiModuleProjectDirectory}/config/spotbugs/exclude.xml</excludeFilterFile>
                    <!-- analyse shipped code only; test sources are not part of the public surface -->
                    <includeTests>false</includeTests>
                </configuration>
                <executions>
                    <execution>
                        <id>spotbugs-check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <!-- PMD source analysis + CPD copy-paste detection. Reports to target/pmd.xml and
                 target/cpd.xml.

                 Both fail the build. PMD's baseline was triaged to zero, with every remaining
                 suppression either scoped to one method in source or justified in the ruleset;
                 CPD's single duplication was collapsed into AbstractIndexedIntegerGenerator.

                 They stay in separate executions because the two goals read failOnViolation from
                 their own configuration, and keeping them split means either can be relaxed
                 independently without silently relaxing the other. -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-pmd-plugin</artifactId>
                <configuration>
                    <targetJdk>${maven.compiler.release}</targetJdk>
                    <printFailingErrors>true</printFailingErrors>
                    <linkXRef>false</linkXRef>
                    <rulesets>
                        <ruleset>${maven.multiModuleProjectDirectory}/config/pmd/ruleset.xml</ruleset>
                    </rulesets>
                    <excludeRoots>
                        <excludeRoot>${project.build.directory}/generated-sources</excludeRoot>
                    </excludeRoots>
                    <!-- CPD: flag any duplicated block of 100+ tokens (~25 lines of Java).
                         Literals and identifiers are deliberately NOT normalised — doing so
                         makes CPD match blocks that merely rhyme, which at this codebase's
                         size is noise rather than signal. -->
                    <minimumTokens>100</minimumTokens>
                </configuration>
                <executions>
                    <execution>
                        <id>pmd-analysis</id>
                        <phase>verify</phase>
                        <configuration>
                            <failOnViolation>true</failOnViolation>
                        </configuration>
                        <goals>
                            <goal>pmd</goal>
                            <goal>check</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>cpd-analysis</id>
                        <phase>verify</phase>
                        <configuration>
                            <failOnViolation>true</failOnViolation>
                        </configuration>
                        <goals>
                            <goal>cpd</goal>
                            <goal>cpd-check</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.jacoco</groupId>
                <artifactId>jacoco-maven-plugin</artifactId>
                <version>${jacoco-maven-plugin.version}</version>
                <executions>
                    <execution>
                        <id>prepare-agent</id>
                        <goals>
                            <goal>prepare-agent</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>report</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>report</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>check</id>
                        <phase>verify</phase>
                        <goals>
                            <goal>check</goal>
                        </goals>
                        <configuration>
                            <haltOnFailure>true</haltOnFailure>
                            <rules>
                                <!-- every package in the module must meet the floor; thresholds are
                                     properties so weak modules can relax them in their own pom -->
                                <rule>
                                    <element>PACKAGE</element>
                                    <limits>
                                        <limit>
                                            <counter>LINE</counter>
                                            <value>COVEREDRATIO</value>
                                            <minimum>${jacoco.line.min}</minimum>
                                        </limit>
                                        <limit>
                                            <counter>BRANCH</counter>
                                            <value>COVEREDRATIO</value>
                                            <minimum>${jacoco.branch.min}</minimum>
                                        </limit>
                                    </limits>
                                </rule>
                            </rules>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- CycloneDX SBOM. makeAggregateBom produces one bom.xml describing the whole
                 reactor, so consumers and vulnerability scanners get a single component
                 inventory rather than one per module. Test-scope dependencies are excluded:
                 Testcontainers and the JDBC drivers are not shipped to consumers. -->
            <plugin>
                <groupId>org.cyclonedx</groupId>
                <artifactId>cyclonedx-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>build-sbom</id>
                        <phase>package</phase>
                        <goals>
                            <goal>makeAggregateBom</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <projectType>library</projectType>
                    <schemaVersion>1.6</schemaVersion>
                    <includeBomSerialNumber>true</includeBomSerialNumber>
                    <includeCompileScope>true</includeCompileScope>
                    <includeProvidedScope>true</includeProvidedScope>
                    <includeRuntimeScope>true</includeRuntimeScope>
                    <includeSystemScope>true</includeSystemScope>
                    <includeTestScope>false</includeTestScope>
                    <includeLicenseText>false</includeLicenseText>
                    <outputReactorProjects>true</outputReactorProjects>
                    <outputFormat>xml</outputFormat>
                    <outputName>bom</outputName>
                    <verbose>false</verbose>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>${maven-source-plugin.version}</version>
                <executions>
                    <execution>
                        <id>attach-sources</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-javadoc-plugin</artifactId>
                <version>${maven-javadoc-plugin.version}</version>
                <executions>
                    <execution>
                        <id>attach-javadocs</id>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>
    </build>

    <profiles>
        <!--
            Builds the brand-themed API reference that ships inside the docs site.
            Cloudflare Pages cannot run Java, so the Javadoc is generated locally and
            committed under website/public/api (served verbatim at /api/).

            Regenerate after public-API changes and commit the result:

                ./mvnw -Pjavadoc-site javadoc:aggregate

            notimestamp keeps regenerated output diff-clean; the brand stylesheet and
            breadcrumb strip are layered on so the reference matches the Starlight site.
        -->
        <profile>
            <id>javadoc-site</id>
            <build>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-javadoc-plugin</artifactId>
                        <configuration>
                            <!-- The aggregate goal hard-codes an "apidocs" subfolder under
                                 outputDirectory, so the reference is served at /apidocs/. -->
                            <outputDirectory>${project.basedir}/website/public</outputDirectory>
                            <doctitle>Bloviate API Reference</doctitle>
                            <windowtitle>Bloviate API</windowtitle>
                            <notimestamp>true</notimestamp>
                            <quiet>true</quiet>
                            <additionalOptions>
                                <additionalOption>--add-stylesheet ${project.basedir}/website/javadoc/bloviate-javadoc.css</additionalOption>
                            </additionalOptions>
                            <top><![CDATA[<nav class="blv-site-strip"><a href="/">Bloviate</a><span>/</span><a href="/reference/">Reference</a><span>/</span>API</nav>]]></top>
                            <bottom><![CDATA[<div class="blv-site-foot">Bloviate API Reference &middot; <a href="/">bloviate.io</a></div>]]></bottom>
                        </configuration>
                    </plugin>
                </plugins>
            </build>
        </profile>
    </profiles>

</project>