Golang Abs示例

说明

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

编程语言: Golang

命名空间/包名称: path/filepath

示例#1
文件: goplay_test.go 项目: JamesClonk/goplay

func TestCompileBinary(t *testing.T) {
	scriptFilename := "output.go"
	binaryFilename := "TestCompileBinary_output"
	if Exist(binaryFilename) {
		removeFile(t, binaryFilename)
	}

	scriptPath, err := filepath.Abs(scriptFilename)
	if err != nil {
		t.Fatal(err)
	}
	binaryPath, err := filepath.Abs(binaryFilename)
	if err != nil {
		t.Fatal(err)
	}

	CompileBinary(scriptPath, binaryPath, false)

	if !Exist(binaryFilename) {
		t.Fatalf("Compiled binary does not exist: [%s]", binaryFilename)
	}
	defer removeFile(t, binaryFilename)

	out, err := exec.Command("./" + binaryFilename).Output()
	if err != nil {
		t.Fatal(err)
	}
	expected(t, binaryFilename, string(out), "The night is all magic\n")
}

示例#2
文件: webtry.go 项目: Crawping/skia_custom

// doCmd executes the given command line string in either the out/Debug
// directory or the inout directory. Returns the stdout and stderr.
func doCmd(commandLine string, moveToDebug bool) (string, error) {
	log.Printf("Command: %q\n", commandLine)
	programAndArgs := strings.SplitN(commandLine, " ", 2)
	program := programAndArgs[0]
	args := []string{}
	if len(programAndArgs) > 1 {
		args = strings.Split(programAndArgs[1], " ")
	}
	cmd := exec.Command(program, args...)
	abs, err := filepath.Abs("../../out/Debug")
	if err != nil {
		return "", fmt.Errorf("Failed to find absolute path to Debug directory.")
	}
	if moveToDebug {
		cmd.Dir = abs
	} else if !*useChroot { // Don't set cmd.Dir when using chroot.
		abs, err := filepath.Abs("../../../inout")
		if err != nil {
			return "", fmt.Errorf("Failed to find absolute path to inout directory.")
		}
		cmd.Dir = abs
	}
	log.Printf("Run in directory: %q\n", cmd.Dir)
	message, err := cmd.CombinedOutput()
	log.Printf("StdOut + StdErr: %s\n", string(message))
	if err != nil {
		log.Printf("Exit status: %s\n", err.Error())
		return string(message), fmt.Errorf("Failed to run command.")
	}
	return string(message), nil
}

示例#3
文件: writers_filewriter_test.go 项目: haowang1013/seelog

func (this *fileWriterTester) checkRequiredFilesExist(testCase *fileWriterTestCase, files []string) {
	var found bool
	for _, expected := range testCase.resFiles {
		found = false
		exAbs, err := filepath.Abs(expected)
		if err != nil {
			this.t.Errorf("filepath.Abs failed for %s", expected)
			continue
		}

		for _, f := range files {
			if af, e := filepath.Abs(f); e == nil {
				this.t.Log(af)
				if exAbs == af {
					found = true
					break
				}
			} else {
				this.t.Errorf("filepath.Abs failed for %s", f)
			}
		}

		if !found {
			this.t.Errorf("Expected file: %s doesn't exist. Got %v\n", exAbs, files)
		}
	}
}

示例#4
文件: pod.go 项目: HimanshPal/cnt

func NewPod(path string, args BuildArgs) (*Pod, error) {
	fullPath, err := filepath.Abs(path)
	if err != nil {
		logs.WithE(err).WithField("path", path).Fatal("Cannot get fullpath")
	}

	manifest, err := readPodManifest(fullPath + POD_MANIFEST)
	if err != nil {
		return nil, errors.Annotate(err, "Failed to read pod manifest")
	}
	fields := data.WithField("pod", manifest.Name.String())

	target := path + PATH_TARGET
	if cnt.Home.Config.TargetWorkDir != "" {
		currentAbsDir, err := filepath.Abs(cnt.Home.Config.TargetWorkDir + "/" + manifest.Name.ShortName())
		if err != nil {
			logs.WithEF(err, fields).Panic("invalid target path")
		}
		target = currentAbsDir
	}

	pod := &Pod{
		fields:   fields,
		path:     fullPath,
		args:     args,
		target:   target,
		manifest: *manifest,
	}

	return pod, nil
}

示例#5

func TestEnvOverride(t *testing.T) {
	cgifile, _ := filepath.Abs("testdata/test.cgi")

	var perl string
	var err error
	perl, err = exec.LookPath("perl")
	if err != nil {
		return
	}
	perl, _ = filepath.Abs(perl)

	cwd, _ := os.Getwd()
	h := &Handler{
		Path: perl,
		Root: "/test.cgi",
		Dir:  cwd,
		Args: []string{cgifile},
		Env: []string{
			"SCRIPT_FILENAME=" + cgifile,
			"REQUEST_URI=/foo/bar"},
	}
	expectedMap := map[string]string{
		"cwd": cwd,
		"env-SCRIPT_FILENAME": cgifile,
		"env-REQUEST_URI":     "/foo/bar",
	}
	runCgiTest(t, h, "GET /test.cgi HTTP/1.0\nHost: example.com\n\n", expectedMap)
}

示例#6
文件: local.go 项目: wernight/rclone

func (f *Fs) filterPath(s string) string {
	s = filepath.Clean(s)
	if runtime.GOOS == "windows" {
		s = strings.Replace(s, `/`, `\`, -1)

		if !filepath.IsAbs(s) && !strings.HasPrefix(s, "\\") {
			s2, err := filepath.Abs(s)
			if err == nil {
				s = s2
			}
		}

		if f.nounc {
			return s
		}
		// Convert to UNC
		return uncPath(s)
	}

	if !filepath.IsAbs(s) {
		s2, err := filepath.Abs(s)
		if err == nil {
			s = s2
		}
	}

	return s
}

示例#7
文件: conf.go 项目: zhanghjster/ChatChat

func LoadConfigure() *Configure {

	dir := "conf"
	absDir := "."
	if _, err := os.Stat("../" + dir + "/"); err == nil {
		absDir, _ = filepath.Abs("../" + dir + "/")
	} else if _, err := os.Stat("../../" + dir + "/"); err == nil {
		absDir, _ = filepath.Abs("../../" + dir + "/")
	} else {
		absDir = binDir() + "/../" + dir
	}

	var file = absDir + "/../conf/server.cfg"
	var default_file = absDir + "/../conf/server_default.cfg"

	if _, err := os.Stat(file); err != nil {
		file = default_file
	}

	var config = Configure{}

	if _, err := toml.DecodeFile(file, &config); err != nil {
		panic(err)
	}

	fmt.Print(config)

	return &config
}

示例#8
文件: main.go 项目: alimy/caddydev

// pkgFromDir extracts package import path from dir. dir can be a path on file system
// or go get path.
func pkgFromDir(dir string) string {
	gopaths := strings.Split(os.Getenv("GOPATH"), string(filepath.ListSeparator))

	// if directory exits, infer import path from dir relative to GOPATH.
	if stat, err := os.Stat(dir); err == nil && stat.IsDir() {
		for _, gopath := range gopaths {
			absgopath, _ := filepath.Abs(gopath)
			gosrc := filepath.Join(absgopath, "src") + string(filepath.Separator)
			absdir, _ := filepath.Abs(dir)
			if strings.HasPrefix(absdir, gosrc) {
				return strings.TrimPrefix(absdir, gosrc)
			}
		}

		// not in GOPATH, create symlink to fake GOPATH.
		if newpath, err := symlinkGOPATH(dir); err == nil {
			return filepath.Base(newpath)
		}
	}

	if isLocalPkg(dir) {
		return dir
	}

	return ""
}

示例#9
文件: goversioninfo_test.go 项目: tommale/goversioninfo

func testFile(t *testing.T, filename string) {
	path, _ := filepath.Abs("./tests/" + filename + ".json")

	jsonBytes, err := ioutil.ReadFile(path)
	if err != nil {
		t.Error("Could not load "+filename+".json", err)
	}

	// Create a new container
	vi := &VersionInfo{}

	// Parse the config
	if err := vi.ParseJSON(jsonBytes); err != nil {
		t.Error("Could not parse "+filename+".json", err)
	}
	// Fill the structures with config data
	vi.Build()

	// Write the data to a buffer
	vi.Walk()

	path2, _ := filepath.Abs("./tests/" + filename + ".hex")

	expected, err := ioutil.ReadFile(path2)
	if err != nil {
		t.Error("Could not load "+filename+".hex", err)
	}

	if !bytes.Equal(vi.Buffer.Bytes(), expected) {
		t.Error("Data does not match " + filename + ".hex")
	}
}

示例#10
文件: what.go 项目: tintohill/pythia

// guessImportPath finds the package containing filename, and returns
// its source directory (an element of $GOPATH) and its import path
// relative to it.
//
// TODO(adonovan): what about _test.go files that are not part of the
// package?
//
func guessImportPath(filename string, buildContext *build.Context) (srcdir, importPath string, err error) {
	absFile, err := filepath.Abs(filename)
	if err != nil {
		err = fmt.Errorf("can't form absolute path of %s", filename)
		return
	}
	absFileDir := segments(filepath.Dir(absFile))

	// Find the innermost directory in $GOPATH that encloses filename.
	minD := 1024
	for _, gopathDir := range buildContext.SrcDirs() {
		absDir, err := filepath.Abs(gopathDir)
		if err != nil {
			continue // e.g. non-existent dir on $GOPATH
		}
		d := prefixLen(segments(absDir), absFileDir)
		// If there are multiple matches,
		// prefer the innermost enclosing directory
		// (smallest d).
		if d >= 0 && d < minD {
			minD = d
			srcdir = gopathDir
			importPath = strings.Join(absFileDir[len(absFileDir)-minD:], string(os.PathSeparator))
		}
	}
	if srcdir == "" {
		err = fmt.Errorf("can't find package for file %s", filename)
	}
	return
}

示例#11
文件: service.go 项目: SimiPro/go-cloudinary

// cleanAssetName returns an asset name from the parent dirname and
// the file name without extension.
// The combination
//   path=/tmp/css/default.css
//   basePath=/tmp/
//   prependPath=new/
// will return
//   new/css/default
func cleanAssetName(path, basePath, prependPath string) string {
	var name string
	path, basePath, prependPath = strings.TrimSpace(path), strings.TrimSpace(basePath), strings.TrimSpace(prependPath)
	basePath, err := filepath.Abs(basePath)
	if err != nil {
		basePath = ""
	}
	apath, err := filepath.Abs(path)
	if err == nil {
		path = apath
	}
	if basePath == "" {
		idx := strings.LastIndex(path, string(os.PathSeparator))
		if idx != -1 {
			idx = strings.LastIndex(path[:idx], string(os.PathSeparator))
		}
		name = path[idx+1:]
	} else {
		// Directory
		name = strings.Replace(path, basePath, "", 1)
		if name[0] == os.PathSeparator {
			name = name[1:]
		}
	}
	if prependPath != "" {
		if prependPath[0] == os.PathSeparator {
			prependPath = prependPath[1:]
		}
		prependPath = EnsureTrailingSlash(prependPath)
	}
	return prependPath + name[:len(name)-len(filepath.Ext(name))]
}

示例#12
文件: rm_end_space.go 项目: soarpenguin/go-scripts

func main() {

	if flag.NArg() == 0 {
		fmt.Printf("[Error] path or file must provide one.\n\n")
		flag.Usage()
		os.Exit(retFail)
	}

	for i := 0; i < flag.NArg(); i++ {
		path := strings.TrimSpace(flag.Arg(i))
		switch dir, err := os.Stat(path); {
		case err != nil:
			//fmt.Printf("[Error] error in Stat(): %s.\n", err)
			panic(err)
		case dir.IsDir():
			if path, err = filepath.Abs(path); err != nil {
				panic(err)
			}
			dealDirWithWhiteList(path, cmd, suffixArray)
		default:
			if path, err = filepath.Abs(path); err != nil {
				panic(err)
			}
			dealFileWithWhiteList(path, cmd, suffixArray)
		}
	}
}

示例#13
文件: sync.go 项目: traherom/syncer

// LoadSync loads the sync based on the settings found in localPath
func LoadSync(localPath string) (*SyncInfo, error) {
	// Only open pre-existing syncs. sql.Open would indiscrimately create an
	// empty database if we didn't check this in advance
	dbPath := filepath.Join(localPath, settingsDir, dbFileName)
	if _, err := os.Stat(dbPath); os.IsNotExist(err) {
		return nil, &ErrSync{fmt.Sprintf("'%v' does not appear to be a valid sync: no settings directory found", localPath), err}
	}

	db, err := sql.Open("sqlite3", dbPath)
	if err != nil {
		return nil, err
	}

	// Load remainder of settings
	sync := new(SyncInfo)
	sync.db = db
	sync.changesReady = make(chan bool)

	if sync.localBase, err = filepath.Abs(localPath); err != nil {
		return nil, &ErrSync{"Unable to get absolute local path", err}
	}

	if sync.remoteBase, err = sync.Get(remotePathKey); err != nil {
		return nil, &ErrSync{"Remote path not set", err}
	}
	if sync.remoteBase, err = filepath.Abs(filepath.FromSlash(sync.remoteBase)); err != nil {
		return nil, &ErrSync{"Unable to get absolute remote path", err}
	}

	cKeyStr, err := sync.Get(cryptoKeyKey)
	if err != nil {
		return nil, &ErrSync{"Encryption key not set", err}
	}

	aKeyStr, err := sync.Get(authKeyKey)
	if err != nil {
		return nil, &ErrSync{"Authentication key not set", err}
	}

	cKey, err := gocrypt.KeyFromString(cKeyStr)
	if err != nil {
		return nil, &ErrSync{"Failed to convert encryption key", err}
	}
	aKey, err := gocrypt.KeyFromString(aKeyStr)
	if err != nil {
		return nil, &ErrSync{"Failed to convert authentication key", err}
	}

	sync.keys = &gocrypt.KeyCombo{CryptoKey: cKey, AuthKey: aKey}

	// Make sure everything loaded correctly
	if err = sync.sanityCheckConfig(); err != nil {
		return nil, err
	}

	log.Println("Cleaning sync")
	sync.Clean()

	return sync, nil
}

示例#14
文件: goplay_test.go 项目: JamesClonk/goplay

func TestCompleteBuild(t *testing.T) {
	scriptFilename := "build/builder.go"
	binaryFilename := "build/TestCompleteBuildBinary_builder"
	if Exist(binaryFilename) {
		removeFile(t, binaryFilename)
	}

	out, err := exec.Command("./" + scriptFilename).Output()
	if err != nil {
		t.Fatal(err)
	}
	expected(t, "build/builder.go", string(out), "Build!\n")

	scriptPath, err := filepath.Abs(scriptFilename)
	if err != nil {
		t.Fatal(err)
	}
	binaryPath, err := filepath.Abs(binaryFilename)
	if err != nil {
		t.Fatal(err)
	}

	CompileBinary(scriptPath, binaryPath, true)

	if !Exist(binaryFilename) {
		t.Fatalf("Compiled binary does not exist: [%s]", binaryFilename)
	}
	defer removeFile(t, binaryFilename)

	out, err = exec.Command("./" + binaryFilename).Output()
	if err != nil {
		t.Fatal(err)
	}
	expected(t, "build/builder.go", string(out), "Build!\n")
}

示例#15
文件: service_loadbalancer_test.go 项目: rwehner/contrib

func TestNewStaticPageHandler(t *testing.T) {
	defPagePath, _ := filepath.Abs("haproxy.cfg")
	defErrorPath, _ := filepath.Abs("template.cfg")
	defErrURL := "http://www.k8s.io"

	testDefPage := "file://" + defPagePath
	testErrorPage := "file://" + defErrorPath

	handler := newStaticPageHandler("", testDefPage)
	if handler == nil {
		t.Fatalf("Expected page handler")
	}

	handler = newStaticPageHandler(testErrorPage, testDefPage)
	if handler.pagePath != testErrorPage {
		t.Fatalf("Expected local file content but got default page")
	}

	handler = newStaticPageHandler(defErrURL, testDefPage)
	if handler.pagePath != defErrURL {
		t.Fatalf("Expected remote error page content but got default page")
	}

	handler = newStaticPageHandler(defErrURL+"s", testDefPage)
	if handler.pagePath != testDefPage {
		t.Fatalf("Expected local file content with not valid URL")
	}
}

示例#16
文件: git.go 项目: unitychrism/git-lfs

func GitAndRootDirs() (string, string, error) {
	cmd := execCommand("git", "rev-parse", "--git-dir", "--show-toplevel")
	buf := &bytes.Buffer{}
	cmd.Stderr = buf

	out, err := cmd.Output()
	output := string(out)
	if err != nil {
		return "", "", fmt.Errorf("Failed to call git rev-parse --git-dir --show-toplevel: %q", buf.String())
	}

	paths := strings.Split(output, "\n")
	pathLen := len(paths)

	if pathLen == 0 {
		return "", "", fmt.Errorf("Bad git rev-parse output: %q", output)
	}

	absGitDir, err := filepath.Abs(paths[0])
	if err != nil {
		return "", "", fmt.Errorf("Error converting %q to absolute: %s", paths[0], err)
	}

	if pathLen == 1 || len(paths[1]) == 0 {
		return absGitDir, "", nil
	}

	absRootDir, err := filepath.Abs(paths[1])
	if err != nil {
		return "", "", fmt.Errorf("Error converting %q to absolute: %s", paths[1], err)
	}

	return absGitDir, absRootDir, nil
}

示例#17
文件: path.go 项目: peer23peer/TMSU

func RelTo(path, to string) string {
	var err error

	path, err = filepath.Abs(path)
	if err != nil {
		panic("could not get absolute path")
	}

	to, err = filepath.Abs(to)
	if err != nil {
		panic("could not get absolute path")
	}

	if path == to {
		return "."
	}

	prefix := trailingSeparator(to)
	if strings.HasPrefix(path, prefix) {
		// can't use filepath.Join as it strips the leading './'
		return "." + string(filepath.Separator) + path[len(prefix):]
	}

	to = filepath.Dir(to)
	prefix = trailingSeparator(to)
	if strings.HasPrefix(path, prefix) {
		// can't use filepath.Join as it strips the leading './'
		return ".." + string(filepath.Separator) + path[len(prefix):]
	}

	return path
}

示例#18
文件: conf.go 项目: mymch/configure

func (c *Conf) include(parentConfPath string) {
	includeFileNames := c.getIncludeFileNames()
	for _, includeFileName := range includeFileNames {
		if !filepath.IsAbs(includeFileName) {
			confPath := func() string {
				parentConfPath, err := filepath.Abs(parentConfPath)
				if err != nil {
					return ""
				}
				splitPath := strings.Split(parentConfPath, "/")
				return "/" + strings.Join(splitPath[:len(splitPath)-1], "/")
			}()
			var err error
			includeFileName, err = filepath.Abs(confPath + "/" + includeFileName)
			if err != nil {
				continue
			}
		}
		var err error
		c.loopDetector, err = loopDetection(includeFileName, c.loopDetector)
		if err != nil {
			return
		}

		childConf := NewConf(includeFileName)
		if childConf == nil {
			continue
		}
		childKeys := childConf.GetKeys()
		for _, childKey := range childKeys {
			c.Set(childKey, childConf.Get(childKey))
		}
	}
}

示例#19
文件: context.go 项目: jbowtie/ratago

func (context *ExecutionContext) FetchInputDocument(loc string, relativeToSource bool) (doc *xml.XmlDocument) {
	//create the map if needed
	if context.InputDocuments == nil {
		context.InputDocuments = make(map[string]*xml.XmlDocument)
	}

	// rely on caller to tell us how to resolve relative paths
	base := ""
	if relativeToSource {
		base, _ = filepath.Abs(filepath.Dir(context.Source.Uri()))
	} else {
		base, _ = filepath.Abs(filepath.Dir(context.Style.Doc.Uri()))
	}
	resolvedLoc := filepath.Join(base, loc)

	//if abspath in map return existing document
	doc, ok := context.InputDocuments[resolvedLoc]
	if ok {
		return
	}

	//else load the document and add to map
	doc, e := xml.ReadFile(resolvedLoc, xml.StrictParseOption)
	if e != nil {
		fmt.Println(e)
		return
	}
	context.InputDocuments[resolvedLoc] = doc
	return
}

示例#20
文件: e2e_build.go 项目: CsatariGergely/kubernetes

func getK8sBin(bin string) (string, error) {
	// Use commandline specified path
	if *k8sBinDir != "" {
		absPath, err := filepath.Abs(*k8sBinDir)
		if err != nil {
			return "", err
		}
		if _, err := os.Stat(filepath.Join(*k8sBinDir, bin)); err != nil {
			return "", fmt.Errorf("Could not find kube-apiserver under directory %s.", absPath)
		}
		return filepath.Join(absPath, bin), nil
	}

	path, err := filepath.Abs(filepath.Dir(os.Args[0]))
	if err != nil {
		return "", fmt.Errorf("Could not find absolute path of directory containing the tests %s.", filepath.Dir(os.Args[0]))
	}
	if _, err := os.Stat(filepath.Join(path, bin)); err == nil {
		return filepath.Join(path, bin), nil
	}

	buildOutputDir, err := getK8sBuildOutputDir()
	if err != nil {
		return "", err
	}
	if _, err := os.Stat(filepath.Join(buildOutputDir, bin)); err == nil {
		return filepath.Join(buildOutputDir, bin), nil
	}

	// Give up with error
	return "", fmt.Errorf("Unable to locate %s.  Can be defined using --k8s-path.", bin)
}

示例#21
文件: utils.go 项目: THEY/godo

// PackageName determines the package name from sourceFile if it is within $GOPATH
func PackageName(sourceFile string) (string, error) {
	if filepath.Ext(sourceFile) != ".go" {
		return "", errors.New("sourcefile must end with .go")
	}
	sourceFile, err := filepath.Abs(sourceFile)
	if err != nil {
		Panic("util", "Could not convert to absolute path: %s", sourceFile)
	}

	gopath := os.Getenv("GOPATH")
	if gopath == "" {
		return "", errors.New("Environment variable GOPATH is not set")
	}
	paths := strings.Split(gopath, string(os.PathListSeparator))
	for _, path := range paths {
		srcDir := filepath.Join(path, "src")
		srcDir, err := filepath.Abs(srcDir)
		if err != nil {
			continue
		}

		//log.Printf("srcDir %s sourceFile %s\n", srcDir, sourceFile)
		rel, err := filepath.Rel(srcDir, sourceFile)
		if err != nil {
			continue
		}
		return filepath.Dir(rel), nil
	}
	return "", errors.New("sourceFile not reachable from GOPATH")
}

示例#22
文件: edit_test.go 项目: JoshuaSchnell/helm

func TestJoinChart(t *testing.T) {

	chartDir, _ := filepath.Abs("../testdata/charts/redis")

	// prepare files fixture
	var files []string
	paths := []string{
		"../testdata/charts/redis/Chart.yaml",
		"../testdata/charts/redis/manifests/redis-pod.yaml",
	}
	for _, f := range paths {
		abspath, _ := filepath.Abs(f)
		files = append(files, abspath)
	}

	bytes, err := joinChart(chartDir, files)
	if err != nil {
		t.Fatalf("failed to join chart: %v", bytes)
	}

	if bytes.Len() < 1 {
		t.Fatalf("empty chart after join: %v", bytes)
	}

}

示例#23
文件: paths.go 项目: kokomo88/bitrise-cli

func initBitriseWorkPaths() error {
	bitriseWorkDirPath, err := filepath.Abs("./.bitrise")
	if err != nil {
		return err
	}
	if exist, err := pathutil.IsPathExists(bitriseWorkDirPath); err != nil {
		return err
	} else if !exist {
		if err := os.MkdirAll(bitriseWorkDirPath, 0777); err != nil {
			return err
		}
	}
	BitriseWorkDirPath = bitriseWorkDirPath

	bitriseWorkStepsDirPath, err := filepath.Abs(path.Join(BitriseWorkDirPath, "step_src"))
	if err != nil {
		return err
	}
	if exist, err := pathutil.IsPathExists(bitriseWorkStepsDirPath); err != nil {
		return err
	} else if !exist {
		if err := os.MkdirAll(bitriseWorkStepsDirPath, 0777); err != nil {
			return err
		}
	}
	BitriseWorkStepsDirPath = bitriseWorkStepsDirPath

	return nil
}

示例#24
文件: phantom.go 项目: huih/pholcus

func (self *Phantom) setFile(js string) (string, error) {
	self.Mutex.Lock()
	defer self.Mutex.Unlock()
	jshash := util.MakeHash(js)
	fullFileName := self.FullTempJsFilePrefix + jshash
	if self.FullTempJsFiles[fullFileName] {
		return fullFileName, nil
	}
	if !filepath.IsAbs(fullFileName) {
		fullFileName, _ = filepath.Abs(fullFileName)
	}
	if !filepath.IsAbs(self.FullPhantomjsName) {
		self.FullPhantomjsName, _ = filepath.Abs(self.FullPhantomjsName)
	}

	// 创建/打开目录
	p, _ := filepath.Split(fullFileName)
	d, err := os.Stat(p)
	if err != nil || !d.IsDir() {
		if err := os.MkdirAll(p, 0777); err != nil {
			return "", err
		}
	}

	// 创建并写入文件
	f, _ := os.Create(fullFileName)
	f.Write([]byte(js))
	f.Close()
	self.FullTempJsFiles[fullFileName] = true
	return fullFileName, nil
}

示例#25
文件: main.go 项目: optimuse/goldi

func main() {
	defer panicHandler()
	app.Version(Version)

	kingpin.MustParse(app.Parse(os.Args[1:]))

	inputPath, _ := filepath.Abs((*inputFile).Name())
	if *outputPath != "" {
		*outputPath, _ = filepath.Abs(*outputPath)
	}

	outputPackageName := determineOutputPackageName()
	config := NewConfig(outputPackageName, *functionName, inputPath, *outputPath)
	gen := New(config)
	output := &bytes.Buffer{}

	if *verbose {
		gen.Debug = true
	}

	logVerboseGeneratorConfig(inputPath, outputPackageName)
	err := gen.Generate(*inputFile, output)
	if err != nil {
		log(err.Error())
		os.Exit(1)
	}

	if *outputPath == "" || *forceStdOut {
		logVerbose("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
		fmt.Println(output.String())
		return
	}

	writeOutputFile(output)
}

示例#26
文件: snapshot_writer.go 项目: ThiruKumar/go_ws

// appendShardSnapshotFiles adds snapshot files for each shard in the store.
func appendShardSnapshotFiles(sw *snapshot.Writer, store *Store) error {
	// Calculate absolute path of store to use for relative shard paths.
	storePath, err := filepath.Abs(store.Path())
	if err != nil {
		return fmt.Errorf("store abs path: %s", err)
	}

	// Create files for each shard.
	for _, shardID := range store.ShardIDs() {
		// Retrieve shard.
		sh := store.Shard(shardID)
		if sh == nil {
			return fmt.Errorf("shard not found: %d", shardID)
		}

		// Calculate relative path from store.
		shardPath, err := filepath.Abs(sh.Path())
		if err != nil {
			return fmt.Errorf("shard abs path: %s", err)
		}
		name, err := filepath.Rel(storePath, shardPath)
		if err != nil {
			return fmt.Errorf("shard rel path: %s", err)
		}

		if err := appendShardSnapshotFile(sw, sh, name); err != nil {
			return fmt.Errorf("append shard: name=%s, err=%s", name, err)
		}
	}

	return nil
}

示例#27
文件: local.go 项目: pombredanne/rclone

// filterPath cleans and makes absolute the path passed in.
//
// On windows it makes the path UNC also.
func (f *Fs) filterPath(s string) string {
	s = filterFragment(s)
	if runtime.GOOS == "windows" {
		if !filepath.IsAbs(s) && !strings.HasPrefix(s, "\\") {
			s2, err := filepath.Abs(s)
			if err == nil {
				s = s2
			}
		}

		if f.nounc {
			return s
		}
		// Convert to UNC
		return uncPath(s)
	}

	if !filepath.IsAbs(s) {
		s2, err := filepath.Abs(s)
		if err == nil {
			s = s2
		}
	}

	return s
}

示例#28
文件: gonative.go 项目: geoko86/gonative

// runs dist bootrap to build the compilers for a target platform
func distBootstrap(goRoot string, p Platform) (err error) {
	// the dist tool gets put in the pkg/tool/{host_platform} directory after we've built
	// the compilers/stdlib for the host platform
	hostPlatform := Platform{runtime.GOOS, runtime.GOARCH}
	scriptPath, err := filepath.Abs(filepath.Join(goRoot, "pkg", "tool", hostPlatform.String(), "dist"))
	if err != nil {
		return
	}

	// but we want to run it from the src directory
	scriptDir, err := filepath.Abs(filepath.Join(goRoot, "src"))
	if err != nil {
		return
	}

	bootstrapCmd := exec.Cmd{
		Path: scriptPath,
		Args: []string{scriptPath, "bootstrap", "-v"},
		Env: append(os.Environ(),
			"GOOS="+p.OS,
			"GOARCH="+p.Arch),
		Dir:    scriptDir,
		Stdout: os.Stdout,
		Stderr: os.Stderr,
	}

	return bootstrapCmd.Run()
}

示例#29
文件: loader.go 项目: Clarifai/kubernetes

// ResolveLocalPaths resolves all relative paths in the config object with respect to the stanza's LocationOfOrigin
// this cannot be done directly inside of LoadFromFile because doing so there would make it impossible to load a file without
// modification of its contents.
func ResolveLocalPaths(config *clientcmdapi.Config) error {
	for _, cluster := range config.Clusters {
		if len(cluster.LocationOfOrigin) == 0 {
			continue
		}
		base, err := filepath.Abs(filepath.Dir(cluster.LocationOfOrigin))
		if err != nil {
			return fmt.Errorf("Could not determine the absolute path of config file %s: %v", cluster.LocationOfOrigin, err)
		}

		if err := ResolvePaths(GetClusterFileReferences(cluster), base); err != nil {
			return err
		}
	}
	for _, authInfo := range config.AuthInfos {
		if len(authInfo.LocationOfOrigin) == 0 {
			continue
		}
		base, err := filepath.Abs(filepath.Dir(authInfo.LocationOfOrigin))
		if err != nil {
			return fmt.Errorf("Could not determine the absolute path of config file %s: %v", authInfo.LocationOfOrigin, err)
		}

		if err := ResolvePaths(GetAuthInfoFileReferences(authInfo), base); err != nil {
			return err
		}
	}

	return nil
}

示例#30
文件: main.go 项目: dmcgowan/dockerdevtools

func main() {
	flag.Parse()

	args := flag.Args()
	if len(args) < 2 {
		logrus.Fatal("Expecting source and target directory")
	}

	targetDir, err := filepath.Abs(args[len(args)-1])
	if err != nil {
		logrus.Fatal("Error resolving target directory %s: %v", args[len(args)-1], err)
	}
	targetDir = filepath.Clean(targetDir)

	for _, bundleDir := range args[:len(args)-1] {
		absDir, err := filepath.Abs(bundleDir)
		if err != nil {
			logrus.Fatalf("Error resolving directory %s: %v", bundleDir, err)
		}
		bundleDir = filepath.Clean(absDir)
		logrus.Infof("Copying %s to %s", bundleDir, targetDir)
		if err := buildutil.CopyBundleBinaries(bundleDir, targetDir); err != nil {
			logrus.Fatalf("Error copying binaries: %v", err)
		}
	}
}

展开阅读全文