Implement typed segment migration for Status segment with polymorphic unmarshaling

- Add SegmentBase in segments/typed_base.go for typed segment common functionality
- Migrate Status segment to typed configuration with struct tags and defaults
- Implement polymorphic JSON unmarshaling in Block to detect and unmarshal typed segments
- Update MapSegmentWithWriter to handle both typed and legacy segments
- Add TypedSegmentMarker interface to distinguish typed from legacy segments
- Status segment now uses direct struct field access instead of properties.Map
- Add comprehensive tests for polymorphic unmarshaling
- All builds succeed and tests pass

Co-authored-by: JanDeDobbeleer <[email protected]>

Author: Copilot

src/config/block.go

@@ -1,6 +1,9 @@
 package config
 
-import "fmt"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 // BlockType type of block
 type BlockType string
@@ -49,3 +52,83 @@ func (b *Block) key() any {
 
 	return fmt.Sprintf("%s-%s", b.Type, b.Alignment)
 }
+
+// typedSegmentMarker is used to identify typed segments vs legacy property-based segments
+type typedSegmentMarker interface {
+	IsTypedSegment()
+}
+
+// UnmarshalJSON implements custom unmarshaling to support polymorphic segments
+func (b *Block) UnmarshalJSON(data []byte) error {
+	// Use type alias to avoid recursion
+	type Alias Block
+	aux := &struct {
+		RawSegments []json.RawMessage `json:"segments"`
+		*Alias
+	}{
+		Alias: (*Alias)(b),
+	}
+
+	if err := json.Unmarshal(data, &aux); err != nil {
+		return err
+	}
+
+	// Clear segments before repopulating
+	b.Segments = nil
+
+	for i, rawSeg := range aux.RawSegments {
+		segment, err := unmarshalSegment(rawSeg)
+		if err != nil {
+			return fmt.Errorf("segment %d: %w", i, err)
+		}
+		b.Segments = append(b.Segments, segment)
+	}
+
+	return nil
+}
+
+func unmarshalSegment(data []byte) (*Segment, error) {
+	// Peek at type field
+	var typeCheck struct {
+		Type SegmentType `json:"type"`
+	}
+	if err := json.Unmarshal(data, &typeCheck); err != nil {
+		return nil, err
+	}
+
+	// Try to create a segment writer using the factory
+	f, ok := Segments[typeCheck.Type]
+	if !ok {
+		return nil, fmt.Errorf("unknown segment type: %s", typeCheck.Type)
+	}
+
+	writer := f()
+
+	if typedSeg, isTyped := writer.(typedSegmentMarker); isTyped {
+		// Unmarshal into the typed segment
+		if err := json.Unmarshal(data, writer); err != nil {
+			return nil, err
+		}
+
+		// Apply defaults
+		if err := ApplyDefaults(typedSeg); err != nil {
+			return nil, err
+		}
+
+		// Create segment wrapper with writer already set
+		seg := &Segment{
+			Type:   typeCheck.Type,
+			writer: writer,
+		}
+
+		return seg, nil
+	}
+
+	// Fall back to old property-based system for non-migrated segments
+	var seg Segment
+	if err := json.Unmarshal(data, &seg); err != nil {
+		return nil, err
+	}
+
+	return &seg, nil
+}

src/config/block_test.go

@@ -0,0 +1,63 @@
+package config
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBlockUnmarshalTypedSegment(t *testing.T) {
+	jsonData := `{
+		"type": "prompt",
+		"segments": [
+			{
+				"type": "status",
+				"status_template": "custom template",
+				"always_enabled": true
+			}
+		]
+	}`
+
+	var block Block
+	err := json.Unmarshal([]byte(jsonData), &block)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(block.Segments))
+	assert.Equal(t, STATUS, block.Segments[0].Type)
+
+	// The writer field should be set (it's private but accessible in same package)
+	segment := block.Segments[0]
+	assert.NotNil(t, segment.writer, "writer should be set")
+
+	// Check it's marked as typed
+	type typedMarker interface {
+		IsTypedSegment()
+	}
+	_, isTyped := segment.writer.(typedMarker)
+	assert.True(t, isTyped, "segment should be marked as typed")
+}
+
+func TestBlockUnmarshalLegacySegment(t *testing.T) {
+	jsonData := `{
+		"type": "prompt",
+		"segments": [
+			{
+				"type": "text",
+				"properties": {
+					"text": "hello"
+				}
+			}
+		]
+	}`
+
+	var block Block
+	err := json.Unmarshal([]byte(jsonData), &block)
+
+	assert.NoError(t, err)
+	assert.Equal(t, 1, len(block.Segments))
+	assert.Equal(t, TEXT, block.Segments[0].Type)
+
+	// For legacy segments, properties should be preserved
+	assert.NotNil(t, block.Segments[0].Properties)
+}

src/config/segment_types.go

@@ -472,6 +472,19 @@ var Segments = map[SegmentType]func() SegmentWriter{
 func (segment *Segment) MapSegmentWithWriter(env runtime.Environment) error {
 	segment.env = env
 
+	// If writer is already set (from polymorphic unmarshal), just init it
+	if segment.writer != nil {
+		// Check if it's a typed segment
+		type typedMarker interface {
+			IsTypedSegment()
+		}
+		if _, ok := segment.writer.(typedMarker); ok {
+			// Typed segments ignore props, pass nil wrapper
+			segment.writer.Init(nil, env)
+			return nil
+		}
+	}
+
 	if segment.Properties == nil {
 		segment.Properties = make(properties.Map)
 	}
@@ -482,6 +495,24 @@ func (segment *Segment) MapSegmentWithWriter(env runtime.Environment) error {
 	}
 
 	writer := f()
+
+	// Check if this is a typed segment that wasn't unmarshaled yet
+	type typedMarker interface {
+		IsTypedSegment()
+	}
+	if _, isTyped := writer.(typedMarker); isTyped {
+		// Apply defaults
+		if err := ApplyDefaults(writer); err != nil {
+			return err
+		}
+
+		// Typed segments ignore props
+		writer.Init(nil, env)
+		segment.writer = writer
+		return nil
+	}
+
+	// Old property-based initialization
 	wrapper := &properties.Wrapper{
 		Properties: segment.Properties,
 	}

src/segments/status.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
+	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"github.com/jandedobbeleer/oh-my-posh/src/template"
 	"github.com/jandedobbeleer/oh-my-posh/src/text"
 )
@@ -15,47 +16,64 @@ const (
 )
 
 type Status struct {
-	Base
-
-	String  string
-	Meaning string
-	Error   bool
+	SegmentBase
+
+	// Configuration fields with defaults
+	StatusTemplate  string `json:"status_template,omitempty" toml:"status_template,omitempty" yaml:"status_template,omitempty" default:"{{ .Code }}"`
+	StatusSeparator string `json:"status_separator,omitempty" toml:"status_separator,omitempty" yaml:"status_separator,omitempty" default:"|"`
+	AlwaysEnabled   bool   `json:"always_enabled,omitempty" toml:"always_enabled,omitempty" yaml:"always_enabled,omitempty"`
+
+	// Runtime state (not serialized)
+	String  string `json:"-"`
+	Meaning string `json:"-"`
+	Error   bool   `json:"-"`
+	Code    int    `json:"-"`
 }
 
 func (s *Status) Template() string {
 	return " {{ .String }} "
 }
 
+// Init satisfies the SegmentWriter interface (ignores props for typed segments)
+func (s *Status) Init(_ properties.Properties, env runtime.Environment) {
+	s.SegmentBase.Init(env)
+}
+
+// IsTypedSegment marks this as a typed segment
+func (s *Status) IsTypedSegment() {}
+
 func (s *Status) Enabled() bool {
-	status, pipeStatus := s.env.StatusCodes()
+	status, pipeStatus := s.Env().StatusCodes()
 
+	s.Code = status
 	s.String = s.formatStatus(status, pipeStatus)
 	// Deprecated: Use {{ reason .Code }} instead
 	s.Meaning = template.GetReasonFromStatus(status)
 
-	if s.props.GetBool(properties.AlwaysEnabled, false) {
+	if s.AlwaysEnabled {
 		return true
 	}
 
 	return s.Error
 }
 
 func (s *Status) formatStatus(status int, pipeStatus string) string {
-	statusTemplate := s.props.GetString(StatusTemplate, "{{ .Code }}")
+	statusTemplate := s.StatusTemplate
 
 	if status != 0 {
 		s.Error = true
 	}
 
 	if pipeStatus == "" {
+		s.Code = status
 		if txt, err := template.Render(statusTemplate, s); err == nil {
 			return txt
 		}
 
 		return strconv.Itoa(status)
 	}
 
-	StatusSeparator := s.props.GetString(StatusSeparator, "|")
+	statusSeparator := s.StatusSeparator
 
 	builder := text.NewBuilder()
 
@@ -70,7 +88,7 @@ func (s *Status) formatStatus(status int, pipeStatus string) string {
 	for i, codeStr := range splitted {
 		write := func(txt string) {
 			if i > 0 {
-				builder.WriteString(StatusSeparator)
+				builder.WriteString(statusSeparator)
 			}
 			builder.WriteString(txt)
 		}

src/segments/typed_base.go

@@ -0,0 +1,49 @@
+package segments
+
+import (
+	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
+)
+
+// SegmentBase provides base functionality for typed segments
+type SegmentBase struct {
+	// Runtime-only fields (not serialized)
+	env   runtime.Environment `json:"-" toml:"-" yaml:"-"`
+	text  string              `json:"-" toml:"-" yaml:"-"`
+	index int                 `json:"-" toml:"-" yaml:"-"`
+}
+
+// SetText sets the rendered text
+func (s *SegmentBase) SetText(text string) {
+	s.text = text
+}
+
+// Text returns the rendered text
+func (s *SegmentBase) Text() string {
+	return s.text
+}
+
+// SetIndex sets the segment index
+func (s *SegmentBase) SetIndex(index int) {
+	s.index = index
+}
+
+// Init initializes the segment with the runtime environment
+func (s *SegmentBase) Init(env runtime.Environment) {
+	s.env = env
+}
+
+// Env returns the runtime environment
+func (s *SegmentBase) Env() runtime.Environment {
+	return s.env
+}
+
+// CacheKey returns an empty cache key by default
+func (s *SegmentBase) CacheKey() (string, bool) {
+	return "", false
+}
+
+// TypedSegmentMarker is a marker interface to identify typed segments
+// Typed segments should implement this to distinguish from legacy property-based segments
+type TypedSegmentMarker interface {
+	IsTypedSegment()
+}