// RemovePackage removes the specified folder files. If folder is empty when
// done (no nested folders, remove the folder and any empty parent folders.
func RemovePackage(path, root string) error {
// Ensure the path is empty of files.
dir, err := os.Open(path)
if err != nil {
return err
}
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return err
}
for _, fi := range fl {
if fi.IsDir() {
continue
}
err = os.Remove(filepath.Join(path, fi.Name()))
if err != nil {
return err
}
}
// Ignore errors here.
for i := 0; i <= looplimit; i++ {
if pathos.FileStringEquals(path, root) {
return nil
}
dir, err := os.Open(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to open directory %q: %v\n", path, err)
return nil
}
fl, err := dir.Readdir(1)
dir.Close()
if err != nil && err != io.EOF {
// fmt.Fprintf(os.Stderr, "Failedd to list directory %q: %v\n", path, err)
return nil
}
if len(fl) > 0 {
return nil
}
err = os.Remove(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to remove empty directory %q: %v\n", path, err)
return nil
}
nextPath := filepath.Clean(filepath.Join(path, ".."))
// Check for root.
if nextPath == path {
return nil
}
path = nextPath
}
panic("removePackage() remove parent folders")
}
func copyFile(destPath, srcPath string) error {
ss, err := os.Stat(srcPath)
if err != nil {
return err
}
src, err := os.Open(srcPath)
if err != nil {
return err
}
defer src.Close()
dest, err := os.Create(destPath)
if err != nil {
return err
}
_, err = io.Copy(dest, src)
// Close before setting mod and time.
dest.Close()
if err != nil {
return err
}
err = os.Chmod(destPath, ss.Mode())
if err != nil {
return err
}
return os.Chtimes(destPath, ss.ModTime(), ss.ModTime())
}
func (ctx *Context) getIngoreFiles(src string) ([]string, error) {
var ignoreFile []string
srcDir, err := os.Open(src)
if err != nil {
return nil, err
}
fl, err := srcDir.Readdir(-1)
srcDir.Close()
if err != nil {
return nil, err
}
for _, fi := range fl {
if fi.IsDir() {
continue
}
if fi.Name()[0] == '.' {
continue
}
tags, err := ctx.getFileTags(filepath.Join(src, fi.Name()), nil)
if err != nil {
return nil, err
}
for _, tag := range tags {
for _, ignore := range ctx.ignoreTag {
if tag == ignore {
ignoreFile = append(ignoreFile, fi.Name())
}
}
}
}
return ignoreFile, nil
}
// readDirNames reads the directory named by dirname and returns
// a sorted list of directory entries.
func readDirNames(dirname string) ([]string, error) {
f, err := os.Open(dirname)
if err != nil {
return nil, err
}
names, err := f.Readdirnames(-1)
f.Close()
if err != nil {
return nil, err
}
sort.Strings(names)
return names, nil
}
func (ctx *Context) addSingleImport(pkgInDir, imp string) error {
if _, found := ctx.Package[imp]; found {
return nil
}
// Also need to check for vendor paths that won't use the local path in import path.
for _, pkg := range ctx.Package {
if pkg.Canonical == imp && pkg.inVendor && pathos.FileHasPrefix(pkg.Dir, pkgInDir) {
return nil
}
}
dir, gopath, err := ctx.findImportDir(pkgInDir, imp)
if err != nil {
if _, is := err.(ErrNotInGOPATH); is {
ctx.setPackage("", imp, imp, "", StatusMissing)
return nil
}
return err
}
if pathos.FileStringEquals(gopath, ctx.Goroot) {
ctx.setPackage(dir, imp, imp, ctx.Goroot, StatusStandard)
return nil
}
df, err := os.Open(dir)
if err != nil {
return err
}
info, err := df.Readdir(-1)
df.Close()
if err != nil {
return err
}
for _, fi := range info {
if fi.IsDir() {
continue
}
switch fi.Name()[0] {
case '.', '_':
continue
}
if pathos.FileStringEquals(dir, pkgInDir) {
continue
}
path := filepath.Join(dir, fi.Name())
err = ctx.addFileImports(path, gopath)
if err != nil {
return err
}
}
return nil
}
func readVendorFile(vendorFilePath string) (*vendorfile.File, error) {
vf := &vendorfile.File{}
f, err := os.Open(vendorFilePath)
if err != nil {
return nil, err
}
defer f.Close()
err = vf.Unmarshal(f)
if err != nil {
return nil, err
}
return vf, nil
}
func hasGoFileInFolder(folder string) (bool, error) {
dir, err := os.Open(folder)
if err != nil {
if os.IsNotExist(err) {
// No folder present, no need to check for files.
return false, nil
}
return false, err
}
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return false, err
}
for _, fi := range fl {
if fi.IsDir() == false && filepath.Ext(fi.Name()) == ".go" {
return true, nil
}
}
return false, nil
}
// CopyPackage copies the files from the srcPath to the destPath, destPath
// folder and parents are are created if they don't already exist.
func (ctx *Context) CopyPackage(destPath, srcPath string, ignoreFiles []string, tree bool) error {
if pathos.FileStringEquals(destPath, srcPath) {
return fmt.Errorf("Attempting to copy package to same location %q.", destPath)
}
err := os.MkdirAll(destPath, 0777)
if err != nil {
return err
}
// Ensure the dest is empty of files.
destDir, err := os.Open(destPath)
if err != nil {
return err
}
ignoreTest := false
if tree {
for _, ignore := range ctx.ignoreTag {
if ignore == "test" {
ignoreTest = true
break
}
}
}
fl, err := destDir.Readdir(-1)
destDir.Close()
if err != nil {
return err
}
for _, fi := range fl {
if fi.IsDir() {
if tree {
err = os.RemoveAll(filepath.Join(destPath, fi.Name()))
if err != nil {
return err
}
}
continue
}
err = os.Remove(filepath.Join(destPath, fi.Name()))
if err != nil {
return err
}
}
// Copy files into dest.
srcDir, err := os.Open(srcPath)
if err != nil {
return err
}
fl, err = srcDir.Readdir(-1)
srcDir.Close()
if err != nil {
return err
}
fileLoop:
for _, fi := range fl {
name := fi.Name()
if name[0] == '.' {
continue
}
if fi.IsDir() {
if !tree {
continue
}
if name[0] == '_' {
continue
}
if ignoreTest {
if strings.HasSuffix(name, "_test") || name == "testdata" {
continue
}
}
nextDestPath := filepath.Join(destPath, name)
nextSrcPath := filepath.Join(srcPath, name)
nextIgnoreFiles, err := ctx.getIngoreFiles(nextSrcPath)
if err != nil {
return err
}
err = ctx.CopyPackage(nextDestPath, nextSrcPath, nextIgnoreFiles, true)
if err != nil {
return err
}
continue
}
for _, ignore := range ignoreFiles {
if pathos.FileStringEquals(name, ignore) {
continue fileLoop
}
}
err = copyFile(
filepath.Join(destPath, name),
filepath.Join(srcPath, name),
)
if err != nil {
return err
}
}
return nil
}
func (ctx *Context) modifyAdd(pkg *Package) error {
var err error
src := pkg.Dir
dprintf("found import: %q\n", src)
// If the canonical package is also the local package, then the package
// isn't copied locally already and has already been checked for tags.
// If it has been vendored the source still needs to be examined.
// Examine here and add to the operations list.
var ignoreFile []string
if cpkg, found := ctx.Package[pkg.Canonical]; found {
ignoreFile = cpkg.ignoreFile
} else {
srcDir, err := os.Open(src)
if err != nil {
return err
}
fl, err := srcDir.Readdir(-1)
srcDir.Close()
if err != nil {
return err
}
for _, fi := range fl {
if fi.IsDir() {
continue
}
if fi.Name()[0] == '.' {
continue
}
tags, err := ctx.getFileTags(filepath.Join(src, fi.Name()), nil)
if err != nil {
return err
}
for _, tag := range tags {
for _, ignore := range ctx.ignoreTag {
if tag == ignore {
ignoreFile = append(ignoreFile, fi.Name())
}
}
}
}
}
dest := filepath.Join(ctx.RootDir, ctx.VendorFolder, pathos.SlashToFilepath(pkg.Canonical))
// TODO: This might cause other issues or might be hiding the underlying issues. Examine in depth later.
if pathos.FileStringEquals(src, dest) {
return nil
}
ctx.Operation = append(ctx.Operation, &Operation{
Pkg: pkg,
Src: src,
Dest: dest,
IgnoreFile: ignoreFile,
})
// Update vendor file with correct Local field.
vp := ctx.VendorFilePackagePath(pkg.Canonical)
if vp == nil {
vp = &vendorfile.Package{
Add: true,
Path: pkg.Canonical,
}
ctx.VendorFile.Package = append(ctx.VendorFile.Package, vp)
if pkg.Local != pkg.Canonical && pkg.inVendor {
vp.Origin = pkg.Local
}
}
// Find the VCS information.
system, err := vcs.FindVcs(pkg.Gopath, src)
if err != nil {
return err
}
if system != nil {
if system.Dirty {
return ErrDirtyPackage{pkg.Canonical}
}
vp.Revision = system.Revision
if system.RevisionTime != nil {
vp.RevisionTime = system.RevisionTime.Format(time.RFC3339)
}
}
mvSet := make(map[*Package]struct{}, 3)
ctx.makeSet(pkg, mvSet)
for r := range mvSet {
to := path.Join(ctx.RootImportPath, ctx.VendorFolder, r.Canonical)
dprintf("RULE: %s -> %s\n", r.Local, to)
ctx.RewriteRule[r.Canonical] = to
ctx.RewriteRule[r.Local] = to
}
return nil
}
// CopyPackage copies the files from the srcPath to the destPath, destPath
// folder and parents are are created if they don't already exist.
func CopyPackage(destPath, srcPath string, ignoreFiles []string) error {
if pathos.FileStringEquals(destPath, srcPath) {
return fmt.Errorf("Attempting to copy package to same location %q.", destPath)
}
err := os.MkdirAll(destPath, 0777)
if err != nil {
return err
}
// Ensure the dest is empty of files.
destDir, err := os.Open(destPath)
if err != nil {
return err
}
fl, err := destDir.Readdir(-1)
destDir.Close()
if err != nil {
return err
}
for _, fi := range fl {
if fi.IsDir() {
continue
}
err = os.Remove(filepath.Join(destPath, fi.Name()))
if err != nil {
return err
}
}
// Copy files into dest.
srcDir, err := os.Open(srcPath)
if err != nil {
return err
}
fl, err = srcDir.Readdir(-1)
srcDir.Close()
if err != nil {
return err
}
fileLoop:
for _, fi := range fl {
if fi.IsDir() {
continue
}
if fi.Name()[0] == '.' {
continue
}
for _, ignore := range ignoreFiles {
if pathos.FileStringEquals(fi.Name(), ignore) {
continue fileLoop
}
}
err = copyFile(
filepath.Join(destPath, fi.Name()),
filepath.Join(srcPath, fi.Name()),
)
if err != nil {
return err
}
}
return nil
}