func diff(aFilePath, bFilePath string, separator string) { aFile, err := ioutil.ReadFile(aFilePath) if err != nil { log.Fatalln(fmt.Sprintf("error reading a [%s]:", path.Clean(aFilePath)), err) } aYAML, err := yaml.Parse(aFilePath, aFile) if err != nil { log.Fatalln(fmt.Sprintf("error parsing a [%s]:", path.Clean(aFilePath)), err) } bFile, err := ioutil.ReadFile(bFilePath) if err != nil { log.Fatalln(fmt.Sprintf("error reading b [%s]:", path.Clean(bFilePath)), err) } bYAML, err := yaml.Parse(bFilePath, bFile) if err != nil { log.Fatalln(fmt.Sprintf("error parsing b [%s]:", path.Clean(bFilePath)), err) } diffs := compare.Compare(aYAML, bYAML) if len(diffs) == 0 { fmt.Println("no differences!") return } for _, diff := range diffs { fmt.Println("Difference in", strings.Join(diff.Path, ".")) if diff.A != nil { ayaml, err := candiedyaml.Marshal(diff.A) if err != nil { panic(err) } fmt.Printf(" %s has:\n \x1b[31m%s\x1b[0m\n", aFilePath, strings.Replace(string(ayaml), "\n", "\n ", -1)) } if diff.B != nil { byaml, err := candiedyaml.Marshal(diff.B) if err != nil { panic(err) } fmt.Printf(" %s has:\n \x1b[32m%s\x1b[0m\n", bFilePath, strings.Replace(string(byaml), "\n", "\n ", -1)) } fmt.Printf(separator) } }
func func_exec(arguments []interface{}, binding Binding) (yaml.Node, EvaluationInfo, bool) { info := DefaultInfo() if len(arguments) < 1 { return nil, info, false } args := []string{} debug.Debug("exec: found %d arguments for call\n", len(arguments)) for i, arg := range arguments { list, ok := arg.([]yaml.Node) if i == 0 && ok { debug.Debug("exec: found array as first argument\n") if len(arguments) == 1 && len(list) > 0 { // handle single list argument to gain command and argument for j, arg := range list { v, ok := getArg(j, arg.Value()) if !ok { info.Issue = "command argument must be string" return nil, info, false } args = append(args, v) } } else { info.Issue = "list not allowed for command argument" return nil, info, false } } else { v, ok := getArg(i, arg) if !ok { info.Issue = "command argument must be string" return nil, info, false } args = append(args, v) } } result, err := cachedExecute(args) if err != nil { info.Issue = "execution '" + args[0] + "' failed" // expression set to undefined return nil, info, false } str := string(result) execYML, err := yaml.Parse("exec", result) if strings.HasPrefix(str, "---\n") && err == nil { debug.Debug("exec: found yaml result %+v\n", execYML) return execYML, info, true } else { if strings.HasSuffix(str, "\n") { str = str[:len(str)-1] } int64YML, err := strconv.ParseInt(str, 10, 64) if err == nil { debug.Debug("exec: found integer result: %s\n", int64YML) return node(int64YML), info, true } debug.Debug("exec: found string result: %s\n", string(result)) return node(str), info, true } }
func parseYAML(source string) yaml.Node { parsed, err := yaml.Parse("dynaml test", []byte(source)) if err != nil { panic(err) } return parsed }
func parseYAMLFrom(source string, name string) yaml.Node { parsed, err := yaml.Parse(name, []byte(source)) if err != nil { panic(err) } return parsed }
func merge(templateFilePath string, stubFilePaths []string) { templateFile, err := ioutil.ReadFile(templateFilePath) if err != nil { log.Fatalln("error reading template:", err) } templateYAML, err := yaml.Parse(templateFilePath, templateFile) if err != nil { log.Fatalln("error parsing template:", err) } stubs := []yaml.Node{} for _, stubFilePath := range stubFilePaths { stubFile, err := ioutil.ReadFile(stubFilePath) if err != nil { log.Fatalln("error reading stub:", err) } stubYAML, err := yaml.Parse(stubFilePath, stubFile) if err != nil { log.Fatalln("error parsing stub:", err) } stubs = append(stubs, stubYAML) } flowed, err := flow.Cascade(templateYAML, stubs...) if err != nil { log.Fatalln("error generating manifest:", err) } yaml, err := candiedyaml.Marshal(flowed) if err != nil { log.Fatalln("error marshalling manifest:", err) } fmt.Println(string(yaml)) }