[vpython] Add conditional packages based on PEP425

vpython/application/subcommand_verify.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 application
 
 import (
         "strings"
 
         "github.com/maruel/subcommands"
@@ skipping 24 matching lines @@
 
 func (cr *verifyCommandRun) Run(app subcommands.Application, args []string, env subcommands.Env) int {
         c := cli.GetContext(app, cr, env)
         a := getApplication(c, args)
 
         return run(c, func(c context.Context) error {
                 // Make sure that we can resolve the referenced specifiction.
                 if err := a.opts.ResolveSpec(c); err != nil {
                         return errors.Annotate(err).Reason("failed to resolve specification").Err()
                 }
-                if a.opts.EnvConfig.Spec.Virtualenv == nil {
-                        a.opts.EnvConfig.Spec.Virtualenv = &a.opts.EnvConfig.Package
+
+                s := a.opts.EnvConfig.Spec
+                if s == nil {
+                        s = &vpython.Spec{}
                 }
-                if err := spec.NormalizeSpec(a.opts.EnvConfig.Spec); err != nil {
+                if s.Virtualenv == nil {
+                        s.Virtualenv = &a.opts.EnvConfig.Package
+                }
+
+                // Verify that the spec can be normalized. This may modify it, so we will
+                // normalizse a clone.

[qyearsley, 2017/06/05 20:20:08]

Nit: spelling

[dnj, 2017/06/06 13:59:10]

Done.

+                if err := spec.NormalizeSpec(s.Clone(), nil); err != nil {
                         return errors.Annotate(err).Reason("failed to normalize specification").Err()
                 }
-                s := a.opts.EnvConfig.Spec
+
                 renderedSpec := spec.Render(s)
                 logging.Infof(c, "Successfully verified specification:\n%s", renderedSpec)
 
                 // Run our Verification generator and verify each generated environment.
                 if a.WithVerificationConfig != nil {
                         err := a.WithVerificationConfig(c, func(cfg Config, verificationScenarios []*vpython.Pep425Tag) error {
                                 if len(s.VerifyPep425Tag) > 0 {
                                         verificationScenarios = s.VerifyPep425Tag
                                 }
                                 if len(verificationScenarios) == 0 {
                                         return nil
                                 }
 
                                 var failures []string
                                 for _, vs := range verificationScenarios {
                                         // Create a verification environment to pass to our package loader.
                                         e := vpython.Environment{
                                                 Spec:      s.Clone(),
                                                 Pep425Tag: []*vpython.Pep425Tag{vs},
                                         }
+                                        if err := spec.NormalizeEnvironment(&e); err != nil {
+                                                logging.Errorf(c, "Failed to normalize environment against %q: %s", vs.TagString(), err)
+                                                failures = append(failures, vs.TagString())
+                                                continue
+                                        }
 
                                         if err := cfg.PackageLoader.Resolve(c, &e); err != nil {
                                                 logging.Errorf(c, "Failed to resolve against %q: %s", vs.TagString(), err)
                                                 failures = append(failures, vs.TagString())
                                         }
                                 }
 
                                 if len(failures) > 0 {
                                         logging.Errorf(c, "Verification failed for %d scenario(s): %s\n%s",
                                                 len(failures), strings.Join(failures, ", "), renderedSpec)
                                         return errors.New("verification failed")
                                 }
 
                                 logging.Infof(c, "Verified %d scenario(s).", len(verificationScenarios))
                                 return nil
                         })
                         if err != nil {
                                 return err
                         }
                 }
 
                 return nil
         })
 }