Update for modern Exposed

build.gradle

@@ -1,30 +0,0 @@
-plugins {
-	id 'org.jetbrains.kotlin.jvm' version "$kotlinVersion"
-    id 'org.jetbrains.kotlin.plugin.serialization' version "$kotlinVersion"
-	id 'application'
-}
-
-version = '0.1.1'
-
-mainClassName = 'me.msoucy.gbat.MainKt'
-description = 'Git By A Truck'
-
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
-
-repositories {
-	mavenCentral()
-	jcenter()
-}
-
-dependencies {
-	implementation 'org.jetbrains.kotlin:kotlin-stdlib'
-	implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
-	implementation "com.xenomachina:kotlin-argparser:$kotlin_argparser_version"
-	implementation "org.jetbrains.exposed:exposed-core:$kotlin_exposed_version"
-	implementation "org.jetbrains.exposed:exposed-dao:$kotlin_exposed_version"
-	implementation "org.jetbrains.exposed:exposed-jdbc:$kotlin_exposed_version"
-	implementation "org.xerial:sqlite-jdbc:3.30.1"
-    implementation 'com.google.code.gson:gson:2.8.6'
-	testImplementation 'junit:junit:4.12'
-}

build.gradle.kts

@@ -0,0 +1,39 @@
+plugins {
+	kotlin("jvm") version "1.9.22"
+    kotlin("plugin.serialization") version "1.9.22"
+	application
+}
+
+version = "0.1.1"
+
+group = "me.msoucy.gbat"
+description = "Git By A Truck"
+
+kotlin {
+    jvmToolchain(21)
+}
+
+repositories {
+	mavenCentral()
+}
+
+val argparserVersion: String by project
+val exposedVersion: String by project
+dependencies {
+	implementation(kotlin("reflect"))
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
+	implementation("com.xenomachina:kotlin-argparser:$argparserVersion")
+    implementation("org.jetbrains.exposed:exposed-core:$exposedVersion")
+    implementation("org.jetbrains.exposed:exposed-dao:$exposedVersion")
+    implementation("org.jetbrains.exposed:exposed-jdbc:$exposedVersion")
+	implementation("org.xerial:sqlite-jdbc:3.45.1.0")
+    implementation("com.google.code.gson:gson:2.10.1")
+    implementation("org.python:jython-standalone:2.7.2")
+    implementation("org.pygments:pygments:2.5.2")
+	testImplementation("junit:junit:4.12")
+}
+
+application {
+    mainClass.set("MainKt") // The main class of the application
+}

gradle.properties

@@ -1,3 +1,3 @@
-kotlinVersion=1.3.71
-kotlin_argparser_version=2.0.7
-kotlin_exposed_version=0.25.1
+kotlinVersion=1.4.0
+argparserVersion=2.0.7
+exposedVersion=0.47.0

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,67 +17,98 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +118,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +129,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +137,109 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +25,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +55,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,21 +65,6 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
@@ -86,17 +72,19 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

src/main/kotlin/me/msoucy/gbat/Analyze.kt

@@ -1,21 +1,20 @@
 package me.msoucy.gbat
 
 import java.io.File
-import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
-
-import me.msoucy.gbat.models.CondensedAnalysis
 import me.msoucy.gbat.models.Condensation
+import me.msoucy.gbat.models.CondensedAnalysis
 import me.msoucy.gbat.models.KnowledgeModel
 import me.msoucy.gbat.models.LineModel
 import me.msoucy.gbat.models.RiskModel
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.transactions.transaction
 
 fun analyze(
-    riskModel : RiskModel,
-    createdConstant : Double,
-    historyItem : HistoryItem,
-    verbose : Boolean = false
-) : CondensedAnalysis {
+    riskModel: RiskModel,
+    createdConstant: Double,
+    historyItem: HistoryItem,
+    verbose: Boolean = false
+): CondensedAnalysis {
     val lineModel = LineModel()
     val db = Database.connect("jdbc:sqlite::memory:", "org.sqlite.JDBC")
     return transaction(db) {
@@ -25,8 +24,8 @@ fun analyze(
         historyItem.authorDiffs.forEach { (author, changes) ->
             changes.forEach { change ->
                 changesProcessed++
-                if(changesProcessed % 1000 == 0 && verbose) {
-                    System.err.println("Analyzer applied change #${changesProcessed}")
+                if (changesProcessed % 1000 == 0 && verbose) {
+                    System.err.println("Analyzer applied change #$changesProcessed")
                 }
                 lineModel.apply(change.eventType, change.lineNum, change.lineVal ?: "")
                 knowledgeModel.apply(change.eventType, author, change.lineNum)
@@ -44,21 +43,21 @@ fun analyze(
 }
 
 private fun condenseAnalysis(
-    repoRoot : File,
-    projectRoot : File,
-    fname : File,
-    lineModel : LineModel,
-    knowledgeModel : KnowledgeModel,
-    riskModel : RiskModel
-) : CondensedAnalysis {
+    repoRoot: File,
+    projectRoot: File,
+    fname: File,
+    lineModel: LineModel,
+    knowledgeModel: KnowledgeModel,
+    riskModel: RiskModel
+): CondensedAnalysis {
     val condensations = lineModel.get().mapIndexed { idx, line ->
         val knowledges = knowledgeModel.knowledgeSummary(idx + 1).map { (authors, knowledge) ->
             Condensation(authors,
                          knowledge,
-                         if(authors.all(riskModel::isDeparted)) knowledge else 0.0,
+                         if (authors.all(riskModel::isDeparted)) knowledge else 0.0,
                          riskModel.jointBusProb(authors) * knowledge)
         }.sorted()
         Pair(line, knowledges)
     }
     return CondensedAnalysis(repoRoot, projectRoot, fname, condensations.mutableCopyOf())
-}
+}

src/main/kotlin/me/msoucy/gbat/Main.kt

@@ -1,8 +1,9 @@
 package me.msoucy.gbat
 
-import me.msoucy.gbat.models.RiskModel
-import me.msoucy.gbat.models.SummaryModel
-
+import com.xenomachina.argparser.ArgParser
+import com.xenomachina.argparser.InvalidArgumentException
+import com.xenomachina.argparser.default
+import com.xenomachina.argparser.mainBody
 import java.io.File
 import java.util.concurrent.Executors
 import kotlin.math.pow
@@ -12,90 +13,81 @@ import kotlin.text.RegexOption
 import kotlin.text.startsWith
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
-
-import com.xenomachina.argparser.ArgParser
-import com.xenomachina.argparser.InvalidArgumentException
-import com.xenomachina.argparser.default
-import com.xenomachina.argparser.mainBody
-
+import me.msoucy.gbat.models.RiskModel
+import me.msoucy.gbat.models.SummaryModel
 import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
 
 val REALLY_LONG_TIME = 864000
 val DEFAULT_INTERESTING_RES = mutableListOf(
-	"\\.java$",
-	"\\.cs$",
-	"\\.py$",
-	"\\.c$",
-	"\\.cpp$",
-	"\\.h$",
-	"\\.hpp$",
-	"\\.pl$",
-	"\\.perl$",
-	"\\.rb$",
-	"\\.sh$",
+    "\\.java$",
+    "\\.cs$",
+    "\\.py$",
+    "\\.c$",
+    "\\.cpp$",
+    "\\.h$",
+    "\\.hpp$",
+    "\\.pl$",
+    "\\.perl$",
+    "\\.rb$",
+    "\\.sh$",
     "\\.js$",
     "\\.kt$"
 )
 
-fun validateGit(exe : String) : String {
+fun validateGit(exe: String): String {
     val os = System.getProperty("os.name")
-    var fullexe = if(os.startsWith("Windows") && !exe.endsWith(".exe")) {
+    var fullexe = if (os.startsWith("Windows") && !exe.endsWith(".exe")) {
         exe + ".exe"
     } else exe
     var file = File(fullexe)
-	if(file.canRead()) {
+    if (file.canRead()) {
         return file.absolutePath
     }
-    for(path in System.getenv("PATH").split(";")) {
+    for (path in System.getenv("PATH").split(";")) {
         file = File(path, fullexe)
-        if(file.canRead()) {
+        if (file.canRead()) {
             return file.absolutePath
         }
     }
-    throw InvalidArgumentException("Provided git executable does not exist")	
+    throw InvalidArgumentException("Provided git executable does not exist")
 }
 
 class GbatArgs(parser: ArgParser) {
-	// Input options
-	val interesting by parser.adding("--interesting", "-I",
-		help="Regular expression to determine which files should be included in calculations.")
-	val not_interesting by parser.adding("--not-interesting", "-N",
-		help="Regular expression to determine which files should not be included in calculations.")
-	val case_sensitive by parser.flagging("Use case sensitive regexps when determining interesting files (default is case-insensitive)")
-	val departed by parser.storing("--departed-file", "-D", help="File listing departed devs, one per line", transform=::File).default<File?>(null)
-	val risk_file by parser.storing("--bus-risk-file", help="File of dev=float lines (e.g. ejorgensen=0.4) with custom bus risks for devs", transform=::File).default<File?>(null)
-	val default_bus_risk by parser.storing("--default-bus-risk", help="Default risk that a dev will be hit by a bus in your analysis timeframe (defaults to 0.1).") { toDouble() }.default(0.1)
+    // Input options
+    val interesting by parser.adding("--interesting", "-I", help = "Regular expression to determine which files should be included in calculations.")
+    val not_interesting by parser.adding("--not-interesting", "-N", help = "Regular expression to determine which files should not be included in calculations.")
+    val case_sensitive by parser.flagging("Use case sensitive regexps when determining interesting files (default is case-insensitive)")
+    val departed by parser.storing("--departed-file", "-D", help = "File listing departed devs, one per line", transform = ::File).default<File?>(null)
+    val risk_file by parser.storing("--bus-risk-file", help = "File of dev=float lines (e.g. ejorgensen=0.4) with custom bus risks for devs", transform = ::File).default<File?>(null)
+    val default_bus_risk by parser.storing("--default-bus-risk", help = "Default risk that a dev will be hit by a bus in your analysis timeframe (defaults to 0.1).") { toDouble() }.default(0.1)
 
-	// Multiprocessing options
-	val num_git_procs by parser.storing("--num-git-procs", help="The number of git processes to run simultaneously (defaults to 3)") { toInt() }.default(3)
-	val num_analyzer_procs by parser.storing("--num-analyzer-procs", help="The number of analyzer processes to run (defaults to 3)") { toInt() }.default(3)
+    // Multiprocessing options
+    val num_analyzer_procs by parser.storing("--num-analyzer-procs", help = "The number of analyzer processes to run (defaults to 3)") { toInt() }.default(3)
 
-	// Tuning options
-	val risk_threshold by parser.storing("--risk-threshold", help="Threshold past which to summarize risk (defaults to default bus risk cubed)") { toDouble() }.default<Double?>(null)
-	val creation_constant by parser.storing("--knowledge-creation-constant", help="How much knowledge a changed line should create if a new line creates 1 (defaults to 0.1)") { toDouble() }.default(0.1)
+    // Tuning options
+    val risk_threshold by parser.storing("--risk-threshold", help = "Threshold past which to summarize risk (defaults to default bus risk cubed)") { toDouble() }.default<Double?>(null)
+    val creation_constant by parser.storing("--knowledge-creation-constant", help = "How much knowledge a changed line should create if a new line creates 1 (defaults to 0.1)") { toDouble() }.default(0.1)
 
-	// Misc options
-	val git_exe by parser.storing("--git-exe", help="Path to the git executable", transform=::validateGit).default("git").addValidator { validateGit(value) }
-	val verbose by parser.flagging("--verbose", "-v", help="Print comforting output")
-	val output by parser.storing("Output directory for data files and html summary (defaults to \"output\"), error if already exists").default("output")
+    // Misc options
+    val git_exe by parser.storing("--git-exe", help = "Path to the git executable", transform = ::validateGit).default("git").addValidator { validateGit(value) }
+    val verbose by parser.flagging("--verbose", "-v", help = "Print comforting output")
+    val output by parser.storing("Output directory for data files and html summary (defaults to \"output\"), error if already exists").default("output")
 
-	// Directory
+    // Directory
     val project_root by parser.positional("The root directory to inspect")
 }
 
 fun main(args: Array<String>) = mainBody {
-	ArgParser(args).parseInto(::GbatArgs).run {
+    ArgParser(args).parseInto(::GbatArgs).run {
         val outDir = File(output)
-        if(outDir.isDirectory) {
-            //throw InvalidArgumentException("Output directory already exists")
-        }
 
+        outDir.delete()
         outDir.mkdirs()
+        File(outDir, ".gitignore").writeText("*")
 
-        fun parse_interesting(theList : List<String>) =
+        fun parse_interesting(theList: List<String>) =
             theList.map {
-                if(case_sensitive) {
+                if (case_sensitive) {
                     Regex(it)
                 } else {
                     Regex(it, RegexOption.IGNORE_CASE)
@@ -107,22 +99,20 @@ fun main(args: Array<String>) = mainBody {
         val not_interesting_res = if (not_interesting.isEmpty()) listOf() else parse_interesting(not_interesting)
 
         val projectRootFile = File(project_root).also {
-            if(!it.isDirectory)
+            if (!it.isDirectory)
                 throw InvalidArgumentException("Provided project root does not exist")
         }
 
         val repo = GitRepo(projectRootFile, validateGit(git_exe))
 
-        fun String.isInteresting() : Boolean {
+        fun String.isInteresting(): Boolean {
             var hasInterest = interesting_res.any { it.containsMatchIn(this) }
-            if(hasInterest) {
+            if (hasInterest) {
                 hasInterest = !not_interesting_res.any { it.containsMatchIn(this) }
             }
             return hasInterest
         }
-
-        fun GitRepo.interestingNames() = ls().split("\n").filter{ it.isInteresting() }
-        val fnames = repo.interestingNames()
+        val fnames = repo.ls().split("\n").filter { it.isInteresting() }
 
         if (fnames.isEmpty()) {
             System.err.println("No interesting files found, exiting.")
@@ -136,30 +126,34 @@ fun main(args: Array<String>) = mainBody {
         val riskModel = RiskModel(riskThresh, default_bus_risk, risk_file, departed)
 
         val dbFname = File(outDir, "summary.db")
-        dbFname.delete();
-        val summaryDb = Database.connect("jdbc:sqlite:${dbFname.absolutePath}", driver="org.sqlite.JDBC")
-        transaction(summaryDb) {
-            addLogger(StdOutSqlLogger)
-            // exec("PRAGMA journal_mode = OFF")
-            // exec("PRAGMA synchronous = OFF")
-        }
+        dbFname.delete()
+        val summaryDb = Database.connect("jdbc:sqlite:${dbFname.absolutePath}", driver = "org.sqlite.JDBC")
         val summaryModel = SummaryModel(summaryDb)
+        val analysisExecutor = Executors.newFixedThreadPool(num_analyzer_procs).asCoroutineDispatcher()
 
         runBlocking {
-            flow {
-                fnames.forEach { fname ->
-                    emit(parseHistory(repo, projectRootFile, File(fname)))
+            fnames.map { fname ->
+                async(analysisExecutor) {
+                    if (verbose) {
+                        println("Analyzing $fname")
+                    }
+                    val history = parseHistory(repo, projectRootFile, File(projectRootFile, fname))
+                    analyze(riskModel, creation_constant, history, verbose)
+                }
+            }.awaitAll().forEach { analysis ->
+                if (verbose) {
+                    println("Summarizing ${analysis.fileName}")
                 }
-            }.map { history ->
-                analyze(riskModel, creation_constant, history, verbose)
-            }.collect { analysis ->
                 summaryModel.summarize(analysis)
             }
         }
 
+        if (verbose) {
+            println("Rendering output")
+        }
         renderSummary(projectRootFile, summaryModel, outDir)
 
         // Render summary
-        System.err.println("Done, summary is in ${outDir}/index.html")
+        System.err.println("Done, summary is in $outDir/index.html")
     }
 }

src/main/kotlin/me/msoucy/gbat/ParseHistory.kt

@@ -3,25 +3,26 @@ package me.msoucy.gbat
 import java.io.File
 import kotlin.math.abs
 import kotlin.math.max
-
 import me.msoucy.gbat.models.ChangeType
 import me.msoucy.gbat.models.Event
 
 data class HistoryItem(
-    val repoRoot : File,
-    val projectRoot : File,
-    val fname : File,
-    val authorDiffs : List<Pair<String, List<Event>>>
+    val repoRoot: File,
+    val projectRoot: File,
+    val fname: File,
+    val authorDiffs: List<Pair<String, List<Event>>>
 )
 
-fun parseHistory(repo : GitRepo,
-                 projectRoot : File,
-                 fname : File,
-                 verbose : Boolean = false) : HistoryItem {
+fun parseHistory(
+    repo: GitRepo,
+    projectRoot: File,
+    fname: File,
+    verbose: Boolean = false
+): HistoryItem {
     val entries = repo.log(fname)
     val repoRoot = repo.root()
-    if(verbose) {
-        System.err.println("Parsing history for ${fname}")
+    if (verbose) {
+        System.err.println("Parsing history for $fname")
     }
     return HistoryItem(repoRoot, projectRoot, fname,
         entries.map { (author, diff) ->
@@ -30,27 +31,27 @@ fun parseHistory(repo : GitRepo,
     )
 }
 
-fun diffWalk(diff : Diff) : List<Event> {
+fun diffWalk(diff: Diff): List<Event> {
 
     fun String.startsChunk() = startsWith("@@")
     fun String.isOldLine() = startsWith("-")
     fun String.isNewLine() = startsWith("+")
 
-    fun chunkify() : List<List<String>> {
+    fun chunkify(): List<List<String>> {
         val chunks = mutableListOf<MutableList<String>>()
         var curChunk = mutableListOf<String>()
         diff.split("\n").forEach { line ->
-            if(line.startsChunk()) {
-                if(curChunk.isNotEmpty()) {
+            if (line.startsChunk()) {
+                if (curChunk.isNotEmpty()) {
                     chunks.add(curChunk)
                     curChunk = mutableListOf<String>()
                 }
                 curChunk.add(line)
-            } else if(curChunk.isNotEmpty()) {
+            } else if (curChunk.isNotEmpty()) {
                 curChunk.add(line)
             }
         }
-        if(curChunk.isNotEmpty()) {
+        if (curChunk.isNotEmpty()) {
             chunks.add(curChunk)
         }
         return chunks
@@ -60,23 +61,23 @@ fun diffWalk(diff : Diff) : List<Event> {
     val events = mutableListOf<Event>()
 
     class Hunk(
-        val lineNum : Int,
-        val oldLines : List<String>,
-        val newLines : List<String>
+        val lineNum: Int,
+        val oldLines: List<String>,
+        val newLines: List<String>
     )
 
-    fun hunkize(chunkWoHeader : List<String>, firstLineNum : Int) : List<Hunk> {
+    fun hunkize(chunkWoHeader: List<String>, firstLineNum: Int): List<Hunk> {
         var curOld = mutableListOf<String>()
         var curNew = mutableListOf<String>()
         var curLine = firstLineNum
         var hunks = mutableListOf<Hunk>()
 
         chunkWoHeader.forEach { line ->
-            if(line.isOldLine()) {
+            if (line.isOldLine()) {
                 curOld.add(line)
-            } else if(line.isNewLine()) {
+            } else if (line.isNewLine()) {
                 curNew.add(line)
-            } else if(curOld.isNotEmpty() || curNew.isNotEmpty()) {
+            } else if (curOld.isNotEmpty() || curNew.isNotEmpty()) {
                 hunks.add(Hunk(curLine, curOld, curNew))
                 curLine += curNew.size + 1
                 curOld = mutableListOf<String>()
@@ -85,28 +86,28 @@ fun diffWalk(diff : Diff) : List<Event> {
                 curLine++
             }
         }
-        if(curOld.isNotEmpty() || curNew.isNotEmpty()) {
+        if (curOld.isNotEmpty() || curNew.isNotEmpty()) {
             hunks.add(Hunk(curLine, curOld, curNew))
         }
 
         return hunks
     }
 
-    fun stepHunk(hunk : Hunk) {
+    fun stepHunk(hunk: Hunk) {
         val oldLen = hunk.oldLines.size
         val newLen = hunk.newLines.size
         val maxLen = max(oldLen, newLen)
         var lineNum = hunk.lineNum
 
         for (i in 0 until maxLen) {
-            if(i < oldLen && i < newLen) {
+            if (i < oldLen && i < newLen) {
                 events += Event(
                     ChangeType.Change,
                     lineNum,
                     hunk.newLines[i].substring(1)
                 )
                 lineNum++
-            } else if(i < oldLen) {
+            } else if (i < oldLen) {
                 events += Event(
                     ChangeType.Remove,
                     lineNum,
@@ -123,7 +124,7 @@ fun diffWalk(diff : Diff) : List<Event> {
         }
     }
 
-    fun stepChunk(chunk : List<String>) {
+    fun stepChunk(chunk: List<String>) {
         val header = chunk[0]
 
         // format of header is
@@ -137,7 +138,7 @@ fun diffWalk(diff : Diff) : List<Event> {
         // of the file the new and old are the same, and since we add
         // and subtract lines as we go, we should stay in step with the
         // new offsets.
-        val newOffset = offsets[1].split(",").map{
+        val newOffset = offsets[1].split(",").map {
             abs(it.toInt())
         }.first()
 
@@ -150,4 +151,4 @@ fun diffWalk(diff : Diff) : List<Event> {
     chunks.forEach(::stepChunk)
 
     return events
-}
+}

src/main/kotlin/me/msoucy/gbat/Renderer.kt

@@ -1,40 +1,36 @@
 package me.msoucy.gbat
 
-import java.io.File
-
-import me.msoucy.gbat.models.ProjectTreeNode
-import me.msoucy.gbat.models.ProjectTreeResult
-import me.msoucy.gbat.models.Statistics
-import me.msoucy.gbat.models.SummaryModel
-
 import com.google.gson.GsonBuilder
+import java.io.File
+import me.msoucy.gbat.models.SummaryModel
 import org.jetbrains.exposed.sql.*
 import org.jetbrains.exposed.sql.transactions.transaction
+import org.python.util.PythonInterpreter
 
 val NUM_RISKIEST_AUTHORS = 10
 val NUM_RISKIEST_FILES = 10
 
 class SummaryRenderer(
-    val summaryModel : SummaryModel,
-    val outputDir : File
+    val summaryModel: SummaryModel,
+    val outputDir: File
 ) {
     private val filesDir = File(outputDir, "files")
     private val gson = GsonBuilder().setPrettyPrinting().create()
 
-    fun renderAll(projectRoot : File) {
+    fun renderAll(projectRoot: File) {
         createFilesDir()
         renderSummaryJson(projectRoot)
         renderFileJson(projectRoot)
-        // renderSrc(projectRoot)
+        renderSrc(projectRoot)
     }
 
-    private fun renderSummaryJson(projectRoot : File) {
+    private fun renderSummaryJson(projectRoot: File) {
         val summary = summaryModel.projectSummary(projectRoot.absolutePath)
         val json = gson.toJson(summary)
         File(filesDir, "summary.json").writeText(json)
     }
 
-    private fun renderFileJson(projectRoot : File) {
+    private fun renderFileJson(projectRoot: File) {
         summaryModel.projectFiles(projectRoot.absolutePath).forEach {
             val json = gson.toJson(summaryModel.fileSummary(it.fileId))
             File(filesDir, "${it.fileId}.json").writeText(json)
@@ -42,15 +38,41 @@ class SummaryRenderer(
     }
 
     private fun createFilesDir() = filesDir.mkdirs()
+
+    private fun renderSrc(projectRoot: File) {
+        val interpreter = PythonInterpreter()
+        val cssFile = File(filesDir, "pygments.css")
+        interpreter.exec("""
+from pygments.formatters import HtmlFormatter
+formatter = HtmlFormatter(linenos=True, lineanchors='gbab')
+formatCss = formatter.get_style_defs()
+""")
+        cssFile.writeText(interpreter.get("formatCss", String::class.java))
+
+        summaryModel.projectFiles(projectRoot.absolutePath).forEach {
+            val resultFile = File(filesDir, "${it.fileId}.html")
+            val lines = summaryModel.fileLines(it.fileId)
+            val body = lines.joinToString("\n")
+            interpreter["fname"] = it.fname.toString()
+            interpreter["body"] = body
+            interpreter.exec("""
+from pygments import highlight
+from pygments.lexers import guess_lexer_for_filename
+lexer = guess_lexer_for_filename(fname, body)
+html = highlight(body, lexer, formatter)
+""")
+            resultFile.writeText("""<link rel=stylesheet type="text/css" href="pygments.css">""" + interpreter.get("html", String::class.java))
+        }
+    }
 }
 
 fun renderSummary(
-    projectRoot : File,
-    summaryModel : SummaryModel,
-    outputDir : File
+    projectRoot: File,
+    summaryModel: SummaryModel,
+    outputDir: File
 ) {
     transaction(summaryModel.db) {
         val renderer = SummaryRenderer(summaryModel, outputDir)
         renderer.renderAll(projectRoot)
     }
-}
+}

src/main/kotlin/me/msoucy/gbat/Repo.kt

@@ -5,8 +5,8 @@ import java.io.IOException
 
 typealias Diff = String
 
-class GitRepo(val projectRoot : File, val git_exe : String) {
-    fun ls() : String {
+class GitRepo(val projectRoot: File, val git_exe: String) {
+    fun ls(): String {
         val cmd = listOf(
             git_exe,
             "ls-tree",
@@ -14,13 +14,14 @@ class GitRepo(val projectRoot : File, val git_exe : String) {
             "--name-only",
             "-r",
             "HEAD",
+            "--",
             projectRoot.absolutePath
         )
         val (out, _) = cmd.runCommand(projectRoot)
         return out ?: ""
     }
 
-    fun root() : File {
+    fun root(): File {
         val cmd = listOf(
             git_exe,
             "rev-parse",
@@ -30,7 +31,7 @@ class GitRepo(val projectRoot : File, val git_exe : String) {
         return File((out ?: "").trim())
     }
 
-    fun log(fname : File) : List<Pair<String, Diff>> {
+    fun log(fname: File): List<Pair<String, Diff>> {
         val cmd = listOf(
             git_exe,
             "--no-pager",
@@ -40,14 +41,15 @@ class GitRepo(val projectRoot : File, val git_exe : String) {
             "--follow", // Follow history through renames
             "--patience", // Use the patience diff algorithm
             "-p", // Show patches
+            "--",
             fname.absolutePath
         )
         val (out, err) = cmd.runCommand(projectRoot)
-        if(err != "") {
+        if (err != "") {
             System.err.println("Error from git log: " + err)
             throw IOException(err)
         }
-        val logEntries = (out?: "").split("\u0000").filter {it.trim().isNotEmpty()}
+        val logEntries = (out ?: "").split("\u0000").filter { it.trim().isNotEmpty() }
         return logEntries.map {
             val (header, diffLines) = splitEntryHeader(it)
             val diff = diffLines.joinToString("\n")
@@ -58,25 +60,25 @@ class GitRepo(val projectRoot : File, val git_exe : String) {
         }.reversed()
     }
 
-    private fun parseAuthor(header : List<String>) : String {
-        val segs = header.getOrNull(1)?.trim()?.split("\\s+".toRegex())?: listOf()
+    private fun parseAuthor(header: List<String>): String {
+        val segs = header.getOrNull(1)?.trim()?.split("\\s+".toRegex()) ?: listOf()
         return segs.subList(1, segs.size - 1).joinToString(" ")
     }
 
-    private fun splitEntryHeader(entry : String) : Pair<List<String>, List<String>> {
+    private fun splitEntryHeader(entry: String): Pair<List<String>, List<String>> {
         val lines = entry.split("\n")
-        if(lines.size < 2) {
+        if (lines.size < 2) {
             return Pair(listOf(), listOf())
-        } else if(!lines.get(0).startsWith("commit")) {
+        } else if (!lines.get(0).startsWith("commit")) {
             return Pair(listOf(), listOf())
-        } else if(!lines.get(1).startsWith("Author")) {
+        } else if (!lines.get(1).startsWith("Author")) {
             return Pair(listOf(), listOf())
         }
         var ind = 2
-        while(ind < lines.size && !lines.get(ind).startsWith("diff")) {
+        while (ind < lines.size && !lines.get(ind).startsWith("diff")) {
             ind++
         }
         return Pair(lines.subList(0, ind).copyOf(),
                     lines.subList(ind, lines.size).copyOf())
     }
-}
+}

src/main/kotlin/me/msoucy/gbat/Util.kt

@@ -4,10 +4,10 @@ import java.io.File
 import java.io.IOException
 import java.util.concurrent.TimeUnit
 
-fun <T> Iterable<T>.copyOf() : List<T> = mutableListOf<T>().also { it.addAll(this) }
+fun <T> Iterable<T>.copyOf(): List<T> = mutableListOf<T>().also { it.addAll(this) }
 fun <T> Iterable<T>.mutableCopyOf() = mutableListOf<T>().also { it.addAll(this) }
 
-fun List<String>.runCommand(workingDir: File): Pair<String?,String?> {
+fun List<String>.runCommand(workingDir: File): Pair<String?, String?> {
     try {
         val proc = ProcessBuilder(*this.toTypedArray())
                 .directory(workingDir)
@@ -18,8 +18,8 @@ fun List<String>.runCommand(workingDir: File): Pair<String?,String?> {
         proc.waitFor(5, TimeUnit.SECONDS)
         return Pair(proc.inputStream.bufferedReader().readText(),
                     proc.errorStream.bufferedReader().readText())
-    } catch(e: IOException) {
+    } catch (e: IOException) {
         e.printStackTrace()
         return Pair(null, null)
     }
-}
+}

src/main/kotlin/me/msoucy/gbat/models/KnowledgeModel.kt

@@ -1,30 +1,25 @@
 package me.msoucy.gbat.models
 
-import java.io.File
-import java.nio.file.Path
-import java.nio.file.Paths
-import org.jetbrains.exposed.dao.id.IntIdTable
-import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
-
 import me.msoucy.gbat.copyOf
 import me.msoucy.gbat.mutableCopyOf
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
 
-class KnowledgeModel(val db : Database, val constant : Double, val riskModel : RiskModel) {
+class KnowledgeModel(val db: Database, val constant: Double, val riskModel: RiskModel) {
 
-    class KnowledgeAcct(var knowledgeAcctId : Int,
-                        var authors : List<String>,
-                        var authorsStr : String)
+    class KnowledgeAcct(
+        var knowledgeAcctId: Int,
+        var authors: List<String>,
+        var authorsStr: String
+    )
 
-    object AuthorsTable : Table("authors") {
-        val id = integer("authorid")
+    object AuthorsTable : IntIdTable("authors", "authorid") {
         val author = text("author").uniqueIndex("authors_idx")
-        override val primaryKey = PrimaryKey(id)
     }
-    object KnowledgeAcctsTable : Table("knowledgeaccts") {
-        val id = integer("knowledgeacctid")
+    object KnowledgeAcctsTable : IntIdTable("knowledgeaccts", "knowledgeacctid") {
         val authors = text("authors").uniqueIndex("knowledgeacctsauthors_idx")
-        override val primaryKey = PrimaryKey(id)
     }
     object KnowledgeAuthorsTable : Table("knowedgeaccts_authors") {
         val knowledgeacctid = integer("knowledgeacctid")
@@ -33,7 +28,7 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
     }
     object LineKnowledge : Table("lineknowledge") {
         val linenum = integer("linenum")
-        val knowledgeacctid = integer("knowledgeacctid")
+        val knowledgeacctid = integer("knowledgeacctid").references(KnowledgeAuthorsTable.knowledgeacctid)
         val knowledge = double("knowledge")
     }
 
@@ -45,13 +40,13 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
     val SAFE_KNOWLEDGE_ACCT_ID = 1
     val KNOWLEDGE_PER_LINE_ADDED = 1000.0
 
-    fun apply(changeType : ChangeType, author : String, lineNum : Int) = when(changeType) {
+    fun apply(changeType: ChangeType, author: String, lineNum: Int) = when (changeType) {
         ChangeType.Add -> lineAdded(author, lineNum)
         ChangeType.Change -> lineChanged(author, lineNum)
         ChangeType.Remove -> lineRemoved(lineNum)
     }
 
-    fun lineChanged(author : String, lineNum : Int) {
+    fun lineChanged(author: String, lineNum: Int) {
         val kCreated = constant * KNOWLEDGE_PER_LINE_ADDED
         val kAcquired = (1 - constant) * KNOWLEDGE_PER_LINE_ADDED
         val totLineK = totalLineKnowledge(lineNum)
@@ -63,21 +58,21 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         adjustKnowledge(knowledgeAcctId, lineNum, kCreated)
     }
 
-    fun lineRemoved(lineNum : Int) {
+    fun lineRemoved(lineNum: Int) {
         allAcctsWithKnowledgeOf(lineNum).forEach {
             destroyLineKnowledge(it, lineNum)
         }
         bumpAllLinesFrom(lineNum, -1)
     }
 
-    fun lineAdded(author : String, lineNum : Int) {
+    fun lineAdded(author: String, lineNum: Int) {
         val knowledgeAcctId = lookupOrCreateKnowledgeAcct(listOf(author))
-        bumpAllLinesFrom(lineNum-1, 1)
+        bumpAllLinesFrom(lineNum - 1, 1)
         adjustKnowledge(knowledgeAcctId, lineNum, KNOWLEDGE_PER_LINE_ADDED)
     }
 
-    fun knowledgeSummary(lineNum : Int) = transaction(db) {
-        LineKnowledge.select {
+    fun knowledgeSummary(lineNum: Int) = transaction(db) {
+        LineKnowledge.selectAll().where {
             LineKnowledge.linenum eq lineNum
         }.map {
             val acct = getKnowledgeAcct(it[LineKnowledge.knowledgeacctid])
@@ -87,35 +82,35 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         }.copyOf()
     }
 
-    private fun bumpAllLinesFrom(lineNum : Int, adjustment : Int) = transaction(db) {
-        LineKnowledge.update({LineKnowledge.linenum greater lineNum}) {
+    private fun bumpAllLinesFrom(lineNum: Int, adjustment: Int) = transaction(db) {
+        LineKnowledge.update({ LineKnowledge.linenum greater lineNum }) {
             with(SqlExpressionBuilder) {
                 it[LineKnowledge.linenum] = LineKnowledge.linenum + adjustment
             }
         }
     }
 
-    private fun getKnowledgeAcct(knowledgeAcctId : Int) : KnowledgeAcct = transaction(db) {
-        KnowledgeAcctsTable.select {
+    private fun getKnowledgeAcct(knowledgeAcctId: Int): KnowledgeAcct = transaction(db) {
+        KnowledgeAcctsTable.selectAll().where {
             KnowledgeAcctsTable.id eq knowledgeAcctId
         }.map {
             KnowledgeAcct(
-                it[KnowledgeAcctsTable.id],
+                it[KnowledgeAcctsTable.id].value,
                 it[KnowledgeAcctsTable.authors].split("\n"),
                 it[KnowledgeAcctsTable.authors]
             )
         }.firstOrNull() ?: KnowledgeAcct(-1, listOf(), "")
     }
 
-    private fun destroyLineKnowledge(knowledgeId : Int, lineNum : Int) = transaction(db) {
+    private fun destroyLineKnowledge(knowledgeId: Int, lineNum: Int) = transaction(db) {
         LineKnowledge.deleteWhere {
-            (LineKnowledge.knowledgeacctid eq knowledgeId) and
-            (LineKnowledge.linenum eq lineNum)
+            (knowledgeacctid eq knowledgeId) and
+            (linenum eq lineNum)
         }
     }
 
-    private fun redistributeKnowledge(author : String, lineNum : Int, redistPct : Double) {
-        if(riskModel.isDeparted(author)) {
+    private fun redistributeKnowledge(author: String, lineNum: Int, redistPct: Double) {
+        if (riskModel.isDeparted(author)) {
             return
         }
         val knowledgeIds = nonSafeAcctsWithKnowledgeOf(lineNum)
@@ -124,13 +119,13 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
             if (author !in knowledgeAcct.authors) {
                 val oldKnowledge = knowledgeInAcct(knowledgeAcct.knowledgeAcctId, lineNum)
                 var newAuthors = knowledgeAcct.authors.mutableCopyOf()
-                if(newAuthors.all(riskModel::isDeparted)) {
+                if (newAuthors.all(riskModel::isDeparted)) {
                     newAuthors = mutableListOf(author)
                 } else {
                     newAuthors.add(author)
                 }
                 newAuthors = newAuthors.sorted().mutableCopyOf()
-                val newKnowledgeId = if(riskModel.jointBusProbBelowThreshold(newAuthors)) {
+                val newKnowledgeId = if (riskModel.jointBusProbBelowThreshold(newAuthors)) {
                     SAFE_KNOWLEDGE_ACCT_ID
                 } else {
                     lookupOrCreateKnowledgeAcct(newAuthors)
@@ -142,8 +137,8 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         }
     }
 
-    private fun knowledgeInAcct(knowledgeAcctId : Int, lineNum : Int) = transaction(db) {
-        LineKnowledge.select {
+    private fun knowledgeInAcct(knowledgeAcctId: Int, lineNum: Int) = transaction(db) {
+        LineKnowledge.selectAll().where {
             (LineKnowledge.knowledgeacctid eq knowledgeAcctId) and
             (LineKnowledge.linenum eq lineNum)
         }.map {
@@ -151,8 +146,8 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         }.first()
     }
 
-    private fun nonSafeAcctsWithKnowledgeOf(lineNum : Int) = transaction(db) {
-        LineKnowledge.select {
+    private fun nonSafeAcctsWithKnowledgeOf(lineNum: Int) = transaction(db) {
+        LineKnowledge.selectAll().where {
             (LineKnowledge.linenum eq lineNum) and
             (LineKnowledge.knowledgeacctid neq SAFE_KNOWLEDGE_ACCT_ID)
         }.map {
@@ -160,20 +155,20 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         }
     }
 
-    private fun allAcctsWithKnowledgeOf(lineNum : Int) = transaction(db) {
-        LineKnowledge.select {
+    private fun allAcctsWithKnowledgeOf(lineNum: Int) = transaction(db) {
+        LineKnowledge.selectAll().where {
             LineKnowledge.linenum eq lineNum
         }.map {
             it[LineKnowledge.knowledgeacctid]
         }
     }
 
-    private fun adjustKnowledge(knowledgeAcctId : Int, lineNum : Int, adjustment : Double) = transaction(db) {
-        val lineExists = LineKnowledge.select {
+    private fun adjustKnowledge(knowledgeAcctId: Int, lineNum: Int, adjustment: Double) = transaction(db) {
+        val lineExists = LineKnowledge.selectAll().where {
             (LineKnowledge.knowledgeacctid eq knowledgeAcctId) and
             (LineKnowledge.linenum eq lineNum)
         }.count() > 0
-        if(!lineExists) {
+        if (!lineExists) {
             LineKnowledge.insert {
                 it[LineKnowledge.knowledgeacctid] = knowledgeAcctId
                 it[LineKnowledge.linenum] = lineNum
@@ -183,53 +178,52 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
         LineKnowledge.update({
             (LineKnowledge.knowledgeacctid eq knowledgeAcctId) and
             (LineKnowledge.linenum eq lineNum)
-        }) { 
+        }) {
             with(SqlExpressionBuilder) {
                 it[LineKnowledge.knowledge] = LineKnowledge.knowledge + adjustment
             }
         }
     }
 
-    private fun lookupOrCreateKnowledgeAcct(authors : List<String>) = transaction(db) {
+    private fun lookupOrCreateKnowledgeAcct(authors: List<String>) = transaction(db) {
         val authorStr = authors.sorted().joinToString("\n")
-        var newId = KnowledgeAcctsTable.select {
+        KnowledgeAcctsTable.selectAll().where {
             KnowledgeAcctsTable.authors eq authorStr
         }.map {
-            it[KnowledgeAcctsTable.id]
-        }.firstOrNull() ?: -1
-        if (newId != -1) {
-            KnowledgeAcctsTable.insert { 
+            it[KnowledgeAcctsTable.id].value
+        }.firstOrNull() ?: run {
+            KnowledgeAcctsTable.insert {
                 it[KnowledgeAcctsTable.authors] = authorStr
             }
-            newId = KnowledgeAcctsTable.select {
+            val theNewId = KnowledgeAcctsTable.selectAll().where {
                 KnowledgeAcctsTable.authors eq authorStr
             }.map {
-                it[KnowledgeAcctsTable.id]
+                it[KnowledgeAcctsTable.id].value
             }.first()
 
             authors.map(::lookupOrCreateAuthor).forEach { authorId ->
                 KnowledgeAuthorsTable.insert {
-                    it[KnowledgeAuthorsTable.knowledgeacctid] = newId
-                    it[KnowledgeAuthorsTable.authorid] = authorId
+                    it[KnowledgeAuthorsTable.knowledgeacctid] = theNewId
+                    it[KnowledgeAuthorsTable.authorid] = authorId.value
                 }
             }
+            theNewId
         }
-        newId
     }
 
-    private fun lookupOrCreateAuthor(authorName : String) = transaction(db) {
-        AuthorsTable.insertIgnore { 
+    private fun lookupOrCreateAuthor(authorName: String) = transaction(db) {
+        AuthorsTable.insertIgnore {
             it[author] = authorName
         }
-        AuthorsTable.select {
+        AuthorsTable.selectAll().where {
             AuthorsTable.author eq authorName
         }.first().let {
             it[AuthorsTable.id]
         }
     }
-    
-    private fun totalLineKnowledge(linenum : Int) = transaction(db) {
-        LineKnowledge.select {
+
+    private fun totalLineKnowledge(linenum: Int) = transaction(db) {
+        LineKnowledge.selectAll().where {
             LineKnowledge.linenum eq linenum
         }.map {
             it[LineKnowledge.knowledge]
@@ -239,12 +233,10 @@ class KnowledgeModel(val db : Database, val constant : Double, val riskModel : R
     private fun createTables() = transaction(db) {
         SchemaUtils.dropDatabase()
         SchemaUtils.createMissingTablesAndColumns(AuthorsTable, KnowledgeAcctsTable, KnowledgeAuthorsTable, LineKnowledge)
-        AuthorsTable.insertIgnore { 
-            it[id] = 1
+        AuthorsTable.insertIgnore {
             it[author] = ""
         }
-        KnowledgeAcctsTable.insertIgnore { 
-            it[id] = 1
+        KnowledgeAcctsTable.insertIgnore {
             it[authors] = ""
         }
         KnowledgeAuthorsTable.insertIgnore {

src/main/kotlin/me/msoucy/gbat/models/LineModel.kt

@@ -1,42 +1,34 @@
 package me.msoucy.gbat.models
 
-import java.io.File
-import java.nio.file.Path
-import java.nio.file.Paths
-import kotlin.io.forEachLine
-import org.jetbrains.exposed.dao.id.IntIdTable
-import org.jetbrains.exposed.sql.*
-import org.jetbrains.exposed.sql.transactions.transaction
-
 class LineModel() {
-    inner class Line(var num : Int, var text : String)
+    inner class Line(var num: Int, var text: String)
     val model = mutableSetOf<Line>()
 
-    fun apply(changeType : ChangeType, lineNum : Int, lineText : String) = when(changeType) {
+    fun apply(changeType: ChangeType, lineNum: Int, lineText: String) = when (changeType) {
         ChangeType.Add -> add(Line(lineNum, lineText))
         ChangeType.Change -> change(Line(lineNum, lineText))
         ChangeType.Remove -> del(Line(lineNum, lineText))
     }
 
-    fun add(line : Line) {
+    fun add(line: Line) {
         model.onEach { entry ->
-            if(entry.num >= line.num) {
+            if (entry.num >= line.num) {
                 entry.num++
             }
         }
         model.add(line)
     }
 
-    fun del(line : Line) {
+    fun del(line: Line) {
         model.removeIf { it.num == line.num }
         model.onEach { entry ->
-            if(entry.num > line.num) {
+            if (entry.num > line.num) {
                 entry.num--
             }
         }
     }
 
-    fun change(line : Line) {
+    fun change(line: Line) {
         model.removeIf { it.num == line.num }
         model.add(line)
     }

src/main/kotlin/me/msoucy/gbat/models/Models.kt

@@ -7,37 +7,37 @@ enum class ChangeType {
 }
 
 data class Event(
-    val eventType : ChangeType,
-    val lineNum : Int,
-    val lineVal : String?
+    val eventType: ChangeType,
+    val lineNum: Int,
+    val lineVal: String?
 )
 
 data class Condensation(
-    val authors : List<String>,
-    val knowledge : Double,
-    val orphaned : Double,
-    val risk : Double = 0.0
+    val authors: List<String>,
+    val knowledge: Double,
+    val orphaned: Double,
+    val risk: Double = 0.0
 ) : Comparable<Condensation> {
-    override operator fun compareTo(other : Condensation) : Int {
+    override operator fun compareTo(other: Condensation): Int {
         var result = authors.size.compareTo(other.authors.size)
-        if(result == 0) {
+        if (result == 0) {
             authors.zip(other.authors).forEach { (a, b) ->
-                if(result == 0) result = a.compareTo(b)
+                if (result == 0) result = a.compareTo(b)
             }
         }
-        if(result == 0)
+        if (result == 0)
             result = knowledge.compareTo(other.knowledge)
-        if(result == 0)
+        if (result == 0)
             result = orphaned.compareTo(other.orphaned)
-        if(result == 0)
+        if (result == 0)
             result = risk.compareTo(other.risk)
         return result
     }
 }
 
 class CondensedAnalysis(
-    var repoRoot : File,
-    var projectRoot : File,
-    var fileName : File,
-    var lineSummaries : MutableList<Pair<String, List<Condensation>>> = mutableListOf()
-)
+    var repoRoot: File,
+    var projectRoot: File,
+    var fileName: File,
+    var lineSummaries: MutableList<Pair<String, List<Condensation>>> = mutableListOf()
+)

src/main/kotlin/me/msoucy/gbat/models/RiskModel.kt

@@ -3,50 +3,52 @@ package me.msoucy.gbat.models
 import java.io.File
 import kotlin.io.forEachLine
 
-class RiskModel(val threshold : Double,
-                val default : Double,
-                val busRiskFile : File?,
-                val departedFile : File?) {
+class RiskModel(
+    val threshold: Double,
+    val default: Double,
+    val busRiskFile: File?,
+    val departedFile: File?
+) {
     val departed = mutableSetOf<String>()
-    val risks = mutableMapOf<String, Double>().withDefault {default}
+    val risks = mutableMapOf<String, Double>().withDefault { default }
 
     init {
         parseBusRisks()
         parseDeparted()
     }
 
-    operator fun get(author : String) : Double {
+    operator fun get(author: String): Double {
         val name = author.trim()
-        if(name.isEmpty()) {
+        if (name.isEmpty()) {
             return threshold
         }
         return risks.getOrPut(name) { default }
     }
 
-    fun isDeparted(author : String) = author.trim() in departed
+    fun isDeparted(author: String) = author.trim() in departed
 
-    fun jointBusProb(authors : List<String>) =
+    fun jointBusProb(authors: List<String>) =
         (authors.map { this[it] } + 1.0).reduce { a, b -> a * b }
 
-    fun jointBusProbBelowThreshold(authors : List<String>) =
+    fun jointBusProbBelowThreshold(authors: List<String>) =
         jointBusProb(authors) <= threshold
-    
+
     private fun parseBusRisks() {
         busRiskFile?.forEachLine { line ->
             val sline = line.trim()
-            if(sline.isNotEmpty()) {
+            if (sline.isNotEmpty()) {
                 val segments = sline.split("=")
                 val risk = segments.last()
-                val author = segments.dropLast(1).joinToString(separator="=")
+                val author = segments.dropLast(1).joinToString(separator = "=")
                 risks[author] = risk.toDouble()
             }
         }
     }
-    
+
     private fun parseDeparted() {
         departedFile?.forEachLine { line ->
             val author = line.trim()
-            if(author.isNotEmpty()) {
+            if (author.isNotEmpty()) {
                 risks[author] = 1.0
                 departed.add(author)
             }

src/main/kotlin/me/msoucy/gbat/models/SummaryModel.kt

@@ -55,7 +55,7 @@ class FileTree {
     var authorRisks = mutableMapOf<String, Statistics>()
     var lines = mutableListOf<LineDict>()
 }
-class FileEntry(var name : String = "") {
+class FileEntry(var name: String = "") {
     var stats = Statistics()
     var authorRisks = mutableMapOf<String, Statistics>()
 }
@@ -64,14 +64,14 @@ class ProjectTree {
     var files = mutableMapOf<Int, FileEntry>()
     var dirs = mutableListOf<Int>()
 }
-class ProjectFilesResult(var fileId : Int, var fname : Path)
+class ProjectFilesResult(var fileId: Int, var fname: Path)
 
 data class Statistics(
-    var totKnowledge : Double = 0.0,
-    var totRisk : Double = 0.0,
-    var totOrphaned : Double = 0.0
+    var totKnowledge: Double = 0.0,
+    var totRisk: Double = 0.0,
+    var totOrphaned: Double = 0.0
 ) {
-    constructor(row : ResultRow) :
+    constructor(row: ResultRow) :
         this(row[AllocationsTable.knowledge.sum()] ?: 0.0,
              row[AllocationsTable.risk.sum()] ?: 0.0,
              row[AllocationsTable.orphaned.sum()] ?: 0.0) {}
@@ -81,25 +81,25 @@ class ProjectTreeNode {
     var files = mutableListOf<FileEntry>()
     var dirs = mutableListOf<ProjectTreeNode>()
 }
-class ProjectTreeResult(var name : String, var root : ProjectTreeNode) {
+class ProjectTreeResult(var name: String, var root: ProjectTreeNode) {
     var stats = Statistics()
     var authorRisks = mutableMapOf<String, Statistics>()
 }
 
-class SummaryModel(val db : Database) {
+class SummaryModel(val db: Database) {
 
     val GIT_BY_A_BUS_BELOW_THRESHOLD = "Git by a Bus Safe Author"
 
     init {
         createTables()
     }
-    
+
     private val lineAllocations = (LinesTable leftJoin AllocationsTable)
     private val lineAllocationGroups = (lineAllocations leftJoin AuthorsGroupsTable)
     private val manyJoined = (lineAllocations leftJoin FilesTable leftJoin DirsTable)
     private val allJoined = (manyJoined leftJoin AuthorsGroupsTable)
 
-    fun summarize(ca : CondensedAnalysis) {
+    fun summarize(ca: CondensedAnalysis) {
         val fname = adjustFname(ca.repoRoot.absoluteFile,
                                 ca.projectRoot.absoluteFile,
                                 ca.fileName.absoluteFile)
@@ -122,7 +122,7 @@ class SummaryModel(val db : Database) {
             }
         }
     }
-    
+
     fun totalKnowledge() = transaction(db) {
         AllocationsTable.selectAll().map { it[AllocationsTable.knowledge] }.sum()
     }
@@ -139,12 +139,12 @@ class SummaryModel(val db : Database) {
         FilesTable.selectAll().count()
     }
 
-    fun authorgroupsWithRisk(top : Int? = null) : List<Pair<String, Double>> = transaction(db) {
+    fun authorgroupsWithRisk(top: Int? = null): List<Pair<String, Double>> = transaction(db) {
         var query = (AllocationsTable innerJoin AuthorsGroupsTable)
         .selectAll()
         .groupBy(AuthorsGroupsTable.authors)
         .orderBy(AllocationsTable.risk.sum() to SortOrder.DESC)
-        if(top != null) {
+        if (top != null) {
             query = query.limit(top)
         }
         query.map {
@@ -152,12 +152,12 @@ class SummaryModel(val db : Database) {
         }
     }
 
-    fun fileidsWithRisk(top : Int? = null) : List<Pair<Int, Double>> = transaction(db) {
+    fun fileidsWithRisk(top: Int? = null): List<Pair<Int, Double>> = transaction(db) {
         var query = (FilesTable leftJoin LinesTable leftJoin AllocationsTable)
         .selectAll()
         .groupBy(FilesTable.id)
         .orderBy(AllocationsTable.risk.sum() to SortOrder.DESC)
-        if(top != null) {
+        if (top != null) {
             query = query.limit(top)
         }
         query.map {
@@ -165,8 +165,8 @@ class SummaryModel(val db : Database) {
         }
     }
 
-    fun fpath(fileId : Int) : Path = transaction(db) {
-        FilesTable.select {
+    fun fpath(fileId: Int): Path = transaction(db) {
+        FilesTable.selectAll().where {
             FilesTable.id eq fileId
         }.first().let { row ->
             val dirs = reconsDirs(row[FilesTable.dirid])
@@ -174,9 +174,9 @@ class SummaryModel(val db : Database) {
         }
     }
 
-    fun projectFiles(project : String) : List<ProjectFilesResult> = transaction(db) {
+    fun projectFiles(project: String): List<ProjectFilesResult> = transaction(db) {
         val projectId = findOrCreateProject(project)
-        (FilesTable innerJoin DirsTable).select {
+        (FilesTable innerJoin DirsTable).selectAll().where {
             (FilesTable.dirid eq DirsTable.id) and
             (DirsTable.projectid eq projectId)
         }.map { row ->
@@ -184,15 +184,15 @@ class SummaryModel(val db : Database) {
         }
     }
 
-    fun projectSummary(project : String) = transaction(db) {
+    fun projectSummary(project: String) = transaction(db) {
         val projectId = findOrCreateProject(project)
-        val theTree = mutableMapOf<Int, ProjectTree>().withDefault {ProjectTree()}
+        val theTree = mutableMapOf<Int, ProjectTree>().withDefault { ProjectTree() }
 
         // First fill in the directory structure, ignoring the files
         val parentDirIds = mutableListOf(0)
-        while(parentDirIds.isNotEmpty()) {
+        while (parentDirIds.isNotEmpty()) {
             val parentId = parentDirIds.removeAt(0)
-            DirsTable.select { DirsTable.parentdirid eq parentId }
+            DirsTable.selectAll().where { DirsTable.parentdirid eq parentId }
             .forEach { row ->
                 val dirId = row[DirsTable.id].value
                 theTree.getOrPut(parentId) { ProjectTree() }.dirs.add(dirId)
@@ -203,13 +203,13 @@ class SummaryModel(val db : Database) {
 
         // Then add the files
         theTree.entries.forEach { entry ->
-            FilesTable.select { FilesTable.dirid eq entry.key }.forEach { row ->
+            FilesTable.selectAll().where { FilesTable.dirid eq entry.key }.forEach { row ->
                 entry.value.files[row[FilesTable.id].value] = FileEntry(row[FilesTable.fname])
             }
             entry.value.files.entries.forEach { (fileId, fileEntry) ->
                 lineAllocations
-                .slice(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
-                .select { LinesTable.fileid eq fileId }
+                .select(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
+                .where { LinesTable.fileid eq fileId }
                 .groupBy(LinesTable.fileid)
                 .forEach { row ->
                     fileEntry.stats.totKnowledge = row[AllocationsTable.knowledge.sum()] ?: 0.0
@@ -219,12 +219,12 @@ class SummaryModel(val db : Database) {
             }
             entry.value.files.entries.forEach { (fileId, fileEntry) ->
                 lineAllocationGroups
-                .slice(
+                .select(
                     AllocationsTable.knowledge.sum(),
                     AllocationsTable.risk.sum(),
                     AllocationsTable.orphaned.sum(),
                     AuthorsGroupsTable.authors
-                ).select { LinesTable.fileid eq fileId }
+                ).where { LinesTable.fileid eq fileId }
                 .groupBy(AllocationsTable.authorgroupid)
                 .orderBy(AuthorsGroupsTable.authors)
                 .forEach { row ->
@@ -239,24 +239,24 @@ class SummaryModel(val db : Database) {
         val projectTree = ProjectTreeResult(project, root)
 
         allJoined
-        .slice(
+        .select(
             AllocationsTable.knowledge.sum(),
             AllocationsTable.risk.sum(),
             AllocationsTable.orphaned.sum(),
             AuthorsGroupsTable.authors
         )
-        .select { DirsTable.projectid eq projectId }
+        .where { DirsTable.projectid eq projectId }
         .groupBy(AuthorsGroupsTable.id)
         .forEach { row ->
             projectTree.authorRisks[row[AuthorsGroupsTable.authors]] = Statistics(row)
         }
 
         manyJoined
-        .slice(
+        .select(
             AllocationsTable.knowledge.sum(),
             AllocationsTable.risk.sum(),
             AllocationsTable.orphaned.sum()
-        ).select {
+        ).where {
             DirsTable.projectid eq projectId
         }.first().let { row ->
             projectTree.stats = Statistics(row)
@@ -265,11 +265,11 @@ class SummaryModel(val db : Database) {
         projectTree
     }
 
-    fun fileSummary(fileId : Int) = transaction(db) {
+    fun fileSummary(fileId: Int) = transaction(db) {
         var fileTree = FileTree()
         lineAllocationGroups
-        .slice(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum(), AuthorsGroupsTable.authors)
-        .select {
+        .select(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum(), AuthorsGroupsTable.authors)
+        .where {
             LinesTable.fileid eq fileId
         }.groupBy(AuthorsGroupsTable.id).forEach { row ->
             val authors = row[AuthorsGroupsTable.authors]
@@ -279,29 +279,29 @@ class SummaryModel(val db : Database) {
             JoinType.LEFT,
             LinesTable.fileid, FilesTable.id
         )
-        .slice(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
-        .select { LinesTable.fileid eq fileId }
+        .select(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
+        .where { LinesTable.fileid eq fileId }
         .first().let { row ->
             fileTree.stats = Statistics(row)
         }
 
-        fileTree.name = FilesTable.select { FilesTable.id eq fileId }.map { it[FilesTable.fname] }.first()
+        fileTree.name = FilesTable.selectAll().where { FilesTable.id eq fileId }.map { it[FilesTable.fname] }.first()
 
-        LinesTable.select { LinesTable.fileid eq fileId }
+        LinesTable.selectAll().where { LinesTable.fileid eq fileId }
         .map { it[LinesTable.id].value }
         .forEach { lineId ->
             val lineDict = LineDict()
             lineAllocationGroups
-            .slice(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum(), AuthorsGroupsTable.authors)
-            .select {
+            .select(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum(), AuthorsGroupsTable.authors)
+            .where {
                 LinesTable.id eq lineId
             }.groupBy(AuthorsGroupsTable.id).forEach { lineRow ->
                 lineDict.authorRisks[lineRow[AuthorsGroupsTable.authors]] = Statistics(lineRow)
             }
 
             lineAllocations
-            .slice(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
-            .select {
+            .select(AllocationsTable.knowledge.sum(), AllocationsTable.risk.sum(), AllocationsTable.orphaned.sum())
+            .where {
                 LinesTable.id eq lineId
             }.first().let {
                 lineDict.stats = Statistics(it)
@@ -311,17 +311,18 @@ class SummaryModel(val db : Database) {
         fileTree
     }
 
-    fun fileLines(fileId : Int) : List<String> = transaction(db) {
-        LinesTable.select {
+    fun fileLines(fileId: Int): List<String> = transaction(db) {
+        LinesTable.selectAll().where {
             LinesTable.fileid eq fileId
         }.orderBy(LinesTable.linenum).map {
             it[LinesTable.line]
         }
     }
 
-    private fun transformNode(tree : MutableMap<Int, ProjectTree>, dirId : Int) : ProjectTreeNode {
+    private fun transformNode(tree: MutableMap<Int, ProjectTree>, dirId: Int): ProjectTreeNode {
         val result = ProjectTreeNode()
         tree[dirId]?.let { dirdict ->
+            result.name = dirdict.name
             result.dirs = mutableListOf<ProjectTreeNode>().apply {
                 dirdict.dirs.forEach {
                     add(transformNode(tree, it))
@@ -333,11 +334,11 @@ class SummaryModel(val db : Database) {
         return result
     }
 
-    private fun reconsDir(dirId : Int) = transaction(db) {
+    private fun reconsDir(dirId: Int) = transaction(db) {
         val segs = mutableListOf<String>()
         var newDirId = dirId
-        while(newDirId != 0) {
-            DirsTable.select {
+        while (newDirId != 0) {
+            DirsTable.selectAll().where {
                 DirsTable.id eq newDirId
             }.forEach {
                 segs.add(it[DirsTable.dir])
@@ -347,9 +348,9 @@ class SummaryModel(val db : Database) {
         Paths.get(segs.reversed().joinToString("/")).normalize()
     }
 
-    private fun safeAuthorName(author : String?) = author ?: GIT_BY_A_BUS_BELOW_THRESHOLD
+    private fun safeAuthorName(author: String?) = author ?: GIT_BY_A_BUS_BELOW_THRESHOLD
 
-    private fun createAllocation(knowledge : Double, risk : Double, orphaned : Double, authorGroupId : Int, lineId : Int) = transaction(db) {
+    private fun createAllocation(knowledge: Double, risk: Double, orphaned: Double, authorGroupId: Int, lineId: Int) = transaction(db) {
         AllocationsTable.insert {
             it[AllocationsTable.knowledge] = knowledge
             it[AllocationsTable.risk] = risk
@@ -359,9 +360,9 @@ class SummaryModel(val db : Database) {
         }
     }
 
-    private fun findOrCreateAuthorGroup(authors : List<String>) : Int = transaction(db) {
+    private fun findOrCreateAuthorGroup(authors: List<String>): Int = transaction(db) {
         val authorsstr = authors.joinToString("\n")
-        var authorGroupId = AuthorsGroupsTable.select {
+        var authorGroupId = AuthorsGroupsTable.selectAll().where {
             AuthorsGroupsTable.authors eq authorsstr
         }.map {
             it[AuthorsGroupsTable.id].value
@@ -382,18 +383,18 @@ class SummaryModel(val db : Database) {
         authorGroupId
     }
 
-    private fun findOrCreateAuthor(author : String) : Int = transaction(db) {
+    private fun findOrCreateAuthor(author: String): Int = transaction(db) {
         AuthorsTable.insertIgnore {
             it[AuthorsTable.author] = author
         }
-        ProjectTable.select {
+        AuthorsTable.selectAll().where {
             AuthorsTable.author eq author
         }.map {
             it[AuthorsTable.id].value
         }.first()
     }
 
-    private fun createLine(line : String, lineNum : Int, fileId : Int) = transaction(db) {
+    private fun createLine(line: String, lineNum: Int, fileId: Int) = transaction(db) {
         LinesTable.insertAndGetId {
             it[LinesTable.line] = line
             it[LinesTable.linenum] = lineNum
@@ -401,31 +402,31 @@ class SummaryModel(val db : Database) {
         }.value
     }
 
-    private fun createFile(fname : String, parentDirId : Int) = transaction(db) {
+    private fun createFile(fname: String, parentDirId: Int) = transaction(db) {
         FilesTable.insertAndGetId {
             it[FilesTable.fname] = fname
             it[FilesTable.dirid] = parentDirId
         }.value
     }
 
-    private fun findOrCreateProject(project : String) : Int = transaction(db) {
+    private fun findOrCreateProject(project: String): Int = transaction(db) {
         ProjectTable.insertIgnore {
             it[ProjectTable.project] = project
         }
-        ProjectTable.select {
+        ProjectTable.selectAll().where {
             ProjectTable.project eq project
         }.map {
             it[ProjectTable.id].value
         }.first()
     }
 
-    private fun findOrCreateDir(dirname : String, projectId : Int, parentDirId : Int) : Int = transaction(db) {
+    private fun findOrCreateDir(dirname: String, projectId: Int, parentDirId: Int): Int = transaction(db) {
         DirsTable.insertIgnore {
             it[dir] = dirname
             it[parentdirid] = parentDirId
             it[projectid] = projectId
         }
-        DirsTable.select {
+        DirsTable.selectAll().where {
             DirsTable.dir eq dirname
             DirsTable.parentdirid eq parentDirId
             DirsTable.projectid eq projectId
@@ -434,26 +435,26 @@ class SummaryModel(val db : Database) {
         }.first()
     }
 
-    private fun splitAllDirs(dirname : File) = dirname.toPath().iterator().asSequence().toList()
+    private fun splitAllDirs(dirname: File) = dirname.toPath().iterator().asSequence().toList()
 
-    private fun adjustFname(repoRoot : File, projectRoot : File, fname : File) : File {
-        val rootDiff = if(projectRoot.canonicalPath != repoRoot.canonicalPath) {
+    private fun adjustFname(repoRoot: File, projectRoot: File, fname: File): File {
+        val rootDiff = if (projectRoot.canonicalPath != repoRoot.canonicalPath) {
             projectRoot.relativeTo(repoRoot)
         } else {
             repoRoot
         }
-        return if(rootDiff.toString().length != 0) {
+        return if (rootDiff.toString().length != 0) {
             fname.relativeTo(rootDiff)
         } else {
             fname
         }
     }
 
-    private fun reconsDirs(dirId : Int) = transaction(db) {
+    private fun reconsDirs(dirId: Int) = transaction(db) {
         val dirs = mutableListOf<String>()
         var parentDirId = dirId
-        while(parentDirId != 0) {
-            DirsTable.select {
+        while (parentDirId != 0) {
+            DirsTable.selectAll().where {
                 DirsTable.id eq parentDirId
             }
             .first()
@@ -476,4 +477,4 @@ class SummaryModel(val db : Database) {
             AllocationsTable
         )
     }
-}
+}