@jpetit/toolkit 3.0.22 → 3.1.1

package/lib/compilers/base.ts

@@ -1,103 +0,0 @@
-import tui from '../tui'
-import { execa } from 'execa'
-import { exists, rm } from 'fs/promises'
-import { join, sep } from 'path'
-import { readText } from '../utils'
-import type { Handler } from '../types'
-
-export type CompilerInfo = {
-    compiler_id: string
-    name: string
-    language: string
-    version: string
-    flags1: string
-    flags2: string
-    extension: string
-    type: string
-    warning: string
-}
-
-export abstract class Compiler {
-    abstract id(): string
-
-    abstract name(): string
-
-    abstract type(): string
-
-    abstract language(): string
-
-    abstract version(): Promise<string>
-
-    abstract flags1(): string
-
-    abstract flags2(): string
-
-    abstract extension(): string
-
-    warning(): string {
-        return ''
-    }
-
-    async available(): Promise<boolean> {
-        const version = await this.version()
-        return version !== 'not found'
-    }
-
-    async info(): Promise<CompilerInfo> {
-        return {
-            compiler_id: this.id(),
-            name: this.name(),
-            language: this.language(),
-            version: await this.version(),
-            flags1: this.flags1(),
-            flags2: this.flags2(),
-            extension: this.extension(),
-            type: this.type(),
-            warning: this.warning(),
-        }
-    }
-
-    abstract compile(handler: Handler, directory: string, sourcePath: string): Promise<void>
-
-    // Default implementation of execute for compiled languages
-    async execute(
-        handler: Handler,
-        directory: string,
-        sourcePath: string,
-        inputPath: string,
-        outputPath: string,
-    ): Promise<void> {
-        const executablePath = `solution.${this.extension()}.exe`
-        if (!(await exists(join(directory, executablePath)))) {
-            throw new Error(`Executable file ${executablePath} does not exist in directory ${directory}`)
-        }
-        // TODO: check in windows
-        const relativeExecutablePath = `.${sep}${executablePath}` // force prepending ./ to make it work
-        const fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        const input = await readText(fullInputPath)
-
-        tui.command(`${relativeExecutablePath} < ${inputPath} > ${outputPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            input,
-            stdout: { file: fullOutputPath },
-            stderr: 'inherit',
-            cwd: directory,
-        })`${relativeExecutablePath}`
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${executablePath} with exit code ${exitCode}`)
-    }
-
-    protected async getVersion(cmd: string, lineIndex: number): Promise<string> {
-        try {
-            const { stdout } = await execa`${cmd.split(' ')}`
-            const lines = stdout.split('\n')
-            return lines[lineIndex]?.trim() || 'Unknown version'
-        } catch {
-            return 'not found'
-        }
-    }
-}

package/lib/compilers/clojure.ts

@@ -1,76 +0,0 @@
-import tui from '../tui'
-import { type Handler } from '../types'
-import { Compiler } from './base'
-import { execa } from 'execa'
-import { join } from 'path'
-import { nothing, readText } from 'lib/utils'
-import { rm } from 'fs/promises'
-
-export class Clojure_Compiler extends Compiler {
-    id(): string {
-        return 'Clojure'
-    }
-
-    name(): string {
-        return 'Clojure'
-    }
-
-    type(): string {
-        return 'vm'
-    }
-
-    language(): string {
-        return 'Clojure'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('clj --version', 0)
-    }
-
-    flags1(): string {
-        return ''
-    }
-
-    flags2(): string {
-        return ''
-    }
-
-    extension(): string {
-        return 'clj'
-    }
-
-    async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        await nothing()
-
-        if (handler.source_modifier !== 'none') {
-            throw new Error(`source modifier not implemented`)
-        }
-
-        tui.warning(`No compilation available for Clojure`)
-    }
-
-    override async execute(
-        handler: Handler,
-        directory: string,
-        sourcePath: string,
-        inputPath: string,
-        outputPath: string,
-    ): Promise<void> {
-        const fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        const input = await readText(fullInputPath)
-
-        tui.command(`clj -M ${sourcePath} < ${inputPath} > ${outputPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            input,
-            stdout: { file: fullOutputPath },
-            stderr: 'inherit',
-            cwd: directory,
-        })`clj -M ${sourcePath}`
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${sourcePath}`)
-    }
-}

package/lib/compilers/gcc.ts

@@ -1,68 +0,0 @@
-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 {
-        return 'GCC'
-    }
-
-    name(): string {
-        return 'GNU C Compiler'
-    }
-
-    type(): string {
-        return 'compiler'
-    }
-
-    language(): string {
-        return 'C'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('gcc --version', 0)
-    }
-
-    flags1(): string {
-        return '-D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare'
-    }
-
-    flags2(): string {
-        return ''
-    }
-
-    extension(): string {
-        return 'c'
-    }
-
-    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}`)
-    }
-}

package/lib/compilers/ghc.ts

@@ -1,75 +0,0 @@
-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 {
-    id(): string {
-        return 'GHC'
-    }
-
-    name(): string {
-        return 'GHC'
-    }
-
-    type(): string {
-        return 'compiler'
-    }
-
-    language(): string {
-        return 'Haskell'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('ghc --version', 0)
-    }
-
-    flags1(): string {
-        return '-O3'
-    }
-
-    flags2(): string {
-        return '-O3'
-    }
-
-    extension(): string {
-        return 'hs'
-    }
-
-    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}`)
-    }
-}

package/lib/compilers/gxx.ts

@@ -1,68 +0,0 @@
-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 {
-    id(): string {
-        return 'GXX'
-    }
-
-    name(): string {
-        return 'GNU C++ Compiler'
-    }
-
-    type(): string {
-        return 'compiler'
-    }
-
-    language(): string {
-        return 'C++'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('g++ --version', 0)
-    }
-
-    flags1(): string {
-        return '-std=c++17 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
-    }
-
-    flags2(): string {
-        return '-std=c++17 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
-    }
-
-    extension(): string {
-        return 'cc'
-    }
-
-    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}`)
-    }
-}

package/lib/compilers/index.ts

@@ -1,72 +0,0 @@
-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 { RunPython_Compiler } from './run-python'
-import { RunHaskell_Compiler } from './run-haskell'
-
-const compilersRegistryById: Record<string, new () => Compiler> = {
-    C: GCC_Compiler,
-    'C++': GXX_Compiler,
-    Python3: Python3_Compiler,
-    Haskell: GHC_Compiler,
-    Clojure: Clojure_Compiler,
-    RunPython: RunPython_Compiler,
-    RunHaskell: RunHaskell_Compiler,
-}
-
-const compilersRegistryByExtension: Record<string, new () => Compiler> = {
-    c: GCC_Compiler,
-    cc: GXX_Compiler,
-    py: Python3_Compiler,
-    hs: GHC_Compiler,
-    clj: Clojure_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/python3.ts

@@ -1,105 +0,0 @@
-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 { 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 ''
-    }
-
-    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}`)
-        }
-        await writeText(fullWrapperPath, wrapperSource)
-
-        tui.command(`python3 -m py_compile ${wrapperPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            stderr: 'inherit',
-            stdout: 'inherit',
-            cwd: directory,
-        })`python3 -m py_compile ${wrapperPath}`
-
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
-    }
-
-    override async execute(
-        handler: Handler,
-        directory: string,
-        sourcePath: string,
-        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 fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        const input = await readText(fullInputPath)
-
-        tui.command(`python3 ${wrapperPath} < ${inputPath} > ${outputPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            input,
-            stdout: { file: fullOutputPath },
-            stderr: 'inherit',
-            cwd: directory,
-        })`python3 ${wrapperPath}`
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${wrapperPath}`)
-    }
-}

package/lib/compilers/run-haskell.ts

@@ -1,113 +0,0 @@
-import { execa } from 'execa'
-import { rm } from 'fs/promises'
-import { join } from 'path'
-import tui from '../tui'
-import type { Handler } from '../types'
-import { readText, writeText } from '../utils'
-import { Compiler } from './base'
-
-export class RunHaskell_Compiler extends Compiler {
-    id(): string {
-        return 'RunHaskell'
-    }
-
-    name(): string {
-        return 'RunHaskell'
-    }
-
-    type(): string {
-        return 'compiler'
-    }
-
-    language(): string {
-        return 'Haskell'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('ghc --version', 0)
-    }
-
-    flags1(): string {
-        return ''
-    }
-
-    flags2(): string {
-        return ''
-    }
-
-    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}`)
-        }
-
-        // 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}`)
-    }
-
-    override async execute(
-        handler: Handler,
-        directory: string,
-        sourcePath: string,
-        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)
-
-        await rm(fullOutputPath, { force: true })
-
-        tui.command(`runhaskell ${mergedPath} > ${outputPath}`)
-
-        const { exitCode } = await execa({
-            reject: false,
-            stdout: { file: fullOutputPath },
-            stderr: 'inherit',
-            cwd: directory,
-        })`runhaskell ${mergedPath}`
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${mergedPath}`)
-    }
-
-    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)
-    }
-}