cipd: Refactor client to make it more readable.

go/src/infra/tools/cipd/local/pkgdef.go

 // Copyright 2015 The Chromium 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 cipd
+package local
 
 import (
         "fmt"
         "io"
         "io/ioutil"
         "path/filepath"
         "regexp"
         "sort"
 
         "github.com/go-yaml/yaml"
+
+        "infra/tools/cipd/common"
 )
 
 // PackageDef defines how exactly to build a package: what files to put into it,
 // how to name them, how to name the package itself, etc. It is loaded from
 // *.yaml file.
 type PackageDef struct {
         // Package defines a name of the package.
         Package string
         // Root defines where to search for files, relative to package file itself.
         Root string
@@ skipping 28 matching lines @@
 
         // Substitute variables in all strings.
         for _, str := range out.strings() {
                 *str, err = subVars(*str, vars)
                 if err != nil {
                         return
                 }
         }
 
         // Validate package name right away.
-        err = ValidatePackageName(out.Package)
+        err = common.ValidatePackageName(out.Package)
         if err != nil {
                 return
         }
 
         // Make sure "file" or "dir" are used, but not both.
         for i, chunk := range out.Data {
                 if chunk.File == "" && chunk.Dir == "" {
                         return out, fmt.Errorf("files entry #%d needs 'file' or 'dir' key", i)
                 }
                 if chunk.File != "" && chunk.Dir != "" {
@@ skipping 26 matching lines @@
         }
 
         // Used to skip duplicates.
         seen := map[string]File{}
         add := func(f File) {
                 if seen[f.Name()] == nil {
                         seen[f.Name()] = f
                 }
         }
 
-        log.Info("Enumerating files to zip...")
+        log.Infof("Enumerating files to zip...")
         for _, chunk := range def.Data {
                 // Individual file.
                 if chunk.File != "" {
                         file, err := WrapFile(makeAbs(chunk.File), root, nil)
                         if err != nil {
                                 return nil, err
                         }
                         add(file)
                         continue
                 }
@@ skipping 62 matching lines @@
                 re, err := regexp.Compile(expr)
                 if err != nil {
                         return nil, err
                 }
                 exps = append(exps, re)
         }
 
         return func(abs string) bool {
                 rel, err := filepath.Rel(startDir, abs)
                 if err != nil {
-                        log.Warnf("Unexpected error when evaluating %s: %s", abs, err)
+                        log.Warningf("Unexpected error when evaluating %s: %s", abs, err)
                         return true
                 }
                 // Do not evaluate paths outside of startDir.
                 rel = filepath.ToSlash(rel)
                 if rel[:3] == "../" {
                         return false
                 }
                 for _, exp := range exps {
                         if exp.MatchString(rel) {
                                 return true
@@ skipping 47 matching lines @@
                         badKeys = append(badKeys, key)
                         return match
                 }
                 return val
         })
         if len(badKeys) != 0 {
                 return res, fmt.Errorf("Values for some variables are not provided: %v", badKeys)
         }
         return res, nil
 }