New upstream version 0.3.0

Author: anthonyfok

make.go

@@ -102,15 +102,18 @@ func downloadFile(filename, url string) error {
 
 // upstream describes the upstream repo we are about to package.
 type upstream struct {
+	rr          *vcs.RepoRoot
 	tarPath     string   // path to the downloaded or generated orig tarball tempfile
 	compression string   // compression method, either "gz" or "xz"
 	version     string   // Debian package upstream version number, e.g. 0.0~git20180204.1d24609
+	commitIsh   string   // commit-ish corresponding to upstream version to be packaged
+	remote      string   // git remote, set to short hostname if upstream git history is included
 	firstMain   string   // import path of the first main package within repo, if any
 	vendorDirs  []string // all vendor sub directories, relative to the repo directory
 	repoDeps    []string // the repository paths of all dependencies (e.g. github.com/zyedidia/glob)
 	hasGodeps   bool     // whether the Godeps/_workspace directory exists
 	hasRelease  bool     // whether any release tags exist, for debian/watch
-	isRelease   bool     // whether we are packaging a tagged version or not
+	isRelease   bool     // whether what we end up packaging is a tagged release
 }
 
 func (u *upstream) get(gopath, repo, rev string) error {
@@ -122,6 +125,7 @@ func (u *upstream) get(gopath, repo, rev string) error {
 	if err != nil {
 		return err
 	}
+	u.rr = rr
 	dir := filepath.Join(gopath, "src", rr.Root)
 	if rev != "" {
 		return rr.VCS.CreateAtRev(dir, rr.Repo, rev)
@@ -341,7 +345,7 @@ func makeUpstreamSourceTarball(repo, revision string, forcePrerelease bool) (*up
 
 	log.Printf("Determining upstream version number\n")
 
-	u.version, u.hasRelease, u.isRelease, err = pkgVersionFromGit(repoDir, forcePrerelease)
+	u.version, err = pkgVersionFromGit(repoDir, &u, forcePrerelease)
 	if err != nil {
 		return nil, err
 	}
@@ -370,7 +374,8 @@ func runGitCommandIn(dir string, arg ...string) error {
 	return cmd.Run()
 }
 
-func createGitRepository(debsrc, gopkg, orig string, dep14, pristineTar bool) (string, error) {
+func createGitRepository(debsrc, gopkg, orig string, u *upstream,
+	includeUpstreamHistory, allowUnknownHoster, dep14, pristineTar bool) (string, error) {
 	wd, err := os.Getwd()
 	if err != nil {
 		return "", err
@@ -412,6 +417,21 @@ func createGitRepository(debsrc, gopkg, orig string, dep14, pristineTar bool) (s
 		return dir, err
 	}
 
+	if includeUpstreamHistory {
+		u.remote, err = shortHostName(gopkg, allowUnknownHoster)
+		if err != nil {
+			return dir, fmt.Errorf("Unable to fetch upstream history: %q", err)
+		}
+		log.Printf("Adding %q as remote %q\n", u.rr.Repo, u.remote)
+		if err := runGitCommandIn(dir, "remote", "add", u.remote, u.rr.Repo); err != nil {
+			return dir, err
+		}
+		log.Printf("Running \"git fetch %s\"\n", u.remote)
+		if err := runGitCommandIn(dir, "fetch", u.remote); err != nil {
+			return dir, err
+		}
+	}
+
 	// Import upstream orig tarball
 
 	arg := []string{"import-orig", "--no-interactive"}
@@ -421,6 +441,9 @@ func createGitRepository(debsrc, gopkg, orig string, dep14, pristineTar bool) (s
 	if pristineTar {
 		arg = append(arg, "--pristine-tar")
 	}
+	if includeUpstreamHistory {
+		arg = append(arg, "--upstream-vcs-tag="+u.commitIsh)
+	}
 	arg = append(arg, filepath.Join(wd, orig))
 	cmd := exec.Command("gbp", arg...)
 	cmd.Dir = dir
@@ -484,16 +507,11 @@ func normalizeDebianProgramName(str string) string {
 	return safe
 }
 
-// This follows https://fedoraproject.org/wiki/PackagingDrafts/Go#Package_Names
-func debianNameFromGopkg(gopkg string, t packageType, allowUnknownHoster bool) string {
+func shortHostName(gopkg string, allowUnknownHoster bool) (host string, err error) {
 	parts := strings.Split(gopkg, "/")
+	fqdn := parts[0]
 
-	if t == typeProgram || t == typeProgramLibrary {
-		return normalizeDebianProgramName(parts[len(parts)-1])
-	}
-
-	host := parts[0]
-	switch host {
+	switch fqdn {
 	case "github.com":
 		host = "github"
 	case "code.google.com":
@@ -526,12 +544,30 @@ func debianNameFromGopkg(gopkg string, t packageType, allowUnknownHoster bool) s
 		if allowUnknownHoster {
 			suffix, _ := publicsuffix.PublicSuffix(host)
 			host = host[:len(host)-len(suffix)-len(".")]
-			log.Printf("WARNING: Using %q as canonical hostname for %q. If that is not okay, please file a bug against %s.\n", host, parts[0], os.Args[0])
+			log.Printf("WARNING: Using %q as canonical hostname for %q. If that is not okay, please file a bug against %s.\n", host, fqdn, os.Args[0])
 		} else {
-			log.Fatalf("Cannot derive Debian package name: unknown hoster %q. See -help output for -allow_unknown_hoster\n", host)
+			err = fmt.Errorf("unknown hoster %q", fqdn)
 		}
 	}
+	return host, err
+}
+
+// debianNameFromGopkg maps a Go package repo path to a Debian package name,
+// e.g. "golang.org/x/text" → "golang-golang-x-text".
+// This follows https://fedoraproject.org/wiki/PackagingDrafts/Go#Package_Names
+func debianNameFromGopkg(gopkg string, t packageType, allowUnknownHoster bool) string {
+	parts := strings.Split(gopkg, "/")
+
+	if t == typeProgram || t == typeProgramLibrary {
+		return normalizeDebianProgramName(parts[len(parts)-1])
+	}
+
+	host, err := shortHostName(gopkg, allowUnknownHoster)
+	if err != nil {
+		log.Fatalf("Cannot derive Debian package name: %v. See -help output for -allow_unknown_hoster\n", err)
+	}
 	parts[0] = host
+
 	return strings.Trim("golang-"+strings.ToLower(strings.Replace(strings.Join(parts, "-"), "_", "-", -1)), "-")
 }
 
@@ -706,6 +742,13 @@ func execMake(args []string, usage func()) {
 			` * "library+program" (aliases: "lib+prog", "l+p", "both")`+"\n"+
 			` * "program+library" (aliases: "prog+lib", "p+l", "combined")`)
 
+	var includeUpstreamHistory bool
+	fs.BoolVar(&includeUpstreamHistory,
+		"upstream-git-history",
+		true,
+		"Include upstream git history (Debian pkg-go team new workflow).\n"+
+			"New in dh-make-golang 0.3.0, currently experimental.")
+
 	fs.StringVar(&wrapAndSort,
 		"wrap-and-sort",
 		"a",
@@ -848,7 +891,7 @@ func execMake(args []string, usage func()) {
 
 	debversion := u.version + "-1"
 
-	dir, err := createGitRepository(debsrc, gopkg, orig, dep14, pristineTar)
+	dir, err := createGitRepository(debsrc, gopkg, orig, u, includeUpstreamHistory, allowUnknownHoster, dep14, pristineTar)
 	if err != nil {
 		log.Fatalf("Could not create git repository: %v\n", err)
 	}
@@ -913,4 +956,18 @@ func execMake(args []string, usage func()) {
 	fmt.Printf("    git remote set-url origin [email protected]:go-team/packages/%s.git\n", debsrc)
 	fmt.Printf("    gbp push\n")
 	fmt.Printf("\n")
+
+	if includeUpstreamHistory {
+		fmt.Printf("NOTE: Full upstream git history has been included as per pkg-go team's\n")
+		fmt.Printf("      new workflow.  This feature is new and somewhat experimental,\n")
+		fmt.Printf("      and all feedback are welcome!\n")
+		fmt.Printf("      (For old behavior, use --include-upstream-history=false)\n")
+		fmt.Printf("\n")
+		fmt.Printf("The upstream git history is being tracked with the remote named %q.\n", u.remote)
+		fmt.Printf("To upgrade to the latest upstream version, you may use something like:\n")
+		fmt.Printf("    git fetch %-15v # note the latest tag or commit-ish\n", u.remote)
+		fmt.Printf("    uscan --report-status     # check we get the same tag or commit-ish\n")
+		fmt.Printf("    gbp import-orig --sign-tags --uscan --upstream-vcs-tag=<commit-ish>\n")
+		fmt.Printf("\n")
+	}
 }

version.go

@@ -21,8 +21,13 @@ var (
 	semverRegexp = regexp.MustCompile(`^v(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$`)
 )
 
+// pkgVersionFromGit determines the actual version to be packaged
+// from the git repository status and user preference.
+// Besides returning the Debian upstream version, the "upstream" struct
+// struct fields u.version, u.commitIsh, u.hasRelease and u.isRelease
+// are also set.
 // TODO: also support other VCS
-func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, hasRelease, isRelease bool, err error) {
+func pkgVersionFromGit(gitdir string, u *upstream, forcePrerelease bool) (string, error) {
 	var latestTag string
 	var commitsAhead int
 
@@ -31,7 +36,7 @@ func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, has
 	cmd.Dir = gitdir
 	if out, err := cmd.Output(); err == nil {
 		latestTag = strings.TrimSpace(string(out))
-		hasRelease = true
+		u.hasRelease = true
 		log.Printf("Found latest tag %q", latestTag)
 
 		if !semverRegexp.MatchString(latestTag) {
@@ -44,11 +49,11 @@ func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, has
 		cmd.Dir = gitdir
 		out, err := cmd.Output()
 		if err != nil {
-			return "", true, false, err
+			return "", err
 		}
 		commitsAhead, err = strconv.Atoi(strings.TrimSpace(string(out)))
 		if err != nil {
-			return "", true, false, err
+			return "", err
 		}
 
 		if commitsAhead == 0 {
@@ -58,13 +63,15 @@ func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, has
 			log.Printf("INFO: master is ahead of %q by %v commits", latestTag, commitsAhead)
 		}
 
-		version = strings.TrimPrefix(latestTag, "v")
-		isRelease = true
+		u.commitIsh = latestTag
+		u.version = strings.TrimPrefix(latestTag, "v")
 
 		if forcePrerelease {
 			log.Printf("INFO: Force packaging master (prerelease) as requested by user")
+			// Fallthrough to package @master (prerelease)
 		} else {
-			return version, hasRelease, isRelease, nil
+			u.isRelease = true
+			return u.version, nil
 		}
 	}
 
@@ -73,26 +80,26 @@ func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, has
 	// 1.0~rc1 < 1.0 < 1.0+b1, as per
 	// https://www.debian.org/doc/manuals/maint-guide/first.en.html#namever
 	mainVer := "0.0~"
-	if hasRelease {
-		mainVer = version + "+"
+	if u.hasRelease {
+		mainVer = u.version + "+"
 	}
 
 	// Find committer date, UNIX timestamp
 	cmd = exec.Command("git", "log", "--pretty=format:%ct", "-n1")
 	cmd.Dir = gitdir
 	lastCommitUnixBytes, err := cmd.Output()
 	if err != nil {
-		return "", hasRelease, isRelease, err
+		return "", err
 	}
 	lastCommitUnix, err := strconv.ParseInt(strings.TrimSpace(string(lastCommitUnixBytes)), 0, 64)
 	if err != nil {
-		return "", hasRelease, isRelease, err
+		return "", err
 	}
 
-	// This results in an output like 4.10.2-232-g9f107c8
+	// This results in an output like "v4.10.2-232-g9f107c8"
 	cmd = exec.Command("git", "describe", "--long", "--tags")
 	cmd.Dir = gitdir
-	lastCommitSha := ""
+	lastCommitHash := ""
 	describeBytes, err := cmd.Output()
 	if err != nil {
 		// In case there are no tags at all, we just use the sha of the current commit
@@ -101,19 +108,21 @@ func pkgVersionFromGit(gitdir string, forcePrerelease bool) (version string, has
 		cmd.Stderr = os.Stderr
 		revparseBytes, err := cmd.Output()
 		if err != nil {
-			return "", hasRelease, isRelease, err
+			return "", err
 		}
-		lastCommitSha = strings.TrimSpace(string(revparseBytes))
+		lastCommitHash = strings.TrimSpace(string(revparseBytes))
+		u.commitIsh = lastCommitHash
 	} else {
 		submatches := describeRegexp.FindSubmatch(describeBytes)
 		if submatches == nil {
-			return "", hasRelease, isRelease, fmt.Errorf("git describe output %q does not match expected format", string(describeBytes))
+			return "", fmt.Errorf("git describe output %q does not match expected format", string(describeBytes))
 		}
-		lastCommitSha = string(submatches[1])
+		lastCommitHash = string(submatches[1])
+		u.commitIsh = strings.TrimSpace(string(describeBytes))
 	}
-	version = fmt.Sprintf("%sgit%s.%s",
+	u.version = fmt.Sprintf("%sgit%s.%s",
 		mainVer,
 		time.Unix(lastCommitUnix, 0).UTC().Format("20060102"),
-		lastCommitSha)
-	return version, hasRelease, isRelease, nil
+		lastCommitHash)
+	return u.version, nil
 }

version_test.go

@@ -42,7 +42,8 @@ func TestSnapshotVersion(t *testing.T) {
 		t.Fatalf("Could not run %v: %v", cmd.Args, err)
 	}
 
-	got, _, _, err := pkgVersionFromGit(tempdir, false)
+	var u upstream
+	got, err := pkgVersionFromGit(tempdir, &u, false)
 	if err != nil {
 		t.Fatalf("Determining package version from git failed: %v", err)
 	}
@@ -52,7 +53,7 @@ func TestSnapshotVersion(t *testing.T) {
 
 	gitCmdOrFatal(t, tempdir, "tag", "-a", "v1", "-m", "release v1")
 
-	got, _, _, err = pkgVersionFromGit(tempdir, false)
+	got, err = pkgVersionFromGit(tempdir, &u, false)
 	if err != nil {
 		t.Fatalf("Determining package version from git failed: %v", err)
 	}
@@ -72,7 +73,7 @@ func TestSnapshotVersion(t *testing.T) {
 		t.Fatalf("Could not run %v: %v", cmd.Args, err)
 	}
 
-	got, _, _, err = pkgVersionFromGit(tempdir, false)
+	got, err = pkgVersionFromGit(tempdir, &u, false)
 	if err != nil {
 		t.Fatalf("Determining package version from git failed: %v", err)
 	}
@@ -92,7 +93,7 @@ func TestSnapshotVersion(t *testing.T) {
 		t.Fatalf("Could not run %v: %v", cmd.Args, err)
 	}
 
-	got, _, _, err = pkgVersionFromGit(tempdir, false)
+	got, err = pkgVersionFromGit(tempdir, &u, false)
 	if err != nil {
 		t.Fatalf("Determining package version from git failed: %v", err)
 	}