Golang Format.String方法代码示例

// Action - Creates and returns action.
func (cmd *Command) Action(ctx action.Map) *action.Action {
	value := action.Format{Value: cmd.IAction}
	// If value is a string it's action name
	if name, ok := value.String(); ok {
		return &action.Action{
			Name: name,
			Ctx:  ctx,
		}
	}
	// If value is a map it's action
	if m, ok := value.Map(); ok {
		// Get action name
		name, _ := m.Get("name").String()
		// Get action ctx
		if c, ok := m.Get("ctx").Map(); ok {
			c.Merge(ctx)
			ctx = c
		}
		return &action.Action{
			Name: name,
			Ctx:  ctx,
		}
	}
	return nil
}

// trimFunc - Runs strings.TrimSpace on strings, lists and maps.
func trimFunc(in action.Format) interface{} {
	// If it's a string just trim
	if value, ok := in.String(); ok {
		return strings.TrimSpace(value)
	}

	// If it's a list - deep trim all values
	if value, ok := in.List(); ok {
		for num, val := range value {
			if result := trimFunc(action.Format{Value: val}); result != nil {
				value[num] = result
			}
		}
		return value
	}

	// If it's a map - deep trim all values
	if value, ok := in.Map(); ok {
		value.Transform(value.Keys(), trimFunc)
		return value
	}

	// Not expected type - don't touch
	return in.Value
}

// joinURL - joins query to uri
func joinURL(uri string, query action.Format) (u *url.URL, err error) {
	u, err = url.Parse(uri)
	if err != nil {
		return
	}

	if query.IsNil() {
		return
	}

	var urlQuery url.Values
	if u.RawQuery == "" {
		urlQuery = make(url.Values)
	} else {
		urlQuery, err = url.ParseQuery(u.RawQuery)
		if err != nil {
			return
		}
	}

	// If request query is map
	if q, ok := query.Map(); ok {
		urlQuery = mapToQuery(urlQuery, q)
	} else if q, ok := query.String(); ok { // or a string
		urlQuery, err = strToQuery(urlQuery, q)
		if err != nil {
			return
		}
	}

	u.RawQuery = urlQuery.Encode()

	return
}

// IsSelector - Checks if value is a selector.
func IsSelector(value action.Format) bool {
	// If value is a string it's a selector
	if _, ok := value.String(); ok {
		return true
	}

	// Maybe it's a map ?
	m, ok := value.Map()
	if !ok {
		return false
	}

	// If we formatted this map save it
	value.Value = m

	// If map contains $path it's a selector
	if !m.Get("$path").IsNil() {
		return true
	}

	// If map contains $extract it's a selector
	if !m.Get("$extract").IsNil() {
		return true
	}

	return false
}

// ToSelector - Transforms a value into a Selector.
// Accepts string and map values.
func ToSelector(value action.Format) selector.Extractor {
	// Try to get string value
	if path, ok := value.String(); ok {
		return &selector.Selector{
			Extractor: selector.TextExtractor,
			Path:      path,
		}
	}

	// Maybe it's a map...
	if m, ok := value.Map(); ok {
		return mapToSelector(m)
	}

	return nil
}

func printValue(value interface{}, n int) {
	switch value.(type) {
	case action.Map:
		print("\n")
		printMap(value.(action.Map), n+1)
	case []interface{}:
		print("\n")
		for _, v := range value.([]interface{}) {
			prints(n+1, "-")
			printValue(v, n+1)
		}
	case []string:
		print("\n")
		for _, v := range value.([]string) {
			prints(n+1, "- %v\n", v)
		}
	case string:
		lines := strings.Split(value.(string), "\n")
		if len(lines) <= 1 {
			print(value.(string))
			print("\n")
		} else {
			print("\n")
			for _, ln := range lines {
				prints(n+1, "%s\n", ln)
			}
		}
	default:
		f := action.Format{value}
		if v, ok := f.String(); ok {
			prints(0, "%#v\n", v)
		} else {
			prints(0, "%#v\n", value)
		}
	}
}