@jpetit/toolkit 3.0.23 → 3.1.2

package/lib/maker.ts

@@ -1,28 +1,31 @@
-import tui from '../lib/tui'
-import { filesAreEqual, fileSize, nothing, projectDir, readText, readYaml, writeText } from '../lib/utils'
 import chalk from 'chalk'
 import { execa } from 'execa'
-import { cp, exists, glob, mkdir, mkdtemp, rename } from 'fs/promises'
+import { cp, exists, glob, mkdir, rename } from 'fs/promises'
 import { imageSizeFromFile } from 'image-size/fromFile'
-import { tmpdir } from 'os'
-import { basename, dirname, join, normalize, resolve, sep } from 'path'
+import { basename, dirname, join, normalize, resolve } from 'path'
 import prettyBytes from 'pretty-bytes'
 import prettyMs from 'pretty-ms'
+import tui from '../lib/tui'
+import {
+    filesAreEqual,
+    fileSize,
+    humanid,
+    isDirectory,
+    isDirectoryInDir,
+    nothing,
+    projectDir,
+    readText,
+    toolkitPrefix,
+    writeText,
+} from '../lib/utils'
 import { getCompilerByExtension, getCompilerById } from './compilers'
 import type { Compiler } from './compilers/base'
-import { languageNames, proglangExtensions, proglangNames } from './data'
-import { type Handler, ZHandler, ZScores } from './types'
-import { th } from 'zod/locales'
-
-export interface MakerOptions {
-    verbose?: boolean
-    directory: string
-}
+import { languageNames } from './data'
+import { newInspector, Inspector } from './inspector'
 
-export async function newMaker(options: MakerOptions): Promise<Maker> {
-    const maker = new Maker(options)
-    await maker.makeInspection()
-    return maker
+export async function newMaker(directory: string): Promise<Maker> {
+    const inspector = await newInspector(directory)
+    return new Maker(inspector)
 }
 
 type ExecutionResult = {
@@ -34,210 +37,21 @@ type ExecutionResult = {
 }
 
 export class Maker {
-    verbose: boolean
-    directory: string
-    structure: 'multi' | 'single' = 'multi'
-    // multi: many languages in the same directory
-    // single: one language in a subdirectory of a .pbm directory
-    language: string | null = null // only for single structure, tells which language it is
-
-    // @ts-expect-error: will be initialized later
-    handler: Handler
-    languages: string[] = []
-    originalLanguage: string | null = null
-    problemYmls: Record<string, any> = {} // language -> content
-    solutions: string[] = []
-    goldenSolution: string | null = null
-    testcases: string[] = [] // testcase names without extensions
-
-    public constructor(options: MakerOptions) {
-        this.verbose = options.verbose || false
-        this.directory = normalize(join(options.directory, '.')) // normalize path and ensure no trailing slash
-    }
-
-    public async makeInspection() {
-        await tui.section('Inspecting problem', async () => {
-            await this.loadStructure()
-            await this.loadLanguages()
-            await this.loadHandler()
-            await this.loadOriginalLanguage()
-            await this.loadSolutions()
-            await this.loadGoldenSolution()
-            await this.loadTestcases()
-            await this.loadScores()
-            await this.loadAwards()
-        })
-    }
-
-    private async loadStructure() {
-        await tui.section('Determining structure', async () => {
-            await nothing()
-            if (this.directory.endsWith('.pbm')) {
-                this.structure = 'multi'
-            } else {
-                this.structure = 'single'
-            }
-            console.log(this.structure)
-        })
-    }
-
-    private async loadLanguages() {
-        await tui.section('Loading languages', async () => {
-            if (this.structure === 'multi') {
-                await this.loadLanguagesMulti()
-            } else {
-                await this.loadLanguagesSingle()
-            }
-        })
-    }
-
-    private async loadLanguagesMulti() {
-        const files = await Array.fromAsync(glob('problem.*.yml', { cwd: this.directory }))
-        const languages = files
-            .map((file) => {
-                const match = file.match(/problem\.(.+)\.yml/)
-                return match ? match[1] : null
-            })
-            .filter((language) => language && language in languageNames)
-        this.languages = languages as string[]
-        tui.yaml(this.languages)
-
-        for (const language of this.languages) {
-            await tui.section(`Loading problem.${language}.yml`, async () => {
-                this.problemYmls[language] = await readYaml(`${this.directory}/problem.${language}.yml`)
-                tui.yaml(this.problemYmls[language])
-            })
-        }
-    }
-
-    private async loadLanguagesSingle() {
-        for (const language of Object.keys(languageNames)) {
-            const name = join(this.directory, '..', language, `problem.${language}.yml`)
-            if (await exists(name)) {
-                this.languages.push(language)
-            }
-        }
-        tui.yaml(this.languages)
-
-        for (const language of this.languages) {
-            const name = join(this.directory, '..', language, `problem.${language}.yml`)
-            await tui.section(`Loading ..${sep}${language}${sep}problem.${language}.yml`, async () => {
-                this.problemYmls[language] = await readYaml(name)
-                tui.yaml(this.problemYmls[language])
-            })
-        }
-
-        this.language = basename(this.directory)
-    }
+    inspector: Inspector
 
-    private async loadHandler() {
-        await tui.section('Loading handler.yml', async () => {
-            const data = await readYaml(`${this.directory}/handler.yml`)
-            this.handler = ZHandler.parse(data)
-            tui.yaml(this.handler)
-        })
-    }
-
-    private async loadScores() {
-        await tui.section('Loading scores.yml', async () => {
-            if (await exists(`${this.directory}/scores.yml`)) {
-                const data = await readYaml(`${this.directory}/scores.yml`)
-                const scores = ZScores.parse(data)
-                tui.yaml(scores)
-            } else {
-                tui.print('scores.yml not defined')
-            }
-        })
-    }
-    private async loadOriginalLanguage() {
-        await tui.section('Determining original language', async () => {
-            await nothing()
-            for (const language of this.languages) {
-                if ('author' in this.problemYmls[language]) {
-                    this.originalLanguage = language
-                    break
-                }
-            }
-            if (!this.originalLanguage) {
-                throw new Error('No original language found (a language with an author field)')
-            }
-            tui.print(this.originalLanguage)
-        })
-    }
-
-    private async loadSolutions() {
-        await tui.section('Loading solutions', async () => {
-            const comaSeparatedExtensions = Object.keys(proglangNames).join(',')
-            const files = await Array.fromAsync(glob(`solution.{${comaSeparatedExtensions}}`, { cwd: this.directory }))
-            this.solutions = files
-            tui.yaml(this.solutions)
-            if (this.solutions.length === 0) throw new Error('No solutions found')
-        })
-    }
-
-    private async loadGoldenSolution() {
-        await tui.section('Determining golden solution', async () => {
-            if (this.handler.compilers === 'RunPython') {
-                this.goldenSolution = 'solution.py'
-            } else if (this.handler.compilers === 'RunHaskell' || this.handler.compilers === 'GHC') {
-                this.goldenSolution = 'solution.hs'
-            } else if (this.handler.compilers === 'RunClojure' || this.handler.compilers === 'Clojure') {
-                this.goldenSolution = 'solution.clj'
-            } else {
-                // any compilers
-                const solutionProglang = this.handler.solution
-                const extension = proglangExtensions[solutionProglang]
-                if (!extension) {
-                    throw new Error(`Unknown programming language ${solutionProglang} for solution`)
-                }
-                const goldenSolutionPath = join(this.directory, `solution.${extension}`)
-                const fileExists = await exists(goldenSolutionPath)
-                if (!fileExists) {
-                    throw new Error(`Golden solution file ${goldenSolutionPath} not found`)
-                }
-                this.goldenSolution = `solution.${extension}`
-            }
-            tui.print(this.goldenSolution)
-        })
-    }
-
-    private async loadTestcases() {
-        await tui.section('Loading testcases', async () => {
-            const files = await Array.fromAsync(glob('*.inp', { cwd: this.directory }))
-            this.testcases = files.map((file) => file.replace('.inp', '')).sort()
-            tui.yaml(this.testcases)
-        })
-    }
-
-    private async loadAwards() {
-        await tui.section('Loading awards', async () => {
-            if (await exists(join(this.directory, 'award.html'))) {
-                tui.success(tui.hyperlink(this.directory, 'award.html') + ' found')
-            } else {
-                tui.warning('award.html not found')
-            }
-
-            if (await exists(join(this.directory, 'award.png'))) {
-                tui.success(tui.hyperlink(this.directory, 'award.png') + ' found')
-                const dimensions = await imageSizeFromFile(join(this.directory, 'award.png'))
-                await tui.image(join(this.directory, 'award.png'), 6, 3)
-                tui.print(`${dimensions.width}x${dimensions.height}`)
-            } else {
-                tui.warning('award.png not found')
-            }
-        })
+    public constructor(inspector: Inspector) {
+        this.inspector = inspector
     }
 
     async showDirectory() {
         await tui.section('Directory', async () => {
             await nothing()
-            tui.directory(resolve(this.directory))
-            const fullPath = normalize(resolve(this.directory))
+            tui.directory(resolve(this.inspector.directory))
+            const fullPath = normalize(resolve(this.inspector.directory))
             if (!fullPath.endsWith('.pbm')) {
                 const lastPath = basename(fullPath)
                 const butLastPath = dirname(fullPath)
-                /*
-                 */
+
                 if (!Object.keys(languageNames).includes(lastPath) || !butLastPath.endsWith('.pbm')) {
                     throw new Error(
                         'The problem directory should end with .pbm or be a language id inside a .pbm directory',
@@ -246,28 +60,58 @@ export class Maker {
             }
         })
     }
+
     public async makeProblem() {
         await this.makeGoldenExecutable()
         await this.makeCorrects()
-        await this.verifySolutions()
+        await this.checkSolutions()
         await this.makePdfs()
         await this.makeTexts()
     }
 
     public async makeExecutable(program: string) {
         const compiler = this.selectCompiler()
-        await tui.section(`Compiling ${tui.hyperlink(this.directory, program)} with ${compiler.name()}`, async () => {
-            try {
-                await compiler.compile(this.handler, this.directory, program)
-            } catch (error) {
-                throw new Error(`Compilation failed`)
-            }
-        })
+        const newProgram = `${toolkitPrefix()}-${program}`
+        await tui.section(
+            `Copying ${tui.hyperlink(this.inspector.directory, program)} to ${tui.hyperlink(this.inspector.directory, newProgram)}`,
+            async () => {
+                await cp(join(this.inspector.directory, program), join(this.inspector.directory, newProgram))
+            },
+        )
+        await tui.section(
+            `Compiling ${tui.hyperlink(this.inspector.directory, newProgram)} with ${compiler.name()} (${this.inspector.handler.source_modifier})`,
+            async () => {
+                try {
+                    let outputPath: string
+                    if (this.inspector.handler.source_modifier === 'none') {
+                        outputPath = await compiler.compileNormal(
+                            this.inspector.handler,
+                            this.inspector.directory,
+                            newProgram,
+                        )
+                    } else if (this.inspector.handler.source_modifier === 'no_main') {
+                        outputPath = await compiler.compileWithMain(
+                            this.inspector.handler,
+                            this.inspector.directory,
+                            newProgram,
+                        )
+                    } else {
+                        throw new Error(`Unknown source modifier: ${this.inspector.handler.source_modifier as string}`)
+                    }
+                    if (!(await exists(join(this.inspector.directory, outputPath)))) {
+                        throw new Error(`Compilation failed for ${newProgram}`)
+                    }
+                    tui.success(`Compiled ${newProgram} to ${outputPath}`)
+                } catch (error) {
+                    throw new Error(`Compilation failed`)
+                }
+            },
+        )
     }
 
     public async makeExecutables() {
         await tui.section('Compiling solutions', async () => {
-            for (const solution of this.solutions) {
+            for (const solution of this.inspector.solutions) {
                 await this.makeExecutable(solution)
             }
         })
@@ -275,26 +119,32 @@ export class Maker {
 
     public async makeGoldenExecutable() {
         await tui.section(
-            `Compiling golden solution ${tui.hyperlink(this.directory, this.goldenSolution!)}`,
+            `Compiling golden solution from ${tui.hyperlink(this.inspector.directory, this.inspector.goldenSolution!)}`,
             async () => {
-                if (!this.goldenSolution) {
+                if (!this.inspector.goldenSolution) {
                     throw new Error('Golden solution not set')
                 }
-                await this.makeExecutable(this.goldenSolution)
+                await this.makeExecutable(this.inspector.goldenSolution)
             },
         )
     }
 
-    public async verifySolutions() {
-        for (const solution of this.solutions) {
-            if (solution !== this.goldenSolution) {
-                await this.verifyCandidate(solution)
+    public async checkSolutions() {
+        for (const solution of this.inspector.solutions) {
+            if (solution !== this.inspector.goldenSolution) {
+                await this.checkCandidate(solution)
             }
         }
     }
 
     async makeCorrect(testcase: string, compiler: Compiler, sourcePath: string): Promise<ExecutionResult> {
-        return await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.cor`, compiler, sourcePath)
+        return await this.runTestcase(
+            testcase,
+            `${testcase}.inp`,
+            `${testcase}.cor`,
+            compiler,
+            toolkitPrefix() + '-' + sourcePath,
+        )
     }
 
     async runTestcase(
@@ -307,7 +157,7 @@ export class Maker {
         let error = false
         const start = Date.now()
         try {
-            await compiler.execute(this.handler, this.directory, sourcePath, input, output)
+            await compiler.execute(this.inspector.handler, this.inspector.directory, sourcePath, input, output)
         } catch (e) {
             tui.error(`Execution failed for testcase '${testcase}'`)
             error = true
@@ -315,37 +165,37 @@ export class Maker {
         const end = Date.now()
         const time = end - start
 
-        if (this.handler.handler === 'graphic') {
-            await rename(join(this.directory, 'output.png'), join(this.directory, output))
+        if (this.inspector.handler.handler === 'graphic') {
+            await rename(join(this.inspector.directory, 'output.png'), join(this.inspector.directory, output))
         }
 
-        const inputSize = await fileSize(`${this.directory}/${input}`)
-        const outputSize = await fileSize(`${this.directory}/${output}`)
+        const inputSize = await fileSize(join(this.inspector.directory, input))
+        const outputSize = await fileSize(join(this.inspector.directory, output))
 
         return { testcase, error, time, inputSize, outputSize }
     }
 
     selectCompiler(): Compiler {
-        if (this.handler.compilers === 'RunPython') {
+        if (this.inspector.handler.compilers === 'RunPython') {
             return getCompilerById('RunPython')
-        } else if (this.handler.compilers === 'RunHaskell') {
+        } else if (this.inspector.handler.compilers === 'RunHaskell') {
             return getCompilerById('RunHaskell')
-        } else if (this.handler.compilers === 'RunClojure') {
+        } else if (this.inspector.handler.compilers === 'RunClojure') {
             return getCompilerById('RunClojure')
         } else {
-            const extension = this.goldenSolution!.split('.').pop()!
+            const extension = this.inspector.goldenSolution!.split('.').pop()!
             return getCompilerByExtension(extension)
         }
     }
 
     public async makeCorrects() {
         const compiler = this.selectCompiler()
-        await tui.section(`Making corrects with golden solution`, async () => {
+        await tui.section(`Making correct outputs with golden solution`, async () => {
             await tui.section(`Executing testcases using ${compiler.name()}`, async () => {
                 const results: ExecutionResult[] = []
 
-                for (const testcase of this.testcases) {
-                    results.push(await this.makeCorrect(testcase, compiler, this.goldenSolution!))
+                for (const testcase of this.inspector.testcases) {
+                    results.push(await this.makeCorrect(testcase, compiler, this.inspector.goldenSolution!))
                 }
 
                 console.log()
@@ -374,44 +224,44 @@ export class Maker {
 
     public async makePdfs() {
         await tui.section('Making PDF statements', async () => {
-            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-pdf-`))
+            const tmpDirBase = join(this.inspector.directory, toolkitPrefix() + '-pdf', humanid())
+            await mkdir(tmpDirBase, { recursive: true })
             await tui.section('Creating working directory', async () => {
                 await nothing()
                 tui.directory(tmpDirBase)
             })
-            try {
-                for (const language of this.languages) {
-                    if (this.structure === 'multi' || (this.structure === 'single' && language === this.language)) {
-                        await tui.section(`Making PDF statement for ${languageNames[language]}`, async () => {
-                            await this.makePdf(tmpDirBase, language)
-                        })
-                    }
+            for (const language of this.inspector.languages) {
+                if (
+                    this.inspector.structure === 'multi' ||
+                    (this.inspector.structure === 'single' && language === this.inspector.language)
+                ) {
+                    await tui.section(`Making PDF statement for ${languageNames[language]}`, async () => {
+                        await this.makePdf(tmpDirBase, language)
+                    })
                 }
-            } finally {
-                // do not clean up because of hyperlinks
             }
         })
     }
 
     async makeSamples(tmpDir: string, language: string): Promise<[string, string]> {
-        const graphic = this.handler.handler === 'graphic'
-        const samples1c: string[] = []
-        const samples2c: string[] = []
+        const graphic = this.inspector.handler.handler === 'graphic'
+        const samples1col: string[] = []
+        const samples2col: string[] = []
         let index = 1
-        for (const testcase of this.testcases) {
+        for (const testcase of this.inspector.testcases) {
             if (testcase.startsWith('sample')) {
                 let size = ''
                 if (graphic) {
-                    await cp(join(this.directory, `${testcase}.cor`), join(tmpDir, `${testcase}.cor.png`))
+                    await cp(join(this.inspector.directory, `${testcase}.cor`), join(tmpDir, `${testcase}.cor.png`))
                     const dimensions = await imageSizeFromFile(join(tmpDir, `${testcase}.cor.png`))
                     size = `(${dimensions.width}$\\times$${dimensions.height})`
                 }
-                samples1c.push(`\n\\SampleOneColInputOutput[${size}]{${testcase}}{${index}}\n`)
-                samples2c.push(`\n\\SampleTwoColInputOutput[${size}]{${testcase}}{${index}}\n`)
+                samples1col.push(`\n\\SampleOneColInputOutput[${size}]{${testcase}}{${index}}\n`)
+                samples2col.push(`\n\\SampleTwoColInputOutput[${size}]{${testcase}}{${index}}\n`)
                 index++
             }
         }
-        return [samples1c.join('\n'), samples2c.join('\n')]
+        return [samples1col.join('\n'), samples2col.join('\n')]
     }
 
     async makePdf(tmpDirBase: string, language: string) {
@@ -420,9 +270,9 @@ export class Maker {
 
         const date = new Date().toISOString().substring(0, 10)
         const year = new Date().getFullYear()
-        const author = this.problemYmls[language].author || 'Unknown'
-        const authorEmail = this.problemYmls[language].author_email || 'unknown email'
-        const translator = this.problemYmls[language].translator || ''
+        const author = this.inspector.problemLangYmls[language].author || 'Unknown'
+        const authorEmail = this.inspector.problemLangYmls[language].author_email || 'unknown email'
+        const translator = this.inspector.problemLangYmls[language].translator || ''
 
         const [samples1c, samples2c] = await this.makeSamples(tmpDir, language)
 
@@ -455,7 +305,20 @@ Draft generated with \\textbf{new-jutge-toolkit}.
         `
 
         // copy files to tmpDir
-        await cp(this.directory, tmpDir, { recursive: true })
+        // TODO: only copy needed files
+        for await (const entry of glob('*', { cwd: this.inspector.directory })) {
+            if (
+                entry.startsWith(toolkitPrefix()) ||
+                entry.endsWith('.exe') ||
+                entry.endsWith('.html') ||
+                entry.endsWith('.md') ||
+                entry.endsWith('.txt') ||
+                (await isDirectoryInDir(this.inspector.directory, entry))
+            ) {
+                continue
+            }
+            await cp(join(this.inspector.directory, entry), join(tmpDir, entry))
+        }
 
         // write root.tex
         await writeText(join(tmpDir, 'root.tex'), root)
@@ -480,9 +343,9 @@ Draft generated with \\textbf{new-jutge-toolkit}.
                 // stdout: 'inherit',
                 cwd: tmpDir,
             })`xelatex -interaction=nonstopmode -file-line-error root.tex`
-            await cp(join(tmpDir, 'root.pdf'), join(this.directory, `problem.${language}.pdf`))
+            await cp(join(tmpDir, 'root.pdf'), join(this.inspector.directory, `problem.${language}.pdf`))
             tui.success(
-                `Generated ${tui.hyperlink(this.directory, `problem.${language}.pdf`)} see ${tui.hyperlink(tmpDir, `root.log`)}`,
+                `Generated ${tui.hyperlink(this.inspector.directory, `problem.${language}.pdf`)} see ${tui.hyperlink(tmpDir, `root.log`)}`,
             )
         } catch (e) {
             tui.error(`Error in LaTeX: ${tui.hyperlink(tmpDir, `root.log`)}`)
@@ -504,15 +367,19 @@ Draft generated with \\textbf{new-jutge-toolkit}.
     }
 
     public async makeTexts() {
-        await tui.section('Making text statements', async () => {
-            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-text-`))
+        await tui.section('Making text statements (.{md,txt,html})', async () => {
+            const tmpDirBase = join(this.inspector.directory, toolkitPrefix() + '-text', humanid())
+            await mkdir(tmpDirBase, { recursive: true })
             await tui.section('Creating working directory', async () => {
                 await nothing()
                 tui.directory(tmpDirBase)
             })
             try {
-                for (const language of this.languages) {
-                    if (this.structure === 'multi' || (this.structure === 'single' && language === this.language)) {
+                for (const language of this.inspector.languages) {
+                    if (
+                        this.inspector.structure === 'multi' ||
+                        (this.inspector.structure === 'single' && language === this.inspector.language)
+                    ) {
                         await tui.section(`Making text statements for ${languageNames[language]}`, async () => {
                             await this.makeText(tmpDirBase, language)
                         })
@@ -530,9 +397,9 @@ Draft generated with \\textbf{new-jutge-toolkit}.
 
         const date = new Date().toISOString().substring(0, 10)
         const year = new Date().getFullYear()
-        const author = this.problemYmls[language].author || 'Unknown'
-        const authorEmail = this.problemYmls[language].author_email || 'unknown email'
-        const translator = this.problemYmls[language].translator || ''
+        const author = this.inspector.problemLangYmls[language].author || 'Unknown'
+        const authorEmail = this.inspector.problemLangYmls[language].author_email || 'unknown email'
+        const translator = this.inspector.problemLangYmls[language].translator || ''
 
         const root = `
     
@@ -570,7 +437,21 @@ Draft generated with \\textbf{new-jutge-toolkit}.
         `
 
         // copy files to tmpDir
-        await cp(this.directory, tmpDir, { recursive: true })
+        // TODO: only copy needed files
+        for await (const entry of glob('*', { cwd: this.inspector.directory })) {
+            if (
+                entry.startsWith(toolkitPrefix()) ||
+                entry.endsWith('.pdf') ||
+                entry.endsWith('.exe') ||
+                entry.endsWith('.html') ||
+                entry.endsWith('.md') ||
+                entry.endsWith('.txt') ||
+                (await isDirectoryInDir(this.inspector.directory, entry))
+            ) {
+                continue
+            }
+            await cp(join(this.inspector.directory, entry), join(tmpDir, entry))
+        }
 
         // write root.tex
         await writeText(join(tmpDir, 'root.tex'), root)
@@ -604,8 +485,8 @@ Draft generated with \\textbf{new-jutge-toolkit}.
         try {
             tui.command('pandoc --quiet root.tex --to plain --output root.txt')
             await execa({ cwd: tmpDir })`pandoc --quiet root.tex --to plain --output root.txt`
-            await cp(join(tmpDir, 'root.txt'), join(this.directory, `problem.${language}.txt`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.txt`))
+            await cp(join(tmpDir, 'root.txt'), join(this.inspector.directory, `problem.${language}.txt`))
+            tui.success('Generated ' + tui.hyperlink(this.inspector.directory, `problem.${language}.txt`))
         } catch (e) {
             console.error('pandoc error', e)
         }
@@ -618,35 +499,64 @@ Draft generated with \\textbf{new-jutge-toolkit}.
             await execa({
                 cwd: tmpDir,
             })`pandoc --quiet root.tex --to markdown --to markdown-header_attributes --lua-filter=fixCodeBlocks.lua --output root.md`
-            await cp(join(tmpDir, 'root.md'), join(this.directory, `problem.${language}.md`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.md`))
+            await cp(join(tmpDir, 'root.md'), join(this.inspector.directory, `problem.${language}.md`))
+            tui.success('Generated ' + tui.hyperlink(this.inspector.directory, `problem.${language}.md`))
         } catch (e) {
             console.error('pandoc error', e)
         }
 
-        // md
+        // html
         try {
             tui.command('pandoc --quiet root.tex --to html --mathml --embed-resources --output root.html')
             await execa({
                 cwd: tmpDir,
             })`pandoc --quiet root.tex --to html --mathml --embed-resources --output root.html`
-            await cp(join(tmpDir, 'root.html'), join(this.directory, `problem.${language}.html`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.html`))
+            await cp(join(tmpDir, 'root.html'), join(this.inspector.directory, `problem.${language}.html`))
+            tui.success('Generated ' + tui.hyperlink(this.inspector.directory, `problem.${language}.html`))
         } catch (e) {
             console.error('pandoc error', e)
         }
     }
 
-    public async verifyCandidate(program: string) {
-        await tui.section(`Verifying ${program}`, async () => {
+    public async checkCandidate(program: string) {
+        await tui.section(`Checking ${program}`, async () => {
             const extension = program.split('.').pop()!
             const compiler = getCompilerByExtension(extension)
+            const newProgram = `${toolkitPrefix()}-${program}`
+
+            await tui.section(
+                `Copying ${tui.hyperlink(this.inspector.directory, program)} to ${tui.hyperlink(this.inspector.directory, newProgram)}`,
+                async () => {
+                    await cp(join(this.inspector.directory, program), join(this.inspector.directory, newProgram))
+                },
+            )
 
             await tui.section(
-                `Using compiler ${compiler.name()} to compile ${tui.hyperlink(this.directory, program)}`,
+                `Using compiler ${compiler.name()} to compile ${tui.hyperlink(this.inspector.directory, newProgram)}`,
                 async () => {
                     try {
-                        await compiler.compile(this.handler, this.directory, program)
+                        let outputPath: string
+                        if (this.inspector.handler.source_modifier === 'none') {
+                            outputPath = await compiler.compileNormal(
+                                this.inspector.handler,
+                                this.inspector.directory,
+                                newProgram,
+                            )
+                        } else if (this.inspector.handler.source_modifier === 'no_main') {
+                            outputPath = await compiler.compileWithMain(
+                                this.inspector.handler,
+                                this.inspector.directory,
+                                newProgram,
+                            )
+                        } else {
+                            throw new Error(
+                                `Unknown source modifier: ${this.inspector.handler.source_modifier as string}`,
+                            )
+                        }
+                        if (!(await exists(join(this.inspector.directory, outputPath)))) {
+                            throw new Error(`Compilation failed for ${newProgram}`)
+                        }
+                        tui.success(`Compiled ${newProgram} to ${outputPath}`)
                     } catch (error) {
                         throw new Error(`Compilation failed`)
                     }
@@ -655,14 +565,14 @@ Draft generated with \\textbf{new-jutge-toolkit}.
 
             const results: ExecutionResult[] = []
             await tui.section('Executing testcases', async () => {
-                for (const testcase of this.testcases) {
+                for (const testcase of this.inspector.testcases) {
                     results.push(
                         await this.runTestcase(
                             testcase,
                             `${testcase}.inp`,
-                            `${testcase}.${extension}.out`,
+                            `${toolkitPrefix()}-${testcase}.${extension}.out`,
                             compiler,
-                            program,
+                            newProgram,
                         ),
                     )
                 }
@@ -674,8 +584,11 @@ Draft generated with \\textbf{new-jutge-toolkit}.
                     const status = result.error
                         ? 'EE'
                         : (await filesAreEqual(
-                                `${this.directory}/${result.testcase}.cor`,
-                                `${this.directory}/${result.testcase}.${extension}.out`,
+                                join(this.inspector.directory, `${result.testcase}.cor`),
+                                join(
+                                    this.inspector.directory,
+                                    `${toolkitPrefix()}-${result.testcase}.${extension}.out`,
+                                ),
                             ))
                           ? 'OK'
                           : 'WA'