@jpetit/toolkit 3.0.0

package/lib/maker.ts

@@ -0,0 +1,535 @@
+import { imageSizeFromFile } from 'image-size/fromFile'
+import { paths } from '@/lib/settings'
+import * as tui from '@/lib/tui.js'
+import { filesAreEqual, fileSize, readYaml } from '@/lib/utils'
+import chalk from 'chalk'
+import { cp, exists, mkdir, mkdtemp, rename, rm } from 'fs/promises'
+import { tmpdir } from 'os'
+import { join, normalize } from 'path'
+import prettyBytes from 'pretty-bytes'
+import prettyMs from 'pretty-ms'
+import z from 'zod'
+import { getCompilerByExtension } from './compilers'
+import type { Compiler } from './compilers/base'
+import { languageNames, proglangExtensions } from './data'
+import { file } from 'bun'
+
+export const ZHandler = z.object({
+    handler: z.enum(['std', 'graphic']).default('std'),
+    solution: z.string().default('C++'),
+    source_modifier: z.string().default('none'),
+})
+
+export type Handler = z.infer<typeof ZHandler>
+
+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
+    // @ts-expect-error: will be initialized later
+    handler: Handler
+    languages: string[] = []
+    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
+    }
+
+    private async loadHandler() {
+        await tui.section('Loading handler.yml', async () => {
+            const data = await readYaml(`${this.directory}/handler.yml`)
+            try {
+                this.handler = ZHandler.parse(data)
+            } catch (e) {
+                tui.error(`Invalid handler.yml format`)
+                console.dir(e)
+                process.exit(1)
+            }
+            tui.print(Bun.YAML.stringify(this.handler, null, 2))
+        })
+    }
+
+    private async loadLanguages() {
+        await tui.section('Loading languages', async () => {
+            const glob = new Bun.Glob('problem.*.yml')
+            const files = await Array.fromAsync(glob.scan(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.print(Bun.YAML.stringify(this.languages, null, 2))
+
+            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.print(Bun.YAML.stringify(this.problemYmls[language], null, 2))
+                })
+            }
+        })
+    }
+
+    private async loadSolutions() {
+        await tui.section('Loading solutions', async () => {
+            const glob = new Bun.Glob('solution.{py,cc}')
+            const files = await Array.fromAsync(glob.scan(this.directory))
+            this.solutions = files
+            tui.print(Bun.YAML.stringify(this.solutions, null, 2))
+            if (this.solutions.length === 0) throw new Error('No solutions found')
+        })
+    }
+
+    private async loadGoldenSolution() {
+        await tui.section('Loading golden solution', async () => {
+            const solutionProglang = this.handler.solution
+            const extension = proglangExtensions[solutionProglang]
+            if (!extension) {
+                tui.error(`Unknown programming language '${solutionProglang}' for solution`)
+                process.exit(1)
+            }
+            const goldenSolutionPath = join(this.directory, `solution.${extension}`)
+            const fileExists = await exists(goldenSolutionPath)
+            if (!fileExists) {
+                tui.error(`Golden solution file '${goldenSolutionPath}' not found`)
+                process.exit(1)
+            }
+            this.goldenSolution = `solution.${extension}`
+            tui.print(this.goldenSolution)
+        })
+    }
+
+    private async loadTestcases() {
+        await tui.section('Loading testcases', async () => {
+            const glob = new Bun.Glob('*.inp')
+            const files = await Array.fromAsync(glob.scan(this.directory))
+            this.testcases = files.map((file) => file.replace('.inp', '')).sort()
+            tui.print(Bun.YAML.stringify(this.testcases, null, 2))
+        })
+    }
+
+    public async makeInspection() {
+        await tui.section('Inspecting problem', async () => {
+            await this.loadHandler()
+            await this.loadLanguages()
+            await this.loadSolutions()
+            await this.loadGoldenSolution()
+            await this.loadTestcases()
+        })
+    }
+
+    public async makeProblem() {
+        await this.makeExecutables()
+        await this.makeCorrects()
+        await this.makePdfs()
+        await this.makeTexts()
+    }
+
+    public async makeExecutable(program: string) {
+        await tui.section(`Compiling ${program}`, async () => {
+            const extension = program.split('.').pop()!
+            const compiler = getCompilerByExtension(extension)
+            try {
+                await compiler.compile(this.directory, program)
+            } catch (error) {
+                tui.error(`Compilation failed`)
+                console.error(error)
+                process.exit(1)
+            }
+        })
+    }
+
+    public async makeExecutables() {
+        await tui.section('Compiling solutions', async () => {
+            for (const solution of this.solutions) {
+                await this.makeExecutable(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.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 }
+    }
+
+    public async makeCorrects() {
+        await tui.section('Making corrects', async () => {
+            const extension = this.goldenSolution!.split('.').pop()!
+            const compiler = getCompilerByExtension(extension)
+            const results: ExecutionResult[] = []
+            await tui.section(`Using ${compiler.id()} on ${this.goldenSolution} to make corrects`, async () => {
+                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,
+                            )}`,
+                        ),
+                    )
+                }
+                console.log()
+
+                const errors = results.filter((result) => result.error).length
+                if (errors > 0) {
+                    tui.error(`${errors} errors occurred while making correct answers`)
+                    process.exit(1)
+                }
+            })
+        })
+    }
+
+    public async makePdfs() {
+        await tui.section('Making PDF statements', async () => {
+            await tui.section('Creating temporary directory', async () => {})
+            const tmpDirBase = await mkdtemp(join(tmpdir(), `pdf-`))
+            tui.command(tmpDirBase)
+            try {
+                for (const language of this.languages) {
+                    await tui.section(`Making PDF statement for ${language}`, async () => {
+                        await this.makePdf(tmpDirBase, language)
+                    })
+                }
+            } finally {
+                // TODO: await rm(tmpDirBase, { recursive: true, force: true })
+            }
+        })
+    }
+
+    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 Bun.write(join(tmpDir, 'root.tex'), root)
+
+        // tweak the tex file
+        const tex1 = await Bun.file(join(tmpDir, `problem.${language}.tex`)).text()
+        const tex2 = tex1
+            .replace(/\\begin{htmlonly}[\s\S]*?\\end{htmlonly}/g, '')
+            .replace(/\\begin{latexonly}/g, '')
+            .replace(/\\end{latexonly}/g, '')
+            .replace(/\.eps}/g, '}')
+        await Bun.write(join(tmpDir, `problem.${language}.tex`), tex2)
+
+        // copy style files
+        await this.copyStyleFiles(tmpDir, language)
+
+        // latex
+        try {
+            tui.command('pdflatex -interaction=nonstopmode -file-line-error root.tex')
+            await Bun.$`pdflatex -interaction=nonstopmode -file-line-error root.tex`.cwd(tmpDir).text()
+            await cp(join(tmpDir, 'root.pdf'), join(this.directory, `problem.${language}.pdf`))
+            tui.success(`Generated problem.${language}.pdf`)
+        } catch (e) {
+            console.error('pdflatex error', e)
+        }
+    }
+
+    async copyStyleFiles(tmpDir: string, language: string) {
+        const cpSty = async (path: string) => {
+            const source = join(paths.data, 'assets', 'sty', path)
+            await Bun.write(join(tmpDir, path), Bun.file(source))
+        }
+        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 () => {
+            await tui.section('Creating temporary directory', async () => {})
+            const tmpDirBase = await mkdtemp(join(tmpdir(), `text-`))
+            tui.command(tmpDirBase)
+            try {
+                for (const language of this.languages) {
+                    await tui.section(`Making text statements for ${language}`, async () => {
+                        await this.makeText(tmpDirBase, language)
+                    })
+                }
+            } finally {
+                await rm(tmpDirBase, { recursive: true, force: true })
+            }
+        })
+    }
+
+    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 Bun.write(join(tmpDir, 'root.tex'), root)
+
+        // tweak the tex file
+        const tex1 = await Bun.file(join(tmpDir, `problem.${language}.tex`)).text()
+        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 Bun.write(join(tmpDir, `problem.${language}.tex`), tex2)
+
+        // copy style files
+        await this.copyStyleFiles(tmpDir, language)
+
+        // convert .eps files to png
+        const glob2 = new Bun.Glob('*.{eps}')
+        for await (const file of glob2.scan(tmpDir)) {
+            tui.command(`convert ${file} ${file.replace(/\.eps$/, '.png')}`)
+            await Bun.$`convert ${file} ${file.replace(/\.eps$/, '.png')}`.cwd(tmpDir)
+        }
+
+        // create lua files
+        const luaSource = join(paths.data, 'assets', 'lua', 'fixCodeBlocks.lua')
+        await Bun.write(join(tmpDir, 'fixCodeBlocks.lua'), Bun.file(luaSource))
+
+        // txt
+        try {
+            tui.command('pandoc --quiet root.tex --to plain --output root.txt')
+            await Bun.$`pandoc --quiet root.tex --to plain --output root.txt`.cwd(tmpDir)
+            await cp(join(tmpDir, 'root.txt'), join(this.directory, `problem.${language}.txt`))
+            tui.success(`Generated 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 Bun.$`pandoc --quiet root.tex --to markdown --to markdown-header_attributes --lua-filter=fixCodeBlocks.lua --output root.md`.cwd(
+                tmpDir,
+            )
+            await cp(join(tmpDir, 'root.md'), join(this.directory, `problem.${language}.md`))
+            tui.success(`Generated 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 Bun.$`pandoc --quiet root.tex --to html --mathml --embed-resources --output root.html`.cwd(tmpDir)
+            await cp(join(tmpDir, 'root.html'), join(this.directory, `problem.${language}.html`))
+            tui.success(`Generated problem.${language}.html`)
+        } catch (e) {
+            console.error('pandoc error', e)
+        }
+    }
+
+    public async verifyCandidate(program: string) {
+        await tui.section(`Verifying candidate ${program}`, async () => {
+            const extension = program.split('.').pop()!
+            const compiler = getCompilerByExtension(extension)
+
+            await tui.section(`Using compiler '${compiler.name()}' to compile '${program}'`, async () => {
+                try {
+                    await compiler.compile(this.directory, program)
+                } catch (error) {
+                    tui.error(`Compilation failed`)
+                    process.exit(1)
+                }
+            })
+
+            const results: ExecutionResult[] = []
+            await tui.section('Executing candidate on 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 candidate '${program}'`)
+                } else {
+                    tui.success(`All testcases passed successfully for candidate '${program}'`)
+                }
+            })
+        })
+    }
+}

package/lib/settings.ts

@@ -0,0 +1,42 @@
+import { exists } from 'fs/promises'
+import envPaths from 'env-paths'
+import { mkdir } from 'fs/promises'
+import { join } from 'path'
+import { z } from 'zod'
+
+const ZSettings = z.object({
+    name: z.string().min(1).default('John Doe'),
+    email: z.string().email().default('john.doe@example.com'),
+    notifications: z.boolean().default(true),
+})
+
+export type Settings = z.infer<typeof ZSettings>
+
+export const paths = envPaths('jutge', { suffix: 'toolkit' })
+
+function configPath() {
+    return join(paths.config, 'config.json')
+}
+
+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()
+    return await Bun.write(configPath(), JSON.stringify(settings, null, 4))
+}
+
+export async function loadSettings(): Promise<Settings> {
+    const data = await Bun.file(configPath()).text()
+    const parsed = JSON.parse(data)
+    return ZSettings.parse(parsed)
+}
+
+export async function settingsExist(): Promise<boolean> {
+    return await exists(configPath())
+}

package/lib/tui.ts

@@ -0,0 +1,69 @@
+import boxen from 'boxen'
+import chalk from 'chalk'
+import { marked } from 'marked'
+import { markedTerminal } from 'marked-terminal'
+
+let indentation = 0
+
+const symbols = ['', '▶', '◆', '●', '■']
+
+export function sectionStart(text: string) {
+    if (indentation === 0) {
+        console.log(chalk.blue(boxen(text, { padding: { left: 1, right: 1 }, width: process.stdout.columns })))
+    } else {
+        console.log(chalk.blue(`${symbols[indentation]} ${text}`))
+    }
+    ++indentation
+    console.group()
+}
+
+export function sectionEnd() {
+    --indentation
+    console.groupEnd()
+}
+
+export async function section<T>(text: string, fn: () => Promise<T>): Promise<T> {
+    sectionStart(text)
+    const result = await fn()
+    sectionEnd()
+    return result
+}
+
+export function title(text: string) {
+    console.log(chalk.blue.bold(boxen(text, { padding: { left: 1, right: 1 }, width: process.stdout.columns })))
+    console.log()
+}
+
+export function command(text: string) {
+    console.log(chalk.magenta(`❯ ${text}`))
+}
+
+export function warning(text: string) {
+    console.log(chalk.yellow(`Warning: ${text}`))
+}
+
+export function error(text: string) {
+    console.log(chalk.red(`Error: ${text}`))
+}
+
+export function success(text: string) {
+    console.log(chalk.green(`Success: ${text}`))
+}
+
+export function action(text: string) {
+    console.log(chalk.blue(`${text}...`))
+}
+
+export function print(text: string): void {
+    const lines = text.split('\n')
+    for (const line of lines) {
+        console.log(line)
+    }
+}
+
+export async function markdown(content: string): Promise<void> {
+    // @ts-expect-error: i don't know why types are not working here but seems to work at runtime
+    marked.use(markedTerminal())
+    const output = await marked.parse(content)
+    console.log(output)
+}