Let the extension works

Yet there are several features missing

src/conn.ts

@@ -1,36 +1,4 @@
-export class Problem{
-    name?: string;
-    inputs?: string[];
-    outputs?: string[];
-
-    constructor(name?: string, inputs?: string[], outputs?: string[]){
-        this.name = name;
-        this.inputs = inputs;
-        this.outputs = outputs;
-    }
-}
-
-export class Contest{
-    problems?: Problem[];
-
-    constructor(problems?: Problem[]){
-        this.problems = problems;
-    }
-}
-
-export class SiteDescription{
-    name: string;
-    description: string;
-    contestParser: (contestId: string) => Contest;
-    problemParser: (problemId: string) => Problem;
-
-    constructor(name: string, description: string, contestParser: (contestId: string) => Contest, problemParser: (problemId: string) => Problem){
-        this.name = name;
-        this.description = description;
-        this.contestParser = contestParser;
-        this.problemParser = problemParser;
-    }
-}
+import { SiteDescription, Contest, Problem } from "./types";
 
 /**
  * Register a new site creating an entry in this dictionary.
@@ -44,32 +12,44 @@ export const SITES: SiteDescription[] = [
     new SiteDescription(
         "personal",
         "Not a site. Custom problems and contest.",
-        function(contestId: string) {
-            return new Contest();
-        },
-        function(problemId: string) {
-            return new Problem();
+        numProblems => {
+            let problems = [];
+
+            for (let i = 0; i < numProblems; i++) {
+                problems.push(new Problem(`P${i+1}`, ["0\n", "2\n", "9\n"], ["2\n", "4\n", "11\n"]));
+            }
+
+            return new Contest(problems);
         },
+        problemId => {
+            return new Problem("W", ["0\n", "2\n", "9\n"], ["2\n", "4\n", "11\n"]);
+        }
     ),
 
     new SiteDescription(
         "codeforces",
         "codeforces.com",
-        function(contestId: string) {
+        contestId => {
             return new Contest();
         },
-        function(problemId: string){
+        problemId => {
             return new Problem();
-        }
+        },
     ),
 ];
 
 export function getSite(site: string): SiteDescription  {
+    let result = undefined;
+
     SITES.forEach(siteDescription => {
         if (siteDescription.name === site){
-            return siteDescription;
+            result = siteDescription;
         }
     });
 
+    if (result !== undefined){
+        return result;
+    }
+
     throw new Error("Provided site is invalid");
 }

src/core.ts

@@ -1,10 +1,10 @@
 'use strict';
 import { mkdirSync, existsSync, copyFileSync, openSync, readSync, readdirSync, writeSync, closeSync } from "fs";
-import { dirname, join, extname, basename } from "path";
+import { dirname, join, extname } from "path";
 import * as child_process from 'child_process';
 import * as gwen from './gwen';
-import * as conn from './conn';
-import { TestcaseResult, Veredict, SolutionResult } from "./types";
+import { TestcaseResult, Veredict, SolutionResult, Problem, Contest } from "./types";
+import { getSite } from "./conn";
 
 export const TESTCASES = 'testcases';
 export const ATTIC = 'attic';
@@ -20,10 +20,6 @@ function createFolder(path: string){
     }
 }
 
-/**
- * TODO: Comment full code
- * Doc string
- */
 export function newArena(path: string){
     createFolder(path);
 
@@ -36,10 +32,23 @@ export function newArena(path: string){
     copyFileSync(join(SRC, 'static', 'sol.cpp'), join(path, 'sol.cpp'));
 }
 
+export function removeExtension(name: string){
+    let split = name.split('.');
+    if (split.length === 0){
+        return name;
+    }
+    else{
+        split.pop(); // drop extension
+        return split.join('.');
+    }
+}
+
 export function testcasesName(path: string){
     return readdirSync(join(path, TESTCASES)).
-            filter( function (tcpath) { return extname(tcpath) === '.in';}).
-            map( function(tcpath) { return tcpath.split('.')[0]; });
+            filter( function (tcpath) {
+                return extname(tcpath) === '.in';
+            }).
+            map( function(tcpath) { return removeExtension(tcpath); });
 }
 
 function testcases(path: string){
@@ -47,11 +56,11 @@ function testcases(path: string){
         let inp_fd = openSync(join(path, TESTCASES, `${name}.in`), 'r');
         let out_fd = openSync(join(path, TESTCASES, `${name}.out`), 'r');
 
-        let inp_buffer = new Buffer("");
-        let out_buffer = new Buffer("");
+        let inp_buffer = new Buffer(MAX_SIZE_INPUT);
+        let out_buffer = new Buffer(MAX_SIZE_INPUT);
 
-        readSync(inp_fd, inp_buffer, 0, 1 << 30, 0);
-        readSync(out_fd, out_buffer, 0, 1 << 30, 0);
+        readSync(inp_fd, inp_buffer, 0, MAX_SIZE_INPUT, 0);
+        readSync(out_fd, out_buffer, 0, MAX_SIZE_INPUT, 0);
 
         return [
             inp_buffer.toString(),
@@ -86,17 +95,7 @@ export function upgradeArena(path: string) {
     }
 }
 
-// TODO: Test
-function newProblemFromId(path: string, site: string, problemId: string){
-    let siteDesc = conn.getSite(site);
-
-    let problem = siteDesc.problemParser(problemId);
-
-    newProblem(path, problem);
-}
-
-// TODO: Test
-function newProblem(path: string, problem: conn.Problem){
+function newProblem(path: string, problem: Problem){
     newArena(path);
 
     problem.inputs!.forEach((value, index) => {
@@ -110,21 +109,32 @@ function newProblem(path: string, problem: conn.Problem){
     });
 }
 
-// TODO: Test
-function newContestFromId(path: string, site: string, contestId: string){
-    createFolder(path);
-    let siteDesc = conn.getSite(site);
-    let contest = siteDesc.contestParser(contestId);
-    newContest(path, contest);
+export function newProblemFromId(path: string, site: string, problemId: string){
+    let siteDesc = getSite(site);
+
+    let problem = siteDesc.problemParser(problemId);
+
+    newProblem(path, problem);
 }
 
-// TODO: Test
-function newContest(path: string, contest: conn.Contest){
+function newContest(path: string, contest: Contest){
     contest.problems!.forEach(problem => {
         newProblem(join(path, problem.name!), problem);
     });
 }
 
+/**
+ * Create a contest
+ *
+ * @param contestId Can be a number if the site is `personal` and this number denote number of problems
+ */
+export function newContestFromId(path: string, site: string, contestId: string | number){
+    createFolder(path);
+    let siteDesc = getSite(site);
+    let contest = siteDesc.contestParser(contestId);
+    newContest(path, contest);
+}
+
 export function timedRun(path: string, tcName: string, timeout = TESTCASE_TIMEOUT){
     let tcInput = join(path, TESTCASES, `${tcName}.in`);
     let tcOutput = join(path, TESTCASES, `${tcName}.out`);
@@ -174,7 +184,7 @@ export function timedRun(path: string, tcName: string, timeout = TESTCASE_TIMEOU
 }
 
 function compileCode(pathCode: string, pathOutput: string){
-    // # TODO: Avoid this hardcoded line. Use personalized compile line.
+    // # TODO: Avoid this hardcoded line. Use personalized compile line. increase stack by default
     return child_process.spawnSync("g++", ["-std=c++11", `${pathCode}`, "-o", `${pathOutput}`]);
 }
 
@@ -196,24 +206,32 @@ export function testSolution(path: string){
     let testcasesId = testcasesName(path);
     testcasesId.sort(); // Proccess all testcases in sorted order
 
+    console.log("Test Solution at: ", testcasesId);
+
     let results = [];
+    let fail = undefined;
 
     testcasesId.forEach(tcId => {
         let tcResult = timedRun(path, tcId);
 
         if (tcResult.status !== Veredict.OK){
-            return new SolutionResult(tcResult.status, tcId);
+            fail = new SolutionResult(tcResult.status, tcId);
         }
 
         results.push(tcResult);
     });
 
-    // TODO: Report max time and maybe other stats. Same with stress
-    return new SolutionResult(Veredict.OK);
+    if (fail === undefined){
+        // TODO: IMPORTANT: Report max time and maybe other stats. Same with stress
+        return new SolutionResult(Veredict.OK);
+    }
+    else{
+        return fail;
+    }
 }
 
 function generateTestcase(path: string){
-    // TODO: Revisit this call to python3. How to make it cross platform
+    // TODO: NILOX: Revisit this call to python3. How to make it cross platform
     let genResult = child_process.spawnSync("python3", [join(path, ATTIC, 'gen.py')]);
 
     let currentFd = openSync(join(path, TESTCASES, 'gen.in'), 'w');
@@ -260,7 +278,7 @@ export function stressSolution(path: string, times: number = 10){
         closeSync(inputFd);
 
         // Run without restrictions
-        // TODO: Restrict brute in time, and capture errors
+        // TODO: EASY: Restrict brute in time, and capture errors
         let runResult = child_process.spawnSync(brout, {
             input: tcData,
         });
@@ -282,4 +300,26 @@ export function stressSolution(path: string, times: number = 10){
 
     // TODO: Check testSolution comment on this point
     return new SolutionResult(Veredict.OK);
+}
+
+export function veredictName(veredict: Veredict){
+    switch (veredict) {
+        case Veredict.OK:
+            return "OK";
+
+        case Veredict.WA:
+            return "WA";
+
+        case Veredict.TLE:
+            return "TLE";
+
+        case Veredict.RTE:
+            return "RTE";
+
+        case Veredict.CE:
+            return "CE";
+
+        default:
+            throw new Error("Invalid Veredict");
+    }
 }

src/extension.ts

@@ -2,16 +2,16 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
-import { exec } from 'child_process';
-import { existsSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
+import { existsSync, writeFileSync, readdirSync } from 'fs';
+import { join, dirname, extname } from 'path';
 import { SITES } from './conn';
+import { newContestFromId, testSolution, veredictName, stressSolution, upgradeArena, newProblemFromId, removeExtension } from './core';
+import { Veredict } from './types';
 
 /**
- * TODO: IMPORTANT: Move acmh to typescript.
  * TODO: Add several checkers and try to infer which is the correct! [*]
  * TODO: Smart ID detection while parsing ContestId & ProblemId [*]
- * TODO: Find great name/slogan!!! Competitive Programming made simple
+ * TODO: Find great name/slogan!!! other than acmhelper Competitive Programming made simple
  * TODO: Change mock for personal -> Allow user choose number of problems while creating personal contest
  * TODO: Implement parser for codeforces to test on real cases
  * TODO: Learn how to move static files from `src` to `out`.
@@ -20,49 +20,45 @@ import { SITES } from './conn';
  * [*] Machine Learning?
  */
 
-// TODO: Erase this. After testing, to avoid catastrophical forgetting.
-// const SITES = [
-//     { label: 'Codeforces', target: 'codeforces' },
-//     { label: 'Mock', description: 'Fake site for experimentation', target: 'mock' },
-// ];
-
 const TESTCASES = 'testcases';
-const ATTIC = 'attic';
 
-function is_problem_folder(path: string) {
+function isProblemFolder(path: string) {
     return  existsSync(join(path, 'sol.cpp')) &&
             existsSync(join(path, 'attic'));
 }
 
-function current_problem() {
+function currentProblem() {
+    // Try to find the problem using current open file
     if (vscode.window.activeTextEditor){
         let path = vscode.window.activeTextEditor.document.uri.path;
 
         const MAX_DEPTH = 3;
 
-        for (let i = 0; i < MAX_DEPTH && !is_problem_folder(path); i++) {
+        for (let i = 0; i < MAX_DEPTH && !isProblemFolder(path); i++) {
             path = dirname(path);
         }
 
-        if (is_problem_folder(path)){
+        if (isProblemFolder(path)){
             return path;
         }
     }
 
+    // Try to find the problem using the current open workspace folder
     if (vscode.workspace.workspaceFolders !== undefined){
         let path = vscode.workspace.workspaceFolders[0].uri.path;
 
         const MAX_DEPTH = 1;
 
-        for (let i = 0; i < MAX_DEPTH && !is_problem_folder(path); i++) {
+        for (let i = 0; i < MAX_DEPTH && !isProblemFolder(path); i++) {
             path = dirname(path);
         }
 
-        if (is_problem_folder(path)){
+        if (isProblemFolder(path)){
             return path;
         }
     }
 
+    // Problem not found
     return undefined;
 }
 
@@ -81,7 +77,7 @@ function quickPickSites() {
 }
 
 // Create a new problem
-async function add_problem() {
+async function addProblem() {
     if (vscode.workspace.workspaceFolders === undefined) {
         vscode.window.showErrorMessage("Open the folder that will contain the problem.");
         return;
@@ -98,7 +94,7 @@ async function add_problem() {
 
     let site = site_info.target;
 
-    // TODO: Provide custom problem id example in placeholder per different site
+    // TODO: IMPORTANT: Provide custom problem id example in placeholder per different site
     let id = await vscode.window.showInputBox({placeHolder: "Problem ID"});
 
     if (id === undefined){
@@ -108,18 +104,16 @@ async function add_problem() {
 
     path = join(path, `${id}`);
 
-    let command = `acmh problem ${site} ${id} -p ${path}`;
+    newProblemFromId(path, site, id);
 
-    await exec(command, async function(error, stdout, stderr) {
-        await vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(path));
-        // TODO: How can I have access to new proccess created using `openFolder`?
-        // Just want to run two commands below
-        // await vscode.commands.executeCommand("vscode.open", vscode.Uri.file("sol.cpp"));
-        // vscode.window.showInformationMessage(`Add problem ${site}/${id} at ${path}`);
-    });
+    await vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(path));
+    // TODO: How can I have access to new proccess created using `openFolder`?
+    // Just want to run two commands below
+    // await vscode.commands.executeCommand("vscode.open", vscode.Uri.file("sol.cpp"));
+    // vscode.window.showInformationMessage(`Add problem ${site}/${id} at ${path}`);
 }
 
-async function add_contest() {
+async function addContest() {
     if (vscode.workspace.workspaceFolders === undefined) {
         vscode.window.showErrorMessage("Open the folder that will contain the contest.");
         return;
@@ -135,86 +129,105 @@ async function add_contest() {
     }
 
     let site = site_info.target;
+    let id = undefined;
 
-    // TODO: Provide custom contest id example in placeholder per different site
-    let id = await vscode.window.showInputBox({placeHolder: "Contest ID"});
+    if (site === "personal"){
+        let name= await vscode.window.showInputBox({placeHolder: "Contest Name"});
 
-    if (id === undefined){
-        vscode.window.showErrorMessage("Contest ID not provided.");
-        return;
+        if (name === undefined){
+            vscode.window.showErrorMessage("Name not provided.");
+            return;
+        }
+
+        path = join(path, name);
+
+        let probCountStr = await vscode.window.showInputBox({placeHolder: "Number of problems"});
+
+        if (name === undefined){
+            vscode.window.showErrorMessage("Number of problems not provided.");
+            return;
+        }
+
+        id = Number.parseInt(probCountStr!);
     }
+    else{
+        // TODO: IMPORTANT: Provide custom contest id example in placeholder per different site
+        id = await vscode.window.showInputBox({placeHolder: "Contest ID"});
 
-    path = join(path, `${id}`);
+        if (id === undefined){
+            vscode.window.showErrorMessage("Contest ID not provided.");
+            return;
+        }
 
-    let command = `acmh contest ${site} ${id} -p ${path}`;
+        path = join(path, `${id}`);
+    }
 
-    await exec(command, async function(error, stdout, stderr) {
-        await vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(path));
-    });
+    newContestFromId(path, site, id);
+
+    vscode.commands.executeCommand("vscode.openFolder", vscode.Uri.file(path));
 }
 
-async function run_solution(){
-    let path = current_problem();
+async function debugTestcase(path: string, tcId: string){
+    // Change editor layout to show failing test
+    await vscode.commands.executeCommand("vscode.setEditorLayout", { orientation: 0, groups: [{ groups: [{}], size: 0.5 }, { groups: [{}, {}, {}], size: 0.5 }] });
+
+    let sol = join(path, `sol.cpp`);
+    let inp = join(path, TESTCASES, `${tcId}.in`);
+    let out = join(path, TESTCASES, `${tcId}.out`);
+    let cur = join(path, TESTCASES, `${tcId}.cur`);
+
+    // TODO: How to clear opened tabs?
+    await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(sol), vscode.ViewColumn.One);
+    await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(inp), vscode.ViewColumn.Two);
+    await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(out), vscode.ViewColumn.Three);
+
+    // This file might not exist!
+    if (existsSync(cur)){
+        await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(cur), vscode.ViewColumn.Four);
+    }
+}
+
+async function runSolution(){
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
         return;
     }
 
-    let command = `acmh run -p ${path}`;
+    let result = testSolution(path);
 
-    await exec(command, async function(error, stdout, stderr) {
-        let lines = stdout.split('\n');
-
-        if (lines[0] === 'ok'){
-            vscode.window.showInformationMessage("OK!");
-        }
-        else{
-            vscode.window.showErrorMessage(`${lines[0]} on test ${lines[1]}`);
-            await vscode.commands.executeCommand("vscode.setEditorLayout", { orientation: 0, groups: [{ groups: [{}], size: 0.5 }, { groups: [{}, {}, {}], size: 0.5 }] });
-
-            // This is always true
-            if (path !== undefined){
-                let testid = lines[1];
-                let sol = join(path, `sol.cpp`);
-                let inp = join(path, TESTCASES, `${testid}.in`);
-                let out = join(path, TESTCASES, `${testid}.out`);
-                let cur = join(path, TESTCASES, `${testid}.cur`);
-
-                // TODO: How to clear opened tabs?
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(sol), vscode.ViewColumn.One);
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(inp), vscode.ViewColumn.Two);
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(out), vscode.ViewColumn.Three);
-
-                // This file might not exist!
-                if (existsSync(cur)){
-                    await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(cur), vscode.ViewColumn.Four);
-                }
-            }
-        }
-    });
+    if (result.status === Veredict.OK){
+        vscode.window.showInformationMessage("OK");
+    }
+    else{
+        vscode.window.showErrorMessage(`${veredictName(result.status)} on test ${result.failTcId}`);
+        debugTestcase(path, result.failTcId!);
+    }
 }
 
-async function open_testcase() {
-    let path = current_problem();
+async function openTestcase() {
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
         return;
     }
 
-    let tcs = [];
+    let tcs: any[] = [];
 
-    // TODO: How to listdir in typescript?
-    let num = 0;
-    while (existsSync(join(path, TESTCASES, `${num}.in`))){
-        tcs.push({
-            'label' : `${num}`,
-            'target' : `${num}`
-        });
+    // Read testcases
+    readdirSync(join(path, TESTCASES)).
+        filter( function (tcpath) {
+            return extname(tcpath) === '.in';}).
+        map( function(tcpath) {
+            let name = removeExtension(tcpath);
 
-        num += 1
-    }
+            tcs.push({
+                'label' : name,
+                'target' : name,
+            });
+        });
 
     let tc = await vscode.window.showQuickPick(tcs, { placeHolder: 'Select testcase' });
 
@@ -228,8 +241,8 @@ async function open_testcase() {
     }
 }
 
-async function add_testcase() {
-    let path = current_problem();
+async function addTestcase() {
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
@@ -253,7 +266,7 @@ async function add_testcase() {
 }
 
 async function coding() {
-    let path = current_problem();
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
@@ -269,59 +282,33 @@ async function coding() {
 
 // TODO: Show time that the program took when it's ok
 async function stress(){
-    let path = current_problem();
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
         return;
     }
 
-    let command = `acmh stress -p ${path}`;
-
-    await exec(command, async function(error, stdout, stderr) {
-        let lines = stdout.split('\n');
+    let result = stressSolution(path);
 
-        if (lines[0] === 'ok'){
-            vscode.window.showInformationMessage("OK!");
-        }
-        else{
-            vscode.window.showErrorMessage(`${lines[0]} on test ${lines[1]}`);
-            await vscode.commands.executeCommand("vscode.setEditorLayout", { orientation: 0, groups: [{ groups: [{}], size: 0.5 }, { groups: [{}, {}, {}], size: 0.5 }] });
-
-            // This is always true
-            if (path !== undefined){
-                let testid = lines[1];
-                let sol = join(path, `sol.cpp`);
-                let inp = join(path, TESTCASES, `${testid}.in`);
-                let out = join(path, TESTCASES, `${testid}.out`);
-                let cur = join(path, TESTCASES, `${testid}.cur`);
-
-                // TODO: How to clear opened tabs?
-
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(sol), vscode.ViewColumn.One);
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(inp), vscode.ViewColumn.Two);
-                await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(out), vscode.ViewColumn.Three);
-
-                // This file might not exist!
-                if (existsSync(cur)){
-                    await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(cur), vscode.ViewColumn.Four);
-                }
-            }
-        }
-    });
+    if (result.status === Veredict.OK){
+        vscode.window.showInformationMessage("OK");
+    }
+    else{
+        vscode.window.showErrorMessage(`${veredictName(result.status)} on test ${result.failTcId}`);
+        debugTestcase(path, result.failTcId!);
+    }
 }
 
 async function upgrade(){
-    let path = current_problem();
+    let path = currentProblem();
 
     if (path === undefined){
         vscode.window.showErrorMessage("No active problem");
         return;
     }
 
-    let command = `acmh add --brute --gen -p ${path}`;
-
-    await exec(command, async function(error, stdout, stderr) { });
+    upgradeArena(path);
 }
 
 // this method is called when your extension is activated
@@ -329,23 +316,23 @@ async function upgrade(){
 export function activate(context: vscode.ExtensionContext) {
     console.log('Congratulations, your extension "acmhelper-vscode" is now active!');
 
-    let add_problem_commmand = vscode.commands.registerCommand('extension.addProblem', add_problem);
-    let add_contest_command = vscode.commands.registerCommand('extension.addContest', add_contest);
-    let run_solution_command = vscode.commands.registerCommand('extension.runSolution', run_solution);
-    let open_testcase_command = vscode.commands.registerCommand('extension.openTestcase', open_testcase);
-    let add_testcase_command = vscode.commands.registerCommand('extension.addTestcase', add_testcase);
-    let coding_command = vscode.commands.registerCommand('extension.coding', coding);
-    let stress_command = vscode.commands.registerCommand('extension.stress', stress);
-    let upgrade_command = vscode.commands.registerCommand('extension.upgrade', upgrade);
-
-    context.subscriptions.push(add_problem_commmand);
-    context.subscriptions.push(add_contest_command);
-    context.subscriptions.push(run_solution_command);
-    context.subscriptions.push(open_testcase_command);
-    context.subscriptions.push(add_testcase_command);
-    context.subscriptions.push(coding_command);
-    context.subscriptions.push(stress_command);
-    context.subscriptions.push(upgrade_command);
+    let addProblemCommand = vscode.commands.registerCommand('extension.addProblem', addProblem);
+    let addContestCommand = vscode.commands.registerCommand('extension.addContest', addContest);
+    let runSolutionCommand = vscode.commands.registerCommand('extension.runSolution', runSolution);
+    let openTestcaseCommand = vscode.commands.registerCommand('extension.openTestcase', openTestcase);
+    let addTestcaseCommand = vscode.commands.registerCommand('extension.addTestcase', addTestcase);
+    let codingCommand = vscode.commands.registerCommand('extension.coding', coding);
+    let stressCommand = vscode.commands.registerCommand('extension.stress', stress);
+    let upgradeCommand = vscode.commands.registerCommand('extension.upgrade', upgrade);
+
+    context.subscriptions.push(addProblemCommand);
+    context.subscriptions.push(addContestCommand);
+    context.subscriptions.push(runSolutionCommand);
+    context.subscriptions.push(openTestcaseCommand);
+    context.subscriptions.push(addTestcaseCommand);
+    context.subscriptions.push(codingCommand);
+    context.subscriptions.push(stressCommand);
+    context.subscriptions.push(upgradeCommand);
 }
 
 // this method is called when your extension is deactivated

src/test/extension.test.ts

@@ -6,19 +6,13 @@
 // The module 'assert' provides assertion methods from node
 import * as assert from 'assert';
 import { dirname, join } from 'path';
-import { timedRun, testcasesName, testSolution, newArena, ATTIC, TESTCASES, upgradeArena, stressSolution } from '../core';
+import { timedRun, testcasesName, testSolution, newArena, ATTIC, TESTCASES, upgradeArena, stressSolution, newProblemFromId, newContestFromId } from '../core';
 import { TestcaseResult, Veredict } from '../types';
-import { exists, rmdir, rmdirSync, existsSync, fstat, readdirSync, Stats, unlink, unlinkSync, openSync, writeSync, closeSync, write } from 'fs';
+import { rmdirSync, existsSync, readdirSync, unlinkSync, openSync, writeSync, closeSync } from 'fs';
 
 const SRC = join(dirname(dirname(dirname(__filename))), 'src', 'test');
 const ARENA = join(SRC, 'arena');
 
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-// import * as vscode from 'vscode';
-// import * as myExtension from '../extension';
-
-// Defines a Mocha test suite to group tests of similar kind together
 suite("Extension Tests", function () {
     /**
      * Recursive remove
@@ -100,6 +94,30 @@ suite("Extension Tests", function () {
         result.forEach(name => {assert.notEqual(target.findIndex(tname => { return tname === name; }), -1);});
     });
 
+    /**
+     * core::newProblem
+     */
+    test("newProblemFromId", function(){
+        let path = join(ARENA);
+        let problemId = 'testProblemFromId';
+        newProblemFromId(join(path, problemId), 'personal', problemId);
+
+        assert.equal(existsSync(join(path, problemId, 'sol.cpp')), true);
+        assert.equal(existsSync(join(path, problemId, ATTIC)), true);
+        assert.equal(existsSync(join(path, problemId, TESTCASES)), true);
+        assert.equal(readdirSync(join(path, problemId, TESTCASES)).length, 6);
+    });
+
+    /**
+     * core::newProblem
+     */
+    test("newContestFromId", function(){
+        let path = join(ARENA);
+        let contestId = 'testContestFromId';
+        newContestFromId(join(path, contestId), 'personal', 5);
+        assert.equal(readdirSync(join(path, contestId)).length, 5);
+    });
+
     /**
      * core::timedRun
      *

src/types.ts

@@ -1,7 +1,3 @@
-/**
- * TODO: Move all custom types to this folder
- */
-
 export enum Veredict{
     OK,     // Accepted
     WA,     // Wrong Answer
@@ -28,4 +24,38 @@ export class SolutionResult{
         this.status = status;
         this.failTcId = failTcId;
     }
+}
+
+export class Problem{
+    name?: string;
+    inputs?: string[];
+    outputs?: string[];
+
+    constructor(name?: string, inputs?: string[], outputs?: string[]){
+        this.name = name;
+        this.inputs = inputs;
+        this.outputs = outputs;
+    }
+}
+
+export class Contest{
+    problems?: Problem[];
+
+    constructor(problems?: Problem[]){
+        this.problems = problems;
+    }
+}
+
+export class SiteDescription{
+    name: string;
+    description: string;
+    contestParser: (contestId: string | number) => Contest;
+    problemParser: (problemId: string) => Problem;
+
+    constructor(name: string, description: string, contestParser: (contestId: string | number) => Contest, problemParser: (problemId: string) => Problem){
+        this.name = name;
+        this.description = description;
+        this.contestParser = contestParser;
+        this.problemParser = problemParser;
+    }
 }