Update example bulma version

README.md

@@ -99,7 +99,7 @@ In this example:
 
 ### `for` tag
 
-Salix's `for` tag is used for iterating over iterable variables, such as slices, maps, iterator functions, etc. It can assign one or two variables depending on your needs. When using a single variable, it sets that variable to the current element in the case of slices or arrays, or the current value for maps. With two variables, it assigns the first to the index (in the case of slices or arrays) or the key (for maps), and the second to the element or value, respectively. Here's an example of the for tag in action:
+Salix's `for` tag is used for iterating over slices, arrays, and maps. It can assign one or two variables depending on your needs. When using a single variable, it sets that variable to the current element in the case of slices or arrays, or the current value for maps. With two variables, it assigns the first to the index (in the case of slices or arrays) or the key (for maps), and the second to the element or value, respectively. Here's an example of the for tag in action:
 
 ```
 #for(id, name in users):
@@ -129,8 +129,6 @@ The include tag allows you to import content from other templates in the namespa
 #include("header.html")
 ```
 
-If the file name starts with a question mark, nonexistent files will be ignored.
-
 #### Using the `include` tag with extra arguments
 
 The `include` tag can accept extra local variables as arguments. Here's an example with a `title` variable:
@@ -155,8 +153,6 @@ The macro tag is a powerful feature that allows you to define reusable template
 
 When a macro tag has a block, it sets the macro's content. When it doesn't, it inserts the contents of the macro. In the above example, a macro is defined and then inserted.
 
-If the macro name starts with a question mark, nonexistent macros will be ignored.
-
 #### Using the `macro` tag with extra arguments
 
 Similar to the `include` tag, the `macro` tag can accept extra local variables as arguments. You can define these variables when including the macro. Here's an example:

ast/ast.go

@@ -20,14 +20,6 @@ func (p Position) String() string {
 	return fmt.Sprintf("%s: line %d, col %d", p.Name, p.Line, p.Col)
 }
 
-type Nil struct {
-	Position Position
-}
-
-func (n Nil) Pos() Position {
-	return n.Position
-}
-
 type Tag struct {
 	Name     Ident
 	Params   []Node

examples/readme/readme.salix.html

@@ -9,6 +9,7 @@
     <div>
         <h2>#(toLower(user.Name))</h2>
         <p>User ID: #(i)</p>
+        #(user.LoggedIn ? "hi" : "haii :3")
         #if(user.LoggedIn): <p>This user is logged in</p> #!if
         #if(user.IsAdmin): <p>This user is an admin!</p> #!if
         <p>Registered: #(user.RegisteredTime.Format("01-02-2006"))</p>

expr.go

@@ -32,14 +32,28 @@ func (t *Template) evalExpr(expr ast.Expr, local map[string]any) (any, error) {
 	return a.Interface(), nil
 }
 
-func (t *Template) performOp(a, b reflect.Value, op ast.Operator) (result any, err error) {
+func (t *Template) performOp(a, b reflect.Value, op ast.Operator) (any, error) {
 	if op.Value == "in" {
-		a, b, err = handleIn(op, a, b)
-		if err != nil {
-			return nil, err
+		switch b.Kind() {
+		case reflect.Slice, reflect.Array:
+			if a.CanConvert(b.Type().Elem()) {
+				a = a.Convert(b.Type().Elem())
+			} else {
+				return nil, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
+			}
+		case reflect.Map:
+			if a.CanConvert(b.Type().Key()) {
+				a = a.Convert(b.Type().Key())
+			} else {
+				return nil, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
+			}
+		case reflect.String:
+			if a.Kind() != reflect.String {
+				return nil, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
+			}
+		default:
+			return nil, ast.PosError(op, "the in operator can only be used on strings, arrays, and slices (got %s and %s)", a.Type(), b.Type())
 		}
-	} else if !a.IsValid() || !b.IsValid() {
-		return handleNil(op, a, b)
 	} else if b.CanConvert(a.Type()) {
 		b = b.Convert(a.Type())
 	} else {
@@ -160,51 +174,3 @@ func (t *Template) performOp(a, b reflect.Value, op ast.Operator) (result any, e
 	}
 	return false, ast.PosError(op, "unknown operator: %q", op.Value)
 }
-
-func handleIn(op ast.Operator, a, b reflect.Value) (c, d reflect.Value, err error) {
-	switch b.Kind() {
-	case reflect.Slice, reflect.Array:
-		if a.CanConvert(b.Type().Elem()) {
-			a = a.Convert(b.Type().Elem())
-		} else {
-			return a, b, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
-		}
-	case reflect.Map:
-		if a.CanConvert(b.Type().Key()) {
-			a = a.Convert(b.Type().Key())
-		} else {
-			return a, b, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
-		}
-	case reflect.String:
-		if a.Kind() != reflect.String {
-			return a, b, ast.PosError(op, "mismatched types in expression (%s and %s)", a.Type(), b.Type())
-		}
-	default:
-		return a, b, ast.PosError(op, "the in operator can only be used on strings, arrays, and slices (got %s and %s)", a.Type(), b.Type())
-	}
-	return a, b, nil
-}
-
-func handleNil(op ast.Operator, a, b reflect.Value) (any, error) {
-	if !a.IsValid() && !b.IsValid() {
-		return true, nil
-	} else if !a.IsValid() {
-		return nil, ast.PosError(op, "nil must be on the right side of an expression")
-	} else if !b.IsValid() {
-		if op.Value != "==" && op.Value != "!=" {
-			return nil, ast.PosError(op, "invalid operator for nil value (expected == or !=, got %s)", op.Value)
-		}
-
-		switch a.Kind() {
-		case reflect.Chan, reflect.Slice, reflect.Map, reflect.Func, reflect.Interface, reflect.Pointer:
-			if op.Value == "==" {
-				return a.IsNil(), nil
-			} else {
-				return !a.IsNil(), nil
-			}
-		default:
-			return nil, ast.PosError(op, "values of type %s cannot be compared against nil", a.Type())
-		}
-	}
-	return nil, nil
-}

for_tag.go

@@ -55,15 +55,6 @@ func (ft forTag) Run(tc *TagContext, block, args []ast.Node) error {
 	in = reflect.ValueOf(val)
 
 	switch in.Kind() {
-	case reflect.Int:
-		local := map[string]any{}
-		for i := range in.Int() {
-			local[vars[0]] = i
-			err = tc.Execute(block, local)
-			if err != nil {
-				return err
-			}
-		}
 	case reflect.Slice, reflect.Array:
 		local := map[string]any{}
 		for i := 0; i < in.Len(); i++ {
@@ -104,38 +95,6 @@ func (ft forTag) Run(tc *TagContext, block, args []ast.Node) error {
 
 			i++
 		}
-	case reflect.Func:
-		local := map[string]any{}
-		i := 0
-		if len(vars) == 1 {
-			for val := range in.Seq() {
-				local[vars[0]] = val.Interface()
-				err = tc.Execute(block, local)
-				if err != nil {
-					return err
-				}
-			}
-		} else if len(vars) == 2 {
-			for val1, val2 := range in.Seq2() {
-				local[vars[0]] = val1.Interface()
-				local[vars[1]] = val2.Interface()
-				err = tc.Execute(block, local)
-				if err != nil {
-					return err
-				}
-			}
-		} else {
-			for val1, val2 := range in.Seq2() {
-				local[vars[0]] = i
-				local[vars[1]] = val1.Interface()
-				local[vars[2]] = val2.Interface()
-				err = tc.Execute(block, local)
-				if err != nil {
-					return err
-				}
-				i++
-			}
-		}
 	}
 
 	return nil

go.mod

@@ -1,3 +1,3 @@
 module go.elara.ws/salix
 
-go 1.23.0
+go 1.21.2

namespace.go

@@ -22,8 +22,8 @@ type Namespace struct {
 	WriteOnSuccess bool
 	// NilToZero indictes whether nil pointer values should be converted to zero values of their underlying
 	// types.
-	NilToZero  bool
-	escapeHTML *bool
+	NilToZero bool
+	escapeHTML     *bool
 }
 
 // New returns a new template namespace

parser/salix.peg

@@ -129,7 +129,7 @@ ParamList = '(' params:(Expr ( ',' _ Expr )* )? ')' {
     return out, nil
 }
 
-Value = not:"!"? node:(Nil / MethodCall / FieldAccess / Index / String / RawString / Float / Integer / Bool / FuncCall / VariableOr / Ident / ParenExpr / Array / Map) {
+Value = not:"!"? node:(MethodCall / FieldAccess / Index / String / RawString / Float / Integer / Bool / FuncCall / VariableOr / Ident / ParenExpr / Array / Map) {
     return ast.Value{
         Node: node.(ast.Node),
         Not:  not != nil,
@@ -288,10 +288,6 @@ ArithmeticOp = ('+' / '-' / '/' / '*' / '%') {
     }, nil
 }
 
-Nil = "nil" {
-    return ast.Nil{Position: getPos(c)}, nil
-}
-
 Text = . [^#]* { return ast.Text{Data: c.text, Position: getPos(c)}, nil }
 
 _ "whitespace" ← [ \t\r\n]*

salix.go

@@ -26,7 +26,7 @@ type Template struct {
 	// WriteOnSuccess indicates whether the output should only be written if generation fully succeeds.
 	// This option buffers the output of the template, so it will use more memory. (default: false)
 	WriteOnSuccess bool
-	NilToZero      bool
+	NilToZero bool
 
 	tags   map[string]Tag
 	vars   map[string]any
@@ -239,8 +239,6 @@ func (t *Template) getValue(node ast.Node, local map[string]any) (any, error) {
 		return t.convertArray(node, local)
 	case ast.Assignment:
 		return node, t.handleAssignment(node, local)
-	case ast.Nil:
-		return nil, nil
 	default:
 		return nil, nil
 	}