Parse build tags and scan a package based on those

dependency/scan.go

diff --git a/dependency/scan.go b/dependency/scan.go
index 5b99858..1b5ac65 100644
--- a/dependency/scan.go
+++ b/dependency/scan.go
@@ -1,7 +1,12 @@
 package dependency
 
 import (
+	"bytes"
+	"io"
+	"os"
+	"path/filepath"
 	"strings"
+	"text/scanner"
 
 	"github.com/Masterminds/glide/msg"
 	"github.com/Masterminds/glide/util"
@@ -32,40 +37,242 @@
 // of ignore. This is a bit of a hack. It causes UseAllFiles to have errors.
 func IterativeScan(path string) ([]string, error) {
 
+	// TODO(mattfarina): Add support for release tags.
+
+	tgs, _ := readBuildTags(path)
+	// Handle the case of scanning with no tags
+	tgs = append(tgs, "")
+
 	var pkgs []string
-	for _, o := range osList {
-		for _, a := range archList {
-			b, err := util.GetBuildContext()
-			if err != nil {
-				return []string{}, err
+	for _, tt := range tgs {
+
+		// split the tag combination to look at permutations.
+		ts := strings.Split(tt, ",")
+		var ttgs []string
+		var arch string
+		var ops string
+		for _, ttt := range ts {
+			dirty := false
+			if strings.HasPrefix(ttt, "!") {
+				dirty = true
+				ttt = strings.TrimPrefix(ttt, "!")
 			}
-
-			// Make sure use all files is off
-			b.UseAllFiles = false
-
-			// Set the OS and Arch for this pass
-			b.GOARCH = a
-			b.GOOS = o
-
-			pk, err := b.ImportDir(path, 0)
-			if err != nil {
-				msg.Debug("Problem parsing package at %s for %s %s", path, o, a)
-				return []string{}, err
+			if isSupportedOs(ttt) {
+				if dirty {
+					ops = getOsValue(ttt)
+				} else {
+					ops = ttt
+				}
+			} else if isSupportedArch(ttt) {
+				if dirty {
+					arch = getArchValue(ttt)
+				} else {
+					arch = ttt
+				}
+			} else {
+				if !dirty {
+					ttgs = append(ttgs, ttt)
+				}
 			}
+		}
 
-			for _, dep := range pk.Imports {
-				found := false
-				for _, p := range pkgs {
-					if p == dep {
-						found = true
-					}
+		// Handle the case where there are no tags but we need to iterate
+		// on something.
+		if len(ttgs) == 0 {
+			ttgs = append(ttgs, "")
+		}
+
+		b, err := util.GetBuildContext()
+		if err != nil {
+			return []string{}, err
+		}
+
+		// Make sure use all files is off
+		b.UseAllFiles = false
+
+		// Set the OS and Arch for this pass
+		b.GOARCH = arch
+		b.GOOS = ops
+		b.BuildTags = ttgs
+		msg.Debug("Scanning with Arch(%s), OS(%s), and Build Tags(%v)", arch, ops, ttgs)
+
+		pk, err := b.ImportDir(path, 0)
+		if err != nil && strings.HasPrefix(err.Error(), "no buildable Go source files in") {
+			continue
+		} else if err != nil {
+			msg.Debug("Problem parsing package at %s for %s %s", path, ops, arch)
+			return []string{}, err
+		}
+
+		for _, dep := range pk.Imports {
+			found := false
+			for _, p := range pkgs {
+				if p == dep {
+					found = true
 				}
-				if !found {
-					pkgs = append(pkgs, dep)
-				}
+			}
+			if !found {
+				pkgs = append(pkgs, dep)
 			}
 		}
 	}
 
 	return pkgs, nil
 }
+
+func readBuildTags(p string) ([]string, error) {
+	_, err := os.Stat(p)
+	if err != nil {
+		return []string{}, err
+	}
+
+	d, err := os.Open(p)
+	if err != nil {
+		return []string{}, err
+	}
+
+	objects, err := d.Readdir(-1)
+	if err != nil {
+		return []string{}, err
+	}
+
+	var tags []string
+	for _, obj := range objects {
+
+		// only process Go files
+		if strings.HasSuffix(obj.Name(), ".go") {
+			fp := filepath.Join(p, obj.Name())
+
+			co, err := readGoContents(fp)
+			if err != nil {
+				return []string{}, err
+			}
+
+			// Only look at places where we had a code comment.
+			if len(co) > 0 {
+				t := findTags(co)
+				for _, tg := range t {
+					found := false
+					for _, tt := range tags {
+						if tt == tg {
+							found = true
+						}
+					}
+					if !found {
+						tags = append(tags, tg)
+					}
+				}
+			}
+		}
+	}
+
+	return tags, nil
+}
+
+// Read contents of a Go file up to the package declaration. This can be used
+// to find the the build tags.
+func readGoContents(fp string) ([]byte, error) {
+	f, err := os.Open(fp)
+	defer f.Close()
+	if err != nil {
+		return []byte{}, err
+	}
+
+	var s scanner.Scanner
+	s.Init(f)
+	var tok rune
+	var pos scanner.Position
+	for tok != scanner.EOF {
+		tok = s.Scan()
+
+		// Getting the token text will skip comments by default.
+		tt := s.TokenText()
+		// build tags will not be after the package declaration.
+		if tt == "package" {
+			pos = s.Position
+			break
+		}
+	}
+
+	buf := bytes.NewBufferString("")
+	f.Seek(0, 0)
+	_, err = io.CopyN(buf, f, int64(pos.Offset))
+	if err != nil {
+		return []byte{}, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// From a byte slice of a Go file find the tags.
+func findTags(co []byte) []string {
+	p := co
+	var tgs []string
+	for len(p) > 0 {
+		line := p
+		if i := bytes.IndexByte(line, '\n'); i >= 0 {
+			line, p = line[:i], p[i+1:]
+		} else {
+			p = p[len(p):]
+		}
+		line = bytes.TrimSpace(line)
+		// Only look at comment lines that are well formed in the Go style
+		if bytes.HasPrefix(line, []byte("//")) {
+			line = bytes.TrimSpace(line[len([]byte("//")):])
+			if len(line) > 0 && line[0] == '+' {
+				f := strings.Fields(string(line))
+
+				// We've found a +build tag line.
+				if f[0] == "+build" {
+					for _, tg := range f[1:] {
+						tgs = append(tgs, tg)
+					}
+				}
+			}
+		}
+	}
+
+	return tgs
+}
+
+// Get an OS value that's not the one passed in.
+func getOsValue(n string) string {
+	for _, o := range osList {
+		if o != n {
+			return o
+		}
+	}
+
+	return n
+}
+
+func isSupportedOs(n string) bool {
+	for _, o := range osList {
+		if o == n {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Get an Arch value that's not the one passed in.
+func getArchValue(n string) string {
+	for _, o := range archList {
+		if o != n {
+			return o
+		}
+	}
+
+	return n
+}
+
+func isSupportedArch(n string) bool {
+	for _, o := range archList {
+		if o == n {
+			return true
+		}
+	}
+
+	return false
+}