Allow renaming struct fields using struct tags (#251)

Author: rtpt-erikgeiser

checker/checker_test.go

@@ -51,10 +51,10 @@ func TestVisitor_MethodNode(t *testing.T) {
 	var err error
 
 	env := &mockEnv{}
-	input := `Var.Set(1, 0.5) 
-				+ Var.Add(2) 
-				+ Var.Any(true) 
-				+ Var.Get() 
+	input := `Var.Set(1, 0.5)
+				+ Var.Add(2)
+				+ Var.Any(true)
+				+ Var.Get()
 				+ Var.Sub(3)
 				+ (Duration.String() == "" ? 1 : 0)
 				+ Interface.Method(0)
@@ -72,7 +72,7 @@ func TestVisitor_MethodNode(t *testing.T) {
 }
 
 func TestVisitor_BuiltinNode(t *testing.T) {
-	var typeTests = []string{
+	typeTests := []string{
 		`all(Tickets, {.Price > 0}) && any(map(Tickets, {.Price}), {# < 1000})`,
 		`filter(map(Tickets, {.Origin}), {len(#) != 3})[0]`,
 		`none(Any, {#.Any < 1})`,
@@ -102,7 +102,7 @@ func TestVisitor_ConstantNode(t *testing.T) {
 }
 
 func TestCheck(t *testing.T) {
-	var typeTests = []string{
+	typeTests := []string{
 		"!Bool",
 		"!BoolPtr == Bool",
 		"'a' == 'b' + 'c'",
@@ -551,6 +551,24 @@ func TestCheck_AsBool(t *testing.T) {
 	assert.Equal(t, "expected bool, but got int", err.Error())
 }
 
+func TestCheck_tagged_field_name(t *testing.T) {
+	input := `foo.bar`
+
+	tree, err := parser.Parse(input)
+	assert.NoError(t, err)
+
+	config := &conf.Config{}
+	expr.Env(struct {
+		x struct {
+			y bool `expr:"bar"`
+		} `expr:"foo"`
+	}{})
+	expr.AsBool()(config)
+
+	_, err = checker.Check(tree, config)
+	assert.Error(t, err)
+}
+
 //
 // Mock types
 //

checker/types.go

@@ -233,8 +233,7 @@ func fieldType(ntype reflect.Type, name string) (reflect.Type, bool) {
 		case reflect.Struct:
 			// First check all struct's fields.
 			for i := 0; i < ntype.NumField(); i++ {
-				f := ntype.Field(i)
-				if f.Name == name {
+				if f := ntype.Field(i); actualFieldName(f) == name {
 					return f.Type, true
 				}
 			}
@@ -372,3 +371,11 @@ func setTypeForIntegers(node ast.Node, t reflect.Type) {
 		}
 	}
 }
+
+func actualFieldName(f reflect.StructField) string {
+	if taggedName := f.Tag.Get("expr"); taggedName != "" {
+		return taggedName
+	}
+
+	return f.Name
+}

conf/types_table.go

@@ -82,7 +82,7 @@ func FieldsFromStruct(t reflect.Type) TypesTable {
 				}
 			}
 
-			types[f.Name] = Tag{Type: f.Type}
+			types[actualFieldName(f)] = Tag{Type: f.Type}
 		}
 	}
 
@@ -98,3 +98,11 @@ func dereference(t reflect.Type) reflect.Type {
 	}
 	return t
 }
+
+func actualFieldName(f reflect.StructField) string {
+	if taggedName := f.Tag.Get("expr"); taggedName != "" {
+		return taggedName
+	}
+
+	return f.Name
+}

docs/Getting-Started.md

@@ -29,7 +29,7 @@ func main() {
 
 ## Compile
 
-Usually we want to compile the code on save (For example, in [web user interface](https://antonmedv.github.io/expr/)).  
+Usually we want to compile the code on save (For example, in [web user interface](https://antonmedv.github.io/expr/)).
 
 ```go
 package main
@@ -65,7 +65,9 @@ func main() {
 }
 ```
 
-You may use existing types. For example, an environment can be a struct.
+You may use existing types. For example, an environment can be a struct. The
+struct fields can be renamed by adding struct tags such as `expr:"timestamp"` in
+the example below:
 
 ```go
 package main
@@ -86,11 +88,11 @@ func (Env) Format(t time.Time) string { return t.Format(time.RFC822) }
 
 type Tweet struct {
 	Text string
-	Date time.Time
+	Date time.Time `expr:"Timestamp"`
 }
 
 func main() {
-	code := `map(filter(Tweets, {len(.Text) > 0}), {.Text + Format(.Date)})`
+	code := `map(filter(Tweets, {len(.Text) > 0}), {.Text + Format(.Timestamp)})`
 
 	// We can use an empty instance of the struct as an environment.
 	program, err := expr.Compile(code, expr.Env(Env{}))
@@ -111,5 +113,5 @@ func main() {
 }
 ```
 
-* [Contents](README.md)
-* Next: [Custom functions](Custom-Functions.md)
+- [Contents](README.md)
+- Next: [Custom functions](Custom-Functions.md)

expr_test.go

@@ -114,6 +114,28 @@ func ExampleEnv() {
 	// Output: true
 }
 
+func ExampleEnv_tagged_field_names() {
+	env := struct {
+		FirstWord  string
+		Separator  string `expr:"Space"`
+		SecondWord string `expr:"second_word"`
+	}{
+		FirstWord:  "Hello",
+		Separator:  " ",
+		SecondWord: "World",
+	}
+
+	output, err := expr.Eval(`FirstWord + Space + second_word`, env)
+	if err != nil {
+		fmt.Printf("%v", err)
+		return
+	}
+
+	fmt.Printf("%v", output)
+
+	// Output : Hello World
+}
+
 func ExampleAsBool() {
 	env := map[string]int{
 		"foo": 0,
@@ -513,9 +535,10 @@ func TestExpr(t *testing.T) {
 			}
 			return ret
 		},
-		Inc:    func(a int) int { return a + 1 },
-		Nil:    nil,
-		Tweets: []tweet{{"Oh My God!", date}, {"How you doin?", date}, {"Could I be wearing any more clothes?", date}},
+		Inc:       func(a int) int { return a + 1 },
+		Nil:       nil,
+		Tweets:    []tweet{{"Oh My God!", date}, {"How you doin?", date}, {"Could I be wearing any more clothes?", date}},
+		Lowercase: "lowercase",
 	}
 
 	tests := []struct {
@@ -934,6 +957,10 @@ func TestExpr(t *testing.T) {
 			`OneDayDuration + Now`,
 			tnowPlusOne,
 		},
+		{
+			`lowercase`,
+			"lowercase",
+		},
 	}
 
 	for _, tt := range tests {
@@ -1229,6 +1256,7 @@ type divideError struct{ Message string }
 func (e divideError) Error() string {
 	return e.Message
 }
+
 func TestConstExpr_error_as_error(t *testing.T) {
 	env := map[string]interface{}{
 		"divide": func(a, b int) (int, error) {
@@ -1415,6 +1443,7 @@ type mockEnv struct {
 	NilInt               *int
 	NilSlice             []ticket
 	Tweets               []tweet
+	Lowercase            string `expr:"lowercase"`
 }
 
 func (e *mockEnv) GetInt() int {

file/source_test.go

@@ -43,7 +43,6 @@ func TestStringSource_SnippetSingleLine(t *testing.T) {
 	source := NewSource("hello, world")
 	if str, found := source.Snippet(1); !found {
 		t.Errorf(snippetNotFound, t.Name(), 1)
-
 	} else if str != "hello, world" {
 		t.Errorf(unexpectedSnippet, t.Name(), str, "hello, world")
 	}

vm/runtime.go

@@ -61,7 +61,19 @@ func fetch(from, i interface{}, nilsafe bool) interface{} {
 		}
 
 	case reflect.Struct:
-		value := v.FieldByName(reflect.ValueOf(i).String())
+		fieldName := reflect.ValueOf(i).String()
+
+		value := v.FieldByNameFunc(func(name string) bool {
+			switch field, _ := v.Type().FieldByName(name); field.Tag.Get("expr") {
+			case fieldName:
+				return true
+			case "":
+				return name == fieldName
+			default:
+				return false
+			}
+		})
+
 		if value.IsValid() && value.CanInterface() {
 			return value.Interface()
 		}

vm/vm_test.go

@@ -17,7 +17,7 @@ import (
 )
 
 func TestRun_debug(t *testing.T) {
-	var input = `[1, 2, 3]`
+	input := `[1, 2, 3]`
 
 	node, err := parser.Parse(input)
 	require.NoError(t, err)
@@ -256,6 +256,7 @@ func TestRun_method_with_error(t *testing.T) {
 
 	require.Equal(t, nil, out)
 }
+
 func TestRun_fast_methods(t *testing.T) {
 	input := `hello() + world()`
 
@@ -316,3 +317,28 @@ func TestRun_inner_method_with_error(t *testing.T) {
 
 	require.Equal(t, nil, out)
 }
+
+func TestRun_tagged_field_name(t *testing.T) {
+	input := `value`
+
+	tree, err := parser.Parse(input)
+	require.NoError(t, err)
+
+	env := struct {
+		V string `expr:"value"`
+	}{
+		V: "hello world",
+	}
+
+	funcConf := conf.New(env)
+	_, err = checker.Check(tree, funcConf)
+	require.NoError(t, err)
+
+	program, err := compiler.Compile(tree, funcConf)
+	require.NoError(t, err)
+
+	out, err := vm.Run(program, env)
+	require.NoError(t, err)
+
+	require.Equal(t, "hello world", out)
+}