Skip to content

Commit

Permalink
Export Schema struct fields
Browse files Browse the repository at this point in the history 
closes issue#9
  • Loading branch information
@santhosh-tekuri
santhosh-tekuri committed Apr 20, 2018
1 parent 8b6ee27 commit 3c5842b
Show file tree
Hide file tree
Showing 3 changed files with 165 additions and 165 deletions.
106 changes: 53 additions & 53 deletions compiler.go
View file
Expand Up @@ -39,9 +39,9 @@ func (draft *Draft) validateSchema(url, ptr string, v interface{}) error {
return &SchemaError{
url,
&ValidationError{
Message: fmt.Sprintf("doesn't validate with %q", meta.url+meta.ptr),
Message: fmt.Sprintf("doesn't validate with %q", meta.URL+meta.Ptr),
InstancePtr: instancePtr,
SchemaURL: meta.url,
SchemaURL: meta.URL,
SchemaPtr: "#",
Causes: []*ValidationError{err.(*ValidationError)},
},
Expand Down Expand Up @@ -141,7 +141,7 @@ func (c Compiler) compileRef(draft *Draft, r *resource, root map[string]interfac
if err := draft.validateSchema(r.url, "", r.doc); err != nil {
return nil, err
}
s := &Schema{url: r.url, ptr: "#"}
s := &Schema{URL: r.url, Ptr: "#"}
r.schemas["#"] = s
if m, ok := r.doc.(map[string]interface{}); ok {
if _, err := c.compile(draft, r, s, base, m, m); err != nil {
Expand Down Expand Up @@ -178,7 +178,7 @@ func (c Compiler) compileRef(draft *Draft, r *resource, root map[string]interfac
if err := draft.validateSchema(r.url, strings.TrimPrefix(ref, "#/"), doc); err != nil {
return nil, err
}
r.schemas[ref] = &Schema{url: base, ptr: ref}
r.schemas[ref] = &Schema{URL: base, Ptr: ref}
if _, err := c.compile(draft, r, r.schemas[ref], ptrBase, root, doc); err != nil {
return nil, err
}
Expand All @@ -203,7 +203,7 @@ func (c Compiler) compileRef(draft *Draft, r *resource, root map[string]interfac
return nil, err
}
u, f := split(refURL)
s := &Schema{url: u, ptr: f}
s := &Schema{URL: u, Ptr: f}
r.schemas[refURL] = s
if err := c.compileMap(draft, r, s, refURL, root, v); err != nil {
return nil, err
Expand All @@ -221,11 +221,11 @@ func (c Compiler) compileRef(draft *Draft, r *resource, root map[string]interfac
func (c Compiler) compile(draft *Draft, r *resource, s *Schema, base string, root map[string]interface{}, m interface{}) (*Schema, error) {
if s == nil {
s = new(Schema)
s.url, _ = split(base)
s.URL, _ = split(base)
}
switch m := m.(type) {
case bool:
s.always = &m
s.Always = &m
return s, nil
default:
return s, c.compileMap(draft, r, s, base, root, m.(map[string]interface{}))
Expand All @@ -243,7 +243,7 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,

if ref, ok := m["$ref"]; ok {
b, _ := split(base)
s.ref, err = c.compileRef(draft, r, root, b, ref.(string))
s.Ref, err = c.compileRef(draft, r, root, b, ref.(string))
if err != nil {
return err
}
Expand All @@ -254,16 +254,16 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
if t, ok := m["type"]; ok {
switch t := t.(type) {
case string:
s.types = []string{t}
s.Types = []string{t}
case []interface{}:
s.types = toStrings(t)
s.Types = toStrings(t)
}
}

if e, ok := m["enum"]; ok {
s.enum = e.([]interface{})
s.Enum = e.([]interface{})
allPrimitives := true
for _, item := range s.enum {
for _, item := range s.Enum {
switch jsonType(item) {
case "object", "array":
allPrimitives = false
Expand All @@ -272,11 +272,11 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
}
s.enumError = "enum failed"
if allPrimitives {
if len(s.enum) == 1 {
s.enumError = fmt.Sprintf("value must be %#v", s.enum[0])
if len(s.Enum) == 1 {
s.enumError = fmt.Sprintf("value must be %#v", s.Enum[0])
} else {
strEnum := make([]string, len(s.enum))
for i, item := range s.enum {
strEnum := make([]string, len(s.Enum))
for i, item := range s.Enum {
strEnum[i] = fmt.Sprintf("%#v", item)
}
s.enumError = fmt.Sprintf("value must be one of %s", strings.Join(strEnum, ", "))
Expand All @@ -285,7 +285,7 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
}

if not, ok := m["not"]; ok {
s.not, err = c.compile(draft, r, nil, base, root, not)
s.Not, err = c.compile(draft, r, nil, base, root, not)
if err != nil {
return err
}
Expand All @@ -306,13 +306,13 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
}
return nil, nil
}
if s.allOf, err = loadSchemas("allOf"); err != nil {
if s.AllOf, err = loadSchemas("allOf"); err != nil {
return err
}
if s.anyOf, err = loadSchemas("anyOf"); err != nil {
if s.AnyOf, err = loadSchemas("anyOf"); err != nil {
return err
}
if s.oneOf, err = loadSchemas("oneOf"); err != nil {
if s.OneOf, err = loadSchemas("oneOf"); err != nil {
return err
}

Expand All @@ -323,32 +323,32 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
}
return -1
}
s.minProperties, s.maxProperties = loadInt("minProperties"), loadInt("maxProperties")
s.MinProperties, s.MaxProperties = loadInt("minProperties"), loadInt("maxProperties")

if req, ok := m["required"]; ok {
s.required = toStrings(req.([]interface{}))
s.Required = toStrings(req.([]interface{}))
}

if props, ok := m["properties"]; ok {
props := props.(map[string]interface{})
s.properties = make(map[string]*Schema, len(props))
s.Properties = make(map[string]*Schema, len(props))
for pname, pmap := range props {
s.properties[pname], err = c.compile(draft, r, nil, base, root, pmap)
s.Properties[pname], err = c.compile(draft, r, nil, base, root, pmap)
if err != nil {
return err
}
}
}

if regexProps, ok := m["regexProperties"]; ok {
s.regexProperties = regexProps.(bool)
s.RegexProperties = regexProps.(bool)
}

if patternProps, ok := m["patternProperties"]; ok {
patternProps := patternProps.(map[string]interface{})
s.patternProperties = make(map[*regexp.Regexp]*Schema, len(patternProps))
s.PatternProperties = make(map[*regexp.Regexp]*Schema, len(patternProps))
for pattern, pmap := range patternProps {
s.patternProperties[regexp.MustCompile(pattern)], err = c.compile(draft, r, nil, base, root, pmap)
s.PatternProperties[regexp.MustCompile(pattern)], err = c.compile(draft, r, nil, base, root, pmap)
if err != nil {
return err
}
Expand All @@ -359,10 +359,10 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
switch additionalProps := additionalProps.(type) {
case bool:
if !additionalProps {
s.additionalProperties = false
s.AdditionalProperties = false
}
case map[string]interface{}:
s.additionalProperties, err = c.compile(draft, r, nil, base, root, additionalProps)
s.AdditionalProperties, err = c.compile(draft, r, nil, base, root, additionalProps)
if err != nil {
return err
}
Expand All @@ -371,63 +371,63 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,

if deps, ok := m["dependencies"]; ok {
deps := deps.(map[string]interface{})
s.dependencies = make(map[string]interface{}, len(deps))
s.Dependencies = make(map[string]interface{}, len(deps))
for pname, pvalue := range deps {
switch pvalue := pvalue.(type) {
case []interface{}:
s.dependencies[pname] = toStrings(pvalue)
s.Dependencies[pname] = toStrings(pvalue)
default:
s.dependencies[pname], err = c.compile(draft, r, nil, base, root, pvalue)
s.Dependencies[pname], err = c.compile(draft, r, nil, base, root, pvalue)
if err != nil {
return err
}
}
}
}

s.minItems, s.maxItems = loadInt("minItems"), loadInt("maxItems")
s.MinItems, s.MaxItems = loadInt("minItems"), loadInt("maxItems")

if unique, ok := m["uniqueItems"]; ok {
s.uniqueItems = unique.(bool)
s.UniqueItems = unique.(bool)
}

if items, ok := m["items"]; ok {
switch items := items.(type) {
case []interface{}:
s.items, err = loadSchemas("items")
s.Items, err = loadSchemas("items")
if err != nil {
return err
}
if additionalItems, ok := m["additionalItems"]; ok {
switch additionalItems := additionalItems.(type) {
case bool:
s.additionalItems = additionalItems
s.AdditionalItems = additionalItems
case map[string]interface{}:
s.additionalItems, err = c.compile(draft, r, nil, base, root, additionalItems)
s.AdditionalItems, err = c.compile(draft, r, nil, base, root, additionalItems)
if err != nil {
return err
}
}
} else {
s.additionalItems = true
s.AdditionalItems = true
}
default:
s.items, err = c.compile(draft, r, nil, base, root, items)
s.Items, err = c.compile(draft, r, nil, base, root, items)
if err != nil {
return err
}
}
}

s.minLength, s.maxLength = loadInt("minLength"), loadInt("maxLength")
s.MinLength, s.MaxLength = loadInt("minLength"), loadInt("maxLength")

if pattern, ok := m["pattern"]; ok {
s.pattern = regexp.MustCompile(pattern.(string))
s.Pattern = regexp.MustCompile(pattern.(string))
}

if format, ok := m["format"]; ok {
s.formatName = format.(string)
s.format, _ = formats.Get(s.formatName)
s.FormatName = format.(string)
s.Format, _ = formats.Get(s.FormatName)
}

loadFloat := func(pname string) *big.Float {
Expand All @@ -438,42 +438,42 @@ func (c Compiler) compileMap(draft *Draft, r *resource, s *Schema, base string,
return nil
}

s.minimum = loadFloat("minimum")
s.Minimum = loadFloat("minimum")
if exclusive, ok := m["exclusiveMinimum"]; ok {
if exclusive, ok := exclusive.(bool); ok {
if exclusive {
s.minimum, s.exclusiveMinimum = nil, s.minimum
s.Minimum, s.ExclusiveMinimum = nil, s.Minimum
}
} else {
s.exclusiveMinimum = loadFloat("exclusiveMinimum")
s.ExclusiveMinimum = loadFloat("exclusiveMinimum")
}
}

s.maximum = loadFloat("maximum")
s.Maximum = loadFloat("maximum")
if exclusive, ok := m["exclusiveMaximum"]; ok {
if exclusive, ok := exclusive.(bool); ok {
if exclusive {
s.maximum, s.exclusiveMaximum = nil, s.maximum
s.Maximum, s.ExclusiveMaximum = nil, s.Maximum
}
} else {
s.exclusiveMaximum = loadFloat("exclusiveMaximum")
s.ExclusiveMaximum = loadFloat("exclusiveMaximum")
}
}

s.multipleOf = loadFloat("multipleOf")
s.MultipleOf = loadFloat("multipleOf")

if draft == Draft6 {
if c, ok := m["const"]; ok {
s.constant = []interface{}{c}
s.Constant = []interface{}{c}
}
if propertyNames, ok := m["propertyNames"]; ok {
s.propertyNames, err = c.compile(draft, r, nil, base, root, propertyNames)
s.PropertyNames, err = c.compile(draft, r, nil, base, root, propertyNames)
if err != nil {
return err
}
}
if contains, ok := m["contains"]; ok {
s.contains, err = c.compile(draft, r, nil, base, root, contains)
s.Contains, err = c.compile(draft, r, nil, base, root, contains)
if err != nil {
return err
}
Expand Down
4 changes: 2 additions & 2 deletions errors.go
View file
Expand Up @@ -91,8 +91,8 @@ func addContext(instancePtr, schemaPtr string, err error) error {
func finishSchemaContext(err error, s *Schema) {
ve := err.(*ValidationError)
if len(ve.SchemaURL) == 0 {
ve.SchemaURL = s.url
ve.SchemaPtr = s.ptr + "/" + ve.SchemaPtr
ve.SchemaURL = s.URL
ve.SchemaPtr = s.Ptr + "/" + ve.SchemaPtr
for _, cause := range ve.Causes {
finishSchemaContext(cause, s)
}
Expand Down

0 comments on commit 3c5842b

Please sign in to comment.