Added a /conditions/current endpoint with computed best-guess values for current conditions

internal/application/units/converter.go

@@ -9,10 +9,15 @@ import (
 type Converter interface {
 	TemperatureCToOutput(celsius *float64) *float64
 	SpeedKmhToOutput(kmh *float64) *float64
+	System() string
 }
 
 type USConverter struct{}
 
+func (USConverter) System() string {
+	return "us"
+}
+
 func (USConverter) TemperatureCToOutput(celsius *float64) *float64 {
 	if celsius == nil {
 		return nil
@@ -29,6 +34,28 @@ func (USConverter) SpeedKmhToOutput(kmh *float64) *float64 {
 	return &mph
 }
 
+type MetricConverter struct{}
+
+func (MetricConverter) System() string {
+	return "metric"
+}
+
+func (MetricConverter) TemperatureCToOutput(celsius *float64) *float64 {
+	return clone(celsius)
+}
+
+func (MetricConverter) SpeedKmhToOutput(kmh *float64) *float64 {
+	return clone(kmh)
+}
+
+func clone(v *float64) *float64 {
+	if v == nil {
+		return nil
+	}
+	out := *v
+	return &out
+}
+
 func round(v float64, precision int) float64 {
 	pow := math.Pow(10, float64(precision))
 	return math.Round(v*pow) / pow

internal/application/units/converter_test.go

@@ -41,3 +41,32 @@ func TestUSConverterSpeedKmhToOutput(t *testing.T) {
 		t.Fatalf("expected 10.0 mph, got %v", got)
 	}
 }
+
+func TestMetricConverterPassthrough(t *testing.T) {
+	c := MetricConverter{}
+
+	if got := c.TemperatureCToOutput(nil); got != nil {
+		t.Fatalf("expected nil for nil temperature input")
+	}
+	if got := c.SpeedKmhToOutput(nil); got != nil {
+		t.Fatalf("expected nil for nil speed input")
+	}
+
+	temp := 12.3456
+	gotTemp := c.TemperatureCToOutput(&temp)
+	if gotTemp == nil || *gotTemp != temp {
+		t.Fatalf("expected temperature passthrough %v, got %v", temp, gotTemp)
+	}
+	if gotTemp == &temp {
+		t.Fatalf("expected temperature output to be a clone pointer")
+	}
+
+	speed := 14.2
+	gotSpeed := c.SpeedKmhToOutput(&speed)
+	if gotSpeed == nil || *gotSpeed != speed {
+		t.Fatalf("expected speed passthrough %v, got %v", speed, gotSpeed)
+	}
+	if gotSpeed == &speed {
+		t.Fatalf("expected speed output to be a clone pointer")
+	}
+}

internal/application/units/registry.go

@@ -0,0 +1,73 @@
+package units
+
+import (
+	"fmt"
+	"strings"
+)
+
+type Factory interface {
+	System() string
+	New() Converter
+}
+
+type StaticFactory struct {
+	UnitSystem string
+	Converter  Converter
+}
+
+func (f StaticFactory) System() string {
+	return f.UnitSystem
+}
+
+func (f StaticFactory) New() Converter {
+	return f.Converter
+}
+
+type Registry struct {
+	factories map[string]Factory
+}
+
+func NewRegistry() *Registry {
+	return &Registry{factories: map[string]Factory{}}
+}
+
+func (r *Registry) Register(factory Factory) error {
+	if r == nil {
+		return fmt.Errorf("register unit factory: registry is nil")
+	}
+	if factory == nil {
+		return fmt.Errorf("register unit factory: factory is nil")
+	}
+	system := normalize(factory.System())
+	if system == "" {
+		return fmt.Errorf("register unit factory: unit system is empty")
+	}
+	if _, exists := r.factories[system]; exists {
+		return fmt.Errorf("register unit factory: system %q already registered", system)
+	}
+	if factory.New() == nil {
+		return fmt.Errorf("register unit factory: factory returned nil converter for %q", system)
+	}
+	r.factories[system] = factory
+	return nil
+}
+
+func (r *Registry) Resolve(system string) (Converter, error) {
+	if r == nil {
+		return nil, fmt.Errorf("resolve unit converter: registry is nil")
+	}
+	key := normalize(system)
+	factory, ok := r.factories[key]
+	if !ok {
+		return nil, fmt.Errorf("resolve unit converter: unsupported unit system %q", system)
+	}
+	converter := factory.New()
+	if converter == nil {
+		return nil, fmt.Errorf("resolve unit converter: factory for %q returned nil converter", key)
+	}
+	return converter, nil
+}
+
+func normalize(system string) string {
+	return strings.ToLower(strings.TrimSpace(system))
+}

internal/application/units/registry_test.go

@@ -0,0 +1,62 @@
+package units
+
+import "testing"
+
+func TestRegistryResolve(t *testing.T) {
+	reg := NewRegistry()
+	if err := reg.Register(StaticFactory{UnitSystem: "us", Converter: USConverter{}}); err != nil {
+		t.Fatalf("register us: %v", err)
+	}
+	if err := reg.Register(StaticFactory{UnitSystem: "metric", Converter: MetricConverter{}}); err != nil {
+		t.Fatalf("register metric: %v", err)
+	}
+
+	converter, err := reg.Resolve("US")
+	if err != nil {
+		t.Fatalf("resolve us: %v", err)
+	}
+	if converter.System() != "us" {
+		t.Fatalf("expected us converter, got %q", converter.System())
+	}
+
+	converter, err = reg.Resolve(" metric ")
+	if err != nil {
+		t.Fatalf("resolve metric: %v", err)
+	}
+	if converter.System() != "metric" {
+		t.Fatalf("expected metric converter, got %q", converter.System())
+	}
+}
+
+func TestRegistryRejectsInvalidRegistration(t *testing.T) {
+	reg := NewRegistry()
+	if err := reg.Register(nil); err == nil {
+		t.Fatalf("expected error for nil factory")
+	}
+
+	if err := reg.Register(StaticFactory{UnitSystem: "", Converter: USConverter{}}); err == nil {
+		t.Fatalf("expected error for empty unit system")
+	}
+
+	if err := reg.Register(StaticFactory{UnitSystem: "us", Converter: nil}); err == nil {
+		t.Fatalf("expected error for nil converter")
+	}
+
+	if err := reg.Register(StaticFactory{UnitSystem: "us", Converter: USConverter{}}); err != nil {
+		t.Fatalf("register us: %v", err)
+	}
+	if err := reg.Register(StaticFactory{UnitSystem: "US", Converter: USConverter{}}); err == nil {
+		t.Fatalf("expected duplicate registration error")
+	}
+}
+
+func TestRegistryResolveUnknown(t *testing.T) {
+	reg := NewRegistry()
+	if err := reg.Register(StaticFactory{UnitSystem: "us", Converter: USConverter{}}); err != nil {
+		t.Fatalf("register us: %v", err)
+	}
+
+	if _, err := reg.Resolve("metric"); err == nil {
+		t.Fatalf("expected unsupported unit system error")
+	}
+}