lookup.go

// Copyright (c) 2014 Alex Kalyvitis
// Portions Copyright (c) 2009 Michael Hoisie

package mustache

import (
	"reflect"
	"strings"
)

// The lookup function searches for a property that matches name within the
// context chain. We first start from the first item in the context chain which
// is the most likely to have the value we're looking for. If not found, we'll
// move up the chain and repeat.
func lookup(name string, context ...interface{}) (interface{}, bool) {
	// If the dot notation was used we split the word in two and perform two
	// consecutive lookups. If the first one fails we return no value and a
	// negative truth. Taken from github.com/hoisie/mustache.
	if name != "." && strings.Contains(name, ".") {
		parts := strings.SplitN(name, ".", 2)
		if value, ok := lookup(parts[0], context...); ok {
			return lookup(parts[1], value)
		}
		return nil, false
	}
	// Iterate over the context chain and try to match the name to a value.
	for _, c := range context {
		// Reflect on the value and type of the current context.
		reflectValue := reflect.ValueOf(c)
		reflectType := reflect.TypeOf(c)
		// If the name is ".", we should return the whole context as-is.
		if name == "." {
			return c, truth(reflectValue)
		}
		switch reflectValue.Kind() {
		// If the current context is a map, we'll look for a key in that map
		// that matches the name.
		case reflect.Map:
			// Try to match a map key to the name. For example:
			//
			// 	m := map[string]string{"foo": "bar"}
			//  mustache.Render("{{foo}}", m)
			item := reflectValue.MapIndex(reflect.ValueOf(name))
			if item.IsValid() {
				return item.Interface(), truth(item)
			}
		// If the current context is a struct, we'll look for a property in that
		// struct that matches the name. In the near future I'd like to add
		// support for matching struct names to tags so we can use lower_case
		// names in our templates which makes it more mustache like.
		case reflect.Struct:
			// First we'll try to match a field. For example:
			//
			// 	type Foo struct { Bar string }
			//  ctx := &Foo{"baz"}
			//  mustache.Render("{{Bar}}", ctx)
			field := reflectValue.FieldByName(name)
			if field.IsValid() {
				return field.Interface(), truth(field)
			}
			// If no field was matched, we'll try to match a method. This is
			// useful for methods that return a value. For example:
			//
			// 	type Foo struct { bar string }
			// 	func (f *Foo) Bar() string { return f.bar }
			//  ctx := &Foo{"baz"}
			//  mustache.Render("{{Bar}}", ctx)
			//
			method := reflectValue.MethodByName(name)
			if method.IsValid() && method.Type().NumIn() == 1 {
				out := method.Call(nil)[0]
				return out.Interface(), truth(out)
			}
			// If no method was matched, we'll try to match a tag. This is
			// useful for matching fields that have a different name than the
			// one we want to use in our templates. For example:
			//
			// 	type Foo struct {
			// 		Bar string `template:"baz"`
			// 	}
			//  ctx := &Foo{"qux"}
			//  mustache.Render("{{baz}}", ctx)
			//
			for i := 0; i < reflectValue.NumField(); i++ {
				field := reflectValue.Field(i)
				tag := reflectType.Field(i).Tag.Get("template")
				if tag == name {
					return field.Interface(), truth(field)
				}
			}
		}
		// If by this point no value was matched, we'll move up a step in the
		// chain and try to match a value there.
	}
	// We've exhausted the whole context chain and found nothing. Return a nil
	// value and a negative truth.
	return nil, false
}

// The truth function will tell us if r is a truthy value or not. This is
// important for sections as they will render their content based on the output
// of this function.
//
// Zero values are considered falsy. For example an empty string, the integer 0
// and so on are all considered falsy.
func truth(r reflect.Value) bool {
out:
	switch r.Kind() {
	case reflect.Array, reflect.Slice:
		return r.Len() > 0
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return r.Int() > 0
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return r.Uint() > 0
	case reflect.Float32, reflect.Float64:
		return r.Float() > 0
	case reflect.String:
		return r.String() != ""
	case reflect.Bool:
		return r.Bool()
	case reflect.Ptr, reflect.Interface:
		r = r.Elem()
		goto out
	default:
		return r.Interface() != nil
	}
}