Golang Import示例

说明

golang import示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: go/build

示例#1
文件: packages.go 项目: nelsam/hel

func parsePatterns(pkgPatterns ...string) (packages []string) {
	for _, pkgPattern := range pkgPatterns {
		if !strings.HasSuffix(pkgPattern, "...") {
			packages = append(packages, pkgPattern)
			continue
		}
		parent := strings.TrimSuffix(pkgPattern, "...")
		parentPkg, err := build.Import(parent, cwd, build.AllowBinary)
		if err != nil {
			panic(err)
		}
		filepath.Walk(parentPkg.Dir, func(path string, info os.FileInfo, err error) error {
			if !info.IsDir() {
				return nil
			}
			path = strings.Replace(path, parentPkg.Dir, parent, 1)
			if _, err := build.Import(path, cwd, build.AllowBinary); err != nil {
				// This directory doesn't appear to be a go package
				return nil
			}
			packages = append(packages, path)
			return nil
		})
	}
	return
}

示例#2
文件: new.go 项目: pmlarocque/revel

func newApp(args []string) {
	if len(args) == 0 {
		errorf("No path given.\nRun 'revel help new' for usage.\n")
	}

	importPath := args[0]
	_, err := build.Import(importPath, "", build.FindOnly)
	if err == nil {
		fmt.Fprintf(os.Stderr, "Abort: Import path %s already exists.\n", importPath)
		return
	}

	revelPkg, err := build.Import("github.com/robfig/revel", "", build.FindOnly)
	if err != nil {
		fmt.Fprintln(os.Stderr, "Failed to find revel code.")
		return
	}

	appDir := path.Join(revelPkg.SrcRoot, filepath.FromSlash(importPath))
	err = os.MkdirAll(appDir, 0777)
	panicOnError(err, "Failed to create directory "+appDir)

	skeletonBase = path.Join(revelPkg.Dir, "skeleton")
	mustCopyDir(appDir, skeletonBase, map[string]interface{}{
		// app.conf
		"AppName": filepath.Base(appDir),
		"Secret":  genSecret(),
	})

	fmt.Fprintln(os.Stdout, "Your application is ready:\n  ", appDir)
	fmt.Fprintln(os.Stdout, "\nYou can run it with:\n   revel run", importPath)
}

示例#3
文件: new.go 项目: huaguzi/revel

func setApplicationPath(args []string) {
	var err error
	importPath = args[0]
	if filepath.IsAbs(importPath) {
		errorf("Abort: '%s' looks like a directory.  Please provide a Go import path instead.",
			importPath)
	}

	_, err = build.Import(importPath, "", build.FindOnly)
	if err == nil {
		errorf("Abort: Import path %s already exists.\n", importPath)
	}

	revelPkg, err = build.Import(revel.REVEL_IMPORT_PATH, "", build.FindOnly)
	if err != nil {
		errorf("Abort: Could not find Revel source code: %s\n", err)
	}

	appPath = filepath.Join(srcRoot, filepath.FromSlash(importPath))
	appName = filepath.Base(appPath)
	basePath = filepath.ToSlash(filepath.Dir(importPath))

	if basePath == "." {
		// we need to remove the a single '.' when
		// the app is in the $GOROOT/src directory
		basePath = ""
	} else {
		// we need to append a '/' when the app is
		// is a subdirectory such as $GOROOT/src/path/to/revelapp
		basePath += "/"
	}
}

示例#4
文件: genmath.go 项目: kelsieflynn/llgo

// genMath generates the standard math package.
func genMath() error {
	log.Println("Generating math package")

	// XXX currently just copying the already-generated Go files from the
	// standard library. We'll need to either translate the assembly files
	// (manually or automatically), or perhaps use compiler-rt.

	gopkg, err := build.Import("math", "", 0)
	if err != nil {
		return err
	}

	const llgopkgpath = "github.com/axw/llgo/pkg/math"
	llgopkg, err := build.Import(llgopkgpath, "", build.FindOnly)
	if err != nil {
		return err
	}

	for _, filename := range gopkg.GoFiles {
		srcfile := filepath.Join(gopkg.Dir, filename)
		data, err := ioutil.ReadFile(srcfile)
		if err != nil {
			return err
		}
		dstfile := filepath.Join(llgopkg.Dir, filename)
		err = ioutil.WriteFile(dstfile, data, os.FileMode(0644))
		if err != nil {
			return err
		}
		log.Printf("- %s", filename)
	}

	return nil
}

示例#5
文件: gensyscall.go 项目: kelsieflynn/llgo

// genSyscall generates the standard syscall package.
func genSyscall() error {
	log.Println("Generating syscall package")

	// XXX currently just copying the already-generated Go files from the
	// standard library. In the future, we'll just copy the handwritten
	// bits and generate the other stuff using a pure-Go package.

	gopkg, err := build.Import("syscall", "", 0)
	if err != nil {
		return err
	}

	const llgopkgpath = "github.com/axw/llgo/pkg/syscall"
	llgopkg, err := build.Import(llgopkgpath, "", build.FindOnly)
	if err != nil {
		return err
	}

	for _, filename := range gopkg.GoFiles {
		srcfile := filepath.Join(gopkg.Dir, filename)
		data, err := ioutil.ReadFile(srcfile)
		if err != nil {
			return err
		}
		dstfile := filepath.Join(llgopkg.Dir, filename)
		err = ioutil.WriteFile(dstfile, data, os.FileMode(0644))
		if err != nil {
			return err
		}
		log.Printf("- %s", filename)
	}

	return nil
}

示例#6
文件: revel.go 项目: jlujan/revel

// findSrcPaths uses the "go/build" package to find the source root for Revel
// and the app.
func findSrcPaths(importPath string) (revelSourcePath, appSourcePath string) {
	var (
		gopaths = filepath.SplitList(build.Default.GOPATH)
		goroot  = build.Default.GOROOT
	)

	if len(gopaths) == 0 {
		ERROR.Fatalln("GOPATH environment variable is not set. ",
			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
	}

	if ContainsString(gopaths, goroot) {
		ERROR.Fatalf("GOPATH (%s) must not include your GOROOT (%s). "+
			"Please refer to http://golang.org/doc/code.html to configure your Go environment.",
			gopaths, goroot)
	}

	appPkg, err := build.Import(importPath, "", build.FindOnly)
	if err != nil {
		ERROR.Fatalln("Failed to import", importPath, "with error:", err)
	}

	revelPkg, err := build.Import(REVEL_IMPORT_PATH, "", build.FindOnly)
	if err != nil {
		ERROR.Fatalln("Failed to find Revel with error:", err)
	}

	return revelPkg.SrcRoot, appPkg.SrcRoot
}

示例#7
文件: cmd_new.go 项目: repp/armadillo

func setAppPaths(args []string) {
	var err error
	importPath := args[0]
	if filepath.IsAbs(importPath) {
		errorf("Abort: '%s' looks like a directory.  Please provide a Go import path instead.", importPath)
	}

	_, err = build.Import(importPath, "", build.FindOnly)
	if err == nil {
		errorf("Abort: Import path %s already exists.\n", importPath)
	}

	armadilloPkg, err2 := build.Import(IMPORT_PATH, "", build.FindOnly)
	if err2 != nil {
		errorf("Abort: Could not find Armadillo source code: %s\n", err)
	}

	appPath = filepath.Join(srcRoot, filepath.FromSlash(importPath))
	appName = filepath.Base(appPath)
	skeletonPath = filepath.Join(armadilloPkg.Dir, "skeleton")
	templateData = map[string]interface{}{
		"AppName": appName,
	}

}

示例#8
文件: buildllgo.go 项目: kelsieflynn/llgo

func buildLlgo() error {
	log.Println("Building llgo")

	pkg, err := build.Import(gollvmpkgpath, "", build.FindOnly)
	if err != nil {
		return err
	}

	cgoCflags := fmt.Sprintf("%s -I %s/../include", llvmcflags, pkg.Dir)
	cgoLdflags := fmt.Sprintf("%s -Wl,-L%s -lLLVM-%s",
		llvmldflags, llvmlibdir, llvmversion)

	var output []byte
	ldflags := "-r " + llvmlibdir
	args := []string{"get", "-ldflags", ldflags}

	llvmtag := "llvm" + llvmversion
	if strings.HasSuffix(llvmversion, "svn") {
		llvmtag = "llvmsvn"
	}
	args = append(args, []string{"-tags", llvmtag}...)

	args = append(args, llgopkgpath)
	cmd := exec.Command("go", args...)
	cmd.Env = os.Environ()
	cmd.Env = append(cmd.Env, "CGO_CFLAGS="+cgoCflags)
	cmd.Env = append(cmd.Env, "CGO_LDFLAGS="+cgoLdflags)

	output, err = cmd.CombinedOutput()
	if err != nil {
		fmt.Fprintf(os.Stderr, "%s\n", string(output))
		return err
	}

	pkg, err = build.Import(llgopkgpath, "", build.FindOnly)
	if err != nil {
		return err
	}
	llgobin = path.Join(pkg.BinDir, "llgo")

	// If the user did not specify -triple on the command
	// line, ask llgo for it now.
	if triple == "" {
		output, err = exec.Command(llgobin, "-print-triple").CombinedOutput()
		if err != nil {
			fmt.Fprintf(os.Stderr, "%s\n", string(output))
			return err
		}
		triple = strings.TrimSpace(string(output))
	}
	if err = initGOVARS(triple); err != nil {
		return err
	}
	log.Printf("GOARCH = %s, GOOS = %s", GOARCH, GOOS)

	log.Printf("Built %s", llgobin)
	return nil
}

示例#9
文件: git_test.go 项目: CadeLaRen/gov

func init() {
	var err error
	govdep1, err = build.Import("github.com/brianm/govdep1", ".", 0)
	if err != nil {
		panic(err)
	}

	govdep2, err = build.Import("bitbucket.org/xnio/govdep2", ".", 0)
	if err != nil {
		panic(err)
	}
}

示例#10
文件: new.go 项目: Joinhack/peony

func newapp(args []string) {
	if len(args) == 0 {
		eprintf(newShortDesc)
	}
	filepath.Join(peony.GetPeonyPath(), "templates")
	importPath := args[0]

	gopath := build.Default.GOPATH

	if gopath == "" {
		eprintf("please set the GOPATH\n", importPath)
	}

	if filepath.IsAbs(importPath) {
		eprintf("importpath[%s] looks like the file path.\n", importPath)
	}

	if _, err := build.Import(importPath, "", build.FindOnly); err == nil {
		eprintf("importpath[%s] already exist.\n", importPath)
	}

	if _, err := build.Import(peony.PEONY_IMPORTPATH, "", build.FindOnly); err != nil {
		eprintf("peony source is required.\n")
	}

	tmplatesPath := filepath.Join(peony.GetPeonyPath(), "templates")
	errorsPath := filepath.Join(peony.GetPeonyPath(), "views", "errors")

	srcPath := filepath.Join(filepath.SplitList(gopath)[0], "src")
	appPath := filepath.Join(srcPath, filepath.FromSlash(importPath))
	if err := os.Mkdir(appPath, 0777); err != nil {
		eprintf("mdir app dir error, %s\n", err.Error())
	}
	if err := copyDir(tmplatesPath, appPath); err != nil {
		eprintf("copy dir error, %s\n", err.Error())
	}
	if err := copyDir(errorsPath, filepath.Join(appPath, "app", "views", "errors")); err != nil {
		eprintf("copy dir error, %s\n", err.Error())
	}
	appName := filepath.Base(filepath.FromSlash(importPath))
	param := map[string]string{
		"AppName":    appName,
		"ImportPath": importPath,
		"SecKey":     peony.GenSecKey(),
	}
	if err := genConfig(appPath, param); err != nil {
		eprintf("generator configure error, %s\n", err.Error())
	}
	fmt.Println("app already is ready, please execute command: peony run", importPath)
}

示例#11
文件: revel.go 项目: rjmcguire/revel

func Init(importPath string, mode string) {
	RunMode = mode

	// Find the user's app path.
	importPath = strings.TrimRight(importPath, "/")
	pkg, err := build.Import(importPath, "", build.FindOnly)
	if err != nil {
		log.Fatalln("Failed to import", importPath, "with error:", err)
	}
	BasePath = pkg.Dir
	if BasePath == "" {
		log.Fatalf("Failed to find code.  Did you pass the import path?")
	}
	AppName = filepath.Base(BasePath)
	AppPath = path.Join(BasePath, "app")
	ViewsPath = path.Join(AppPath, "views")
	ImportPath = importPath

	// Find the provided resources.
	revelPkg, err := build.Import("github.com/robfig/revel", "", build.FindOnly)
	if err != nil {
		log.Fatalf("Failed to find revel code.")
	}
	RevelPath = revelPkg.Dir
	RevelTemplatePath = path.Join(RevelPath, "templates")

	// Load application.conf
	Config, err = LoadConfig(path.Join(BasePath, "conf", "app.conf"))
	if err != nil {
		log.Fatalln("Failed to load app.conf:", err)
	}
	Config.SetSection(mode)
	secretStr, err := Config.String("app.secret")
	if err != nil {
		log.Fatalln("No app.secret provided.")
	}
	secretKey = []byte(secretStr)

	// Configure logging.
	TRACE = getLogger("trace")
	INFO = getLogger("info")
	WARN = getLogger("warn")
	ERROR = getLogger("error")

	for _, hook := range InitHooks {
		hook()
	}

	revelInit = true
}

示例#12
文件: new.go 项目: ubik86/revel

func newApp(args []string) {
	if len(args) == 0 {
		errorf("No import path given.\nRun 'revel help new' for usage.\n")
	}

	gopath := build.Default.GOPATH
	if gopath == "" {
		errorf("Abort: GOPATH environment variable is not set. " +
			"Please refer to http://golang.org/doc/code.html to configure your Go environment.")
	}

	importPath := args[0]
	if path.IsAbs(importPath) {
		errorf("Abort: '%s' looks like a directory.  Please provide a Go import path instead.",
			importPath)
	}

	_, err := build.Import(importPath, "", build.FindOnly)
	if err == nil {
		fmt.Fprintf(os.Stderr, "Abort: Import path %s already exists.\n", importPath)
		return
	}

	revelPkg, err := build.Import(revel.REVEL_IMPORT_PATH, "", build.FindOnly)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Abort: Could not find Revel source code: %s\n", err)
		return
	}

	srcRoot := path.Join(filepath.SplitList(gopath)[0], "src")
	appDir := path.Join(srcRoot, filepath.FromSlash(importPath))
	err = os.MkdirAll(appDir, 0777)
	panicOnError(err, "Failed to create directory "+appDir)

	skeletonBase = path.Join(revelPkg.Dir, "skeleton")
	mustCopyDir(appDir, skeletonBase, map[string]interface{}{
		// app.conf
		"AppName": filepath.Base(appDir),
		"Secret":  genSecret(),
	})

	// Dotfiles are skipped by mustCopyDir, so we have to explicitly copy the .gitignore.
	gitignore := ".gitignore"
	mustCopyFile(path.Join(appDir, gitignore), path.Join(skeletonBase, gitignore))

	fmt.Fprintln(os.Stdout, "Your application is ready:\n  ", appDir)
	fmt.Fprintln(os.Stdout, "\nYou can run it with:\n   revel run", importPath)
}

示例#13
文件: reflect.go 项目: spate/llgo

func doParseReflect() {
	buildpkg, err := build.Import("reflect", "", 0)
	if err != nil {
		parseReflectResult, parseReflectError = nil, err
		return
	}

	filenames := make([]string, len(buildpkg.GoFiles))
	for i, f := range buildpkg.GoFiles {
		filenames[i] = path.Join(buildpkg.Dir, f)
	}
	fset := token.NewFileSet()
	files, err := parseFiles(fset, filenames)
	if err != nil {
		parseReflectResult, parseReflectError = nil, err
		return
	}

	pkg, err := ast.NewPackage(fset, files, types.GcImport, types.Universe)
	if err != nil {
		parseReflectResult, parseReflectError = nil, err
		return
	}

	_, err = types.Check(fset, pkg)
	if err != nil {
		parseReflectResult, parseReflectError = nil, err
		return
	}

	parseReflectResult, parseReflectError = pkg, nil
	return
}

示例#14
文件: gen.go 项目: wingdog/gom

func scanDirectory(path, srcDir string) (ret []string, err error) {
	pkg, err := build.Import(path, srcDir, build.AllowBinary)
	if err != nil {
		return ret, err
	}

	for _, imp := range pkg.Imports {
		switch {
		case isStandardImport(imp):
			// Ignore standard packages
		case !build.IsLocalImport(imp):
			// Add the external package
			ret = appendPkg(ret, imp)
			fallthrough
		default:
			// Does the recursive walk
			pkgs, err := scanDirectory(imp, pkg.Dir)
			if err != nil {
				return ret, err
			}
			ret = appendPkgs(ret, pkgs)
		}
	}

	return ret, err
}

示例#15
文件: restore.go 项目: mitake/godep

// restore checks out the given revision.
func restore(dep Dependency) error {
	rev, ok := restored[dep.root]
	debugln(rev)
	debugln(ok)
	debugln(dep.root)
	if ok {
		if rev != dep.Rev {
			return errors.New("Wanted to restore rev " + dep.Rev + ", already restored rev " + rev + " for another package in the repo")
		}
		verboseln("Skipping already restored repo")
		return nil
	}

	debugln("Restoring:", dep.ImportPath, dep.Rev)
	pkg, err := build.Import(dep.ImportPath, ".", build.FindOnly)
	if err != nil {
		// This should never happen
		debugln("Error finding package "+dep.ImportPath+" on restore:", err)
		return err
	}
	err = dep.vcs.RevSync(pkg.Dir, dep.Rev)
	if err == nil {
		restored[dep.root] = dep.Rev
	}
	return err
}

示例#16
文件: subservice.go 项目: sdmajor/skynet

func NewSubService(log skynet.Logger, servicePath, args, uuid string) (ss *SubService, err error) {
	ss = &SubService{
		ServicePath: servicePath,
		Args:        args,
		// TODO: proper argument splitting
	}
	ss.argv, err = shellquote.Split(args)
	if err != nil {
		return
	}

	ss.argv = append([]string{"-uuid", uuid}, ss.argv...)

	//verify that it exists on the local system

	pkg, err := build.Import(ss.ServicePath, "", 0)
	if err != nil {
		return
	}

	if pkg.Name != "main" {
		return
	}

	_, binName := path.Split(ss.ServicePath)
	binPath := filepath.Join(pkg.BinDir, binName)
	ss.binPath = binPath

	return
}

示例#17
文件: main.go 项目: dsnet/compress

func defaultPaths() string {
	pkg, err := build.Import(testPkg, "", build.FindOnly)
	if err != nil {
		return ""
	}
	return pkg.Dir
}

示例#18
文件: main.go 项目: 0x7cc/rsc

func main() {
	flag.Parse()
	if build.Default.GOARCH == "amd64" {
		ptrKind = "Q"
		ptrSize = 8
		if *useInt64 {
			intSize = 8
			newIntSize = intSize
			intKind = "Q"
		}
		if *fixInt64 {
			newIntSize = 8
			*fixOffset = true
		}
	}
	args := flag.Args()
	if len(args) == 0 {
		p, err := build.ImportDir(".", 0)
		if err != nil {
			log.Fatal(err)
		}
		check(p)
	} else {
		for _, arg := range args {
			p, err := build.Import(arg, "", 0)
			if err != nil {
				log.Print(err)
				continue
			}
			check(p)
		}
	}
}

示例#19
文件: plan_test.go 项目: CadeLaRen/gov

func init() {
	var err error
	example, err = build.Import("github.com/brianm/gov/example", ".", 0)
	if err != nil {
		panic(err)
	}
}

示例#20
文件: errcheck_test.go 项目: robfig/errcheck

func init() {
	unchecked = make(map[marker]bool)
	blank = make(map[marker]bool)

	pkg, err := build.Import(testPackage, "", 0)
	if err != nil {
		panic("failed to import test package")
	}
	fset := token.NewFileSet()
	astPkg, err := parser.ParseDir(fset, pkg.Dir, nil, parser.ParseComments)
	if err != nil {
		panic("failed to parse test package")
	}

	for _, file := range astPkg["main"].Files {
		for _, comment := range file.Comments {
			text := comment.Text()
			pos := fset.Position(comment.Pos())
			switch text {
			case "UNCHECKED\n":
				unchecked[marker{pos.Filename, pos.Line}] = true
			case "BLANK\n":
				blank[marker{pos.Filename, pos.Line}] = true
			}
		}
	}
}

示例#21
文件: main.go 项目: bz2/httprequest

func generate(serverPkg, serverType, clientType string) error {
	cwd, err := os.Getwd()
	if err != nil {
		return err
	}
	currentDir = cwd

	methods, imports, err := serverMethods(serverPkg, serverType)
	if err != nil {
		return errgo.Mask(err)
	}
	localPkg, err := build.Import(".", currentDir, 0)
	if err != nil {
		return errgo.Notef(err, "cannot open package in current directory")
	}
	arg := templateArg{
		CommandLine: strings.Join(flag.Args(), " "),
		Imports:     imports,
		Methods:     methods,
		PkgName:     localPkg.Name,
		ClientType:  clientType,
	}
	var buf bytes.Buffer
	if err := code.Execute(&buf, arg); err != nil {
		return errgo.Mask(err)
	}
	data, err := format.Source(buf.Bytes())
	if err != nil {
		return errgo.Notef(err, "cannot format source")
	}
	if err := writeOutput(data, clientType); err != nil {
		return errgo.Mask(err)
	}
	return nil
}

示例#22
文件: nodot.go 项目: dasmithii/escher

func getExportedDeclerationsForPackage(pkgPath string, filename string, blacklist ...string) ([]string, error) {
	pkg, err := build.Import(pkgPath, ".", 0)
	if err != nil {
		return []string{}, err
	}

	declarations, err := getExportedDeclarationsForFile(filepath.Join(pkg.Dir, filename))
	if err != nil {
		return []string{}, err
	}

	blacklistLookup := map[string]bool{}
	for _, declaration := range blacklist {
		blacklistLookup[declaration] = true
	}

	filteredDeclarations := []string{}
	for _, declaration := range declarations {
		if blacklistLookup[declaration] {
			continue
		}
		filteredDeclarations = append(filteredDeclarations, declaration)
	}

	return filteredDeclarations, nil
}

示例#23
文件: run_darwin.go 项目: shadown/francis

func (e *Engine) Run(command []string, filename string, memlimit, timeout int) (crash.Info, error) {

	pkg, err := build.Import("github.com/bnagy/francis", ".", build.FindOnly)
	if err != nil {
		return crash.Info{}, fmt.Errorf("Couldn't find import path: %s", err)
	}
	tool := filepath.Join(pkg.Dir, "exploitaben/exploitaben.py")

	// Construct the command array
	cmdSlice := []string{tool, "-e", "MallocScribble=1", "-e", "MallocGuardEdges=1"}
	if e.Timeout > 0 {
		cmdSlice = append(cmdSlice, []string{"-t", strconv.Itoa(e.Timeout)}...)
	}
	cmdSlice = append(cmdSlice, "--")
	cmdSlice = append(cmdSlice, command...)
	cmdStr := strings.Join(cmdSlice, " ")

	cmd := exec.Command(cmdSlice[0], cmdSlice[1:]...)

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return crash.Info{}, fmt.Errorf("Error creating pipe: %s", err)
	}
	if err := cmd.Start(); err != nil {
		return crash.Info{}, fmt.Errorf("Error launching tool: %s", err)
	}

	out, _ := ioutil.ReadAll(stdout)
	cmd.Wait()

	return getCrashInfo(out, cmdStr)

}

示例#24
文件: server.go 项目: tartavull/govisual

// walk resolves the package import graph from p to its roots.
func walk(p string) *Package {
	pkgs := make(map[string]*Package)
	var f func(*Package, string) *Package
	f = func(parent *Package, p string) *Package {
		if pk, found := pkgs[p]; found {
			return pk
		}
		pk := Package{
			Name:   p,
			Parent: parent,
		}
		switch p {
		case "C", "unsafe", "runtime":
			// don't resolve dependencies, these
			// packages don't have any, or don't exist.
		default:
			pkg, err := build.Import(p, "", 0)
			if err != nil {
				log.Fatal(err)
			}
			for _, i := range pkg.Imports {
				pk.Children = append(pk.Children, f(&pk, i))
			}
		}
		pkgs[p] = &pk
		return &pk
	}
	return f(nil, p)
}

示例#25
文件: new.go 项目: huaguzi/revel

func setSkeletonPath(args []string) {
	var err error
	if len(args) == 2 { // user specified
		skeletonName := args[1]
		_, err = build.Import(skeletonName, "", build.FindOnly)
		if err != nil {
			// Execute "go get <pkg>"
			getCmd := exec.Command(gocmd, "get", "-d", skeletonName)
			fmt.Println("Exec:", getCmd.Args)
			getOutput, err := getCmd.CombinedOutput()

			// check getOutput for no buildible string
			bpos := bytes.Index(getOutput, []byte("no buildable Go source files in"))
			if err != nil && bpos == -1 {
				errorf("Abort: Could not find or 'go get' Skeleton  source code: %s\n%s\n", getOutput, skeletonName)
			}
		}
		// use the
		skeletonPath = filepath.Join(srcRoot, skeletonName)

	} else {
		// use the revel default
		skeletonPath = filepath.Join(revelPkg.Dir, "skeleton")
	}
}

示例#26
文件: build.go 项目: umisama/kocha

func (c *buildCommand) Package(importPath string) (*build.Package, error) {
	pkg, err := build.Import(importPath, "", build.FindOnly)
	if err != nil {
		return nil, err
	}
	return pkg, nil
}

示例#27
文件: server.go 项目: tartavull/govisual

func findImport(pkgs map[string][]Node, p string, size float64) {
	if p == "C" {
		return
	}
	//n := Node{Id:p, Label:p}
	if _, ok := pkgs[p]; ok {
		// seen this package before, skip it
		return
	}
	pkg, err := build.Import(p, "", 0)
	if err != nil {
		log.Fatal(err)
	}
	filter := func(imports []string) []Node {
		var n []Node
		for _, p := range imports {
			n = append(n, Node{Id: p, Label: p})
		}
		return n
	}
	pkgs[p] = filter(pkg.Imports)
	for _, pkg := range pkgs[p] {
		findImport(pkgs, pkg.Id, size/2)
	}
}

示例#28
文件: package.go 项目: hfeeki/resources-go

// OpenPackagePath returns a FSBundle which accesses files
// in the source directory of the package named by the given
// import path.
func OpenPackage(import_path string) (Bundle, error) {
	pkg, err := build.Import(import_path, "", build.FindOnly)
	if err != nil {
		return nil, err
	}
	return OpenFS(pkg.Dir), nil
}

示例#29
文件: fix.go 项目: Karthikvb/15640_projects

// importPathToNameGoPath finds out the actual package name, as declared in its .go files.
// If there's a problem, it falls back to using importPathToNameBasic.
func importPathToNameGoPath(importPath string) (packageName string) {
	if buildPkg, err := build.Import(importPath, "", 0); err == nil {
		return buildPkg.Name
	} else {
		return importPathToNameBasic(importPath)
	}
}

示例#30
文件: main.go 项目: chrisp-fb/rell

func pkgDir(path string) string {
	pkg, err := build.Import(path, "", build.FindOnly)
	if err != nil {
		return ""
	}
	return pkg.Dir
}

展开阅读全文