[vpython] Add conditional packages based on PEP425

vpython/spec/match.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 (
+        "github.com/luci/luci-go/vpython/api/vpython"
+)
+
+// PackageMatches returns true if any of the match qualifiers in the supplied
+// package match the supplied PEP425 tags.

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

... match any of the supplied PEP425 tags.

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

Done.

+//
+// As a special case, if the package doesn't specify any match tags, it will
+// always match regardless of the supplied PEP425 tags.
+//
+// See PEP425Matches for more information.
+func PackageMatches(pkg *vpython.Spec_Package, tags []*vpython.Pep425Tag) bool {
+        if len(pkg.MatchTag) == 0 {
+                return true
+        }
+
+        for _, matchTag := range pkg.MatchTag {
+                if PEP425Matches(matchTag, tags) {
+                        return true
+                }
+        }
+        return false
+}
+
+// PEP425Matches returns true if match matches at least one of the tags in tags.
+//
+// A match is determined if the non-zero fields in match equal the equivalent
+// fields in a tag.
+func PEP425Matches(match *vpython.Pep425Tag, tags []*vpython.Pep425Tag) bool {

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

For consistency, this could be called Pep425Matches (since the type is called
Pep425Tag).

Also, I'm new to Go -- should the types of the arguments in this type
declaration be interpreted as "pointer to vpython.Pep425Tag" and "pointer to a
slice of vpython.Pep425Tag"?

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

The type is called "Pep425Tag" b/c it is derived from a protobuf message, and
protobuf naming practices dictate not uppercasing acronyms. However, the
preferred way to express it in Go naming is to keep acronyms capitalized, so I'm
doing that where possible in the Go code.

[]*vpython.Pep425Tag is "Slice of pointers to Pep425Tag".

+        // Special case: empty match matches nothing.
+        if match.IsZero() {
+                return false
+        }
+
+        for _, tag := range tags {
+                if v := match.Version; v != "" && tag.Version != v {
+                        continue
+                }
+                if v := match.Abi; v != "" && tag.Abi != v {
+                        continue
+                }
+                if v := match.Arch; v != "" && tag.Arch != v {
+                        continue

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

Another Go question:

Is this equivalent to:


		if match.Version != "" && tag.Version != match.Version {
			continue
		}
		if match.Abi != "" && tag.Abi != match.Abi {
			continue
		}
		if match.Arch != "" && tag.Arch != match.Arch {
			continue
		}

I'm not sure what's conventional, but it might also make sense to use variable
names like `ver`, `abi`, `arch` instead of `v` for all of them.

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

Yes. Idiomatic Go is pretty cool with abbreviated names. Since it's scoped to a
single line, it's concise enough that I actually prefer the consistency in
naming ("v" everywhere) over matching fields.

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

Yes. Idiomatic Go is pretty cool with abbreviated names. Since it's scoped to a
single line, it's concise enough that I actually prefer the consistency in
naming ("v" everywhere) over matching fields.

+                }
+                return true
+        }
+
+        return false
+}