Add httpmock, merge unmarshal into fileutil. (#434)

## Community Contribution License
All community contributions in this pull request are licensed to the
project maintainers
under the terms of the [Apache 2
license](https://www.apache.org/licenses/LICENSE-2.0).
By creating this pull request I represent that I have the right to
license the
contributions to the project maintainers under the Apache 2 license.

## Summary
Add httpmock as an opensource package. It seems generally helpful, and
we'll need it for aisdk.
Decided to merge `unmarshal` into `fileutil` .... but let me know if you
disagree. In the process, added better docs, tests, and added a Glob
function to fileutil.

## How was it tested?
Ran tests.

Author: loreto

pkg/fileutil/doc.go

@@ -0,0 +1,58 @@
+// Package fileutil provides utilities for working with files and paths in a
+// safe and convenient way.
+//
+// The package offers two main sets of functionality:
+//
+//  1. File operations through both direct functions and a Path type:
+//     - Checking file/directory existence and type
+//     - Creating directories
+//     - Writing files atomically
+//     - Getting file information
+//     - Globbing files with pattern matching
+//
+//  2. File unmarshaling utilities:
+//     - Support for JSON, JSONC (JSON with comments), YAML, and TOML formats
+//     - Batch processing of multiple files
+//     - Type-safe unmarshaling into Go structs
+//
+// # Path Type
+//
+// The Path type provides a type-safe way to work with filesystem paths:
+//
+//	path := fileutil.Path("base/dir")
+//	subpath := path.Subpath("nested", "path")
+//	if subpath.IsDir() {
+//	    // Handle directory...
+//	}
+//
+// # File Operations
+//
+// Basic file operations are available both as methods on Path and as standalone
+// functions:
+//
+//	// Using Path type
+//	path := fileutil.Path("config")
+//	if path.Exists() {
+//	    info := path.FileInfo()
+//	    // ...
+//	}
+//
+//	// Using standalone functions
+//	if fileutil.Exists("config") {
+//	    info := fileutil.FileInfo("config")
+//	    // ...
+//	}
+//
+// # File Unmarshaling
+//
+// The package provides utilities for unmarshaling structured data from files:
+//
+//	var config MyConfig
+//	err := fileutil.UnmarshalFile("config.yaml", &config)
+//
+//	// Or process multiple files
+//	configs, err := fileutil.UnmarshalPaths[MyConfig](fs, []string{"configs"})
+//
+// All paths in this package are relative to the current working directory unless
+// specified otherwise.
+package fileutil

pkg/fileutil/fileutil.go

@@ -1,90 +1,97 @@
-// TODO: publish as it's own shared package that other binaries can use.
-// Right now we have other copies in other binaries. For example, devbox
-// has its own copy.
-
 package fileutil
 
 import (
 	"io/fs"
 	"os"
 	"path/filepath"
 
+	"github.com/bmatcuk/doublestar/v4"
 	"github.com/google/renameio/v2"
 )
 
-type Path string
-
-func (p Path) String() string {
-	return string(p)
-}
+type osFS struct{}
 
-func (p Path) Subpath(elements ...string) Path {
-	all := append([]string{p.String()}, elements...)
-	return Path(filepath.Join(all...))
+func (osFS) Open(name string) (fs.File, error) {
+	return os.Open(name)
 }
 
+// IsDir returns true if the path exists and is a directory.
 func IsDir(path string) bool {
-	info := FileInfo(path)
-	if info == nil {
-		return false
-	}
-	return info.IsDir()
-}
-
-func (p Path) IsDir() bool {
-	return IsDir(p.String())
+	return isDir(osFS{}, path)
 }
 
+// IsFile returns true if the path exists and is a regular file.
 func IsFile(path string) bool {
-	info := FileInfo(path)
-	if info == nil {
-		return false
-	}
-	return info.Mode().IsRegular()
+	return isFile(osFS{}, path)
 }
 
-func (p Path) IsFile() bool {
-	return IsFile(p.String())
+// Exists returns true if the path exists.
+func Exists(path string) bool {
+	return exists(osFS{}, path)
 }
 
-func Exists(path string) bool {
-	return FileInfo(path) != nil
+// FileInfo returns the fs.FileInfo for the given path.
+func FileInfo(path string) fs.FileInfo {
+	return fileInfo(osFS{}, path)
 }
 
-func (p Path) Exists() bool {
-	return Exists(p.String())
+// Glob returns all files that match the given pattern.
+func Glob(pattern string) ([]string, error) {
+	return doublestar.Glob(osFS{}, pattern)
 }
 
+// EnsureDir ensures that the directory at the given path exists,
+// creating it and any parent directories if necessary.
 func EnsureDir(path string) error {
 	if IsDir(path) {
 		return nil
 	}
 	return os.MkdirAll(path, 0o700 /* as suggested by xdg spec */)
 }
 
-func (p Path) EnsureDir() error {
-	return EnsureDir(p.String())
+// WriteFile writes data to the named file, creating it if necessary.
+// If the file already exists, it is replaced.
+// The file is written atomically by writing to a temporary file and renaming it.
+func WriteFile(path string, data []byte) error {
+	// First ensure the directory exists:
+	dir := filepath.Dir(path)
+	err := EnsureDir(dir)
+	if err != nil {
+		return err
+	}
+
+	return renameio.WriteFile(path, data, 0o600)
+}
+
+// isDir returns true if the path exists and is a directory in the given filesystem.
+func isDir(fsys fs.FS, path string) bool {
+	info := fileInfo(fsys, path)
+	if info == nil {
+		return false
+	}
+	return info.IsDir()
 }
 
-func FileInfo(path string) fs.FileInfo {
-	info, err := os.Stat(path)
-	if err != nil {
-		return nil
+// isFile returns true if the path exists and is a regular file in the given filesystem.
+func isFile(fsys fs.FS, path string) bool {
+	info := fileInfo(fsys, path)
+	if info == nil {
+		return false
 	}
-	return info
+	return info.Mode().IsRegular()
 }
 
-func (p Path) FileInfo() fs.FileInfo {
-	return FileInfo(p.String())
+// exists returns true if the path exists in the given filesystem.
+func exists(fsys fs.FS, path string) bool {
+	return fileInfo(fsys, path) != nil
 }
 
-func WriteFile(path string, data []byte) error {
-	// First ensure the directory exists:
-	dir := filepath.Dir(path)
-	err := EnsureDir(dir)
+// fileInfo returns the fs.FileInfo for the given path in the given filesystem.
+// Returns nil if the path does not exist or cannot be accessed.
+func fileInfo(fsys fs.FS, path string) fs.FileInfo {
+	info, err := fs.Stat(fsys, path)
 	if err != nil {
-		return err
+		return nil
 	}
-	// Write using `renameio` to ensure an atomic write:
-	return renameio.WriteFile(path, data, 0o600)
+	return info
 }

pkg/fileutil/fileutil_test.go

@@ -0,0 +1,130 @@
+package fileutil
+
+import (
+	"io/fs"
+	"testing"
+	"testing/fstest"
+)
+
+func TestIsDir(t *testing.T) {
+	fsys := fstest.MapFS{
+		"dir/":   &fstest.MapFile{Mode: fs.ModeDir},
+		"file":   &fstest.MapFile{Data: []byte("content")},
+		"empty/": &fstest.MapFile{Mode: fs.ModeDir},
+	}
+
+	tests := []struct {
+		name     string
+		path     string
+		expected bool
+	}{
+		{"existing directory", "dir", true},
+		{"regular file", "file", false},
+		{"empty directory", "empty", true},
+		{"non-existent path", "nonexistent", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isDir(fsys, tt.path); got != tt.expected {
+				t.Errorf("isDir(%q) = %v, want %v", tt.path, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestIsFile(t *testing.T) {
+	fsys := fstest.MapFS{
+		"dir/":  &fstest.MapFile{Mode: fs.ModeDir},
+		"file":  &fstest.MapFile{Data: []byte("content")},
+		"empty": &fstest.MapFile{Data: []byte{}},
+	}
+
+	tests := []struct {
+		name     string
+		path     string
+		expected bool
+	}{
+		{"directory", "dir", false},
+		{"regular file", "file", true},
+		{"empty file", "empty", true},
+		{"non-existent path", "nonexistent", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := isFile(fsys, tt.path); got != tt.expected {
+				t.Errorf("isFile(%q) = %v, want %v", tt.path, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestExists(t *testing.T) {
+	fsys := fstest.MapFS{
+		"dir/":  &fstest.MapFile{Mode: fs.ModeDir},
+		"file":  &fstest.MapFile{Data: []byte("content")},
+		"empty": &fstest.MapFile{Data: []byte{}},
+	}
+
+	tests := []struct {
+		name     string
+		path     string
+		expected bool
+	}{
+		{"existing directory", "dir", true},
+		{"existing file", "file", true},
+		{"empty file", "empty", true},
+		{"non-existent path", "nonexistent", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := exists(fsys, tt.path); got != tt.expected {
+				t.Errorf("exists(%q) = %v, want %v", tt.path, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestFileInfo(t *testing.T) {
+	fsys := fstest.MapFS{
+		"dir/":  &fstest.MapFile{Mode: fs.ModeDir},
+		"file":  &fstest.MapFile{Data: []byte("content")},
+		"empty": &fstest.MapFile{Data: []byte{}},
+	}
+
+	tests := []struct {
+		name          string
+		path          string
+		expectNil     bool
+		expectIsDir   bool
+		expectRegular bool
+	}{
+		{"directory", "dir", false, true, false},
+		{"regular file", "file", false, false, true},
+		{"empty file", "empty", false, false, true},
+		{"non-existent path", "nonexistent", true, false, false},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			info := fileInfo(fsys, test.path)
+			if test.expectNil {
+				if info != nil {
+					t.Errorf("fileInfo(%q) = %v, want nil", test.path, info)
+				}
+				return
+			}
+			if info == nil {
+				t.Fatalf("fileInfo(%q) = nil, want non-nil", test.path)
+			}
+			if got := info.IsDir(); got != test.expectIsDir {
+				t.Errorf("fileInfo(%q).IsDir() = %v, want %v", test.path, got, test.expectIsDir)
+			}
+			if got := info.Mode().IsRegular(); got != test.expectRegular {
+				t.Errorf("fileInfo(%q).Mode().IsRegular() = %v, want %v", test.path, got, test.expectRegular)
+			}
+		})
+	}
+}

pkg/fileutil/path.go

@@ -0,0 +1,53 @@
+package fileutil
+
+import (
+	"io/fs"
+	"path/filepath"
+)
+
+// Path represents a filesystem path with helper methods for common operations.
+// It provides a type-safe way to handle paths and perform path-related operations.
+type Path string
+
+// String returns the path as a string.
+func (p Path) String() string {
+	return string(p)
+}
+
+// Subpath creates a new Path by joining the current path with additional path elements.
+// It uses filepath.Join internally to handle path separators correctly for the current OS.
+func (p Path) Subpath(elements ...string) Path {
+	all := append([]string{p.String()}, elements...)
+	return Path(filepath.Join(all...))
+}
+
+// IsDir returns true if the path exists and is a directory.
+// The path is relative to the current working directory.
+func (p Path) IsDir() bool {
+	return IsDir(p.String())
+}
+
+// IsFile returns true if the path exists and is a regular file.
+// The path is relative to the current working directory.
+func (p Path) IsFile() bool {
+	return IsFile(p.String())
+}
+
+// EnsureDir ensures that the directory at this path exists,
+// creating it and any parent directories if necessary.
+func (p Path) EnsureDir() error {
+	return EnsureDir(p.String())
+}
+
+// FileInfo returns the fs.FileInfo for this path.
+// Returns nil if the path does not exist or cannot be accessed.
+// The path is relative to the current working directory.
+func (p Path) FileInfo() fs.FileInfo {
+	return FileInfo(p.String())
+}
+
+// Exists returns true if the path exists.
+// The path is relative to the current working directory.
+func (p Path) Exists() bool {
+	return Exists(p.String())
+}