Update Go version requirement to 1.21.0 for go-yaml compatibility

- Update go.mod to require Go 1.21.0+ (minimum for go-yaml v1.18.0)
- Remove toolchain directive to maximize compatibility
- Update README.md to reflect new Go version requirement
- Update go.sum with dependency checksums

Author: jackspirou

README.md

@@ -42,7 +42,7 @@ To install the `utc` package, use the following command:
 go get github.com/agentstation/utc
 ```
 
-**Requirements**: Go 1.18 or later (uses `any` type and other modern Go features)
+**Requirements**: Go 1.21.0 or later (required by go-yaml dependency)
 
 ## Usage
 

go.mod

@@ -1,3 +1,5 @@
 module github.com/agentstation/utc
 
-go 1.18
+go 1.21.0
+
+require github.com/goccy/go-yaml v1.18.0

go.sum

@@ -0,0 +1,2 @@
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=

utc.go

@@ -216,6 +216,39 @@ func (t *Time) UnmarshalText(text []byte) error {
 	return nil
 }
 
+// UnmarshalYAML implements the yaml.Unmarshaler interface for utc.Time
+func (t *Time) UnmarshalYAML(unmarshal func(any) error) error {
+	var s string
+	if err := unmarshal(&s); err != nil {
+		return err
+	}
+
+	// Handle empty string
+	if s == "" {
+		t.Time = time.Time{}
+		return nil
+	}
+
+	// Parse the time string using our flexible parser
+	parsed, err := parse(s)
+	if err != nil {
+		return fmt.Errorf("failed to parse time %q: %w", s, err)
+	}
+
+	t.Time = parsed
+	return nil
+}
+
+// MarshalYAML implements the yaml.Marshaler interface for utc.Time
+func (t Time) MarshalYAML() (any, error) {
+	if t.Time.IsZero() {
+		return nil, nil
+	}
+
+	// Use RFC3339 format for YAML output
+	return t.Time.Format(time.RFC3339), nil
+}
+
 // String implements the Stringer interface for utc.Time. It prints the time in RFC3339 format.
 //
 // Unlike many Go types that panic on nil receivers, this method returns "<nil>" to match
@@ -554,6 +587,8 @@ func parse(s string) (time.Time, error) {
 		time.RFC3339,
 		"2006-01-02 15:04:05",
 		"2006-01-02",
+		"2006-01", // YYYY-MM format
+		"2006",    // YYYY format
 	}
 	var firstErr error
 	for _, layout := range tryLayouts {

utc_test.go

@@ -6,6 +6,8 @@ import (
 	"strings"
 	"testing"
 	"time"
+	
+	"github.com/goccy/go-yaml"
 )
 
 func TestUTC_UnmarshalJSON(t *testing.T) {
@@ -1235,3 +1237,157 @@ func TestUTC_TimezoneInitErrors(t *testing.T) {
 		}
 	}
 }
+
+func TestUTC_UnmarshalYAML(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		want    time.Time
+		wantErr bool
+	}{
+		{
+			name:    "RFC3339 format",
+			input:   `"2023-01-01T12:00:00Z"`,
+			want:    time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC),
+			wantErr: false,
+		},
+		{
+			name:    "Date only format",
+			input:   `"2023-06-15"`,
+			want:    time.Date(2023, 6, 15, 0, 0, 0, 0, time.UTC),
+			wantErr: false,
+		},
+		{
+			name:    "Year-month format",
+			input:   `"2024-06"`,
+			want:    time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC),
+			wantErr: false,
+		},
+		{
+			name:    "Year only format",
+			input:   `"2024"`,
+			want:    time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
+			wantErr: false,
+		},
+		{
+			name:    "Date time format",
+			input:   `"2023-01-01 15:30:45"`,
+			want:    time.Date(2023, 1, 1, 15, 30, 45, 0, time.UTC),
+			wantErr: false,
+		},
+		{
+			name:    "Empty string",
+			input:   `""`,
+			want:    time.Time{},
+			wantErr: false,
+		},
+		{
+			name:    "Invalid format",
+			input:   `"not-a-date"`,
+			wantErr: true,
+		},
+		{
+			name:    "Invalid month",
+			input:   `"2023-13-01"`,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var ut Time
+			err := yaml.Unmarshal([]byte(tt.input), &ut)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && !ut.Time.Equal(tt.want) {
+				t.Errorf("UnmarshalYAML() = %v, want %v", ut.Time, tt.want)
+			}
+		})
+	}
+}
+
+func TestUTC_MarshalYAML(t *testing.T) {
+	tests := []struct {
+		name    string
+		time    Time
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "Normal time",
+			time: Time{time.Date(2023, 6, 15, 12, 30, 45, 0, time.UTC)},
+			want: "\"2023-06-15T12:30:45Z\"\n",
+			wantErr: false,
+		},
+		{
+			name: "Zero time",
+			time: Time{time.Time{}},
+			want: "null\n",
+			wantErr: false,
+		},
+		{
+			name: "Time with nanoseconds",
+			time: Time{time.Date(2023, 6, 15, 12, 30, 45, 123456789, time.UTC)},
+			want: "\"2023-06-15T12:30:45Z\"\n",
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			data, err := yaml.Marshal(tt.time)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("MarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && string(data) != tt.want {
+				t.Errorf("MarshalYAML() = %q, want %q", string(data), tt.want)
+			}
+		})
+	}
+}
+
+func TestUTC_YAMLRoundTrip(t *testing.T) {
+	// Test that we can marshal and unmarshal back to the same value
+	tests := []struct {
+		name string
+		time Time
+	}{
+		{
+			name: "Normal time",
+			time: Time{time.Date(2023, 6, 15, 12, 30, 45, 0, time.UTC)},
+		},
+		{
+			name: "Date only",
+			time: Time{time.Date(2023, 6, 15, 0, 0, 0, 0, time.UTC)},
+		},
+		{
+			name: "Year month",
+			time: Time{time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC)},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Marshal to YAML
+			data, err := yaml.Marshal(tt.time)
+			if err != nil {
+				t.Fatalf("Failed to marshal: %v", err)
+			}
+
+			// Unmarshal back
+			var result Time
+			err = yaml.Unmarshal(data, &result)
+			if err != nil {
+				t.Fatalf("Failed to unmarshal: %v", err)
+			}
+
+			// Compare (ignoring nanoseconds which might be lost in formatting)
+			if !result.Time.Truncate(time.Second).Equal(tt.time.Time.Truncate(time.Second)) {
+				t.Errorf("Round trip failed: got %v, want %v", result.Time, tt.time.Time)
+			}
+		})
+	}
+}