From a95d054189a5a0307ce6238ff99cbcff855cc02f Mon Sep 17 00:00:00 2001
From: Arsen Musayelyan <moussaelianarsen@gmail.com>
Date: Mon, 1 Mar 2021 15:01:21 -0800
Subject: [PATCH] Add comments and remove debug code

---
 ast.go      | 12 ++++++++++++
 defaults.go | 25 ++++++++++++++++++++-----
 scpt.go     | 39 +++++++++++++++++++++++++++++++++++++--
 3 files changed, 69 insertions(+), 7 deletions(-)

diff --git a/ast.go b/ast.go
index 61900b1..2d035e0 100644
--- a/ast.go
+++ b/ast.go
@@ -15,25 +15,36 @@ type AST struct {
 // containing the position at which the error was encountered and the error
 // itself
 func (ast *AST) Execute() error {
+	// For each command in AST
 	for _, cmd := range ast.Commands {
+		// If parsing variables
 		if cmd.Vars != nil {
+			// For each variable
 			for _, Var := range cmd.Vars {
+				// Parse value of variable
 				val, err := ParseValue(Var.Value)
 				if err != nil {
 					return fmt.Errorf("%s: %s", Var.Value.Pos, err)
 				}
+				// If value of variable is a function call
 				if IsFuncCall(val) {
+					// Assert type of val as *FuncCall
 					Call := val.(*FuncCall)
+					// Set variable value to function return value
 					Vars[Var.Key], err = CallFunction(Call)
 					if err != nil {
 						return fmt.Errorf("%s: %s", Var.Value.Pos, err)
 					}
 				} else {
+					// If value is not a function call, set variable value to parsed value
 					Vars[Var.Key] = val
 				}
 			}
+		// If parsing function calls
 		} else if cmd.Calls != nil {
+			// For each function call
 			for _, Call := range cmd.Calls {
+				// Attempt to call function
 				_, err := CallFunction(Call)
 				if err != nil {
 					return fmt.Errorf("%s: %s", Call.Pos, err)
@@ -91,6 +102,7 @@ type Bool bool
 // Capture parses a boolean literal encountered in the script into
 // a Go boolean value
 func (b *Bool) Capture(values []string) error {
+	// Convert string to boolean
 	*b = values[0] == "true"
 	return nil
 }
diff --git a/defaults.go b/defaults.go
index 2aba936..908cd9e 100644
--- a/defaults.go
+++ b/defaults.go
@@ -8,47 +8,62 @@ import (
 	"os/exec"
 )
 
+// Default function to display a dialog
 func displayDialog(args map[string]interface{}) (interface{}, error) {
+	// Get title
 	title, ok := args["title"]
 	if !ok {
 		return nil, errors.New("title not provided")
 	}
+	// Get unnamed argument as text
 	text, ok := args[""]
 	if !ok {
 		return nil, errors.New("text not provided")
 	}
+	// Display correct dialog based on given type
 	switch args["type"] {
 	case "yesno":
+		// Display yes or no dialog, returning bool based on user input
 		return dlgs.Question(fmt.Sprint(title), fmt.Sprint(text), true)
 	case "info":
+		// Display info dialog, returning bool based on success
 		return dlgs.Info(fmt.Sprint(title), fmt.Sprint(text))
 	case "error":
+		// Display error dialog, returning bool based on success
 		return dlgs.Error(fmt.Sprint(title), fmt.Sprint(text))
 	case "entry":
+		// Check if default text given
 		defaultText, ok := args["default"]
 		if !ok {
+			// Set to empty if not given
 			defaultText = ""
 		}
+		// Display entry dialog
 		input, _, err := dlgs.Entry(fmt.Sprint(title), fmt.Sprint(text), fmt.Sprint(defaultText))
+		// Return user input
 		return input, err
 	default:
+		// If type unknown, return error
 		return nil, fmt.Errorf("unknown dialog type: %v", args["type"])
 	}
 }
 
+// Default function to run a shell script using `sh -c`
 func doShellScript(args map[string]interface{}) (interface{}, error) {
+	// Get unnamed argument and assert its type as string
 	script, ok := args[""].(string)
+	// If assertion successful
 	if ok {
+		// Create new exec.Cmd containing `sh -c <script>`
 		cmd := exec.Command("sh", "-c", script)
+		// Set command I/O
 		cmd.Stdout = os.Stdout
+		cmd.Stdin = os.Stdin
+		cmd.Stderr = os.Stderr
+		// Run command
 		_ = cmd.Run()
 		return "", nil
 	} else {
 		return nil, errors.New("script not provided")
 	}
-}
-
-func print(args map[string]interface{}) (interface{}, error) {
-	fmt.Println(args)
-	return nil, nil
 }
\ No newline at end of file
diff --git a/scpt.go b/scpt.go
index 21a5f19..0c0937e 100644
--- a/scpt.go
+++ b/scpt.go
@@ -1,3 +1,5 @@
+// Package scpt provides an interpreter for my simple applescript-like
+// scripting language
 package scpt
 
 import (
@@ -20,12 +22,12 @@ type FuncMap map[string]func(map[string]interface{}) (interface{}, error)
 var Funcs = FuncMap{
 	"display-dialog":  displayDialog,
 	"do-shell-script": doShellScript,
-	"print":           print,
 }
 
 // AddFuncs adds all functions from the provided FuncMap into
 // the Funcs variable
 func AddFuncs(fnMap FuncMap) {
+	// Add each function to Funcs
 	for name, fn := range fnMap {
 		Funcs[name] = fn
 	}
@@ -35,62 +37,81 @@ func AddFuncs(fnMap FuncMap) {
 // the Vars variable
 func AddVars(varMap map[string]interface{}) {
 	for name, val := range varMap {
+		// Add each variable to Vars
 		Vars[name] = val
 	}
 }
 
 // Parse uses participle to parse a script from r into a new AST
 func Parse(r io.Reader) (*AST, error) {
+	// Build parser from empty AST struct
 	parser, err := participle.Build(&AST{})
 	if err != nil {
 		return nil, err
 	}
+	// Create new empty AST struct
 	ast := &AST{}
+	// Parse script from provided reader into ast
 	err = parser.Parse(r, ast)
 	if err != nil {
 		return nil, err
 	}
+	// Return filled AST struct
 	return ast, nil
 }
 
 // ParseValue parses a Value struct into a go value
 func ParseValue(val *Value) (interface{}, error) {
+	// Determine which value was provided and return it
 	if val.String != nil {
+		// Return unquoted string
 		return strings.Trim(*val.String, `"`), nil
 	} else if val.Bool != nil {
+		// Return dereferenced boolean
 		return *val.Bool, nil
 	} else if val.Float != nil {
+		// Return dereferenced float
 		return *val.Float, nil
 	} else if val.Integer != nil {
+		// Return dereferenced integer
 		return *val.Integer, nil
 	} else if val.SubCmd != nil {
+		// Return reference to subcommand
 		return val.SubCmd, nil
 	} else if val.VarVal != nil {
+		// Return value of provided key
 		return Vars[*val.VarVal], nil
 	} else if val.Expr != nil {
+		// Parse value of left side of expression
 		left, _ := ParseValue(val.Expr.Left)
+		// If value is string, requote
 		if isStr(left) {
 			left = requoteStr(left.(string))
 		}
+		// Parse value of right side of expression
 		right, _ := ParseValue(val.Expr.Right)
+		// If value is string, requote
 		if isStr(right) {
 			right = requoteStr(right.(string))
 		}
+		// Create string expression from halves and operator
 		exp := fmt.Sprintf(
 			"%v %s %v",
 			left,
 			val.Expr.Op,
 			right,
 		)
-		fmt.Println(exp)
+		// Compile string expression
 		program, err := expr.Compile(strings.ReplaceAll(exp, "^", "**"))
 		if err != nil {
 			return nil, err
 		}
+		// Run expression
 		out, err := expr.Run(program, Vars)
 		if err != nil {
 			return nil, err
 		}
+		// Return expression output value
 		return out, nil
 	}
 	return nil, nil
@@ -98,11 +119,13 @@ func ParseValue(val *Value) (interface{}, error) {
 
 // Add quotes to an unquoted string
 func requoteStr(s string) string {
+	// Return quoted string
 	return `"` + s + `"`
 }
 
 // Check if i is a string
 func isStr(i interface{}) bool {
+	// if type of input is string, return true
 	if reflect.TypeOf(i).String() == "string" {
 		return true
 	}
@@ -113,26 +136,35 @@ func isStr(i interface{}) bool {
 // storing the argument name and its value. If the argument has
 // no name, its key will be an empty string
 func UnwrapArgs(args []*Arg) (map[string]interface{}, error) {
+	// Create new empty map of strings to any type
 	argMap := map[string]interface{}{}
+	// For each argument
 	for _, arg := range args {
+		// Parse value into interface{}
 		val, err := ParseValue(arg.Value)
 		if err != nil {
 			return nil, err
 		}
+		// If value is function call
 		if IsFuncCall(val) {
+			// Call function, setting its value as the argument's value
 			argMap[arg.Key], err = CallFunction(val.(*FuncCall))
 			if err != nil {
 				return nil, err
 			}
+			// Skip further code and start next loop
 			continue
 		}
+		// Set argument value to parsed value
 		argMap[arg.Key] = val
 	}
+	// Return map of arguments
 	return argMap, nil
 }
 
 // IsFuncCall checks if val is a FuncCall struct
 func IsFuncCall(val interface{}) bool {
+	// If type of val contains .FuncCall, return true
 	if strings.Contains(reflect.TypeOf(val).String(), ".FuncCall") {
 		return true
 	}
@@ -142,13 +174,16 @@ func IsFuncCall(val interface{}) bool {
 // CallFunction executes a given function call in the form of
 // a FuncCall struct
 func CallFunction(call *FuncCall) (interface{}, error) {
+	// Unwrap provided arguments
 	argMap, err := UnwrapArgs(call.Args)
 	if err != nil {
 		return nil, err
 	}
+	// Attempt to get function from Funcs map
 	fn, ok := Funcs[call.Name]
 	if !ok {
 		return nil, errors.New("no such function: " + call.Name)
 	}
+	// Return value received from function
 	return fn(argMap)
 }