bpmodify/bpmodify.go

// Mostly copied from Go's src/cmd/gofmt:
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main

import (
	"bytes"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"syscall"
	"unicode"

	"github.com/google/blueprint/parser"
)

var (
	// main operation modes
	list               = flag.Bool("l", false, "list files that would be modified by bpmodify")
	write              = flag.Bool("w", false, "write result to (source) file instead of stdout")
	doDiff             = flag.Bool("d", false, "display diffs instead of rewriting files")
	sortLists          = flag.Bool("s", false, "sort touched lists, even if they were unsorted")
	targetedModules    = new(identSet)
	targetedProperties = new(qualifiedProperties)
	addIdents          = new(identSet)
	removeIdents       = new(identSet)
	removeProperty     = flag.Bool("remove-property", false, "remove the property")
	moveProperty       = flag.Bool("move-property", false, "moves contents of property into newLocation")
	newLocation        string
	setString          *string
	addLiteral         *string
	setBool            *string
	replaceProperty    = new(replacements)
)

func init() {
	flag.Var(targetedModules, "m", "comma or whitespace separated list of modules on which to operate")
	flag.Var(targetedProperties, "parameter", "alias to -property=`name1[,name2[,... […]")
	flag.StringVar(&newLocation, "new-location", "", " use with moveProperty to move contents of -property into a property with name -new-location ")
	flag.Var(targetedProperties, "property", "comma-separated list of fully qualified `name`s of properties to modify (default \"deps\")")
	flag.Var(addIdents, "a", "comma or whitespace separated list of identifiers to add")
	flag.Var(stringPtrFlag{&addLiteral}, "add-literal", "a literal to add to a list")
	flag.Var(removeIdents, "r", "comma or whitespace separated list of identifiers to remove")
	flag.Var(stringPtrFlag{&setString}, "str", "set a string property")
	flag.Var(replaceProperty, "replace-property", "property names to be replaced, in the form of oldName1=newName1,oldName2=newName2")
	flag.Var(stringPtrFlag{&setBool}, "set-bool", "a boolean value to set a property with (not a list)")
	flag.Usage = usage
}

var (
	exitCode = 0
)

func report(err error) {
	fmt.Fprintln(os.Stderr, err)
	exitCode = 2
}

func usage() {
	fmt.Fprintf(flag.CommandLine.Output(), "Usage: %s [flags] [path ...]\n", os.Args[0])
	flag.PrintDefaults()
}

// If in == nil, the source is the contents of the file with the given filename.
func processFile(filename string, in io.Reader, out io.Writer) error {
	if in == nil {
		f, err := os.Open(filename)
		if err != nil {
			return err
		}
		defer f.Close()
		if *write {
			syscall.Flock(int(f.Fd()), syscall.LOCK_EX)
		}
		in = f
	}
	src, err := ioutil.ReadAll(in)
	if err != nil {
		return err
	}
	r := bytes.NewBuffer(src)
	file, errs := parser.Parse(filename, r, parser.NewScope(nil))
	if len(errs) > 0 {
		for _, err := range errs {
			fmt.Fprintln(os.Stderr, err)
		}
		return fmt.Errorf("%d parsing errors", len(errs))
	}
	modified, errs := findModules(file)
	if len(errs) > 0 {
		for _, err := range errs {
			fmt.Fprintln(os.Stderr, err)
		}
		fmt.Fprintln(os.Stderr, "continuing...")
	}
	if modified {
		res, err := parser.Print(file)
		if err != nil {
			return err
		}
		if *list {
			fmt.Fprintln(out, filename)
		}
		if *write {
			err = ioutil.WriteFile(filename, res, 0644)
			if err != nil {
				return err
			}
		}
		if *doDiff {
			data, err := diff(src, res)
			if err != nil {
				return fmt.Errorf("computing diff: %s", err)
			}
			fmt.Printf("diff %s bpfmt/%s\n", filename, filename)
			out.Write(data)
		}
		if !*list && !*write && !*doDiff {
			_, err = out.Write(res)
		}
	}
	return err
}
func findModules(file *parser.File) (modified bool, errs []error) {
	for _, def := range file.Defs {
		if module, ok := def.(*parser.Module); ok {
			for _, prop := range module.Properties {
				if prop.Name == "name" && prop.Value.Type() == parser.StringType && targetedModule(prop.Value.Eval().(*parser.String).Value) {
					for _, p := range targetedProperties.properties {
						m, newErrs := processModuleProperty(module, prop.Name, file, p)
						errs = append(errs, newErrs...)
						modified = modified || m
					}
				}
			}
		}
	}
	return modified, errs
}

func processModuleProperty(module *parser.Module, moduleName string,
	file *parser.File, property qualifiedProperty) (modified bool, errs []error) {
	prop, parent, err := getRecursiveProperty(module, property.name(), property.prefixes())
	if err != nil {
		return false, []error{err}
	}
	if prop == nil {
		if len(addIdents.idents) > 0 || addLiteral != nil {
			// We are adding something to a non-existing list prop, so we need to create it first.
			prop, modified, err = createRecursiveProperty(module, property.name(), property.prefixes(), &parser.List{})
		} else if setString != nil {
			// We setting a non-existent string property, so we need to create it first.
			prop, modified, err = createRecursiveProperty(module, property.name(), property.prefixes(), &parser.String{})
		} else if setBool != nil {
			// We are setting a non-existent property, so we need to create it first.
			prop, modified, err = createRecursiveProperty(module, property.name(), property.prefixes(), &parser.Bool{})
		} else {
			// We cannot find an existing prop, and we aren't adding anything to the prop,
			// which means we must be removing something from a non-existing prop,
			// which means this is a noop.
			return false, nil
		}
		if err != nil {
			// Here should be unreachable, but still handle it for completeness.
			return false, []error{err}
		}
	} else if *removeProperty {
		// remove-property is used solely, so return here.
		return parent.RemoveProperty(prop.Name), nil
	} else if *moveProperty {
		return parent.MovePropertyContents(prop.Name, newLocation), nil
	}
	m, errs := processParameter(prop.Value, property.String(), moduleName, file)
	modified = modified || m
	return modified, errs
}
func getRecursiveProperty(module *parser.Module, name string, prefixes []string) (prop *parser.Property, parent *parser.Map, err error) {
	prop, parent, _, err = getOrCreateRecursiveProperty(module, name, prefixes, nil)
	return prop, parent, err
}
func createRecursiveProperty(module *parser.Module, name string, prefixes []string,
	empty parser.Expression) (prop *parser.Property, modified bool, err error) {
	prop, _, modified, err = getOrCreateRecursiveProperty(module, name, prefixes, empty)
	return prop, modified, err
}
func getOrCreateRecursiveProperty(module *parser.Module, name string, prefixes []string,
	empty parser.Expression) (prop *parser.Property, parent *parser.Map, modified bool, err error) {
	m := &module.Map
	for i, prefix := range prefixes {
		if prop, found := m.GetProperty(prefix); found {
			if mm, ok := prop.Value.Eval().(*parser.Map); ok {
				m = mm
			} else {
				// We've found a property in the AST and such property is not of type
				// *parser.Map, which must mean we didn't modify the AST.
				return nil, nil, false, fmt.Errorf("Expected property %q to be a map, found %s",
					strings.Join(prefixes[:i+1], "."), prop.Value.Type())
			}
		} else if empty != nil {
			mm := &parser.Map{}
			m.Properties = append(m.Properties, &parser.Property{Name: prefix, Value: mm})
			m = mm
			// We've created a new node in the AST. This means the m.GetProperty(name)
			// check after this for loop must fail, because the node we inserted is an
			// empty parser.Map, thus this function will return |modified| is true.
		} else {
			return nil, nil, false, nil
		}
	}
	if prop, found := m.GetProperty(name); found {
		// We've found a property in the AST, which must mean we didn't modify the AST.
		return prop, m, false, nil
	} else if empty != nil {
		prop = &parser.Property{Name: name, Value: empty}
		m.Properties = append(m.Properties, prop)
		return prop, m, true, nil
	} else {
		return nil, nil, false, nil
	}
}
func processParameter(value parser.Expression, paramName, moduleName string,
	file *parser.File) (modified bool, errs []error) {
	if _, ok := value.(*parser.Variable); ok {
		return false, []error{fmt.Errorf("parameter %s in module %s is a variable, unsupported",
			paramName, moduleName)}
	}
	if _, ok := value.(*parser.Operator); ok {
		return false, []error{fmt.Errorf("parameter %s in module %s is an expression, unsupported",
			paramName, moduleName)}
	}

	if (*replaceProperty).size() != 0 {
		if list, ok := value.Eval().(*parser.List); ok {
			return parser.ReplaceStringsInList(list, (*replaceProperty).oldNameToNewName), nil
		} else if str, ok := value.Eval().(*parser.String); ok {
			oldVal := str.Value
			replacementValue := (*replaceProperty).oldNameToNewName[oldVal]
			if replacementValue != "" {
				str.Value = replacementValue
				return true, nil
			} else {
				return false, nil
			}
		}
		return false, []error{fmt.Errorf("expected parameter %s in module %s to be a list or string, found %s",
			paramName, moduleName, value.Type().String())}
	}
	if len(addIdents.idents) > 0 || len(removeIdents.idents) > 0 {
		list, ok := value.(*parser.List)
		if !ok {
			return false, []error{fmt.Errorf("expected parameter %s in module %s to be list, found %s",
				paramName, moduleName, value.Type())}
		}
		wasSorted := parser.ListIsSorted(list)
		for _, a := range addIdents.idents {
			m := parser.AddStringToList(list, a)
			modified = modified || m
		}
		for _, r := range removeIdents.idents {
			m := parser.RemoveStringFromList(list, r)
			modified = modified || m
		}
		if (wasSorted || *sortLists) && modified {
			parser.SortList(file, list)
		}
	} else if addLiteral != nil {
		if *sortLists {
			return false, []error{fmt.Errorf("sorting not supported when adding a literal")}
		}
		list, ok := value.(*parser.List)
		if !ok {
			return false, []error{fmt.Errorf("expected parameter %s in module %s to be list, found %s",
				paramName, moduleName, value.Type().String())}
		}
		value, errs := parser.ParseExpression(strings.NewReader(*addLiteral))
		if errs != nil {
			return false, errs
		}
		list.Values = append(list.Values, value)
		modified = true
	} else if setBool != nil {
		res, ok := value.(*parser.Bool)
		if !ok {
			return false, []error{fmt.Errorf("expected parameter %s in module %s to be bool, found %s",
				paramName, moduleName, value.Type().String())}
		}
		if *setBool == "true" {
			res.Value = true
		} else if *setBool == "false" {
			res.Value = false
		} else {
			return false, []error{fmt.Errorf("expected parameter %s to be true or false, found %s",
				paramName, *setBool)}
		}
		modified = true
	} else if setString != nil {
		str, ok := value.(*parser.String)
		if !ok {
			return false, []error{fmt.Errorf("expected parameter %s in module %s to be string, found %s",
				paramName, moduleName, value.Type().String())}
		}
		str.Value = *setString
		modified = true
	}
	return modified, nil
}
func targetedModule(name string) bool {
	if targetedModules.all {
		return true
	}
	for _, m := range targetedModules.idents {
		if m == name {
			return true
		}
	}
	return false
}
func visitFile(path string, f os.FileInfo, err error) error {
	//TODO(dacek): figure out a better way to target intended .bp files without parsing errors
	if err == nil && (f.Name() == "Blueprints" || strings.HasSuffix(f.Name(), ".bp")) {
		err = processFile(path, nil, os.Stdout)
	}
	if err != nil {
		report(err)
	}
	return nil
}
func walkDir(path string) {
	filepath.Walk(path, visitFile)
}
func main() {
	defer func() {
		if err := recover(); err != nil {
			report(fmt.Errorf("error: %s", err))
		}
		os.Exit(exitCode)
	}()
	flag.Parse()

	if len(targetedProperties.properties) == 0 && *moveProperty {
		report(fmt.Errorf("-move-property must specify property"))
		return
	}

	if len(targetedProperties.properties) == 0 {
		targetedProperties.Set("deps")
	}
	if flag.NArg() == 0 {
		if *write {
			report(fmt.Errorf("error: cannot use -w with standard input"))
			return
		}
		if err := processFile("<standard input>", os.Stdin, os.Stdout); err != nil {
			report(err)
		}
		return
	}
	if len(targetedModules.idents) == 0 {
		report(fmt.Errorf("-m parameter is required"))
		return
	}

	if len(addIdents.idents) == 0 && len(removeIdents.idents) == 0 && setString == nil && addLiteral == nil && !*removeProperty && !*moveProperty && (*replaceProperty).size() == 0 && setBool == nil {
		report(fmt.Errorf("-a, -add-literal, -r, -remove-property, -move-property, replace-property or -str parameter is required"))
		return
	}
	if *removeProperty && (len(addIdents.idents) > 0 || len(removeIdents.idents) > 0 || setString != nil || addLiteral != nil || (*replaceProperty).size() > 0) {
		report(fmt.Errorf("-remove-property cannot be used with other parameter(s)"))
		return
	}
	if *moveProperty && (len(addIdents.idents) > 0 || len(removeIdents.idents) > 0 || setString != nil || addLiteral != nil || (*replaceProperty).size() > 0) {
		report(fmt.Errorf("-move-property cannot be used with other parameter(s)"))
		return
	}
	if *moveProperty && newLocation == "" {
		report(fmt.Errorf("-move-property must specify -new-location"))
		return
	}
	for i := 0; i < flag.NArg(); i++ {
		path := flag.Arg(i)
		switch dir, err := os.Stat(path); {
		case err != nil:
			report(err)
		case dir.IsDir():
			walkDir(path)
		default:
			if err := processFile(path, nil, os.Stdout); err != nil {
				report(err)
			}
		}
	}
}

func diff(b1, b2 []byte) (data []byte, err error) {
	f1, err := ioutil.TempFile("", "bpfmt")
	if err != nil {
		return
	}
	defer os.Remove(f1.Name())
	defer f1.Close()
	f2, err := ioutil.TempFile("", "bpfmt")
	if err != nil {
		return
	}
	defer os.Remove(f2.Name())
	defer f2.Close()
	f1.Write(b1)
	f2.Write(b2)
	data, err = exec.Command("diff", "-uw", f1.Name(), f2.Name()).CombinedOutput()
	if len(data) > 0 {
		// diff exits with a non-zero status when the files don't match.
		// Ignore that failure as long as we get output.
		err = nil
	}
	return
}

type stringPtrFlag struct {
	s **string
}

func (f stringPtrFlag) Set(s string) error {
	*f.s = &s
	return nil
}
func (f stringPtrFlag) String() string {
	if f.s == nil || *f.s == nil {
		return ""
	}
	return **f.s
}

type replacements struct {
	oldNameToNewName map[string]string
}

func (m *replacements) String() string {
	ret := ""
	sep := ""
	for k, v := range m.oldNameToNewName {
		ret += sep
		ret += k
		ret += ":"
		ret += v
		sep = ","
	}
	return ret
}

func (m *replacements) Set(s string) error {
	usedNames := make(map[string]struct{})

	pairs := strings.Split(s, ",")
	length := len(pairs)
	m.oldNameToNewName = make(map[string]string)
	for i := 0; i < length; i++ {

		pair := strings.SplitN(pairs[i], "=", 2)
		if len(pair) != 2 {
			return fmt.Errorf("Invalid replacement pair %s", pairs[i])
		}
		oldName := pair[0]
		newName := pair[1]
		if _, seen := usedNames[oldName]; seen {
			return fmt.Errorf("Duplicated replacement name %s", oldName)
		}
		if _, seen := usedNames[newName]; seen {
			return fmt.Errorf("Duplicated replacement name %s", newName)
		}
		usedNames[oldName] = struct{}{}
		usedNames[newName] = struct{}{}
		m.oldNameToNewName[oldName] = newName
	}
	return nil
}

func (m *replacements) Get() interface{} {
	//TODO(dacek): Remove Get() method from interface as it seems unused.
	return m.oldNameToNewName
}

func (m *replacements) size() (length int) {
	return len(m.oldNameToNewName)
}

type identSet struct {
	idents []string
	all    bool
}

func (m *identSet) String() string {
	return strings.Join(m.idents, ",")
}
func (m *identSet) Set(s string) error {
	m.idents = strings.FieldsFunc(s, func(c rune) bool {
		return unicode.IsSpace(c) || c == ','
	})
	if len(m.idents) == 1 && m.idents[0] == "*" {
		m.all = true
	}
	return nil
}
func (m *identSet) Get() interface{} {
	return m.idents
}

type qualifiedProperties struct {
	properties []qualifiedProperty
}

type qualifiedProperty struct {
	parts []string
}

var _ flag.Getter = (*qualifiedProperties)(nil)

func (p *qualifiedProperty) name() string {
	return p.parts[len(p.parts)-1]
}
func (p *qualifiedProperty) prefixes() []string {
	return p.parts[:len(p.parts)-1]
}
func (p *qualifiedProperty) String() string {
	return strings.Join(p.parts, ".")
}

func parseQualifiedProperty(s string) (*qualifiedProperty, error) {
	parts := strings.Split(s, ".")
	if len(parts) == 0 {
		return nil, fmt.Errorf("%q is not a valid property name", s)
	}
	for _, part := range parts {
		if part == "" {
			return nil, fmt.Errorf("%q is not a valid property name", s)
		}
	}
	prop := qualifiedProperty{parts}
	return &prop, nil

}

func (p *qualifiedProperties) Set(s string) error {
	properties := strings.Split(s, ",")
	if len(properties) == 0 {
		return fmt.Errorf("%q is not a valid property name", s)
	}

	p.properties = make([]qualifiedProperty, len(properties))
	for i := 0; i < len(properties); i++ {
		tmp, err := parseQualifiedProperty(properties[i])
		if err != nil {
			return err
		}
		p.properties[i] = *tmp
	}
	return nil
}

func (p *qualifiedProperties) String() string {
	arrayLength := len(p.properties)
	props := make([]string, arrayLength)
	for i := 0; i < len(p.properties); i++ {
		props[i] = p.properties[i].String()
	}
	return strings.Join(props, ",")
}
func (p *qualifiedProperties) Get() interface{} {
	return p.properties
}