Example #1
0
// Tests that packages generated by the binder can be successfully compiled and
// the requested tester run against it.
func TestBindings(t *testing.T) {
	// Skip the test if no Go command can be found
	gocmd := runtime.GOROOT() + "/bin/go"
	if !common.FileExist(gocmd) {
		t.Skip("go sdk not found for testing")
	}
	// Skip the test if the go-ethereum sources are symlinked (https://github.com/golang/go/issues/14845)
	linkTestCode := fmt.Sprintf("package linktest\nfunc CheckSymlinks(){\nfmt.Println(backends.NewNilBackend())\n}")
	linkTestDeps, err := imports.Process("", []byte(linkTestCode), nil)
	if err != nil {
		t.Fatalf("failed check for goimports symlink bug: %v", err)
	}
	if !strings.Contains(string(linkTestDeps), "go-ethereum") {
		t.Skip("symlinked environment doesn't support bind (https://github.com/golang/go/issues/14845)")
	}
	// Create a temporary workspace for the test suite
	ws, err := ioutil.TempDir("", "")
	if err != nil {
		t.Fatalf("failed to create temporary workspace: %v", err)
	}
	defer os.RemoveAll(ws)

	pkg := filepath.Join(ws, "bindtest")
	if err = os.MkdirAll(pkg, 0700); err != nil {
		t.Fatalf("failed to create package: %v", err)
	}
	// Generate the test suite for all the contracts
	for i, tt := range bindTests {
		// Generate the binding and create a Go source file in the workspace
		bind, err := Bind([]string{tt.name}, []string{tt.abi}, []string{tt.bytecode}, "bindtest")
		if err != nil {
			t.Fatalf("test %d: failed to generate binding: %v", i, err)
		}
		if err = ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+".go"), []byte(bind), 0600); err != nil {
			t.Fatalf("test %d: failed to write binding: %v", i, err)
		}
		// Generate the test file with the injected test code
		code := fmt.Sprintf("package bindtest\nimport \"testing\"\nfunc Test%s(t *testing.T){\n%s\n}", tt.name, tt.tester)
		blob, err := imports.Process("", []byte(code), nil)
		if err != nil {
			t.Fatalf("test %d: failed to generate tests: %v", i, err)
		}
		if err := ioutil.WriteFile(filepath.Join(pkg, strings.ToLower(tt.name)+"_test.go"), blob, 0600); err != nil {
			t.Fatalf("test %d: failed to write tests: %v", i, err)
		}
	}
	// Test the entire package and report any failures
	cmd := exec.Command(gocmd, "test", "-v")
	cmd.Dir = pkg
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("failed to run binding test: %v\n%s", err, out)
	}
}
Example #2
0
func goimports(src []byte) (string, string) {
	out, err := imports.Process("", src, nil)
	if err != nil {
		return "", fmt.Sprintf("%v", err)
	}
	return string(out), ""
}
Example #3
0
func TranspileFile(goFilename, phpFilename, phpStr string, gosrc io.Writer) error {
	parser := parser.NewParser()
	file, err := parser.Parse(phpFilename, phpStr)
	if err != nil {
		return fmt.Errorf("found errors while parsing %s: %s", phpFilename, err)
	}

	tg := Togo{currentScope: parser.FileSet.Scope}

	nodes := []goast.Node{}
	for _, node := range tg.beginScope(tg.currentScope) {
		nodes = append(nodes, node)
	}
	for _, phpNode := range file.Nodes {
		nodes = append(nodes, tg.ToGoStmt(phpNode.(phpast.Statement)))
	}

	buf := &bytes.Buffer{}

	if err = format.Node(buf, token.NewFileSet(), File(phpFilename[:len(phpFilename)-4], nodes...)); err != nil {
		return fmt.Errorf("error while formatting %s: %s", phpFilename, err)
	}

	imported, err := imports.Process(goFilename, buf.Bytes(), &imports.Options{AllErrors: true, Comments: true, TabIndent: true, TabWidth: 8})
	if err != nil {
		return fmt.Errorf("error while getting imports for %s: %s", phpFilename, err)
	}

	_, err = gosrc.Write(imported)
	return err
}
Example #4
0
func fmtHandler(w http.ResponseWriter, r *http.Request) {
	var (
		in  = []byte(r.FormValue("body"))
		out []byte
		err error
	)

	if len(in) > maxSnippetSize {
		w.WriteHeader(http.StatusInternalServerError)
		fmt.Fprintln(w, "Compile server error.")
		return
	}

	if r.FormValue("imports") != "" {
		out, err = imports.Process("prog.go", in, nil)
	} else {
		out, err = format.Source(in)
	}

	var resp fmtResponse
	if err != nil {
		resp.Error = err.Error()
	} else {
		resp.Body = string(out)
	}

	w.Header().Set("Access-Control-Allow-Methods", "POST")
	w.Header().Set("Access-Control-Allow-Origin", *flagAllowOriginHeader)

	json.NewEncoder(w).Encode(resp)
}
Example #5
0
func validFormat(repoPath string, prFiles []*octokat.PullRequestFile) (formatted bool, files []string, err error) {
	repo, err := gitreader.OpenRepo(repoPath)
	if err != nil {
		return false, files, err
	}

	for _, file := range prFiles {
		name := file.FileName

		if strings.HasSuffix(name, ".go") && !strings.HasPrefix(name, "vendor/") {
			blob, err := repo.CatFile(file.Sha, name)
			if err != nil {
				return false, files, err
			}

			src, err := blob.Bytes()
			if err != nil {
				return false, files, err
			}

			res, err := imports.Process(name, src, nil)
			if err != nil {
				return false, files, err
			}

			if !bytes.Equal(src, res) {
				files = append(files, name)
				formatted = false
			}
		}
	}

	return len(files) == 0, files, err
}
Example #6
0
func convertFile(dest_path, source_path string, fixImports bool, types ...string) error {
	buf, err := genlib.Generate(source_path, types...)
	if err != nil {
		return err
	}

	if fixImports {
		buf, err = imports.Process(path.Base(source_path), buf, &imports.Options{
			TabWidth:  8,
			TabIndent: true,
			Comments:  true,
			Fragment:  true,
			AllErrors: false,
		})
		if err != nil {
			return err
		}
	}

	f, err := os.Create(dest_path)
	if err != nil {
		return err
	}

	_, err = io.Copy(f, bytes.NewBuffer(buf))
	if err != nil {
		return err
	}

	return nil
}
Example #7
0
func assertOutput(inPath, lang, goldenPath string, t *testing.T) {
	assert := assert.New(t)
	emptyDS := datas.NewDataStore(chunks.NewMemoryStore()) // Will be DataStore containing imports

	depsDir, err := ioutil.TempDir("", "")
	assert.NoError(err)
	defer os.RemoveAll(depsDir)

	inFile, err := os.Open(inPath)
	assert.NoError(err)
	defer inFile.Close()

	goldenFile, err := os.Open(goldenPath)
	assert.NoError(err)
	defer goldenFile.Close()
	goldenBytes, err := ioutil.ReadAll(goldenFile)
	d.Chk.NoError(err)

	var buf bytes.Buffer
	pkg := pkg.ParseNomDL("gen", inFile, filepath.Dir(inPath), emptyDS)
	written := map[string]bool{}
	gen := newCodeGen(&buf, getBareFileName(inPath), lang, written, depsMap{}, pkg)
	gen.WritePackage()

	bs := buf.Bytes()
	if lang == "go" {
		bs, err = imports.Process("", bs, nil)
		d.Chk.NoError(err)
	}

	assert.Equal(string(goldenBytes), string(bs), "%s did not generate the same string", inPath)
}
Example #8
0
// FindInterface returns the import path and identifier of an interface.
// For example, given "http.ResponseWriter", FindInterface returns
// "net/http", "ResponseWriter".
func FindInterface(iface string) (path string, pkg string, id string, err error) {
	if len(strings.Fields(iface)) != 1 {
		return "", "", "", fmt.Errorf("couldn't parse interface: %s", iface)
	}

	// Let goimports do the heavy lifting.
	src := []byte("package hack\n" + "var i " + iface)
	imp, err := imports.Process("", src, nil)
	if err != nil {
		return "", "", "", fmt.Errorf("couldn't parse interface: %s", iface)
	}

	// imp should now contain an appropriate import.
	// Parse out the import and the identifier.
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "", imp, 0)
	if err != nil {
		panic(err)
	}
	if len(f.Imports) == 0 {
		return "", "", "", fmt.Errorf("unrecognized interface: %s", iface)
	}
	raw := f.Imports[0].Path.Value   // "io"
	path, err = strconv.Unquote(raw) // io
	if err != nil {
		panic(err)
	}
	decl := f.Decls[1].(*ast.GenDecl)      // var i io.Reader
	spec := decl.Specs[0].(*ast.ValueSpec) // i io.Reader
	sel := spec.Type.(*ast.SelectorExpr)   // io.Reader
	pkg = sel.X.(*ast.Ident).Name          // io
	id = sel.Sel.Name                      // Reader
	return path, pkg, id, nil
}
Example #9
0
File: print.go Project: kgrz/msgp
func format(file string, data []byte) error {
	out, err := imports.Process(file, data, nil)
	if err != nil {
		return err
	}
	return ioutil.WriteFile(file, out, 0600)
}
Example #10
0
func main() {
	flag.Usage = usage
	flag.Parse()
	if flag.NArg() < 2 {
		usage()
	}
	args := flag.Args()
	n := len(args)
	extras := args[:n-2]
	a := args[n-2:]
	inter, typeName := a[0], a[1]
	opts := GenOpts{Inter: inter, NoGoImports: !*goimports, NoNamedReturnValues: !*named, Extra: extras}
	if !*existing {
		pi, err := parse(typeName)
		check(err)
		opts.ImplName = pi.ptr + pi.name
		opts.PkgName = pi.pkg
	} else {
		opts.Existing = typeName
		if !strings.HasSuffix(typeName, "}") && !strings.HasSuffix(typeName, ")") {
			// We need to create a instance of this type.
			// Let's it's a struct/slice.
			opts.Existing += "{}"
		}
	}

	buf := new(bytes.Buffer)
	check(tm.Execute(buf, opts))

	src, err := imports.Process("", buf.Bytes(), nil)
	check(err, "imports:", buf.String())

	check(run(src), "run:", string(src))
}
Example #11
0
func genTypesOnlyAPI(file string) error {
	apiGen := &api.API{
		NoRemoveUnusedShapes:   true,
		NoRenameToplevelShapes: true,
	}
	apiGen.Attach(file)
	apiGen.Setup()
	// to reset imports so that timestamp has an entry in the map.
	apiGen.APIGoCode()

	var buf bytes.Buffer
	err := typesOnlyTplAPI.Execute(&buf, apiGen)
	if err != nil {
		panic(err)
	}
	code := strings.TrimSpace(buf.String())
	code = util.GoFmt(code)

	// Ignore dir error, filepath will catch it for an invalid path.
	os.Mkdir(apiGen.PackageName(), 0755)
	// Fix imports.
	codeWithImports, err := imports.Process("", []byte(fmt.Sprintf("package %s\n\n%s", apiGen.PackageName(), code)), nil)
	if err != nil {
		fmt.Println(err)
		return err
	}
	outFile := filepath.Join(apiGen.PackageName(), "api.go")
	err = ioutil.WriteFile(outFile, []byte(fmt.Sprintf("%s\n%s", copyrightHeader, codeWithImports)), 0644)
	if err != nil {
		return err
	}
	return nil
}
Example #12
0
func main() {
	runtime.GOMAXPROCS(runtime.NumCPU())
	flag.Parse()

	var funcOut io.Writer
	if *functionDest == "-" {
		funcOut = os.Stdout
	} else {
		file, err := os.Create(*functionDest)
		if err != nil {
			glog.Fatalf("Couldn't open %v: %v", *functionDest, err)
		}
		defer file.Close()
		funcOut = file
	}

	data := new(bytes.Buffer)

	group, version := path.Split(*groupVersion)
	group = strings.TrimRight(group, "/")

	_, err := data.WriteString(fmt.Sprintf("package %v\n", version))
	if err != nil {
		glog.Fatalf("error writing package line: %v", err)
	}

	versionPath := path.Join(pkgBase, group, version)
	generator := pkg_runtime.NewConversionGenerator(api.Scheme.Raw(), versionPath)
	apiShort := generator.AddImport(path.Join(pkgBase, "api"))
	generator.AddImport(path.Join(pkgBase, "api/resource"))
	// TODO(wojtek-t): Change the overwrites to a flag.
	generator.OverwritePackage(version, "")
	for _, knownType := range api.Scheme.KnownTypes(version) {
		if !strings.HasPrefix(knownType.PkgPath(), versionPath) {
			continue
		}
		if err := generator.GenerateConversionsForType(version, knownType); err != nil {
			glog.Errorf("error while generating conversion functions for %v: %v", knownType, err)
		}
	}
	generator.RepackImports(util.NewStringSet())
	if err := generator.WriteImports(data); err != nil {
		glog.Fatalf("error while writing imports: %v", err)
	}
	if err := generator.WriteConversionFunctions(data); err != nil {
		glog.Fatalf("Error while writing conversion functions: %v", err)
	}
	if err := generator.RegisterConversionFunctions(data, fmt.Sprintf("%s.Scheme", apiShort)); err != nil {
		glog.Fatalf("Error while writing conversion functions: %v", err)
	}

	b, err := imports.Process("", data.Bytes(), nil)
	if err != nil {
		glog.Fatalf("error while update imports: %v", err)
	}
	if _, err := funcOut.Write(b); err != nil {
		glog.Fatalf("error while writing out the resulting file: %v", err)
	}
}
Example #13
0
// WriteFormattedFile formats the code with goimports and writes the result to
// the given file, if file doesnt exists, it creates it
func WriteFormattedFile(fileName string, model []byte) error {
	dest, err := imports.Process("", model, nil)
	if err != nil {
		return err
	}

	return Write(fileName, dest)
}
Example #14
0
File: go.go Project: tcnksm/gotests
func (gf *GoFile) Generate() ([]byte, error) {
	var buf bytes.Buffer
	if err := printer.Fprint(&buf, gf.FSet, gf.AstFile); err != nil {
		return nil, err
	}

	return imports.Process(gf.FileName, buf.Bytes(), nil)
}
Example #15
0
func main() {
	iface := "http.Handler"
	src := "package hack; var i " + iface // HL
	fmt.Println(src, "\n---")

	imp, _ := imports.Process("", []byte(src), nil) // HL
	// ignoring errors throughout this presentation
	fmt.Println(string(imp))
}
Example #16
0
func formatGoFile(ffn string, content []byte) ([]byte, error) {
	opts := new(imports.Options)
	opts.TabIndent = true
	opts.TabWidth = 2
	opts.Fragment = true
	opts.Comments = true

	return imports.Process(ffn, content, opts)
}
Example #17
0
// WriteAll writes the generated code for all Types and TypeWriters in the App to respective files.
func (a *App) WriteAll() ([]string, error) {
	var written []string

	// one buffer for each file, keyed by file name
	buffers := make(map[string]*bytes.Buffer)

	// write the generated code for each Type & TypeWriter into memory
	for _, p := range a.Packages {
		for _, t := range p.Types {
			for _, tw := range a.TypeWriters {
				var b bytes.Buffer
				n, err := write(&b, a, p, t, tw)

				if err != nil {
					return written, err
				}

				// don't generate a file if no bytes were written by WriteHeader or WriteBody
				if n == 0 {
					continue
				}

				// append _test to file name if the source type is in a _test.go file
				f := strings.ToLower(fmt.Sprintf("%s_%s%s.go", t.Name, tw.Name(), t.test))

				buffers[f] = &b
			}
		}
	}

	// validate generated ast's before committing to files
	for f, b := range buffers {
		if _, err := parser.ParseFile(token.NewFileSet(), f, b.String(), 0); err != nil {
			// TODO: prompt to write (ignored) _file on error? parsing errors are meaningless without.
			return written, err
		}
	}

	// format, remove unused imports, and commit to files
	for f, b := range buffers {
		src, err := imports.Process(f, b.Bytes(), nil)

		// shouldn't be an error if the ast parsing above succeeded
		if err != nil {
			return written, err
		}

		if err := writeFile(f, src); err != nil {
			return written, err
		}

		written = append(written, f)
	}

	return written, nil
}
Example #18
0
func WriteTo(w io.Writer, b *bytes.Buffer) error {
	opt := &imports.Options{Comments: true}
	res, err := imports.Process("mock.go", b.Bytes(), opt)
	if err != nil {
		return err
	}

	_, err = w.Write(res)
	return err
}
Example #19
0
func (g *Generator) Write(w io.Writer) error {
	opt := &imports.Options{Comments: true}
	res, err := imports.Process("mock.go", g.buf.Bytes(), opt)
	if err != nil {
		return err
	}

	w.Write(res)
	return nil
}
Example #20
0
func prettyfy(input []byte, wr io.Writer) error {
	output, err := imports.Process("storable.go", input, nil)
	if err != nil {
		printDocumentWithNumbers(string(input))
		return err
	}

	_, err = wr.Write(output)
	return err
}
Example #21
0
func (gen CodeGenerator) GenerateFake() (string, error) {
	buf := new(bytes.Buffer)
	err := format.Node(buf, token.NewFileSet(), gen.sourceFile())
	if err != nil {
		return "", err
	}

	code, err := imports.Process("", buf.Bytes(), nil)
	return commentLine() + prettifyCode(string(code)), err
}
Example #22
0
func processFile(filename string, in io.Reader, out io.Writer, stdin bool) error {
	opt := options
	if stdin {
		nopt := *options
		nopt.Fragment = true
		opt = &nopt
	}

	if in == nil {
		f, err := os.Open(filename)
		if err != nil {
			return err
		}
		defer f.Close()
		in = f
	}

	src, err := ioutil.ReadAll(in)
	if err != nil {
		return err
	}

	res, err := imports.Process(filename, src, opt)
	if err != nil {
		return err
	}

	if !bytes.Equal(src, res) {
		// formatting has changed
		if *list {
			fmt.Fprintln(out, filename)
		}
		if *write {
			err = ioutil.WriteFile(filename, res, 0)
			if err != nil {
				return err
			}
		}
		if *doDiff {
			data, err := diff(src, res)
			if err != nil {
				return fmt.Errorf("computing diff: %s", err)
			}
			fmt.Printf("diff %s gofmt/%s\n", filename, filename)
			out.Write(data)
		}
	}

	if !*list && !*write && !*doDiff {
		_, err = out.Write(res)
	}

	return err
}
Example #23
0
func genFull(file string) error {
	// Heavily inspired by https://github.com/aws/aws-sdk-go/blob/45ba2f817fbf625fe48cf9b51fae13e5dfba6171/internal/model/cli/gen-api/main.go#L36
	// That code is copyright Amazon
	api := &api.API{}
	api.Attach(file)
	paginatorsFile := strings.Replace(file, "api-2.json", "paginators-1.json", -1)
	if _, err := os.Stat(paginatorsFile); err == nil {
		api.AttachPaginators(paginatorsFile)
	}

	docsFile := strings.Replace(file, "api-2.json", "docs-2.json", -1)
	if _, err := os.Stat(docsFile); err == nil {
		api.AttachDocs(docsFile)
	}
	api.Setup()

	processedApiCode, err := imports.Process("", []byte(fmt.Sprintf("package %s\n\n%s", api.PackageName(), api.APIGoCode())), nil)
	if err != nil {
		fmt.Println(err)
		return err
	}
	// Ignore dir error, filepath will catch it for an invalid path.
	os.Mkdir(api.PackageName(), 0755)
	outFile := filepath.Join(api.PackageName(), "api.go")
	err = ioutil.WriteFile(outFile, []byte(fmt.Sprintf("%s\n%s", copyrightHeader, processedApiCode)), 0644)
	if err != nil {
		return err
	}

	processedServiceCode, err := imports.Process("", []byte(fmt.Sprintf("package %s\n\n%s", api.PackageName(), api.ServiceGoCode())), nil)
	if err != nil {
		fmt.Println(err)
		return err
	}
	outFile = filepath.Join(api.PackageName(), "service.go")
	err = ioutil.WriteFile(outFile, []byte(fmt.Sprintf("%s\n%s", copyrightHeader, processedServiceCode)), 0644)
	if err != nil {
		return err
	}
	return nil
}
Example #24
0
func (s *Sandbox) imports(w http.ResponseWriter, r *http.Request) {
	code, _ := ioutil.ReadAll(r.Body)
	newCode, err := imports.Process("main.go", code, s.importsOpts)
	s.stats.Imports++
	if err != nil {
		w.WriteHeader(400)
		w.Write([]byte(err.Error()))
		return
	}
	w.WriteHeader(200)
	w.Write(newCode)
}
Example #25
0
func main() {
	if len(os.Args) != 2 {
		panic("Must have exactly one argument; the output file")
	}

	type simpleTestMetadata struct {
		Name           string
		Description    string
		TaskDefinition string
		Timeout        string
		ExitCodes      map[string]int
		Tags           []string
		Version        string
	}

	_, filename, _, _ := runtime.Caller(0)
	metadataFiles, err := filepath.Glob(filepath.Join(path.Dir(filename), "..", "testdata", "simpletests", "*.json"))
	if err != nil || len(metadataFiles) == 0 {
		panic("No tests found" + err.Error())
	}

	testMetadatas := make([]simpleTestMetadata, len(metadataFiles))
	for i, f := range metadataFiles {
		data, err := ioutil.ReadFile(f)
		if err != nil {
			panic("Cannot read file " + f)
		}
		err = json.Unmarshal(data, &testMetadatas[i])
		if err != nil {
			panic("Cannot parse " + f + ": " + err.Error())
		}
	}

	simpleTests := template.Must(template.New("simpleTest").Parse(simpleTestPattern))
	output := bytes.NewBuffer([]byte{})
	err = simpleTests.Execute(output, testMetadatas)
	if err != nil {
		panic(err)
	}
	formattedOutput, err := imports.Process("", output.Bytes(), nil)
	if err != nil {
		fmt.Println(string(output.Bytes()))
		panic(err)
	}

	// Add '.go' so the arg can be used with 'go run' as well, without being interpreted as a file to run
	outputFile, err := os.Create(os.Args[1] + ".go")
	if err != nil {
		panic(err)
	}
	outputFile.Write(formattedOutput)
}
Example #26
0
func writeWithFormat(file, template string, binCode binCode) ([]byte, error) {
	var b bytes.Buffer
	w := bufio.NewWriter(&b)

	write(w, template, binCode)
	w.Flush()

	formatted, err := imports.Process(file, b.Bytes(), nil)
	if err != nil {
		return nil, err
	}
	return formatted, nil
}
Example #27
0
File: table.go Project: oov/sqruct
// Source returns source code in Go.
func (t *Table) Source() (string, error) {
	b, err := render(t.SourceTemplate, t.parent.SourceTemplate, sourceTemplate, t)
	if err != nil {
		return "", err
	}

	b2, err := imports.Process("", b, nil)
	if err != nil {
		log.Println("WARN:", err)
		return string(b), nil
	}

	return string(b2), nil
}
Example #28
0
//Generate find all gtm templates in directory, generate go code and save it
func Generate(dir string) (gtms []string, err error) {

	//get all files. with extension .gtm in dir
	gtms, err = filepath.Glob(path.Join(dir, "*"+*extension))
	if err != nil {
		return
	}

	if *verbose {
		fmt.Println("find", len(gtms), "template files")
	}

	//generate it
	for _, gtm := range gtms {
		if *verbose {
			fmt.Println(gtm)
		}
		var filedata []byte

		//parse gtm
		filedata, err = Parse(gtm)
		if err != nil {
			return
		}

		if *verbose {
			scanner := bufio.NewScanner(bytes.NewReader(filedata))
			var i int
			for scanner.Scan() {
				i++
				fmt.Println(i, scanner.Text())
			}
			// fmt.Println(string(filedata))
		}

		// save
		filename := regexp.MustCompile(*extension+"$").ReplaceAllString(gtm, ".go")

		filedata, err = imports.Process(filename, filedata, nil)
		if err != nil {
			return
		}

		if err = ioutil.WriteFile(filename, filedata, 0755); err != nil {
			return
		}
	}
	return
}
Example #29
0
func main() {
	var out *os.File
	var err error
	flag.Parse()

	if len(flag.Args()) != 2 {
		log.Fatalln("invalid arguments")
	}

	pkgName := flag.Arg(0)
	chType := flag.Arg(1)

	if *outfile == "" {
		out = os.Stdout
	} else {
		out, err = os.Create(*outfile)
		if err != nil {
			log.Fatal(err)
		}
	}

	if chType == "" {
		log.Fatal("type not specified")
	}

	info := struct {
		PkgName   string
		ChType    string
		PrintName string
	}{
		pkgName,
		chType,
		printableName(chType),
	}

	buf := &bytes.Buffer{}
	if err := tmpl.Execute(buf, info); err != nil {
		log.Fatal(err)
	}
	b, err := imports.Process(*outfile, buf.Bytes(), nil)
	if err != nil {
		log.Fatal(err)
	}
	buf = bytes.NewBuffer(b)

	if _, err := io.Copy(out, buf); err != nil {
		log.Fatal(err)
	}
}
Example #30
0
func renderCode(fullpath string, tmpl *template.Template, context interface{}) (fb []byte, err error) {
	targetBuf := bytes.Buffer{}

	err = tmpl.Execute(&targetBuf, context)
	if err != nil {
		return nil, fmt.Errorf("Problem rendering %s : %v", tmpl.Name(), err)
	}

	fb, err = imports.Process(fullpath, targetBuf.Bytes(), nil)
	if err != nil {
		return targetBuf.Bytes(), fmt.Errorf("Problem formatting %s : %v\n%s", tmpl.Name(), err, targetBuf.Bytes())
	}

	return fb, err
}