fix: include unit in Timer.RenderDisplay() output (#10)

Timer syntax like ~{10-15%seconds} was only displaying '10-15' instead of
'10-15 seconds' because:

1. The Unit field from the parser wasn't being set on the Timer struct
   when converting from parser.Component to cooklang.Timer

2. Timer.RenderDisplay() only returned the Duration, ignoring the Unit

This fix:
- Sets Timer.Unit from component.Unit during parsing in ToCooklangRecipe()
- Updates RenderDisplay() to include the unit when available
- Adds comprehensive tests for timer parsing and display

Author: hilli

cooklang.go

@@ -281,12 +281,21 @@ func (t Timer) Render() string {
 }
 
 // RenderDisplay returns timer in plain text format suitable for display.
-// Returns the timer name if available, otherwise the duration.
+// Returns the duration with unit if available, or just the duration.
+// If the timer has a name but no duration, returns the name.
 func (t Timer) RenderDisplay() string {
+	// If there's a duration, show it (optionally with unit)
+	if t.Duration != "" {
+		if t.Unit != "" {
+			return t.Duration + " " + t.Unit
+		}
+		return t.Duration
+	}
+	// Fall back to name if no duration
 	if t.Name != "" {
 		return t.Name
 	}
-	return t.Duration
+	return ""
 }
 
 // Render returns the Cooklang syntax representation of this cookware.
@@ -675,6 +684,7 @@ func ToCooklangRecipe(pRecipe *parser.Recipe) *Recipe {
 			case "timer":
 				stepComp = &Timer{
 					Duration:   component.Quantity,
+					Unit:       component.Unit,
 					Name:       component.Name,
 					Annotation: component.Value,
 				}

timer_test.go

@@ -0,0 +1,207 @@
+package cooklang
+
+import (
+	"testing"
+)
+
+func TestTimerRenderDisplay(t *testing.T) {
+	tests := []struct {
+		name     string
+		timer    Timer
+		expected string
+	}{
+		{
+			name: "duration with unit",
+			timer: Timer{
+				Duration: "10",
+				Unit:     "minutes",
+			},
+			expected: "10 minutes",
+		},
+		{
+			name: "duration range with unit",
+			timer: Timer{
+				Duration: "10-15",
+				Unit:     "seconds",
+			},
+			expected: "10-15 seconds",
+		},
+		{
+			name: "duration without unit",
+			timer: Timer{
+				Duration: "5",
+			},
+			expected: "5",
+		},
+		{
+			name: "named timer without duration falls back to name",
+			timer: Timer{
+				Name: "resting",
+			},
+			expected: "resting",
+		},
+		{
+			name: "duration takes precedence over name",
+			timer: Timer{
+				Duration: "10",
+				Unit:     "minutes",
+				Name:     "boiling",
+			},
+			expected: "10 minutes",
+		},
+		{
+			name:     "empty timer returns empty string",
+			timer:    Timer{},
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.timer.RenderDisplay()
+			if result != tt.expected {
+				t.Errorf("RenderDisplay() = %q, want %q", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestTimerParsingWithUnit(t *testing.T) {
+	tests := []struct {
+		name             string
+		input            string
+		expectedDuration string
+		expectedUnit     string
+		expectedDisplay  string
+	}{
+		{
+			name:             "simple timer with minutes",
+			input:            "Boil for ~{10%minutes}.",
+			expectedDuration: "10",
+			expectedUnit:     "minutes",
+			expectedDisplay:  "10 minutes",
+		},
+		{
+			name:             "timer with seconds",
+			input:            "Stir for ~{30%seconds}.",
+			expectedDuration: "30",
+			expectedUnit:     "seconds",
+			expectedDisplay:  "30 seconds",
+		},
+		{
+			name:             "timer with range and unit",
+			input:            "Mix for ~{10-15%seconds}.",
+			expectedDuration: "10-15",
+			expectedUnit:     "seconds",
+			expectedDisplay:  "10-15 seconds",
+		},
+		{
+			name:             "timer with hours",
+			input:            "Bake for ~{2%hours}.",
+			expectedDuration: "2",
+			expectedUnit:     "hours",
+			expectedDisplay:  "2 hours",
+		},
+		{
+			name:             "timer without unit",
+			input:            "Wait ~{5}.",
+			expectedDuration: "5",
+			expectedUnit:     "",
+			expectedDisplay:  "5",
+		},
+		{
+			name:             "named timer with unit",
+			input:            "Let it ~rest{10%minutes}.",
+			expectedDuration: "10",
+			expectedUnit:     "minutes",
+			expectedDisplay:  "10 minutes",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			recipe, err := ParseString(tt.input)
+			if err != nil {
+				t.Fatalf("Failed to parse recipe: %v", err)
+			}
+
+			// Find the timer in the parsed recipe
+			var foundTimer *Timer
+			step := recipe.FirstStep
+			for step != nil && foundTimer == nil {
+				component := step.FirstComponent
+				for component != nil {
+					if timer, ok := component.(*Timer); ok {
+						foundTimer = timer
+						break
+					}
+					component = component.GetNext()
+				}
+				step = step.NextStep
+			}
+
+			if foundTimer == nil {
+				t.Fatal("No timer found in parsed recipe")
+			}
+
+			if foundTimer.Duration != tt.expectedDuration {
+				t.Errorf("Duration = %q, want %q", foundTimer.Duration, tt.expectedDuration)
+			}
+
+			if foundTimer.Unit != tt.expectedUnit {
+				t.Errorf("Unit = %q, want %q", foundTimer.Unit, tt.expectedUnit)
+			}
+
+			display := foundTimer.RenderDisplay()
+			if display != tt.expectedDisplay {
+				t.Errorf("RenderDisplay() = %q, want %q", display, tt.expectedDisplay)
+			}
+		})
+	}
+}
+
+func TestTimerInRecipeSteps(t *testing.T) {
+	// Test that timers are correctly rendered in recipe step text
+	recipe, err := ParseString("Stir for ~{10-15%seconds}.")
+	if err != nil {
+		t.Fatalf("Failed to parse recipe: %v", err)
+	}
+
+	// Get the step instruction text
+	step := recipe.FirstStep
+	if step == nil {
+		t.Fatal("No steps found in recipe")
+	}
+
+	// Build the instruction text from components
+	var instructionText string
+	component := step.FirstComponent
+	for component != nil {
+		switch c := component.(type) {
+		case *Timer:
+			instructionText += c.RenderDisplay()
+		case *Instruction:
+			instructionText += c.Text
+		}
+		component = component.GetNext()
+	}
+
+	// The instruction should contain "10-15 seconds"
+	expectedSubstring := "10-15 seconds"
+	if !contains(instructionText, expectedSubstring) {
+		t.Errorf("Instruction text %q should contain %q", instructionText, expectedSubstring)
+	}
+}
+
+func contains(s, substr string) bool {
+	return len(s) >= len(substr) && (s == substr || len(s) > 0 && containsHelper(s, substr))
+}
+
+func containsHelper(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}