fix: properly normalize Windows paths, add windows test runner

.gitattributes

@@ -0,0 +1 @@
+* text eol=lf

.github/workflows/build.yml

@@ -4,9 +4,9 @@ name: build
 on: [push, pull_request]
 jobs:
   tests:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@main
+      - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
           go-version: '1.18'
@@ -16,3 +16,17 @@ jobs:
         uses: shogo82148/actions-goveralls@v1
         with:
           path-to-profile: profile.cov
+
+  tests-latest:
+    strategy:
+      matrix:
+        go-version: ['stable']
+        os: [ubuntu-latest, windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Run tests
+        run: make test

builder/build_package.go

@@ -4,9 +4,6 @@ package builder
 
 import (
 	"fmt"
-	"path/filepath"
-	"regexp"
-	"runtime"
 
 	"github.com/spdx/tools-golang/spdx"
 	"github.com/spdx/tools-golang/spdx/v2/common"
@@ -21,32 +18,19 @@ import (
 func BuildPackageSection(packageName string, dirRoot string, pathsIgnore []string) (*spdx.Package, error) {
 	// build the file section first, so we'll have it available
 	// for calculating the package verification code
-	filepaths, err := utils.GetAllFilePaths(dirRoot, pathsIgnore)
-	osType := runtime.GOOS
+	relativePaths, err := utils.GetAllFilePaths(dirRoot, pathsIgnore)
 
 	if err != nil {
 		return nil, err
 	}
 
-	re, ok := regexp.Compile("/+")
-	if ok != nil {
-		return nil, err
-	}
-	dirRootLen := 0
-	if osType == "windows" {
-		dirRootLen = len(dirRoot)
-	}
-
 	files := []*spdx.File{}
 	fileNumber := 0
-	for _, fp := range filepaths {
-		newFilePatch := ""
-		if osType == "windows" {
-			newFilePatch = filepath.FromSlash("." + fp[dirRootLen:])
-		} else {
-			newFilePatch = filepath.FromSlash("./" + fp)
-		}
-		newFile, err := BuildFileSection(re.ReplaceAllLiteralString(newFilePatch, string(filepath.Separator)), dirRoot, fileNumber)
+	for _, filePath := range relativePaths {
+		// SPDX spec says file names should generally start with ./
+		// see: https://spdx.github.io/spdx-spec/v2.3/file-information/#81-file-name-field
+		relativePath := "." + filePath
+		newFile, err := BuildFileSection(relativePath, dirRoot, fileNumber)
 		if err != nil {
 			return nil, err
 		}

utils/filesystem.go

@@ -10,19 +10,21 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 )
 
 // GetAllFilePaths takes a path to a directory (including an optional slice of
 // path patterns to ignore), and returns a slice of relative paths to all files
 // in that directory and its subdirectories (excluding those that are ignored).
+// These paths are always normalized to use URI-like forward-slashes but begin with /
 func GetAllFilePaths(dirRoot string, pathsIgnored []string) ([]string, error) {
 	// paths is a _pointer_ to a slice -- not just a slice.
 	// this is so that it can be appropriately modified by append
 	// in the sub-function.
 	paths := &[]string{}
-	prefix := strings.TrimSuffix(dirRoot, "/")
+	prefix := strings.TrimSuffix(filepath.ToSlash(dirRoot), "/")
 
 	err := filepath.Walk(dirRoot, func(path string, fi os.FileInfo, err error) error {
 		if err != nil {
@@ -37,6 +39,7 @@ func GetAllFilePaths(dirRoot string, pathsIgnored []string) ([]string, error) {
 			return nil
 		}
 
+		path = filepath.ToSlash(path)
 		shortPath := strings.TrimPrefix(path, prefix)
 
 		// don't include path if it should be ignored
@@ -55,7 +58,7 @@ func GetAllFilePaths(dirRoot string, pathsIgnored []string) ([]string, error) {
 // GetHashesForFilePath takes a path to a file on disk, and returns
 // SHA1, SHA256 and MD5 hashes for that file as strings.
 func GetHashesForFilePath(p string) (string, string, string, error) {
-	f, err := os.Open(p)
+	f, err := os.Open(filepath.FromSlash(p))
 	if err != nil {
 		return "", "", "", err
 	}
@@ -82,11 +85,11 @@ func GetHashesForFilePath(p string) (string, string, string, error) {
 // and determines whether that file should be ignored because it matches
 // any of those patterns.
 func ShouldIgnore(fileName string, pathsIgnored []string) bool {
-	fDirs, fFile := filepath.Split(fileName)
+	fDirs, fFile := path.Split(fileName)
 
 	for _, pattern := range pathsIgnored {
 		// split into dir(s) and filename
-		patternDirs, patternFile := filepath.Split(pattern)
+		patternDirs, patternFile := path.Split(pattern)
 		patternDirStars := strings.HasPrefix(patternDirs, "**")
 		if patternDirStars {
 			patternDirs = patternDirs[2:]