Unexpose "DockerfileMetadata" and add new exposed "DockerFroms" (since that's what's really necessary externally from that internal structure)

Author: tianon

go/src/bashbrew/cmd-build.go

@@ -44,12 +44,12 @@ func cmdBuild(c *cli.Context) error {
 				continue
 			}
 
-			meta, err := r.DockerfileMetadata(entry)
+			froms, err := r.DockerFroms(entry)
 			if err != nil {
 				return cli.NewMultiError(fmt.Errorf(`failed fetching/scraping FROM for %q (tags %q)`, r.RepoName, entry.TagsString()), err)
 			}
 
-			for _, from := range meta.Froms {
+			for _, from := range froms {
 				if from != "scratch" && pull != "never" {
 					doPull := false
 					switch pull {

go/src/bashbrew/cmd-deps.go

@@ -67,11 +67,11 @@ func cmdFamily(parents bool, c *cli.Context) error {
 				continue
 			}
 
-			meta, err := r.DockerfileMetadata(entry)
+			froms, err := r.DockerFroms(entry)
 			if err != nil {
 				return cli.NewMultiError(fmt.Errorf(`failed fetching/scraping FROM for %q (tags %q)`, r.RepoName, entry.TagsString()), err)
 			}
-			for _, from := range meta.Froms {
+			for _, from := range froms {
 				for _, tag := range r.Tags("", false, entry) {
 					network.AddEdge(from, tag)
 				}

go/src/bashbrew/cmd-from.go

@@ -28,14 +28,14 @@ func cmdFrom(c *cli.Context) error {
 				continue
 			}
 
-			meta, err := r.DockerfileMetadata(entry)
+			froms, err := r.DockerFroms(entry)
 			if err != nil {
 				return cli.NewMultiError(fmt.Errorf(`failed fetching/scraping FROM for %q (tags %q)`, r.RepoName, entry.TagsString()), err)
 			}
 
-			froms := strings.Join(meta.Froms, " ")
+			fromsString := strings.Join(froms, " ")
 			for _, tag := range r.Tags(namespace, uniq, entry) {
-				fmt.Printf("%s: %s\n", tag, froms)
+				fmt.Printf("%s: %s\n", tag, fromsString)
 			}
 		}
 	}

go/src/bashbrew/docker.go

@@ -17,7 +17,7 @@ import (
 	"github.com/docker-library/go-dockerlibrary/manifest"
 )
 
-type DockerfileMetadata struct {
+type dockerfileMetadata struct {
 	StageFroms []string              // every image "FROM" instruction value (or the parent stage's FROM value in the case of a named stage)
 	StageNames []string              // the name of any named stage (in order)
 	StageNameFroms map[string]string // map of stage names to FROM values (or the parent stage's FROM value in the case of a named stage), useful for resolving stage names to FROM values
@@ -30,21 +30,33 @@ func (r Repo) DockerFrom(entry *manifest.Manifest2822Entry) (string, error) {
 }
 
 func (r Repo) ArchDockerFrom(arch string, entry *manifest.Manifest2822Entry) (string, error) {
-	dockerfileMeta, err := r.ArchDockerfileMetadata(arch, entry)
+	dockerfileMeta, err := r.archDockerfileMetadata(arch, entry)
 	if err != nil {
 		return "", err
 	}
 
 	return dockerfileMeta.StageFroms[len(dockerfileMeta.StageFroms)-1], nil
 }
 
-func (r Repo) DockerfileMetadata(entry *manifest.Manifest2822Entry) (*DockerfileMetadata, error) {
-	return r.ArchDockerfileMetadata(arch, entry)
+func (r Repo) DockerFroms(entry *manifest.Manifest2822Entry) ([]string, error) {
+	return r.ArchDockerFroms(arch, entry)
 }
 
-var dockerfileMetadataCache = map[string]*DockerfileMetadata{}
+func (r Repo) ArchDockerFroms(arch string, entry *manifest.Manifest2822Entry) ([]string, error) {
+	dockerfileMeta, err := r.archDockerfileMetadata(arch, entry)
+	if err != nil {
+		return nil, err
+	}
+	return dockerfileMeta.Froms, nil
+}
+
+func (r Repo) dockerfileMetadata(entry *manifest.Manifest2822Entry) (*dockerfileMetadata, error) {
+	return r.archDockerfileMetadata(arch, entry)
+}
+
+var dockerfileMetadataCache = map[string]*dockerfileMetadata{}
 
-func (r Repo) ArchDockerfileMetadata(arch string, entry *manifest.Manifest2822Entry) (*DockerfileMetadata, error) {
+func (r Repo) archDockerfileMetadata(arch string, entry *manifest.Manifest2822Entry) (*dockerfileMetadata, error) {
 	commit, err := r.fetchGitRepo(arch, entry)
 	if err != nil {
 		return nil, err
@@ -79,8 +91,8 @@ func (r Repo) ArchDockerfileMetadata(arch string, entry *manifest.Manifest2822En
 	return meta, nil
 }
 
-func parseDockerfileMetadata(dockerfile io.Reader) (*DockerfileMetadata, error) {
-	meta := &DockerfileMetadata{
+func parseDockerfileMetadata(dockerfile io.Reader) (*dockerfileMetadata, error) {
+	meta := &dockerfileMetadata{
 		// panic: assignment to entry in nil map
 		StageNameFroms: map[string]string{},
 		// (nil slices work fine)
@@ -215,7 +227,7 @@ func (r Repo) dockerBuildUniqueBits(entry *manifest.Manifest2822Entry) ([]string
 		entry.ArchDirectory(arch),
 		entry.ArchFile(arch),
 	}
-	meta, err := r.DockerfileMetadata(entry)
+	meta, err := r.dockerfileMetadata(entry)
 	if err != nil {
 		return nil, err
 	}

go/src/bashbrew/sort.go

@@ -101,12 +101,12 @@ func sortRepoObjects(rs []*Repo, applyConstraints bool) ([]*Repo, error) {
 				continue
 			}
 
-			meta, err := r.DockerfileMetadata(entry)
+			froms, err := r.DockerFroms(entry)
 			if err != nil {
 				return nil, err
 			}
 
-			for _, from := range meta.Froms {
+			for _, from := range froms {
 				fromNode, ok := canonicalNodes[from]
 				if !ok {
 					// if our FROM isn't in the list of things we're sorting, it isn't relevant in this context