working parse version

Author: chermehdi

commands/parse.go

@@ -1,17 +1,194 @@
 package commands
 
 import (
+	"bytes"
+	"context"
+	json2 "encoding/json"
 	"fmt"
+	. "github.com/chermehdi/egor/config"
+	"github.com/chermehdi/egor/templates"
+	"github.com/fatih/color"
 	"github.com/urfave/cli/v2"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+	template2 "text/template"
+	"time"
 )
 
-var ParseCommand cli.Command = cli.Command{
+const listenAddr = ":4243"
+
+// Serialize task into a JSON string.
+func SerializeTask(meta EgorMeta) (string, error) {
+	var buffer bytes.Buffer
+	encoder := json2.NewEncoder(&buffer)
+	if err := encoder.Encode(meta); err != nil {
+		return "", err
+	}
+	return buffer.String(), nil
+}
+
+func CreateFile(filePath string) (*os.File, error) {
+	return os.OpenFile(filePath, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0777)
+}
+
+func CreateDirectoryStructure(task Task, config Config) error {
+	dir, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	taskDir := path.Join(dir, task.Name)
+	if err = os.Mkdir(taskDir, 0777); err != nil {
+		return err
+	}
+	if err = os.Chdir(taskDir); err != nil {
+		return err
+	}
+	egorMeta := NewEgorMeta(task, config)
+
+	file, err := CreateFile(config.ConfigFileName)
+	if err != nil {
+		return err
+	}
+	if err = egorMeta.Save(file); err != nil {
+		return err
+	}
+	if err = os.Mkdir("inputs", 0777); err != nil {
+		return err
+	}
+
+	if err = os.Mkdir("outputs", 0777); err != nil {
+		return err
+	}
+	inputs := egorMeta.Inputs
+	for i := 0; i < len(inputs); i++ {
+		file, err := CreateFile(inputs[i].Path)
+		if err != nil {
+			return err
+		}
+		_, err = file.WriteString(task.Tests[i].Input)
+		if err != nil {
+			return err
+		}
+	}
+
+	outputs := egorMeta.Outputs
+	for i := 0; i < len(outputs); i++ {
+		file, err := CreateFile(outputs[i].Path)
+		if err != nil {
+			return err
+		}
+		_, err = file.WriteString(task.Tests[i].Output)
+		if err != nil {
+			return err
+		}
+	}
+	templateContent, err := templates.ResolveTemplateByLanguage(config.Lang.Default)
+	if err != nil {
+		return err
+	}
+	template := template2.New("Solution template")
+	compiledTemplate, err := template.Parse(templateContent)
+	if err != nil {
+		return err
+	}
+	taskFile, err := CreateFile(egorMeta.TaskFile)
+	if err != nil {
+		return err
+	}
+	if err = compiledTemplate.Execute(taskFile, config); err != nil {
+		return err
+	}
+	return nil
+}
+
+// Given the json string returned by competitive companion
+// it will parse it as a json Task and return it.
+func extractTaskFromJson(json string) (*Task, error) {
+	var task Task
+	err := json2.Unmarshal([]byte(json), &task)
+	if err != nil {
+		return nil, err
+	}
+	return &task, nil
+}
+
+func createWebServer(quit chan<- string) *http.Server {
+	router := http.NewServeMux() // here you could also go with third party packages to create a router
+	// Register your routes
+	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		content, err := ioutil.ReadAll(r.Body)
+		if err != nil {
+			panic(err)
+		}
+		quit <- string(content)
+	})
+	return &http.Server{
+		Addr:    listenAddr,
+		Handler: router,
+	}
+}
+
+func waitForShutDown(server *http.Server, done chan<- string, quit <-chan string) {
+	content := <-quit
+	color.Magenta("Shutting down the server")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	server.SetKeepAlivesEnabled(false)
+
+	if err := server.Shutdown(ctx); err != nil {
+		color.Red("Could not shutdown the server")
+	}
+	done <- content
+}
+
+func ParseAction(context *cli.Context) error {
+	msgReceiveChannel := make(chan string, 1)
+	msgReadChannel := make(chan string, 1)
+
+	server := createWebServer(msgReadChannel)
+
+	go waitForShutDown(server, msgReceiveChannel, msgReadChannel)
+
+	color.Green("Starting the server on %s\n", listenAddr)
+	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		color.Red("Could not listen on %s, %v\n", listenAddr, err)
+	}
+	json := <-msgReceiveChannel
+	color.Green("Server stopped")
+	fmt.Printf("Received data %v\n", json)
+	// first line contains a json string
+	lines := strings.Split(json, "\n")
+	task, err := extractTaskFromJson(lines[1])
+	if err != nil {
+		return err
+	}
+	fmt.Printf("task %v\n", task)
+	config, err := LoadDefaultConfiguration()
+	if err != nil {
+		return err
+	}
+	err = CreateDirectoryStructure(*task, *config)
+	if err != nil {
+		color.Red("Error happened %v", err)
+	}
+	return nil
+}
+
+// Command to parse tasks from the `Competitive Companion` Chrome extension.
+// Running this command, will start a server on the default port that the extension
+// uses, and will create a directory structure containing input files, expected output files,
+// 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"},
-	Usage:     "parse task from navigator",
+	Usage:     "Parse a task using 'Competitive Companion'",
 	UsageText: "parse task from navigator",
-	Action: func(context *cli.Context) error {
-		fmt.Println("Hello from parse")
-		return nil
-	},
+	Action:    ParseAction,
 }

commands/parse_test.go

@@ -0,0 +1,56 @@
+package commands
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func getDummyTaskJson() string {
+	return `{
+		"group" : "Educational Codeforces Round 75 (Rated for Div. 2)",
+			"interactive" : false,
+			"output" : {
+			"type" : "stdout"
+		},
+		"timeLimit" : 2000,
+			"name" : "C. Minimize The Integer",
+			"url" : "https://codeforces.com/contest/1251/problem/C",
+			"testType" : "single",
+			"languages" : {
+			"java" : {
+				"mainClass" : "Main",
+					"taskClass" : "CMinimizeTheInteger"
+			}
+		},
+		"input" : {
+			"type" : "stdin"
+		},
+		"memoryLimit" : 256,
+			"tests" : [{ "input" : "3\n0709\n1337\n246432\n","output" : "0079\n1337\n234642\n"}]
+	}`
+}
+
+func TestExtractTaskFromString(t *testing.T) {
+	task, _ := extractTaskFromJson(getDummyTaskJson())
+	assert.Equal(t, task.Name, "C. Minimize The Integer")
+	assert.Equal(t, task.Group, "Educational Codeforces Round 75 (Rated for Div. 2)")
+	assert.Equal(t, task.Url, "https://codeforces.com/contest/1251/problem/C")
+	assert.Equal(t, task.Interactive, false)
+	assert.Equal(t, int(task.MemoryLimit), 256)
+	assert.Equal(t, task.TestType, "single")
+
+	assert.Equal(t, len(task.Tests), 1)
+	assert.Equal(t, task.Tests[0].Input, "3\n0709\n1337\n246432\n")
+	assert.Equal(t, task.Tests[0].Output, "0079\n1337\n234642\n")
+
+	assert.Equal(t, task.Input.Type, "stdin")
+	assert.Equal(t, task.Output.Type, "stdout")
+
+	assert.Equal(t, len(task.Languages), 1)
+	assert.Equal(t, task.Languages["java"].MainClass, "Main")
+	assert.Equal(t, task.Languages["java"].TaskClass, "CMinimizeTheInteger")
+}
+
+func TestCurrentDirectory(t *testing.T) {
+	//CreateDirectoryStructure(config.Task{});
+}

config/config.go

@@ -16,7 +16,9 @@ type Config struct {
 	Lang struct {
 		Default string `yaml:"default"`
 	}
-	Version string `yaml:"version"`
+	ConfigFileName string `yaml:"config_file_name"`
+	Version        string `yaml:"version"`
+	Author         string `yaml:"author"`
 }
 
 func getDefaultConfigLocation() (string, error) {
@@ -39,7 +41,8 @@ func createDefaultConfiguration() *Config {
 		}{
 			Default: "cpp",
 		},
-		Version: "1.0",
+		Version:        "1.0",
+		ConfigFileName: "egor-meta.json",
 	}
 }
 
@@ -57,7 +60,7 @@ func saveDefaultConfiguration() error {
 	if err != nil {
 		return err
 	}
-	return ioutil.WriteFile(location, buffer.Bytes(), 0644)
+	return ioutil.WriteFile(location, buffer.Bytes(), 0777)
 }
 
 // Returns the Configuration object associated with
@@ -86,7 +89,9 @@ func LoadDefaultConfiguration() (*Config, error) {
 	}
 	if _, err := os.Stat(location); err != nil {
 		if os.IsNotExist(err) {
-			saveDefaultConfiguration()
+			if err := saveDefaultConfiguration(); err != nil {
+				return nil, err
+			}
 		}
 	}
 	return LoadConfiguration(location)

config/config_test.go

@@ -45,7 +45,7 @@ func createFakeConfigFile() error {
 }
 
 func TestLoadConfiguration(t *testing.T) {
-	createFakeConfigFile()
+	_ = createFakeConfigFile()
 	defer deleteFakeConfigFile()
 	config, err := LoadConfiguration(getConfigPath())
 	if err != nil {
@@ -55,7 +55,7 @@ func TestLoadConfiguration(t *testing.T) {
 	assert.Equal(t, config.Server.Port, getDefaultConfiguration().Server.Port)
 }
 
-func deleteFakeConfigFile() error {
+func deleteFakeConfigFile() {
 	configPath := getConfigPath()
-	return os.Remove(configPath)
+	_ = os.Remove(configPath)
 }