@jpetit/toolkit 3.0.19 → 3.0.20

package/lib/compilers/base.ts

@@ -60,7 +60,13 @@ export abstract class Compiler {
     abstract compile(handler: Handler, directory: string, sourcePath: string): Promise<void>
 
     // Default implementation of execute for compiled languages
-    async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+    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}`)

package/lib/compilers/clojure.ts

@@ -1,8 +1,10 @@
-// TODO: all!
-
+import tui from 'lib/tui'
 import { type Handler } from '..//types'
-import { nothing } from '..//utils'
 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 {
@@ -39,6 +41,36 @@ export class Clojure_Compiler extends Compiler {
 
     async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
         await nothing()
-        throw new Error(`Not implemented`)
+
+        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

@@ -52,13 +52,13 @@ export class GCC_Compiler extends Compiler {
                 cwd: directory,
             })`gcc ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
         } else if (handler.source_modifier === 'no_main') {
-            tui.command(`gcc ${this.flags1()} ${sourcePath} main.cc -o ${exePath}`)
+            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.cc -o ${exePath}`
+            })`gcc ${this.flags1().split(' ')} ${sourcePath} main.c -o ${exePath}`
         } else {
             throw new Error(`Unknown source modifier: ${handler.source_modifier}`)
         }

package/lib/compilers/ghc.ts

@@ -4,6 +4,9 @@ import { Compiler } from './base'
 import { rm, exists } from 'fs/promises'
 import { join } from 'path'
 import { execa } from 'execa'
+import { read } from 'fs'
+import { concatText, readText, writeText } from 'lib/utils'
+import { dir } from 'console'
 
 export class GHC_Compiler extends Compiler {
     id(): string {
@@ -39,22 +42,36 @@ export class GHC_Compiler extends Compiler {
     }
 
     async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const exePath = sourcePath + '.exe'
-        const fullExePath = join(directory, exePath)
-        await rm(fullExePath, { force: true })
+        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 ${exePath}`)
+            tui.command(`ghc ${this.flags1()} ${sourcePath} -o ${outputPath}`)
             await execa({
                 reject: false,
                 stderr: 'inherit',
                 stdout: 'inherit',
                 cwd: directory,
-            })`ghc ${this.flags1().split(' ')} ${sourcePath} -o ${exePath}`
+            })`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(fullExePath))) throw new Error(`Compilation failed for ${sourcePath}`)
+        if (!(await exists(fullOutputPath))) throw new Error(`Compilation failed for ${sourcePath}`)
     }
 }

package/lib/compilers/python3.ts

@@ -40,48 +40,57 @@ export class Python3_Compiler extends Compiler {
     }
 
     async compile(handler: Handler, directory: string, sourcePath: string): Promise<void> {
-        const exePath = sourcePath + '.exe'
+        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') {
-            tui.command(`tweak ${sourcePath} to ${exePath}`, { italic: true })
-            const source = await readText(join(directory, sourcePath))
-            const sourceModified = source
+            wrapperSource = source
                 .replace('import turtle', 'import turtle_pil as turtle')
                 .replace('from turtle import', 'from turtle_pil import')
-            await writeText(join(directory, exePath), sourceModified)
         } else if (handler.source_modifier === 'no_main' || handler.source_modifier === 'structs') {
-            tui.command(`cat ${sourcePath} main.py > ${exePath}`)
-            const solution = await readText(join(directory, sourcePath))
             const main = await readText(join(directory, 'main.py'))
-            const solutionWithMain = solution + '\n\n\n' + main
-            await writeText(join(directory, exePath), solutionWithMain)
+            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 ${exePath}`)
+        tui.command(`python3 -m py_compile ${wrapperPath}`)
 
         const { exitCode } = await execa({
             reject: false,
             stderr: 'inherit',
             stdout: 'inherit',
             cwd: directory,
-        })`python3 -m py_compile ${exePath}`
+        })`python3 -m py_compile ${wrapperPath}`
 
         if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
     }
 
-    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
-        const exePath = 'solution.py.exe'
-        if (!(await exists(join(directory, exePath)))) {
-            throw new Error(`Executable file ${exePath} does not exist in directory ${directory}`)
+    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 ${exePath} < ${inputPath} > ${outputPath}`)
+        tui.command(`python3 ${wrapperPath} < ${inputPath} > ${outputPath}`)
 
         const { exitCode } = await execa({
             reject: false,
@@ -89,8 +98,8 @@ export class Python3_Compiler extends Compiler {
             stdout: { file: fullOutputPath },
             stderr: 'inherit',
             cwd: directory,
-        })`python3 ${exePath}`
+        })`python3 ${wrapperPath}`
 
-        if (exitCode !== 0) throw new Error(`Execution failed for ${exePath}`)
+        if (exitCode !== 0) throw new Error(`Execution failed for ${wrapperPath}`)
     }
 }

package/lib/compilers/run-haskell.ts

@@ -61,7 +61,13 @@ export class RunHaskell_Compiler extends Compiler {
         if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
     }
 
-    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+    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 })

package/lib/compilers/run-python.ts

@@ -61,7 +61,13 @@ export class RunPython_Compiler extends Compiler {
         if (exitCode !== 0) throw new Error(`Compilation failed for ${sourcePath}`)
     }
 
-    override async execute(handler: Handler, directory: string, inputPath: string, outputPath: string): Promise<void> {
+    override async execute(
+        handler: Handler,
+        directory: string,
+        sourcePath: string,
+        inputPath: string,
+        outputPath: string,
+    ): Promise<void> {
         const exePath = 'solution.py.exe'
         if (!(await exists(join(directory, exePath)))) {
             throw new Error(`Executable file ${exePath} does not exist in directory ${directory}`)

package/lib/maker.ts

@@ -293,15 +293,21 @@ export class Maker {
         }
     }
 
-    async makeCorrect(testcase: string, compiler: Compiler): Promise<ExecutionResult> {
-        return await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.cor`, compiler)
+    async makeCorrect(testcase: string, compiler: Compiler, sourcePath: string): Promise<ExecutionResult> {
+        return await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.cor`, compiler, sourcePath)
     }
 
-    async runTestcase(testcase: string, input: string, output: string, compiler: Compiler): Promise<ExecutionResult> {
+    async runTestcase(
+        testcase: string,
+        input: string,
+        output: string,
+        compiler: Compiler,
+        sourcePath: string,
+    ): Promise<ExecutionResult> {
         let error = false
         const start = Date.now()
         try {
-            await compiler.execute(this.handler, this.directory, input, output)
+            await compiler.execute(this.handler, this.directory, sourcePath, input, output)
         } catch (e) {
             tui.error(`Execution failed for testcase '${testcase}'`)
             error = true
@@ -339,7 +345,7 @@ export class Maker {
                 const results: ExecutionResult[] = []
 
                 for (const testcase of this.testcases) {
-                    results.push(await this.makeCorrect(testcase, compiler))
+                    results.push(await this.makeCorrect(testcase, compiler, this.goldenSolution!))
                 }
 
                 console.log()
@@ -651,7 +657,13 @@ Draft generated with \\textbf{new-jutge-toolkit}.
             await tui.section('Executing testcases', async () => {
                 for (const testcase of this.testcases) {
                     results.push(
-                        await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.${extension}.out`, compiler),
+                        await this.runTestcase(
+                            testcase,
+                            `${testcase}.inp`,
+                            `${testcase}.${extension}.out`,
+                            compiler,
+                            program,
+                        ),
                     )
                 }
 

package/lib/utils.ts

@@ -35,6 +35,18 @@ export async function writeText(path: string, content: string): Promise<void> {
     await writeFile(path, content)
 }
 
+export async function concatText(
+    inputPaths: string[],
+    outputPath: string,
+    separator: string = '\n\n\n',
+): Promise<void> {
+    let content = ''
+    for (const inputPath of inputPaths) {
+        content += (await readText(inputPath)) + separator
+    }
+    await writeText(outputPath, content)
+}
+
 export async function writeYaml(path: string, data: any): Promise<void> {
     const content = YAML.stringify(data, null, 4)
     await writeText(path, content)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@jpetit/toolkit",
     "description": "Toolkit to prepare problems for Jutge.org",
-    "version": "3.0.19",
+    "version": "3.0.20",
     "publishConfig": {
         "access": "public"
     },

package/toolkit/make.ts

@@ -37,6 +37,7 @@ interface MakeOptions extends MakerOptions {
     directories: string[]
     tasks: TaskType[]
     ignoreErrors: boolean
+    onlyErrors: boolean
     verbose?: boolean
 }
 
@@ -44,6 +45,7 @@ export const make = new Command('make')
     .description('Make problem components')
     .argument('[directories...]', 'problem directories', ['.'])
     .option('-i, --ignore-errors', 'ignore errors on a directory and continue processing', false)
+    .option('-e, --only-errors', 'only show errors at the final summary', false)
     .option('-t, --tasks <tasks...>', 'tasks to run: all, inspection, executables, corrects, pdf, text', ['all'])
     .option('-v, --verbose', 'verbose output (TODO)', false)
 
@@ -104,10 +106,11 @@ export const make = new Command('make')
                 tui.warning('No problem directories found')
             }
             for (const directory of realDirectories) {
-                tui.directory(directory)
                 if (errors[directory]) {
+                    tui.directory(directory)
                     tui.error(`  ${errors[directory]}`)
-                } else {
+                } else if (!options.onlyErrors) {
+                    tui.directory(directory)
                     tui.success(`  No errors found`)
                 }
             }