groot: add support for extracting copyright year from code templates

go-hep · May 27, 2020 · 351d7f1 · 351d7f1
1 parent c771d0c
commit 351d7f1
Show file tree

Hide file tree

Showing 8 changed files with 104 additions and 21 deletions.
diff --git a/groot/gen.rboot.go b/groot/gen.rboot.go
@@ -245,13 +245,15 @@ func genVersions(streamers []rbytes.StreamerInfo) {
 		log.Fatalf("could not generate ROOT classes versions: %+v", err)
 	}
 
-	f, err := os.Create("./rvers/versions_gen.go")
+	fname := "./rvers/versions_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rvers", f)
+	genroot.GenImports(year, "rvers", f)
 
 	fmt.Fprintf(f, "\n\n// ROOT version\nconst ROOT = %d\n\n", types[len(types)-1].Version)
 

diff --git a/groot/gen.rbytes.go b/groot/gen.rbytes.go
@@ -20,13 +20,15 @@ func main() {
 }
 
 func genRBuffer() {
-	f, err := os.Create("./rbytes/rbuffer_gen.go")
+	fname := "./rbytes/rbuffer_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rbytes", f,
+	genroot.GenImports(year, "rbytes", f,
 		"encoding/binary",
 		"math",
 	)

diff --git a/groot/gen.rcont.go b/groot/gen.rcont.go
@@ -22,13 +22,15 @@ func main() {
 }
 
 func genArrays() {
-	f, err := os.Create("./rcont/array_gen.go")
+	fname := "./rcont/array_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rcont", f,
+	genroot.GenImports(year, "rcont", f,
 		"reflect",
 		"",
 		"go-hep.org/x/hep/groot/root",

diff --git a/groot/gen.rhist.go b/groot/gen.rhist.go
@@ -21,13 +21,15 @@ func main() {
 }
 
 func genH1() {
-	f, err := os.Create("./rhist/h1_gen.go")
+	fname := "./rhist/h1_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rhist", f,
+	genroot.GenImports(year, "rhist", f,
 		"fmt", "math", "reflect",
 		"",
 		"go-hep.org/x/hep/hbook",
@@ -77,13 +79,15 @@ func genH1() {
 }
 
 func genH2() {
-	f, err := os.Create("./rhist/h2_gen.go")
+	fname := "./rhist/h2_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rhist", f,
+	genroot.GenImports(year, "rhist", f,
 		"fmt", "math", "reflect",
 		"",
 		"go-hep.org/x/hep/hbook",

diff --git a/groot/gen.rtree.go b/groot/gen.rtree.go
@@ -23,13 +23,15 @@ func main() {
 }
 
 func genLeaves() {
-	f, err := os.Create("./rtree/leaf_gen.go")
+	fname := "./rtree/leaf_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	genroot.GenImports("rtree", f,
+	genroot.GenImports(year, "rtree", f,
 		"fmt",
 		"reflect",
 		"strings",
@@ -588,7 +590,9 @@ var (
 `
 
 func genRLeaves() {
-	f, err := os.Create("./rtree/rleaf_gen.go")
+	fname := "./rtree/rleaf_gen.go"
+	year := genroot.ExtractYear(fname)
+	f, err := os.Create(fname)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -601,7 +605,7 @@ func genRLeaves() {
 		Sli = Kind("Sli")
 	)
 
-	genroot.GenImports("rtree", f,
+	genroot.GenImports(year, "rtree", f,
 		"reflect",
 		"unsafe", // for unsafeDecayArrayXXX
 		"",

diff --git a/groot/internal/genroot/genroot.go b/groot/internal/genroot/genroot.go
@@ -5,12 +5,15 @@
 package genroot // import "go-hep.org/x/hep/groot/internal/genroot"
 
 import (
+	"bytes"
 	"fmt"
 	"go/format"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
+	"strconv"
+	"time"
 )
 
 // GoFmt formats a file using gofmt.
@@ -32,8 +35,11 @@ func GoFmt(f *os.File) {
 }
 
 // GenImports adds the provided imports to the given writer.
-func GenImports(pkg string, w io.Writer, imports ...string) {
-	fmt.Fprintf(w, srcHeader, pkg)
+func GenImports(year int, pkg string, w io.Writer, imports ...string) {
+	if year <= 0 {
+		year = gopherYear
+	}
+	fmt.Fprintf(w, srcHeader, year, pkg)
 	if len(imports) == 0 {
 		return
 	}
@@ -49,7 +55,30 @@ func GenImports(pkg string, w io.Writer, imports ...string) {
 	fmt.Fprintf(w, ")\n\n")
 }
 
-const srcHeader = `// Copyright ©2020 The go-hep Authors. All rights reserved.
+// ExtractYear returns the copyright year of a Go-HEP header file.
+func ExtractYear(fname string) int {
+	raw, err := ioutil.ReadFile(fname)
+	if err != nil {
+		return gopherYear
+	}
+	if !bytes.HasPrefix(raw, []byte("// Copyright")) {
+		return gopherYear
+	}
+	raw = bytes.TrimPrefix(raw, []byte("// Copyright ©"))
+	raw = bytes.TrimPrefix(raw, []byte("// Copyright "))
+	idx := bytes.Index(raw, []byte("The go-hep Authors"))
+	raw = bytes.TrimSpace(raw[:idx])
+
+	year, err := strconv.Atoi(string(raw))
+	if err != nil {
+		return gopherYear
+	}
+	return year
+}
+
+var gopherYear = time.Now().Year()
+
+const srcHeader = `// Copyright ©%d The go-hep Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 

diff --git a/groot/internal/genroot/genroot_test.go b/groot/internal/genroot/genroot_test.go
@@ -0,0 +1,34 @@
+// Copyright ©2020 The go-hep Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package genroot
+
+import "testing"
+
+func TestExtractYear(t *testing.T) {
+	for _, tc := range []struct {
+		fname string
+		year  int
+	}{
+		{
+			fname: "./genroot.go",
+			year:  2018,
+		},
+		{
+			fname: "./genroot_test.go",
+			year:  2020,
+		},
+		{
+			fname: "../../cmd/root-gen-rfunc/testdata/func1_golden.txt",
+			year:  2020,
+		},
+	} {
+		t.Run(tc.fname, func(t *testing.T) {
+			year := ExtractYear(tc.fname)
+			if year != tc.year {
+				t.Fatalf("invalid year: got=%d, want=%d", year, tc.year)
+			}
+		})
+	}
+}
diff --git a/groot/rtree/rfunc/gen-rfuncs.go b/groot/rtree/rfunc/gen-rfuncs.go
@@ -103,23 +103,29 @@ func genRFuncs() {
 }
 
 func genRFunc(typ Func) {
-	f, err := os.Create("./rfunc_" + typ.Name + "_gen.go")
+	fcodeName := "./rfunc_" + typ.Name + "_gen.go"
+	yearCode := genroot.ExtractYear(fcodeName)
+
+	ftestName := "./rfunc_" + typ.Name + "_gen_test.go"
+	yearTest := genroot.ExtractYear(ftestName)
+
+	f, err := os.Create(fcodeName)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer f.Close()
 
-	ft, err := os.Create("./rfunc_" + typ.Name + "_gen_test.go")
+	ft, err := os.Create(ftestName)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer ft.Close()
 
-	genroot.GenImports("rfunc", f,
+	genroot.GenImports(yearCode, "rfunc", f,
 		"fmt",
 	)
 
-	genroot.GenImports("rfunc", ft,
+	genroot.GenImports(yearTest, "rfunc", ft,
 		"reflect",
 		"testing",
 	)