Merge pull request #259 from yassinebenaid/dev

support `unset` keyword

Author: yassinebenaid

analyser/analyser.go

@@ -199,6 +199,10 @@ func (a *analyser) analyseStatement(s ast.Statement) {
 				a.analyseExpression(r.Dst)
 			}
 		}
+	case ast.Unset:
+		for _, name := range v.Names {
+			a.analyseExpression(name)
+		}
 	default:
 		a.report(Error{Msg: fmt.Sprintf("Unsupported statement type: %T", v)})
 	}

ast/statement.go

@@ -122,6 +122,11 @@ type Return struct {
 	BreakPoint int
 }
 
+type Unset struct {
+	Flag  string
+	Names []Expression
+}
+
 type Continue struct {
 	BreakPoint int
 	Type       BreakPointsType
@@ -229,6 +234,7 @@ func (Return) node()              {}
 func (Wait) node()                {}
 func (Embed) node()               {}
 func (Defer) node()               {}
+func (Unset) node()               {}
 
 // Expressions
 func (CommandSubstitution) expr() {}
@@ -258,3 +264,4 @@ func (Return) stmt()         {}
 func (Wait) stmt()           {}
 func (Embed) stmt()          {}
 func (Defer) stmt()          {}
+func (Unset) stmt()          {}

generator/builtins.go

@@ -25,6 +25,20 @@ func (g *generator) handleExit(buf *InstructionBuffer, exit ast.Exit) {
 	buf.add(ir.Exit{Code: g.handleExpression(buf, exit.Code)})
 }
 
+func (g *generator) handleUnset(buf *InstructionBuffer, unset ast.Unset) {
+	var names InstructionBuffer
+
+	for _, name := range unset.Names {
+		names.add(g.handleExpression(buf, name))
+	}
+
+	if unset.Flag == "" || unset.Flag == "-v" {
+		buf.add(ir.Unset{Names: names, VarsOnly: unset.Flag == "-v"})
+	} else {
+		buf.add(ir.UnsetFunctions(names))
+	}
+}
+
 func (g *generator) handleReturn(buf *InstructionBuffer, b *ast.Return) {
 	buf.add(ir.Set{Name: fmt.Sprintf("breakpoint%d", b.BreakPoint), Value: ir.Literal("true")})
 	buf.add(ir.Set{Name: "shell.ExitCode", Value: ir.ParseInt{Value: g.handleExpression(buf, b.Code)}})

generator/generator.go

@@ -88,6 +88,8 @@ func (g *generator) generate(buf *InstructionBuffer, statement ast.Statement) {
 		g.handleCase(buf, v)
 	case ast.Exit:
 		g.handleExit(buf, v)
+	case ast.Unset:
+		g.handleUnset(buf, v)
 	default:
 		panic(fmt.Sprintf("Unsupported statement: %T", v))
 	}

generator/tests/19-unset.test

@@ -0,0 +1,28 @@
+#(TEST: can unset variables)
+
+unset var 
+
+unset var $var var
+
+unset -v var var
+
+unset -f var var
+
+#(RESULT)
+
+package main
+
+import "github.com/yassinebenaid/bunster/runtime"
+
+func Main(shell *runtime.Shell, streamManager *runtime.StreamManager) {
+	defer shell.Terminate(streamManager)
+	shell.Unset(false, "var")
+	shell.Unset(false, "var", shell.ReadVar("var"), "var")
+	shell.Unset(true, "var", "var")
+	shell.UnsetFunctions("var", "var")
+}
+
+#(ENDTEST)
+
+
+ 

ir/ir.go

@@ -178,6 +178,31 @@ func (e Exit) togo() string {
 		};`, e.Code.togo())
 }
 
+type Unset struct {
+	VarsOnly bool
+	Names    []Instruction
+}
+
+func (e Unset) togo() string {
+	var names []string
+	for _, name := range e.Names {
+		names = append(names, name.togo())
+	}
+
+	return fmt.Sprintf(` shell.Unset(%t, %s);`, e.VarsOnly, strings.Join(names, ", "))
+}
+
+type UnsetFunctions []Instruction
+
+func (e UnsetFunctions) togo() string {
+	var names []string
+	for _, name := range e {
+		names = append(names, name.togo())
+	}
+
+	return fmt.Sprintf(` shell.UnsetFunctions( %s);`, strings.Join(names, ", "))
+}
+
 type ReadVar string
 
 func (rv ReadVar) togo() string {

parser/builtin_test.go

@@ -46,9 +46,64 @@ var builtinTests = []testCase{
 			Code: ast.Word("1"),
 		},
 	}},
+
+	{`unset var`, ast.Script{
+		ast.Unset{
+			Names: []ast.Expression{
+				ast.Word("var"),
+			},
+		},
+	}},
+	{`unset var1 $var2 var3`, ast.Script{
+		ast.Unset{
+			Names: []ast.Expression{
+				ast.Word("var1"),
+				ast.Var("var2"),
+				ast.Word("var3")},
+		},
+	}},
+	{`unset var1 # comment`, ast.Script{
+		ast.Unset{
+			Names: []ast.Expression{
+				ast.Word("var1"),
+			},
+		},
+	}},
+	{`unset var1 && unset var1`, ast.Script{
+		ast.List{
+			Left: ast.Unset{
+				Names: []ast.Expression{
+					ast.Word("var1"),
+				},
+			},
+			Operator: "&&",
+			Right: ast.Unset{
+				Names: []ast.Expression{
+					ast.Word("var1"),
+				},
+			},
+		},
+	}},
+	{`
+	unset var1
+	unset var2
+	`, ast.Script{
+		ast.Unset{Names: []ast.Expression{ast.Word("var1")}},
+		ast.Unset{Names: []ast.Expression{ast.Word("var2")}},
+	}},
+	{`
+	unset -f var1
+	unset -v var2
+	`, ast.Script{
+		ast.Unset{Flag: "-f", Names: []ast.Expression{ast.Word("var1")}},
+		ast.Unset{Flag: "-v", Names: []ast.Expression{ast.Word("var2")}},
+	}},
 }
 
 var builtinsErrorHandlingCases = []errorHandlingTestCase{
 	{`exit <foo`, "syntax error: unexpected token `<`. (line: 1, column: 6)"},
 	{`return <foo`, "syntax error: unexpected token `<`. (line: 1, column: 8)"},
+	{`unset`, "syntax error: unexpected token `end of file`. (line: 1, column: 6)"},
+	{`unset -`, "syntax error: expected a valid flag character after `-`, found `end of file`. (line: 1, column: 8)"},
+	{`unset -k`, "syntax error: expected a valid flag character after `-`, found `k`. (line: 1, column: 8)"},
 }

parser/builtins.go

@@ -27,6 +27,8 @@ func (p *parser) getBuiltinParser() func() ast.Statement {
 		return p.parseLocal
 	case token.EXPORT:
 		return p.parseExport
+	case token.UNSET:
+		return p.parseUnset
 	case token.AT:
 		if p.next.Type != token.EMBED {
 			return nil
@@ -341,6 +343,57 @@ func (p *parser) parseExport() ast.Statement {
 	return assignements
 }
 
+func (p *parser) parseUnset() ast.Statement {
+	p.proceed()
+
+	if p.curr.Type == token.BLANK {
+		p.proceed()
+	}
+
+	var flag string
+
+	if p.curr.Type == token.MINUS {
+		p.proceed()
+		if p.curr.Type == token.WORD && (p.curr.Literal == "f" || p.curr.Literal == "v") {
+			flag = "-" + p.curr.Literal
+			p.proceed()
+		} else {
+			p.error("expected a valid flag character after `-`, found `%v`", p.curr)
+		}
+	}
+
+	if p.curr.Type == token.BLANK {
+		p.proceed()
+	}
+
+	var names []ast.Expression
+
+	for !p.isControlToken() && p.curr.Type != token.EOF {
+		name := p.parseExpression()
+		names = append(names, name)
+
+		if p.curr.Type == token.BLANK {
+			p.proceed()
+		}
+
+		if p.curr.Type == token.HASH {
+			for p.curr.Type != token.NEWLINE && p.curr.Type != token.EOF {
+				p.proceed()
+			}
+		}
+	}
+
+	if names == nil || (!p.isControlToken() && p.curr.Type != token.EOF) {
+		p.error("unexpected token `%s`", p.curr)
+		return nil
+	}
+
+	return ast.Unset{
+		Flag:  flag,
+		Names: names,
+	}
+}
+
 func (p *parser) parseEmbedDirective() ast.Statement {
 	p.proceed()
 	p.proceed()

runtime/shell.go

@@ -154,6 +154,30 @@ func (shell *Shell) MarkVarAsExported(name string) {
 	shell.exportedVars.set(name, struct{}{})
 }
 
+func (shell *Shell) Unset(vars_only bool, names ...string) {
+	for _, name := range names {
+		if shell.localVars.forget(name) ||
+			shell.vars.forget(name) ||
+			shell.env.forget(name) {
+			continue
+		}
+
+		if !vars_only && shell.functions.forget(name) {
+			continue
+		}
+
+		if shell.parent != nil {
+			shell.parent.Unset(vars_only, name)
+		}
+	}
+}
+
+func (shell *Shell) UnsetFunctions(names ...string) {
+	for _, name := range names {
+		shell.functions.forget(name)
+	}
+}
+
 func (shell *Shell) ReadSpecialVar(name string) string {
 	switch name {
 	case "0":
@@ -348,6 +372,17 @@ func (r *repository[T]) set(key string, value T) {
 	r.data[key] = value
 }
 
+func (r *repository[T]) forget(key string) bool {
+	r.mx.Lock()
+	defer r.mx.Unlock()
+	_, ok := r.data[key]
+	if !ok {
+		return false
+	}
+	delete(r.data, key)
+	return true
+}
+
 func (r *repository[T]) clone() *repository[T] {
 	var repo = newRepository[T]()
 	for key, value := range r.data {