Kotlin Single-File Scripts

//| mvnDeps:
//| - com.github.ajalt.clikt:clikt:5.0.3
//| - com.konghq:unirest-java:3.14.5
//| - org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3

import com.github.ajalt.clikt.core.CliktCommand
import com.github.ajalt.clikt.core.main
import com.github.ajalt.clikt.parameters.options.*
import com.github.ajalt.clikt.parameters.types.int
import kotlinx.serialization.json.*
import kong.unirest.Unirest
import java.nio.file.*

fun fetchLinks(title: String): List<String> {
    val response = Unirest.get("https://en.wikipedia.org/w/api.php")
        .queryString("action", "query")
        .queryString("titles", title)
        .queryString("prop", "links")
        .queryString("format", "json")
        .header("User-Agent", "WikiFetcherBot/1.0 (https://example.com; contact@example.com)")
        .asString()

    if (!response.isSuccess) return emptyList()

    val json = Json.parseToJsonElement(response.body).jsonObject
    val pages = json["query"]?.jsonObject?.get("pages")?.jsonObject ?: return emptyList()
    return pages.values.flatMap { page ->
        page.jsonObject["links"]
            ?.jsonArray
            ?.mapNotNull { it.jsonObject["title"]?.jsonPrimitive?.content }
            ?: emptyList()
    }
}

class Crawler : CliktCommand(name = "wiki-fetcher") {
    val startArticle by option(help = "Starting Wikipedia article").required()
    val depth by option(help = "Depth of link traversal").int().required()

    override fun run() {
        var seen = mutableSetOf(startArticle)
        var current = mutableSetOf(startArticle)

        repeat(depth) {
            val next = current.flatMap { fetchLinks(it) }.toSet()
            current = (next - seen).toMutableSet()
            seen += current
        }

        val jsonOut = Json { prettyPrint = true }
            .encodeToString(JsonElement.serializer(), JsonArray(seen.map { JsonPrimitive(it) }))
        Files.writeString(Paths.get("fetched.json"), jsonOut)
    }
}

fun main(args: Array<String>) = Crawler().main(args)

> ./mill JsonApiClient.kt --start-article singapore --depth 2

> cat fetched.json
[
    "Calling code",
    "+65",
    "British Empire",
    "1st Parliament of Singapore",
    ...
]

//| mvnDeps: [org.jsoup:jsoup:1.7.2]

import org.jsoup.Jsoup
import org.jsoup.nodes.Document
import org.jsoup.nodes.Element

fun fetchLinks(title: String): List<String> {
    val url = "https://en.wikipedia.org/wiki/$title"
    val doc: Document = Jsoup.connect(url)
        .header("User-Agent", "Mozilla/5.0 (compatible; JsoupBot/1.0; +https://example.com/bot)")
        .get()

    return doc.select("main p a")
        .mapNotNull { a ->
            val href = a.attr("href")
            if (href.startsWith("/wiki/")) href.removePrefix("/wiki/") else null
        }
}

fun main(args: Array<String>) {
    if (args.size < 2) {
        System.err.println("Usage: kotlin Scraper <startArticle> <depth>")
        return
    }

    val startArticle = args[0]
    val depth = args[1].toInt()

    var seen = mutableSetOf(startArticle)
    var current = mutableSetOf(startArticle)

    repeat(depth) {
        val next = mutableSetOf<String>()
        for (article in current) {
            for (link in fetchLinks(article)) {
                if (seen.add(link)) next.add(link)
            }
        }
        current = next
    }

    seen.forEach { println(it) }
}

> ./mill HtmlScraper.kt singapore 1
Hokkien
Conscription_in_Singapore
Malaysia_Agreement
Government_of_Singapore
...

//| mvnDeps: [io.ktor:ktor-server-core:2.3.7, io.ktor:ktor-server-cio:2.3.7]
import io.ktor.server.engine.*
import io.ktor.server.cio.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun main() {
    embeddedServer(CIO, port = 8080) {
        routing {
            post("/reverse-string") {
                val body = call.receiveText()
                call.respondText(body.reversed())
            }
        }
    }.start(wait = true)
}

> ./mill WebServer.kt:runBackground

> curl -d 'helloworld' localhost:8080/reverse-string
dlrowolleh

//| mvnDeps:
//| - org.xerial:sqlite-jdbc:3.43.0.0
//| - org.jetbrains.exposed:exposed-core:0.55.0
//| - org.jetbrains.exposed:exposed-dao:0.55.0
//| - org.jetbrains.exposed:exposed-jdbc:0.55.0
//| - org.jetbrains.exposed:exposed-java-time:0.55.0
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.javatime.date
import org.jetbrains.exposed.sql.transactions.transaction
import java.nio.file.*
import java.time.LocalDate

object BuyerTable : Table("buyer") {
    val id = integer("id").autoIncrement()
    val name = varchar("name", 255)
    val dateOfBirth = date("date_of_birth")
    override val primaryKey = PrimaryKey(id)
}

object ShippingInfoTable : Table("shipping_info") {
    val id = integer("id").autoIncrement()
    val buyerId = integer("buyer_id") references BuyerTable.id
    val shippingDate = date("shipping_date")
    override val primaryKey = PrimaryKey(id)
}

fun main(args: Array<String>) {
    Database.connect("jdbc:sqlite:./file.db", driver = "org.sqlite.JDBC") // Initialize database

    transaction {
        // Populate database from SQL file - split by semicolons and execute each statement
        val sqlContent = Files.readString(Paths.get("sqlite-customers.sql"))
        sqlContent.split(";")
            .map { it.trim() }
            .filter { it.isNotEmpty() }
            .forEach { statement -> exec(statement) }

        // Find names of buyers whose shipping date is today or later
        val query = BuyerTable
            .join(ShippingInfoTable, JoinType.INNER, BuyerTable.id, ShippingInfoTable.buyerId)
            .select(BuyerTable.name)
            .where { ShippingInfoTable.shippingDate greaterEq LocalDate.parse(args[0]) }

        for (row in query) println(row[BuyerTable.name])
    }
}

> ./mill Database.kt 2011-01-01
James Bond
John Doe

//| mvnDeps:
//| - org.jetbrains.kotlinx:kotlinx-html-jvm:0.11.0
//| - com.atlassian.commonmark:commonmark:0.13.1

import java.io.File
import org.commonmark.parser.Parser
import org.commonmark.renderer.html.HtmlRenderer
import kotlinx.html.*
import kotlinx.html.stream.appendHTML

fun main(args: Array<String>) {
    val outDir = File("site-out")
    val outPostDir = outDir.resolve("post")

    val postInfo = File("post").listFiles { f -> f.extension == "md" }!!
        .map { f ->
            val match = Regex("""(\d+) - (.+)\.md""").matchEntire(f.name)
                ?: error("Invalid post filename: ${f.name}")
            val (prefix, suffix) = match.destructured
            Triple(prefix.toInt(), suffix, f)
        }
        .sortedBy { it.first }

    if (outDir.exists()) outDir.deleteRecursively()
    outPostDir.mkdirs()

    fun writeHtml(path: File, pageTitle: String, bodyContent: FlowContent.() -> Unit) {

    }

    val parser = Parser.builder().build()
    val renderer = HtmlRenderer.builder().build()

    for ((_, suffix, file) in postInfo) {
        val document = parser.parse(file.readText())
        val htmlContent = renderer.render(document)

        val slug = suffix.replace(" ", "-").lowercase()
        val outputFile = outPostDir.resolve("$slug.html")
        outputFile.writer().use { w ->
            w.appendLine("<!DOCTYPE html>")
            w.appendHTML().html {
                body {
                    h1 { +"Blog / $suffix" }
                    unsafe{
                        +htmlContent
                    }
                }
            }
        }
    }
}

> ./mill StaticSite.kt

> cat site-out/post/my-first-post.html
<!DOCTYPE html>
<html>
  <body>
    <h1>Blog / My First Post</h1>
<p>Sometimes you want numbered lists:</p>
<ol>
<li>One</li>
<li>Two</li>
<li>Three</li>
</ol>
  </body>
</html>