Gradle plugins#

There are three. Add only the ones you need.

plugins {
	application
	id("io.jimble.jte") version "0.4.0"
	id("io.jimble.run") version "0.4.0"
	id("io.jimble.db")  version "0.4.0"
}

They are not on the Plugin Portal. They come from Maven Central, so write the repository into settings.gradle.kts (the jimble new skeleton already has it).

pluginManagement {
	repositories {
		mavenCentral()
		gradlePluginPortal()
	}
}

Writing it from scratch#

If you are not using jimble new, these two files are enough. What follows was actually run (gradle build chains migrate → codegen → compileJava, and gradle run starts the app).

// settings.gradle.kts
pluginManagement {
	repositories {
		mavenCentral()
		gradlePluginPortal()
	}
}

rootProject.name = "memo"

// build.gradle.kts
plugins {
	application
	id("io.jimble.jte") version "0.4.0"   // if you use src/main/jte
	id("io.jimble.run") version "0.4.0"   // if you want hot reload
	id("io.jimble.db")  version "0.4.0"   // if you use a database
}

repositories {
	mavenCentral()
}

// jimble is built for Java 25. Without this the dependencies will not resolve
java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(25)
	}
}

dependencies {
	implementation("io.jimble:jimble-web:0.4.0")

	testImplementation(platform("org.junit:junit-bom:5.11.4"))
	testImplementation("org.junit.jupiter:junit-jupiter")
	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

tasks.withType<Test>().configureEach {
	useJUnitPlatform()
}

// Add conf/ to the resources. Config and migrations are both read from there ([Configuration](./config))
sourceSets {
	main {
		resources {
			srcDir("conf")
		}
	}
}

application {
	mainClass = "memo.App"
}

jimbleRun {
	mainClass = "memo.App"
}

Dependency resolution is looking for a library compatible with JVM runtime version 21,
but 'io.jimble:jimble-web:0.4.0' is only compatible with JVM runtime version 25 or newer

Which artifact to depend on#

You do not write down what comes along for the ride (add jimble-web and you get jimble-db and jimble-util too).

You do not need a JDBC driver — jimble-db carries MySQL / MariaDB and PostgreSQL.

io.jimble.db#

./gradlew migrate       # apply the SQL that has not been applied
./gradlew codegen       # build the table definition classes (after migrate)
./gradlew codegenCheck  # check the committed generated code against the schema

What they do is in Migrations and code generation.

jimble {
	sourceRoot   = "src/main/java"   // where generated code goes
	env          = "local"           // passed to the CLI as -Denv=...
	autoGenerate = true              // wire it in front of compileJava?
}

So migrate → codegen → compileJava is wired only locally. It is not wired in CI, which compiles straight from the committed generated code.

./gradlew build -Pjimble.autoGenerate=true    # when you want it wired in CI too

When codegenCheck finds drift, it fails and says this.

コミットされている生成物がスキーマと一致しません（2 件）。codegen を実行してコミットしてください。
  生成物が古いです: db/blog_example/table/post/Post.java
  生成物が足りません: db/blog_example/table/tag/Tag.java

In English: "The committed generated code does not match the schema (2 files). Run codegen and commit the result." — then, per file, "generated code is stale" and "generated code is missing".

io.jimble.jte#

The .jte files under src/main/jte are turned into Java. compileJava compiles them, so a type error in a template fails the build (Templates).

jte {
	sourceDirectory       = "src/main/jte"
	packageName           = "gg.jte.generated.precompiled"
	contentType           = "Html"    // Html | Plain
	trimControlStructures = true
	htmlCommentsPreserved = false
}

Only the plugin carries the compiler (gg.jte:jte). The application's runtime classpath gets jte-runtime and nothing else (requirement D-27).

io.jimble.run#

./gradlew jimbleRun

How it works and what to watch out for is in Hot reload. This page is the list of settings.

jimbleRun {
	mainClass = "my_blog.App"        // required
}

What gets watched is src, conf (if it exists), and watchDirs.

When the build fails#

Nothing stops. The failure comes out in the browser.

Fix it, save, reload, and you carry on.