podman

1
// Copyright 2015 go-swagger maintainers
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//    http://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14

15
package spec
16

17
import (
18
	"encoding/json"
19
	"fmt"
20
	"strings"
21

22
	"github.com/go-openapi/jsonpointer"
23
	"github.com/go-openapi/swag"
24
)
25

26
// BooleanProperty creates a boolean property
27
func BooleanProperty() *Schema {
28
	return &Schema{SchemaProps: SchemaProps{Type: []string{"boolean"}}}
29
}
30

31
// BoolProperty creates a boolean property
32
func BoolProperty() *Schema { return BooleanProperty() }
33

34
// StringProperty creates a string property
35
func StringProperty() *Schema {
36
	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
37
}
38

39
// CharProperty creates a string property
40
func CharProperty() *Schema {
41
	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}
42
}
43

44
// Float64Property creates a float64/double property
45
func Float64Property() *Schema {
46
	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "double"}}
47
}
48

49
// Float32Property creates a float32/float property
50
func Float32Property() *Schema {
51
	return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "float"}}
52
}
53

54
// Int8Property creates an int8 property
55
func Int8Property() *Schema {
56
	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int8"}}
57
}
58

59
// Int16Property creates an int16 property
60
func Int16Property() *Schema {
61
	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int16"}}
62
}
63

64
// Int32Property creates an int32 property
65
func Int32Property() *Schema {
66
	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int32"}}
67
}
68

69
// Int64Property creates an int64 property
70
func Int64Property() *Schema {
71
	return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}}
72
}
73

74
// StrFmtProperty creates a property for the named string format
75
func StrFmtProperty(format string) *Schema {
76
	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: format}}
77
}
78

79
// DateProperty creates a date property
80
func DateProperty() *Schema {
81
	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date"}}
82
}
83

84
// DateTimeProperty creates a date time property
85
func DateTimeProperty() *Schema {
86
	return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date-time"}}
87
}
88

89
// MapProperty creates a map property
90
func MapProperty(property *Schema) *Schema {
91
	return &Schema{SchemaProps: SchemaProps{Type: []string{"object"},
92
		AdditionalProperties: &SchemaOrBool{Allows: true, Schema: property}}}
93
}
94

95
// RefProperty creates a ref property
96
func RefProperty(name string) *Schema {
97
	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
98
}
99

100
// RefSchema creates a ref property
101
func RefSchema(name string) *Schema {
102
	return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}}
103
}
104

105
// ArrayProperty creates an array property
106
func ArrayProperty(items *Schema) *Schema {
107
	if items == nil {
108
		return &Schema{SchemaProps: SchemaProps{Type: []string{"array"}}}
109
	}
110
	return &Schema{SchemaProps: SchemaProps{Items: &SchemaOrArray{Schema: items}, Type: []string{"array"}}}
111
}
112

113
// ComposedSchema creates a schema with allOf
114
func ComposedSchema(schemas ...Schema) *Schema {
115
	s := new(Schema)
116
	s.AllOf = schemas
117
	return s
118
}
119

120
// SchemaURL represents a schema url
121
type SchemaURL string
122

123
// MarshalJSON marshal this to JSON
124
func (r SchemaURL) MarshalJSON() ([]byte, error) {
125
	if r == "" {
126
		return []byte("{}"), nil
127
	}
128
	v := map[string]interface{}{"$schema": string(r)}
129
	return json.Marshal(v)
130
}
131

132
// UnmarshalJSON unmarshal this from JSON
133
func (r *SchemaURL) UnmarshalJSON(data []byte) error {
134
	var v map[string]interface{}
135
	if err := json.Unmarshal(data, &v); err != nil {
136
		return err
137
	}
138
	return r.fromMap(v)
139
}
140

141
func (r *SchemaURL) fromMap(v map[string]interface{}) error {
142
	if v == nil {
143
		return nil
144
	}
145
	if vv, ok := v["$schema"]; ok {
146
		if str, ok := vv.(string); ok {
147
			u, err := parseURL(str)
148
			if err != nil {
149
				return err
150
			}
151

152
			*r = SchemaURL(u.String())
153
		}
154
	}
155
	return nil
156
}
157

158
// SchemaProps describes a JSON schema (draft 4)
159
type SchemaProps struct {
160
	ID                   string           `json:"id,omitempty"`
161
	Ref                  Ref              `json:"-"`
162
	Schema               SchemaURL        `json:"-"`
163
	Description          string           `json:"description,omitempty"`
164
	Type                 StringOrArray    `json:"type,omitempty"`
165
	Nullable             bool             `json:"nullable,omitempty"`
166
	Format               string           `json:"format,omitempty"`
167
	Title                string           `json:"title,omitempty"`
168
	Default              interface{}      `json:"default,omitempty"`
169
	Maximum              *float64         `json:"maximum,omitempty"`
170
	ExclusiveMaximum     bool             `json:"exclusiveMaximum,omitempty"`
171
	Minimum              *float64         `json:"minimum,omitempty"`
172
	ExclusiveMinimum     bool             `json:"exclusiveMinimum,omitempty"`
173
	MaxLength            *int64           `json:"maxLength,omitempty"`
174
	MinLength            *int64           `json:"minLength,omitempty"`
175
	Pattern              string           `json:"pattern,omitempty"`
176
	MaxItems             *int64           `json:"maxItems,omitempty"`
177
	MinItems             *int64           `json:"minItems,omitempty"`
178
	UniqueItems          bool             `json:"uniqueItems,omitempty"`
179
	MultipleOf           *float64         `json:"multipleOf,omitempty"`
180
	Enum                 []interface{}    `json:"enum,omitempty"`
181
	MaxProperties        *int64           `json:"maxProperties,omitempty"`
182
	MinProperties        *int64           `json:"minProperties,omitempty"`
183
	Required             []string         `json:"required,omitempty"`
184
	Items                *SchemaOrArray   `json:"items,omitempty"`
185
	AllOf                []Schema         `json:"allOf,omitempty"`
186
	OneOf                []Schema         `json:"oneOf,omitempty"`
187
	AnyOf                []Schema         `json:"anyOf,omitempty"`
188
	Not                  *Schema          `json:"not,omitempty"`
189
	Properties           SchemaProperties `json:"properties,omitempty"`
190
	AdditionalProperties *SchemaOrBool    `json:"additionalProperties,omitempty"`
191
	PatternProperties    SchemaProperties `json:"patternProperties,omitempty"`
192
	Dependencies         Dependencies     `json:"dependencies,omitempty"`
193
	AdditionalItems      *SchemaOrBool    `json:"additionalItems,omitempty"`
194
	Definitions          Definitions      `json:"definitions,omitempty"`
195
}
196

197
// SwaggerSchemaProps are additional properties supported by swagger schemas, but not JSON-schema (draft 4)
198
type SwaggerSchemaProps struct {
199
	Discriminator string                 `json:"discriminator,omitempty"`
200
	ReadOnly      bool                   `json:"readOnly,omitempty"`
201
	XML           *XMLObject             `json:"xml,omitempty"`
202
	ExternalDocs  *ExternalDocumentation `json:"externalDocs,omitempty"`
203
	Example       interface{}            `json:"example,omitempty"`
204
}
205

206
// Schema the schema object allows the definition of input and output data types.
207
// These types can be objects, but also primitives and arrays.
208
// This object is based on the [JSON Schema Specification Draft 4](http://json-schema.org/)
209
// and uses a predefined subset of it.
210
// On top of this subset, there are extensions provided by this specification to allow for more complete documentation.
211
//
212
// For more information: http://goo.gl/8us55a#schemaObject
213
type Schema struct {
214
	VendorExtensible
215
	SchemaProps
216
	SwaggerSchemaProps
217
	ExtraProps map[string]interface{} `json:"-"`
218
}
219

220
// JSONLookup implements an interface to customize json pointer lookup
221
func (s Schema) JSONLookup(token string) (interface{}, error) {
222
	if ex, ok := s.Extensions[token]; ok {
223
		return &ex, nil
224
	}
225

226
	if ex, ok := s.ExtraProps[token]; ok {
227
		return &ex, nil
228
	}
229

230
	r, _, err := jsonpointer.GetForToken(s.SchemaProps, token)
231
	if r != nil || (err != nil && !strings.HasPrefix(err.Error(), "object has no field")) {
232
		return r, err
233
	}
234
	r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token)
235
	return r, err
236
}
237

238
// WithID sets the id for this schema, allows for chaining
239
func (s *Schema) WithID(id string) *Schema {
240
	s.ID = id
241
	return s
242
}
243

244
// WithTitle sets the title for this schema, allows for chaining
245
func (s *Schema) WithTitle(title string) *Schema {
246
	s.Title = title
247
	return s
248
}
249

250
// WithDescription sets the description for this schema, allows for chaining
251
func (s *Schema) WithDescription(description string) *Schema {
252
	s.Description = description
253
	return s
254
}
255

256
// WithProperties sets the properties for this schema
257
func (s *Schema) WithProperties(schemas map[string]Schema) *Schema {
258
	s.Properties = schemas
259
	return s
260
}
261

262
// SetProperty sets a property on this schema
263
func (s *Schema) SetProperty(name string, schema Schema) *Schema {
264
	if s.Properties == nil {
265
		s.Properties = make(map[string]Schema)
266
	}
267
	s.Properties[name] = schema
268
	return s
269
}
270

271
// WithAllOf sets the all of property
272
func (s *Schema) WithAllOf(schemas ...Schema) *Schema {
273
	s.AllOf = schemas
274
	return s
275
}
276

277
// WithMaxProperties sets the max number of properties an object can have
278
func (s *Schema) WithMaxProperties(max int64) *Schema {
279
	s.MaxProperties = &max
280
	return s
281
}
282

283
// WithMinProperties sets the min number of properties an object must have
284
func (s *Schema) WithMinProperties(min int64) *Schema {
285
	s.MinProperties = &min
286
	return s
287
}
288

289
// Typed sets the type of this schema for a single value item
290
func (s *Schema) Typed(tpe, format string) *Schema {
291
	s.Type = []string{tpe}
292
	s.Format = format
293
	return s
294
}
295

296
// AddType adds a type with potential format to the types for this schema
297
func (s *Schema) AddType(tpe, format string) *Schema {
298
	s.Type = append(s.Type, tpe)
299
	if format != "" {
300
		s.Format = format
301
	}
302
	return s
303
}
304

305
// AsNullable flags this schema as nullable.
306
func (s *Schema) AsNullable() *Schema {
307
	s.Nullable = true
308
	return s
309
}
310

311
// CollectionOf a fluent builder method for an array parameter
312
func (s *Schema) CollectionOf(items Schema) *Schema {
313
	s.Type = []string{jsonArray}
314
	s.Items = &SchemaOrArray{Schema: &items}
315
	return s
316
}
317

318
// WithDefault sets the default value on this parameter
319
func (s *Schema) WithDefault(defaultValue interface{}) *Schema {
320
	s.Default = defaultValue
321
	return s
322
}
323

324
// WithRequired flags this parameter as required
325
func (s *Schema) WithRequired(items ...string) *Schema {
326
	s.Required = items
327
	return s
328
}
329

330
// AddRequired  adds field names to the required properties array
331
func (s *Schema) AddRequired(items ...string) *Schema {
332
	s.Required = append(s.Required, items...)
333
	return s
334
}
335

336
// WithMaxLength sets a max length value
337
func (s *Schema) WithMaxLength(max int64) *Schema {
338
	s.MaxLength = &max
339
	return s
340
}
341

342
// WithMinLength sets a min length value
343
func (s *Schema) WithMinLength(min int64) *Schema {
344
	s.MinLength = &min
345
	return s
346
}
347

348
// WithPattern sets a pattern value
349
func (s *Schema) WithPattern(pattern string) *Schema {
350
	s.Pattern = pattern
351
	return s
352
}
353

354
// WithMultipleOf sets a multiple of value
355
func (s *Schema) WithMultipleOf(number float64) *Schema {
356
	s.MultipleOf = &number
357
	return s
358
}
359

360
// WithMaximum sets a maximum number value
361
func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema {
362
	s.Maximum = &max
363
	s.ExclusiveMaximum = exclusive
364
	return s
365
}
366

367
// WithMinimum sets a minimum number value
368
func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema {
369
	s.Minimum = &min
370
	s.ExclusiveMinimum = exclusive
371
	return s
372
}
373

374
// WithEnum sets a the enum values (replace)
375
func (s *Schema) WithEnum(values ...interface{}) *Schema {
376
	s.Enum = append([]interface{}{}, values...)
377
	return s
378
}
379

380
// WithMaxItems sets the max items
381
func (s *Schema) WithMaxItems(size int64) *Schema {
382
	s.MaxItems = &size
383
	return s
384
}
385

386
// WithMinItems sets the min items
387
func (s *Schema) WithMinItems(size int64) *Schema {
388
	s.MinItems = &size
389
	return s
390
}
391

392
// UniqueValues dictates that this array can only have unique items
393
func (s *Schema) UniqueValues() *Schema {
394
	s.UniqueItems = true
395
	return s
396
}
397

398
// AllowDuplicates this array can have duplicates
399
func (s *Schema) AllowDuplicates() *Schema {
400
	s.UniqueItems = false
401
	return s
402
}
403

404
// AddToAllOf adds a schema to the allOf property
405
func (s *Schema) AddToAllOf(schemas ...Schema) *Schema {
406
	s.AllOf = append(s.AllOf, schemas...)
407
	return s
408
}
409

410
// WithDiscriminator sets the name of the discriminator field
411
func (s *Schema) WithDiscriminator(discriminator string) *Schema {
412
	s.Discriminator = discriminator
413
	return s
414
}
415

416
// AsReadOnly flags this schema as readonly
417
func (s *Schema) AsReadOnly() *Schema {
418
	s.ReadOnly = true
419
	return s
420
}
421

422
// AsWritable flags this schema as writeable (not read-only)
423
func (s *Schema) AsWritable() *Schema {
424
	s.ReadOnly = false
425
	return s
426
}
427

428
// WithExample sets the example for this schema
429
func (s *Schema) WithExample(example interface{}) *Schema {
430
	s.Example = example
431
	return s
432
}
433

434
// WithExternalDocs sets/removes the external docs for/from this schema.
435
// When you pass empty strings as params the external documents will be removed.
436
// When you pass non-empty string as one value then those values will be used on the external docs object.
437
// So when you pass a non-empty description, you should also pass the url and vice versa.
438
func (s *Schema) WithExternalDocs(description, url string) *Schema {
439
	if description == "" && url == "" {
440
		s.ExternalDocs = nil
441
		return s
442
	}
443

444
	if s.ExternalDocs == nil {
445
		s.ExternalDocs = &ExternalDocumentation{}
446
	}
447
	s.ExternalDocs.Description = description
448
	s.ExternalDocs.URL = url
449
	return s
450
}
451

452
// WithXMLName sets the xml name for the object
453
func (s *Schema) WithXMLName(name string) *Schema {
454
	if s.XML == nil {
455
		s.XML = new(XMLObject)
456
	}
457
	s.XML.Name = name
458
	return s
459
}
460

461
// WithXMLNamespace sets the xml namespace for the object
462
func (s *Schema) WithXMLNamespace(namespace string) *Schema {
463
	if s.XML == nil {
464
		s.XML = new(XMLObject)
465
	}
466
	s.XML.Namespace = namespace
467
	return s
468
}
469

470
// WithXMLPrefix sets the xml prefix for the object
471
func (s *Schema) WithXMLPrefix(prefix string) *Schema {
472
	if s.XML == nil {
473
		s.XML = new(XMLObject)
474
	}
475
	s.XML.Prefix = prefix
476
	return s
477
}
478

479
// AsXMLAttribute flags this object as xml attribute
480
func (s *Schema) AsXMLAttribute() *Schema {
481
	if s.XML == nil {
482
		s.XML = new(XMLObject)
483
	}
484
	s.XML.Attribute = true
485
	return s
486
}
487

488
// AsXMLElement flags this object as an xml node
489
func (s *Schema) AsXMLElement() *Schema {
490
	if s.XML == nil {
491
		s.XML = new(XMLObject)
492
	}
493
	s.XML.Attribute = false
494
	return s
495
}
496

497
// AsWrappedXML flags this object as wrapped, this is mostly useful for array types
498
func (s *Schema) AsWrappedXML() *Schema {
499
	if s.XML == nil {
500
		s.XML = new(XMLObject)
501
	}
502
	s.XML.Wrapped = true
503
	return s
504
}
505

506
// AsUnwrappedXML flags this object as an xml node
507
func (s *Schema) AsUnwrappedXML() *Schema {
508
	if s.XML == nil {
509
		s.XML = new(XMLObject)
510
	}
511
	s.XML.Wrapped = false
512
	return s
513
}
514

515
// SetValidations defines all schema validations.
516
//
517
// NOTE: Required, ReadOnly, AllOf, AnyOf, OneOf and Not are not considered.
518
func (s *Schema) SetValidations(val SchemaValidations) {
519
	s.Maximum = val.Maximum
520
	s.ExclusiveMaximum = val.ExclusiveMaximum
521
	s.Minimum = val.Minimum
522
	s.ExclusiveMinimum = val.ExclusiveMinimum
523
	s.MaxLength = val.MaxLength
524
	s.MinLength = val.MinLength
525
	s.Pattern = val.Pattern
526
	s.MaxItems = val.MaxItems
527
	s.MinItems = val.MinItems
528
	s.UniqueItems = val.UniqueItems
529
	s.MultipleOf = val.MultipleOf
530
	s.Enum = val.Enum
531
	s.MinProperties = val.MinProperties
532
	s.MaxProperties = val.MaxProperties
533
	s.PatternProperties = val.PatternProperties
534
}
535

536
// WithValidations is a fluent method to set schema validations
537
func (s *Schema) WithValidations(val SchemaValidations) *Schema {
538
	s.SetValidations(val)
539
	return s
540
}
541

542
// Validations returns a clone of the validations for this schema
543
func (s Schema) Validations() SchemaValidations {
544
	return SchemaValidations{
545
		CommonValidations: CommonValidations{
546
			Maximum:          s.Maximum,
547
			ExclusiveMaximum: s.ExclusiveMaximum,
548
			Minimum:          s.Minimum,
549
			ExclusiveMinimum: s.ExclusiveMinimum,
550
			MaxLength:        s.MaxLength,
551
			MinLength:        s.MinLength,
552
			Pattern:          s.Pattern,
553
			MaxItems:         s.MaxItems,
554
			MinItems:         s.MinItems,
555
			UniqueItems:      s.UniqueItems,
556
			MultipleOf:       s.MultipleOf,
557
			Enum:             s.Enum,
558
		},
559
		MinProperties:     s.MinProperties,
560
		MaxProperties:     s.MaxProperties,
561
		PatternProperties: s.PatternProperties,
562
	}
563
}
564

565
// MarshalJSON marshal this to JSON
566
func (s Schema) MarshalJSON() ([]byte, error) {
567
	b1, err := json.Marshal(s.SchemaProps)
568
	if err != nil {
569
		return nil, fmt.Errorf("schema props %v", err)
570
	}
571
	b2, err := json.Marshal(s.VendorExtensible)
572
	if err != nil {
573
		return nil, fmt.Errorf("vendor props %v", err)
574
	}
575
	b3, err := s.Ref.MarshalJSON()
576
	if err != nil {
577
		return nil, fmt.Errorf("ref prop %v", err)
578
	}
579
	b4, err := s.Schema.MarshalJSON()
580
	if err != nil {
581
		return nil, fmt.Errorf("schema prop %v", err)
582
	}
583
	b5, err := json.Marshal(s.SwaggerSchemaProps)
584
	if err != nil {
585
		return nil, fmt.Errorf("common validations %v", err)
586
	}
587
	var b6 []byte
588
	if s.ExtraProps != nil {
589
		jj, err := json.Marshal(s.ExtraProps)
590
		if err != nil {
591
			return nil, fmt.Errorf("extra props %v", err)
592
		}
593
		b6 = jj
594
	}
595
	return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil
596
}
597

598
// UnmarshalJSON marshal this from JSON
599
func (s *Schema) UnmarshalJSON(data []byte) error {
600
	props := struct {
601
		SchemaProps
602
		SwaggerSchemaProps
603
	}{}
604
	if err := json.Unmarshal(data, &props); err != nil {
605
		return err
606
	}
607

608
	sch := Schema{
609
		SchemaProps:        props.SchemaProps,
610
		SwaggerSchemaProps: props.SwaggerSchemaProps,
611
	}
612

613
	var d map[string]interface{}
614
	if err := json.Unmarshal(data, &d); err != nil {
615
		return err
616
	}
617

618
	_ = sch.Ref.fromMap(d)
619
	_ = sch.Schema.fromMap(d)
620

621
	delete(d, "$ref")
622
	delete(d, "$schema")
623
	for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) {
624
		delete(d, pn)
625
	}
626

627
	for k, vv := range d {
628
		lk := strings.ToLower(k)
629
		if strings.HasPrefix(lk, "x-") {
630
			if sch.Extensions == nil {
631
				sch.Extensions = map[string]interface{}{}
632
			}
633
			sch.Extensions[k] = vv
634
			continue
635
		}
636
		if sch.ExtraProps == nil {
637
			sch.ExtraProps = map[string]interface{}{}
638
		}
639
		sch.ExtraProps[k] = vv
640
	}
641

642
	*s = sch
643

644
	return nil
645
}
646