Finished docs

Author: classPythonAddike

docs/Utils.md

@@ -0,0 +1,143 @@
+# Utilities
+
+GoWandBox also offers a couple of utilities, most of which wrap around the WandBox API -
+
+## List Supported Languages
+
+```go
+languages, err := gwb.GetLanguages(10000) // Timeout of 10000 milliseconds
+
+if err != nil {
+	log.Fatal(err)
+}
+
+for _, lang := range languages() {
+	fmt.Printf("Language - %v\n", lang.DisplayName) // Name of the language
+	fmt.Println(lang.Name)                          // Name with version
+	fmt.Printf("Version - %v\n", lang.Version)
+	fmt.Printf("Used with - %v\n", lang.DisplayCompileCommand) // Command used to compile/run
+	fmt.Printf(
+		"Supports Compiler Options - %v\nSupports Runtime Options - %v\n",
+		lang.CompilerOptionRaw,
+		lang.RuntimeOptionRaw,
+	)
+	fmt.Printf("Switches - %v\n", lang.Switches) // lang.Switches is an array of switches
+	fmt.Printf("Template Names - %v\n", lang.Templates)
+	// lang.Templates is an array of template names,
+	// which can be obtained with the GetTemplate() function
+	
+	fmt.Println("--------------------------------")
+}
+```
+
+```
+$ go run main.go
+Language - gcc HEAD
+gcc-head-c
+Version - 12.0.0 20210721 (experimental)
+Used with - gcc prog.c
+Supports Compiler Options - true
+Supports Runtime Options - false
+Switches - [{true warning -Wall -Wextra Warnings} {false optimize -O2 -march=native Optimization} {false cpp-verbose -v Verbose} {gnu11 std-c  } {cpp-no-pedantic cpp-pedantic  }]
+Template Names - [gcc-c]
+--------------------------------
+Language - gcc
+gcc-11.1.0-c
+Version - 11.1.0
+Used with - gcc prog.c
+Supports Compiler Options - true
+Supports Runtime Options - false
+Switches - [{true warning -Wall -Wextra Warnings} {false optimize -O2 -march=native Optimization} {false cpp-verbose -v Verbose} {gnu11 std-c  } {cpp-no-pedantic cpp-pedantic  }]
+Template Names - [gcc-c]
+--------------------------------
+......
+```
+
+## Get Template
+
+You can get the template for a language, with the `GetTemplate()` function.
+
+```go
+template, err := gwb.GetTemplate("cpython", 10000)
+// Get the template for `cpython`, with a 10000 millisecond timeout
+
+if err != nil {
+	log.Fatal(err)
+}
+
+fmt.Println(template.Code)
+```
+
+```
+$ go run main.go
+
+# This file is a "Hello, world!" in Python language by CPython for wandbox.
+
+print("Hello, world!")
+
+# CPython references:
+#   https://www.python.org/
+```
+
+## Get User State
+
+You can view the state of a WandBox user, given their SessionKey (Provided by WandBox) -
+```go
+user, err := gwb.GetUser("session-key", 10000)
+if err != nil {
+	log.Fatal(err)
+}
+
+fmt.Printf("Username: %v\n", user.Username)
+fmt.Printf("Logged in Currently: %v\n", user.Login)
+```
+
+```
+$ go run main.go
+Username: ABCDEFGH
+Logged in Currently: true
+```
+
+## Get PermLinks
+
+If you have the the PermLink of a program that was executed, and saved, you can retrieve information about it, such as the code, input, compiler used, time it was executed at, output, errors, etc.
+
+```go
+result, err := GetPermLink("permlink", 10000) // Timeout of 10000 milliseconds
+
+if err != nil {
+	log.Fatal(err)
+}
+
+fmt.Printf("Code: %v\n", result.Parameter.Code)
+fmt.Printf("Files: %v\n", result.Parameter.Codes)
+fmt.Printf("Compiled with: %v\n", result.Parameter.Compiler)
+
+fmt.Printf("Output: %v\n", result.Result.ProgramMessage)
+fmt.Printf("Exit Code: %v\n", result.Result.Status)
+```
+
+```
+$ go run main.go
+Code: print(123)
+Files: []
+Compiled with: cpython-head
+Output: 123
+
+Exit Code: 0
+```
+
+For a detailed list of information available, check out the pkg.go.dev page - [https://pkg.go.dev/github.com/classPythonAddike/gowandbox](https://pkg.go.dev/github.com/classPythonAddike/gowandbox#GWBPermLink)
+
+## Change WandBox API URL
+
+You can use your own instance of WandBox, instead of the default one with `ChangeWandBoxUrl()`
+
+```go
+gwb.ChangeWandBoxUrl("https://my.wandboxinstance.com/api/")
+```
+
+To reset the WandBox URL - 
+```go
+gwb.ResetWandBoxUrl()
+```

docs/_sidebar.md

@@ -1,2 +1,3 @@
 * [Home](/)
 * [Compiling](/Compiling.md)
+* [Utils](/Utils.md)

get_template.go

@@ -1,6 +1,7 @@
 package gowandbox
 
 import (
+	"encoding/json"
 	"errors"
 	"io/ioutil"
 	"net/http"
@@ -12,27 +13,29 @@ import (
 	If the language is not found, an error is returned (bad template).
 	Maps to the `/template/:template` endpoint
 */
-func GetTemplate(language string, timeout int) (string, error) {
+func GetTemplate(language string, timeout int) (GWBTemplate, error) {
 
 	client := http.Client{
 		Timeout: time.Duration(timeout) * time.Millisecond,
 	}
 
+	templ := GWBTemplate{}
+
 	resp, err := client.Get(
 		WandBoxUrl + "template/" + language,
 	)
 
 	if err != nil {
-		return "", err
+		return templ, err
 	}
 
 	if resp.StatusCode != http.StatusOK {
 		defer resp.Body.Close()
 		e, _ := ioutil.ReadAll(resp.Body)
-		return "", errors.New(string(e))
+		return templ, errors.New(string(e))
 	}
 
 	defer resp.Body.Close()
-	res, err := ioutil.ReadAll(resp.Body)
-	return string(res), err
+	err = json.NewDecoder(resp.Body).Decode(&templ)
+	return templ, err
 }

get_template_test.go

@@ -6,13 +6,13 @@ import (
 )
 
 func TestTemplate(t *testing.T) {
-	_, err := GetTemplate("cpython", 10000)
+	template, err := GetTemplate("cpython", 10000)
 
 	if err != nil {
 		t.Error(err.Error())
 	}
 
-	t.Log("Got template for cpython")
+	t.Logf("Got template for cpython - %v", template.Code)
 }
 
 func TestBadTemplateError(t *testing.T) {

types.go

@@ -205,3 +205,7 @@ type GWBPermLink struct {
 		ProgramMessage string `json:"program_message"`
 	} `json:"result"`
 }
+
+type GWBTemplate struct {
+	Code string `json:"code"`
+}