使用golang验证yaml模式（语义检查）

We have tool which need to read YAML file with specific structure. When we got the YAML file we need to know if

  1. Check if the YAML file is valid according to some guideline - semantic check
  2. Where is the syntax error if any

For example this is example of the validation that we need to address

 _version:  {required: true}
   id: {required: true, pattern: '/^[A-Za_\-\.]+$/'}   
   release-version: {required: true}
   type:   

   builds:
     type:seq
     sequence:
       -type:map
     mapping:
        name:{required: true, unique: true, pattern: '/^[A-Za-z0-3_\-\.]+$/'}
        params: 
          type: map
          mapping: { =: {type: any} }

Mapping is a key value object
seq can have multiple builds
type any is and key value

We use this open source to parse the yaml https://github.com/go-yaml/yaml

One idea (which is good) is to convert to json like following to do it by converting the file to json and validate it which have library to support it, any example in my context will be very helpful https://github.com/xeipuuv/gojsonschema

But not sure how I handle

Type map
Type seq

Here is what you could try.

Model a struct after the shape of the expected yaml data:

type Config struct {
        Version struct {
                Required bool
        }
        ID struct {
                Required bool
                Pattern string
        }
        ReleaseVersion struct {
                Required bool
        }
        Type interface{}
        Builds struct {
                Type []interface{} `yaml:"type"`
                Sequence struct {
                        Type string
                }
                Mapping struct {
                        Name map[string]interface{}
                        Params struct {
                                Type string `yaml:"type"`
                                Mapping struct {
                                        To map[string]string `yaml:"="`
                                }
                        }
                } `yaml:"mapping"`              
        }
}

The yaml flag yaml:"somefield" is added to label the field name of the yaml the data we're interested in.

Also many fields with unknown/undetermined type can be declared as empty interface (interface{}) or if you want to "enforce" that the underlying form is a key-value object you can either declare it as a map[string]interface{} or another struct.

We then unmarshal the yaml data into the struct:

cfg := Config{}
err := yaml.Unmarshal([]byte(data), &cfg)
if err != nil {
        log.Fatalf("error: %v", err)
}

Since we have modeled fields as either anonymous structs or maps, we can test if a particular field has a "key-value" value by checking its equality to nil.

// Mapping is a key value object
if (Mapping != nil) {
        // Mapping is a key-value object, since it's not nil.
}


// type any is and key value
// Mapping.To is declared with map[string]string type
// so if it's not nil we can say there's a map there.
if (Mapping.To != nil) {
        // Mapping.To is a map
}

In marshaling/unmarshaling, maps and structs are pretty interchangeable. The benefit of a struct is you can predefine the field's names ahead of time while unmarshaling to a map it won't be clear to you what the keys are.

You can make go-yaml work with jsonschema. See this issue: https://github.com/santhosh-tekuri/jsonschema/issues/5

In short:

  1. Create a custom yaml parser that produces compatible output types, as per this issue.
  2. Parse the yaml into an interface{} using that custom parser
  3. Validate with jsonschema.ValidateInterface.

(once yaml.v3 has been released, the custom unmarshaller should be able to be replaced with a configuration option)

I was originally using the accepted answer's approach of parsing into a struct and then writing code to manually validate that the struct met my spec. This quickly got very ugly - the above approach allows for a clean separate spec and reliable validation of it.