New upstream version 0.0~git20180827.d94f0cb

Author: toddy15

description.go

@@ -2,22 +2,14 @@ package main
 
 import (
 	"bytes"
-	"encoding/base64"
-	"encoding/json"
+	"context"
 	"fmt"
-	"net/http"
 	"os/exec"
 	"strings"
 
 	"github.com/russross/blackfriday"
 )
 
-type readmeReply struct {
-	Content  string `json:"content"`
-	Encoding string `json:"encoding"`
-	Name     string `json:"name"`
-}
-
 func reformatForControl(raw string) string {
 	// Reformat the wrapped description to conform to Debian’s control format.
 	for strings.Contains(raw, "\n\n") {
@@ -30,26 +22,18 @@ func getLongDescriptionForGopkg(gopkg string) (string, error) {
 	if !strings.HasPrefix(gopkg, "github.com/") {
 		return "", nil
 	}
-	resp, err := http.Get("https://api.github.com/repos/" + gopkg[len("github.com/"):] + "/readme")
-	if err != nil {
-		return "", err
+	parts := strings.Split(strings.TrimPrefix(gopkg, "github.com/"), "/")
+	if got, want := len(parts), 2; got != want {
+		return "", fmt.Errorf("invalid GitHub repo: %q does not follow github.com/owner/repo", gopkg)
 	}
-	defer resp.Body.Close()
+	owner, repo := parts[0], parts[1]
 
-	if resp.StatusCode != http.StatusOK {
-		return "", fmt.Errorf("unexpected HTTP status: got %d, want %d", resp.StatusCode, http.StatusOK)
-	}
-
-	var rr readmeReply
-	if err := json.NewDecoder(resp.Body).Decode(&rr); err != nil {
+	rr, _, err := gitHub.Repositories.GetReadme(context.TODO(), owner, repo, nil)
+	if err != nil {
 		return "", err
 	}
 
-	if rr.Encoding != "base64" {
-		return "", fmt.Errorf("unexpected encoding: got %q, want %q", rr.Encoding, "base64")
-	}
-
-	content, err := base64.StdEncoding.DecodeString(rr.Content)
+	content, err := rr.GetContent()
 	if err != nil {
 		return "", err
 	}
@@ -61,14 +45,14 @@ func getLongDescriptionForGopkg(gopkg string) (string, error) {
 	// fairly involved, but it’d be the most correct solution to the problem at
 	// hand. Our current code just knows markdown, which is good enough since
 	// most (Go?) projects in fact use markdown for their README files.
-	if !strings.HasSuffix(rr.Name, "md") &&
-		!strings.HasSuffix(rr.Name, "markdown") &&
-		!strings.HasSuffix(rr.Name, "mdown") &&
-		!strings.HasSuffix(rr.Name, "mkdn") {
+	if !strings.HasSuffix(rr.GetName(), "md") &&
+		!strings.HasSuffix(rr.GetName(), "markdown") &&
+		!strings.HasSuffix(rr.GetName(), "mdown") &&
+		!strings.HasSuffix(rr.GetName(), "mkdn") {
 		return reformatForControl(strings.TrimSpace(string(content))), nil
 	}
 
-	output := blackfriday.Markdown(content, &TextRenderer{}, 0)
+	output := blackfriday.Markdown([]byte(content), &TextRenderer{}, 0)
 	// Shell out to fmt(1) to line-wrap the output.
 	cmd := exec.Command("fmt")
 	cmd.Stdin = bytes.NewBuffer(output)

estimate.go

@@ -3,14 +3,17 @@ package main
 import (
 	"flag"
 	"fmt"
+	"go/build"
 	"io/ioutil"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"sort"
 	"strings"
 
 	"golang.org/x/tools/go/vcs"
+	"golang.org/x/tools/refactor/importgraph"
 )
 
 func get(gopath, repo string) error {
@@ -77,72 +80,94 @@ func estimate(importpath string) error {
 		}
 	}
 
-	// Use digraph(1) to obtain the forward transitive closure of the repo in
-	// question.
-	cmd := exec.Command("/bin/sh", "-c", "go list -f '{{.ImportPath}}{{.Imports}}{{.TestImports}}{{.XTestImports}}' ... | tr '[]' ' ' | digraph forward $(go list "+importpath+"/...)")
+	// Remove standard lib packages
+	cmd := exec.Command("go", "list", "std")
 	cmd.Stderr = os.Stderr
 	cmd.Env = append([]string{
 		fmt.Sprintf("GOPATH=%s", gopath),
 	}, passthroughEnv()...)
+
 	out, err := cmd.Output()
 	if err != nil {
 		return fmt.Errorf("%v: %v", cmd.Args, err)
 	}
-
-	closure := make(map[string]bool)
+	stdlib := make(map[string]bool)
 	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-		closure[line] = true
+		stdlib[line] = true
 	}
 
-	// Remove standard lib packages
-	cmd = exec.Command("go", "list", "std")
-	cmd.Stderr = os.Stderr
-	cmd.Env = append([]string{
-		fmt.Sprintf("GOPATH=%s", gopath),
-	}, passthroughEnv()...)
+	stdlib["C"] = true // would fail resolving anyway
 
-	out, err = cmd.Output()
+	// Filter out all already-packaged ones:
+	golangBinaries, err := getGolangBinaries()
 	if err != nil {
-		return fmt.Errorf("%v: %v", cmd.Args, err)
-	}
-	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-		delete(closure, line)
+		return nil
 	}
 
-	delete(closure, "C") // would fail resolving anyway
+	build.Default.GOPATH = gopath
+	forward, _, errors := importgraph.Build(&build.Default)
+	if len(errors) > 0 {
+		lines := make([]string, 0, len(errors))
+		for importPath, err := range errors {
+			lines = append(lines, fmt.Sprintf("%s: %v", importPath, err))
+		}
+		return fmt.Errorf("could not load packages: %v", strings.Join(lines, "\n"))
+	}
 
-	// Resolve all packages to the root of their repository.
-	roots := make(map[string]bool)
-	for dep := range closure {
-		rr, err := vcs.RepoRootForImportPath(dep, false)
+	var lines []string
+	seen := make(map[string]bool)
+	rrseen := make(map[string]bool)
+	node := func(importPath string, indent int) {
+		rr, err := vcs.RepoRootForImportPath(importPath, false)
 		if err != nil {
-			log.Printf("Could not determine repo path for import path %q: %v\n", dep, err)
-			continue
+			log.Printf("Could not determine repo path for import path %q: %v\n", importPath, err)
+			return
 		}
-
-		roots[rr.Root] = true
+		if rrseen[rr.Root] {
+			return
+		}
+		rrseen[rr.Root] = true
+		if _, ok := golangBinaries[rr.Root]; ok {
+			return // already packaged in Debian
+		}
+		lines = append(lines, fmt.Sprintf("%s%s", strings.Repeat("  ", indent), rr.Root))
 	}
-
-	// Filter out all already-packaged ones:
-	golangBinaries, err := getGolangBinaries()
-	if err != nil {
-		return nil
+	var visit func(x string, indent int)
+	visit = func(x string, indent int) {
+		if seen[x] {
+			return
+		}
+		seen[x] = true
+		if !stdlib[x] {
+			node(x, indent)
+		}
+		for y := range forward[x] {
+			visit(y, indent+1)
+		}
 	}
 
-	for importpath, binary := range golangBinaries {
-		if roots[importpath] {
-			log.Printf("found %s in Debian package %s", importpath, binary)
-			delete(roots, importpath)
+	keys := make([]string, 0, len(forward))
+	for key := range forward {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		if !strings.HasPrefix(key, importpath) {
+			continue
+		}
+		if seen[key] {
+			continue // already covered in a previous visit call
 		}
+		visit(key, 0)
 	}
 
-	if len(roots) == 0 {
+	if len(lines) == 0 {
 		log.Printf("%s is already fully packaged in Debian", importpath)
 		return nil
 	}
 	log.Printf("Bringing %s to Debian requires packaging the following Go packages:", importpath)
-	for importpath := range roots {
-		fmt.Println(importpath)
+	for _, line := range lines {
+		fmt.Println(line)
 	}
 
 	return nil

main.go

@@ -3,6 +3,13 @@ package main
 import (
 	"fmt"
 	"os"
+
+	"github.com/google/go-github/github"
+	"github.com/gregjones/httpcache"
+)
+
+var (
+	gitHub *github.Client
 )
 
 func usage() {
@@ -19,6 +26,14 @@ func usage() {
 }
 
 func main() {
+	transport := github.BasicAuthTransport{
+		Username:  os.Getenv("GITHUB_USERNAME"),
+		Password:  os.Getenv("GITHUB_PASSWORD"),
+		OTP:       os.Getenv("GITHUB_OTP"),
+		Transport: httpcache.NewMemoryCacheTransport(),
+	}
+	gitHub = github.NewClient(transport.Client())
+
 	// Retrieve args and Shift binary name off argument list.
 	args := os.Args[1:]
 

make.go

@@ -410,6 +410,8 @@ func debianNameFromGopkg(gopkg, t string, allowUnknownHoster bool) string {
 		host = "howett"
 	} else if host == "go4.org" {
 		host = "go4"
+	} else if host == "salsa.debian.org" {
+		host = "debian"
 	} else {
 		if allowUnknownHoster {
 			suffix, _ := publicsuffix.PublicSuffix(host)
@@ -489,12 +491,12 @@ func writeTemplates(dir, gopkg, debsrc, debbin, debversion, pkgType string, depe
 	// TODO: change this once we have a “golang” section.
 	fmt.Fprintf(f, "Section: devel\n")
 	fmt.Fprintf(f, "Priority: optional\n")
-	fmt.Fprintf(f, "Maintainer: Debian Go Packaging Team <pkg-go[email protected].debian.org>\n")
+	fmt.Fprintf(f, "Maintainer: Debian Go Packaging Team <team+pkg-go@tracker.debian.org>\n")
 	fmt.Fprintf(f, "Uploaders: %s <%s>\n", getDebianName(), getDebianEmail())
 	sort.Strings(dependencies)
 	builddeps := append([]string{"debhelper (>= 11)", "dh-golang", "golang-any"}, dependencies...)
 	fmt.Fprintf(f, "Build-Depends: %s\n", strings.Join(builddeps, ",\n               "))
-	fmt.Fprintf(f, "Standards-Version: 4.1.4\n")
+	fmt.Fprintf(f, "Standards-Version: 4.2.1\n")
 	fmt.Fprintf(f, "Homepage: %s\n", getHomepageForGopkg(gopkg))
 	fmt.Fprintf(f, "Vcs-Browser: https://salsa.debian.org/go-team/packages/%s\n", debsrc)
 	fmt.Fprintf(f, "Vcs-Git: https://salsa.debian.org/go-team/packages/%s.git\n", debsrc)
@@ -572,6 +574,7 @@ func writeTemplates(dir, gopkg, debsrc, debbin, debversion, pkgType string, depe
 	if pkgType == "program" {
 		fmt.Fprintf(f, "override_dh_auto_install:\n")
 		fmt.Fprintf(f, "\tdh_auto_install -- --no-source\n")
+		fmt.Fprintf(f, "\n")
 	}
 	fmt.Fprintf(f, "%%:\n")
 	fmt.Fprintf(f, "\tdh $@ --buildsystem=golang --with=golang\n")
@@ -601,7 +604,7 @@ func writeTemplates(dir, gopkg, debsrc, debbin, debversion, pkgType string, depe
 			return err
 		}
 		defer f.Close()
-		fmt.Fprintf(f, "version=3\n")
+		fmt.Fprintf(f, "version=4\n")
 		fmt.Fprintf(f, `opts=filenamemangle=s/.+\/v?(\d\S*)\.tar\.gz/%s-\$1\.tar\.gz/,\`+"\n", debsrc)
 		fmt.Fprintf(f, `uversionmangle=s/(\d)[_\.\-\+]?(RC|rc|pre|dev|beta|alpha)[.]?(\d*)$/\$1~\$2\$3/ \`+"\n")
 		fmt.Fprintf(f, `  https://%s/tags .*/v?(\d\S*)\.tar\.gz`+"\n", gopkg)
@@ -642,7 +645,7 @@ func writeITP(gopkg, debsrc, debversion string) (string, error) {
 	fmt.Fprintf(f, "Subject: ITP: %s -- %s\n", debsrc, description)
 	fmt.Fprintf(f, "Content-Type: text/plain; charset=utf-8\n")
 	fmt.Fprintf(f, "Content-Transfer-Encoding: 8bit\n")
-	fmt.Fprintf(f, "X-Debbugs-CC: [email protected], pkg-go-maintainers@lists.alioth.debian.org\n")
+	fmt.Fprintf(f, "X-Debbugs-CC: [email protected], debian[email protected]\n")
 	fmt.Fprintf(f, "\n")
 	fmt.Fprintf(f, "Package: wnpp\n")
 	fmt.Fprintf(f, "Severity: wishlist\n")
@@ -713,7 +716,7 @@ func execMake(args []string, usage func()) {
 	fs.BoolVar(&allowUnknownHoster,
 		"allow_unknown_hoster",
 		false,
-		"The pkg-go naming conventions (see https://pkg-go.alioth.debian.org/packaging.html) use a canonical identifier for the hostname, and the mapping is hardcoded into dh-make-golang. In case you want to package a Go package living on an unknown hoster, you may set this flag to true and double-check that the resulting package name is sane. Contact pkg-go if unsure.")
+		"The pkg-go naming conventions (see https://go-team.pages.debian.net/packaging.html) use a canonical identifier for the hostname, and the mapping is hardcoded into dh-make-golang. In case you want to package a Go package living on an unknown hoster, you may set this flag to true and double-check that the resulting package name is sane. Contact pkg-go if unsure.")
 
 	var pkgType string
 	fs.StringVar(&pkgType,

make_test.go

@@ -17,7 +17,7 @@ func TestAcceptInput(t *testing.T) {
 	for _, tt := range shortName {
 		in := normalizeDebianProgramName(tt.in)
 		if in != tt.out {
-			t.Errorf("userInput(%q) => %q, want %q", tt.in, tt.out)
+			t.Errorf("userInput(%q) => %q, want %q", tt.in, in, tt.out)
 		}
 	}
 }
@@ -39,7 +39,7 @@ func TestNormalizeDebianProgramName(t *testing.T) {
 	for _, tt := range miscName {
 		s := normalizeDebianProgramName(tt.in)
 		if s != tt.out {
-			t.Errorf("normalizeDebianProgramName(%q) => %q, want %q", tt.in, tt.out)
+			t.Errorf("normalizeDebianProgramName(%q) => %q, want %q", tt.in, s, tt.out)
 		}
 	}
 }