Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 94a32104 authored by Colin Cross's avatar Colin Cross
Browse files

Move AllowMissingDependencies check from PathsForSource to PathForSource 

PathsForSource was handling the AllowMissingDependencies case, but
PathForSource was not.  Refactor PathForSource and
ExistentPathForSource, and add logic to PathForSource to fall back
to behavior similar to ExistentPathForSource when
AllowMissingDependencies is set.

Test: paths_test.go
Change-Id: Id7925999a27ea75a05e9301bbf1eb9f9a6bc4652
parent 1ccfcc36

android/paths.go

+61 −75
Original line number Diff line number Diff line
@@ -195,20 +195,6 @@ type Paths []Path 


// PathsForSource returns Paths rooted from SrcDir

func PathsForSource(ctx PathContext, paths []string) Paths {

	if ctx.Config().AllowMissingDependencies() {

		if modCtx, ok := ctx.(ModuleContext); ok {

			ret := make(Paths, 0, len(paths))

			for _, path := range paths {

				p := ExistentPathForSource(ctx, path)

				if p.Valid() {

					ret = append(ret, p.Path())

				} else {

					modCtx.AddMissingDependencies([]string{path})

				}

			}

			return ret

		}

	}

	ret := make(Paths, len(paths))

	for i, path := range paths {

		ret[i] = PathForSource(ctx, path)
@@ -507,100 +493,100 @@ func safePathForSource(ctx PathContext, path string) SourcePath { 
	return ret

}



// PathForSource joins the provided path components and validates that the result

// neither escapes the source dir nor is in the out dir.

// On error, it will return a usable, but invalid SourcePath, and report a ModuleError.

func PathForSource(ctx PathContext, pathComponents ...string) SourcePath {

// pathForSource creates a SourcePath from pathComponents, but does not check that it exists.

func pathForSource(ctx PathContext, pathComponents ...string) (SourcePath, error) {

	p, err := validatePath(pathComponents...)

	ret := SourcePath{basePath{p, ctx.Config(), ""}}

	if err != nil {

		reportPathError(ctx, err)

		return ret

		return ret, err

	}



	abs, err := filepath.Abs(ret.String())

	if err != nil {

		reportPathError(ctx, err)

		return ret

		return ret, err

	}

	buildroot, err := filepath.Abs(ctx.Config().buildDir)

	if err != nil {

		reportPathError(ctx, err)

		return ret

		return ret, err

	}

	if strings.HasPrefix(abs, buildroot) {

		reportPathErrorf(ctx, "source path %s is in output", abs)

		return ret

		return ret, fmt.Errorf("source path %s is in output", abs)

	}



	if exists, _, err := ctx.Fs().Exists(ret.String()); err != nil {

		reportPathErrorf(ctx, "%s: %s", ret, err.Error())

	} else if !exists {

		reportPathErrorf(ctx, "source path %s does not exist", ret)

	if pathtools.IsGlob(ret.String()) {

		return ret, fmt.Errorf("path may not contain a glob: %s", ret.String())

	}

	return ret



	return ret, nil

}



// existsWithDependencies returns true if the path exists, and adds appropriate dependencies to rerun if the

// path does not exist.

func existsWithDependencies(ctx PathContext, path SourcePath) (exists bool, err error) {

	var files []string



	if gctx, ok := ctx.(PathGlobContext); ok {

		// Use glob to produce proper dependencies, even though we only want

		// a single file.

		files, err = gctx.GlobWithDeps(path.String(), nil)

	} else {

		var deps []string

		// We cannot add build statements in this context, so we fall back to

		// AddNinjaFileDeps

		files, deps, err = pathtools.Glob(path.String(), nil)

		ctx.AddNinjaFileDeps(deps...)

	}



// ExistentPathForSource returns an OptionalPath with the SourcePath if the

// path exists, or an empty OptionalPath if it doesn't exist. Dependencies are added

// so that the ninja file will be regenerated if the state of the path changes.

func ExistentPathForSource(ctx PathContext, pathComponents ...string) OptionalPath {

	p, err := validatePath(pathComponents...)

	if err != nil {

		reportPathError(ctx, err)

		return OptionalPath{}

		return false, fmt.Errorf("glob: %s", err.Error())

	}

	path := SourcePath{basePath{p, ctx.Config(), ""}}



	abs, err := filepath.Abs(path.String())

	return len(files) > 0, nil

}



// PathForSource joins the provided path components and validates that the result

// neither escapes the source dir nor is in the out dir.

// On error, it will return a usable, but invalid SourcePath, and report a ModuleError.

func PathForSource(ctx PathContext, pathComponents ...string) SourcePath {

	path, err := pathForSource(ctx, pathComponents...)

	if err != nil {

		reportPathError(ctx, err)

		return OptionalPath{}

	}

	buildroot, err := filepath.Abs(ctx.Config().buildDir)



	if modCtx, ok := ctx.(ModuleContext); ok && ctx.Config().AllowMissingDependencies() {

		exists, err := existsWithDependencies(ctx, path)

		if err != nil {

			reportPathError(ctx, err)

		return OptionalPath{}

		}

	if strings.HasPrefix(abs, buildroot) {

		reportPathErrorf(ctx, "source path %s is in output", abs)

		return OptionalPath{}

		if !exists {

			modCtx.AddMissingDependencies([]string{path.String()})

		}



	if pathtools.IsGlob(path.String()) {

		reportPathErrorf(ctx, "path may not contain a glob: %s", path.String())

		return OptionalPath{}

	} else if exists, _, err := ctx.Fs().Exists(path.String()); err != nil {

		reportPathErrorf(ctx, "%s: %s", path, err.Error())

	} else if !exists {

		reportPathErrorf(ctx, "source path %s does not exist", path)

	}

	return path

}



	if gctx, ok := ctx.(PathGlobContext); ok {

		// Use glob to produce proper dependencies, even though we only want

		// a single file.

		files, err := gctx.GlobWithDeps(path.String(), nil)

// ExistentPathForSource returns an OptionalPath with the SourcePath if the

// path exists, or an empty OptionalPath if it doesn't exist. Dependencies are added

// so that the ninja file will be regenerated if the state of the path changes.

func ExistentPathForSource(ctx PathContext, pathComponents ...string) OptionalPath {

	path, err := pathForSource(ctx, pathComponents...)

	if err != nil {

			reportPathErrorf(ctx, "glob: %s", err.Error())

		reportPathError(ctx, err)

		return OptionalPath{}

	}



		if len(files) == 0 {

			return OptionalPath{}

		}

	} else {

		// We cannot add build statements in this context, so we fall back to

		// AddNinjaFileDeps

		files, dirs, err := pathtools.Glob(path.String(), nil)

	exists, err := existsWithDependencies(ctx, path)

	if err != nil {

			reportPathErrorf(ctx, "glob: %s", err.Error())

		reportPathError(ctx, err)

		return OptionalPath{}

	}



		ctx.AddNinjaFileDeps(dirs...)



		if len(files) == 0 {

	if !exists {

		return OptionalPath{}

	}



		ctx.AddNinjaFileDeps(path.String())

	}

	return OptionalPathForPath(path)

}