Dev

.github/workflows/tests.yml

@@ -2,7 +2,7 @@ name: Go
 
 on:
   push:
-    branches: [ main ]
+    branches: [ main, dev ]
 
 jobs:
 

.gitignore

@@ -50,6 +50,5 @@ testbinaries/
 tests_random/
 nuru
 Notes.md
-gotest
 tutorials/en/*
-upx
+config.json

Makefile

@@ -1,43 +1,57 @@
-VERSION=0.3.0
+VERSION=0.3.0-dev
 
 build_linux:
 	@echo 'building linux binary...'
-	env GOOS=linux GOARCH=amd64 go build -o nuru
+	env GOOS=linux GOARCH=amd64 go build -ldflags="-s -w" -o nuru
+	@echo 'shrinking binary...'
+	./upx --brute nuru
 	@echo 'zipping build....'
 	tar -zcvf nuru_linux_amd64_v${VERSION}.tar.gz nuru
 	@echo 'cleaning up...'
 	rm nuru
 
 build_windows:
 	@echo 'building windows executable...'
-	env GOOS=windows GOARCH=amd64 go build -o nuru_windows_amd64_v${VERSION}.exe
+	env GOOS=windows GOARCH=amd64 go build -ldflags="-s -w" -o nuru_windows_amd64_v${VERSION}.exe
+	@echo 'zipping build...'
+	./upx --brute nuru_windows_amd64_v${VERSION}.exe
 
 build_mac:
 	@echo 'building mac binary...'
-	env GOOS=darwin GOARCH=amd64 go build -o nuru
+	env GOOS=darwin GOARCH=amd64 go build -ldflags="-s -w" -o nuru
+	@echo 'shrinking binary...'
+	./upx --brute nuru
 	@echo 'zipping build...'
 	tar -zcvf nuru_mac_amd64_v${VERSION}.tar.gz nuru
 	@echo 'cleaning up...'
 	rm nuru
 
 build_android:
 	@echo 'building android binary'
-	env GOOS=android GOARCH=arm64 go build -o nuru
+	env GOOS=android GOARCH=arm64 go build -ldflags="-s -w" -o nuru
 	@echo 'zipping build...'
 	tar -zcvf nuru_linux_amd64_v${VERSION}.tar.gz nuru
 	@echo 'cleaning up...'
 	rm nuru
 
 build_test:
-	go build -o test
-	mv test testbinaries/
+	go build -ldflags="-s -w" -o nuru
+
+dependencies:
+	@echo 'checking dependencies...'
+	go mod tidy
 
 test:
-	go test -v ./parser/
-	go test -v ./ast/
-	go test -v ./evaluator/
-	go test -v ./object/
-	go test -v ./lexer/
+	@echo -e '\nTesting Lexer...'
+	@./gotest --format testname ./lexer/ 
+	@echo -e '\nTesting Parser...'
+	@./gotest --format testname ./parser/
+	@echo -e '\nTesting AST...'
+	@./gotest --format testname ./ast/
+	@echo -e '\nTesting Object...'
+	@./gotest --format testname ./object/
+	@echo -e '\nTesting Evaluator...'
+	@./gotest --format testname ./evaluator/
 
 clean:
 	go clean

ast/ast.go

@@ -549,6 +549,7 @@ type MethodExpression struct {
 	Object    Expression
 	Method    Expression
 	Arguments []Expression
+	Defaults  map[string]Expression
 }
 
 func (me *MethodExpression) expressionNode()      {}
@@ -577,3 +578,70 @@ func (i *Import) String() string {
 	}
 	return out.String()
 }
+
+type PackageBlock struct {
+	Token      token.Token
+	Statements []Statement
+}
+
+func (pb *PackageBlock) statementNode()       {}
+func (pb *PackageBlock) TokenLiteral() string { return pb.Token.Literal }
+func (pb *PackageBlock) String() string {
+	var out bytes.Buffer
+
+	for _, s := range pb.Statements {
+		out.WriteString(s.String())
+	}
+
+	return out.String()
+}
+
+type Package struct {
+	Token token.Token
+	Name  *Identifier
+	Block *BlockStatement
+}
+
+func (p *Package) expressionNode()      {}
+func (p *Package) TokenLiteral() string { return p.Token.Literal }
+func (p *Package) String() string {
+	var out bytes.Buffer
+
+	out.WriteString("pakeji " + p.Name.Value + "\n")
+	out.WriteString("::\n")
+	for _, s := range p.Block.Statements {
+		out.WriteString(s.String())
+	}
+	out.WriteString("\n::")
+
+	return out.String()
+}
+
+type At struct {
+	Token token.Token
+}
+
+func (a *At) expressionNode()      {}
+func (a *At) TokenLiteral() string { return a.Token.Literal }
+func (a *At) String() string       { return "@" }
+
+type PropertyAssignment struct {
+	Token token.Token // the '=' token
+	Name  *PropertyExpression
+	Value Expression
+}
+
+func (pa *PropertyAssignment) expressionNode()      {}
+func (pa *PropertyAssignment) TokenLiteral() string { return pa.Token.Literal }
+func (pa *PropertyAssignment) String() string       { return "Ngl I'm tired" }
+
+type PropertyExpression struct {
+	Expression
+	Token    token.Token // The . token
+	Object   Expression
+	Property Expression
+}
+
+func (pe *PropertyExpression) expressionNode()      {}
+func (pe *PropertyExpression) TokenLiteral() string { return pe.Token.Literal }
+func (pe *PropertyExpression) String() string       { return "Ngl I'm tired part two" }

evaluator/assign.go

@@ -11,6 +11,6 @@ func evalAssign(node *ast.Assign, env *object.Environment) object.Object {
 		return val
 	}
 
-	env.Set(node.Name.Value, val)
-	return NULL
+	obj := env.Set(node.Name.Value, val)
+	return obj
 }

evaluator/at.go

@@ -0,0 +1,13 @@
+package evaluator
+
+import (
+	"github.com/AvicennaJr/Nuru/ast"
+	"github.com/AvicennaJr/Nuru/object"
+)
+
+func evalAt(node *ast.At, env *object.Environment) object.Object {
+	if at, ok := env.Get("@"); ok {
+		return at
+	}
+	return newError("Iko nje ya scope")
+}

evaluator/builtins.go

@@ -49,11 +49,28 @@ var builtins = map[string]*object.Builtin{
 					arr = append(arr, arg.Inspect())
 				}
 				str := strings.Join(arr, " ")
-				return &object.String{Value: str}
+				fmt.Println(str)
 			}
 			return nil
 		},
 	},
+	"_andika": {
+		Fn: func(args ...object.Object) object.Object {
+			if len(args) == 0 {
+				return &object.String{Value: "\n"}
+			} else {
+				var arr []string
+				for _, arg := range args {
+					if arg == nil {
+						return newError("Hauwezi kufanya operesheni hii")
+					}
+					arr = append(arr, arg.Inspect())
+				}
+				str := strings.Join(arr, " ")
+				return &object.String{Value: str}
+			}
+		},
+	},
 	"aina": {
 		Fn: func(args ...object.Object) object.Object {
 			if len(args) != 1 {
@@ -66,38 +83,16 @@ var builtins = map[string]*object.Builtin{
 	"fungua": {
 		Fn: func(args ...object.Object) object.Object {
 
-			if len(args) > 2 {
-				return newError("Samahani, Hatuhitaji hoja zaidi ya 2, wewe umeweka %d", len(args))
+			if len(args) != 1 {
+				return newError("Samahani, tunahitaji hoja 1, wewe umeweka %d", len(args))
 			}
 			filename := args[0].(*object.String).Value
-			mode := os.O_RDONLY
-			if len(args) == 2 {
-				fileMode := args[1].(*object.String).Value
-				switch fileMode {
-				case "soma":
-					mode = os.O_RDONLY
-				// still buggy, will work on this soon
-				case "andika":
-					mode = os.O_WRONLY
-					os.Remove(filename)
-				case "ongeza":
-					mode = os.O_APPEND
-				default:
-					return newError("Tumeshindwa kufungua file na mode %s", fileMode)
-				}
-			}
-			file, err := os.OpenFile(filename, os.O_CREATE|mode, 0644)
+
+			file, err := os.ReadFile(filename)
 			if err != nil {
-				return &object.Null{}
-			}
-			var reader *bufio.Reader
-			var writer *bufio.Writer
-			if mode == os.O_RDONLY {
-				reader = bufio.NewReader(file)
-			} else {
-				writer = bufio.NewWriter(file)
+				return &object.Error{Message: "Tumeshinwa kusoma file"}
 			}
-			return &object.File{Filename: filename, Reader: reader, Writer: writer, Handle: file}
+			return &object.File{Filename: filename, Content: string(file)}
 		},
 	},
 

evaluator/call.go

@@ -17,6 +17,12 @@ func evalCall(node *ast.CallExpression, env *object.Environment) object.Object {
 	switch fn := function.(type) {
 	case *object.Function:
 		args = evalArgsExpressions(node, fn, env)
+	case *object.Package:
+		obj, ok := fn.Scope.Get("andaa")
+		if !ok {
+			return newError("Pakeji haina 'andaa'")
+		}
+		args = evalArgsExpressions(node, obj.(*object.Function), env)
 	default:
 		args = evalExpressions(node.Arguments, env)
 	}

evaluator/evaluator.go

@@ -90,7 +90,8 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 
 	case *ast.StringLiteral:
 		return &object.String{Value: node.Value}
-
+	case *ast.At:
+		return evalAt(node, env)
 	case *ast.ArrayLiteral:
 		elements := evalExpressions(node.Elements, env)
 		if len(elements) == 1 && isError(elements[0]) {
@@ -123,7 +124,16 @@ func Eval(node ast.Node, env *object.Environment) object.Object {
 	// 	return evalForExpression(node, env)
 	case *ast.ForIn:
 		return evalForInExpression(node, env, node.Token.Line)
-
+	case *ast.Package:
+		return evalPackage(node, env)
+	case *ast.PropertyExpression:
+		return evalPropertyExpression(node, env)
+	case *ast.PropertyAssignment:
+		val := Eval(node.Value, env)
+		if isError(val) {
+			return val
+		}
+		return evalPropertyAssignment(node.Name, val, env)
 	case *ast.Assign: // making let temporarily optional as I debug
 		return evalAssign(node, env)
 	case *ast.AssignEqual:
@@ -233,7 +243,6 @@ func isTruthy(obj object.Object) bool {
 }
 
 func newError(format string, a ...interface{}) *object.Error {
-	format = fmt.Sprintf("\x1b[%dm%s\x1b[0m", 31, format)
 	return &object.Error{Message: fmt.Sprintf(format, a...)}
 }
 
@@ -271,6 +280,20 @@ func applyFunction(fn object.Object, args []object.Object, line int) object.Obje
 			return result
 		}
 		return NULL
+	case *object.Package:
+		obj := &object.Instance{
+			Package: fn,
+			Env:     object.NewEnclosedEnvironment(fn.Env),
+		}
+		obj.Env.Set("@", obj)
+		node, ok := fn.Scope.Get("andaa")
+		if !ok {
+			return newError("Hamna andaa function")
+		}
+		node.(*object.Function).Env.Set("@", obj)
+		applyFunction(node, args, fn.Name.Token.Line)
+		node.(*object.Function).Env.Del("@")
+		return obj
 	default:
 		if fn != nil {
 			return newError("Mstari %d: Hii sio function: %s", line, fn.Type())

evaluator/evaluator_test.go

@@ -263,8 +263,8 @@ kama (10 > 1) {
 			continue
 		}
 
-		if errObj.Message != fmt.Sprintf("\x1b[%dm%s\x1b[0m", 31, tt.expectedMessage) {
-			t.Errorf("wrong error message, expected=%q, got=%q", fmt.Sprintf("\x1b[%dm%s\x1b[0m", 31, tt.expectedMessage), errObj.Message)
+		if errObj.Message != fmt.Sprintf(tt.expectedMessage) {
+			t.Errorf("wrong error message, expected=%q, got=%q", fmt.Sprintf(tt.expectedMessage), errObj.Message)
 		}
 	}
 }
@@ -1110,7 +1110,7 @@ func TestTimeModule(t *testing.T) {
 		t.Fatalf("Object is not a time object, got=%T", evaluated)
 	}
 
-	_, err := time.Parse("2006-01-02 15:04:05", muda.TimeValue)
+	_, err := time.Parse("15:04:05 02-01-2006", muda.TimeValue)
 	if err != nil {
 		t.Errorf("Wrong time value: got=%v", err)
 	}