diff options
Diffstat (limited to 'vendor/github.com/graphql-go/graphql/language/printer/printer.go')
-rw-r--r-- | vendor/github.com/graphql-go/graphql/language/printer/printer.go | 821 |
1 files changed, 0 insertions, 821 deletions
diff --git a/vendor/github.com/graphql-go/graphql/language/printer/printer.go b/vendor/github.com/graphql-go/graphql/language/printer/printer.go deleted file mode 100644 index 3add3852..00000000 --- a/vendor/github.com/graphql-go/graphql/language/printer/printer.go +++ /dev/null @@ -1,821 +0,0 @@ -package printer - -import ( - "fmt" - "strings" - - "github.com/graphql-go/graphql/language/ast" - "github.com/graphql-go/graphql/language/visitor" - "reflect" -) - -func getMapValue(m map[string]interface{}, key string) interface{} { - tokens := strings.Split(key, ".") - valMap := m - for _, token := range tokens { - v, ok := valMap[token] - if !ok { - return nil - } - switch v := v.(type) { - case []interface{}: - return v - case map[string]interface{}: - valMap = v - continue - default: - return v - } - } - return valMap -} -func getMapSliceValue(m map[string]interface{}, key string) []interface{} { - tokens := strings.Split(key, ".") - valMap := m - for _, token := range tokens { - v, ok := valMap[token] - if !ok { - return []interface{}{} - } - switch v := v.(type) { - case []interface{}: - return v - default: - return []interface{}{} - } - } - return []interface{}{} -} -func getMapValueString(m map[string]interface{}, key string) string { - tokens := strings.Split(key, ".") - valMap := m - for _, token := range tokens { - v, ok := valMap[token] - if !ok { - return "" - } - if v == nil { - return "" - } - switch v := v.(type) { - case map[string]interface{}: - valMap = v - continue - case string: - return v - default: - return fmt.Sprintf("%v", v) - } - } - return "" -} - -func toSliceString(slice interface{}) []string { - if slice == nil { - return []string{} - } - res := []string{} - switch reflect.TypeOf(slice).Kind() { - case reflect.Slice: - s := reflect.ValueOf(slice) - for i := 0; i < s.Len(); i++ { - elem := s.Index(i) - elemInterface := elem.Interface() - if elem, ok := elemInterface.(string); ok { - res = append(res, elem) - } - } - return res - default: - return res - } -} - -func join(str []string, sep string) string { - ss := []string{} - // filter out empty strings - for _, s := range str { - if s == "" { - continue - } - ss = append(ss, s) - } - return strings.Join(ss, sep) -} - -func wrap(start, maybeString, end string) string { - if maybeString == "" { - return maybeString - } - return start + maybeString + end -} - -// Given array, print each item on its own line, wrapped in an indented "{ }" block. -func block(maybeArray interface{}) string { - s := toSliceString(maybeArray) - if len(s) == 0 { - return "{}" - } - return indent("{\n"+join(s, "\n")) + "\n}" -} - -func indent(maybeString interface{}) string { - if maybeString == nil { - return "" - } - switch str := maybeString.(type) { - case string: - return strings.Replace(str, "\n", "\n ", -1) - } - return "" -} - -var printDocASTReducer = map[string]visitor.VisitFunc{ - "Name": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Name: - return visitor.ActionUpdate, node.Value - case map[string]interface{}: - return visitor.ActionUpdate, getMapValue(node, "Value") - } - return visitor.ActionNoChange, nil - }, - "Variable": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Variable: - return visitor.ActionUpdate, fmt.Sprintf("$%v", node.Name) - case map[string]interface{}: - return visitor.ActionUpdate, "$" + getMapValueString(node, "Name") - } - return visitor.ActionNoChange, nil - }, - - // Document - "Document": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Document: - definitions := toSliceString(node.Definitions) - return visitor.ActionUpdate, join(definitions, "\n\n") + "\n" - case map[string]interface{}: - definitions := toSliceString(getMapValue(node, "Definitions")) - return visitor.ActionUpdate, join(definitions, "\n\n") + "\n" - } - return visitor.ActionNoChange, nil - }, - "OperationDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.OperationDefinition: - op := string(node.Operation) - name := fmt.Sprintf("%v", node.Name) - - varDefs := wrap("(", join(toSliceString(node.VariableDefinitions), ", "), ")") - directives := join(toSliceString(node.Directives), " ") - selectionSet := fmt.Sprintf("%v", node.SelectionSet) - // Anonymous queries with no directives or variable definitions can use - // the query short form. - str := "" - if name == "" && directives == "" && varDefs == "" && op == ast.OperationTypeQuery { - str = selectionSet - } else { - str = join([]string{ - op, - join([]string{name, varDefs}, ""), - directives, - selectionSet, - }, " ") - } - return visitor.ActionUpdate, str - case map[string]interface{}: - - op := getMapValueString(node, "Operation") - name := getMapValueString(node, "Name") - - varDefs := wrap("(", join(toSliceString(getMapValue(node, "VariableDefinitions")), ", "), ")") - directives := join(toSliceString(getMapValue(node, "Directives")), " ") - selectionSet := getMapValueString(node, "SelectionSet") - str := "" - if name == "" && directives == "" && varDefs == "" && op == ast.OperationTypeQuery { - str = selectionSet - } else { - str = join([]string{ - op, - join([]string{name, varDefs}, ""), - directives, - selectionSet, - }, " ") - } - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "VariableDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.VariableDefinition: - variable := fmt.Sprintf("%v", node.Variable) - ttype := fmt.Sprintf("%v", node.Type) - defaultValue := fmt.Sprintf("%v", node.DefaultValue) - - return visitor.ActionUpdate, variable + ": " + ttype + wrap(" = ", defaultValue, "") - case map[string]interface{}: - - variable := getMapValueString(node, "Variable") - ttype := getMapValueString(node, "Type") - defaultValue := getMapValueString(node, "DefaultValue") - - return visitor.ActionUpdate, variable + ": " + ttype + wrap(" = ", defaultValue, "") - - } - return visitor.ActionNoChange, nil - }, - "SelectionSet": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.SelectionSet: - str := block(node.Selections) - return visitor.ActionUpdate, str - case map[string]interface{}: - selections := getMapValue(node, "Selections") - str := block(selections) - return visitor.ActionUpdate, str - - } - return visitor.ActionNoChange, nil - }, - "Field": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Argument: - name := fmt.Sprintf("%v", node.Name) - value := fmt.Sprintf("%v", node.Value) - return visitor.ActionUpdate, name + ": " + value - case map[string]interface{}: - - alias := getMapValueString(node, "Alias") - name := getMapValueString(node, "Name") - args := toSliceString(getMapValue(node, "Arguments")) - directives := toSliceString(getMapValue(node, "Directives")) - selectionSet := getMapValueString(node, "SelectionSet") - - str := join( - []string{ - wrap("", alias, ": ") + name + wrap("(", join(args, ", "), ")"), - join(directives, " "), - selectionSet, - }, - " ", - ) - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "Argument": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.FragmentSpread: - name := fmt.Sprintf("%v", node.Name) - directives := toSliceString(node.Directives) - return visitor.ActionUpdate, "..." + name + wrap(" ", join(directives, " "), "") - case map[string]interface{}: - name := getMapValueString(node, "Name") - value := getMapValueString(node, "Value") - return visitor.ActionUpdate, name + ": " + value - } - return visitor.ActionNoChange, nil - }, - - // Fragments - "FragmentSpread": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.InlineFragment: - typeCondition := fmt.Sprintf("%v", node.TypeCondition) - directives := toSliceString(node.Directives) - selectionSet := fmt.Sprintf("%v", node.SelectionSet) - return visitor.ActionUpdate, "... on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet - case map[string]interface{}: - name := getMapValueString(node, "Name") - directives := toSliceString(getMapValue(node, "Directives")) - return visitor.ActionUpdate, "..." + name + wrap(" ", join(directives, " "), "") - } - return visitor.ActionNoChange, nil - }, - "InlineFragment": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case map[string]interface{}: - typeCondition := getMapValueString(node, "TypeCondition") - directives := toSliceString(getMapValue(node, "Directives")) - selectionSet := getMapValueString(node, "SelectionSet") - return visitor.ActionUpdate, - join([]string{ - "...", - wrap("on ", typeCondition, ""), - join(directives, " "), - selectionSet, - }, " ") - } - return visitor.ActionNoChange, nil - }, - "FragmentDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.FragmentDefinition: - name := fmt.Sprintf("%v", node.Name) - typeCondition := fmt.Sprintf("%v", node.TypeCondition) - directives := toSliceString(node.Directives) - selectionSet := fmt.Sprintf("%v", node.SelectionSet) - return visitor.ActionUpdate, "fragment " + name + " on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet - case map[string]interface{}: - name := getMapValueString(node, "Name") - typeCondition := getMapValueString(node, "TypeCondition") - directives := toSliceString(getMapValue(node, "Directives")) - selectionSet := getMapValueString(node, "SelectionSet") - return visitor.ActionUpdate, "fragment " + name + " on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet - } - return visitor.ActionNoChange, nil - }, - - // Value - "IntValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.IntValue: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value) - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Value") - } - return visitor.ActionNoChange, nil - }, - "FloatValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.FloatValue: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value) - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Value") - } - return visitor.ActionNoChange, nil - }, - "StringValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.StringValue: - return visitor.ActionUpdate, `"` + fmt.Sprintf("%v", node.Value) + `"` - case map[string]interface{}: - return visitor.ActionUpdate, `"` + getMapValueString(node, "Value") + `"` - } - return visitor.ActionNoChange, nil - }, - "BooleanValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.BooleanValue: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value) - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Value") - } - return visitor.ActionNoChange, nil - }, - "EnumValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.EnumValue: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value) - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Value") - } - return visitor.ActionNoChange, nil - }, - "ListValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.ListValue: - return visitor.ActionUpdate, "[" + join(toSliceString(node.Values), ", ") + "]" - case map[string]interface{}: - return visitor.ActionUpdate, "[" + join(toSliceString(getMapValue(node, "Values")), ", ") + "]" - } - return visitor.ActionNoChange, nil - }, - "ObjectValue": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.ObjectValue: - return visitor.ActionUpdate, "{" + join(toSliceString(node.Fields), ", ") + "}" - case map[string]interface{}: - return visitor.ActionUpdate, "{" + join(toSliceString(getMapValue(node, "Fields")), ", ") + "}" - } - return visitor.ActionNoChange, nil - }, - "ObjectField": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.ObjectField: - name := fmt.Sprintf("%v", node.Name) - value := fmt.Sprintf("%v", node.Value) - return visitor.ActionUpdate, name + ": " + value - case map[string]interface{}: - name := getMapValueString(node, "Name") - value := getMapValueString(node, "Value") - return visitor.ActionUpdate, name + ": " + value - } - return visitor.ActionNoChange, nil - }, - - // Directive - "Directive": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Directive: - name := fmt.Sprintf("%v", node.Name) - args := toSliceString(node.Arguments) - return visitor.ActionUpdate, "@" + name + wrap("(", join(args, ", "), ")") - case map[string]interface{}: - name := getMapValueString(node, "Name") - args := toSliceString(getMapValue(node, "Arguments")) - return visitor.ActionUpdate, "@" + name + wrap("(", join(args, ", "), ")") - } - return visitor.ActionNoChange, nil - }, - - // Type - "Named": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.Named: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Name) - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Name") - } - return visitor.ActionNoChange, nil - }, - "List": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.List: - return visitor.ActionUpdate, "[" + fmt.Sprintf("%v", node.Type) + "]" - case map[string]interface{}: - return visitor.ActionUpdate, "[" + getMapValueString(node, "Type") + "]" - } - return visitor.ActionNoChange, nil - }, - "NonNull": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.NonNull: - return visitor.ActionUpdate, fmt.Sprintf("%v", node.Type) + "!" - case map[string]interface{}: - return visitor.ActionUpdate, getMapValueString(node, "Type") + "!" - } - return visitor.ActionNoChange, nil - }, - - // Type System Definitions - "SchemaDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.SchemaDefinition: - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "schema", - join(directives, " "), - block(node.OperationTypes), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - operationTypes := toSliceString(getMapValue(node, "OperationTypes")) - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "schema", - join(directives, " "), - block(operationTypes), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "OperationTypeDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.OperationTypeDefinition: - str := fmt.Sprintf("%v: %v", node.Operation, node.Type) - return visitor.ActionUpdate, str - case map[string]interface{}: - operation := getMapValueString(node, "Operation") - ttype := getMapValueString(node, "Type") - str := fmt.Sprintf("%v: %v", operation, ttype) - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "ScalarDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.ScalarDefinition: - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "scalar", - fmt.Sprintf("%v", node.Name), - join(directives, " "), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "scalar", - name, - join(directives, " "), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "ObjectDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.ObjectDefinition: - name := fmt.Sprintf("%v", node.Name) - interfaces := toSliceString(node.Interfaces) - fields := node.Fields - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "type", - name, - wrap("implements ", join(interfaces, ", "), ""), - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - interfaces := toSliceString(getMapValue(node, "Interfaces")) - fields := getMapValue(node, "Fields") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "type", - name, - wrap("implements ", join(interfaces, ", "), ""), - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "FieldDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.FieldDefinition: - name := fmt.Sprintf("%v", node.Name) - ttype := fmt.Sprintf("%v", node.Type) - args := toSliceString(node.Arguments) - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := name + wrap("(", join(args, ", "), ")") + ": " + ttype + wrap(" ", join(directives, " "), "") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - ttype := getMapValueString(node, "Type") - args := toSliceString(getMapValue(node, "Arguments")) - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := name + wrap("(", join(args, ", "), ")") + ": " + ttype + wrap(" ", join(directives, " "), "") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "InputValueDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.InputValueDefinition: - name := fmt.Sprintf("%v", node.Name) - ttype := fmt.Sprintf("%v", node.Type) - defaultValue := fmt.Sprintf("%v", node.DefaultValue) - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - name + ": " + ttype, - wrap("= ", defaultValue, ""), - join(directives, " "), - }, " ") - - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - ttype := getMapValueString(node, "Type") - defaultValue := getMapValueString(node, "DefaultValue") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - name + ": " + ttype, - wrap("= ", defaultValue, ""), - join(directives, " "), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "InterfaceDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.InterfaceDefinition: - name := fmt.Sprintf("%v", node.Name) - fields := node.Fields - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "interface", - name, - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - fields := getMapValue(node, "Fields") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "interface", - name, - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "UnionDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.UnionDefinition: - name := fmt.Sprintf("%v", node.Name) - types := toSliceString(node.Types) - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "union", - name, - join(directives, " "), - "= " + join(types, " | "), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - types := toSliceString(getMapValue(node, "Types")) - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "union", - name, - join(directives, " "), - "= " + join(types, " | "), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "EnumDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.EnumDefinition: - name := fmt.Sprintf("%v", node.Name) - values := node.Values - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "enum", - name, - join(directives, " "), - block(values), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - values := getMapValue(node, "Values") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "enum", - name, - join(directives, " "), - block(values), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "EnumValueDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.EnumValueDefinition: - name := fmt.Sprintf("%v", node.Name) - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - name, - join(directives, " "), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - name, - join(directives, " "), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "InputObjectDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.InputObjectDefinition: - name := fmt.Sprintf("%v", node.Name) - fields := node.Fields - directives := []string{} - for _, directive := range node.Directives { - directives = append(directives, fmt.Sprintf("%v", directive.Name)) - } - str := join([]string{ - "input", - name, - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - fields := getMapValue(node, "Fields") - directives := []string{} - for _, directive := range getMapSliceValue(node, "Directives") { - directives = append(directives, fmt.Sprintf("%v", directive)) - } - str := join([]string{ - "input", - name, - join(directives, " "), - block(fields), - }, " ") - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "TypeExtensionDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.TypeExtensionDefinition: - definition := fmt.Sprintf("%v", node.Definition) - str := "extend " + definition - return visitor.ActionUpdate, str - case map[string]interface{}: - definition := getMapValueString(node, "Definition") - str := "extend " + definition - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, - "DirectiveDefinition": func(p visitor.VisitFuncParams) (string, interface{}) { - switch node := p.Node.(type) { - case *ast.DirectiveDefinition: - args := wrap("(", join(toSliceString(node.Arguments), ", "), ")") - str := fmt.Sprintf("directive @%v%v on %v", node.Name, args, join(toSliceString(node.Locations), " | ")) - return visitor.ActionUpdate, str - case map[string]interface{}: - name := getMapValueString(node, "Name") - locations := toSliceString(getMapValue(node, "Locations")) - args := toSliceString(getMapValue(node, "Arguments")) - argsStr := wrap("(", join(args, ", "), ")") - str := fmt.Sprintf("directive @%v%v on %v", name, argsStr, join(locations, " | ")) - return visitor.ActionUpdate, str - } - return visitor.ActionNoChange, nil - }, -} - -func Print(astNode ast.Node) (printed interface{}) { - defer func() interface{} { - if r := recover(); r != nil { - return fmt.Sprintf("%v", astNode) - } - return printed - }() - printed = visitor.Visit(astNode, &visitor.VisitorOptions{ - LeaveKindMap: printDocASTReducer, - }, nil) - return printed -} |