@jpetit/toolkit 3.0.23 → 3.1.2

package/lib/compilers/gcc.ts

@@ -1,9 +1,4 @@
-import { type Handler } from '../types'
-import tui from '../tui'
 import { Compiler } from './base'
-import { rm, exists } from 'fs/promises'
-import { join } from 'path'
-import { execa } from 'execa'
 
 export class GCC_Compiler extends Compiler {
     id(): string {
@@ -34,35 +29,11 @@ export class GCC_Compiler extends Compiler {
         return ''
     }
 
-    extension(): string {
-        return 'c'
+    tool(): string {
+        return 'gcc'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const exePath = sourcePath + '.exe'
-        const fullExePath = join(directory, exePath)
-        await rm(fullExePath, { force: true })
-
-        if (handler.source_modifier === 'none') {
-            tui.command(`gcc ${this.flags1()} ${sourcePath} -o ${exePath}`)
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`gcc ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
-        } else if (handler.source_modifier === 'no_main') {
-            tui.command(`gcc ${this.flags1()} ${sourcePath} main.c -o ${exePath}`)
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`gcc ${this.flags1().split(' ')} ${sourcePath} main.c -o ${exePath}`
-        } else {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
-        }
-
-        if (!(await exists(fullExePath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    extension(): string {
+        return 'c'
     }
 }

package/lib/compilers/ghc.ts

@@ -1,9 +1,3 @@
-import { execa } from 'execa'
-import { exists, rm } from 'fs/promises'
-import { concatText } from '../utils'
-import { join } from 'path'
-import tui from '../tui'
-import { type Handler } from '../types'
 import { Compiler } from './base'
 
 export class GHC_Compiler extends Compiler {
@@ -35,41 +29,11 @@ export class GHC_Compiler extends Compiler {
         return '-O3'
     }
 
-    extension(): string {
-        return 'hs'
+    tool(): string {
+        return 'ghc'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const outputPath = sourcePath + '.exe'
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-
-        if (handler.source_modifier === 'none') {
-            tui.command(`ghc ${this.flags1()} ${sourcePath} -o ${outputPath}`)
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`ghc ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`
-        } else if (handler.source_modifier === 'no_main') {
-            const wrapperPath = `wrapper-${sourcePath}`
-
-            tui.command(`concat ${sourcePath} and main.hs into ${wrapperPath}`, { italic: true })
-            await concatText([join(directory, sourcePath), join(directory, 'main.hs')], join(directory, wrapperPath))
-
-            tui.command(`ghc ${this.flags1()} ${wrapperPath} -o ${outputPath}`)
-
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`ghc ${this.flags1().split(' ')} ${wrapperPath} -o ${outputPath}`
-        } else {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
-        }
-
-        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    extension(): string {
+        return 'hs'
     }
 }

package/lib/compilers/gxx.ts

@@ -1,8 +1,3 @@
-import { execa } from 'execa'
-import { exists, rm } from 'fs/promises'
-import { join } from 'path'
-import tui from '../tui'
-import { type Handler } from '../types'
 import { Compiler } from './base'
 
 export class GXX_Compiler extends Compiler {
@@ -34,35 +29,11 @@ export class GXX_Compiler extends Compiler {
         return '-std=c++17 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
     }
 
-    extension(): string {
-        return 'cc'
+    tool(): string {
+        return 'g++'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const outputPath = sourcePath + '.exe'
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-
-        if (handler.source_modifier === 'none') {
-            tui.command(`g++ ${this.flags1()} ${sourcePath} -o ${outputPath}`)
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`g++ ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`
-        } else if (handler.source_modifier === 'no_main') {
-            tui.command(`g++ ${this.flags1()} ${sourcePath} main.cc -o ${outputPath}`)
-            await execa({
-                reject: false,
-                stderr: 'inherit',
-                stdout: 'inherit',
-                cwd: directory,
-            })`g++ ${this.flags1().split(' ')} ${sourcePath} main.cc -o ${outputPath}`
-        } else {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
-        }
-
-        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
+    extension(): string {
+        return 'cc'
     }
 }

package/lib/compilers/index.ts

@@ -5,8 +5,11 @@ import { GXX_Compiler } from './gxx'
 import { Python3_Compiler } from './python3'
 import { GHC_Compiler } from './ghc'
 import { Clojure_Compiler } from './clojure'
+import { Java_Compiler } from './java'
+import { Rust_Compiler } from './rust'
 import { RunPython_Compiler } from './run-python'
 import { RunHaskell_Compiler } from './run-haskell'
+import { RunClojure_Compiler } from './run-clojure'
 
 const compilersRegistryById: Record<string, new () => Compiler> = {
     C: GCC_Compiler,
@@ -14,8 +17,12 @@ const compilersRegistryById: Record<string, new () => Compiler> = {
     Python3: Python3_Compiler,
     Haskell: GHC_Compiler,
     Clojure: Clojure_Compiler,
+    Java: Java_Compiler,
+    Rust: Rust_Compiler,
+
     RunPython: RunPython_Compiler,
     RunHaskell: RunHaskell_Compiler,
+    RunClojure: RunClojure_Compiler,
 }
 
 const compilersRegistryByExtension: Record<string, new () => Compiler> = {
@@ -24,6 +31,8 @@ const compilersRegistryByExtension: Record<string, new () => Compiler> = {
     py: Python3_Compiler,
     hs: GHC_Compiler,
     clj: Clojure_Compiler,
+    java: Java_Compiler,
+    rs: Rust_Compiler,
 }
 
 export function getCompilerById(id: string): Compiler {

package/lib/compilers/java.ts

@@ -0,0 +1,105 @@
+import { execa } from 'execa'
+import { join, parse } from 'path'
+import tui from '../tui'
+import type { Handler } from '../types'
+import { nothing, toolkitPrefix } from '../utils'
+import { Compiler } from './base'
+
+export class Java_Compiler extends Compiler {
+    id(): string {
+        return 'Java'
+    }
+
+    name(): string {
+        return 'Java'
+    }
+
+    type(): string {
+        return 'vm'
+    }
+
+    language(): string {
+        return 'Java'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('javac --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    tool(): string {
+        return 'javac'
+    }
+
+    extension(): string {
+        return 'java'
+    }
+
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        const classPath = 'Main.class'
+
+        await this.rmInDir(directory, classPath)
+
+        tui.command(`${this.tool()} ${sourcePath}`)
+        await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`${this.tool()} ${sourcePath}`
+
+        return classPath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        const classPath = 'Main.class'
+
+        tui.command(`add main.${this.extension()} to ${sourcePath}`)
+        await this.concatText(directory, [`main.${this.extension()}`, sourcePath], sourcePath)
+
+        await this.rmInDir(directory, classPath)
+
+        tui.command(`${this.tool()} ${sourcePath}`)
+        await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`${this.tool()} ${sourcePath}`
+
+        return classPath
+    }
+
+    override async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const className = 'Main'
+        const classPath = className + '.class'
+
+        await this.rmInDir(directory, outputPath)
+        const input = await this.getInput(directory, inputPath)
+
+        tui.command(`java ${className} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`java ${className}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${classPath}`)
+    }
+}

package/lib/compilers/python3.ts

@@ -1,9 +1,8 @@
 import { execa } from 'execa'
-import { exists, rm } from 'fs/promises'
 import { join } from 'path'
 import tui from '../tui'
 import type { Handler } from '../types'
-import { readText, writeText } from '../utils'
+import { readText, toolkitPrefix, writeText } from '../utils'
 import { Compiler } from './base'
 
 export class Python3_Compiler extends Compiler {
@@ -35,40 +34,55 @@ export class Python3_Compiler extends Compiler {
         return ''
     }
 
+    tool(): string {
+        return 'python3'
+    }
+
     extension(): string {
         return 'py'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const wrapperPath = `wrapper-${sourcePath}`
-        const fullWrapperPath = join(directory, wrapperPath)
-        const fullSourcePath = join(directory, sourcePath)
-        const source = await readText(fullSourcePath)
-
-        tui.command(`wrap ${sourcePath} to ${wrapperPath}`, { italic: true })
-        let wrapperSource: string
-        if (handler.source_modifier === 'none') {
-            wrapperSource = source
-                .replace('import turtle', 'import turtle_pil as turtle')
-                .replace('from turtle import', 'from turtle_pil import')
-        } else if (handler.source_modifier === 'no_main' || handler.source_modifier === 'structs') {
-            const main = await readText(join(directory, 'main.py'))
-            wrapperSource = source + '\n\n\n' + main
-        } else {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        const source = await readText(join(directory, sourcePath))
+
+        tui.command(`tweak ${sourcePath} for turtle compatibility`)
+        const modSource = source
+            .replace('import turtle', 'import turtle_pil as turtle')
+            .replace('from turtle import', 'from turtle_pil import')
+        await writeText(join(directory, sourcePath), modSource)
+
+        tui.command(`python3 -m py_compile ${sourcePath}`)
+        const { exitCode } = await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`python3 -m py_compile ${sourcePath}`
+
+        if (exitCode !== 0) {
+            throw new Error(`Compilation failed for ${sourcePath}`)
         }
-        await writeText(fullWrapperPath, wrapperSource)
 
-        tui.command(`python3 -m py_compile ${wrapperPath}`)
+        return sourcePath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        tui.command(`add main.${this.extension()} to ${sourcePath}`)
+        await this.concatText(directory, [sourcePath, `main.${this.extension()}`], sourcePath)
 
+        tui.command(`python3 -m py_compile ${sourcePath}`)
         const { exitCode } = await execa({
             reject: false,
             stderr: 'inherit',
             stdout: 'inherit',
             cwd: directory,
-        })`python3 -m py_compile ${wrapperPath}`
+        })`python3 -m py_compile ${sourcePath}`
 
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+        if (exitCode !== 0) {
+            throw new Error(`Compilation failed for ${sourcePath}`)
+        }
+
+        return sourcePath
     }
 
     override async execute(
@@ -78,28 +92,21 @@ export class Python3_Compiler extends Compiler {
         inputPath: string,
         outputPath: string,
     ): Promise<void> {
-        const wrapperPath = `wrapper-${sourcePath}`
-        const fullWrapperPath = join(directory, wrapperPath)
-
-        if (!(await exists(join(directory, wrapperPath)))) {
-            throw new Error(`Executable file ${wrapperPath} does not exist in directory ${directory}`)
-        }
+        const exePath = sourcePath
 
-        const fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        const input = await readText(fullInputPath)
+        await this.rmInDir(directory, outputPath)
+        const input = await this.getInput(directory, inputPath)
 
-        tui.command(`python3 ${wrapperPath} < ${inputPath} > ${outputPath}`)
+        tui.command(`python3 ${exePath} < ${inputPath} > ${outputPath}`)
 
         const { exitCode } = await execa({
             reject: false,
             input,
-            stdout: { file: fullOutputPath },
+            stdout: { file: join(directory, outputPath) },
             stderr: 'inherit',
             cwd: directory,
-        })`python3 ${wrapperPath}`
+        })`python3 ${exePath}`
 
-        if (exitCode !== 0) throw new Error(`Execution failed for ${wrapperPath}`)
+        if (exitCode !== 0) throw new Error(`Execution failed for ${exePath}`)
     }
 }

package/lib/compilers/run-clojure.ts

@@ -0,0 +1,101 @@
+import { execa } from 'execa'
+import { join, parse } from 'path'
+import tui from '../tui'
+import type { Handler } from '../types'
+import { nothing, readText, toolkitPrefix, writeText } from '../utils'
+import { Compiler } from './base'
+
+export class RunClojure_Compiler extends Compiler {
+    id(): string {
+        return 'RunClojure'
+    }
+
+    name(): string {
+        return 'RunClojure'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Clojure'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('clj --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    tool(): string {
+        return 'clj'
+    }
+
+    extension(): string {
+        return 'clj'
+    }
+
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        await nothing()
+
+        tui.warning(`No compilation available for Clojure`)
+
+        return sourcePath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        await nothing()
+        throw new Error('Method not implemented.')
+    }
+
+    override async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const newSourcePath = `${toolkitPrefix()}-${parse(sourcePath).name}-${parse(inputPath).name}.clj`
+
+        tui.command(`merge ${sourcePath} ${inputPath} > ${newSourcePath}`)
+        await this.mergeScripts(directory, sourcePath, inputPath, newSourcePath)
+
+        tui.command(`clj -M ${newSourcePath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`clj -M ${newSourcePath}`
+
+        if (exitCode !== 0) throw new Error(`Execution failed for ${newSourcePath}`)
+    }
+
+    async mergeScripts(
+        directory: string,
+        scriptPath1: string,
+        scriptPath2: string,
+        outputScriptPath: string,
+    ): Promise<void> {
+        const script1 = await readText(join(directory, scriptPath1))
+        const script2 = await readText(join(directory, scriptPath2))
+        let mergedScript = script1
+        mergedScript += '\n\n\n'
+        for (const line of script2.split('\n')) {
+            if (line.trim() === '') {
+                mergedScript += '\n'
+            } else {
+                mergedScript += `(println ${line})\n`
+            }
+        }
+        await writeText(join(directory, outputScriptPath), mergedScript)
+    }
+}

package/lib/compilers/run-haskell.ts

@@ -1,9 +1,8 @@
 import { execa } from 'execa'
-import { rm } from 'fs/promises'
-import { join } from 'path'
+import { join, parse } from 'path'
 import tui from '../tui'
 import type { Handler } from '../types'
-import { readText, writeText } from '../utils'
+import { nothing, readText, toolkitPrefix, writeText } from '../utils'
 import { Compiler } from './base'
 
 export class RunHaskell_Compiler extends Compiler {
@@ -16,7 +15,7 @@ export class RunHaskell_Compiler extends Compiler {
     }
 
     type(): string {
-        return 'compiler'
+        return 'interpreter'
     }
 
     language(): string {
@@ -24,7 +23,7 @@ export class RunHaskell_Compiler extends Compiler {
     }
 
     async version(): Promise<string> {
-        return await this.getVersion('ghc --version', 0)
+        return await this.getVersion('runhaskell --version', 0)
     }
 
     flags1(): string {
@@ -35,15 +34,15 @@ export class RunHaskell_Compiler extends Compiler {
         return ''
     }
 
+    tool(): string {
+        return 'ghc'
+    }
+
     extension(): string {
         return 'hs'
     }
 
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        if (handler.source_modifier !== 'none') {
-            throw new Error(`Unknown source modifier: ${handler.source_modifier as string}`)
-        }
-
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
         // ghci -e ':q' solution.hs
         // This will load and typecheck the file, then immediately quit.
         // If there are compilation errors, they'll be shown. If it loads successfully and just exits, the code compiles.
@@ -58,7 +57,16 @@ export class RunHaskell_Compiler extends Compiler {
             cwd: directory,
         })`ghci -e :q ${sourcePath}`
 
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
+        if (exitCode !== 0) {
+            throw new Error(`Compilation failed for ${sourcePath}`)
+        }
+
+        return sourcePath
+    }
+
+    override async compileWithMain(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        await nothing()
+        throw new Error('Method not implemented.')
     }
 
     override async execute(
@@ -68,25 +76,21 @@ export class RunHaskell_Compiler extends Compiler {
         inputPath: string,
         outputPath: string,
     ): Promise<void> {
-        const mergedPath = `solution-${inputPath}.hs.exe`
-
-        tui.command(`Merging solution.hs and ${inputPath} into ${mergedPath}`, { italic: true })
-        await this.mergeScripts(directory, 'solution.hs', inputPath, mergedPath)
-
-        const fullOutputPath = join(directory, outputPath)
+        const newSourcePath = `${toolkitPrefix()}-${parse(sourcePath).name}-${parse(inputPath).name}.hs`
 
-        await rm(fullOutputPath, { force: true })
+        tui.command(`merge ${sourcePath} ${inputPath} > ${newSourcePath}`)
+        await this.mergeScripts(directory, sourcePath, inputPath, newSourcePath)
 
-        tui.command(`runhaskell ${mergedPath} > ${outputPath}`)
+        tui.command(`runhaskell ${newSourcePath} > ${outputPath}`)
 
         const { exitCode } = await execa({
             reject: false,
-            stdout: { file: fullOutputPath },
+            stdout: { file: join(directory, outputPath) },
             stderr: 'inherit',
             cwd: directory,
-        })`runhaskell ${mergedPath}`
+        })`runhaskell ${newSourcePath}`
 
-        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
+        if (exitCode !== 0) throw new Error(`Execution failed for ${newSourcePath}`)
     }
 
     async mergeScripts(