@jpetit/toolkit 3.1.1 → 3.1.2

package/lib/compilers/index.ts

@@ -0,0 +1,81 @@
+import { nothing } from '../utils'
+import { Compiler, type CompilerInfo } from './base'
+import { GCC_Compiler } from './gcc'
+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,
+    'C++': GXX_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> = {
+    c: GCC_Compiler,
+    cc: GXX_Compiler,
+    py: Python3_Compiler,
+    hs: GHC_Compiler,
+    clj: Clojure_Compiler,
+    java: Java_Compiler,
+    rs: Rust_Compiler,
+}
+
+export function getCompilerById(id: string): Compiler {
+    const CompilerClass = compilersRegistryById[id]
+    if (!CompilerClass) throw new Error(`Compiler '${id}' is not defined`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export function getCompilerByExtension(extension: string): Compiler {
+    const CompilerClass = compilersRegistryByExtension[extension]
+    if (!CompilerClass) throw new Error(`No compiler defined for extension '.${extension}'`)
+    const compilerInstance = new CompilerClass()
+    return compilerInstance
+}
+
+export async function getDefinedCompilerIds(): Promise<string[]> {
+    await nothing()
+    return Object.keys(compilersRegistryById)
+}
+
+export async function getAvailableCompilers(): Promise<string[]> {
+    const available: string[] = []
+    for (const id of Object.keys(compilersRegistryById)) {
+        const CompilerClass = compilersRegistryById[id]!
+        const compilerInstance = new CompilerClass()
+        if (await compilerInstance.available()) {
+            available.push(id)
+        }
+    }
+    return available
+}
+
+export async function getCompilerInfo(id: string): Promise<CompilerInfo> {
+    const compilerInstance = getCompilerById(id)
+    if (!compilerInstance) throw new Error(`Compiler '${id}' is not defined`)
+    return await compilerInstance.info()
+}
+
+export async function getCompilersInfo(): Promise<Record<string, CompilerInfo>> {
+    const infos: Record<string, CompilerInfo> = {}
+    for (const id of Object.keys(compilersRegistryById)) {
+        infos[id] = await getCompilerInfo(id)
+    }
+    return infos
+}

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

@@ -0,0 +1,112 @@
+import { execa } from 'execa'
+import { join } from 'path'
+import tui from '../tui'
+import type { Handler } from '../types'
+import { readText, toolkitPrefix, writeText } from '../utils'
+import { Compiler } from './base'
+
+export class Python3_Compiler extends Compiler {
+    id(): string {
+        return 'Python3'
+    }
+
+    name(): string {
+        return 'Python3'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    tool(): string {
+        return 'python3'
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    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}`)
+        }
+
+        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 ${sourcePath}`
+
+        if (exitCode !== 0) {
+            throw new Error(`Compilation failed for ${sourcePath}`)
+        }
+
+        return sourcePath
+    }
+
+    override async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const exePath = sourcePath
+
+        await this.rmInDir(directory, outputPath)
+        const input = await this.getInput(directory, inputPath)
+
+        tui.command(`python3 ${exePath} < ${inputPath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            input,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`python3 ${exePath}`
+
+        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

@@ -0,0 +1,117 @@
+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 RunHaskell_Compiler extends Compiler {
+    id(): string {
+        return 'RunHaskell'
+    }
+
+    name(): string {
+        return 'RunHaskell'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Haskell'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('runhaskell --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    tool(): string {
+        return 'ghc'
+    }
+
+    extension(): string {
+        return 'hs'
+    }
+
+    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.
+        // With execa, it seems we have to remove the quotes around :q
+
+        tui.command(`ghci -e ':q' ${sourcePath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stderr: 'inherit',
+            stdout: 'inherit',
+            cwd: directory,
+        })`ghci -e :q ${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(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
+        const newSourcePath = `${toolkitPrefix()}-${parse(sourcePath).name}-${parse(inputPath).name}.hs`
+
+        tui.command(`merge ${sourcePath} ${inputPath} > ${newSourcePath}`)
+        await this.mergeScripts(directory, sourcePath, inputPath, newSourcePath)
+
+        tui.command(`runhaskell ${newSourcePath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`runhaskell ${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\nmain = do\n'
+        for (const line of script2.split('\n')) {
+            if (line.trim() === '') {
+                mergedScript += '\n'
+            } else if (line.startsWith('let')) {
+                mergedScript += `    ${line}\n`
+            } else {
+                mergedScript += `    print $ ${line}\n`
+            }
+        }
+        await writeText(join(directory, outputScriptPath), mergedScript)
+    }
+}

package/lib/compilers/run-python.ts

@@ -0,0 +1,103 @@
+import { execa } from 'execa'
+import { cp } from 'fs/promises'
+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 RunPython_Compiler extends Compiler {
+    id(): string {
+        return 'RunPython'
+    }
+
+    name(): string {
+        return 'RunPython'
+    }
+
+    type(): string {
+        return 'interpreter'
+    }
+
+    language(): string {
+        return 'Python'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('python3 --version', 0)
+    }
+
+    flags1(): string {
+        return ''
+    }
+
+    flags2(): string {
+        return ''
+    }
+
+    tool(): string {
+        return 'python3'
+    }
+
+    extension(): string {
+        return 'py'
+    }
+
+    override async compileNormal(handler: Handler, directory: string, sourcePath: string): Promise<string> {
+        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}`)
+        }
+
+        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}.py`
+
+        tui.command(`merge ${sourcePath} ${inputPath} > ${newSourcePath}`)
+        await this.mergeScripts(directory, sourcePath, inputPath, newSourcePath)
+
+        tui.command(`python3 ${newSourcePath} > ${outputPath}`)
+
+        const { exitCode } = await execa({
+            reject: false,
+            stdout: { file: join(directory, outputPath) },
+            stderr: 'inherit',
+            cwd: directory,
+        })`python3 ${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))
+        const mergedScript = script1 + '\n\n\n' + script2
+        await writeText(join(directory, outputScriptPath), mergedScript)
+    }
+}

package/lib/compilers/rust.ts

@@ -0,0 +1,39 @@
+import { Compiler } from './base'
+
+export class Rust_Compiler extends Compiler {
+    id(): string {
+        return 'Rust'
+    }
+
+    name(): string {
+        return 'Rust Compiler'
+    }
+
+    type(): string {
+        return 'compiler'
+    }
+
+    language(): string {
+        return 'Rust'
+    }
+
+    async version(): Promise<string> {
+        return await this.getVersion('rustc --version', 0)
+    }
+
+    flags1(): string {
+        return '-C opt-level=2 -D warnings'
+    }
+
+    flags2(): string {
+        return '-C opt-level=2 -D warnings'
+    }
+
+    tool(): string {
+        return 'rustc'
+    }
+
+    extension(): string {
+        return 'rs'
+    }
+}