lucicfg/cli/base/config.go - infra/luci/luci-go - Git at Google

 // Copyright 2022 The LUCI Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 // Package base contains code shared by other CLI subpackages.
 package base

 import (
 	"fmt"
 	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"

 	"github.com/bazelbuild/buildtools/build"
 	"go.chromium.org/luci/common/data/stringset"
 	"go.chromium.org/luci/common/errors"
 	"go.chromium.org/luci/common/system/filesystem"
 	"go.chromium.org/luci/lucicfg/buildifier"
 	"go.chromium.org/luci/lucicfg/vars"
 	"google.golang.org/protobuf/encoding/prototext"
 )

 // ConfigName is the file name we will be used for lucicfg formatting
 const ConfigName = ".lucicfgfmtrc"

 // sentinel is used to prevent the walking functions in this package from walking
 // across a source control boundary. As of 2023 Q1 we are only worried about Git
 // repos, but should we ever support more VCS's and this walking code is still
 // required (i.e. this hasn't been replaced with a WORKSPACE style config file),
 // this should be extended.
 var sentinel = []string{".git"}

 // RewriterFactory is used to map from 'file to be formatted' to a Rewriter object,
 // via its GetRewriter method.
 //
 // This struct is obtained via the GetRewriterFactory function.
 type RewriterFactory struct {
 	rules          []pathRules
 	configFilePath string
 }

 type pathRules struct {
 	path  string // absolute path to the folder where this rules applies.
 	rules *buildifier.LucicfgFmtConfig_Rules
 }

 // CheckForBogusConfig will look for any config files contained in a subdirectory of entryPath
 // (recursively).
 //
 // Because we intend for there to be at most one config file per workspace, and for that config
 // file to be located at the root of the workspace, any such extra config files would be errors.
 // Due to the 'stateless' nature of fmt and lint, we search down the directory hierarchy here to
 // try to detect such misconfiguration, but in the future when these subcommands become
 // stateful (like validate currently is), we may remove this check.
 func CheckForBogusConfig(entryPath string) error {
 	// Traverse downwards
 	if err := filepath.WalkDir(entryPath, func(path string, d fs.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
 		// Skip checking of entry path, downwards is exclusive
 		if d.IsDir() && path != entryPath {
 			if _, err := os.Stat(filepath.Join(path, ConfigName)); err == nil {
 				return errors.Reason(
 					"\nFound a config in a subdirectory<%s> of a star file."+
 						"Please move to the highest common ancestor directory - %s\n",
 					path,
 					entryPath).Err()
 			} else if !errors.Is(err, os.ErrNotExist) {
 				return err
 			}
 		}
 		return nil
 	}); err != nil {
 		return err
 	} else {
 		return nil
 	}
 }

 func findConfigPathUpwards(path string) (string, error) {
 	var currentDir = path
 	for {
 		if _, err := os.Stat(filepath.Join(currentDir, ConfigName)); err == nil {
 			return filepath.Join(currentDir, ConfigName), nil
 		} else if !errors.Is(err, os.ErrNotExist) {
 			return "", err
 		} else {
 			var parent = filepath.Dir(currentDir)

 			if _, err := os.Stat(filepath.Join(path, ".git")); err == nil || parent == currentDir {
 				return "", nil
 			}

 			currentDir = parent
 		}
 	}
 }

 func convertOrderingToTable(nameOrdering []string) map[string]int {
 	count := len(nameOrdering)
 	table := make(map[string]int, count)
 	// This sequentially gives the names a priority value in the range
 	// [-count, 0). This ensures that all names have distinct priority
 	// values that sort them in the specified order. Since all priority
 	// values are less than the default 0, all names present in the
 	// ordering will sort before names that don't appear in the ordering.
 	for i, n := range nameOrdering {
 		table[n] = i - count
 	}
 	return table
 }

 func rewriterFromConfig(nameOrdering map[string]int) *build.Rewriter {
 	var rewriter = vars.GetDefaultRewriter()
 	if nameOrdering != nil {
 		rewriter.NamePriority = nameOrdering
 		rewriter.RewriteSet = append(rewriter.RewriteSet, "callsort")
 	}
 	return rewriter
 }

 // GetRewriterFactory will attempt to create a RewriterFactory object
 //
 // If configPath is empty, or points to a file which doesn't exist, the returned
 // factory will just produce GetDefaultRewriter() when asked about any path.
 // We will return an error if the config file is invalid.
 func GetRewriterFactory(configPath string) (rewriterFactory *RewriterFactory, err error) {
 	rewriterFactory = &RewriterFactory{
 		rules:          []pathRules{},
 		configFilePath: "",
 	}
 	if configPath == "" {
 		return
 	}
 	contents, err := os.ReadFile(configPath)
 	if err != nil {
 		if !errors.Is(err, os.ErrNotExist) {
 			fmt.Printf("Failed on reading file - %s", configPath)
 			return nil, err
 		} else {
 			return rewriterFactory, nil
 		}
 	}
 	luci := &buildifier.LucicfgFmtConfig{}

 	if err := prototext.Unmarshal(contents, luci); err != nil {
 		return nil, err
 	}
 	return getPostProcessedRewriterFactory(configPath, luci)
 }

 // getPostProcessedRewriterFactory will contain all logic used to make sure
 // RewriterFactory is normalized the way we want.
 //
 // Currently, we will fix paths so that they are absolute.
 // We will also perform a check so that there are no duplicate paths and
 // all paths are delimited with "/"
 func getPostProcessedRewriterFactory(configPath string, cfg *buildifier.LucicfgFmtConfig) (*RewriterFactory, error) {
 	pathSet := stringset.New(0)
 	rules := cfg.Rules
 	rulesSlice := make([]pathRules, 0)
 	for ruleIndex, rule := range rules {
 		// If a rule doesn't have any paths, err out and notify users
 		if len(rule.Path) == 0 {
 			return nil, errors.Reason(
 				"rule[%d]: Does not contain any paths",
 				ruleIndex).Err()
 		}
 		for rulePathIndex, pathInDir := range rule.Path {
 			// Fix paths. Update to use absolute path.
 			fixedPathInDir := filepath.Clean(
 				filepath.Join(filepath.Dir(configPath), pathInDir),
 			)
 			// Check for duplicate paths. If there is, return error
 			if pathSet.Contains(stringset.NewFromSlice(fixedPathInDir)) {
 				return nil, errors.Reason(
 					"rule[%d].path[%d]: Found duplicate path '%s'",
 					ruleIndex, rulePathIndex, pathInDir).Err()
 			}
 			// Check for backslash in path, if there is, return error
 			if strings.Contains(pathInDir, "\\") {
 				return nil, errors.Reason(
 					"rule[%d].path[%d]: Path should not contain backslash '%s'",
 					ruleIndex, rulePathIndex, pathInDir).Err()
 			}
 			// Add into set to check later if duplicate
 			pathSet.Add(fixedPathInDir)
 			if fixedPathInDirAbs, err := filepath.Abs(fixedPathInDir); err != nil {
 				return nil, errors.Annotate(err, "rule[%d].path[%d]: filepath.Abs error %s",
 					ruleIndex, rulePathIndex, pathInDir).Err()
 			} else {
 				fixedPathInDir = fixedPathInDirAbs
 			}

 			rulesSlice = append(rulesSlice, pathRules{
 				fixedPathInDir,
 				rule,
 			})
 		}
 	}

 	return &RewriterFactory{
 		rulesSlice,
 		filepath.Dir(configPath),
 	}, nil
 }

 // GetRewriter will return the Rewriter which is appropriate for formatting
 // the file at `path`, using the previously loaded formatting configuration.
 //
 // Note the method signature will pass in values that we need to evaluate
 // the correct rewriter.
 //
 // We will accept both relative and absolute paths.
 func (f *RewriterFactory) GetRewriter(path string) (*build.Rewriter, error) {
 	rules := f.rules
 	// Check if path is abs, if not, fix it
 	if !filepath.IsAbs(path) {
 		return nil, errors.Reason("GetRewriter got non-absolute path: %q", path).Err()
 	}
 	longestPathMatch := ""
 	var matchingRule *buildifier.LucicfgFmtConfig_Rules

 	// Find the path that best matches the one we are processing.
 	for _, rule := range rules {
 		commonAncestor, err := filesystem.GetCommonAncestor(
 			[]string{rule.path, path},
 			sentinel,
 		)

 		if err != nil {
 			return nil, err
 		}

 		commonAncestor = filepath.Clean(commonAncestor)
 		if commonAncestor == rule.path && len(commonAncestor) > len(longestPathMatch) {
 			longestPathMatch = commonAncestor
 			matchingRule = rule.rules
 		}
 	}
 	if matchingRule != nil && matchingRule.FunctionArgsSort != nil {
 		return rewriterFromConfig(
 			convertOrderingToTable(matchingRule.FunctionArgsSort.Arg),
 		), nil
 	}

 	return vars.GetDefaultRewriter(), nil
 }

 // GuessRewriterFactoryFunc will find the common ancestor dir from all given paths
 // and return a func that returns the rewriter factory.
 //
 // Will look for a config file upwards(inclusive). If found, it will be used to determine
 // rewriter properties. It will also look downwards(exclusive) to expose any misplaced
 // config files.
 func GuessRewriterFactoryFunc(paths []string) (*RewriterFactory, error) {
 	// Find the common ancestor
 	commonAncestorPath, err := filesystem.GetCommonAncestor(paths, sentinel)

 	if errors.Is(err, filesystem.ErrRootSentinel) {
 		// we hit the repo root, just return function that returns default rewriter
 		rewriterFactory, err := GetRewriterFactory("")
 		if err != nil {
 			return nil, err
 		}
 		return rewriterFactory, nil
 	}
 	if err != nil {
 		// other errors are fatal
 		return nil, err
 	}
 	if err := CheckForBogusConfig(commonAncestorPath); err != nil {
 		return nil, err
 	}

 	luciConfigPath, err := findConfigPathUpwards(commonAncestorPath)
 	if err != nil {
 		return nil, err
 	}
 	rewriterFactory, err := GetRewriterFactory(luciConfigPath)
 	if err != nil {
 		return nil, err
 	}

 	return rewriterFactory, nil
 }
	// Copyright 2022 The LUCI Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	// Package base contains code shared by other CLI subpackages.
	package base

	import (
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"

	"github.com/bazelbuild/buildtools/build"
	"go.chromium.org/luci/common/data/stringset"
	"go.chromium.org/luci/common/errors"
	"go.chromium.org/luci/common/system/filesystem"
	"go.chromium.org/luci/lucicfg/buildifier"
	"go.chromium.org/luci/lucicfg/vars"
	"google.golang.org/protobuf/encoding/prototext"
	)

	// ConfigName is the file name we will be used for lucicfg formatting
	const ConfigName = ".lucicfgfmtrc"

	// sentinel is used to prevent the walking functions in this package from walking
	// across a source control boundary. As of 2023 Q1 we are only worried about Git
	// repos, but should we ever support more VCS's and this walking code is still
	// required (i.e. this hasn't been replaced with a WORKSPACE style config file),
	// this should be extended.
	var sentinel = []string{".git"}

	// RewriterFactory is used to map from 'file to be formatted' to a Rewriter object,
	// via its GetRewriter method.
	//
	// This struct is obtained via the GetRewriterFactory function.
	type RewriterFactory struct {
	rules []pathRules
	configFilePath string
	}

	type pathRules struct {
	path string // absolute path to the folder where this rules applies.
	rules *buildifier.LucicfgFmtConfig_Rules
	}

	// CheckForBogusConfig will look for any config files contained in a subdirectory of entryPath
	// (recursively).
	//
	// Because we intend for there to be at most one config file per workspace, and for that config
	// file to be located at the root of the workspace, any such extra config files would be errors.
	// Due to the 'stateless' nature of fmt and lint, we search down the directory hierarchy here to
	// try to detect such misconfiguration, but in the future when these subcommands become
	// stateful (like validate currently is), we may remove this check.
	func CheckForBogusConfig(entryPath string) error {
	// Traverse downwards
	if err := filepath.WalkDir(entryPath, func(path string, d fs.DirEntry, err error) error {
	if err != nil {
	return err
	}
	// Skip checking of entry path, downwards is exclusive
	if d.IsDir() && path != entryPath {
	if _, err := os.Stat(filepath.Join(path, ConfigName)); err == nil {
	return errors.Reason(
	"\nFound a config in a subdirectory<%s> of a star file."+
	"Please move to the highest common ancestor directory - %s\n",
	path,
	entryPath).Err()
	} else if !errors.Is(err, os.ErrNotExist) {
	return err
	}
	}
	return nil
	}); err != nil {
	return err
	} else {
	return nil
	}
	}

	func findConfigPathUpwards(path string) (string, error) {
	var currentDir = path
	for {
	if _, err := os.Stat(filepath.Join(currentDir, ConfigName)); err == nil {
	return filepath.Join(currentDir, ConfigName), nil
	} else if !errors.Is(err, os.ErrNotExist) {
	return "", err
	} else {
	var parent = filepath.Dir(currentDir)

	if _, err := os.Stat(filepath.Join(path, ".git")); err == nil \|\| parent == currentDir {
	return "", nil
	}

	currentDir = parent
	}
	}
	}

	func convertOrderingToTable(nameOrdering []string) map[string]int {
	count := len(nameOrdering)
	table := make(map[string]int, count)
	// This sequentially gives the names a priority value in the range
	// [-count, 0). This ensures that all names have distinct priority
	// values that sort them in the specified order. Since all priority
	// values are less than the default 0, all names present in the
	// ordering will sort before names that don't appear in the ordering.
	for i, n := range nameOrdering {
	table[n] = i - count
	}
	return table
	}

	func rewriterFromConfig(nameOrdering map[string]int) *build.Rewriter {
	var rewriter = vars.GetDefaultRewriter()
	if nameOrdering != nil {
	rewriter.NamePriority = nameOrdering
	rewriter.RewriteSet = append(rewriter.RewriteSet, "callsort")
	}
	return rewriter
	}

	// GetRewriterFactory will attempt to create a RewriterFactory object
	//
	// If configPath is empty, or points to a file which doesn't exist, the returned
	// factory will just produce GetDefaultRewriter() when asked about any path.
	// We will return an error if the config file is invalid.
	func GetRewriterFactory(configPath string) (rewriterFactory *RewriterFactory, err error) {
	rewriterFactory = &RewriterFactory{
	rules: []pathRules{},
	configFilePath: "",
	}
	if configPath == "" {
	return
	}
	contents, err := os.ReadFile(configPath)
	if err != nil {
	if !errors.Is(err, os.ErrNotExist) {
	fmt.Printf("Failed on reading file - %s", configPath)
	return nil, err
	} else {
	return rewriterFactory, nil
	}
	}
	luci := &buildifier.LucicfgFmtConfig{}

	if err := prototext.Unmarshal(contents, luci); err != nil {
	return nil, err
	}
	return getPostProcessedRewriterFactory(configPath, luci)
	}

	// getPostProcessedRewriterFactory will contain all logic used to make sure
	// RewriterFactory is normalized the way we want.
	//
	// Currently, we will fix paths so that they are absolute.
	// We will also perform a check so that there are no duplicate paths and
	// all paths are delimited with "/"
	func getPostProcessedRewriterFactory(configPath string, cfg buildifier.LucicfgFmtConfig) (RewriterFactory, error) {
	pathSet := stringset.New(0)
	rules := cfg.Rules
	rulesSlice := make([]pathRules, 0)
	for ruleIndex, rule := range rules {
	// If a rule doesn't have any paths, err out and notify users
	if len(rule.Path) == 0 {
	return nil, errors.Reason(
	"rule[%d]: Does not contain any paths",
	ruleIndex).Err()
	}
	for rulePathIndex, pathInDir := range rule.Path {
	// Fix paths. Update to use absolute path.
	fixedPathInDir := filepath.Clean(
	filepath.Join(filepath.Dir(configPath), pathInDir),
	)
	// Check for duplicate paths. If there is, return error
	if pathSet.Contains(stringset.NewFromSlice(fixedPathInDir)) {
	return nil, errors.Reason(
	"rule[%d].path[%d]: Found duplicate path '%s'",
	ruleIndex, rulePathIndex, pathInDir).Err()
	}
	// Check for backslash in path, if there is, return error
	if strings.Contains(pathInDir, "\\") {
	return nil, errors.Reason(
	"rule[%d].path[%d]: Path should not contain backslash '%s'",
	ruleIndex, rulePathIndex, pathInDir).Err()
	}
	// Add into set to check later if duplicate
	pathSet.Add(fixedPathInDir)
	if fixedPathInDirAbs, err := filepath.Abs(fixedPathInDir); err != nil {
	return nil, errors.Annotate(err, "rule[%d].path[%d]: filepath.Abs error %s",
	ruleIndex, rulePathIndex, pathInDir).Err()
	} else {
	fixedPathInDir = fixedPathInDirAbs
	}

	rulesSlice = append(rulesSlice, pathRules{
	fixedPathInDir,
	rule,
	})
	}
	}

	return &RewriterFactory{
	rulesSlice,
	filepath.Dir(configPath),
	}, nil
	}

	// GetRewriter will return the Rewriter which is appropriate for formatting
	// the file at `path`, using the previously loaded formatting configuration.
	//
	// Note the method signature will pass in values that we need to evaluate
	// the correct rewriter.
	//
	// We will accept both relative and absolute paths.
	func (f RewriterFactory) GetRewriter(path string) (build.Rewriter, error) {
	rules := f.rules
	// Check if path is abs, if not, fix it
	if !filepath.IsAbs(path) {
	return nil, errors.Reason("GetRewriter got non-absolute path: %q", path).Err()
	}
	longestPathMatch := ""
	var matchingRule *buildifier.LucicfgFmtConfig_Rules

	// Find the path that best matches the one we are processing.
	for _, rule := range rules {
	commonAncestor, err := filesystem.GetCommonAncestor(
	[]string{rule.path, path},
	sentinel,
	)

	if err != nil {
	return nil, err
	}

	commonAncestor = filepath.Clean(commonAncestor)
	if commonAncestor == rule.path && len(commonAncestor) > len(longestPathMatch) {
	longestPathMatch = commonAncestor
	matchingRule = rule.rules
	}
	}
	if matchingRule != nil && matchingRule.FunctionArgsSort != nil {
	return rewriterFromConfig(
	convertOrderingToTable(matchingRule.FunctionArgsSort.Arg),
	), nil
	}

	return vars.GetDefaultRewriter(), nil
	}

	// GuessRewriterFactoryFunc will find the common ancestor dir from all given paths
	// and return a func that returns the rewriter factory.
	//
	// Will look for a config file upwards(inclusive). If found, it will be used to determine
	// rewriter properties. It will also look downwards(exclusive) to expose any misplaced
	// config files.
	func GuessRewriterFactoryFunc(paths []string) (*RewriterFactory, error) {
	// Find the common ancestor
	commonAncestorPath, err := filesystem.GetCommonAncestor(paths, sentinel)

	if errors.Is(err, filesystem.ErrRootSentinel) {
	// we hit the repo root, just return function that returns default rewriter
	rewriterFactory, err := GetRewriterFactory("")
	if err != nil {
	return nil, err
	}
	return rewriterFactory, nil
	}
	if err != nil {
	// other errors are fatal
	return nil, err
	}
	if err := CheckForBogusConfig(commonAncestorPath); err != nil {
	return nil, err
	}

	luciConfigPath, err := findConfigPathUpwards(commonAncestorPath)
	if err != nil {
	return nil, err
	}
	rewriterFactory, err := GetRewriterFactory(luciConfigPath)
	if err != nil {
	return nil, err
	}

	return rewriterFactory, nil
	}