@jpetit/toolkit 3.1.1 → 3.1.2

package/lib/maker.ts

@@ -0,0 +1,613 @@
+import chalk from 'chalk'
+import { execa } from 'execa'
+import { cp, exists, glob, mkdir, rename } from 'fs/promises'
+import { imageSizeFromFile } from 'image-size/fromFile'
+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 } from './data'
+import { newInspector, Inspector } from './inspector'
+
+export async function newMaker(directory: string): Promise<Maker> {
+    const inspector = await newInspector(directory)
+    return new Maker(inspector)
+}
+
+type ExecutionResult = {
+    testcase: string
+    time: number
+    inputSize: number
+    outputSize: number
+    error: boolean
+}
+
+export class Maker {
+    inspector: Inspector
+
+    public constructor(inspector: Inspector) {
+        this.inspector = inspector
+    }
+
+    async showDirectory() {
+        await tui.section('Directory', async () => {
+            await nothing()
+            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',
+                    )
+                }
+            }
+        })
+    }
+
+    public async makeProblem() {
+        await this.makeGoldenExecutable()
+        await this.makeCorrects()
+        await this.checkSolutions()
+        await this.makePdfs()
+        await this.makeTexts()
+    }
+
+    public async makeExecutable(program: string) {
+        const compiler = this.selectCompiler()
+        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.inspector.solutions) {
+                await this.makeExecutable(solution)
+            }
+        })
+    }
+
+    public async makeGoldenExecutable() {
+        await tui.section(
+            `Compiling golden solution from ${tui.hyperlink(this.inspector.directory, this.inspector.goldenSolution!)}`,
+            async () => {
+                if (!this.inspector.goldenSolution) {
+                    throw new Error('Golden solution not set')
+                }
+                await this.makeExecutable(this.inspector.goldenSolution)
+            },
+        )
+    }
+
+    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,
+            toolkitPrefix() + '-' + sourcePath,
+        )
+    }
+
+    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.inspector.handler, this.inspector.directory, sourcePath, input, output)
+        } catch (e) {
+            tui.error(`Execution failed for testcase '${testcase}'`)
+            error = true
+        }
+        const end = Date.now()
+        const time = end - start
+
+        if (this.inspector.handler.handler === 'graphic') {
+            await rename(join(this.inspector.directory, 'output.png'), join(this.inspector.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.inspector.handler.compilers === 'RunPython') {
+            return getCompilerById('RunPython')
+        } else if (this.inspector.handler.compilers === 'RunHaskell') {
+            return getCompilerById('RunHaskell')
+        } else if (this.inspector.handler.compilers === 'RunClojure') {
+            return getCompilerById('RunClojure')
+        } else {
+            const extension = this.inspector.goldenSolution!.split('.').pop()!
+            return getCompilerByExtension(extension)
+        }
+    }
+
+    public async makeCorrects() {
+        const compiler = this.selectCompiler()
+        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.inspector.testcases) {
+                    results.push(await this.makeCorrect(testcase, compiler, this.inspector.goldenSolution!))
+                }
+
+                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 = join(this.inspector.directory, toolkitPrefix() + '-pdf', humanid())
+            await mkdir(tmpDirBase, { recursive: true })
+            await tui.section('Creating working directory', async () => {
+                await nothing()
+                tui.directory(tmpDirBase)
+            })
+            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)
+                    })
+                }
+            }
+        })
+    }
+
+    async makeSamples(tmpDir: string, language: string): Promise<[string, string]> {
+        const graphic = this.inspector.handler.handler === 'graphic'
+        const samples1col: string[] = []
+        const samples2col: string[] = []
+        let index = 1
+        for (const testcase of this.inspector.testcases) {
+            if (testcase.startsWith('sample')) {
+                let size = ''
+                if (graphic) {
+                    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})`
+                }
+                samples1col.push(`\n\\SampleOneColInputOutput[${size}]{${testcase}}{${index}}\n`)
+                samples2col.push(`\n\\SampleTwoColInputOutput[${size}]{${testcase}}{${index}}\n`)
+                index++
+            }
+        }
+        return [samples1col.join('\n'), samples2col.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.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)
+
+        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
+        // 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)
+
+        // 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.inspector.directory, `problem.${language}.pdf`))
+            tui.success(
+                `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`)}`)
+        }
+    }
+
+    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 (.{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.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)
+                        })
+                    }
+                }
+            } 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.inspector.problemLangYmls[language].author || 'Unknown'
+        const authorEmail = this.inspector.problemLangYmls[language].author_email || 'unknown email'
+        const translator = this.inspector.problemLangYmls[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
+        // 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)
+
+        // 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.inspector.directory, `problem.${language}.txt`))
+            tui.success('Generated ' + tui.hyperlink(this.inspector.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.inspector.directory, `problem.${language}.md`))
+            tui.success('Generated ' + tui.hyperlink(this.inspector.directory, `problem.${language}.md`))
+        } catch (e) {
+            console.error('pandoc error', e)
+        }
+
+        // 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.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 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.inspector.directory, newProgram)}`,
+                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`)
+                    }
+                },
+            )
+
+            const results: ExecutionResult[] = []
+            await tui.section('Executing testcases', async () => {
+                for (const testcase of this.inspector.testcases) {
+                    results.push(
+                        await this.runTestcase(
+                            testcase,
+                            `${testcase}.inp`,
+                            `${toolkitPrefix()}-${testcase}.${extension}.out`,
+                            compiler,
+                            newProgram,
+                        ),
+                    )
+                }
+
+                console.log()
+                console.log(`testcase           time     status`)
+                let errors = 0
+                for (const result of results) {
+                    const status = result.error
+                        ? 'EE'
+                        : (await filesAreEqual(
+                                join(this.inspector.directory, `${result.testcase}.cor`),
+                                join(
+                                    this.inspector.directory,
+                                    `${toolkitPrefix()}-${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}`)
+                }
+            })
+        })
+    }
+}

package/lib/settings.ts

@@ -0,0 +1,51 @@
+import envPaths from 'env-paths'
+import { exists, mkdir } from 'fs/promises'
+import { join } from 'path'
+import { guessUserEmail, guessUserName, readYaml, writeYaml } from './utils'
+import { Settings } from './types'
+
+export const paths = envPaths('jutge', { suffix: 'toolkit' })
+
+export function configPath() {
+    return join(paths.config, 'config.yml')
+}
+
+// console.log(`Configuration path: ${configPath()}`)
+
+export async function initializePaths() {
+    await mkdir(paths.config, { recursive: true })
+    await mkdir(paths.data, { recursive: true })
+    await mkdir(paths.cache, { recursive: true })
+    await mkdir(paths.log, { recursive: true })
+    await mkdir(paths.temp, { recursive: true })
+}
+
+export async function saveSettings(settings: Settings) {
+    await initializePaths()
+    settings = Settings.parse(settings)
+    return await writeYaml(configPath(), settings)
+}
+
+export async function loadSettings(): Promise<Settings> {
+    const data = await readYaml(configPath())
+    return Settings.parse(data)
+}
+
+export async function loadSettingsAtStart(): Promise<Settings> {
+    if (!(await settingsExist())) {
+        const defaultSettings = Settings.parse({})
+        defaultSettings.name = (await guessUserName()) || 'John Doe'
+        defaultSettings.email = (await guessUserEmail()) || 'john.doe@example.com'
+        await saveSettings(defaultSettings)
+        return defaultSettings
+    } else {
+        return await loadSettings()
+    }
+}
+
+export async function settingsExist(): Promise<boolean> {
+    return await exists(configPath())
+}
+
+// settings loaded at the start of the program
+export const settings = await loadSettingsAtStart()