// 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) } } }