[errors] Greatly simplify common/errors package.

vpython/spec/load.go

 // Copyright 2017 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package spec
 
 import (
         "bufio"
         "io/ioutil"
         "os"
@@ skipping 27 matching lines @@
         // DefaultInlineBeginGuard is the default loader InlineBeginGuard value.
         DefaultInlineBeginGuard = "[VPYTHON:BEGIN]"
         // DefaultInlineEndGuard is the default loader InlineEndGuard value.
         DefaultInlineEndGuard = "[VPYTHON:END]"
 )
 
 // Load loads an specification file text protobuf from the supplied path.
 func Load(path string, spec *vpython.Spec) error {
         content, err := ioutil.ReadFile(path)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to load file from: %(path)s").
-                        D("path", path).
-                        Err()
+                return errors.Annotate(err, "failed to load file from: %s", path).Err()
         }
 
         return Parse(string(content), spec)
 }
 
 // Parse loads a specification message from a content string.
 func Parse(content string, spec *vpython.Spec) error {
         if err := cproto.UnmarshalTextML(content, spec); err != nil {
-                return errors.Annotate(err).Reason("failed to unmarshal vpython.Spec").Err()
+                return errors.Annotate(err, "failed to unmarshal vpython.Spec").Err()
         }
         return nil
 }
 
 // Loader implements the generic ability to load a "vpython" spec file.
 type Loader struct {
         // InlineBeginGuard is a string that signifies the beginning of an inline
         // specification. If empty, DefaultInlineBeginGuard will be used.
         InlineBeginGuard string
         // InlineEndGuard is a string that signifies the end of an inline
@@ skipping 81 matching lines @@
 // ======
 //
 // LoadForScript will examine successive parent directories starting from the
 // script's location, looking for a file named CommonName. If it finds one, it
 // will use that as the specification file. This enables scripts to implicitly
 // share an specification.
 func (l *Loader) LoadForScript(c context.Context, path string, isModule bool) (*vpython.Spec, error) {
         // Partner File: Try loading the spec from an adjacent file.
         specPath, err := l.findForScript(path, isModule)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to scan for filesystem spec").Err()
+                return nil, errors.Annotate(err, "failed to scan for filesystem spec").Err()
         }
         if specPath != "" {
                 var spec vpython.Spec
                 if err := Load(specPath, &spec); err != nil {
                         return nil, err
                 }
 
                 logging.Infof(c, "Loaded specification from: %s", specPath)
                 return &spec, nil
         }
 
         // Inline: Try and parse the main script for the spec file.
         mainScript := path
         if isModule {
                 // Module.
                 mainScript = filepath.Join(mainScript, "__main__.py")
         }
         switch spec, err := l.parseFrom(mainScript); {
         case err != nil:
-                return nil, errors.Annotate(err).Reason("failed to parse inline spec from: %(script)s").
-                        D("script", mainScript).
-                        Err()
+                return nil, errors.Annotate(err, "failed to parse inline spec from: %s", mainScript).Err()
 
         case spec != nil:
                 logging.Infof(c, "Loaded inline spec from: %s", mainScript)
                 return spec, nil
         }
 
         // Common: Try and identify a common specification file.
         switch path, err := l.findCommonWalkingFrom(filepath.Dir(mainScript)); {
         case err != nil:
                 return nil, err
@@ skipping 27 matching lines @@
         for {
                 prev := path
 
                 // Directory must be a Python module.
                 initPath := filepath.Join(path, "__init__.py")
                 if _, err := os.Stat(initPath); err != nil {
                         if os.IsNotExist(err) {
                                 // Not a Python module, so we're done our search.
                                 return "", nil
                         }
-                        return "", errors.Annotate(err).Reason("failed to stat for: %(path)").
-                                D("path", initPath).
-                                Err()
+                        return "", errors.Annotate(err, "failed to stat for: %s", path).Err()
                 }
 
                 // Does a spec file exist for this path?
                 specPath := path + Suffix
                 switch _, err := os.Stat(specPath); {
                 case err == nil:
                         // Found the file.
                         return specPath, nil
 
                 case os.IsNotExist(err):
                         // Recurse to parent.
                         path = filepath.Dir(path)
                         if path == prev {
                                 // Finished recursing, no ES file.
                                 return "", nil
                         }
 
                 default:
-                        return "", errors.Annotate(err).Reason("failed to check for spec file at: %(path)s").
-                                D("path", specPath).
-                                Err()
+                        return "", errors.Annotate(err, "failed to check for spec file at: %s", specPath).Err()
                 }
         }
 }
 
 func (l *Loader) parseFrom(path string) (*vpython.Spec, error) {
         fd, err := os.Open(path)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to open file").Err()
+                return nil, errors.Annotate(err, "failed to open file").Err()
         }
         defer fd.Close()
 
         // Determine our guards.
         beginGuard := l.InlineBeginGuard
         if beginGuard == "" {
                 beginGuard = DefaultInlineBeginGuard
         }
 
         endGuard := l.InlineEndGuard
@@ skipping 16 matching lines @@
                 } else {
                         if strings.HasSuffix(line, endGuard) {
                                 // Finished processing.
                                 endLine = line
                                 break
                         }
                         content = append(content, line)
                 }
         }
         if err := s.Err(); err != nil {
-                return nil, errors.Annotate(err).Reason("error scanning file").Err()
+                return nil, errors.Annotate(err, "error scanning file").Err()
         }
         if len(content) == 0 {
                 return nil, nil
         }
         if endLine == "" {
                 return nil, errors.New("unterminated inline spec file")
         }
 
         // If we have a common begin/end prefix, trim it from each content line that
         // also has it.
@@ skipping 13 matching lines @@
                         } else {
                                 line = strings.TrimPrefix(line, prefix)
                         }
                         content[i] = line
                 }
         }
 
         // Process the resulting file.
         var spec vpython.Spec
         if err := Parse(strings.Join(content, "\n"), &spec); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to parse spec file from: %(path)s").
-                        D("path", path).
-                        Err()
+                return nil, errors.Annotate(err, "failed to parse spec file from: %s", path).Err()
         }
         return &spec, nil
 }
 
 func (l *Loader) findCommonWalkingFrom(startDir string) (string, error) {
         // Walk until we hit root.
         prevDir := ""
         for prevDir != startDir {
                 checkPath := filepath.Join(startDir, CommonName)
 
                 switch _, err := os.Stat(checkPath); {
                 case err == nil:
                         return checkPath, nil
 
                 case filesystem.IsNotExist(err):
                         // Not in this directory.
 
                 default:
                         // Failed to load specification from this file.
-                        return "", errors.Annotate(err).Reason("failed to stat common spec file at: %(path)s").
-                                D("path", checkPath).
-                                Err()
+                        return "", errors.Annotate(err, "failed to stat common spec file at: %s", checkPath).Err()
                 }
 
                 // If we have any barrier files, check to see if they are present in this
                 // directory.
                 for _, name := range l.CommonFilesystemBarriers {
                         barrierName := filepath.Join(startDir, name)
                         if _, err := os.Stat(barrierName); err == nil {
                                 // Identified a barrier file in this directory.
                                 return "", nil
                         }
                 }
 
                 // Walk up a directory.
                 startDir, prevDir = filepath.Dir(startDir), startDir
         }
 
         // Couldn't find the file.
         return "", nil
 }