mirror of
https://github.com/LukeHagar/libopenapi.git
synced 2025-12-09 12:37:49 +00:00
Added tag model build out with tests.
Working through patterns and re-applying them as I go, cleaning things up as I cook.
This commit is contained in:
Dave Shanley
@@ -1,17 +1,17 @@
|
||||
package v3
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
)
|
||||
|
||||
type Document struct {
|
||||
Version low.NodeReference[string]
|
||||
Info low.NodeReference[*Info]
|
||||
Servers []low.NodeReference[*Server]
|
||||
Paths *Paths
|
||||
Components *Components
|
||||
Security []*SecurityRequirement
|
||||
Tags []*Tag
|
||||
ExternalDocs *ExternalDoc
|
||||
Extensions map[string]low.ObjectReference
|
||||
Version low.NodeReference[string]
|
||||
Info low.NodeReference[*Info]
|
||||
Servers []low.NodeReference[*Server]
|
||||
Paths *Paths
|
||||
Components *Components
|
||||
Security []*SecurityRequirement
|
||||
Tags []low.NodeReference[*Tag]
|
||||
ExternalDocs *ExternalDoc
|
||||
Extensions map[string]low.ObjectReference
|
||||
}
|
||||
|
||||
@@ -1,13 +1,11 @@
|
||||
package v3
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"gopkg.in/yaml.v3"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
)
|
||||
|
||||
type ExternalDoc struct {
|
||||
Node *yaml.Node
|
||||
Description low.NodeReference[string]
|
||||
URL low.NodeReference[string]
|
||||
Extensions map[string]low.ObjectReference
|
||||
Description low.NodeReference[string]
|
||||
URL low.NodeReference[string]
|
||||
Extensions map[string]low.ObjectReference
|
||||
}
|
||||
|
||||
@@ -1,49 +1,53 @@
|
||||
package v3
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
const (
|
||||
Variables = "variables"
|
||||
)
|
||||
|
||||
type Server struct {
|
||||
URL low.NodeReference[string]
|
||||
Description low.NodeReference[string]
|
||||
Variables low.NodeReference[*map[string]low.NodeReference[*ServerVariable]]
|
||||
URL low.NodeReference[string]
|
||||
Description low.NodeReference[string]
|
||||
Variables low.NodeReference[map[string]low.NodeReference[*ServerVariable]]
|
||||
}
|
||||
|
||||
func (s *Server) Build(root *yaml.Node) error {
|
||||
kn, vars := utils.FindKeyNode("variables", root.Content)
|
||||
if vars == nil {
|
||||
return nil
|
||||
}
|
||||
variablesMap := make(map[string]low.NodeReference[*ServerVariable])
|
||||
if utils.IsNodeMap(vars) {
|
||||
var currentNode string
|
||||
var keyNode *yaml.Node
|
||||
for i, varNode := range vars.Content {
|
||||
if i%2 == 0 {
|
||||
currentNode = varNode.Value
|
||||
keyNode = varNode
|
||||
continue
|
||||
}
|
||||
variable := ServerVariable{}
|
||||
err := datamodel.BuildModel(varNode, &variable)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
variablesMap[currentNode] = low.NodeReference[*ServerVariable]{
|
||||
ValueNode: varNode,
|
||||
KeyNode: keyNode,
|
||||
Value: &variable,
|
||||
}
|
||||
}
|
||||
s.Variables = low.NodeReference[*map[string]low.NodeReference[*ServerVariable]]{
|
||||
KeyNode: kn,
|
||||
ValueNode: vars,
|
||||
Value: &variablesMap,
|
||||
}
|
||||
}
|
||||
return nil
|
||||
kn, vars := utils.FindKeyNode(Variables, root.Content)
|
||||
if vars == nil {
|
||||
return nil
|
||||
}
|
||||
variablesMap := make(map[string]low.NodeReference[*ServerVariable])
|
||||
if utils.IsNodeMap(vars) {
|
||||
var currentNode string
|
||||
var keyNode *yaml.Node
|
||||
for i, varNode := range vars.Content {
|
||||
if i%2 == 0 {
|
||||
currentNode = varNode.Value
|
||||
keyNode = varNode
|
||||
continue
|
||||
}
|
||||
variable := ServerVariable{}
|
||||
err := datamodel.BuildModel(varNode, &variable)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
variablesMap[currentNode] = low.NodeReference[*ServerVariable]{
|
||||
ValueNode: varNode,
|
||||
KeyNode: keyNode,
|
||||
Value: &variable,
|
||||
}
|
||||
}
|
||||
s.Variables = low.NodeReference[map[string]low.NodeReference[*ServerVariable]]{
|
||||
KeyNode: kn,
|
||||
ValueNode: vars,
|
||||
Value: variablesMap,
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -1,14 +1,44 @@
|
||||
package v3
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"gopkg.in/yaml.v3"
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
const (
|
||||
Tags = "tags"
|
||||
ExternalDocs = "externalDocs"
|
||||
)
|
||||
|
||||
type Tag struct {
|
||||
Node *yaml.Node
|
||||
Name low.NodeReference[string]
|
||||
Description low.NodeReference[string]
|
||||
ExternalDocs ExternalDoc
|
||||
Extensions map[string]low.ObjectReference
|
||||
Name low.NodeReference[string]
|
||||
Description low.NodeReference[string]
|
||||
ExternalDocs low.NodeReference[*ExternalDoc]
|
||||
Extensions map[low.NodeReference[string]]low.NodeReference[any]
|
||||
}
|
||||
|
||||
func (t *Tag) Build(root *yaml.Node) error {
|
||||
_, ln, exDocs := utils.FindKeyNodeFull(ExternalDocs, root.Content)
|
||||
|
||||
// extract extensions
|
||||
extensionMap, err := datamodel.ExtractExtensions(root)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.Extensions = extensionMap
|
||||
|
||||
// extract external docs
|
||||
var externalDoc ExternalDoc
|
||||
err = datamodel.BuildModel(exDocs, &externalDoc)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
t.ExternalDocs = low.NodeReference[*ExternalDoc]{
|
||||
Value: &externalDoc,
|
||||
KeyNode: ln,
|
||||
ValueNode: exDocs,
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -3,21 +3,21 @@ package low
|
||||
import "gopkg.in/yaml.v3"
|
||||
|
||||
type HasNode interface {
|
||||
GetNode() *yaml.Node
|
||||
GetNode() *yaml.Node
|
||||
}
|
||||
|
||||
type Buildable interface {
|
||||
Build(node *yaml.Node) error
|
||||
Build(node *yaml.Node) error
|
||||
}
|
||||
|
||||
type NodeReference[T any] struct {
|
||||
Value T
|
||||
ValueNode *yaml.Node
|
||||
KeyNode *yaml.Node
|
||||
Value T
|
||||
ValueNode *yaml.Node
|
||||
KeyNode *yaml.Node
|
||||
}
|
||||
|
||||
type ObjectReference struct {
|
||||
Value map[string]interface{}
|
||||
ValueNode *yaml.Node
|
||||
KeyNode *yaml.Node
|
||||
Value interface{}
|
||||
ValueNode *yaml.Node
|
||||
KeyNode *yaml.Node
|
||||
}
|
||||
|
||||
@@ -1,354 +1,411 @@
|
||||
package datamodel
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"sync"
|
||||
"fmt"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"sync"
|
||||
)
|
||||
|
||||
func BuildModel(node *yaml.Node, model interface{}) error {
|
||||
|
||||
if reflect.ValueOf(model).Type().Kind() != reflect.Pointer {
|
||||
return fmt.Errorf("cannot build model on non-pointer: %v", reflect.ValueOf(model).Type().Kind())
|
||||
}
|
||||
v := reflect.ValueOf(model).Elem()
|
||||
for i := 0; i < v.NumField(); i++ {
|
||||
if reflect.ValueOf(model).Type().Kind() != reflect.Pointer {
|
||||
return fmt.Errorf("cannot build model on non-pointer: %v", reflect.ValueOf(model).Type().Kind())
|
||||
}
|
||||
v := reflect.ValueOf(model).Elem()
|
||||
for i := 0; i < v.NumField(); i++ {
|
||||
|
||||
fName := v.Type().Field(i).Name
|
||||
fName := v.Type().Field(i).Name
|
||||
|
||||
// we need to find a matching field in the YAML, the cases may be off, so take no chances.
|
||||
cases := []utils.Case{utils.PascalCase, utils.CamelCase, utils.ScreamingSnakeCase,
|
||||
utils.SnakeCase, utils.KebabCase, utils.RegularCase}
|
||||
// we need to find a matching field in the YAML, the cases may be off, so take no chances.
|
||||
cases := []utils.Case{utils.PascalCase, utils.CamelCase, utils.ScreamingSnakeCase,
|
||||
utils.SnakeCase, utils.KebabCase, utils.RegularCase}
|
||||
|
||||
var vn, kn *yaml.Node
|
||||
for _, tryCase := range cases {
|
||||
kn, vn = utils.FindKeyNode(utils.ConvertCase(fName, tryCase), node.Content)
|
||||
if vn != nil {
|
||||
break
|
||||
}
|
||||
}
|
||||
var vn, kn *yaml.Node
|
||||
for _, tryCase := range cases {
|
||||
kn, vn = utils.FindKeyNode(utils.ConvertCase(fName, tryCase), node.Content)
|
||||
if vn != nil {
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if vn == nil {
|
||||
// no point in going on.
|
||||
continue
|
||||
}
|
||||
if vn == nil {
|
||||
// no point in going on.
|
||||
continue
|
||||
}
|
||||
|
||||
field := v.FieldByName(fName)
|
||||
kind := field.Kind()
|
||||
switch kind {
|
||||
case reflect.Struct, reflect.Slice, reflect.Map, reflect.Pointer:
|
||||
err := SetField(field, vn, kn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("unable to parse unsupported type: %v", kind)
|
||||
}
|
||||
field := v.FieldByName(fName)
|
||||
kind := field.Kind()
|
||||
switch kind {
|
||||
case reflect.Struct, reflect.Slice, reflect.Map, reflect.Pointer:
|
||||
err := SetField(field, vn, kn)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("unable to parse unsupported type: %v", kind)
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
return nil
|
||||
}
|
||||
|
||||
func SetField(field reflect.Value, valueNode *yaml.Node, keyNode *yaml.Node) error {
|
||||
switch field.Type() {
|
||||
switch field.Type() {
|
||||
|
||||
case reflect.TypeOf(map[string]low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
items := make(map[string]low.ObjectReference)
|
||||
var currentLabel string
|
||||
for i, sliceItem := range valueNode.Content {
|
||||
if i%2 == 0 {
|
||||
currentLabel = sliceItem.Value
|
||||
continue
|
||||
}
|
||||
var decoded map[string]interface{}
|
||||
err := sliceItem.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
items[currentLabel] = low.ObjectReference{
|
||||
Value: decoded,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
}
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(map[string]low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
items := make(map[string]low.ObjectReference)
|
||||
var currentLabel string
|
||||
for i, sliceItem := range valueNode.Content {
|
||||
if i%2 == 0 {
|
||||
currentLabel = sliceItem.Value
|
||||
continue
|
||||
}
|
||||
var decoded map[string]interface{}
|
||||
err := sliceItem.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
items[currentLabel] = low.ObjectReference{
|
||||
Value: decoded,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
}
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
|
||||
case reflect.TypeOf(map[string]low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
items := make(map[string]low.NodeReference[string])
|
||||
var currentLabel string
|
||||
for i, sliceItem := range valueNode.Content {
|
||||
if i%2 == 0 {
|
||||
currentLabel = sliceItem.Value
|
||||
continue
|
||||
}
|
||||
items[currentLabel] = low.NodeReference[string]{
|
||||
Value: sliceItem.Value,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
}
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
var decoded map[string]interface{}
|
||||
err := valueNode.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
or := low.ObjectReference{Value: decoded, ValueNode: valueNode}
|
||||
field.Set(reflect.ValueOf(or))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.ObjectReference
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
var decoded map[string]interface{}
|
||||
err := sliceItem.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
items = append(items, low.ObjectReference{
|
||||
Value: decoded,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeStringValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
nr := low.NodeReference[string]{
|
||||
Value: valueNode.Value,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[bool]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeBoolValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
bv, _ := strconv.ParseBool(valueNode.Value)
|
||||
nr := low.NodeReference[bool]{
|
||||
Value: bv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[int]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeIntValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.Atoi(valueNode.Value)
|
||||
nr := low.NodeReference[int]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[int64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeIntValue(valueNode) || utils.IsNodeFloatValue(valueNode) { //
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseInt(valueNode.Value, 10, 64)
|
||||
nr := low.NodeReference[int64]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[float32]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeFloatValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseFloat(valueNode.Value, 32)
|
||||
nr := low.NodeReference[float32]{
|
||||
Value: float32(fv),
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[float64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeFloatValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseFloat(valueNode.Value, 64)
|
||||
nr := low.NodeReference[float64]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[string]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
items = append(items, low.NodeReference[string]{
|
||||
Value: sliceItem.Value,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[float32]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[float32]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
fv, _ := strconv.ParseFloat(sliceItem.Value, 32)
|
||||
items = append(items, low.NodeReference[float32]{
|
||||
Value: float32(fv),
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[float64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[float64]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
fv, _ := strconv.ParseFloat(sliceItem.Value, 64)
|
||||
items = append(items, low.NodeReference[float64]{Value: fv, ValueNode: sliceItem})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[int]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[int]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
iv, _ := strconv.Atoi(sliceItem.Value)
|
||||
items = append(items, low.NodeReference[int]{
|
||||
Value: iv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[int64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[int64]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
iv, _ := strconv.ParseInt(sliceItem.Value, 10, 64)
|
||||
items = append(items, low.NodeReference[int64]{
|
||||
Value: iv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[bool]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[bool]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
bv, _ := strconv.ParseBool(sliceItem.Value)
|
||||
items = append(items, low.NodeReference[bool]{
|
||||
Value: bv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
default:
|
||||
// we want to ignore everything else.
|
||||
break
|
||||
}
|
||||
return nil
|
||||
case reflect.TypeOf(map[string]low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
items := make(map[string]low.NodeReference[string])
|
||||
var currentLabel string
|
||||
for i, sliceItem := range valueNode.Content {
|
||||
if i%2 == 0 {
|
||||
currentLabel = sliceItem.Value
|
||||
continue
|
||||
}
|
||||
items[currentLabel] = low.NodeReference[string]{
|
||||
Value: sliceItem.Value,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
}
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
var decoded map[string]interface{}
|
||||
err := valueNode.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if utils.IsNodeMap(valueNode) {
|
||||
if field.CanSet() {
|
||||
or := low.ObjectReference{Value: decoded, ValueNode: valueNode}
|
||||
field.Set(reflect.ValueOf(or))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.ObjectReference{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.ObjectReference
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
var decoded map[string]interface{}
|
||||
err := sliceItem.Decode(&decoded)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
items = append(items, low.ObjectReference{
|
||||
Value: decoded,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeStringValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
nr := low.NodeReference[string]{
|
||||
Value: valueNode.Value,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[bool]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeBoolValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
bv, _ := strconv.ParseBool(valueNode.Value)
|
||||
nr := low.NodeReference[bool]{
|
||||
Value: bv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[int]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeIntValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.Atoi(valueNode.Value)
|
||||
nr := low.NodeReference[int]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[int64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeIntValue(valueNode) || utils.IsNodeFloatValue(valueNode) { //
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseInt(valueNode.Value, 10, 64)
|
||||
nr := low.NodeReference[int64]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[float32]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeFloatValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseFloat(valueNode.Value, 32)
|
||||
nr := low.NodeReference[float32]{
|
||||
Value: float32(fv),
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf(low.NodeReference[float64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeFloatValue(valueNode) {
|
||||
if field.CanSet() {
|
||||
fv, _ := strconv.ParseFloat(valueNode.Value, 64)
|
||||
nr := low.NodeReference[float64]{
|
||||
Value: fv,
|
||||
ValueNode: valueNode,
|
||||
KeyNode: keyNode,
|
||||
}
|
||||
field.Set(reflect.ValueOf(nr))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[string]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[string]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
items = append(items, low.NodeReference[string]{
|
||||
Value: sliceItem.Value,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[float32]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[float32]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
fv, _ := strconv.ParseFloat(sliceItem.Value, 32)
|
||||
items = append(items, low.NodeReference[float32]{
|
||||
Value: float32(fv),
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[float64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[float64]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
fv, _ := strconv.ParseFloat(sliceItem.Value, 64)
|
||||
items = append(items, low.NodeReference[float64]{Value: fv, ValueNode: sliceItem})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[int]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[int]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
iv, _ := strconv.Atoi(sliceItem.Value)
|
||||
items = append(items, low.NodeReference[int]{
|
||||
Value: iv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[int64]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[int64]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
iv, _ := strconv.ParseInt(sliceItem.Value, 10, 64)
|
||||
items = append(items, low.NodeReference[int64]{
|
||||
Value: iv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
case reflect.TypeOf([]low.NodeReference[bool]{}):
|
||||
if valueNode != nil {
|
||||
if utils.IsNodeArray(valueNode) {
|
||||
if field.CanSet() {
|
||||
var items []low.NodeReference[bool]
|
||||
for _, sliceItem := range valueNode.Content {
|
||||
bv, _ := strconv.ParseBool(sliceItem.Value)
|
||||
items = append(items, low.NodeReference[bool]{
|
||||
Value: bv,
|
||||
ValueNode: sliceItem,
|
||||
KeyNode: valueNode,
|
||||
})
|
||||
}
|
||||
field.Set(reflect.ValueOf(items))
|
||||
}
|
||||
}
|
||||
}
|
||||
break
|
||||
default:
|
||||
// we want to ignore everything else.
|
||||
break
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func BuildModelAsync(n *yaml.Node, model interface{}, lwg *sync.WaitGroup, errors *[]error) {
|
||||
if n != nil {
|
||||
err := BuildModel(n, model)
|
||||
if err != nil {
|
||||
*errors = append(*errors, err)
|
||||
}
|
||||
}
|
||||
lwg.Done()
|
||||
if n != nil {
|
||||
err := BuildModel(n, model)
|
||||
if err != nil {
|
||||
*errors = append(*errors, err)
|
||||
}
|
||||
}
|
||||
lwg.Done()
|
||||
}
|
||||
|
||||
func ExtractExtensions(root *yaml.Node) (map[low.NodeReference[string]]low.NodeReference[any], error) {
|
||||
extensions := utils.FindExtensionNodes(root.Content)
|
||||
extensionMap := make(map[low.NodeReference[string]]low.NodeReference[any])
|
||||
for _, ext := range extensions {
|
||||
if utils.IsNodeMap(ext.Value) {
|
||||
var v interface{}
|
||||
err := ext.Value.Decode(&v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: v, KeyNode: ext.Key}
|
||||
}
|
||||
if utils.IsNodeStringValue(ext.Value) {
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: ext.Value.Value, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeFloatValue(ext.Value) {
|
||||
fv, _ := strconv.ParseFloat(ext.Value.Value, 64)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: fv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeIntValue(ext.Value) {
|
||||
iv, _ := strconv.ParseInt(ext.Value.Value, 10, 64)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: iv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeBoolValue(ext.Value) {
|
||||
bv, _ := strconv.ParseBool(ext.Value.Value)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: bv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeArray(ext.Value) {
|
||||
var v []interface{}
|
||||
err := ext.Value.Decode(&v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
}] = low.NodeReference[any]{Value: v, ValueNode: ext.Value}
|
||||
}
|
||||
}
|
||||
return extensionMap, nil
|
||||
}
|
||||
|
||||
@@ -1,78 +1,182 @@
|
||||
package openapi
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
v3 "github.com/pb33f/libopenapi/datamodel/low/3.0"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
"github.com/pb33f/libopenapi/datamodel/low"
|
||||
v3 "github.com/pb33f/libopenapi/datamodel/low/3.0"
|
||||
"github.com/pb33f/libopenapi/utils"
|
||||
"gopkg.in/yaml.v3"
|
||||
"strconv"
|
||||
"sync"
|
||||
)
|
||||
|
||||
func CreateDocument(spec []byte) (*v3.Document, error) {
|
||||
const (
|
||||
Info = "info"
|
||||
Servers = "servers"
|
||||
)
|
||||
|
||||
// extract details from spec
|
||||
info, err := datamodel.ExtractSpecInfo(spec)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
func CreateDocument(info *datamodel.SpecInfo) (*v3.Document, error) {
|
||||
|
||||
doc := v3.Document{Version: low.NodeReference[string]{Value: info.Version, ValueNode: info.RootNode}}
|
||||
doc := v3.Document{Version: low.NodeReference[string]{Value: info.Version, ValueNode: info.RootNode}}
|
||||
|
||||
// build an index
|
||||
//idx := index.NewSpecIndex(info.RootNode)
|
||||
//datamodel.BuildModel(info.RootNode.Content[0], &doc)
|
||||
// build an index
|
||||
//idx := index.NewSpecIndex(info.RootNode)
|
||||
//datamodel.BuildModel(info.RootNode.Content[0], &doc)
|
||||
var wg sync.WaitGroup
|
||||
var errors []error
|
||||
var runExtraction = func(info *datamodel.SpecInfo, doc *v3.Document,
|
||||
runFunc func(i *datamodel.SpecInfo, d *v3.Document) error,
|
||||
ers *[]error,
|
||||
wg *sync.WaitGroup) {
|
||||
|
||||
// extract info
|
||||
extractErr := extractInfo(info, &doc)
|
||||
if extractErr != nil {
|
||||
return nil, extractErr
|
||||
}
|
||||
if er := runFunc(info, doc); er != nil {
|
||||
*ers = append(*ers, er)
|
||||
}
|
||||
|
||||
// extract servers
|
||||
extractErr = extractServers(info, &doc)
|
||||
if extractErr != nil {
|
||||
return nil, extractErr
|
||||
}
|
||||
wg.Done()
|
||||
}
|
||||
|
||||
return &doc, nil
|
||||
wg.Add(3)
|
||||
go runExtraction(info, &doc, extractInfo, &errors, &wg)
|
||||
go runExtraction(info, &doc, extractServers, &errors, &wg)
|
||||
go runExtraction(info, &doc, extractTags, &errors, &wg)
|
||||
wg.Wait()
|
||||
|
||||
// todo fix this.
|
||||
if len(errors) > 0 {
|
||||
return &doc, errors[0]
|
||||
}
|
||||
|
||||
return &doc, nil
|
||||
}
|
||||
|
||||
func extractInfo(info *datamodel.SpecInfo, doc *v3.Document) error {
|
||||
_, ln, vn := utils.FindKeyNodeFull("info", info.RootNode.Content)
|
||||
if vn != nil {
|
||||
ir := v3.Info{}
|
||||
err := datamodel.BuildModel(vn, &ir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = ir.Build(vn)
|
||||
nr := low.NodeReference[*v3.Info]{Value: &ir, ValueNode: vn, KeyNode: ln}
|
||||
doc.Info = nr
|
||||
}
|
||||
return nil
|
||||
_, ln, vn := utils.FindKeyNodeFull(Info, info.RootNode.Content)
|
||||
if vn != nil {
|
||||
ir := v3.Info{}
|
||||
err := datamodel.BuildModel(vn, &ir)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
err = ir.Build(vn)
|
||||
nr := low.NodeReference[*v3.Info]{Value: &ir, ValueNode: vn, KeyNode: ln}
|
||||
doc.Info = nr
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func extractServers(info *datamodel.SpecInfo, doc *v3.Document) error {
|
||||
_, ln, vn := utils.FindKeyNodeFull("servers", info.RootNode.Content)
|
||||
if vn != nil {
|
||||
if utils.IsNodeArray(vn) {
|
||||
var servers []low.NodeReference[*v3.Server]
|
||||
for _, srvN := range vn.Content {
|
||||
if utils.IsNodeMap(srvN) {
|
||||
srvr := v3.Server{}
|
||||
err := datamodel.BuildModel(srvN, &srvr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
srvr.Build(srvN)
|
||||
servers = append(servers, low.NodeReference[*v3.Server]{
|
||||
Value: &srvr,
|
||||
ValueNode: srvN,
|
||||
KeyNode: ln,
|
||||
})
|
||||
}
|
||||
}
|
||||
doc.Servers = servers
|
||||
}
|
||||
}
|
||||
return nil
|
||||
_, ln, vn := utils.FindKeyNodeFull(Servers, info.RootNode.Content)
|
||||
if vn != nil {
|
||||
if utils.IsNodeArray(vn) {
|
||||
var servers []low.NodeReference[*v3.Server]
|
||||
for _, srvN := range vn.Content {
|
||||
if utils.IsNodeMap(srvN) {
|
||||
srvr := v3.Server{}
|
||||
err := datamodel.BuildModel(srvN, &srvr)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
srvr.Build(srvN)
|
||||
servers = append(servers, low.NodeReference[*v3.Server]{
|
||||
Value: &srvr,
|
||||
ValueNode: srvN,
|
||||
KeyNode: ln,
|
||||
})
|
||||
}
|
||||
}
|
||||
doc.Servers = servers
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func extractTags(info *datamodel.SpecInfo, doc *v3.Document) error {
|
||||
_, ln, vn := utils.FindKeyNodeFull(v3.Tags, info.RootNode.Content)
|
||||
if vn != nil {
|
||||
if utils.IsNodeArray(vn) {
|
||||
var tags []low.NodeReference[*v3.Tag]
|
||||
for _, tagN := range vn.Content {
|
||||
if utils.IsNodeMap(tagN) {
|
||||
tag := v3.Tag{}
|
||||
err := datamodel.BuildModel(tagN, &tag)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tag.Build(tagN)
|
||||
tags = append(tags, low.NodeReference[*v3.Tag]{
|
||||
Value: &tag,
|
||||
ValueNode: tagN,
|
||||
KeyNode: ln,
|
||||
})
|
||||
}
|
||||
}
|
||||
doc.Tags = tags
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ExtractExtensions(root *yaml.Node) (map[low.NodeReference[string]]low.NodeReference[any], error) {
|
||||
extensions := utils.FindExtensionNodes(root.Content)
|
||||
extensionMap := make(map[low.NodeReference[string]]low.NodeReference[any])
|
||||
for _, ext := range extensions {
|
||||
// this is an object, decode into an unknown map.
|
||||
if utils.IsNodeMap(ext.Value) {
|
||||
var v interface{}
|
||||
err := ext.Value.Decode(&v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: v, KeyNode: ext.Key}
|
||||
}
|
||||
if utils.IsNodeStringValue(ext.Value) {
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: ext.Value.Value, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeFloatValue(ext.Value) {
|
||||
fv, _ := strconv.ParseFloat(ext.Value.Value, 64)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: fv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeIntValue(ext.Value) {
|
||||
iv, _ := strconv.ParseInt(ext.Value.Value, 10, 64)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: iv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeBoolValue(ext.Value) {
|
||||
bv, _ := strconv.ParseBool(ext.Value.Value)
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: bv, ValueNode: ext.Value}
|
||||
}
|
||||
if utils.IsNodeArray(ext.Value) {
|
||||
var v []interface{}
|
||||
err := ext.Value.Decode(&v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
extensionMap[low.NodeReference[string]{
|
||||
Value: ext.Key.Value,
|
||||
KeyNode: ext.Key,
|
||||
ValueNode: ext.Value,
|
||||
}] = low.NodeReference[any]{Value: v, ValueNode: ext.Value}
|
||||
}
|
||||
}
|
||||
return extensionMap, nil
|
||||
}
|
||||
|
||||
@@ -1,32 +1,109 @@
|
||||
package openapi
|
||||
|
||||
import (
|
||||
"github.com/pb33f/libopenapi/datamodel"
|
||||
v3 "github.com/pb33f/libopenapi/datamodel/low/3.0"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"io/ioutil"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCreateDocument_NoData(t *testing.T) {
|
||||
doc, err := CreateDocument(nil)
|
||||
assert.Nil(t, doc)
|
||||
assert.Error(t, err)
|
||||
var doc *v3.Document
|
||||
|
||||
func init() {
|
||||
data, _ := ioutil.ReadFile("../test_specs/burgershop.openapi.yaml")
|
||||
info, _ := datamodel.ExtractSpecInfo(data)
|
||||
doc, _ = CreateDocument(info)
|
||||
}
|
||||
|
||||
func BenchmarkCreateDocument(b *testing.B) {
|
||||
data, _ := ioutil.ReadFile("../test_specs/burgershop.openapi.yaml")
|
||||
info, _ := datamodel.ExtractSpecInfo(data)
|
||||
for i := 0; i < b.N; i++ {
|
||||
doc, _ = CreateDocument(info)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCreateDocument(t *testing.T) {
|
||||
data, aErr := ioutil.ReadFile("../test_specs/burgershop.openapi.yaml")
|
||||
assert.NoError(t, aErr)
|
||||
|
||||
doc, err := CreateDocument(data)
|
||||
assert.NotNil(t, doc)
|
||||
assert.NoError(t, err)
|
||||
|
||||
assert.Equal(t, "3.0.1", doc.Version.Value)
|
||||
assert.Equal(t, "Burger Shop", doc.Info.Value.Title.Value)
|
||||
assert.NotEmpty(t, doc.Info.Value.Title.Value)
|
||||
}
|
||||
|
||||
func TestCreateDocument_Info(t *testing.T) {
|
||||
assert.Equal(t, "https://pb33f.io", doc.Info.Value.TermsOfService.Value)
|
||||
assert.Equal(t, "pb33f", doc.Info.Value.Contact.Value.Name.Value)
|
||||
assert.Equal(t, "buckaroo@pb33f.io", doc.Info.Value.Contact.Value.Email.Value)
|
||||
assert.Equal(t, "https://pb33f.io", doc.Info.Value.Contact.Value.URL.Value)
|
||||
assert.Equal(t, "pb33f", doc.Info.Value.License.Value.Name.Value)
|
||||
assert.Equal(t, "https://pb33f.io/made-up", doc.Info.Value.License.Value.URL.Value)
|
||||
}
|
||||
|
||||
func TestCreateDocument_Servers(t *testing.T) {
|
||||
assert.Len(t, doc.Servers, 2)
|
||||
server1 := doc.Servers[0]
|
||||
server2 := doc.Servers[1]
|
||||
|
||||
// server 1
|
||||
assert.Equal(t, "{scheme}://api.pb33f.io", server1.Value.URL.Value)
|
||||
assert.NotEmpty(t, server1.Value.Description.Value)
|
||||
assert.Len(t, server1.Value.Variables.Value, 1)
|
||||
assert.Len(t, server1.Value.Variables.Value["scheme"].Value.Enum, 2)
|
||||
assert.Equal(t, server1.Value.Variables.Value["scheme"].Value.Default.Value, "https")
|
||||
assert.NotEmpty(t, server1.Value.Variables.Value["scheme"].Value.Description.Value)
|
||||
|
||||
// server 2
|
||||
assert.Equal(t, "https://{domain}.{host}.com", server2.Value.URL.Value)
|
||||
assert.NotEmpty(t, server2.Value.Description.Value)
|
||||
assert.Len(t, server2.Value.Variables.Value, 2)
|
||||
assert.Equal(t, server2.Value.Variables.Value["domain"].Value.Default.Value, "api")
|
||||
assert.NotEmpty(t, server2.Value.Variables.Value["domain"].Value.Description.Value)
|
||||
assert.NotEmpty(t, server2.Value.Variables.Value["host"].Value.Description.Value)
|
||||
assert.Equal(t, server2.Value.Variables.Value["host"].Value.Default.Value, "pb33f.io")
|
||||
assert.Equal(t, "1.2", doc.Info.Value.Version.Value)
|
||||
}
|
||||
|
||||
func TestCreateDocument_Tags(t *testing.T) {
|
||||
assert.Len(t, doc.Tags, 2)
|
||||
|
||||
// tag1
|
||||
assert.Equal(t, "Burgers", doc.Tags[0].Value.Name.Value)
|
||||
assert.NotEmpty(t, doc.Tags[0].Value.Description.Value)
|
||||
assert.NotNil(t, doc.Tags[0].Value.ExternalDocs.Value)
|
||||
assert.Equal(t, "https://pb33f.io", doc.Tags[0].Value.ExternalDocs.Value.URL.Value)
|
||||
assert.NotEmpty(t, doc.Tags[0].Value.ExternalDocs.Value.URL.Value)
|
||||
assert.Len(t, doc.Tags[0].Value.Extensions, 7)
|
||||
|
||||
for key, extension := range doc.Tags[0].Value.Extensions {
|
||||
switch key.Value {
|
||||
case "x-internal-ting":
|
||||
assert.Equal(t, "somethingSpecial", extension.Value)
|
||||
case "x-internal-tong":
|
||||
assert.Equal(t, int64(1), extension.Value)
|
||||
case "x-internal-tang":
|
||||
assert.Equal(t, 1.2, extension.Value)
|
||||
case "x-internal-tung":
|
||||
assert.Equal(t, true, extension.Value)
|
||||
case "x-internal-arr":
|
||||
assert.Len(t, extension.Value, 2)
|
||||
assert.Equal(t, "one", extension.Value.([]interface{})[0].(string))
|
||||
case "x-internal-arrmap":
|
||||
assert.Len(t, extension.Value, 2)
|
||||
assert.Equal(t, "now", extension.Value.([]interface{})[0].(map[string]interface{})["what"])
|
||||
case "x-something-else":
|
||||
// crazy times in the upside down. this API should be avoided for the higher up use cases.
|
||||
// this is why we will need a higher level API to this model, this looks cool and all, but dude.
|
||||
assert.Equal(t, "now?", extension.Value.(map[string]interface{})["ok"].([]interface{})[0].(map[string]interface{})["what"])
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/// tag2
|
||||
assert.Equal(t, "Dressing", doc.Tags[1].Value.Name.Value)
|
||||
assert.NotEmpty(t, doc.Tags[1].Value.Description.Value)
|
||||
assert.NotNil(t, doc.Tags[1].Value.ExternalDocs.Value)
|
||||
assert.Equal(t, "https://pb33f.io", doc.Tags[1].Value.ExternalDocs.Value.URL.Value)
|
||||
assert.NotEmpty(t, doc.Tags[1].Value.ExternalDocs.Value.URL.Value)
|
||||
assert.Len(t, doc.Tags[1].Value.Extensions, 0)
|
||||
|
||||
}
|
||||
|
||||
@@ -10,25 +10,38 @@ info:
|
||||
url: https://pb33f.io
|
||||
license:
|
||||
name: pb33f
|
||||
url: https://quobix.com/made-up
|
||||
url: https://pb33f.io/made-up
|
||||
version: "1.2"
|
||||
tags:
|
||||
- name: "Burgers"
|
||||
description: "All kinds of yummy burgers."
|
||||
externalDocs:
|
||||
description: "Find out more"
|
||||
url: "https://quobix.com/"
|
||||
url: "https://pb33f.io"
|
||||
x-internal-ting: somethingSpecial
|
||||
x-internal-tong: 1
|
||||
x-internal-tang: 1.2
|
||||
x-internal-tung: true
|
||||
x-internal-arr:
|
||||
- one
|
||||
- two
|
||||
x-internal-arrmap:
|
||||
- what: now
|
||||
- why: that
|
||||
x-something-else:
|
||||
ok:
|
||||
- what: now?
|
||||
- name: "Dressing"
|
||||
description: "Variety of dressings: cheese, veggie, oil and a lot more"
|
||||
externalDocs:
|
||||
description: "Find out more information about our products)"
|
||||
url: "https://quobix.com/"
|
||||
url: "https://pb33f.io"
|
||||
servers:
|
||||
- url: "{scheme}://api.quobix.com"
|
||||
- url: "{scheme}://api.pb33f.io"
|
||||
description: "this is our main API server, for all fun API things."
|
||||
variables:
|
||||
scheme:
|
||||
enum: [https]
|
||||
enum: [https, wss]
|
||||
default: https
|
||||
description: this is a server variable for the scheme
|
||||
- url: "https://{domain}.{host}.com"
|
||||
@@ -38,8 +51,8 @@ servers:
|
||||
default: "api"
|
||||
description: the default API domain is 'api'
|
||||
host:
|
||||
default: "quobix.com"
|
||||
description: the default host for this API is 'quobix.com'
|
||||
default: "pb33f.io"
|
||||
description: the default host for this API is 'pb33f.com'
|
||||
paths:
|
||||
/burgers:
|
||||
post:
|
||||
|
||||
738
utils/utils.go
738
utils/utils.go
@@ -1,265 +1,285 @@
|
||||
package utils
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"github.com/iancoleman/strcase"
|
||||
"github.com/vmware-labs/yaml-jsonpath/pkg/yamlpath"
|
||||
"gopkg.in/yaml.v3"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"github.com/iancoleman/strcase"
|
||||
"github.com/vmware-labs/yaml-jsonpath/pkg/yamlpath"
|
||||
"gopkg.in/yaml.v3"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type Case int8
|
||||
|
||||
const (
|
||||
// OpenApi3 is used by all OpenAPI 3+ docs
|
||||
OpenApi3 = "openapi"
|
||||
// OpenApi3 is used by all OpenAPI 3+ docs
|
||||
OpenApi3 = "openapi"
|
||||
|
||||
// OpenApi2 is used by all OpenAPI 2 docs, formerly known as swagger.
|
||||
OpenApi2 = "swagger"
|
||||
// OpenApi2 is used by all OpenAPI 2 docs, formerly known as swagger.
|
||||
OpenApi2 = "swagger"
|
||||
|
||||
// AsyncApi is used by akk AsyncAPI docs, all versions.
|
||||
AsyncApi = "asyncapi"
|
||||
// AsyncApi is used by akk AsyncAPI docs, all versions.
|
||||
AsyncApi = "asyncapi"
|
||||
|
||||
PascalCase Case = iota
|
||||
CamelCase
|
||||
ScreamingSnakeCase
|
||||
SnakeCase
|
||||
KebabCase
|
||||
ScreamingKebabCase
|
||||
RegularCase
|
||||
PascalCase Case = iota
|
||||
CamelCase
|
||||
ScreamingSnakeCase
|
||||
SnakeCase
|
||||
KebabCase
|
||||
ScreamingKebabCase
|
||||
RegularCase
|
||||
)
|
||||
|
||||
// FindNodes will find a node based on JSONPath, it accepts raw yaml/json as input.
|
||||
func FindNodes(yamlData []byte, jsonPath string) ([]*yaml.Node, error) {
|
||||
jsonPath = FixContext(jsonPath)
|
||||
jsonPath = FixContext(jsonPath)
|
||||
|
||||
var node yaml.Node
|
||||
yaml.Unmarshal(yamlData, &node)
|
||||
var node yaml.Node
|
||||
yaml.Unmarshal(yamlData, &node)
|
||||
|
||||
path, err := yamlpath.NewPath(jsonPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
results, _ := path.Find(&node)
|
||||
return results, nil
|
||||
path, err := yamlpath.NewPath(jsonPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
results, _ := path.Find(&node)
|
||||
return results, nil
|
||||
}
|
||||
|
||||
func FindLastChildNode(node *yaml.Node) *yaml.Node {
|
||||
s := len(node.Content) - 1
|
||||
if s < 0 {
|
||||
s = 0
|
||||
}
|
||||
if len(node.Content) > 0 && len(node.Content[s].Content) > 0 {
|
||||
return FindLastChildNode(node.Content[s])
|
||||
} else {
|
||||
if len(node.Content) > 0 {
|
||||
return node.Content[s]
|
||||
}
|
||||
return node
|
||||
}
|
||||
s := len(node.Content) - 1
|
||||
if s < 0 {
|
||||
s = 0
|
||||
}
|
||||
if len(node.Content) > 0 && len(node.Content[s].Content) > 0 {
|
||||
return FindLastChildNode(node.Content[s])
|
||||
} else {
|
||||
if len(node.Content) > 0 {
|
||||
return node.Content[s]
|
||||
}
|
||||
return node
|
||||
}
|
||||
}
|
||||
|
||||
// BuildPath will construct a JSONPath from a base and an array of strings.
|
||||
func BuildPath(basePath string, segs []string) string {
|
||||
|
||||
path := strings.Join(segs, ".")
|
||||
path := strings.Join(segs, ".")
|
||||
|
||||
// trim that last period.
|
||||
if len(path) > 0 && path[len(path)-1] == '.' {
|
||||
path = path[:len(path)-1]
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", basePath, path)
|
||||
// trim that last period.
|
||||
if len(path) > 0 && path[len(path)-1] == '.' {
|
||||
path = path[:len(path)-1]
|
||||
}
|
||||
return fmt.Sprintf("%s.%s", basePath, path)
|
||||
}
|
||||
|
||||
// FindNodesWithoutDeserializing will find a node based on JSONPath, without deserializing from yaml/json
|
||||
func FindNodesWithoutDeserializing(node *yaml.Node, jsonPath string) ([]*yaml.Node, error) {
|
||||
jsonPath = FixContext(jsonPath)
|
||||
jsonPath = FixContext(jsonPath)
|
||||
|
||||
path, err := yamlpath.NewPath(jsonPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
results, _ := path.Find(node)
|
||||
return results, nil
|
||||
path, err := yamlpath.NewPath(jsonPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
results, _ := path.Find(node)
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// ConvertInterfaceIntoStringMap will convert an unknown input into a string map.
|
||||
func ConvertInterfaceIntoStringMap(context interface{}) map[string]string {
|
||||
converted := make(map[string]string)
|
||||
if context != nil {
|
||||
if v, ok := context.(map[string]interface{}); ok {
|
||||
for k, n := range v {
|
||||
if s, okB := n.(string); okB {
|
||||
converted[k] = s
|
||||
}
|
||||
}
|
||||
}
|
||||
if v, ok := context.(map[string]string); ok {
|
||||
for k, n := range v {
|
||||
converted[k] = n
|
||||
}
|
||||
}
|
||||
}
|
||||
return converted
|
||||
converted := make(map[string]string)
|
||||
if context != nil {
|
||||
if v, ok := context.(map[string]interface{}); ok {
|
||||
for k, n := range v {
|
||||
if s, okB := n.(string); okB {
|
||||
converted[k] = s
|
||||
}
|
||||
}
|
||||
}
|
||||
if v, ok := context.(map[string]string); ok {
|
||||
for k, n := range v {
|
||||
converted[k] = n
|
||||
}
|
||||
}
|
||||
}
|
||||
return converted
|
||||
}
|
||||
|
||||
// ConvertInterfaceToStringArray will convert an unknown input map type into a string array/slice
|
||||
func ConvertInterfaceToStringArray(raw interface{}) []string {
|
||||
if vals, ok := raw.(map[string]interface{}); ok {
|
||||
var s []string
|
||||
for _, v := range vals {
|
||||
if g, y := v.([]interface{}); y {
|
||||
for _, q := range g {
|
||||
s = append(s, fmt.Sprint(q))
|
||||
}
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
if vals, ok := raw.(map[string][]string); ok {
|
||||
var s []string
|
||||
for _, v := range vals {
|
||||
s = append(s, v...)
|
||||
}
|
||||
return s
|
||||
}
|
||||
return nil
|
||||
if vals, ok := raw.(map[string]interface{}); ok {
|
||||
var s []string
|
||||
for _, v := range vals {
|
||||
if g, y := v.([]interface{}); y {
|
||||
for _, q := range g {
|
||||
s = append(s, fmt.Sprint(q))
|
||||
}
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
if vals, ok := raw.(map[string][]string); ok {
|
||||
var s []string
|
||||
for _, v := range vals {
|
||||
s = append(s, v...)
|
||||
}
|
||||
return s
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ConvertInterfaceArrayToStringArray will convert an unknown interface array type, into a string slice
|
||||
func ConvertInterfaceArrayToStringArray(raw interface{}) []string {
|
||||
if vals, ok := raw.([]interface{}); ok {
|
||||
s := make([]string, len(vals))
|
||||
for i, v := range vals {
|
||||
s[i] = fmt.Sprint(v)
|
||||
}
|
||||
return s
|
||||
}
|
||||
if vals, ok := raw.([]string); ok {
|
||||
return vals
|
||||
}
|
||||
return nil
|
||||
if vals, ok := raw.([]interface{}); ok {
|
||||
s := make([]string, len(vals))
|
||||
for i, v := range vals {
|
||||
s[i] = fmt.Sprint(v)
|
||||
}
|
||||
return s
|
||||
}
|
||||
if vals, ok := raw.([]string); ok {
|
||||
return vals
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ExtractValueFromInterfaceMap pulls out an unknown value from a map using a string key
|
||||
func ExtractValueFromInterfaceMap(name string, raw interface{}) interface{} {
|
||||
|
||||
if propMap, ok := raw.(map[string]interface{}); ok {
|
||||
if props, okn := propMap[name].([]interface{}); okn {
|
||||
return props
|
||||
} else {
|
||||
return propMap[name]
|
||||
}
|
||||
}
|
||||
if propMap, ok := raw.(map[string][]string); ok {
|
||||
return propMap[name]
|
||||
}
|
||||
if propMap, ok := raw.(map[string]interface{}); ok {
|
||||
if props, okn := propMap[name].([]interface{}); okn {
|
||||
return props
|
||||
} else {
|
||||
return propMap[name]
|
||||
}
|
||||
}
|
||||
if propMap, ok := raw.(map[string][]string); ok {
|
||||
return propMap[name]
|
||||
}
|
||||
|
||||
return nil
|
||||
return nil
|
||||
}
|
||||
|
||||
// FindFirstKeyNode will locate the first key and value yaml.Node based on a key.
|
||||
func FindFirstKeyNode(key string, nodes []*yaml.Node, depth int) (keyNode *yaml.Node, valueNode *yaml.Node) {
|
||||
if depth > 40 {
|
||||
return nil, nil
|
||||
}
|
||||
for i, v := range nodes {
|
||||
if key != "" && key == v.Value {
|
||||
if i+1 >= len(nodes) {
|
||||
return v, nodes[i] // next node is what we need.
|
||||
}
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
if len(v.Content) > 0 {
|
||||
depth++
|
||||
x, y := FindFirstKeyNode(key, v.Content, depth)
|
||||
if x != nil && y != nil {
|
||||
return x, y
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
if depth > 40 {
|
||||
return nil, nil
|
||||
}
|
||||
for i, v := range nodes {
|
||||
if key != "" && key == v.Value {
|
||||
if i+1 >= len(nodes) {
|
||||
return v, nodes[i] // next node is what we need.
|
||||
}
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
if len(v.Content) > 0 {
|
||||
depth++
|
||||
x, y := FindFirstKeyNode(key, v.Content, depth)
|
||||
if x != nil && y != nil {
|
||||
return x, y
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// KeyNodeResult is a result from a KeyNodeSearch performed by the FindAllKeyNodesWithPath
|
||||
type KeyNodeResult struct {
|
||||
KeyNode *yaml.Node
|
||||
ValueNode *yaml.Node
|
||||
Parent *yaml.Node
|
||||
Path []yaml.Node
|
||||
KeyNode *yaml.Node
|
||||
ValueNode *yaml.Node
|
||||
Parent *yaml.Node
|
||||
Path []yaml.Node
|
||||
}
|
||||
|
||||
// KeyNodeSearch keeps a track of everything we have found on our adventure down the trees.
|
||||
type KeyNodeSearch struct {
|
||||
Key string
|
||||
Ignore []string
|
||||
Results []*KeyNodeResult
|
||||
AllowExtensions bool
|
||||
Key string
|
||||
Ignore []string
|
||||
Results []*KeyNodeResult
|
||||
AllowExtensions bool
|
||||
}
|
||||
|
||||
// FindKeyNodeTop is a non-recursive search of top level nodes for a key, will not look at content.
|
||||
// Returns the key and value
|
||||
func FindKeyNodeTop(key string, nodes []*yaml.Node) (keyNode *yaml.Node, valueNode *yaml.Node) {
|
||||
|
||||
for i, v := range nodes {
|
||||
if key == v.Value {
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
for i, v := range nodes {
|
||||
if key == v.Value {
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// FindKeyNode is a non-recursive search of a *yaml.Node Content for a child node with a key.
|
||||
// Returns the key and value
|
||||
func FindKeyNode(key string, nodes []*yaml.Node) (keyNode *yaml.Node, valueNode *yaml.Node) {
|
||||
|
||||
//numNodes := len(nodes)
|
||||
for i, v := range nodes {
|
||||
if i%2 == 0 && key == v.Value {
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
for x, j := range v.Content {
|
||||
if key == j.Value {
|
||||
if IsNodeMap(v) {
|
||||
if x+1 == len(v.Content) {
|
||||
return v, v.Content[x]
|
||||
}
|
||||
return v, v.Content[x+1] // next node is what we need.
|
||||
//numNodes := len(nodes)
|
||||
for i, v := range nodes {
|
||||
if i%2 == 0 && key == v.Value {
|
||||
return v, nodes[i+1] // next node is what we need.
|
||||
}
|
||||
for x, j := range v.Content {
|
||||
if key == j.Value {
|
||||
if IsNodeMap(v) {
|
||||
if x+1 == len(v.Content) {
|
||||
return v, v.Content[x]
|
||||
}
|
||||
return v, v.Content[x+1] // next node is what we need.
|
||||
|
||||
}
|
||||
if IsNodeArray(v) {
|
||||
return v, v.Content[x]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
if IsNodeArray(v) {
|
||||
return v, v.Content[x]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
func FindKeyNodeFull(key string, nodes []*yaml.Node) (keyNode *yaml.Node, labelNode *yaml.Node, valueNode *yaml.Node) {
|
||||
for i, v := range nodes {
|
||||
if i%2 == 0 && key == v.Value {
|
||||
return v, nodes[i], nodes[i+1] // next node is what we need.
|
||||
}
|
||||
for x, j := range v.Content {
|
||||
if key == j.Value {
|
||||
if IsNodeMap(v) {
|
||||
if x+1 == len(v.Content) {
|
||||
return v, v.Content[x], v.Content[x]
|
||||
}
|
||||
return v, v.Content[x], v.Content[x+1] // next node is what we need.
|
||||
for i, v := range nodes {
|
||||
if i%2 == 0 && key == v.Value {
|
||||
return v, nodes[i], nodes[i+1] // next node is what we need.
|
||||
}
|
||||
for x, j := range v.Content {
|
||||
if key == j.Value {
|
||||
if IsNodeMap(v) {
|
||||
if x+1 == len(v.Content) {
|
||||
return v, v.Content[x], v.Content[x]
|
||||
}
|
||||
return v, v.Content[x], v.Content[x+1] // next node is what we need.
|
||||
|
||||
}
|
||||
if IsNodeArray(v) {
|
||||
return v, v.Content[x], v.Content[x]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil, nil
|
||||
}
|
||||
if IsNodeArray(v) {
|
||||
return v, v.Content[x], v.Content[x]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil, nil, nil
|
||||
}
|
||||
|
||||
type ExtensionNode struct {
|
||||
Key *yaml.Node
|
||||
Value *yaml.Node
|
||||
}
|
||||
|
||||
func FindExtensionNodes(nodes []*yaml.Node) []*ExtensionNode {
|
||||
var extensions []*ExtensionNode
|
||||
for i, v := range nodes {
|
||||
if i%2 == 0 && strings.HasPrefix(v.Value, "x-") {
|
||||
if i+1 < len(nodes) {
|
||||
extensions = append(extensions, &ExtensionNode{
|
||||
Key: v,
|
||||
Value: nodes[i+1],
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
return extensions
|
||||
}
|
||||
|
||||
var ObjectLabel = "object"
|
||||
@@ -273,257 +293,257 @@ var SchemaSource = "https://json-schema.org/draft/2020-12/schema"
|
||||
var SchemaId = "https://quobix.com/api/vacuum"
|
||||
|
||||
func MakeTagReadable(node *yaml.Node) string {
|
||||
switch node.Tag {
|
||||
case "!!map":
|
||||
return ObjectLabel
|
||||
case "!!seq":
|
||||
return ArrayLabel
|
||||
case "!!str":
|
||||
return StringLabel
|
||||
case "!!int":
|
||||
return IntegerLabel
|
||||
case "!!float":
|
||||
return NumberLabel
|
||||
case "!!bool":
|
||||
return BooleanLabel
|
||||
}
|
||||
return "unknown"
|
||||
switch node.Tag {
|
||||
case "!!map":
|
||||
return ObjectLabel
|
||||
case "!!seq":
|
||||
return ArrayLabel
|
||||
case "!!str":
|
||||
return StringLabel
|
||||
case "!!int":
|
||||
return IntegerLabel
|
||||
case "!!float":
|
||||
return NumberLabel
|
||||
case "!!bool":
|
||||
return BooleanLabel
|
||||
}
|
||||
return "unknown"
|
||||
}
|
||||
|
||||
// IsNodeMap checks if the node is a map type
|
||||
func IsNodeMap(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!map"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!map"
|
||||
}
|
||||
|
||||
// IsNodePolyMorphic will return true if the node contains polymorphic keys.
|
||||
func IsNodePolyMorphic(node *yaml.Node) bool {
|
||||
for i, v := range node.Content {
|
||||
if i%2 == 0 {
|
||||
if v.Value == "anyOf" || v.Value == "oneOf" || v.Value == "allOf" {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
for i, v := range node.Content {
|
||||
if i%2 == 0 {
|
||||
if v.Value == "anyOf" || v.Value == "oneOf" || v.Value == "allOf" {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsNodeArray checks if a node is an array type
|
||||
func IsNodeArray(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!seq"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!seq"
|
||||
}
|
||||
|
||||
// IsNodeStringValue checks if a node is a string value
|
||||
func IsNodeStringValue(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!str"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!str"
|
||||
}
|
||||
|
||||
// IsNodeIntValue will check if a node is an int value
|
||||
func IsNodeIntValue(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!int"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!int"
|
||||
}
|
||||
|
||||
// IsNodeFloatValue will check is a node is a float value.
|
||||
func IsNodeFloatValue(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!float"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!float"
|
||||
}
|
||||
|
||||
// IsNodeBoolValue will check is a node is a bool
|
||||
func IsNodeBoolValue(node *yaml.Node) bool {
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!bool"
|
||||
if node == nil {
|
||||
return false
|
||||
}
|
||||
return node.Tag == "!!bool"
|
||||
}
|
||||
|
||||
// FixContext will clean up a JSONpath string to be correctly traversable.
|
||||
func FixContext(context string) string {
|
||||
|
||||
tokens := strings.Split(context, ".")
|
||||
var cleaned = []string{}
|
||||
for i, t := range tokens {
|
||||
tokens := strings.Split(context, ".")
|
||||
var cleaned = []string{}
|
||||
for i, t := range tokens {
|
||||
|
||||
if v, err := strconv.Atoi(t); err == nil {
|
||||
if v, err := strconv.Atoi(t); err == nil {
|
||||
|
||||
if v < 200 { // codes start here
|
||||
if cleaned[i-1] != "" {
|
||||
cleaned[i-1] += fmt.Sprintf("[%v]", t)
|
||||
}
|
||||
} else {
|
||||
cleaned = append(cleaned, t)
|
||||
}
|
||||
continue
|
||||
}
|
||||
cleaned = append(cleaned, strings.ReplaceAll(t, "(root)", "$"))
|
||||
if v < 200 { // codes start here
|
||||
if cleaned[i-1] != "" {
|
||||
cleaned[i-1] += fmt.Sprintf("[%v]", t)
|
||||
}
|
||||
} else {
|
||||
cleaned = append(cleaned, t)
|
||||
}
|
||||
continue
|
||||
}
|
||||
cleaned = append(cleaned, strings.ReplaceAll(t, "(root)", "$"))
|
||||
|
||||
}
|
||||
return strings.Join(cleaned, ".")
|
||||
}
|
||||
return strings.Join(cleaned, ".")
|
||||
}
|
||||
|
||||
// IsJSON will tell you if a string is JSON or not.
|
||||
func IsJSON(testString string) bool {
|
||||
if testString == "" {
|
||||
return false
|
||||
}
|
||||
runes := []rune(strings.TrimSpace(testString))
|
||||
if runes[0] == '{' && runes[len(runes)-1] == '}' {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
if testString == "" {
|
||||
return false
|
||||
}
|
||||
runes := []rune(strings.TrimSpace(testString))
|
||||
if runes[0] == '{' && runes[len(runes)-1] == '}' {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// IsYAML will tell you if a string is YAML or not.
|
||||
func IsYAML(testString string) bool {
|
||||
if testString == "" {
|
||||
return false
|
||||
}
|
||||
if IsJSON(testString) {
|
||||
return false
|
||||
}
|
||||
var n interface{}
|
||||
err := yaml.Unmarshal([]byte(testString), &n)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
_, err = yaml.Marshal(n)
|
||||
return err == nil
|
||||
if testString == "" {
|
||||
return false
|
||||
}
|
||||
if IsJSON(testString) {
|
||||
return false
|
||||
}
|
||||
var n interface{}
|
||||
err := yaml.Unmarshal([]byte(testString), &n)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
_, err = yaml.Marshal(n)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
// ConvertYAMLtoJSON will do exactly what you think it will. It will deserialize YAML into serialized JSON.
|
||||
func ConvertYAMLtoJSON(yamlData []byte) ([]byte, error) {
|
||||
var decodedYaml map[string]interface{}
|
||||
err := yaml.Unmarshal(yamlData, &decodedYaml)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// if the data can be decoded, it can be encoded (that's my view anyway). no need for an error check.
|
||||
jsonData, _ := json.Marshal(decodedYaml)
|
||||
return jsonData, nil
|
||||
var decodedYaml map[string]interface{}
|
||||
err := yaml.Unmarshal(yamlData, &decodedYaml)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// if the data can be decoded, it can be encoded (that's my view anyway). no need for an error check.
|
||||
jsonData, _ := json.Marshal(decodedYaml)
|
||||
return jsonData, nil
|
||||
}
|
||||
|
||||
// IsHttpVerb will check if an operation is valid or not.
|
||||
func IsHttpVerb(verb string) bool {
|
||||
verbs := []string{"get", "post", "put", "patch", "delete", "options", "trace", "head"}
|
||||
for _, v := range verbs {
|
||||
if verb == v {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
verbs := []string{"get", "post", "put", "patch", "delete", "options", "trace", "head"}
|
||||
for _, v := range verbs {
|
||||
if verb == v {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func ConvertComponentIdIntoFriendlyPathSearch(id string) (string, string) {
|
||||
segs := strings.Split(id, "/")
|
||||
name := segs[len(segs)-1]
|
||||
segs := strings.Split(id, "/")
|
||||
name := segs[len(segs)-1]
|
||||
|
||||
replaced := strings.ReplaceAll(fmt.Sprintf("%s['%s']",
|
||||
strings.Join(segs[:len(segs)-1], "."), name), "#", "$")
|
||||
replaced := strings.ReplaceAll(fmt.Sprintf("%s['%s']",
|
||||
strings.Join(segs[:len(segs)-1], "."), name), "#", "$")
|
||||
|
||||
if replaced[0] != '$' {
|
||||
replaced = fmt.Sprintf("$%s", replaced)
|
||||
}
|
||||
return name, replaced
|
||||
if replaced[0] != '$' {
|
||||
replaced = fmt.Sprintf("$%s", replaced)
|
||||
}
|
||||
return name, replaced
|
||||
}
|
||||
|
||||
func ConvertComponentIdIntoPath(id string) (string, string) {
|
||||
segs := strings.Split(id, "/")
|
||||
name := segs[len(segs)-1]
|
||||
segs := strings.Split(id, "/")
|
||||
name := segs[len(segs)-1]
|
||||
|
||||
return name, strings.ReplaceAll(fmt.Sprintf("%s.%s",
|
||||
strings.Join(segs[:len(segs)-1], "."), name), "#", "$")
|
||||
return name, strings.ReplaceAll(fmt.Sprintf("%s.%s",
|
||||
strings.Join(segs[:len(segs)-1], "."), name), "#", "$")
|
||||
}
|
||||
|
||||
func RenderCodeSnippet(startNode *yaml.Node, specData []string, before, after int) string {
|
||||
|
||||
buf := new(strings.Builder)
|
||||
buf := new(strings.Builder)
|
||||
|
||||
startLine := startNode.Line - before
|
||||
endLine := startNode.Line + after
|
||||
startLine := startNode.Line - before
|
||||
endLine := startNode.Line + after
|
||||
|
||||
if startLine < 0 {
|
||||
startLine = 0
|
||||
}
|
||||
if startLine < 0 {
|
||||
startLine = 0
|
||||
}
|
||||
|
||||
if endLine >= len(specData) {
|
||||
endLine = len(specData) - 1
|
||||
}
|
||||
if endLine >= len(specData) {
|
||||
endLine = len(specData) - 1
|
||||
}
|
||||
|
||||
delta := endLine - startLine
|
||||
delta := endLine - startLine
|
||||
|
||||
for i := 0; i < delta; i++ {
|
||||
l := startLine + i
|
||||
if l < len(specData) {
|
||||
line := specData[l]
|
||||
buf.WriteString(fmt.Sprintf("%s\n", line))
|
||||
}
|
||||
}
|
||||
for i := 0; i < delta; i++ {
|
||||
l := startLine + i
|
||||
if l < len(specData) {
|
||||
line := specData[l]
|
||||
buf.WriteString(fmt.Sprintf("%s\n", line))
|
||||
}
|
||||
}
|
||||
|
||||
return buf.String()
|
||||
return buf.String()
|
||||
}
|
||||
|
||||
func ConvertCase(input string, convert Case) string {
|
||||
if input == "" {
|
||||
return ""
|
||||
}
|
||||
switch convert {
|
||||
case PascalCase:
|
||||
return strcase.ToCamel(input)
|
||||
case CamelCase:
|
||||
return strcase.ToLowerCamel(input)
|
||||
case ScreamingKebabCase:
|
||||
return strcase.ToScreamingKebab(input)
|
||||
case ScreamingSnakeCase:
|
||||
return strcase.ToScreamingSnake(input)
|
||||
case SnakeCase:
|
||||
return strcase.ToSnake(input)
|
||||
default:
|
||||
return input
|
||||
}
|
||||
if input == "" {
|
||||
return ""
|
||||
}
|
||||
switch convert {
|
||||
case PascalCase:
|
||||
return strcase.ToCamel(input)
|
||||
case CamelCase:
|
||||
return strcase.ToLowerCamel(input)
|
||||
case ScreamingKebabCase:
|
||||
return strcase.ToScreamingKebab(input)
|
||||
case ScreamingSnakeCase:
|
||||
return strcase.ToScreamingSnake(input)
|
||||
case SnakeCase:
|
||||
return strcase.ToSnake(input)
|
||||
default:
|
||||
return input
|
||||
}
|
||||
}
|
||||
|
||||
func DetectCase(input string) Case {
|
||||
trim := strings.TrimSpace(input)
|
||||
if trim == "" {
|
||||
return -1
|
||||
}
|
||||
trim := strings.TrimSpace(input)
|
||||
if trim == "" {
|
||||
return -1
|
||||
}
|
||||
|
||||
pascalCase := regexp.MustCompile("^[A-Z][a-z]+(?:[A-Z][a-z]+)*$")
|
||||
camelCase := regexp.MustCompile("^[a-z]+(?:[A-Z][a-z]+)*$")
|
||||
screamingSnakeCase := regexp.MustCompile("^[A-Z]+(_[A-Z]+)*$")
|
||||
snakeCase := regexp.MustCompile("^[a-z]+(_[a-z]+)*$")
|
||||
kebabCase := regexp.MustCompile("^[a-z]+(-[a-z]+)*$")
|
||||
screamingKebabCase := regexp.MustCompile("^[A-Z]+(-[A-Z]+)*$")
|
||||
if pascalCase.MatchString(trim) {
|
||||
return PascalCase
|
||||
}
|
||||
if camelCase.MatchString(trim) {
|
||||
return CamelCase
|
||||
}
|
||||
if screamingSnakeCase.MatchString(trim) {
|
||||
return ScreamingSnakeCase
|
||||
}
|
||||
if snakeCase.MatchString(trim) {
|
||||
return SnakeCase
|
||||
}
|
||||
if kebabCase.MatchString(trim) {
|
||||
return KebabCase
|
||||
}
|
||||
if screamingKebabCase.MatchString(trim) {
|
||||
return ScreamingKebabCase
|
||||
}
|
||||
return RegularCase
|
||||
pascalCase := regexp.MustCompile("^[A-Z][a-z]+(?:[A-Z][a-z]+)*$")
|
||||
camelCase := regexp.MustCompile("^[a-z]+(?:[A-Z][a-z]+)*$")
|
||||
screamingSnakeCase := regexp.MustCompile("^[A-Z]+(_[A-Z]+)*$")
|
||||
snakeCase := regexp.MustCompile("^[a-z]+(_[a-z]+)*$")
|
||||
kebabCase := regexp.MustCompile("^[a-z]+(-[a-z]+)*$")
|
||||
screamingKebabCase := regexp.MustCompile("^[A-Z]+(-[A-Z]+)*$")
|
||||
if pascalCase.MatchString(trim) {
|
||||
return PascalCase
|
||||
}
|
||||
if camelCase.MatchString(trim) {
|
||||
return CamelCase
|
||||
}
|
||||
if screamingSnakeCase.MatchString(trim) {
|
||||
return ScreamingSnakeCase
|
||||
}
|
||||
if snakeCase.MatchString(trim) {
|
||||
return SnakeCase
|
||||
}
|
||||
if kebabCase.MatchString(trim) {
|
||||
return KebabCase
|
||||
}
|
||||
if screamingKebabCase.MatchString(trim) {
|
||||
return ScreamingKebabCase
|
||||
}
|
||||
return RegularCase
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user