podman

1
package spec
2

3
import (
4
	"fmt"
5

6
	"github.com/go-openapi/swag"
7
)
8

9
func resolveAnyWithBase(root interface{}, ref *Ref, result interface{}, options *ExpandOptions) error {
10
	options = optionsOrDefault(options)
11
	resolver := defaultSchemaLoader(root, options, nil, nil)
12

13
	if err := resolver.Resolve(ref, result, options.RelativeBase); err != nil {
14
		return err
15
	}
16

17
	return nil
18
}
19

20
// ResolveRefWithBase resolves a reference against a context root with preservation of base path
21
func ResolveRefWithBase(root interface{}, ref *Ref, options *ExpandOptions) (*Schema, error) {
22
	result := new(Schema)
23

24
	if err := resolveAnyWithBase(root, ref, result, options); err != nil {
25
		return nil, err
26
	}
27

28
	return result, nil
29
}
30

31
// ResolveRef resolves a reference for a schema against a context root
32
// ref is guaranteed to be in root (no need to go to external files)
33
//
34
// ResolveRef is ONLY called from the code generation module
35
func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
36
	res, _, err := ref.GetPointer().Get(root)
37
	if err != nil {
38
		return nil, err
39
	}
40

41
	switch sch := res.(type) {
42
	case Schema:
43
		return &sch, nil
44
	case *Schema:
45
		return sch, nil
46
	case map[string]interface{}:
47
		newSch := new(Schema)
48
		if err = swag.DynamicJSONToStruct(sch, newSch); err != nil {
49
			return nil, err
50
		}
51
		return newSch, nil
52
	default:
53
		return nil, fmt.Errorf("type: %T: %w", sch, ErrUnknownTypeForReference)
54
	}
55
}
56

57
// ResolveParameterWithBase resolves a parameter reference against a context root and base path
58
func ResolveParameterWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Parameter, error) {
59
	result := new(Parameter)
60

61
	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
62
		return nil, err
63
	}
64

65
	return result, nil
66
}
67

68
// ResolveParameter resolves a parameter reference against a context root
69
func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
70
	return ResolveParameterWithBase(root, ref, nil)
71
}
72

73
// ResolveResponseWithBase resolves response a reference against a context root and base path
74
func ResolveResponseWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Response, error) {
75
	result := new(Response)
76

77
	err := resolveAnyWithBase(root, &ref, result, options)
78
	if err != nil {
79
		return nil, err
80
	}
81

82
	return result, nil
83
}
84

85
// ResolveResponse resolves response a reference against a context root
86
func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
87
	return ResolveResponseWithBase(root, ref, nil)
88
}
89

90
// ResolvePathItemWithBase resolves response a path item against a context root and base path
91
func ResolvePathItemWithBase(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
92
	result := new(PathItem)
93

94
	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
95
		return nil, err
96
	}
97

98
	return result, nil
99
}
100

101
// ResolvePathItem resolves response a path item against a context root and base path
102
//
103
// Deprecated: use ResolvePathItemWithBase instead
104
func ResolvePathItem(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
105
	return ResolvePathItemWithBase(root, ref, options)
106
}
107

108
// ResolveItemsWithBase resolves parameter items reference against a context root and base path.
109
//
110
// NOTE: stricly speaking, this construct is not supported by Swagger 2.0.
111
// Similarly, $ref are forbidden in response headers.
112
func ResolveItemsWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
113
	result := new(Items)
114

115
	if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
116
		return nil, err
117
	}
118

119
	return result, nil
120
}
121

122
// ResolveItems resolves parameter items reference against a context root and base path.
123
//
124
// Deprecated: use ResolveItemsWithBase instead
125
func ResolveItems(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
126
	return ResolveItemsWithBase(root, ref, options)
127
}
128