@jpetit/toolkit 3.0.4 → 3.0.6

package/lib/compilers/_frompython.ts

@@ -1,388 +0,0 @@
-import { $ } from 'bun'
-import chalk from 'chalk'
-import { access, copyFile, mkdir, readFile, rename, rm, unlink, writeFile } from 'fs/promises'
-
-// Constants
-const MAX_COMPILATION_TIME = 30000 // 30 seconds in milliseconds
-
-// Custom Errors
-export class CompilationTooLongError extends Error {
-    constructor() {
-        super('Compilation time exceeded')
-        this.name = 'CompilationTooLongError'
-    }
-}
-
-export class ExecutionError extends Error {
-    constructor(message: string) {
-        super(message)
-        this.name = 'ExecutionError'
-    }
-}
-
-export class CompilationError extends Error {
-    constructor(message: string) {
-        super(message)
-        this.name = 'CompilationError'
-    }
-}
-
-interface CompilerInfo {
-    compiler_id: string
-    name: string
-    language: string
-    version: string
-    flags1: string
-    flags2: string
-    extension: string
-    type: string
-    warning: string
-}
-
-interface Handler {
-    source_modifier?: string
-    [key: string]: any
-}
-
-const compilersList: Record<string, typeof Compiler> = {}
-
-function compiler(baseClass: typeof Compiler) {
-    return function <T extends typeof Compiler>(derivedClass: T) {
-        compilersList[derivedClass.name] = derivedClass
-        return derivedClass
-    }
-}
-
-export abstract class Compiler {
-    protected handler: Handler
-    protected _name: string
-    static availableCompilers: string[] = []
-
-    constructor(handler: Handler | null, name: string | null) {
-        this.handler = handler || {}
-        this._name = name || ''
-    }
-
-    abstract name(): string
-    abstract type(): string
-    abstract executable(): string
-    abstract language(): string
-    abstract version(): Promise<string>
-    abstract flags1(): string
-    abstract flags2(): string
-    abstract extension(): string
-    abstract compile(): Promise<boolean>
-    abstract execute(tst: string, correct: boolean, iterations?: number): Promise<number>
-
-    id(): string {
-        return this.constructor.name.replace('Compiler_', '').replace('XX', '++')
-    }
-
-    warning(): string {
-        return ''
-    }
-
-    async prepareExecution(ori: string): Promise<void> {
-        // Override in subclasses if needed
-    }
-
-    protected async executeCompiler(cmd: string): Promise<void> {
-        console.log(chalk.dim(cmd))
-
-        return new Promise((resolve, reject) => {
-            const startTime = Date.now()
-            const proc = Bun.spawn(cmd.split(' '), {
-                stdout: 'pipe',
-                stderr: 'pipe',
-            })
-
-            let output = ''
-            let hasError = false
-
-            const timeout = setTimeout(() => {
-                proc.kill()
-                console.log(chalk.bold.red('Compilation time exceeded!'))
-                reject(new CompilationTooLongError())
-            }, MAX_COMPILATION_TIME)
-
-            ;(async () => {
-                try {
-                    const [stdout, stderr] = await Promise.all([
-                        new Response(proc.stdout).text(),
-                        new Response(proc.stderr).text(),
-                    ])
-
-                    output = stdout + stderr
-                    if (stderr.length > 0) {
-                        hasError = true
-                    }
-
-                    const exitCode = await proc.exited
-                    clearTimeout(timeout)
-
-                    if (exitCode !== 0 || hasError || output.length > 0) {
-                        if (output.length > 0) {
-                            console.log('\n' + output.trim() + '\n')
-                        }
-                        console.log(
-                            chalk.bold.red('Compilation error! ') +
-                                chalk.normal(`Please check ${this._name}.${this.extension()} and try again.`),
-                        )
-                        reject(new CompilationError('Compilation failed'))
-                    } else {
-                        resolve()
-                    }
-                } catch (error) {
-                    clearTimeout(timeout)
-                    reject(error)
-                }
-            })()
-        })
-    }
-
-    protected async getVersion(cmd: string, lineIndex: number): Promise<string> {
-        try {
-            const proc = Bun.spawn(cmd.split(' '), {
-                stdout: 'pipe',
-                stderr: 'pipe',
-            })
-
-            const stdout = await new Response(proc.stdout).text()
-            const lines = stdout.split('\n')
-            return lines[lineIndex]?.trim() || 'Unknown version'
-        } catch {
-            return 'not found'
-        }
-    }
-
-    info(): CompilerInfo {
-        return {
-            compiler_id: this.id(),
-            name: this._name,
-            language: this.language(),
-            version: '', // Will be populated asynchronously
-            flags1: this.flags1(),
-            flags2: this.flags2(),
-            extension: this.extension(),
-            type: this.type(),
-            warning: this.warning(),
-        }
-    }
-
-    protected async timeExecution(cmd: string, iterations: number = 1): Promise<number> {
-        const start = Date.now()
-        for (let i = 0; i < iterations; i++) {
-            await $`sh -c ${cmd}`.quiet()
-        }
-        const end = Date.now()
-        return (end - start) / iterations / 1000 // Return in seconds
-    }
-}
-
-// Python3 Compiler
-export class Compiler_Python3 extends Compiler {
-    name(): string {
-        return 'Python3'
-    }
-
-    type(): string {
-        return 'interpreter'
-    }
-
-    executable(): string {
-        return `${this._name}.py`
-    }
-
-    language(): string {
-        return 'Python'
-    }
-
-    async version(): Promise<string> {
-        return await this.getVersion('python3 -V', 0)
-    }
-
-    flags1(): string {
-        return ''
-    }
-
-    flags2(): string {
-        return ''
-    }
-
-    extension(): string {
-        return 'py'
-    }
-
-    private async genWrapper(): Promise<void> {
-        await Util.writeFile(
-            'py3c.py',
-            `#!/usr/bin/python3
-
-import py_compile, sys
-
-py_compile.compile(sys.argv[1])`,
-        )
-    }
-
-    private async delWrapper(): Promise<void> {
-        await Util.delFile('py3c.py')
-    }
-
-    async execute(tst: string, correct: boolean, iterations: number = 1): Promise<number> {
-        let exec = this.executable()
-
-        if (this.handler.source_modifier === 'no_main' || this.handler.source_modifier === 'structs') {
-            await Util.copyFile(`${this._name}.py`, 'modified.py')
-            const ori = await Util.readFile(`${this._name}.py`)
-            const main = await Util.readFile('main.py')
-            await Util.writeFile('modified.py', `${ori}\n${main}\n`)
-            exec = 'modified.py'
-        }
-
-        const ext = correct ? 'cor' : 'py.out'
-        const cmd = `python3 ${exec} < ${tst}.inp > ${tst}.${ext}`
-
-        if (correct) {
-            process.stdout.write(cmd)
-        }
-
-        const time = await this.timeExecution(cmd, iterations)
-
-        await Util.delFile('modified.py')
-        await Util.delDir('__pycache__')
-
-        return time
-    }
-
-    async compile(): Promise<boolean> {
-        if (this.handler.source_modifier === 'no_main' || this.handler.source_modifier === 'structs') {
-            return await this.compileNoMain()
-        } else {
-            return await this.compileNormal()
-        }
-    }
-
-    private async compileNormal(): Promise<boolean> {
-        try {
-            await this.genWrapper()
-            const code = await Util.readFile(`${this._name}.py`)
-            await Util.writeFile(`${this._name}.py`, code)
-            await this.executeCompiler(`python3 py3c.py ${this._name}.py 1> /dev/null`)
-        } catch (error) {
-            if (error instanceof CompilationTooLongError) {
-                console.log(chalk.bold.red('Compilation time exceeded!'))
-            }
-            return false
-        } finally {
-            await this.delWrapper()
-        }
-        return true
-    }
-
-    private async compileNoMain(): Promise<boolean> {
-        if (!(await this.compileNormal())) {
-            return false
-        }
-
-        await Util.copyFile(`${this._name}.py`, 'modified.py')
-        const ori = await Util.readFile(`${this._name}.py`)
-        const main = await Util.readFile('main.py')
-        await Util.writeFile('modified.py', `${ori}\n${main}\n`)
-
-        try {
-            await this.genWrapper()
-            await this.executeCompiler('python3 py3c.py modified.py 1> /dev/null')
-        } catch (error) {
-            if (error instanceof CompilationTooLongError) {
-                console.log(chalk.bold.red('Compilation time exceeded!'))
-            }
-            return false
-        } finally {
-            await this.delWrapper()
-        }
-        return true
-    }
-}
-
-// Compiler registry
-const COMPILERS = ['GCC', 'GXX', 'Python3']
-
-export function getCompiler(cpl: string, handler: Handler | null = null, name: string | null = null): Compiler {
-    const compilerClass = cpl.replace('++', 'XX')
-
-    switch (compilerClass) {
-        case 'GCC':
-            return new Compiler_GCC(handler, name)
-        case 'GXX':
-            return new Compiler_GXX(handler, name)
-        case 'Python3':
-            return new Compiler_Python3(handler, name)
-        default:
-            throw new Error(`Unknown compiler: ${cpl}`)
-    }
-}
-
-export async function getCompilerExtensions(handlerCompiler: string): Promise<Record<string, string>> {
-    const result: Record<string, string> = {}
-
-    for (const compilerName of COMPILERS) {
-        const compiler = getCompiler(compilerName)
-        const ext = compiler.extension()
-
-        if (compilerName === handlerCompiler) {
-            result[ext] = compilerName
-        } else if (!compilerName.includes('Run') && !(ext in result)) {
-            result[ext] = compilerName
-        }
-    }
-
-    return result
-}
-
-export async function getAvailableCompilers(): Promise<string[]> {
-    const available: string[] = []
-
-    for (const compilerName of COMPILERS) {
-        const compiler = getCompiler(compilerName)
-        const version = await compiler.version()
-
-        if (!version.includes('not found')) {
-            available.push(compilerName)
-        }
-    }
-
-    return available
-}
-
-export async function printAvailableCompilers(): Promise<void> {
-    const available = await getAvailableCompilers()
-
-    if (available.length > 0) {
-        process.stdout.write('Available compilers: ')
-
-        for (let i = 0; i < available.length; i++) {
-            process.stdout.write(available[i])
-
-            if (i === available.length - 2) {
-                process.stdout.write(' and ')
-            } else if (i !== available.length - 1) {
-                process.stdout.write(', ')
-            }
-        }
-
-        console.log()
-    }
-}
-
-export async function getCompilerInfo(): Promise<Record<string, CompilerInfo>> {
-    const result: Record<string, CompilerInfo> = {}
-
-    for (const compilerName of COMPILERS) {
-        const compiler = getCompiler(compilerName)
-        const info = compiler.info()
-        info.version = await compiler.version()
-        result[compilerName] = info
-    }
-
-    return result
-}

package/lib/compilers/base.ts

@@ -1,97 +0,0 @@
-import { rm, exists } from 'fs/promises'
-import { join, sep } from 'path'
-import * as tui from '@/lib/tui'
-
-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(directory: string, sourcePath: string): Promise<void>
-
-    // Default implementation of execute for compiled languages
-    async execute(directory: 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 })
-        tui.command(`${relativeExecutablePath} < ${inputPath} > ${outputPath}`)
-        const proc = Bun.spawn([relativeExecutablePath], {
-            cwd: directory,
-            stdin: Bun.file(fullInputPath),
-            stdout: Bun.file(fullOutputPath),
-            stderr: 'inherit',
-        })
-        await proc.exited
-        const exitCode = proc.exitCode
-
-        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 proc = Bun.spawn(cmd.split(' '), {
-                stdout: 'pipe',
-                stderr: 'pipe',
-            })
-
-            const stdout = await new Response(proc.stdout).text()
-            const lines = stdout.split('\n')
-            return lines[lineIndex]?.trim() || 'Unknown version'
-        } catch {
-            return 'not found'
-        }
-    }
-}

package/lib/compilers/gcc.ts

@@ -1,47 +0,0 @@
-import * as tui from '@/lib/tui.js'
-import { Compiler } from './base'
-import { rm, exists } from 'fs/promises'
-import { join } from 'path'
-
-export class Compiler_GCC 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(directory: string, sourcePath: string): Promise<void> {
-        const outputPath = sourcePath + '.exe'
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        tui.command(`gcc ${this.flags1()} ${sourcePath} -o ${outputPath}`)
-        await Bun.$`gcc ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`.cwd(directory).nothrow()
-        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
-    }
-}

package/lib/compilers/gxx.ts

@@ -1,47 +0,0 @@
-import { rm, exists } from 'fs/promises'
-import { Compiler } from './base'
-import chalk from 'chalk'
-import { join } from 'path'
-
-export class Compiler_GXX 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++11 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
-    }
-
-    flags2(): string {
-        return '-std=c++11 -D_JUDGE_ -O2 -DNDEBUG -Wall -Wextra -Wno-sign-compare -Wshadow'
-    }
-
-    extension(): string {
-        return 'cc'
-    }
-
-    async compile(directory: string, sourcePath: string): Promise<void> {
-        const outputPath = sourcePath + '.exe'
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        console.log(chalk.magenta(`❯ g++ ${this.flags1()} ${sourcePath} -o ${outputPath}`))
-        await Bun.$`g++ ${this.flags1().split(' ')} ${sourcePath} -o ${outputPath}`.cwd(directory).nothrow()
-        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
-    }
-}

package/lib/compilers/index.ts

@@ -1,61 +0,0 @@
-import { Compiler, type CompilerInfo } from './base'
-import { Compiler_GCC } from './gcc'
-import { Compiler_GXX } from './gxx'
-import { Compiler_Python3 } from './python3'
-
-const compilersRegistryById: Record<string, new () => Compiler> = {
-    C: Compiler_GCC,
-    'C++': Compiler_GXX,
-    Python3: Compiler_Python3,
-}
-
-const compilersRegistryByExtension: Record<string, new () => Compiler> = {
-    c: Compiler_GCC,
-    cc: Compiler_GXX,
-    py: Compiler_Python3,
-}
-
-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 Bun.sleep(0) // to make function async
-    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,67 +0,0 @@
-import * as tui from '@/lib/tui.js'
-import { exists, rm } from 'fs/promises'
-import { join } from 'path'
-import { Compiler } from './base'
-
-export class Compiler_Python3 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(directory: string, sourcePath: string): Promise<void> {
-        tui.command(`python3 -m py_compile ${sourcePath}`)
-        console.log('directory:', directory, 'sourcePath:', sourcePath)
-        const { exitCode } = await Bun.$`python3 -m py_compile ${sourcePath}`.cwd(directory).nothrow()
-        if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
-    }
-
-    override async execute(directory: string, inputPath: string, outputPath: string): Promise<void> {
-        const sourcePath = 'solution.py'
-        if (!(await exists(join(directory, sourcePath)))) {
-            throw new Error(`Source file ${sourcePath} does not exist in directory ${directory}`)
-        }
-        const fullInputPath = join(directory, inputPath)
-        const fullOutputPath = join(directory, outputPath)
-        await rm(fullOutputPath, { force: true })
-        tui.command(`python3 ${sourcePath} < ${inputPath} > ${outputPath}`)
-
-        const proc = Bun.spawn(['python3', sourcePath], {
-            cwd: directory,
-            stdin: Bun.file(fullInputPath),
-            stdout: Bun.file(fullOutputPath),
-            stderr: 'inherit',
-        })
-        await proc.exited
-        const exitCode = proc.exitCode
-
-        if (exitCode !== 0) throw new Error(`Execution failed for ${sourcePath}`)
-    }
-}