Merge pull request #52 from chermehdi/custom/templates

Add custom template support

Author: chermehdi

README.md

@@ -10,7 +10,7 @@ and help execute tests locally via their favorite programming language.
 - There are two ways for installing egor.
 
 ### Download compiled binary
-- You can download the binary that corresponds to your operating system and add it to your `PATH` variable, you can find the binaries in the [releases](https://github.com/chermehdi/go-egor/releases) page.
+- You can download the binary corresponding to your operating system and add it to your `PATH` variable, you can find the binaries in the [releases](https://github.com/chermehdi/go-egor/releases) page.
 - For people running Mac OSX Catalina, this won't work and you will be forced to go with the Build from source solution.
 
 ### Build from source
@@ -68,6 +68,62 @@ $ egor config set cpp.lib.location
 $ ls /home/directory/include
 kratos
 ``` 
+
+## Custom templates
+
+- Egor also support the use of custom templates per each language, powered by the golang template engine. to take full advantage of it you can
+take a look at all the details in the official [documentation](https://golang.org/pkg/text/template/).
+
+- A typical configuration for a template, is the following: 
+```
+//
+// {{ if .Problem}} {{ .Problem }} {{ end }} {{ if .Url }} {{ .Url }} {{ end }}
+{{- if .Author }}
+// @author {{ .Author }}
+// created {{ .Time }}
+{{- end }}
+// 
+#include <iostream>
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <map>
+
+using namespace std;
+{{ if .MultipleTestCases }}
+void solve() {
+}
+{{ end }}
+
+int main() {
+  {{- if .FastIO }}
+  ios_base::sync_with_stdio(false);
+  cin.tie(0);
+  {{- end}}
+
+  {{- if .MultipleTestCases }}
+  int t; cin >> t;
+  while(t--) {
+    solve();
+  }
+  {{- end}}
+}
+```
+Each template is provided by a model containing some basic information about the task that is going to be generated
+to help create dynamic templates, the model reference is
+```go
+type TemplateContext struct {
+	Author            string
+	Time              string
+	MultipleTestCases bool
+	Interactive       bool
+	FastIO            bool
+	Problem           string
+	Url               string
+}
+```
+You can access any of the model fields in the template, and make changes accordingly dependending on your preferences.
+- Running the command `egor config set config.templates.{lang} /path/to/template/file` will register the given template and will use it for the given language for future tasks.
 ## Contribution
 
 - Contribution to the project can be done in multiple ways, you can report bugs and issues or you can discuss new features that you like being added in future versions by creating a new issue

commands/config.go

@@ -26,6 +26,9 @@ func UpdateConfiguration(config *config.Config, key, value string) error {
 		config.Author = value
 	} else if lowerKey == "cpp.lib.location" {
 		config.CppLibraryLocation = value
+	} else if strings.HasPrefix(key, "custom.template") {
+		lang := key[strings.LastIndex(key, ".")+1:]
+		config.CustomTemplate[lang] = value
 	} else {
 		// Unknow key
 		return errors.New(fmt.Sprintf("Unknown configuration property %s", key))
@@ -74,6 +77,10 @@ func GetAction(context *cli.Context) error {
 		color.Green("lang.default    \t\t %s\n", configuration.Lang.Default)
 		color.Green("author          \t\t %s\n", configuration.Author)
 		color.Green("cpp.lib.location\t\t %s\n", configuration.CppLibraryLocation)
+		color.Green("config.templates: \n\n")
+		for k, v := range configuration.CustomTemplate {
+			color.Green("\t%s\t\t %s\n", k, v)
+		}
 		return nil
 	} else {
 		value, err := config.GetConfigurationValue(configuration, context.Args().First())

commands/create.go

@@ -125,7 +125,7 @@ func CreateTaskAction(context *cli.Context) error {
 			return err
 		}
 	}
-	location, err := CreateDirectoryStructure(task, *configuration, curDir)
+	location, err := CreateDirectoryStructure(task, *configuration, curDir, nil)
 	if err != nil {
 		return err
 	}

commands/parse.go

@@ -31,7 +31,7 @@ func SerializeTask(meta EgorMeta) (string, error) {
 	return buffer.String(), nil
 }
 
-func CreateDirectoryStructure(task Task, config Config, rootDir string) (string, error) {
+func CreateDirectoryStructure(task Task, config Config, rootDir string, context *cli.Context) (string, error) {
 	taskDir := path.Join(rootDir, task.Name)
 	if err := os.Mkdir(taskDir, 0777); err != nil {
 		return "", err
@@ -78,7 +78,7 @@ func CreateDirectoryStructure(task Task, config Config, rootDir string) (string,
 			return "", err
 		}
 	}
-	templateContent, err := templates.ResolveTemplateByLanguage(config.Lang.Default)
+	templateContent, err := templates.ResolveTemplateByLanguage(config)
 	if err != nil {
 		return "", err
 	}
@@ -91,7 +91,10 @@ func CreateDirectoryStructure(task Task, config Config, rootDir string) (string,
 	if err != nil {
 		return "", err
 	}
-	if err = compiledTemplate.Execute(taskFile, config); err != nil {
+	templateContext := CreateTemplateContext(config, task)
+	templateContext.MultipleTestCases = context.Bool("multiple")
+	templateContext.FastIO = context.Bool("fast-io")
+	if err = compiledTemplate.Execute(taskFile, templateContext); err != nil {
 		return "", err
 	}
 	return taskDir, nil
@@ -141,7 +144,7 @@ func waitForShutDown(server *http.Server, done chan<- string, quit <-chan string
 	done <- content
 }
 
-func ParseAction(_ *cli.Context) error {
+func ParseAction(context *cli.Context) error {
 	msgReceiveChannel := make(chan string, 1)
 	msgReadChannel := make(chan string, 1)
 
@@ -170,7 +173,7 @@ func ParseAction(_ *cli.Context) error {
 	if err != nil {
 		return err
 	}
-	taskDir, err := CreateDirectoryStructure(*task, *config, cwd)
+	taskDir, err := CreateDirectoryStructure(*task, *config, cwd, context)
 	if err != nil {
 		color.Red("Error happened %v", err)
 		return err
@@ -185,8 +188,22 @@ func ParseAction(_ *cli.Context) error {
 // and an additional `egor-meta.json` file, and finally your task file, which is usually a `main.cpp` or `Main.java`
 // file depending on the default configured language.
 var ParseCommand = cli.Command{
-	Name:      "parse",
-	Aliases:   []string{"p"},
+	Name:    "parse",
+	Aliases: []string{"p"},
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "fast-io",
+			Usage:   "Indicates that this task will require the use of Fast IO",
+			Aliases: []string{"io", "fio"},
+			Value:   false,
+		},
+		&cli.BoolFlag{
+			Name:    "multiple",
+			Usage:   "Indicates if this task has multiple test cases",
+			Aliases: []string{"m", "mul"},
+			Value:   false,
+		},
+	},
 	Usage:     "Parse task from navigator",
 	UsageText: "egor parse",
 	Action:    ParseAction,

commands/parse_test.go

@@ -87,7 +87,7 @@ func TestCreateDirectoryStructure(t *testing.T) {
 	CreateDirectory(rootDir)
 	defer DeleteDir(rootDir)
 
-	_, err := CreateDirectoryStructure(task, configuration, rootDir)
+	_, err := CreateDirectoryStructure(task, configuration, rootDir, nil)
 	assert.NoError(t, err)
 
 	taskDir := path.Join(rootDir, task.Name)

config/config.go

@@ -27,6 +27,9 @@ type Config struct {
 	Version            string `yaml:"version"`
 	Author             string `yaml:"author"`
 	CppLibraryLocation string `yaml:"cpp_lib_location"`
+	// Should contain template locations per programming language code
+	// The expected format is: cpp -> /path/to/template_cpp.template
+	CustomTemplate map[string]string `yaml:"custom_template"`
 }
 
 func (conf *Config) HasCppLibrary() bool {
@@ -57,6 +60,7 @@ func createDefaultConfiguration() *Config {
 		Version:            LatestVersion,
 		ConfigFileName:     "egor-meta.json",
 		CppLibraryLocation: path.Join(homeDir, "include"),
+		CustomTemplate:     make(map[string]string),
 	}
 }
 

config/task.go

@@ -1,5 +1,7 @@
 package config
 
+import "time"
+
 // Represents a Competitive programming task's input and output for a some test case.
 type TestCase struct {
 	Input  string
@@ -33,3 +35,28 @@ type Task struct {
 	Output      IOType
 	Languages   map[string]LanguageDescription
 }
+
+// Template parameters
+// This type will hold all the available information to the templates loaded by the user
+type TemplateContext struct {
+	Author            string
+	Time              string
+	MultipleTestCases bool
+	Interactive       bool
+	FastIO            bool
+	Problem           string
+	Url               string
+}
+
+// Creates a new template context from the configuration and the task metadata
+func CreateTemplateContext(config Config, task Task) TemplateContext {
+	return TemplateContext{
+		Author:            config.Author,
+		Time:              time.Now().Format(time.UnixDate),
+		MultipleTestCases: false,
+		Interactive:       false,
+		FastIO:            false,
+		Problem:           task.Name,
+		Url:               task.Url,
+	}
+}

templates/resolver.go

@@ -3,6 +3,8 @@ package templates
 import (
 	"errors"
 	"fmt"
+	"github.com/chermehdi/egor/config"
+	"io/ioutil"
 )
 
 const CppTemplate = `
@@ -57,7 +59,20 @@ const PythonTemplate = `
 # {{end}}
 `
 
-func ResolveTemplateByLanguage(lang string) (string, error) {
+func ResolveTemplateByLanguage(config config.Config) (string, error) {
+	templates := config.CustomTemplate
+	path, has := templates[config.Lang.Default]
+	if !has {
+		return resolveWithDefaultTemplate(config.Lang.Default)
+	}
+	content, err := ioutil.ReadFile(path)
+	if err != nil {
+		return "", err
+	}
+	return string(content), nil
+}
+
+func resolveWithDefaultTemplate(lang string) (string, error) {
 	switch lang {
 	case "cpp":
 		return CppTemplate, nil

templates/resolver_test.go

@@ -1,31 +1,89 @@
 package templates
 
 import (
+	"github.com/chermehdi/egor/config"
+	"io/ioutil"
+	"os"
+	"path"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 )
 
+const TempJavaTemplate = `
+	import java.util.*;
+	class Solution {
+		public static void main(String[] args) {
+		}
+	}
+`
+const TempCppTemplate = `
+	#include <bits/stdc++.h>
+	using namespace std;
+
+	int main() {
+		ios_base::sync_with_stdio(false);
+		cin.tie(0);
+    }
+`
+
 func TestResolveTemplateByLanguageJava(t *testing.T) {
-	temp, err := ResolveTemplateByLanguage("java")
-	assert.NoError(t, err)
-	assert.Equal(t, JavaTemplate, temp)
+	testResolveTemplate(t, "java", JavaTemplate)
 }
 
 func TestResolveTemplateByLanguagePython(t *testing.T) {
-	temp, err := ResolveTemplateByLanguage("python")
-	assert.NoError(t, err)
-	assert.Equal(t, PythonTemplate, temp)
+	testResolveTemplate(t, "python", PythonTemplate)
 }
 
 func TestResolveTemplateByLanguageCpp(t *testing.T) {
-	temp, err := ResolveTemplateByLanguage("cpp")
-	assert.NoError(t, err)
-	assert.Equal(t, CppTemplate, temp)
+	testResolveTemplate(t, "cpp", CppTemplate)
 }
 
-func TestResolveTemplateByLanguageUnknow(t *testing.T) {
-	temp, err := ResolveTemplateByLanguage("dummy")
+func TestResolveTemplateByLanguageUnknown(t *testing.T) {
+	//testResolveTemplate(t, "dummy")
+	configuration := config.Config{
+		Lang: struct {
+			Default string `yaml:"default"`
+		}{Default: "dummy"},
+	}
+	temp, err := ResolveTemplateByLanguage(configuration)
 	assert.Error(t, err)
 	assert.Empty(t, temp)
 }
+
+func TestResolveTemplateByLanguage_CustomTemplateCpp(t *testing.T) {
+	testResolveFromMap(t, "cpp", CppTemplate)
+}
+
+func TestResolveTemplateByLanguage_CustomTemplateJava(t *testing.T) {
+	testResolveFromMap(t, "java", TempJavaTemplate)
+}
+
+func testResolveFromMap(t *testing.T, lang string, expectedTemplate string) {
+	tempDir := os.TempDir()
+	filePath := path.Join(tempDir, "config_template.template")
+	err := ioutil.WriteFile(filePath, []byte(expectedTemplate), 0777)
+	assert.NoError(t, err)
+	defer os.Remove(filePath)
+
+	configuration := config.Config{
+		Lang: struct {
+			Default string `yaml:"default"`
+		}{Default: lang},
+		CustomTemplate: map[string]string{lang: filePath},
+	}
+	fileTemplate, err := ResolveTemplateByLanguage(configuration)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedTemplate, fileTemplate)
+}
+
+func testResolveTemplate(t *testing.T, lang, expected string) {
+	configuration := config.Config{
+		Lang: struct {
+			Default string `yaml:"default"`
+		}{Default: lang},
+	}
+	temp, err := ResolveTemplateByLanguage(configuration)
+	assert.NoError(t, err)
+	assert.Equal(t, temp, expected)
+}