Quelle  main.go   Sprache: unbekannt

// 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 (
 "flag"
 "fmt"
 "io"
 "io/ioutil"
 "os"
 "os/exec"
 "path/filepath"
 "strings"
 "syscall"
 "unicode"

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

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(identSet)
 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()
}

func processBp(bp *bpmodify.Blueprint) error {
 var modules *bpmodify.ModuleSet
 if targetedModules.all {
  modules = bp.AllModules()
 } else {
  modules = bp.ModulesByName(targetedModules.idents...)
 }

 if *removeProperty {
  // remove-property is used solely, so return here.
  return modules.RemoveProperty(targetedProperties.idents...)
 } else if *moveProperty {
  return modules.MoveProperty(newLocation, targetedProperties.idents...)
 } else if len(addIdents.idents) > 0 {
  props, err := modules.GetOrCreateProperty(bpmodify.List, targetedProperties.idents...)
  if err != nil {
   return err
  }
  return props.AddStringToList(addIdents.idents...)
 } else if addLiteral != nil {
  props, err := modules.GetOrCreateProperty(bpmodify.List, targetedProperties.idents...)
  if err != nil {
   return err
  }
  return props.AddLiteral(*addLiteral)
 } else if setString != nil {
  props, err := modules.GetOrCreateProperty(bpmodify.String, targetedProperties.idents...)
  if err != nil {
   return err
  }
  return props.SetString(*setString)
 } else if setBool != nil {
  props, err := modules.GetOrCreateProperty(bpmodify.Bool, targetedProperties.idents...)
  if err != nil {
   return err
  }
  var value bool
  if *setBool == "true" {
   value = true
  } else if *setBool == "false" {
   value = false
  } else {
   return fmt.Errorf("expected parameter to be true or false, found %s", *setBool)
  }
  return props.SetBool(value)
 } else {
  props, err := modules.GetProperty(targetedProperties.idents...)
  if err != nil {
   return err
  }
  if len(removeIdents.idents) > 0 {
   return props.RemoveStringFromList(removeIdents.idents...)
  } else if replaceProperty.size() != 0 {
   return props.ReplaceStrings(replaceProperty.oldNameToNewName)
  }
 }

 return nil
}

// 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 := io.ReadAll(in)
 if err != nil {
  return err
 }

 bp, err := bpmodify.NewBlueprint(filename, src)
 if err != nil {
  return err
 }

 err = processBp(bp)
 if err != nil {
  return err
 }

 res, err := bp.Bytes()
 if err != nil {
  return err
 }
 if *list {
  fmt.Fprintln(out, filename)
 }
 if *write {
  err = os.WriteFile(filename, res, 0644)
  if err != nil {
   return err
  }
 }
 if *doDiff {
  data, err := diff(src, res, filename)
  if err != nil {
   return fmt.Errorf("computing diff: %s", err)
  }
  fmt.Printf("diff -uw a/%s b/%s\n", filename, filename)
  out.Write(data)
 }
 if !*list && !*write && !*doDiff {
  _, err = out.Write(res)
 }

 return err
}

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.idents) == 0 && *moveProperty {
  report(fmt.Errorf("-move-property must specify property"))
  return
 }

 if len(targetedProperties.idents) == 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, filename string) (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(), "--label", "a/"+filename,
  f2.Name(), "--label", "b/"+filename).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
}