feat: expose segment output text

resolves #5750

src/config/migrate_test.go

@@ -81,6 +81,7 @@ func TestMigratePropertyKey(t *testing.T) {
 
 type MockedWriter struct {
 	template string
+	text     string
 }
 
 func (m *MockedWriter) Enabled() bool {
@@ -91,6 +92,14 @@ func (m *MockedWriter) Template() string {
 	return m.template
 }
 
+func (m *MockedWriter) Text() string {
+	return m.text
+}
+
+func (m *MockedWriter) SetText(text string) {
+	m.text = text
+}
+
 func (m *MockedWriter) Init(_ properties.Properties, _ runtime.Environment) {}
 
 func TestIconOverride(t *testing.T) {

src/config/segment.go

@@ -43,7 +43,6 @@ type Segment struct {
 	Cache                  *cache.Config  `json:"cache,omitempty" toml:"cache,omitempty"`
 	Filler                 string         `json:"filler,omitempty" toml:"filler,omitempty"`
 	styleCache             SegmentStyle
-	Text                   string `json:"-" toml:"-"`
 	name                   string
 	LeadingDiamond         string         `json:"leading_diamond,omitempty" toml:"leading_diamond,omitempty"`
 	TrailingDiamond        string         `json:"trailing_diamond,omitempty" toml:"trailing_diamond,omitempty"`
@@ -124,17 +123,26 @@ func (segment *Segment) Render() {
 		return
 	}
 
-	segment.Text = segment.string()
+	text := segment.string()
-	segment.Enabled = len(strings.ReplaceAll(segment.Text, " ", "")) > 0
+	segment.Enabled = len(strings.ReplaceAll(text, " ", "")) > 0
 
 	if !segment.Enabled {
 		segment.env.TemplateCache().RemoveSegmentData(segment.Name())
 		return
 	}
 
+	segment.writer.SetText(text)
 	segment.setCache()
 }
 
+func (segment *Segment) Text() string {
+	return segment.writer.Text()
+}
+
+func (segment *Segment) SetText(text string) {
+	segment.writer.SetText(text)
+}
+
 func (segment *Segment) ResolveForeground() color.Ansi {
 	if len(segment.ForegroundTemplates) != 0 {
 		match := segment.ForegroundTemplates.FirstMatch(segment.writer, segment.Foreground.String())
@@ -202,25 +210,17 @@ func (segment *Segment) restoreCache() bool {
 		return false
 	}
 
-	text, OK := segment.env.Session().Get(segment.textCacheKey())
+	data, OK := segment.env.Session().Get(segment.cacheKey())
 	if !OK {
 		return false
 	}
 
-	segment.env.DebugF("restored %s segment from cache", segment.Name())
-	segment.Text = text
-	segment.Enabled = true
-
-	data, OK := segment.env.Session().Get(segment.writerCacheKey())
-	if !OK {
-		return true
-	}
-
 	err := json.Unmarshal([]byte(data), &segment.writer)
 	if err != nil {
 		segment.env.Error(err)
 	}
 
+	segment.Enabled = true
 	segment.env.TemplateCache().AddSegmentData(segment.Name(), segment.writer)
 
 	return true
@@ -231,26 +231,17 @@ func (segment *Segment) setCache() {
 		return
 	}
 
-	segment.env.Session().Set(segment.textCacheKey(), segment.Text, segment.Cache.Duration)
-
 	data, err := json.Marshal(segment.writer)
 	if err != nil {
 		segment.env.Error(err)
 		return
 	}
 
-	segment.env.Session().Set(segment.writerCacheKey(), string(data), segment.Cache.Duration)
+	segment.env.Session().Set(segment.cacheKey(), string(data), segment.Cache.Duration)
 }
 
-func (segment *Segment) textCacheKey() string {
+func (segment *Segment) cacheKey() string {
-	return segment.cacheKey("segment_cache_%s")
+	format := "segment_cache_%s"
-}
-
-func (segment *Segment) writerCacheKey() string {
-	return segment.cacheKey("segment_cache_writer_%s")
-}
-
-func (segment *Segment) cacheKey(format string) string {
 	switch segment.Cache.Strategy {
 	case cache.Session:
 		return fmt.Sprintf(format, segment.Name())

src/config/segment_types.go

@@ -15,6 +15,8 @@ type SegmentType string
 type SegmentWriter interface {
 	Enabled() bool
 	Template() string
+	SetText(text string)
+	Text() string
 	Init(props properties.Properties, env runtime.Environment)
 }
 
@@ -320,7 +322,11 @@ func (segment *Segment) MapSegmentWithWriter(env runtime.Environment) error {
 		segment.Properties = make(properties.Map)
 	}
 
-	if f, ok := Segments[segment.Type]; ok {
+	f, ok := Segments[segment.Type]
+	if !ok {
+		return errors.New("unable to map writer")
+	}
+
 	writer := f()
 	wrapper := &properties.Wrapper{
 		Properties: segment.Properties,
@@ -329,6 +335,3 @@ func (segment *Segment) MapSegmentWithWriter(env runtime.Environment) error {
 	segment.writer = writer
 	return nil
 }
-
-	return errors.New("unable to map writer")
-}

src/prompt/debug.go

@@ -21,14 +21,16 @@ func (e *Engine) PrintDebug(startTime time.Time, version string) string {
 	// console title timing
 	titleStartTime := time.Now()
 	e.Env.Debug("segment: Title")
-	title := e.getTitleTemplateText()
 	consoleTitle := &config.Segment{
 		Alias:      "ConsoleTitle",
 		NameLength: 12,
 		Enabled:    len(e.Config.ConsoleTitleTemplate) > 0,
-		Text:       title,
 		Duration:   time.Since(titleStartTime),
+		Type:       config.TEXT,
 	}
+	_ = consoleTitle.MapSegmentWithWriter(e.Env)
+	consoleTitle.SetText(e.getTitleTemplateText())
+
 	largestSegmentNameLength := consoleTitle.NameLength
 
 	// render prompt

src/prompt/engine.go

@@ -267,7 +267,7 @@ func (e *Engine) renderActiveSegment() {
 
 	switch e.activeSegment.ResolveStyle() {
 	case config.Plain, config.Powerline:
-		terminal.Write(color.Background, color.Foreground, e.activeSegment.Text)
+		terminal.Write(color.Background, color.Foreground, e.activeSegment.Text())
 	case config.Diamond:
 		background := color.Transparent
 
@@ -276,10 +276,10 @@ func (e *Engine) renderActiveSegment() {
 		}
 
 		terminal.Write(background, color.Background, e.activeSegment.LeadingDiamond)
-		terminal.Write(color.Background, color.Foreground, e.activeSegment.Text)
+		terminal.Write(color.Background, color.Foreground, e.activeSegment.Text())
 	case config.Accordion:
 		if e.activeSegment.Enabled {
-			terminal.Write(color.Background, color.Foreground, e.activeSegment.Text)
+			terminal.Write(color.Background, color.Foreground, e.activeSegment.Text())
 		}
 	}
 

src/segments/angular.go

@@ -2,9 +2,6 @@ package segments
 
 import (
 	"path/filepath"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Angular struct {
@@ -15,22 +12,16 @@ func (a *Angular) Template() string {
 	return languageTemplate
 }
 
-func (a *Angular) Init(props properties.Properties, env runtime.Environment) {
+func (a *Angular) Enabled() bool {
-	a.language = language{
+	a.extensions = []string{"angular.json"}
-		env:        env,
+	a.commands = []*cmd{
-		props:      props,
-		extensions: []string{"angular.json"},
-		commands: []*cmd{
 		{
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 			getVersion: a.getVersion,
 		},
-		},
-		versionURLTemplate: "https://github.com/angular/angular/releases/tag/{{.Full}}",
-	}
 	}
+	a.versionURLTemplate = "https://github.com/angular/angular/releases/tag/{{.Full}}"
 
-func (a *Angular) Enabled() bool {
 	return a.language.Enabled()
 }
 

src/segments/argocd.go

@@ -6,8 +6,6 @@ import (
 	"path"
 	"strings"
 
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"github.com/spf13/pflag"
 	"gopkg.in/yaml.v3"
 )
@@ -33,8 +31,7 @@ type ArgocdConfig struct {
 }
 
 type Argocd struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	ArgocdContext
 }
@@ -43,11 +40,6 @@ func (a *Argocd) Template() string {
 	return NameTemplate
 }
 
-func (a *Argocd) Init(props properties.Properties, env runtime.Environment) {
-	a.props = props
-	a.env = env
-}
-
 func (a *Argocd) Enabled() bool {
 	// always parse config instead of using cli to save time
 	configPath := a.getConfigPath()

src/segments/argocd_test.go

@@ -37,8 +37,10 @@ func TestArgocdGetConfigFromOpts(t *testing.T) {
 		env.On("Getenv", argocdOptsEnv).Return(tc.Opts)
 
 		argocd := &Argocd{
+			base: base{
 				env:   env,
 				props: properties.Map{},
+			},
 		}
 		config := argocd.getConfigFromOpts()
 		assert.Equal(t, tc.Expected, config, tc.Case)
@@ -63,8 +65,10 @@ func TestArgocdGetConfigPath(t *testing.T) {
 		env.On("Getenv", argocdOptsEnv).Return(tc.Opts)
 
 		argocd := &Argocd{
+			base: base{
 				env:   env,
 				props: properties.Map{},
+			},
 		}
 		assert.Equal(t, tc.Expected, argocd.getConfigPath())
 	}
@@ -159,8 +163,10 @@ users:
 		env.On("Error", testify_.Anything).Return()
 
 		argocd := &Argocd{
+			base: base{
 				env:   env,
 				props: properties.Map{},
+			},
 		}
 		if len(tc.ExpectedError) > 0 {
 			_, err := argocd.parseConfig(configFile)
@@ -254,10 +260,8 @@ servers:
 		env.On("Error", testify_.Anything).Return()
 		env.On("Flags").Return(&runtime.Flags{})
 
-		argocd := &Argocd{
+		argocd := &Argocd{}
-			env:   env,
+		argocd.Init(properties.Map{}, env)
-			props: properties.Map{},
-		}
 
 		assert.Equal(t, tc.ExpectedEnabled, argocd.Enabled(), tc.Case)
 

src/segments/aws.go

@@ -5,12 +5,10 @@ import (
 	"strings"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Aws struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Profile string
 	Region  string
@@ -24,11 +22,6 @@ func (a *Aws) Template() string {
 	return " {{ .Profile }}{{ if .Region }}@{{ .Region }}{{ end }} "
 }
 
-func (a *Aws) Init(props properties.Properties, env runtime.Environment) {
-	a.props = props
-	a.env = env
-}
-
 func (a *Aws) Enabled() bool {
 	getEnvFirstMatch := func(envs ...string) string {
 		for _, env := range envs {

src/segments/aws_test.go

@@ -66,10 +66,8 @@ func TestAWSSegment(t *testing.T) {
 		}
 		env.On("Flags").Return(&runtime.Flags{})
 
-		aws := &Aws{
+		aws := &Aws{}
-			env:   env,
+		aws.Init(props, env)
-			props: props,
-		}
 
 		if tc.Template == "" {
 			tc.Template = aws.Template()

src/segments/az.go

@@ -7,12 +7,11 @@ import (
 	"strings"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Az struct {
-	props  properties.Properties
+	base
-	env    runtime.Environment
+
 	Origin string
 	AzureSubscription
 }
@@ -75,11 +74,6 @@ func (a *Az) Template() string {
 	return NameTemplate
 }
 
-func (a *Az) Init(props properties.Properties, env runtime.Environment) {
-	a.props = props
-	a.env = env
-}
-
 func (a *Az) Enabled() bool {
 	source := a.props.GetString(Source, FirstMatch)
 	switch source {

src/segments/az_functions.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type AzFunc struct {
 	language
 }
@@ -13,21 +8,16 @@ func (az *AzFunc) Template() string {
 	return languageTemplate
 }
 
-func (az *AzFunc) Init(props properties.Properties, env runtime.Environment) {
+func (az *AzFunc) Enabled() bool {
-	az.language = language{
+	az.extensions = []string{"host.json", "local.settings.json", "function.json"}
-		env:        env,
+	az.commands = []*cmd{
-		props:      props,
-		extensions: []string{"host.json", "local.settings.json", "function.json"},
-		commands: []*cmd{
 		{
+
 			executable: "func",
 			args:       []string{"--version"},
 			regex:      `(?P<version>[0-9.]+)`,
 		},
-		},
-	}
 	}
 
-func (az *AzFunc) Enabled() bool {
 	return az.language.Enabled()
 }

src/segments/az_test.go

@@ -140,12 +140,9 @@ func TestAzSegment(t *testing.T) {
 			tc.Source = FirstMatch
 		}
 
-		az := &Az{
+		az := &Az{}
-			env: env,
+		az.Init(properties.Map{}, env)
-			props: properties.Map{
+
-				Source: tc.Source,
-			},
-		}
 		assert.Equal(t, tc.ExpectedEnabled, az.Enabled(), tc.Case)
 		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, az), tc.Case)
 	}

src/segments/azd.go

@@ -4,14 +4,10 @@ import (
 	"encoding/json"
 	"path/filepath"
 	"strings"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Azd struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	azdConfig
 }
@@ -25,11 +21,6 @@ func (t *Azd) Template() string {
 	return " \uebd8 {{ .DefaultEnvironment }} "
 }
 
-func (t *Azd) Init(props properties.Properties, env runtime.Environment) {
-	t.props = props
-	t.env = env
-}
-
 func (t *Azd) Enabled() bool {
 	var parentFilePath string
 

src/segments/azd_test.go

@@ -62,10 +62,8 @@ func TestAzdSegment(t *testing.T) {
 			env.On("HasParentFilePath", ".azure", false).Return(&runtime.FileInfo{}, errors.New("no such file or directory"))
 		}
 
-		azd := Azd{
+		azd := Azd{}
-			env:   env,
+		azd.Init(properties.Map{}, env)
-			props: properties.Map{},
-		}
 
 		assert.Equal(t, tc.ExpectedEnabled, azd.Enabled(), tc.Case)
 		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, azd), tc.Case)

src/segments/base.go

@@ -0,0 +1,26 @@
+package segments
+
+import (
+	"github.com/jandedobbeleer/oh-my-posh/src/properties"
+	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
+)
+
+type base struct {
+	props properties.Properties
+	env   runtime.Environment
+
+	Output string `json:"Text"`
+}
+
+func (s *base) Text() string {
+	return s.Output
+}
+
+func (s *base) SetText(text string) {
+	s.Output = text
+}
+
+func (s *base) Init(props properties.Properties, env runtime.Environment) {
+	s.props = props
+	s.env = env
+}

src/segments/battery.go

@@ -2,13 +2,11 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime/battery"
 )
 
 type Battery struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	*battery.Info
 	Error string
@@ -83,8 +81,3 @@ func (b *Battery) enabledWhileError(err error) bool {
 	b.State = battery.Full
 	return true
 }
-
-func (b *Battery) Init(props properties.Properties, env runtime.Environment) {
-	b.props = props
-	b.env = env
-}

src/segments/bazel.go

@@ -2,7 +2,6 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Bazel struct {
@@ -15,29 +14,24 @@ const (
 	Icon properties.Property = "icon"
 )
 
-func (c *Bazel) Template() string {
+func (b *Bazel) Template() string {
 	return " {{ if .Error }}{{ .Icon }} {{ .Error }}{{ else }}{{ url .Icon .URL }} {{ .Full }}{{ end }} "
 }
 
-func (c *Bazel) Init(props properties.Properties, env runtime.Environment) {
+func (b *Bazel) Enabled() bool {
-	c.language = language{
+	b.extensions = []string{"*.bazel", "*.bzl", "BUILD", "WORKSPACE", ".bazelrc", ".bazelversion"}
-		env:        env,
+	b.folders = []string{"bazel-bin", "bazel-out", "bazel-testlogs"}
-		props:      props,
+	b.commands = []*cmd{
-		extensions: []string{"*.bazel", "*.bzl", "BUILD", "WORKSPACE", ".bazelrc", ".bazelversion"},
-		folders:    []string{"bazel-bin", "bazel-out", "bazel-testlogs"},
-		commands: []*cmd{
 		{
 			executable: "bazel",
 			args:       []string{"--version"},
 			regex:      `bazel (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
+	}
 	// Use the correct URL for Bazel >5.4.1, since they do not have the docs subdomain.
-		versionURLTemplate: "https://{{ if lt .Major 6 }}docs.{{ end }}bazel.build/versions/{{ .Major }}.{{ .Minor }}.{{ .Patch }}",
+	b.versionURLTemplate = "https://{{ if lt .Major 6 }}docs.{{ end }}bazel.build/versions/{{ .Major }}.{{ .Minor }}.{{ .Patch }}"
-	}
-	c.Icon = props.GetString(Icon, "\ue63a")
-}
 
-func (c *Bazel) Enabled() bool {
+	b.Icon = b.props.GetString(Icon, "\ue63a")
-	return c.language.Enabled()
+
+	return b.language.Enabled()
 }

src/segments/brewfather.go

@@ -11,13 +11,12 @@ import (
 	"time"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 // segment struct, makes templating easier
 type Brewfather struct {
-	props                  properties.Properties
+	base
-	env                    runtime.Environment
+
 	DaysBottledOrFermented *uint
 	TemperatureTrendIcon   string
 	StatusIcon             string
@@ -276,8 +275,3 @@ func (bf *Brewfather) SGToPlato(sg float64) float64 {
 	// from https://en.wikipedia.org/wiki/Brix#Specific_gravity_2
 	return math.Round(100*((135.997*sg*sg*sg)-(630.272*sg*sg)+(1111.14*sg)-616.868)) / 100 // 2 decimal places
 }
-
-func (bf *Brewfather) Init(props properties.Properties, env runtime.Environment) {
-	bf.props = props
-	bf.env = env
-}

src/segments/brewfather_test.go

@@ -156,20 +156,18 @@ func TestBrewfatherSegment(t *testing.T) {
 		env.On("HTTPRequest", BFBatchReadingsURL).Return([]byte(tc.BatchReadingsJSONResponse), tc.Error)
 		env.On("Flags").Return(&runtime.Flags{})
 
-		ns := &Brewfather{
+		brew := &Brewfather{}
-			props: props,
+		brew.Init(props, env)
-			env:   env,
-		}
 
-		enabled := ns.Enabled()
+		enabled := brew.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
 		if !enabled {
 			continue
 		}
 
 		if tc.Template == "" {
-			tc.Template = ns.Template()
+			tc.Template = brew.Template()
 		}
-		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, ns), tc.Case)
+		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, brew), tc.Case)
 	}
 }

src/segments/buf.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Buf struct {
 	language
 }
@@ -13,22 +8,16 @@ func (b *Buf) Template() string {
 	return languageTemplate
 }
 
-func (b *Buf) Init(props properties.Properties, env runtime.Environment) {
+func (b *Buf) Enabled() bool {
-	b.language = language{
+	b.extensions = []string{"buf.yaml", "buf.gen.yaml", "buf.work.yaml"}
-		env:        env,
+	b.commands = []*cmd{
-		props:      props,
-		extensions: []string{"buf.yaml", "buf.gen.yaml", "buf.work.yaml"},
-		commands: []*cmd{
 		{
 			executable: "buf",
 			args:       []string{"--version"},
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/bufbuild/buf/releases/tag/v{{.Full}}",
-	}
 	}
+	b.versionURLTemplate = "https://github.com/bufbuild/buf/releases/tag/v{{.Full}}"
 
-func (b *Buf) Enabled() bool {
 	return b.language.Enabled()
 }

src/segments/bun.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Bun struct {
 	language
 }
@@ -13,22 +8,16 @@ func (b *Bun) Template() string {
 	return languageTemplate
 }
 
-func (b *Bun) Init(props properties.Properties, env runtime.Environment) {
+func (b *Bun) Enabled() bool {
-	b.language = language{
+	b.extensions = []string{"bun.lockb"}
-		env:        env,
+	b.commands = []*cmd{
-		props:      props,
-		extensions: []string{"bun.lockb"},
-		commands: []*cmd{
 		{
 			executable: "bun",
 			args:       []string{"--version"},
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/oven-sh/bun/releases/tag/bun-v{{.Full}}",
-	}
 	}
+	b.versionURLTemplate = "https://github.com/oven-sh/bun/releases/tag/bun-v{{.Full}}"
 
-func (b *Bun) Enabled() bool {
 	return b.language.Enabled()
 }

src/segments/carbon_intensity.go

@@ -5,12 +5,10 @@ import (
 	"fmt"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type CarbonIntensity struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	TrendIcon string
 
@@ -126,8 +124,3 @@ func (d *CarbonIntensity) setStatus() error {
 
 	return nil
 }
-
-func (d *CarbonIntensity) Init(props properties.Properties, env runtime.Environment) {
-	d.props = props
-	d.env = env
-}

src/segments/carbon_intensity_test.go

@@ -229,10 +229,8 @@ func TestCarbonIntensitySegmentSingle(t *testing.T) {
 		env.On("Error", testify_.Anything)
 		env.On("Flags").Return(&runtime.Flags{})
 
-		d := &CarbonIntensity{
+		d := &CarbonIntensity{}
-			props: props,
+		d.Init(props, env)
-			env:   env,
-		}
 
 		enabled := d.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)

src/segments/cds.go

@@ -2,9 +2,6 @@ package segments
 
 import (
 	"encoding/json"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Cds struct {
@@ -16,25 +13,20 @@ func (c *Cds) Template() string {
 	return languageTemplate
 }
 
-func (c *Cds) Init(props properties.Properties, env runtime.Environment) {
+func (c *Cds) Enabled() bool {
-	c.language = language{
+	c.extensions = []string{".cdsrc.json", ".cdsrc-private.json", "*.cds"}
-		env:        env,
+	c.commands = []*cmd{
-		props:      props,
-		extensions: []string{".cdsrc.json", ".cdsrc-private.json", "*.cds"},
-		commands: []*cmd{
 		{
 			executable: "cds",
 			args:       []string{"--version"},
 			regex:      `@sap/cds: (?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		loadContext: c.loadContext,
-		inContext:   c.inContext,
-		displayMode: props.GetString(DisplayMode, DisplayModeContext),
-	}
 	}
+	//TODO: is this necessary?
+	c.language.loadContext = c.loadContext
+	c.language.inContext = c.inContext
+	c.displayMode = c.props.GetString(DisplayMode, DisplayModeContext)
 
-func (c *Cds) Enabled() bool {
 	return c.language.Enabled()
 }
 

src/segments/cf.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Cf struct {
 	language
 }
@@ -13,23 +8,17 @@ func (c *Cf) Template() string {
 	return languageTemplate
 }
 
-func (c *Cf) Init(props properties.Properties, env runtime.Environment) {
+func (c *Cf) Enabled() bool {
-	c.language = language{
+	c.extensions = []string{"manifest.yml", "mta.yaml"}
-		env:        env,
+	c.commands = []*cmd{
-		props:      props,
-		extensions: []string{"manifest.yml", "mta.yaml"},
-		commands: []*cmd{
 		{
 			executable: "cf",
 			args:       []string{"version"},
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		displayMode:        props.GetString(DisplayMode, DisplayModeFiles),
-		versionURLTemplate: "https://github.com/cloudfoundry/cli/releases/tag/v{{ .Full }}",
-	}
 	}
+	c.displayMode = c.props.GetString(DisplayMode, DisplayModeFiles)
+	c.versionURLTemplate = "https://github.com/cloudfoundry/cli/releases/tag/v{{ .Full }}"
 
-func (c *Cf) Enabled() bool {
 	return c.language.Enabled()
 }

src/segments/cf_target.go

@@ -5,12 +5,10 @@ import (
 	"strings"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type CfTarget struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	CfTargetDetails
 }
@@ -26,11 +24,6 @@ func (c *CfTarget) Template() string {
 	return "{{if .Org }}{{ .Org }}{{ end }}{{if .Space }}/{{ .Space }}{{ end }}"
 }
 
-func (c *CfTarget) Init(props properties.Properties, env runtime.Environment) {
-	c.props = props
-	c.env = env
-}
-
 func (c *CfTarget) Enabled() bool {
 	if !c.env.HasCommand("cf") {
 		return false

src/segments/cmake.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Cmake struct {
 	language
 }
@@ -13,22 +8,16 @@ func (c *Cmake) Template() string {
 	return languageTemplate
 }
 
-func (c *Cmake) Init(props properties.Properties, env runtime.Environment) {
+func (c *Cmake) Enabled() bool {
-	c.language = language{
+	c.extensions = []string{"*.cmake", "CMakeLists.txt"}
-		env:        env,
+	c.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.cmake", "CMakeLists.txt"},
-		commands: []*cmd{
 		{
 			executable: "cmake",
 			args:       []string{"--version"},
 			regex:      `cmake version (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://cmake.org/cmake/help/v{{ .Major }}.{{ .Minor }}",
-	}
 	}
+	c.versionURLTemplate = "https://cmake.org/cmake/help/v{{ .Major }}.{{ .Minor }}"
 
-func (c *Cmake) Enabled() bool {
 	return c.language.Enabled()
 }

src/segments/command.go

@@ -4,12 +4,10 @@ import (
 	"strings"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Cmd struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Output string
 }
@@ -85,8 +83,3 @@ func (c *Cmd) runScript(shell, script string) bool {
 	c.Output = c.env.RunShellCommand(shell, script)
 	return len(c.Output) != 0
 }
-
-func (c *Cmd) Init(props properties.Properties, env runtime.Environment) {
-	c.props = props
-	c.env = env
-}

src/segments/command_test.go

@@ -16,10 +16,10 @@ func TestExecuteCommand(t *testing.T) {
 	props := properties.Map{
 		Command: "echo hello",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.True(t, enabled)
 	assert.Equal(t, "hello", renderTemplate(env, c.Template(), c))
@@ -34,10 +34,10 @@ func TestExecuteMultipleCommandsOrFirst(t *testing.T) {
 	props := properties.Map{
 		Command: "exit 1 || echo hello",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.True(t, enabled)
 	assert.Equal(t, "hello", renderTemplate(env, c.Template(), c))
@@ -51,10 +51,10 @@ func TestExecuteMultipleCommandsOrSecond(t *testing.T) {
 	props := properties.Map{
 		Command: "echo hello || echo world",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.True(t, enabled)
 	assert.Equal(t, "hello", renderTemplate(env, c.Template(), c))
@@ -68,10 +68,10 @@ func TestExecuteMultipleCommandsAnd(t *testing.T) {
 	props := properties.Map{
 		Command: "echo hello && echo world",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.True(t, enabled)
 	assert.Equal(t, "helloworld", renderTemplate(env, c.Template(), c))
@@ -84,10 +84,10 @@ func TestExecuteSingleCommandEmpty(t *testing.T) {
 	props := properties.Map{
 		Command: "",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.False(t, enabled)
 }
@@ -97,10 +97,10 @@ func TestExecuteSingleCommandNoCommandProperty(t *testing.T) {
 	env.On("HasCommand", "bash").Return(true)
 	env.On("RunShellCommand", "bash", "").Return("")
 	var props properties.Map
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.False(t, enabled)
 }
@@ -112,10 +112,10 @@ func TestExecuteMultipleCommandsAndDisabled(t *testing.T) {
 	props := properties.Map{
 		Command: "echo && echo",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.False(t, enabled)
 }
@@ -128,10 +128,10 @@ func TestExecuteMultipleCommandsOrDisabled(t *testing.T) {
 	props := properties.Map{
 		Command: "echo|| echo",
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.False(t, enabled)
 }
@@ -144,10 +144,10 @@ func TestExecuteNonInterpretedCommand(t *testing.T) {
 		Command:   "echo hello && echo world",
 		Interpret: false,
 	}
-	c := &Cmd{
+
-		props: props,
+	c := &Cmd{}
-		env:   env,
+	c.Init(props, env)
-	}
+
 	enabled := c.Enabled()
 	assert.True(t, enabled)
 	assert.Equal(t, "hello world", renderTemplate(env, c.Template(), c))
@@ -180,10 +180,10 @@ func TestExecuteScript(t *testing.T) {
 		props := properties.Map{
 			Script: script,
 		}
-		c := &Cmd{
+
-			props: props,
+		c := &Cmd{}
-			env:   env,
+		c.Init(props, env)
-		}
+
 		enabled := c.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
 		if tc.ExpectedEnabled {

src/segments/connection.go

@@ -8,8 +8,7 @@ import (
 )
 
 type Connection struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	runtime.Connection
 }
@@ -35,8 +34,3 @@ func (c *Connection) Enabled() bool {
 	}
 	return false
 }
-
-func (c *Connection) Init(props properties.Properties, env runtime.Environment) {
-	c.props = props
-	c.env = env
-}

src/segments/connection_test.go

@@ -92,12 +92,14 @@ func TestConnection(t *testing.T) {
 		for _, con := range tc.Connections {
 			env.On("Connection", con.Connection.Type).Return(con.Connection, con.Error)
 		}
-		c := &Connection{
+
-			env: env,
+		props := &properties.Map{
-			props: &properties.Map{
 			Type: tc.ConnectionType,
-			},
 		}
+
+		c := &Connection{}
+		c.Init(props, env)
+
 		assert.Equal(t, tc.ExpectedEnabled, c.Enabled(), fmt.Sprintf("Failed in case: %s", tc.Case))
 		if tc.ExpectedEnabled {
 			assert.Equal(t, tc.ExpectedString, renderTemplate(env, c.Template(), c), fmt.Sprintf("Failed in case: %s", tc.Case))

src/segments/crystal.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Crystal struct {
 	language
 }
@@ -13,22 +8,16 @@ func (c *Crystal) Template() string {
 	return languageTemplate
 }
 
-func (c *Crystal) Init(props properties.Properties, env runtime.Environment) {
+func (c *Crystal) Enabled() bool {
-	c.language = language{
+	c.extensions = []string{"*.cr", "shard.yml"}
-		env:        env,
+	c.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.cr", "shard.yml"},
-		commands: []*cmd{
 		{
 			executable: "crystal",
 			args:       []string{"--version"},
 			regex:      `Crystal (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/crystal-lang/crystal/releases/tag/{{ .Full }}",
-	}
 	}
+	c.versionURLTemplate = "https://github.com/crystal-lang/crystal/releases/tag/{{ .Full }}"
 
-func (c *Crystal) Enabled() bool {
 	return c.language.Enabled()
 }

src/segments/dart.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 var (
 	dartExtensions = []string{"*.dart", "pubspec.yaml", "pubspec.yml", "pubspec.lock"}
 	dartFolders    = []string{".dart_tool"}
@@ -18,23 +13,17 @@ func (d *Dart) Template() string {
 	return languageTemplate
 }
 
-func (d *Dart) Init(props properties.Properties, env runtime.Environment) {
+func (d *Dart) Enabled() bool {
-	d.language = language{
+	d.extensions = dartExtensions
-		env:        env,
+	d.folders = dartFolders
-		props:      props,
+	d.commands = []*cmd{
-		extensions: dartExtensions,
-		folders:    dartFolders,
-		commands: []*cmd{
 		{
 			executable: "dart",
 			args:       []string{"--version"},
 			regex:      `Dart SDK version: (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://dart.dev/guides/language/evolution#dart-{{ .Major }}{{ .Minor }}",
-	}
 	}
+	d.versionURLTemplate = "https://dart.dev/guides/language/evolution#dart-{{ .Major }}{{ .Minor }}"
 
-func (d *Dart) Enabled() bool {
 	return d.language.Enabled()
 }

src/segments/deno.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Deno struct {
 	language
 }
@@ -13,22 +8,16 @@ func (d *Deno) Template() string {
 	return languageTemplate
 }
 
-func (d *Deno) Init(props properties.Properties, env runtime.Environment) {
+func (d *Deno) Enabled() bool {
-	d.language = language{
+	d.extensions = []string{"*.js", "*.ts", "deno.json"}
-		env:        env,
+	d.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.js", "*.ts", "deno.json"},
-		commands: []*cmd{
 		{
 			executable: "deno",
 			args:       []string{"--version"},
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/denoland/deno/releases/tag/v{{.Full}}",
-	}
 	}
+	d.versionURLTemplate = "https://github.com/denoland/deno/releases/tag/v{{.Full}}"
 
-func (d *Deno) Enabled() bool {
 	return d.language.Enabled()
 }

src/segments/docker.go

@@ -3,9 +3,6 @@ package segments
 import (
 	"encoding/json"
 	"path/filepath"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type DockerConfig struct {
@@ -13,8 +10,7 @@ type DockerConfig struct {
 }
 
 type Docker struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Context string
 }
@@ -23,11 +19,6 @@ func (d *Docker) Template() string {
 	return " \uf308 {{ .Context }} "
 }
 
-func (d *Docker) Init(props properties.Properties, env runtime.Environment) {
-	d.props = props
-	d.env = env
-}
-
 func (d *Docker) envVars() []string {
 	return []string{"DOCKER_MACHINE_NAME", "DOCKER_HOST", "DOCKER_CONTEXT"}
 }

src/segments/dotnet.go

@@ -2,8 +2,6 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/constants"
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Dotnet struct {
@@ -16,24 +14,30 @@ func (d *Dotnet) Template() string {
 	return " {{ if .Unsupported }}\uf071{{ else }}{{ .Full }}{{ end }} "
 }
 
-func (d *Dotnet) Init(props properties.Properties, env runtime.Environment) {
+func (d *Dotnet) Enabled() bool {
-	d.language = language{
+	d.extensions = []string{
-		env:        env,
+		"*.cs",
-		props:      props,
+		"*.csx",
-		extensions: []string{"*.cs", "*.csx", "*.vb", "*.sln", "*.slnf", "*.csproj", "*.vbproj", "*.fs", "*.fsx", "*.fsproj", "global.json"},
+		"*.vb",
-		commands: []*cmd{
+		"*.sln",
+		"*.slnf",
+		"*.csproj",
+		"*.vbproj",
+		"*.fs",
+		"*.fsx",
+		"*.fsproj",
+		"global.json",
+	}
+	d.commands = []*cmd{
 		{
 			executable: "dotnet",
 			args:       []string{"--version"},
 			regex: `(?P<version>((?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)` +
 				`(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/dotnet/core/blob/master/release-notes/{{ .Major }}.{{ .Minor }}/{{ .Major }}.{{ .Minor }}.{{ substr 0 1 .Patch }}/{{ .Major }}.{{ .Minor }}.{{ substr 0 1 .Patch }}.md", //nolint: lll
-	}
 	}
+	d.versionURLTemplate = "https://github.com/dotnet/core/blob/master/release-notes/{{ .Major }}.{{ .Minor }}/{{ .Major }}.{{ .Minor }}.{{ substr 0 1 .Patch }}/{{ .Major }}.{{ .Minor }}.{{ substr 0 1 .Patch }}.md" //nolint: lll
 
-func (d *Dotnet) Enabled() bool {
 	enabled := d.language.Enabled()
 	if !enabled {
 		return false

src/segments/elixir.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Elixir struct {
 	language
 }
@@ -13,12 +8,9 @@ func (e *Elixir) Template() string {
 	return languageTemplate
 }
 
-func (e *Elixir) Init(props properties.Properties, env runtime.Environment) {
+func (e *Elixir) Enabled() bool {
-	e.language = language{
+	e.extensions = []string{"*.ex", "*.exs"}
-		env:        env,
+	e.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.ex", "*.exs"},
-		commands: []*cmd{
 		{
 			executable: "asdf",
 			args:       []string{"current", "elixir"},
@@ -29,11 +21,8 @@ func (e *Elixir) Init(props properties.Properties, env runtime.Environment) {
 			args:       []string{"--version"},
 			regex:      `Elixir (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/elixir-lang/elixir/releases/tag/v{{ .Full }}",
-	}
 	}
+	e.versionURLTemplate = "https://github.com/elixir-lang/elixir/releases/tag/v{{ .Full }}"
 
-func (e *Elixir) Enabled() bool {
 	return e.language.Enabled()
 }

src/segments/executiontime.go

@@ -5,15 +5,13 @@ import (
 	"strconv"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 
 	lang "golang.org/x/text/language"
 	"golang.org/x/text/message"
 )
 
 type Executiontime struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	FormattedMs string
 	Ms          int64
@@ -70,11 +68,6 @@ func (t *Executiontime) Template() string {
 	return " {{ .FormattedMs }} "
 }
 
-func (t *Executiontime) Init(props properties.Properties, env runtime.Environment) {
-	t.props = props
-	t.env = env
-}
-
 func (t *Executiontime) formatDuration(style DurationStyle) string {
 	switch style {
 	case Austin:

src/segments/executiontime_test.go

@@ -14,20 +14,20 @@ import (
 func TestExecutionTimeWriterDefaultThresholdEnabled(t *testing.T) {
 	env := new(mock.Environment)
 	env.On("ExecutionTime").Return(1337)
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: properties.Map{},
+	executionTime.Init(properties.Map{}, env)
-	}
+
 	assert.True(t, executionTime.Enabled())
 }
 
 func TestExecutionTimeWriterDefaultThresholdDisabled(t *testing.T) {
 	env := new(mock.Environment)
 	env.On("ExecutionTime").Return(1)
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: properties.Map{},
+	executionTime.Init(properties.Map{}, env)
-	}
+
 	assert.False(t, executionTime.Enabled())
 }
 
@@ -37,10 +37,10 @@ func TestExecutionTimeWriterCustomThresholdEnabled(t *testing.T) {
 	props := properties.Map{
 		ThresholdProperty: float64(10),
 	}
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: props,
+	executionTime.Init(props, env)
-	}
+
 	assert.True(t, executionTime.Enabled())
 }
 
@@ -50,10 +50,10 @@ func TestExecutionTimeWriterCustomThresholdDisabled(t *testing.T) {
 	props := properties.Map{
 		ThresholdProperty: float64(100),
 	}
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: props,
+	executionTime.Init(props, env)
-	}
+
 	assert.False(t, executionTime.Enabled())
 }
 
@@ -62,10 +62,10 @@ func TestExecutionTimeWriterDuration(t *testing.T) {
 	expected := "1.337s"
 	env := new(mock.Environment)
 	env.On("ExecutionTime").Return(input)
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: properties.Map{},
+	executionTime.Init(properties.Map{}, env)
-	}
+
 	executionTime.Enabled()
 	assert.Equal(t, expected, executionTime.FormattedMs)
 }
@@ -75,10 +75,10 @@ func TestExecutionTimeWriterDuration2(t *testing.T) {
 	expected := "3h 42m 51.337s"
 	env := new(mock.Environment)
 	env.On("ExecutionTime").Return(input)
-	executionTime := &Executiontime{
+
-		env:   env,
+	executionTime := &Executiontime{}
-		props: properties.Map{},
+	executionTime.Init(properties.Map{}, env)
-	}
+
 	executionTime.Enabled()
 	assert.Equal(t, expected, executionTime.FormattedMs)
 }

src/segments/firebase.go

@@ -5,9 +5,6 @@ import (
 	"errors"
 	"path/filepath"
 	"strings"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 const (
@@ -15,8 +12,7 @@ const (
 )
 
 type Firebase struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Project string
 }
@@ -29,11 +25,6 @@ func (f *Firebase) Template() string {
 	return " {{ .Project}} "
 }
 
-func (f *Firebase) Init(props properties.Properties, env runtime.Environment) {
-	f.props = props
-	f.env = env
-}
-
 func (f *Firebase) Enabled() bool {
 	cfgDir := filepath.Join(f.env.Home(), ".config", "configstore")
 	configFile, err := f.getActiveConfig(cfgDir)

src/segments/firebase_test.go

@@ -4,6 +4,7 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime/mock"
 	"github.com/stretchr/testify/assert"
 	testify_ "github.com/stretchr/testify/mock"
@@ -59,10 +60,12 @@ func TestFirebaseSegment(t *testing.T) {
 		fcPath := filepath.Join("home", ".config", "configstore", "firebase-tools.json")
 		env.On("FileContent", fcPath).Return(tc.ActiveConfig)
 		env.On("Error", testify_.Anything).Return()
-		f := Firebase{
+
-			env: env,
+		f := &Firebase{}
-		}
+		f.Init(properties.Map{}, env)
+
 		f.Enabled()
+
 		assert.Equal(t, tc.ExpectedEnabled, f.Enabled())
 		if tc.ExpectedEnabled {
 			assert.Equal(t, tc.ExpectedString, renderTemplate(env, f.Template(), f), tc.Case)
@@ -102,9 +105,10 @@ func TestGetFirebaseActiveConfig(t *testing.T) {
 		contentPath := filepath.Join(configPath, "firebase-tools.json")
 		env.On("FileContent", contentPath).Return(tc.ActiveConfig)
 		env.On("Error", testify_.Anything).Return()
-		f := Firebase{
+
-			env: env,
+		f := &Firebase{}
-		}
+		f.Init(properties.Map{}, env)
+
 		got, err := f.getActiveConfig(configPath)
 		assert.Equal(t, tc.ExpectedString, got, tc.Case)
 		if len(tc.ExpectedError) > 0 {

src/segments/flutter.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Flutter struct {
 	language
 }
@@ -13,23 +8,17 @@ func (f *Flutter) Template() string {
 	return languageTemplate
 }
 
-func (f *Flutter) Init(props properties.Properties, env runtime.Environment) {
+func (f *Flutter) Enabled() bool {
-	f.language = language{
+	f.extensions = dartExtensions
-		env:        env,
+	f.folders = dartFolders
-		props:      props,
+	f.commands = []*cmd{
-		extensions: dartExtensions,
-		folders:    dartFolders,
-		commands: []*cmd{
 		{
 			executable: "flutter",
 			args:       []string{"--version"},
 			regex:      `Flutter (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/flutter/flutter/releases/tag/{{ .Major }}.{{ .Minor }}.{{ .Patch }}",
-	}
 	}
+	f.versionURLTemplate = "https://github.com/flutter/flutter/releases/tag/{{ .Major }}.{{ .Minor }}.{{ .Patch }}"
 
-func (f *Flutter) Enabled() bool {
 	return f.language.Enabled()
 }

src/segments/fossil_test.go

@@ -67,13 +67,12 @@ func TestFossilStatus(t *testing.T) {
 		env.On("InWSLSharedDrive").Return(false)
 		env.On("HasCommand", FOSSILCOMMAND).Return(tc.HasCommand)
 		env.On("RunCommand", FOSSILCOMMAND, []string{"status"}).Return(strings.ReplaceAll(tc.Output, "\t", ""), tc.OutputError)
-		f := &Fossil{
+
-			scm: scm{
+		f := &Fossil{}
-				env:   env,
+		f.Init(properties.Map{}, env)
-				props: properties.Map{},
+
-			},
-		}
 		got := f.Enabled()
+
 		assert.Equal(t, !tc.ExpectedDisabled, got, tc.Case)
 		if tc.ExpectedDisabled {
 			continue

src/segments/gcp.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"path"
 
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 
 	"gopkg.in/ini.v1"
@@ -15,8 +14,7 @@ const (
 )
 
 type Gcp struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Account string
 	Project string
@@ -27,11 +25,6 @@ func (g *Gcp) Template() string {
 	return " {{ .Project }} "
 }
 
-func (g *Gcp) Init(props properties.Properties, env runtime.Environment) {
-	g.props = props
-	g.env = env
-}
-
 func (g *Gcp) Enabled() bool {
 	cfgDir := g.getConfigDirectory()
 	configFile, err := g.getActiveConfig(cfgDir)

src/segments/gcp_test.go

@@ -4,6 +4,7 @@ import (
 	"path"
 	"testing"
 
+	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime/mock"
 
@@ -58,9 +59,10 @@ func TestGcpSegment(t *testing.T) {
 		cfgpath := path.Join("config", "configurations", "config_production")
 		env.On("FileContent", cfgpath).Return(tc.CfgData)
 		env.On("Error", testify_.Anything).Return()
-		g := &Gcp{
+
-			env: env,
+		g := &Gcp{}
-		}
+		g.Init(properties.Map{}, env)
+
 		assert.Equal(t, tc.ExpectedEnabled, g.Enabled(), tc.Case)
 		if tc.ExpectedEnabled {
 			assert.Equal(t, tc.ExpectedString, renderTemplate(env, "{{.Project}} :: {{.Region}} :: {{.Account}}", g), tc.Case)
@@ -101,9 +103,10 @@ func TestGetConfigDirectory(t *testing.T) {
 		env.On("Getenv", "APPDATA").Return(tc.AppData)
 		env.On("Home").Return(tc.Home)
 		env.On("GOOS").Return(tc.GOOS)
-		g := &Gcp{
+
-			env: env,
+		g := &Gcp{}
-		}
+		g.Init(properties.Map{}, env)
+
 		assert.Equal(t, tc.Expected, g.getConfigDirectory(), tc.Case)
 	}
 }
@@ -129,9 +132,10 @@ func TestGetActiveConfig(t *testing.T) {
 	for _, tc := range cases {
 		env := new(mock.Environment)
 		env.On("FileContent", "active_config").Return(tc.ActiveConfig)
-		g := &Gcp{
+
-			env: env,
+		g := &Gcp{}
-		}
+		g.Init(properties.Map{}, env)
+
 		got, err := g.getActiveConfig("")
 		assert.Equal(t, tc.ExpectedString, got, tc.Case)
 		if len(tc.ExpectedError) > 0 {

src/segments/git_test.go

@@ -29,12 +29,10 @@ func TestEnabledGitNotFound(t *testing.T) {
 	env.On("HasCommand", "git").Return(false)
 	env.On("GOOS").Return("")
 	env.On("IsWsl").Return(false)
-	g := &Git{
+
-		scm: scm{
+	g := &Git{}
-			env:   env,
+	g.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		},
-	}
 	assert.False(t, g.Enabled())
 }
 
@@ -56,12 +54,10 @@ func TestEnabledInWorkingDirectory(t *testing.T) {
 	env.On("Home").Return(poshHome)
 	env.On("Getenv", poshGitEnv).Return("")
 	env.On("DirMatchesOneOf", testify_.Anything, testify_.Anything).Return(false)
-	g := &Git{
+
-		scm: scm{
+	g := &Git{}
-			env:   env,
+	g.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		},
-	}
 	assert.True(t, g.Enabled())
 	assert.Equal(t, fileInfo.Path, g.workingDir)
 }
@@ -138,12 +134,10 @@ func TestEnabledInWorktree(t *testing.T) {
 		env.On("HasFilesInDir", tc.WorkingFolder, tc.WorkingFolderAddon).Return(true)
 		env.On("HasFilesInDir", tc.WorkingFolder, "HEAD").Return(true)
 		env.On("PathSeparator").Return(string(os.PathSeparator))
-		g := &Git{
+
-			scm: scm{
+		g := &Git{}
-				env:   env,
+		g.Init(properties.Map{}, env)
-				props: properties.Map{},
+
-			},
-		}
 		assert.Equal(t, tc.ExpectedEnabled, g.hasWorktree(fileInfo), tc.Case)
 		assert.Equal(t, tc.ExpectedWorkingFolder, g.workingDir, tc.Case)
 		assert.Equal(t, tc.ExpectedRealFolder, g.realDir, tc.Case)
@@ -198,15 +192,15 @@ func TestEnabledInBareRepo(t *testing.T) {
 		env.On("FileContent", "/home/user/bare.git/HEAD").Return(tc.HEAD)
 		env.MockGitCommand(pwd, tc.Remote, "remote")
 		env.MockGitCommand(pwd, tc.RemoteURL, "remote", "get-url", tc.Remote)
-		g := &Git{
+
-			scm: scm{
+		props := properties.Map{
-				env: env,
-				props: properties.Map{
 			FetchBareInfo:     true,
 			FetchUpstreamIcon: tc.FetchRemote,
-				},
-			},
 		}
+
+		g := &Git{}
+		g.Init(props, env)
+
 		assert.Equal(t, g.Enabled(), tc.ExpectedEnabled, tc.Case)
 		assert.Equal(t, g.Ref, tc.ExpectedHEAD, tc.Case)
 		assert.Equal(t, g.UpstreamIcon, tc.ExpectedRemote, tc.Case)
@@ -221,13 +215,14 @@ func TestGetGitOutputForCommand(t *testing.T) {
 	env.On("IsWsl").Return(false)
 	env.On("RunCommand", "git", append(args, commandArgs...)).Return(want, nil)
 	env.On("GOOS").Return("unix")
+
 	g := &Git{
 		scm: scm{
-			env:     env,
-			props:   properties.Map{},
 			command: GITCOMMAND,
 		},
 	}
+	g.Init(properties.Map{}, env)
+
 	got := g.getGitCommandOutput(commandArgs...)
 	assert.Equal(t, want, got)
 }
@@ -366,10 +361,7 @@ func TestSetGitHEADContextClean(t *testing.T) {
 		env.On("HasFilesInDir", "", "sequencer/todo").Return(tc.Sequencer)
 		env.On("FileContent", "/sequencer/todo").Return(tc.Theirs)
 
-		g := &Git{
+		props := properties.Map{
-			scm: scm{
-				env: env,
-				props: properties.Map{
 			BranchIcon:     "branch ",
 			CommitIcon:     "commit ",
 			RebaseIcon:     "rebase ",
@@ -377,12 +369,17 @@ func TestSetGitHEADContextClean(t *testing.T) {
 			CherryPickIcon: "pick ",
 			TagIcon:        "tag ",
 			RevertIcon:     "revert ",
-				},
+		}
+
+		g := &Git{
+			scm: scm{
 				command: GITCOMMAND,
 			},
 			ShortHash: "1234567",
 			Ref:       tc.Ref,
 		}
+		g.Init(props, env)
+
 		g.setGitHEADContext()
 		assert.Equal(t, tc.Expected, g.HEAD, tc.Case)
 	}
@@ -409,18 +406,21 @@ func TestSetPrettyHEADName(t *testing.T) {
 		env.On("GOOS").Return("unix")
 		env.On("IsWsl").Return(false)
 		env.MockGitCommand("", tc.Tag, "describe", "--tags", "--exact-match")
-		g := &Git{
+
-			scm: scm{
+		props := properties.Map{
-				env: env,
-				props: properties.Map{
 			BranchIcon: "branch ",
 			CommitIcon: "commit ",
 			TagIcon:    "tag ",
-				},
+		}
+
+		g := &Git{
+			scm: scm{
 				command: GITCOMMAND,
 			},
 			ShortHash: tc.ShortHash,
 		}
+		g.Init(props, env)
+
 		g.setPrettyHEADName()
 		assert.Equal(t, tc.Expected, g.HEAD, tc.Case)
 	}
@@ -579,13 +579,14 @@ func TestSetGitStatus(t *testing.T) {
 		env.On("GOOS").Return("unix")
 		env.On("IsWsl").Return(false)
 		env.MockGitCommand("", strings.ReplaceAll(tc.Output, "\t", ""), "status", "-unormal", "--branch", "--porcelain=2")
+
 		g := &Git{
 			scm: scm{
-				env:     env,
-				props:   properties.Map{},
 				command: GITCOMMAND,
 			},
 		}
+		g.Init(properties.Map{}, env)
+
 		if tc.ExpectedWorking == nil {
 			tc.ExpectedWorking = &GitStatus{}
 		}
@@ -620,12 +621,14 @@ func TestGetStashContextZeroEntries(t *testing.T) {
 	for _, tc := range cases {
 		env := new(mock.Environment)
 		env.On("FileContent", "/logs/refs/stash").Return(tc.StashContent)
+
 		g := &Git{
 			scm: scm{
-				env:        env,
 				workingDir: "",
 			},
 		}
+		g.Init(properties.Map{}, env)
+
 		got := g.StashCount()
 		assert.Equal(t, tc.Expected, got)
 	}
@@ -697,14 +700,15 @@ func TestGitUpstream(t *testing.T) {
 				"src.example.com": "EX",
 			},
 		}
+
 		g := &Git{
 			scm: scm{
-				env:     env,
-				props:   props,
 				command: GITCOMMAND,
 			},
 			Upstream: "origin/main",
 		}
+		g.Init(props, env)
+
 		upstreamIcon := g.getUpstreamIcon()
 		assert.Equal(t, tc.Expected, upstreamIcon, tc.Case)
 	}
@@ -735,15 +739,15 @@ func TestGetBranchStatus(t *testing.T) {
 			BranchIdenticalIcon: "equal",
 			BranchGoneIcon:      "gone",
 		}
+
 		g := &Git{
-			scm: scm{
-				props: props,
-			},
 			Ahead:        tc.Ahead,
 			Behind:       tc.Behind,
 			Upstream:     tc.Upstream,
 			UpstreamGone: tc.UpstreamGone,
 		}
+		g.Init(props, new(mock.Environment))
+
 		g.setBranchStatus()
 		assert.Equal(t, tc.Expected, g.BranchStatus, tc.Case)
 	}
@@ -919,14 +923,17 @@ func TestGitUntrackedMode(t *testing.T) {
 	}
 
 	for _, tc := range cases {
+		props := properties.Map{
+			UntrackedModes: tc.UntrackedModes,
+		}
+
 		g := &Git{
 			scm: scm{
-				props: properties.Map{
-					UntrackedModes: tc.UntrackedModes,
-				},
 				realDir: "foo",
 			},
 		}
+		g.Init(props, new(mock.Environment))
+
 		got := g.getUntrackedFilesMode()
 		assert.Equal(t, tc.Expected, got, tc.Case)
 	}
@@ -961,14 +968,17 @@ func TestGitIgnoreSubmodules(t *testing.T) {
 	}
 
 	for _, tc := range cases {
+		props := properties.Map{
+			IgnoreSubmodules: tc.IgnoreSubmodules,
+		}
+
 		g := &Git{
 			scm: scm{
-				props: properties.Map{
-					IgnoreSubmodules: tc.IgnoreSubmodules,
-				},
 				realDir: "foo",
 			},
 		}
+		g.Init(props, new(mock.Environment))
+
 		got := g.getIgnoreSubmodulesMode()
 		assert.Equal(t, tc.Expected, got, tc.Case)
 	}
@@ -1093,12 +1103,14 @@ func TestGitCommit(t *testing.T) {
 	for _, tc := range cases {
 		env := new(mock.Environment)
 		env.MockGitCommand("", tc.Output, "log", "-1", "--pretty=format:an:%an%nae:%ae%ncn:%cn%nce:%ce%nat:%at%nsu:%s%nha:%H%nrf:%D", "--decorate=full")
+
 		g := &Git{
 			scm: scm{
-				env:     env,
+				command: GITCOMMAND,
-				command: "git",
 			},
 		}
+		g.Init(properties.Map{}, env)
+
 		got := g.Commit()
 		assert.Equal(t, tc.Expected, got, tc.Case)
 	}
@@ -1148,11 +1160,10 @@ func TestGitRemotes(t *testing.T) {
 
 		g := &Git{
 			scm: scm{
-				props:   properties.Map{},
 				realDir: "foo",
-				env:     env,
 			},
 		}
+		g.Init(properties.Map{}, env)
 
 		got := g.Remotes()
 		assert.Equal(t, tc.Expected, len(got), tc.Case)
@@ -1194,13 +1205,12 @@ func TestGitRepoName(t *testing.T) {
 
 		g := &Git{
 			scm: scm{
-				props:      properties.Map{},
-				env:        env,
 				realDir:    tc.RealDir,
 				workingDir: tc.WorkingDir,
 			},
 			IsWorkTree: tc.IsWorkTree,
 		}
+		g.Init(properties.Map{}, env)
 
 		got := g.repoName()
 		assert.Equal(t, tc.Expected, got, tc.Case)

src/segments/gitversion.go

@@ -2,9 +2,6 @@ package segments
 
 import (
 	"encoding/json"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type gitVersion struct {
@@ -44,8 +41,7 @@ type gitVersion struct {
 }
 
 type GitVersion struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	gitVersion
 }
@@ -70,8 +66,3 @@ func (n *GitVersion) Enabled() bool {
 
 	return err == nil
 }
-
-func (n *GitVersion) Init(props properties.Properties, env runtime.Environment) {
-	n.props = props
-	n.env = env
-}

src/segments/gitversion_test.go

@@ -47,10 +47,9 @@ func TestGitversion(t *testing.T) {
 		env.On("Pwd").Return("test-dir")
 		env.On("RunCommand", "gitversion", []string{"-output", "json"}).Return(tc.Response, tc.CommandError)
 
-		gitversion := &GitVersion{
+		gitversion := &GitVersion{}
-			env:   env,
+		gitversion.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		}
 		if len(tc.Template) == 0 {
 			tc.Template = gitversion.Template()
 		}

src/segments/golang.go

@@ -2,7 +2,6 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 
 	"golang.org/x/mod/modfile"
 )
@@ -19,26 +18,6 @@ func (g *Golang) Template() string {
 	return languageTemplate
 }
 
-func (g *Golang) Init(props properties.Properties, env runtime.Environment) {
-	g.language = language{
-		env:        env,
-		props:      props,
-		extensions: []string{"*.go", "go.mod"},
-		commands: []*cmd{
-			{
-				regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+)(.(?P<patch>[0-9]+))?))`,
-				getVersion: g.getVersion,
-			},
-			{
-				executable: "go",
-				args:       []string{"version"},
-				regex:      `(?:go(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+)(.(?P<patch>[0-9]+))?)))`,
-			},
-		},
-		versionURLTemplate: "https://golang.org/doc/go{{ .Major }}.{{ .Minor }}",
-	}
-}
-
 func (g *Golang) getVersion() (string, error) {
 	if !g.props.GetBool(ParseModFile, false) {
 		return "", nil
@@ -56,5 +35,19 @@ func (g *Golang) getVersion() (string, error) {
 }
 
 func (g *Golang) Enabled() bool {
+	g.extensions = []string{"*.go", "go.mod"}
+	g.commands = []*cmd{
+		{
+			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+)(.(?P<patch>[0-9]+))?))`,
+			getVersion: g.getVersion,
+		},
+		{
+			executable: "go",
+			args:       []string{"version"},
+			regex:      `(?:go(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+)(.(?P<patch>[0-9]+))?)))`,
+		},
+	}
+	g.versionURLTemplate = "https://golang.org/doc/go{{ .Major }}.{{ .Minor }}"
+
 	return g.language.Enabled()
 }

src/segments/haskell.go

@@ -2,7 +2,6 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Haskell struct {
@@ -19,7 +18,7 @@ func (h *Haskell) Template() string {
 	return languageTemplate
 }
 
-func (h *Haskell) Init(props properties.Properties, env runtime.Environment) {
+func (h *Haskell) Enabled() bool {
 	ghcRegex := `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`
 	ghcCmd := &cmd{
 		executable: "ghc",
@@ -33,13 +32,9 @@ func (h *Haskell) Init(props properties.Properties, env runtime.Environment) {
 		regex:      ghcRegex,
 	}
 
-	h.language = language{
+	h.extensions = []string{"*.hs", "*.lhs", "stack.yaml", "package.yaml", "*.cabal", "cabal.project"}
-		env:                env,
+	h.commands = []*cmd{ghcCmd}
-		props:              props,
+	h.versionURLTemplate = "https://www.haskell.org/ghc/download_ghc_{{ .Major }}_{{ .Minor }}_{{ .Patch }}.html"
-		extensions:         []string{"*.hs", "*.lhs", "stack.yaml", "package.yaml", "*.cabal", "cabal.project"},
-		commands:           []*cmd{ghcCmd},
-		versionURLTemplate: "https://www.haskell.org/ghc/download_ghc_{{ .Major }}_{{ .Minor }}_{{ .Patch }}.html",
-	}
 
 	switch h.props.GetString(StackGhcMode, "never") {
 	case "always":
@@ -52,8 +47,6 @@ func (h *Haskell) Init(props properties.Properties, env runtime.Environment) {
 			h.StackGhc = true
 		}
 	}
-}
 
-func (h *Haskell) Enabled() bool {
 	return h.language.Enabled()
 }

src/segments/helm.go

@@ -1,13 +1,7 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Helm struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Version string
 }
@@ -34,11 +28,6 @@ func (h *Helm) Template() string {
 	return " Helm {{.Version}}"
 }
 
-func (h *Helm) Init(props properties.Properties, env runtime.Environment) {
-	h.props = props
-	h.env = env
-}
-
 func (h *Helm) getVersion() bool {
 	cmd := "helm"
 	if !h.env.HasCommand(cmd) {

src/segments/helm_test.go

@@ -93,10 +93,9 @@ func TestHelmSegment(t *testing.T) {
 			DisplayMode: tc.DisplayMode,
 		}
 
-		h := &Helm{
+		h := &Helm{}
-			env:   env,
+		h.Init(props, env)
-			props: props,
+
-		}
 		assert.Equal(t, tc.ExpectedEnabled, h.Enabled(), tc.Case)
 		if tc.ExpectedEnabled {
 			assert.Equal(t, tc.ExpectedString, renderTemplate(env, h.Template(), h), tc.Case)

src/segments/ipify.go

@@ -4,7 +4,6 @@ import (
 	"net"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime/http"
 )
 
@@ -26,6 +25,8 @@ func (i *ipAPI) Get() (*ipData, error) {
 }
 
 type IPify struct {
+	base
+
 	api IPAPI
 	IP  string
 }
@@ -41,6 +42,8 @@ func (i *IPify) Template() string {
 }
 
 func (i *IPify) Enabled() bool {
+	i.initAPI()
+
 	ip, err := i.getResult()
 	if err != nil {
 		return false
@@ -55,16 +58,22 @@ func (i *IPify) getResult() (string, error) {
 	if dnsErr, OK := err.(*net.DNSError); OK && dnsErr.IsNotFound {
 		return OFFLINE, nil
 	}
+
 	if err != nil {
 		return "", err
 	}
+
 	return data.IP, err
 }
 
-func (i *IPify) Init(props properties.Properties, env runtime.Environment) {
+func (i *IPify) initAPI() {
+	if i.api != nil {
+		return
+	}
+
 	request := &http.Request{
-		Env:         env,
+		Env:         i.env,
-		HTTPTimeout: props.GetInt(properties.HTTPTimeout, properties.DefaultHTTPTimeout),
+		HTTPTimeout: i.props.GetInt(properties.HTTPTimeout, properties.DefaultHTTPTimeout),
 	}
 
 	i.api = &ipAPI{

src/segments/ipify_test.go

@@ -11,10 +11,6 @@ import (
 	testify_ "github.com/stretchr/testify/mock"
 )
 
-const (
-	IPIFYAPIURL = "https://api.ipify.org"
-)
-
 type mockedipAPI struct {
 	testify_.Mock
 }

src/segments/java.go

@@ -2,9 +2,6 @@ package segments
 
 import (
 	"fmt"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Java struct {
@@ -15,17 +12,21 @@ func (j *Java) Template() string {
 	return languageTemplate
 }
 
-func (j *Java) Init(props properties.Properties, env runtime.Environment) {
+func (j *Java) Enabled() bool {
+	j.init()
+
+	return j.language.Enabled()
+}
+
+func (j *Java) init() {
 	javaRegex := `(?: JRE)(?: \(.*\))? \((?P<version>(?P<major>[0-9]+)(?:\.(?P<minor>[0-9]+))?(?:\.(?P<patch>[0-9]+))?).*\),`
 	javaCmd := &cmd{
 		executable: "java",
 		args:       []string{"-Xinternalversion"},
 		regex:      javaRegex,
 	}
-	j.language = language{
+
-		env:   env,
+	j.extensions = []string{
-		props: props,
-		extensions: []string{
 		"pom.xml",
 		"build.gradle.kts",
 		"build.sbt",
@@ -39,12 +40,12 @@ func (j *Java) Init(props properties.Properties, env runtime.Environment) {
 		"*.jar",
 		"*.clj",
 		"*.cljc",
-		},
 	}
-	javaHome := j.language.env.Getenv("JAVA_HOME")
+
+	javaHome := j.env.Getenv("JAVA_HOME")
 	if len(javaHome) > 0 {
 		java := fmt.Sprintf("%s/bin/java", javaHome)
-		j.language.commands = []*cmd{
+		j.commands = []*cmd{
 			{
 				executable: java,
 				args:       []string{"-Xinternalversion"},
@@ -54,9 +55,6 @@ func (j *Java) Init(props properties.Properties, env runtime.Environment) {
 		}
 		return
 	}
-	j.language.commands = []*cmd{javaCmd}
-}
 
-func (j *Java) Enabled() bool {
+	j.commands = []*cmd{javaCmd}
-	return j.language.Enabled()
 }

src/segments/julia.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Julia struct {
 	language
 }
@@ -13,22 +8,16 @@ func (j *Julia) Template() string {
 	return languageTemplate
 }
 
-func (j *Julia) Init(props properties.Properties, env runtime.Environment) {
+func (j *Julia) Enabled() bool {
-	j.language = language{
+	j.extensions = []string{"*.jl"}
-		env:        env,
+	j.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.jl"},
-		commands: []*cmd{
 		{
 			executable: "julia",
 			args:       []string{"--version"},
 			regex:      `julia version (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/JuliaLang/julia/releases/tag/v{{ .Full }}",
-	}
 	}
+	j.versionURLTemplate = "https://github.com/JuliaLang/julia/releases/tag/v{{ .Full }}"
 
-func (j *Julia) Enabled() bool {
 	return j.language.Enabled()
 }

src/segments/kotlin.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Kotlin struct {
 	language
 }
@@ -13,22 +8,16 @@ func (k *Kotlin) Template() string {
 	return languageTemplate
 }
 
-func (k *Kotlin) Init(props properties.Properties, env runtime.Environment) {
+func (k *Kotlin) Enabled() bool {
-	k.language = language{
+	k.extensions = []string{"*.kt", "*.kts", "*.ktm"}
-		env:        env,
+	k.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.kt", "*.kts", "*.ktm"},
-		commands: []*cmd{
 		{
 			executable: "kotlin",
 			args:       []string{"-version"},
 			regex:      `Kotlin version (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/JetBrains/kotlin/releases/tag/v{{ .Full }}",
-	}
 	}
+	k.versionURLTemplate = "https://github.com/JetBrains/kotlin/releases/tag/v{{ .Full }}"
 
-func (k *Kotlin) Enabled() bool {
 	return k.language.Enabled()
 }

src/segments/kubectl.go

@@ -4,7 +4,6 @@ import (
 	"path/filepath"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 
 	"gopkg.in/yaml.v3"
 )
@@ -17,8 +16,8 @@ const (
 )
 
 type Kubectl struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
+
 	KubeContext
 	Context string
 	dirty   bool
@@ -42,11 +41,6 @@ func (k *Kubectl) Template() string {
 	return " {{ .Context }}{{ if .Namespace }} :: {{ .Namespace }}{{ end }} "
 }
 
-func (k *Kubectl) Init(props properties.Properties, env runtime.Environment) {
-	k.props = props
-	k.env = env
-}
-
 func (k *Kubectl) Enabled() bool {
 	parseKubeConfig := k.props.GetBool(ParseKubeConfig, true)
 

src/segments/kubectl_test.go

@@ -158,15 +158,15 @@ func TestKubectlSegment(t *testing.T) {
 
 		env.On("Home").Return("testhome")
 
-		k := &Kubectl{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			properties.DisplayError: tc.DisplayError,
 			ParseKubeConfig:         tc.ParseKubeConfig,
 			ContextAliases:          tc.ContextAliases,
-			},
 		}
 
+		k := &Kubectl{}
+		k.Init(props, env)
+
 		assert.Equal(t, tc.ExpectedEnabled, k.Enabled(), tc.Case)
 		if tc.ExpectedEnabled {
 			assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, k), tc.Case)

src/segments/language.go

@@ -60,8 +60,8 @@ func (c *cmd) parse(versionInfo string) (*version, error) {
 }
 
 type language struct {
-	env                runtime.Environment
+	base
-	props              properties.Properties
+
 	projectRoot        *runtime.FileInfo
 	loadContext        loadContext
 	inContext          inContext

src/segments/language_test.go

@@ -64,13 +64,12 @@ func bootStrapLanguageTest(args *languageArgs) *language {
 	}
 
 	l := &language{
-		props:              args.properties,
-		env:                env,
 		extensions:         args.extensions,
 		commands:           args.commands,
 		versionURLTemplate: args.versionURLTemplate,
 		matchesVersionFile: args.matchesVersionFile,
 	}
+	l.Init(args.properties, env)
 
 	return l
 }

src/segments/lastfm.go

@@ -6,12 +6,10 @@ import (
 	"fmt"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type LastFM struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Artist string
 	Track  string
@@ -120,8 +118,3 @@ func (d *LastFM) setStatus() error {
 
 	return nil
 }
-
-func (d *LastFM) Init(props properties.Properties, env runtime.Environment) {
-	d.props = props
-	d.env = env
-}

src/segments/lastfm_test.go

@@ -63,20 +63,18 @@ func TestLFMSegmentSingle(t *testing.T) {
 		env.On("HTTPRequest", LFMAPIURL).Return([]byte(tc.APIJSONResponse), tc.Error)
 		env.On("Error", testify_.Anything)
 
-		o := &LastFM{
+		lfm := &LastFM{}
-			props: props,
+		lfm.Init(props, env)
-			env:   env,
-		}
 
-		enabled := o.Enabled()
+		enabled := lfm.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
 		if !enabled {
 			continue
 		}
 
 		if tc.Template == "" {
-			tc.Template = o.Template()
+			tc.Template = lfm.Template()
 		}
-		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, o), tc.Case)
+		assert.Equal(t, tc.ExpectedString, renderTemplate(env, tc.Template, lfm), tc.Case)
 	}
 }

src/segments/lua.go

@@ -2,7 +2,6 @@ package segments
 
 import (
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Lua struct {
@@ -17,13 +16,10 @@ func (l *Lua) Template() string {
 	return languageTemplate
 }
 
-func (l *Lua) Init(props properties.Properties, env runtime.Environment) {
+func (l *Lua) Enabled() bool {
-	l.language = language{
+	l.extensions = []string{"*.lua", "*.rockspec"}
-		env:        env,
+	l.folders = []string{"lua"}
-		props:      props,
+	l.commands = []*cmd{
-		extensions: []string{"*.lua", "*.rockspec"},
-		folders:    []string{"lua"},
-		commands: []*cmd{
 		{
 			executable:         "lua",
 			args:               []string{"-v"},
@@ -36,13 +32,11 @@ func (l *Lua) Init(props properties.Properties, env runtime.Environment) {
 			regex:              `LuaJIT (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+)(.(?P<patch>[0-9]+))?))`,
 			versionURLTemplate: "https://github.com/LuaJIT/LuaJIT/tree/v{{ .Major}}.{{ .Minor}}",
 		},
-		},
 	}
+
 	if l.props.GetString(PreferredExecutable, "lua") == "luajit" {
 		l.commands = []*cmd{l.commands[1], l.commands[0]}
 	}
-}
 
-func (l *Lua) Enabled() bool {
 	return l.language.Enabled()
 }

src/segments/mercurial_test.go

@@ -16,12 +16,8 @@ func TestMercurialEnabledToolNotFound(t *testing.T) {
 	env.On("GOOS").Return("")
 	env.On("IsWsl").Return(false)
 
-	hg := &Mercurial{
+	hg := &Mercurial{}
-		scm: scm{
+	hg.Init(properties.Map{}, env)
-			env:   env,
-			props: properties.Map{},
-		},
-	}
 
 	assert.False(t, hg.Enabled())
 }
@@ -42,12 +38,8 @@ func TestMercurialEnabledInWorkingDirectory(t *testing.T) {
 	env.On("Home").Return(poshHome)
 	env.On("Getenv", poshGitEnv).Return("")
 
-	hg := &Mercurial{
+	hg := &Mercurial{}
-		scm: scm{
+	hg.Init(properties.Map{}, env)
-			env:   env,
-			props: properties.Map{},
-		},
-	}
 
 	assert.True(t, hg.Enabled())
 	assert.Equal(t, fileInfo.Path, hg.workingDir)
@@ -142,6 +134,7 @@ A Added.File
 			ParentFolder: "/dir",
 			IsDir:        true,
 		}
+
 		props := properties.Map{
 			FetchStatus: true,
 		}
@@ -158,12 +151,8 @@ A Added.File
 		env.MockHgCommand(fileInfo.Path, tc.LogOutput, "log", "-r", ".", "--template", hgLogTemplate)
 		env.MockHgCommand(fileInfo.Path, tc.StatusOutput, "status")
 
-		hg := &Mercurial{
+		hg := &Mercurial{}
-			scm: scm{
+		hg.Init(props, env)
-				env:   env,
-				props: props,
-			},
-		}
 
 		if tc.ExpectedWorking != nil {
 			tc.ExpectedWorking.Formats = map[string]string{}

src/segments/mvn.go

@@ -1,39 +1,28 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Mvn struct {
 	language
 }
 
 func (m *Mvn) Enabled() bool {
+	m.extensions = []string{"pom.xml"}
+	m.commands = []*cmd{
+		{
+			executable: "mvn",
+			args:       []string{"--version"},
+			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)(?:-(?P<prerelease>[a-z]+-[0-9]+))?))`,
+		},
+	}
+	m.versionURLTemplate = "https://github.com/apache/maven/releases/tag/maven-{{ .Full }}"
+
+	mvnw, err := m.env.HasParentFilePath("mvnw", false)
+	if err == nil {
+		m.commands[0].executable = mvnw.Path
+	}
+
 	return m.language.Enabled()
 }
 
 func (m *Mvn) Template() string {
 	return languageTemplate
 }
-
-func (m *Mvn) Init(props properties.Properties, env runtime.Environment) {
-	m.language = language{
-		env:        env,
-		props:      props,
-		extensions: []string{"pom.xml"},
-		commands: []*cmd{
-			{
-				executable: "mvn",
-				args:       []string{"--version"},
-				regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)(?:-(?P<prerelease>[a-z]+-[0-9]+))?))`,
-			},
-		},
-		versionURLTemplate: "https://github.com/apache/maven/releases/tag/maven-{{ .Full }}",
-	}
-
-	mvnw, err := m.language.env.HasParentFilePath("mvnw", false)
-	if err == nil {
-		m.language.commands[0].executable = mvnw.Path
-	}
-}

src/segments/nba.go

@@ -7,13 +7,11 @@ import (
 	"time"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 // segment struct, makes templating easier
 type Nba struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	NBAData
 }
@@ -310,8 +308,3 @@ func (nba *Nba) getResult() (*NBAData, error) {
 
 	return data, nil
 }
-
-func (nba *Nba) Init(props properties.Properties, env runtime.Environment) {
-	nba.props = props
-	nba.env = env
-}

src/segments/nba_test.go

@@ -94,10 +94,8 @@ func TestNBASegment(t *testing.T) {
 			env.On("HTTPRequest", scheduleURLEndpoint).Return([]byte(tc.JSONResponse), tc.Error)
 		}
 
-		nba := &Nba{
+		nba := &Nba{}
-			props: props,
+		nba.Init(props, env)
-			env:   env,
-		}
 
 		enabled := nba.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)

src/segments/nbgv.go

@@ -2,14 +2,10 @@ package segments
 
 import (
 	"encoding/json"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Nbgv struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	VersionInfo
 }
@@ -45,8 +41,3 @@ func (n *Nbgv) Enabled() bool {
 	}
 	return n.VersionInfo.VersionFileFound
 }
-
-func (n *Nbgv) Init(props properties.Properties, env runtime.Environment) {
-	n.props = props
-	n.env = env
-}

src/segments/nbgv_test.go

@@ -63,11 +63,12 @@ func TestNbgv(t *testing.T) {
 		env := new(mock.Environment)
 		env.On("HasCommand", "nbgv").Return(tc.HasNbgv)
 		env.On("RunCommand", "nbgv", []string{"get-version", "--format=json"}).Return(tc.Response, tc.Error)
-		nbgv := &Nbgv{
+
-			env:   env,
+		nbgv := &Nbgv{}
-			props: properties.Map{},
+		nbgv.Init(properties.Map{}, env)
-		}
+
 		enabled := nbgv.Enabled()
+
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
 		if tc.Template == "" {
 			tc.Template = nbgv.Template()

src/segments/nightscout.go

@@ -7,13 +7,12 @@ import (
 	"time"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 // segment struct, makes templating easier
 type Nightscout struct {
-	props     properties.Properties
+	base
-	env       runtime.Environment
+
 	TrendIcon string
 	NightscoutData
 }
@@ -124,8 +123,3 @@ func (ns *Nightscout) getResult() (*NightscoutData, error) {
 
 	return data, nil
 }
-
-func (ns *Nightscout) Init(props properties.Properties, env runtime.Environment) {
-	ns.props = props
-	ns.env = env
-}

src/segments/nightscout_test.go

@@ -120,10 +120,8 @@ func TestNSSegment(t *testing.T) {
 
 		env.On("HTTPRequest", FAKEAPIURL).Return([]byte(tc.JSONResponse), tc.Error)
 
-		ns := &Nightscout{
+		ns := &Nightscout{}
-			props: props,
+		ns.Init(props, env)
-			env:   env,
-		}
 
 		enabled := ns.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)

src/segments/nixshell.go

@@ -3,9 +3,6 @@ package segments
 import (
 	"path/filepath"
 	"strings"
-
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 const (
@@ -13,8 +10,7 @@ const (
 )
 
 type NixShell struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Type string
 }
@@ -53,11 +49,6 @@ func (n *NixShell) InNewNixShell() bool {
 	return false
 }
 
-func (n *NixShell) Init(props properties.Properties, env runtime.Environment) {
-	n.props = props
-	n.env = env
-}
-
 func (n *NixShell) Enabled() bool {
 	n.Type = n.DetectType()
 

src/segments/node.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/regex"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Node struct {
@@ -29,25 +28,19 @@ func (n *Node) Template() string {
 	return " {{ if .PackageManagerIcon }}{{ .PackageManagerIcon }} {{ end }}{{ .Full }} "
 }
 
-func (n *Node) Init(props properties.Properties, env runtime.Environment) {
+func (n *Node) Enabled() bool {
-	n.language = language{
+	n.extensions = []string{"*.js", "*.ts", "package.json", ".nvmrc", "pnpm-workspace.yaml", ".pnpmfile.cjs", ".vue"}
-		env:        env,
+	n.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.js", "*.ts", "package.json", ".nvmrc", "pnpm-workspace.yaml", ".pnpmfile.cjs", ".vue"},
-		commands: []*cmd{
 		{
 			executable: "node",
 			args:       []string{"--version"},
 			regex:      `(?:v(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_V{{ .Major }}.md#{{ .Full }}",
-		matchesVersionFile: n.matchesVersionFile,
-		loadContext:        n.loadContext,
-	}
 	}
+	n.versionURLTemplate = "https://github.com/nodejs/node/blob/master/doc/changelogs/CHANGELOG_V{{ .Major }}.md#{{ .Full }}"
+	n.language.matchesVersionFile = n.matchesVersionFile
+	n.language.loadContext = n.loadContext
 
-func (n *Node) Enabled() bool {
 	return n.language.Enabled()
 }
 

src/segments/node_test.go

@@ -42,10 +42,11 @@ func TestNodeMatchesVersionFile(t *testing.T) {
 
 		node := &Node{
 			language: language{
-				env:     env,
 				version: nodeVersion,
 			},
 		}
+		node.Init(properties.Map{}, env)
+
 		version, match := node.matchesVersionFile()
 		assert.Equal(t, tc.Expected, match, tc.Case)
 		assert.Equal(t, tc.ExpectedVersion, version, tc.Case)
@@ -80,17 +81,17 @@ func TestNodeInContext(t *testing.T) {
 		env.On("HasFiles", "yarn.lock").Return(tc.hasYarn)
 		env.On("HasFiles", "package-lock.json").Return(tc.hasNPM)
 		env.On("HasFiles", "package.json").Return(tc.hasDefault)
-		node := &Node{
+
-			language: language{
+		props := properties.Map{
-				env: env,
-				props: properties.Map{
 			PnpmIcon:            "pnpm",
 			YarnIcon:            "yarn",
 			NPMIcon:             "npm",
 			FetchPackageManager: tc.PkgMgrEnabled,
-				},
-			},
 		}
+
+		node := &Node{}
+		node.Init(props, env)
+
 		node.loadContext()
 		assert.Equal(t, tc.ExpectedString, node.PackageManagerIcon, tc.Case)
 	}

src/segments/npm.go

@@ -1,34 +1,23 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Npm struct {
 	language
 }
 
 func (n *Npm) Enabled() bool {
+	n.extensions = []string{"package.json", "package-lock.json"}
+	n.commands = []*cmd{
+		{
+			executable: "npm",
+			args:       []string{"--version"},
+			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
+		},
+	}
+	n.versionURLTemplate = "https://github.com/npm/cli/releases/tag/v{{ .Full }}"
+
 	return n.language.Enabled()
 }
 
 func (n *Npm) Template() string {
 	return " \ue71e {{.Full}} "
 }
-
-func (n *Npm) Init(props properties.Properties, env runtime.Environment) {
-	n.language = language{
-		env:        env,
-		props:      props,
-		extensions: []string{"package.json", "package-lock.json"},
-		commands: []*cmd{
-			{
-				executable: "npm",
-				args:       []string{"--version"},
-				regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
-			},
-		},
-		versionURLTemplate: "https://github.com/npm/cli/releases/tag/v{{ .Full }}",
-	}
-}

src/segments/nx.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"path/filepath"
 
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
@@ -17,22 +16,16 @@ func (a *Nx) Template() string {
 	return languageTemplate
 }
 
-func (a *Nx) Init(props properties.Properties, env runtime.Environment) {
+func (a *Nx) Enabled() bool {
-	a.language = language{
+	a.extensions = []string{"workspace.json", "nx.json"}
-		env:        env,
+	a.commands = []*cmd{
-		props:      props,
-		extensions: []string{"workspace.json", "nx.json"},
-		commands: []*cmd{
 		{
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 			getVersion: a.getVersion,
 		},
-		},
-		versionURLTemplate: "https://github.com/nrwl/nx/releases/tag/{{.Full}}",
-	}
 	}
+	a.versionURLTemplate = "https://github.com/nrwl/nx/releases/tag/{{.Full}}"
 
-func (a *Nx) Enabled() bool {
 	return a.language.Enabled()
 }
 

src/segments/ocaml.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type OCaml struct {
 	language
 }
@@ -13,21 +8,15 @@ func (o *OCaml) Template() string {
 	return languageTemplate
 }
 
-func (o *OCaml) Init(props properties.Properties, env runtime.Environment) {
+func (o *OCaml) Enabled() bool {
-	o.language = language{
+	o.extensions = []string{"*.ml", "*.mli", "dune", "dune-project", "dune-workspace"}
-		env:        env,
+	o.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.ml", "*.mli", "dune", "dune-project", "dune-workspace"},
-		commands: []*cmd{
 		{
 			executable: "ocaml",
 			args:       []string{"-version"},
 			regex:      `The OCaml toplevel, version (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))(-(?P<prerelease>[a-z]+))?)`,
 		},
-		},
-	}
 	}
 
-func (o *OCaml) Enabled() bool {
 	return o.language.Enabled()
 }

src/segments/os.go

@@ -6,8 +6,7 @@ import (
 )
 
 type Os struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Icon string
 }
@@ -91,8 +90,3 @@ func (oi *Os) getDistroIcon(distro string) string {
 
 	return oi.props.GetString(Linux, "\uF17C")
 }
-
-func (oi *Os) Init(props properties.Properties, env runtime.Environment) {
-	oi.props = props
-	oi.env = env
-}

src/segments/os_test.go

@@ -103,10 +103,8 @@ func TestOSInfo(t *testing.T) {
 			props[properties.Property(tc.Platform)] = tc.Icon
 		}
 
-		osInfo := &Os{
+		osInfo := &Os{}
-			env:   env,
+		osInfo.Init(props, env)
-			props: props,
-		}
 
 		_ = osInfo.Enabled()
 		assert.Equal(t, tc.ExpectedString, renderTemplate(env, osInfo.Template(), osInfo), tc.Case)

src/segments/owm.go

@@ -8,12 +8,11 @@ import (
 	"net/url"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 type Owm struct {
-	props       properties.Properties
+	base
-	env         runtime.Environment
+
 	Weather     string
 	URL         string
 	units       string
@@ -167,8 +166,3 @@ func (d *Owm) setStatus() error {
 	}
 	return nil
 }
-
-func (d *Owm) Init(props properties.Properties, env runtime.Environment) {
-	d.props = props
-	d.env = env
-}

src/segments/owm_test.go

@@ -84,10 +84,8 @@ func TestOWMSegmentSingle(t *testing.T) {
 		env.On("HTTPRequest", testURL).Return([]byte(tc.WeatherJSONResponse), tc.Error)
 		env.On("Error", testify_.Anything)
 
-		o := &Owm{
+		o := &Owm{}
-			props: props,
+		o.Init(props, env)
-			env:   env,
-		}
 
 		enabled := o.Enabled()
 		assert.Equal(t, tc.ExpectedEnabled, enabled, tc.Case)
@@ -212,15 +210,15 @@ func TestOWMSegmentIcons(t *testing.T) {
 
 		env.On("HTTPRequest", testURL).Return([]byte(weatherResponse), nil)
 
-		o := &Owm{
+		props := properties.Map{
-			props: properties.Map{
 			APIKey:   "key",
 			Location: "AMSTERDAM,NL",
 			Units:    "metric",
-			},
-			env: env,
 		}
 
+		o := &Owm{}
+		o.Init(props, env)
+
 		assert.Nil(t, o.setStatus())
 		assert.Equal(t, expectedString, renderTemplate(env, o.Template(), o), tc.Case)
 	}
@@ -234,15 +232,15 @@ func TestOWMSegmentIcons(t *testing.T) {
 
 		env.On("HTTPRequest", testURL).Return([]byte(weatherResponse), nil)
 
-		o := &Owm{
+		props := properties.Map{
-			props: properties.Map{
 			APIKey:   "key",
 			Location: "AMSTERDAM,NL",
 			Units:    "metric",
-			},
-			env: env,
 		}
 
+		o := &Owm{}
+		o.Init(props, env)
+
 		assert.Nil(t, o.setStatus())
 		assert.Equal(t, expectedString, renderTemplate(env, "«{{.Weather}} ({{.Temperature}}{{.UnitIcon}})»({{.URL}})", o), tc.Case)
 	}

src/segments/path.go

@@ -32,8 +32,8 @@ func (f Folders) List() []string {
 }
 
 type Path struct {
-	props           properties.Properties
+	base
-	env             runtime.Environment
+
 	mappedLocations map[string]string
 	root            string
 	relative        string
@@ -193,11 +193,6 @@ func (pt *Path) Parent() string {
 	return sb.String()
 }
 
-func (pt *Path) Init(props properties.Properties, env runtime.Environment) {
-	pt.props = props
-	pt.env = env
-}
-
 func (pt *Path) setStyle() {
 	if len(pt.relative) == 0 {
 		root := pt.root

src/segments/path_test.go

@@ -155,13 +155,14 @@ func TestParent(t *testing.T) {
 		env.On("Shell").Return(shell.GENERIC)
 		env.On("PathSeparator").Return(tc.PathSeparator)
 		env.On("GOOS").Return(tc.GOOS)
-		path := &Path{
+
-			env: env,
+		props := properties.Map{
-			props: properties.Map{
 			FolderSeparatorIcon: tc.FolderSeparatorIcon,
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 
 		got := path.Parent()
@@ -795,18 +796,18 @@ func TestAgnosterPathStyles(t *testing.T) {
 			env.On("RunCommand", "cygpath", testify_.Anything).Return("brrrr", nil)
 		}
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			FolderSeparatorIcon: tc.FolderSeparatorIcon,
 			properties.Style:    tc.Style,
 			MaxDepth:            tc.MaxDepth,
 			MaxWidth:            tc.MaxWidth,
 			HideRootLocation:    tc.HideRootLocation,
 			DisplayCygpath:      displayCygpath,
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		path.setStyle()
 		got := renderTemplateNoTrimSpace(env, "{{ .Path }}", path)
@@ -933,11 +934,12 @@ func TestFullAndFolderPath(t *testing.T) {
 		if tc.DisableMappedLocations {
 			props[MappedLocationsEnabled] = false
 		}
+
 		path := &Path{
-			env:        env,
-			props:      props,
 			StackCount: env.StackCount(),
 		}
+		path.Init(props, env)
+
 		path.setPaths()
 		path.setStyle()
 		got := renderTemplateNoTrimSpace(env, tc.Template, path)
@@ -992,15 +994,15 @@ func TestFullPathCustomMappedLocations(t *testing.T) {
 
 		template.Init(env)
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			properties.Style:       Full,
 			MappedLocationsEnabled: false,
 			MappedLocations:        tc.MappedLocations,
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		path.setStyle()
 
@@ -1026,16 +1028,16 @@ func TestFolderPathCustomMappedLocations(t *testing.T) {
 
 	template.Init(env)
 
-	path := &Path{
+	props := properties.Map{
-		env: env,
-		props: properties.Map{
 		properties.Style: FolderType,
 		MappedLocations: map[string]string{
 			abcd: "#",
 		},
-		},
 	}
 
+	path := &Path{}
+	path.Init(props, env)
+
 	path.setPaths()
 	path.setStyle()
 
@@ -1207,17 +1209,19 @@ func TestAgnosterPath(t *testing.T) {
 		}
 		env.On("Flags").Return(args)
 		env.On("Shell").Return(shell.PWSH)
-		path := &Path{
+
-			env: env,
+		props := properties.Map{
-			props: properties.Map{
 			properties.Style:     Agnoster,
 			FolderSeparatorIcon:  " > ",
 			FolderIcon:           "f",
 			HomeIcon:             "~",
 			Cycle:                tc.Cycle,
 			CycleFolderSeparator: tc.ColorSeparator,
-			},
 		}
+
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		path.setStyle()
 		got := renderTemplateNoTrimSpace(env, "{{ .Path }}", path)
@@ -1363,15 +1367,17 @@ func TestAgnosterLeftPath(t *testing.T) {
 		}
 		env.On("Flags").Return(args)
 		env.On("Shell").Return(shell.PWSH)
-		path := &Path{
+
-			env: env,
+		props := properties.Map{
-			props: properties.Map{
 			properties.Style:    AgnosterLeft,
 			FolderSeparatorIcon: " > ",
 			FolderIcon:          "f",
 			HomeIcon:            "~",
-			},
 		}
+
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		path.setStyle()
 		got := renderTemplateNoTrimSpace(env, "{{ .Path }}", path)
@@ -1421,16 +1427,16 @@ func TestGetPwd(t *testing.T) {
 
 		template.Init(env)
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			MappedLocationsEnabled: tc.MappedLocationsEnabled,
 			MappedLocations: map[string]string{
 				abcd: "#",
 			},
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		assert.Equal(t, tc.Expected, path.pwd)
 	}
@@ -1457,14 +1463,11 @@ func TestGetFolderSeparator(t *testing.T) {
 		env.On("DebugF", testify_.Anything, testify_.Anything).Return(nil)
 		env.On("Shell").Return(shell.GENERIC)
 		env.On("Trace", testify_.Anything, testify_.Anything).Return(nil)
-
+		env.On("TemplateCache").Return(&cache.Template{
+			Shell: "bash",
+		})
 		template.Init(env)
 
-		path := &Path{
-			env:           env,
-			pathSeparator: "/",
-		}
-
 		props := properties.Map{}
 
 		if len(tc.FolderSeparatorTemplate) > 0 {
@@ -1475,11 +1478,11 @@ func TestGetFolderSeparator(t *testing.T) {
 			props[FolderSeparatorIcon] = tc.FolderSeparatorIcon
 		}
 
-		env.On("TemplateCache").Return(&cache.Template{
+		path := &Path{
-			Shell: "bash",
+			pathSeparator: "/",
-		})
+		}
+		path.Init(props, env)
 
-		path.props = props
 		got := path.getFolderSeparator()
 		assert.Equal(t, tc.Expected, got)
 	}
@@ -1614,7 +1617,10 @@ func TestNormalizePath(t *testing.T) {
 		}
 
 		env.On("PathSeparator").Return(tc.PathSeparator)
-		pt := &Path{env: env}
+
+		pt := &Path{}
+		pt.Init(properties.Map{}, env)
+
 		got := pt.normalize(tc.Input)
 		assert.Equal(t, tc.Expected, got, tc.Case)
 	}
@@ -1650,9 +1656,7 @@ func TestReplaceMappedLocations(t *testing.T) {
 
 		template.Init(env)
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			MappedLocationsEnabled: tc.MappedLocationsEnabled,
 			MappedLocations: map[string]string{
 				abcd:       "#",
@@ -1661,9 +1665,11 @@ func TestReplaceMappedLocations(t *testing.T) {
 				"~":        "@",
 				"~/j/*":    "",
 			},
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		path.setPaths()
 		assert.Equal(t, tc.Expected, path.pwd)
 	}
@@ -1725,16 +1731,17 @@ func TestSplitPath(t *testing.T) {
 		env.On("HasParentFilePath", ".git", false).Return(tc.GitDir, nil)
 		env.On("GOOS").Return(tc.GOOS)
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			GitDirFormat: tc.GitDirFormat,
-			},
+		}
+
+		path := &Path{
 			root:          tc.Root,
 			relative:      tc.Relative,
 			pathSeparator: "/",
 			windowsPath:   tc.GOOS == runtime.WINDOWS,
 		}
+		path.Init(props, env)
 
 		got := path.splitPath()
 		assert.Equal(t, tc.Expected, got, tc.Case)
@@ -1779,13 +1786,13 @@ func TestGetMaxWidth(t *testing.T) {
 
 		template.Init(env)
 
-		path := &Path{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			MaxWidth: tc.MaxWidth,
-			},
 		}
 
+		path := &Path{}
+		path.Init(props, env)
+
 		got := path.getMaxWidth()
 		assert.Equal(t, tc.Expected, got, tc.Case)
 	}

src/segments/perl.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Perl struct {
 	language
 }
@@ -13,27 +8,21 @@ func (p *Perl) Template() string {
 	return languageTemplate
 }
 
-func (p *Perl) Init(props properties.Properties, env runtime.Environment) {
+func (p *Perl) Enabled() bool {
 	perlRegex := `This is perl.*v(?P<version>(?P<major>[0-9]+)(?:\.(?P<minor>[0-9]+))(?:\.(?P<patch>[0-9]+))?).* built for .+`
-	p.language = language{
+	p.extensions = []string{
-		env:   env,
-		props: props,
-		extensions: []string{
 		".perl-version",
 		"*.pl",
 		"*.pm",
 		"*.t",
-		},
+	}
-		commands: []*cmd{
+	p.commands = []*cmd{
 		{
 			executable: "perl",
 			args:       []string{"-version"},
 			regex:      perlRegex,
 		},
-		},
-	}
 	}
 
-func (p *Perl) Enabled() bool {
 	return p.language.Enabled()
 }

src/segments/php.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Php struct {
 	language
 }
@@ -13,22 +8,16 @@ func (p *Php) Template() string {
 	return languageTemplate
 }
 
-func (p *Php) Init(props properties.Properties, env runtime.Environment) {
+func (p *Php) Enabled() bool {
-	p.language = language{
+	p.extensions = []string{"*.php", "composer.json", "composer.lock", ".php-version", "blade.php"}
-		env:        env,
+	p.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.php", "composer.json", "composer.lock", ".php-version", "blade.php"},
-		commands: []*cmd{
 		{
 			executable: "php",
 			args:       []string{"--version"},
 			regex:      `(?:PHP (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://www.php.net/ChangeLog-{{ .Major }}.php#PHP_{{ .Major }}_{{ .Minor }}",
-	}
 	}
+	p.versionURLTemplate = "https://www.php.net/ChangeLog-{{ .Major }}.php#PHP_{{ .Major }}_{{ .Minor }}"
 
-func (p *Php) Enabled() bool {
 	return p.language.Enabled()
 }

src/segments/plastic_test.go

@@ -15,12 +15,10 @@ func TestPlasticEnabledNotFound(t *testing.T) {
 	env.On("HasCommand", "cm").Return(false)
 	env.On("GOOS").Return("")
 	env.On("IsWsl").Return(false)
-	p := &Plastic{
+
-		scm: scm{
+	p := &Plastic{}
-			env:   env,
+	p.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		},
-	}
 	assert.False(t, p.Enabled())
 }
 
@@ -36,12 +34,10 @@ func TestPlasticEnabledInWorkspaceDirectory(t *testing.T) {
 		IsDir:        true,
 	}
 	env.On("HasParentFilePath", ".plastic", false).Return(fileInfo, nil)
-	p := &Plastic{
+
-		scm: scm{
+	p := &Plastic{}
-			env:   env,
+	p.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		},
-	}
 	assert.True(t, p.Enabled())
 	assert.Equal(t, fileInfo.ParentFolder, p.plasticWorkspaceFolder)
 }
@@ -50,12 +46,10 @@ func setupCmStatusEnv(status, headStatus string) *Plastic {
 	env := new(mock.Environment)
 	env.On("RunCommand", "cm", []string{"status", "--all", "--machinereadable"}).Return(status, nil)
 	env.On("RunCommand", "cm", []string{"status", "--head", "--machinereadable"}).Return(headStatus, nil)
-	p := &Plastic{
+
-		scm: scm{
+	p := &Plastic{}
-			env:   env,
+	p.Init(properties.Map{}, env)
-			props: properties.Map{},
+
-		},
-	}
 	return p
 }
 

src/segments/pnpm.go

@@ -1,34 +1,23 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Pnpm struct {
 	language
 }
 
 func (n *Pnpm) Enabled() bool {
+	n.extensions = []string{"package.json", "pnpm-lock.yaml"}
+	n.commands = []*cmd{
+		{
+			executable: "pnpm",
+			args:       []string{"--version"},
+			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
+		},
+	}
+	n.versionURLTemplate = "https://github.com/pnpm/pnpm/releases/tag/v{{ .Full }}"
+
 	return n.language.Enabled()
 }
 
 func (n *Pnpm) Template() string {
 	return " \U000F02C1 {{.Full}} "
 }
-
-func (n *Pnpm) Init(props properties.Properties, env runtime.Environment) {
-	n.language = language{
-		env:        env,
-		props:      props,
-		extensions: []string{"package.json", "pnpm-lock.yaml"},
-		commands: []*cmd{
-			{
-				executable: "pnpm",
-				args:       []string{"--version"},
-				regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
-			},
-		},
-		versionURLTemplate: "https://github.com/pnpm/pnpm/releases/tag/v{{ .Full }}",
-	}
-}

src/segments/posh_git_test.go

@@ -191,15 +191,16 @@ func TestPoshGitSegment(t *testing.T) {
 		env.On("RunCommand", "git", []string{"-C", "", "--no-optional-locks", "-c", "core.quotepath=false",
 			"-c", "color.status=false", "remote", "get-url", "origin"}).Return("github.com/cli", nil)
 
+		props := &properties.Map{
+			FetchUpstreamIcon: tc.FetchUpstreamIcon,
+		}
+
 		g := &Git{
 			scm: scm{
-				env: env,
-				props: &properties.Map{
-					FetchUpstreamIcon: tc.FetchUpstreamIcon,
-				},
 				command: GITCOMMAND,
 			},
 		}
+		g.Init(props, env)
 
 		if len(tc.Template) == 0 {
 			tc.Template = g.Template()
@@ -236,11 +237,9 @@ func TestParsePoshGitHEAD(t *testing.T) {
 	}
 
 	for _, tc := range cases {
-		g := &Git{
+		g := &Git{}
-			scm: scm{
+		g.Init(&properties.Map{}, new(mock.Environment))
-				props: &properties.Map{},
+
-			},
-		}
 		assert.Equal(t, tc.ExpectedString, g.parsePoshGitHEAD(tc.HEAD), tc.Case)
 	}
 }

src/segments/project.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
 	"github.com/jandedobbeleer/oh-my-posh/src/regex"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"golang.org/x/exp/slices"
 
 	toml "github.com/pelletier/go-toml/v2"
@@ -52,36 +51,14 @@ type NuSpec struct {
 }
 
 type Project struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
+
 	ProjectData
 	Error    string
 	projects []*ProjectItem
 }
 
 func (n *Project) Enabled() bool {
-	for _, item := range n.projects {
-		if n.hasProjectFile(item) {
-			data := item.Fetcher(*item)
-			if data == nil {
-				continue
-			}
-			n.ProjectData = *data
-			n.ProjectData.Type = item.Name
-			return true
-		}
-	}
-	return n.props.GetBool(properties.AlwaysEnabled, false)
-}
-
-func (n *Project) Template() string {
-	return " {{ if .Error }}{{ .Error }}{{ else }}{{ if .Version }}\uf487 {{.Version}} {{ end }}{{ if .Name }}{{ .Name }} {{ end }}{{ if .Target }}\uf4de {{.Target}} {{ end }}{{ end }}" //nolint:lll
-}
-
-func (n *Project) Init(props properties.Properties, env runtime.Environment) {
-	n.props = props
-	n.env = env
-
 	n.projects = []*ProjectItem{
 		{
 			Name:    "node",
@@ -124,6 +101,23 @@ func (n *Project) Init(props properties.Properties, env runtime.Environment) {
 			Fetcher: n.getPowerShellModuleData,
 		},
 	}
+
+	for _, item := range n.projects {
+		if n.hasProjectFile(item) {
+			data := item.Fetcher(*item)
+			if data == nil {
+				continue
+			}
+			n.ProjectData = *data
+			n.ProjectData.Type = item.Name
+			return true
+		}
+	}
+	return n.props.GetBool(properties.AlwaysEnabled, false)
+}
+
+func (n *Project) Template() string {
+	return " {{ if .Error }}{{ .Error }}{{ else }}{{ if .Version }}\uf487 {{.Version}} {{ end }}{{ if .Name }}{{ .Name }} {{ end }}{{ if .Target }}\uf4de {{.Target}} {{ end }}{{ end }}" //nolint:lll
 }
 
 func (n *Project) hasProjectFile(p *ProjectItem) bool {

src/segments/pulumi.go

@@ -8,7 +8,6 @@ import (
 	"path/filepath"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 	"gopkg.in/yaml.v3"
 )
 
@@ -24,8 +23,7 @@ const (
 )
 
 type Pulumi struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 
 	Stack string
 	Name  string
@@ -52,11 +50,6 @@ func (p *Pulumi) Template() string {
 	return "\U000f0d46 {{ .Stack }}{{if .User }} :: {{ .User }}@{{ end }}{{ if .URL }}{{ .URL }}{{ end }}"
 }
 
-func (p *Pulumi) Init(props properties.Properties, env runtime.Environment) {
-	p.props = props
-	p.env = env
-}
-
 func (p *Pulumi) Enabled() bool {
 	if !p.env.HasCommand("pulumi") {
 		return false

src/segments/pulumi_test.go

@@ -180,14 +180,14 @@ description: A Console App
 		env.On("HasFilesInDir", filepath.Clean("/home/foobar/.pulumi/workspaces"), workspaceFile).Return(len(tc.WorkSpaceFile) > 0)
 		env.On("FileContent", filepath.Clean("/home/foobar/.pulumi/workspaces/"+workspaceFile)).Return(tc.WorkSpaceFile, nil)
 
-		pulumi := &Pulumi{
+		props := properties.Map{
-			env: env,
-			props: properties.Map{
 			FetchStack: tc.FetchStack,
 			FetchAbout: tc.FetchAbout,
-			},
 		}
 
+		pulumi := &Pulumi{}
+		pulumi.Init(props, env)
+
 		assert.Equal(t, tc.ExpectedEnabled, pulumi.Enabled(), tc.Case)
 
 		if !tc.ExpectedEnabled {

src/segments/python.go

@@ -28,15 +28,10 @@ func (p *Python) Template() string {
 	return " {{ if .Error }}{{ .Error }}{{ else }}{{ if .Venv }}{{ .Venv }} {{ end }}{{ .Full }}{{ end }} "
 }
 
-func (p *Python) Init(props properties.Properties, env runtime.Environment) {
+func (p *Python) Enabled() bool {
-	p.language = language{
+	p.extensions = []string{"*.py", "*.ipynb", "pyproject.toml", "venv.bak"}
-		env:         env,
+	p.folders = []string{".venv", "venv", "virtualenv", "venv-win", "pyenv-win"}
-		props:       props,
+	p.commands = []*cmd{
-		extensions:  []string{"*.py", "*.ipynb", "pyproject.toml", "venv.bak"},
-		folders:     []string{".venv", "venv", "virtualenv", "venv-win", "pyenv-win"},
-		loadContext: p.loadContext,
-		inContext:   p.inContext,
-		commands: []*cmd{
 		{
 			getVersion: p.pyenvVersion,
 			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
@@ -56,13 +51,12 @@ func (p *Python) Init(props properties.Properties, env runtime.Environment) {
 			args:       []string{"--version"},
 			regex:      `(?:Python (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 		},
-		},
-		versionURLTemplate: "https://docs.python.org/release/{{ .Major }}.{{ .Minor }}.{{ .Patch }}/whatsnew/changelog.html#python-{{ .Major }}-{{ .Minor }}-{{ .Patch }}",
-		displayMode:        props.GetString(DisplayMode, DisplayModeEnvironment),
-	}
 	}
+	p.versionURLTemplate = "https://docs.python.org/release/{{ .Major }}.{{ .Minor }}.{{ .Patch }}/whatsnew/changelog.html#python-{{ .Major }}-{{ .Minor }}-{{ .Patch }}"
+	p.displayMode = p.props.GetString(DisplayMode, DisplayModeEnvironment)
+	p.language.loadContext = p.loadContext
+	p.language.inContext = p.inContext
 
-func (p *Python) Enabled() bool {
 	return p.language.Enabled()
 }
 

src/segments/quasar.go

@@ -5,7 +5,6 @@ import (
 	"path/filepath"
 
 	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
 )
 
 const (
@@ -25,11 +24,21 @@ type Quasar struct {
 }
 
 func (q *Quasar) Enabled() bool {
+	q.projectFiles = []string{"quasar.config", "quasar.config.js"}
+	q.commands = []*cmd{
+		{
+			executable: "quasar",
+			args:       []string{"--version"},
+			regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
+		},
+	}
+	q.versionURLTemplate = "https://github.com/quasarframework/quasar/releases/tag/quasar-v{{ .Full }}"
+
 	if !q.language.Enabled() {
 		return false
 	}
 
-	if q.language.props.GetBool(FetchDependencies, false) {
+	if q.props.GetBool(FetchDependencies, false) {
 		q.fetchDependencies()
 	}
 
@@ -40,22 +49,6 @@ func (q *Quasar) Template() string {
 	return " \uea6a {{.Full}}{{ if .HasVite }} \ueb29 {{ .Vite.Version }}{{ end }} "
 }
 
-func (q *Quasar) Init(props properties.Properties, env runtime.Environment) {
-	q.language = language{
-		env:          env,
-		props:        props,
-		projectFiles: []string{"quasar.config", "quasar.config.js"},
-		commands: []*cmd{
-			{
-				executable: "quasar",
-				args:       []string{"--version"},
-				regex:      `(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`,
-			},
-		},
-		versionURLTemplate: "https://github.com/quasarframework/quasar/releases/tag/quasar-v{{ .Full }}",
-	}
-}
-
 func (q *Quasar) fetchDependencies() {
 	if !q.language.env.HasFilesInDir(q.projectRoot.ParentFolder, "package-lock.json") {
 		return

src/segments/r.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type R struct {
 	language
 }
@@ -13,13 +8,10 @@ func (r *R) Template() string {
 	return languageTemplate
 }
 
-func (r *R) Init(props properties.Properties, env runtime.Environment) {
+func (r *R) Enabled() bool {
 	rRegex := `version (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+)))`
-	r.language = language{
+	r.extensions = []string{"*.R", "*.Rmd", "*.Rsx", "*.Rda", "*.Rd", "*.Rproj", ".Rproj.user"}
-		env:        env,
+	r.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.R", "*.Rmd", "*.Rsx", "*.Rda", "*.Rd", "*.Rproj", ".Rproj.user"},
-		commands: []*cmd{
 		{
 			executable: "Rscript",
 			args:       []string{"--version"},
@@ -35,11 +27,8 @@ func (r *R) Init(props properties.Properties, env runtime.Environment) {
 			args:       []string{"--version"},
 			regex:      rRegex,
 		},
-		},
-		versionURLTemplate: "https://www.r-project.org/",
-	}
 	}
+	r.versionURLTemplate = "https://www.r-project.org/"
 
-func (r *R) Enabled() bool {
 	return r.language.Enabled()
 }

src/segments/react.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type React struct {
 	language
 }
@@ -13,22 +8,16 @@ func (r *React) Template() string {
 	return languageTemplate
 }
 
-func (r *React) Init(props properties.Properties, env runtime.Environment) {
+func (r *React) Enabled() bool {
-	r.language = language{
+	r.extensions = []string{"package.json"}
-		env:        env,
+	r.commands = []*cmd{
-		props:      props,
-		extensions: []string{"package.json"},
-		commands: []*cmd{
 		{
 			regex:      `(?:(?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))))`,
 			getVersion: r.getVersion,
 		},
-		},
-		versionURLTemplate: "https://github.com/facebook/react/releases/tag/v{{.Full}}",
-	}
 	}
+	r.versionURLTemplate = "https://github.com/facebook/react/releases/tag/v{{.Full}}"
 
-func (r *React) Enabled() bool {
 	return r.language.Enabled()
 }
 

src/segments/root.go

@@ -1,13 +1,7 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Root struct {
-	props properties.Properties
+	base
-	env   runtime.Environment
 }
 
 func (rt *Root) Template() string {
@@ -17,8 +11,3 @@ func (rt *Root) Template() string {
 func (rt *Root) Enabled() bool {
 	return rt.env.Root()
 }
-
-func (rt *Root) Init(props properties.Properties, env runtime.Environment) {
-	rt.props = props
-	rt.env = env
-}

src/segments/ruby.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Ruby struct {
 	language
 }
@@ -13,12 +8,9 @@ func (r *Ruby) Template() string {
 	return languageTemplate
 }
 
-func (r *Ruby) Init(props properties.Properties, env runtime.Environment) {
+func (r *Ruby) Enabled() bool {
-	r.language = language{
+	r.extensions = []string{"*.rb", "Rakefile", "Gemfile"}
-		env:        env,
+	r.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.rb", "Rakefile", "Gemfile"},
-		commands: []*cmd{
 		{
 			executable: "rbenv",
 			args:       []string{"version-name"},
@@ -44,15 +36,14 @@ func (r *Ruby) Init(props properties.Properties, env runtime.Environment) {
 			args:       []string{"--version"},
 			regex:      `ruby\s+(?P<version>[^\s]+)\s+`,
 		},
-		},
-	}
 	}
 
-func (r *Ruby) Enabled() bool {
 	enabled := r.language.Enabled()
+
 	// this happens when no version is set
 	if r.Full == "______" {
 		r.Full = ""
 	}
+
 	return enabled
 }

src/segments/rust.go

@@ -1,10 +1,5 @@
 package segments
 
-import (
-	"github.com/jandedobbeleer/oh-my-posh/src/properties"
-	"github.com/jandedobbeleer/oh-my-posh/src/runtime"
-)
-
 type Rust struct {
 	language
 }
@@ -13,21 +8,15 @@ func (r *Rust) Template() string {
 	return languageTemplate
 }
 
-func (r *Rust) Init(props properties.Properties, env runtime.Environment) {
+func (r *Rust) Enabled() bool {
-	r.language = language{
+	r.extensions = []string{"*.rs", "Cargo.toml", "Cargo.lock"}
-		env:        env,
+	r.commands = []*cmd{
-		props:      props,
-		extensions: []string{"*.rs", "Cargo.toml", "Cargo.lock"},
-		commands: []*cmd{
 		{
 			executable: "rustc",
 			args:       []string{"--version"},
 			regex:      `rustc (?P<version>((?P<major>[0-9]+).(?P<minor>[0-9]+).(?P<patch>[0-9]+))(-(?P<prerelease>[a-z]+))?)(( \((?P<buildmetadata>[0-9a-f]+ [0-9]+-[0-9]+-[0-9]+)\))?)`,
 		},
-		},
-	}
 	}
 
-func (r *Rust) Enabled() bool {
 	return r.language.Enabled()
 }