@jutge.org/toolkit 4.4.27 → 4.4.28

package/docs/problem-anatomy.md

@@ -1,4 +1,4 @@
-# Problem anatomy (WORK IN PROGRESS)
+# Problem anatomy
 
 This document describes the anatomy of a common problem in [Jutge.org](https://jutge.org/). It explains the terminology used, the structure of a problem folder, and the purpose of each file that may be present in it.
 
@@ -87,6 +87,10 @@ The first method is preferred whenever possible, as it avoids duplication of fil
 
 Problem statements are stored in LaTeX files named `problem.lang.tex`, where `lang` denotes the ISO 639-1 code of the language for which the statement is given (currently `ca`, `en`, `es`, `fr`, `de` for Catalan, English, Spanish, French, and German respectively). Problem statements make use of certain macros.
 
+### Demo problem
+
+The clonable `demo` problem contains an example of a problem statement with many features that can be used in your own problem statements; see [demo.tex](demo.tex) for examples and inspiration.
+
 ### Structure
 
 The typical structure of a problem statement is the following:
@@ -293,8 +297,8 @@ If the arguments have not been specified, the default `time_factor` and `time_co
 This is an example of how the arguments would look in `handler.yml`:
 
 ```yml
-time_factor: [2, 10, 2]
-time_constant: [0.1, 0.01, 0.05]
+time_factor: [2, 10, 20]
+time_constant: [0.1, 0.5, 1.0]
 ```
 
 ### Advanced: Checkers
@@ -371,7 +375,7 @@ Unfortunately, the distillation process requires some hand work and is not curre
 
 ### Test options
 
-The `test.ops` file can be used to specify some advanced low-level limits for the correction of the corresponding test case. The options should be written as if they were arguments of a program, with a space between each other. The following options are available:
+The `test.ops` file can be used to specify some advanced low-level limits for the correction of the corresponding test case. The options should be written in a line as if they were arguments of a program, with a space between each other. The following options are available:
 
 - `--maxtime`: Sets maximum execution time. It has three values: `cputime`, `limtime`, and `clktime`. You can specify only the `cputime`, the `cputime` and the `limtime`, or all of them.
     - `cputime` is the maximum time that the program has to use the CPU (processing instructions).
@@ -390,6 +394,12 @@ The `test.ops` file can be used to specify some advanced low-level limits for th
 
 - `--maxcore`: Sets the maximum file size in MB of the core file (generated if the program crashes).
 
+Here is an example of a `test.ops` file:
+
+```
+--maxtime=10 --maxoutput=5
+```
+
 ## Solutions
 
 Each problem must have one golden solution and may have several alternative solutions in different programming languages. By default, the golden solution is C++, but can be changed in the `handler.yml` file with the `solution` field (e.g., `solution: Python3`).

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@jutge.org/toolkit",
     "description": "Toolkit to prepare problems for Jutge.org",
-    "version": "4.4.27",
+    "version": "4.4.28",
     "homepage": "https://jutge.org",
     "author": {
         "name": "Jutge.org",

package/toolkit/lint.ts

@@ -1,33 +1,46 @@
 import { Command } from '@commander-js/extra-typings'
 import chalk from 'chalk'
-import { lintDirectories, type LintIssue, type LintResult } from '../lib/lint'
+import { resolve } from 'path'
+import { lintDirectories, type LintIssue, type LintPassed, type LintResult } from '../lib/lint'
 import tui from '../lib/tui'
-import { nothing } from '../lib/utils'
 
 export function formatLintIssue(issue: LintIssue): string {
-    const prefix = issue.severity === 'error' ? chalk.red('error') : chalk.yellow('warning')
-    const path = issue.path ? chalk.gray(` (${issue.path})`) : ''
-    return `  ${prefix} ${issue.code}: ${issue.message}${path}`
+    // Pad path to 20 spaces, left-aligned file path before the code/info
+    const pathPart = issue.path ? chalk.gray(`${issue.path.padEnd(20, ' ')}`) : ' '.repeat(20);
+    const prefix = issue.severity === 'error' ? chalk.red('×') : chalk.yellow('⚠️');
+    return `${prefix} ${pathPart} ${issue.code}: ${issue.message}`;
 }
 
-export async function printLintResults(results: LintResult[], directories: string[]): Promise<{ hasError: boolean }> {
+export function formatLintPassed(passed: LintPassed): string {
+    // Pad path to 20 spaces, left-aligned file path before the code/info
+    const pathPart = passed.path ? chalk.gray(`${passed.path.padEnd(20, ' ')}`) : ' '.repeat(20);
+    return `${chalk.green('✓')} ${pathPart} ${passed.code}: ${passed.message}`;
+}
+
+
+export function printLintResults(
+    results: LintResult[],
+    directories: string[],
+    options?: { verbose?: boolean },
+): { hasError: boolean } {
+    const verbose = options?.verbose ?? false
     let hasError = false
     for (const result of results) {
         const errors = result.issues.filter((i) => i.severity === 'error')
         if (errors.length > 0) hasError = true
 
-        const dirLabel =
-            result.directory === directories[0] && results.length === 1 ? result.directory : result.directory
+        if (verbose && result.passed?.length) {
+            for (const p of result.passed) {
+                tui.print(formatLintPassed(p))
+            }
+        }
         if (result.issues.length === 0) {
-            tui.print(chalk.green('✓') + ' ' + dirLabel + ' ' + chalk.gray('— no issues'))
+            tui.success(`✅ No issues found in ${tui.hyperlink(resolve(result.directory))}`)
         } else {
-            tui.print()
-            await tui.section(`Linting ${dirLabel}`, async () => {
-                await nothing()
-                for (const issue of result.issues) {
-                    tui.print(formatLintIssue(issue))
-                }
-            })
+            for (const issue of result.issues) {
+                tui.print(formatLintIssue(issue))
+            }
+            tui.error(`❌ ${result.issues.length} issue(s) found in ${tui.hyperlink(resolve(result.directory))}`)
         }
     }
 
@@ -46,18 +59,17 @@ export async function printLintResults(results: LintResult[], directories: strin
 export const lintCmd = new Command('lint')
     .summary('Lint a problem directory')
 
-    .argument('[directory]', 'problem directory to lint', '.')
+    .option('-d, --directory <directory>', 'problem directory', '.')
+    .option('-v, --verbose', 'show all validations, including passed checks')
 
-    .action(async (directory: string) => {
-        const results = await lintDirectories([directory])
+    .action(async ({ directory, verbose }) => {
 
-        if (results.length === 0) {
-            tui.warning('No problem directories found (looked for handler.yml in the given path(s)).')
-            return
-        }
-
-        const { hasError } = await printLintResults(results, [directory])
-        if (hasError) {
-            process.exitCode = 1
-        }
+        await tui.section(`Linting ${tui.hyperlink(resolve(directory))}`, async () => {
+            const results = await lintDirectories([directory], { verbose })
+            if (results.length === 0) throw new Error('No problem directories found (looked for handler.yml in the given path(s)).')
+            const { hasError } = printLintResults(results, [directory], { verbose })
+            if (hasError) {
+                process.exitCode = 1
+            }
+        })
     })