package yaml import ( "bufio" "bytes" "io" "os" "strings" "gopkg.in/yaml.v2" ) // Parse parses the configuration from io.Reader r. func Parse(r io.Reader) (*Manifest, error) { resources, err := ParseRaw(r) if err != nil { return nil, err } manifest := new(Manifest) for _, raw := range resources { if raw == nil { continue } resource, err := parseRaw(raw) if err != nil { return nil, err } manifest.Resources = append( manifest.Resources, resource, ) } return manifest, nil } // ParseBytes parses the configuration from bytes b. func ParseBytes(b []byte) (*Manifest, error) { return Parse( bytes.NewBuffer(b), ) } // ParseString parses the configuration from string s. func ParseString(s string) (*Manifest, error) { return ParseBytes( []byte(s), ) } // ParseFile parses the configuration from path p. func ParseFile(p string) (*Manifest, error) { f, err := os.Open(p) if err != nil { return nil, err } defer f.Close() return Parse(f) } func parseRaw(r *RawResource) (Resource, error) { var obj Resource switch r.Kind { case "cron": obj = new(Cron) case "secret": obj = new(Secret) case "signature": obj = new(Signature) case "registry": obj = new(Registry) default: obj = new(Pipeline) } err := yaml.Unmarshal(r.Data, obj) return obj, err } // ParseRaw parses the multi-document yaml from the // io.Reader and returns a slice of raw resources. func ParseRaw(r io.Reader) ([]*RawResource, error) { const newline = '\n' var resources []*RawResource var resource *RawResource scanner := bufio.NewScanner(r) for scanner.Scan() { line := scanner.Text() if isSeparator(line) { resource = nil } if resource == nil { resource = &RawResource{} resources = append(resources, resource) } if isSeparator(line) { continue } if isTerminator(line) { break } if scanner.Err() == io.EOF { break } resource.Data = append( resource.Data, line..., ) resource.Data = append( resource.Data, newline, ) } for _, resource := range resources { err := yaml.Unmarshal(resource.Data, resource) if err != nil { return nil, err } } return resources, nil } // ParseRawString parses the multi-document yaml from s // and returns a slice of raw resources. func ParseRawString(s string) ([]*RawResource, error) { return ParseRaw( strings.NewReader(s), ) } // ParseRawBytes parses the multi-document yaml from b // and returns a slice of raw resources. func ParseRawBytes(b []byte) ([]*RawResource, error) { return ParseRaw( bytes.NewReader(b), ) } // ParseRawFile parses the multi-document yaml from path p // and returns a slice of raw resources. func ParseRawFile(p string) ([]*RawResource, error) { f, err := os.Open(p) if err != nil { return nil, err } defer f.Close() return ParseRaw(f) } func isSeparator(s string) bool { return strings.HasPrefix(s, "---") } func isTerminator(s string) bool { return strings.HasPrefix(s, "...") }