@jpetit/toolkit 3.0.14 → 3.0.16

package/lib/maker.ts

@@ -0,0 +1,686 @@
+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 { imageSizeFromFile } from 'image-size/fromFile'
+import { tmpdir } from 'os'
+import { basename, dirname, join, normalize, resolve, sep } from 'path'
+import prettyBytes from 'pretty-bytes'
+import prettyMs from 'pretty-ms'
+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
+}
+
+export async function newMaker(options: MakerOptions): Promise<Maker> {
+    const maker = new Maker(options)
+    await maker.makeInspection()
+    return maker
+}
+
+type ExecutionResult = {
+    testcase: string
+    time: number
+    inputSize: number
+    outputSize: number
+    error: boolean
+}
+
+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])
+            })
+        }
+    }
+
+    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')
+            }
+        })
+    }
+
+    async showDirectory() {
+        await tui.section('Directory', async () => {
+            await nothing()
+            tui.directory(resolve(this.directory))
+            const fullPath = normalize(resolve(this.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',
+                    )
+                }
+            }
+        })
+    }
+    public async makeProblem() {
+        await this.makeGoldenExecutable()
+        await this.makeCorrects()
+        await this.verifySolutions()
+        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`)
+            }
+        })
+    }
+
+    public async makeExecutables() {
+        await tui.section('Compiling solutions', async () => {
+            for (const solution of this.solutions) {
+                await this.makeExecutable(solution)
+            }
+        })
+    }
+
+    public async makeGoldenExecutable() {
+        await tui.section(
+            `Compiling golden solution ${tui.hyperlink(this.directory, this.goldenSolution!)}`,
+            async () => {
+                if (!this.goldenSolution) {
+                    throw new Error('Golden solution not set')
+                }
+                await this.makeExecutable(this.goldenSolution)
+            },
+        )
+    }
+
+    public async verifySolutions() {
+        for (const solution of this.solutions) {
+            if (solution !== this.goldenSolution) {
+                await this.verifyCandidate(solution)
+            }
+        }
+    }
+
+    async makeCorrect(testcase: string, compiler: Compiler): Promise<ExecutionResult> {
+        return await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.cor`, compiler)
+    }
+
+    async runTestcase(testcase: string, input: string, output: string, compiler: Compiler): Promise<ExecutionResult> {
+        let error = false
+        const start = Date.now()
+        try {
+            await compiler.execute(this.handler, this.directory, input, output)
+        } catch (e) {
+            tui.error(`Execution failed for testcase '${testcase}'`)
+            error = true
+        }
+        const end = Date.now()
+        const time = end - start
+
+        if (this.handler.handler === 'graphic') {
+            await rename(join(this.directory, 'output.png'), join(this.directory, output))
+        }
+
+        const inputSize = await fileSize(`${this.directory}/${input}`)
+        const outputSize = await fileSize(`${this.directory}/${output}`)
+
+        return { testcase, error, time, inputSize, outputSize }
+    }
+
+    selectCompiler(): Compiler {
+        if (this.handler.compilers === 'RunPython') {
+            return getCompilerById('RunPython')
+        } else if (this.handler.compilers === 'RunHaskell') {
+            return getCompilerById('RunHaskell')
+        } else if (this.handler.compilers === 'RunClojure') {
+            return getCompilerById('RunClojure')
+        } else {
+            const extension = this.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(`Executing testcases using ${compiler.name()}`, async () => {
+                const results: ExecutionResult[] = []
+
+                for (const testcase of this.testcases) {
+                    results.push(await this.makeCorrect(testcase, compiler))
+                }
+
+                console.log()
+                console.log(`testcase           time      input     output`)
+                for (const result of results) {
+                    const time = prettyMs(result.time)
+                    const inputSize = prettyBytes(result.inputSize).replace(' ', '')
+                    const outputSize = prettyBytes(result.outputSize).replace(' ', '')
+                    console.log(
+                        (result.error ? chalk.red : chalk.green)(
+                            `${result.testcase.padEnd(12)} ${time.padStart(10)} ${inputSize.padStart(10)} ${outputSize.padStart(
+                                10,
+                            )}`,
+                        ),
+                    )
+                }
+
+                const errors = results.filter((result) => result.error).length
+                if (errors > 0) {
+                    console.log()
+                    throw new Error(`${errors} errors occurred while making correct answers`)
+                }
+            })
+        })
+    }
+
+    public async makePdfs() {
+        await tui.section('Making PDF statements', async () => {
+            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-pdf-`))
+            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)
+                        })
+                    }
+                }
+            } 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[] = []
+        let index = 1
+        for (const testcase of this.testcases) {
+            if (testcase.startsWith('sample')) {
+                let size = ''
+                if (graphic) {
+                    await cp(join(this.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`)
+                index++
+            }
+        }
+        return [samples1c.join('\n'), samples2c.join('\n')]
+    }
+
+    async makePdf(tmpDirBase: string, language: string) {
+        const tmpDir = join(tmpDirBase, language)
+        await mkdir(tmpDir)
+
+        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 [samples1c, samples2c] = await this.makeSamples(tmpDir, language)
+
+        const root = `
+    
+\\documentclass[11pt]{article}
+
+\\usepackage{judgeit}
+\\usepackage{judgeit.${language}}
+
+% TODO?
+\\lstMakeShortInline@
+
+\\begin{document}
+
+\\providecommand{\\SampleOneCol}{${samples1c}} 
+\\providecommand{\\SampleTwoCol}{${samples2c}} 
+\\ProblemId{{DRAFT ${language}}}
+\\DoProblem{${language}}
+
+\\ProblemInformation
+\\Author: ${author}\\\\ ${translator ? `(${language}: ${translator})` : ''}
+\\Generation: ${date}
+
+\\subsection*{Draft}
+Draft generated with \\textbf{new-jutge-toolkit}.
+
+\\end{document}
+
+        `
+
+        // copy files to tmpDir
+        await cp(this.directory, tmpDir, { recursive: true })
+
+        // write root.tex
+        await writeText(join(tmpDir, 'root.tex'), root)
+
+        // tweak the tex file
+        const tex1 = await readText(join(tmpDir, `problem.${language}.tex`))
+        const tex2 = tex1
+            .replace(/\\begin{htmlonly}[\s\S]*?\\end{htmlonly}/g, '')
+            .replace(/\\begin{latexonly}/g, '')
+            .replace(/\\end{latexonly}/g, '')
+            .replace(/\.eps}/g, '}')
+        await writeText(join(tmpDir, `problem.${language}.tex`), tex2)
+
+        // copy style files
+        await this.copyStyleFiles(tmpDir, language)
+
+        // latex
+        try {
+            tui.command('xelatex -interaction=nonstopmode -file-line-error root.tex')
+            await execa({
+                stderr: 'inherit',
+                // stdout: 'inherit',
+                cwd: tmpDir,
+            })`xelatex -interaction=nonstopmode -file-line-error root.tex`
+            await cp(join(tmpDir, 'root.pdf'), join(this.directory, `problem.${language}.pdf`))
+            tui.success(
+                `Generated ${tui.hyperlink(this.directory, `problem.${language}.pdf`)} see ${tui.hyperlink(tmpDir, `root.log`)}`,
+            )
+        } catch (e) {
+            tui.error(`Error in LaTeX: ${tui.hyperlink(tmpDir, `root.log`)}`)
+        }
+    }
+
+    async copyStyleFiles(tmpDir: string, language: string) {
+        const cpSty = async (path: string) => {
+            const source = join(projectDir(), 'assets', 'sty', path)
+            await cp(source, join(tmpDir, path))
+        }
+        await cpSty('picins.sty')
+        await cpSty('judgeit.sty')
+        if (language === 'ca') await cpSty('judgeit.ca.sty')
+        if (language === 'es') await cpSty('judgeit.es.sty')
+        if (language === 'en') await cpSty('judgeit.en.sty')
+        if (language === 'fr') await cpSty('judgeit.fr.sty')
+        if (language === 'de') await cpSty('judgeit.de.sty')
+    }
+
+    public async makeTexts() {
+        await tui.section('Making text statements', async () => {
+            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-text-`))
+            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 text statements for ${languageNames[language]}`, async () => {
+                            await this.makeText(tmpDirBase, language)
+                        })
+                    }
+                }
+            } finally {
+                // do not clean up because of hyperlinks
+            }
+        })
+    }
+
+    async makeText(tmpDirBase: string, language: string) {
+        const tmpDir = join(tmpDirBase, language)
+        await mkdir(tmpDir)
+
+        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 root = `
+    
+\\documentclass[11pt]{article}
+
+\\usepackage{judgeit}
+\\usepackage{judgeit.${language}}
+
+% TODO?
+\\lstMakeShortInline@
+
+% redefine commands to simplify text output
+\\renewcommand{\\Sample}{}
+\\renewcommand{\\Statement}{}
+\\renewcommand{\\Problem}[1]{\\section{#1}}
+\\renewcommand{\\ProblemId}[1]{DRAFT ${language}}
+
+% redefine figure commands to avoid troubles with \\parpic
+\\renewcommand{\\FigureL}[2]{\\includegraphics[#1]{#2}}
+\\renewcommand{\\FigureC}[2]{\\includegraphics[#1]{#2}}
+\\renewcommand{\\FigureR}[2]{\\includegraphics[#1]{#2}}
+
+\\begin{document}
+
+\\DoProblem{${language}}
+
+\\subsection*{\\TxtAuthor}
+${author} ${translator ? `(${language}: ${translator})` : ''}
+
+\\subsection*{Draft}
+Draft generated with \\textbf{new-jutge-toolkit}.
+
+\\end{document}
+
+        `
+
+        // copy files to tmpDir
+        await cp(this.directory, tmpDir, { recursive: true })
+
+        // write root.tex
+        await writeText(join(tmpDir, 'root.tex'), root)
+
+        // tweak the tex file
+        const tex1 = await readText(join(tmpDir, `problem.${language}.tex`))
+        const tex2 = tex1
+            .replace(/\\begin{latexonly}[\s\S]*?\\end{latexonly}/g, '')
+            .replace(/\\begin{htmlonly}/g, '')
+            .replace(/\\end{htmlonly}/g, '')
+            .replace(/\\begin{minipage}/g, '')
+            .replace(/\\end{minipage}/g, '')
+            .replace(/\.eps}/g, '}')
+        await writeText(join(tmpDir, `problem.${language}.tex`), tex2)
+
+        // copy style files
+        await this.copyStyleFiles(tmpDir, language)
+
+        // convert .eps files to png
+        const files = (await Array.fromAsync(glob('*.eps', { cwd: tmpDir }))).sort()
+        for (const file of files) {
+            tui.command(`convert ${file} ${file.replace(/\.eps$/, '.png')}`)
+            await execa({ cwd: tmpDir })`convert ${file} ${file.replace(/\.eps$/, '.png')}`
+        }
+
+        // create lua files
+        const luaSource = join(projectDir(), 'assets', 'lua', 'fixCodeBlocks.lua')
+        await cp(luaSource, join(tmpDir, 'fixCodeBlocks.lua'))
+
+        // txt
+        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`))
+        } catch (e) {
+            console.error('pandoc error', e)
+        }
+
+        // md
+        try {
+            tui.command(
+                'pandoc --quiet root.tex --to markdown --to markdown-header_attributes --lua-filter=fixCodeBlocks.lua --output root.md',
+            )
+            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`))
+        } catch (e) {
+            console.error('pandoc error', e)
+        }
+
+        // md
+        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`))
+        } catch (e) {
+            console.error('pandoc error', e)
+        }
+    }
+
+    public async verifyCandidate(program: string) {
+        await tui.section(`Verifying ${program}`, async () => {
+            const extension = program.split('.').pop()!
+            const compiler = getCompilerByExtension(extension)
+
+            await tui.section(
+                `Using compiler ${compiler.name()} to compile ${tui.hyperlink(this.directory, program)}`,
+                async () => {
+                    try {
+                        await compiler.compile(this.handler, this.directory, program)
+                    } catch (error) {
+                        throw new Error(`Compilation failed`)
+                    }
+                },
+            )
+
+            const results: ExecutionResult[] = []
+            await tui.section('Executing testcases', async () => {
+                for (const testcase of this.testcases) {
+                    results.push(
+                        await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.${extension}.out`, compiler),
+                    )
+                }
+
+                console.log()
+                console.log(`testcase           time     status`)
+                let errors = 0
+                for (const result of results) {
+                    const status = result.error
+                        ? 'EE'
+                        : (await filesAreEqual(
+                                `${this.directory}/${result.testcase}.cor`,
+                                `${this.directory}/${result.testcase}.${extension}.out`,
+                            ))
+                          ? 'OK'
+                          : 'WA'
+                    const time = prettyMs(result.time)
+                    console.log(
+                        (status !== 'OK' ? chalk.red : chalk.green)(
+                            `${result.testcase.padEnd(12)} ${time.padStart(10)} ${status.padStart(10)}`,
+                        ),
+                    )
+                    if (status !== 'OK') errors++
+                }
+                console.log()
+
+                if (errors) {
+                    tui.error(`${errors} errors found for ${program}`)
+                } else {
+                    tui.success(`All testcases passed successfully for ${program}`)
+                }
+            })
+        })
+    }
+}