DRY up the factory methods

use optional functions to set address functions

cmd/x32-cli/cli.go

@@ -121,7 +121,6 @@ func connect(config Config) (*xair.X32Client, error) {
 	client, err := xair.NewX32Client(
 		config.Host,
 		config.Port,
-		xair.WithKind("x32"),
 		xair.WithTimeout(config.Timeout),
 	)
 	if err != nil {

cmd/xair-cli/cli.go

@@ -119,7 +119,6 @@ func connect(config Config) (*xair.XAirClient, error) {
 	client, err := xair.NewXAirClient(
 		config.Host,
 		config.Port,
-		xair.WithKind("xair"),
 		xair.WithTimeout(config.Timeout),
 	)
 	if err != nil {

internal/xair/address.go

@@ -18,9 +18,9 @@ var x32AddressMap = map[string]string{
 	"snapshot": "/-snap",
 }
 
-func addressMapForMixerKind(kind MixerKind) map[string]string {
+func addressMapFromMixerKind(kind mixerKind) map[string]string {
 	switch kind {
-	case KindX32:
+	case kindX32:
 		return x32AddressMap
 	default:
 		return xairAddressMap

internal/xair/bus.go

@@ -9,12 +9,13 @@ type Bus struct {
 	Comp        *Comp
 }
 
+// newBus creates a new Bus instance
 func newBus(c *Client) *Bus {
 	return &Bus{
 		client:      c,
 		baseAddress: c.addressMap["bus"],
-		Eq:          newEqForBus(c),
-		Comp:        newCompForBus(c),
+		Eq:          newEq(c, c.addressMap["bus"]),
+		Comp:        newComp(c, c.addressMap["bus"]),
 	}
 }
 

internal/xair/client.go

@@ -2,7 +2,6 @@ package xair
 
 import (
 	"fmt"
-	"net"
 	"time"
 
 	"github.com/charmbracelet/log"
@@ -11,9 +10,10 @@ import (
 )
 
 type Client struct {
-	engine
+	*engine
 }
 
+// XAirClient is a client for controlling XAir mixers
 type XAirClient struct {
 	Client
 	Main     *Main
@@ -23,6 +23,7 @@ type XAirClient struct {
 	Snapshot *Snapshot
 }
 
+// X32Client is a client for controlling X32 mixers
 type X32Client struct {
 	Client
 	Main     *Main
@@ -34,50 +35,15 @@ type X32Client struct {
 	Snapshot *Snapshot
 }
 
-func createEngine(mixerIP string, mixerPort int, opts ...Option) (*engine, error) {
-	localAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", 0))
-	if err != nil {
-		return nil, fmt.Errorf("failed to resolve local address: %v", err)
-	}
-
-	conn, err := net.ListenUDP("udp", localAddr)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create UDP connection: %v", err)
-	}
-
-	mixerAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", mixerIP, mixerPort))
-	if err != nil {
-		conn.Close()
-		return nil, fmt.Errorf("failed to resolve mixer address: %v", err)
-	}
-
-	log.Debugf("Local UDP connection: %s	", conn.LocalAddr().String())
-
-	e := &engine{
-		timeout:   100 * time.Millisecond,
-		conn:      conn,
-		mixerAddr: mixerAddr,
-		parser:    newParser(),
-		done:      make(chan bool),
-		respChan:  make(chan *osc.Message, 100),
-	}
-
-	for _, opt := range opts {
-		opt(e)
-	}
-
-	return e, nil
-}
-
-// NewX32Client creates a new X32Client instance
-func NewX32Client(mixerIP string, mixerPort int, opts ...Option) (*X32Client, error) {
-	e, err := createEngine(mixerIP, mixerPort, opts...)
+// NewX32Client creates a new X32Client instance with optional engine configuration
+func NewX32Client(mixerIP string, mixerPort int, opts ...EngineOption) (*X32Client, error) {
+	e, err := newEngine(mixerIP, mixerPort, kindX32, opts...)
 	if err != nil {
 		return nil, err
 	}
 
 	c := &X32Client{
-		Client: Client{*e},
+		Client: Client{e},
 	}
 	c.Main = newMainStereo(&c.Client)
 	c.MainMono = newMainMono(&c.Client)
@@ -90,15 +56,15 @@ func NewX32Client(mixerIP string, mixerPort int, opts ...Option) (*X32Client, er
 	return c, nil
 }
 
-// NewXAirClient creates a new XAirClient instance
-func NewXAirClient(mixerIP string, mixerPort int, opts ...Option) (*XAirClient, error) {
-	e, err := createEngine(mixerIP, mixerPort, opts...)
+// NewXAirClient creates a new XAirClient instance with optional engine configuration
+func NewXAirClient(mixerIP string, mixerPort int, opts ...EngineOption) (*XAirClient, error) {
+	e, err := newEngine(mixerIP, mixerPort, kindXAir, opts...)
 	if err != nil {
 		return nil, err
 	}
 
 	c := &XAirClient{
-		Client: Client{*e},
+		Client: Client{e},
 	}
 	c.Main = newMainStereo(&c.Client)
 	c.Strip = newStrip(&c.Client)

internal/xair/comp.go

@@ -2,53 +2,31 @@ package xair
 
 import "fmt"
 
+// Comp represents the compressor parameters.
 type Comp struct {
 	client      *Client
 	baseAddress string
 	AddressFunc func(fmtString string, args ...any) string
 }
 
-// Factory function to create Comp instance for Main
-func newCompForMain(c *Client) *Comp {
-	return &Comp{
+// Factory function to create Comp instance with optional configuration
+func newComp(c *Client, baseAddress string, opts ...CompOption) *Comp {
+	comp := &Comp{
 		client:      c,
-		baseAddress: c.addressMap["main"],
-		AddressFunc: func(fmtString string, args ...any) string {
-			return fmtString
-		},
-	}
-}
-
-// Factory function to create Comp instance for Strip
-func newCompForStrip(c *Client) *Comp {
-	return &Comp{
-		client:      c,
-		baseAddress: c.addressMap["strip"],
+		baseAddress: fmt.Sprintf("%s/dyn", baseAddress),
 		AddressFunc: fmt.Sprintf,
 	}
-}
 
-// Factory function to create Comp instance for Bus
-func newCompForBus(c *Client) *Comp {
-	return &Comp{
-		client:      c,
-		baseAddress: c.addressMap["bus"],
-		AddressFunc: fmt.Sprintf,
+	for _, opt := range opts {
+		opt(comp)
 	}
-}
 
-// Factory function to create Comp instance for Matrix
-func newCompForMatrix(c *Client) *Comp {
-	return &Comp{
-		client:      c,
-		baseAddress: c.addressMap["matrix"],
-		AddressFunc: fmt.Sprintf,
-	}
+	return comp
 }
 
 // On retrieves the on/off status of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) On(index int) (bool, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/on"
+	address := c.AddressFunc(c.baseAddress, index) + "/on"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return false, err
@@ -67,7 +45,7 @@ func (c *Comp) On(index int) (bool, error) {
 
 // SetOn sets the on/off status of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetOn(index int, on bool) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/on"
+	address := c.AddressFunc(c.baseAddress, index) + "/on"
 	var value int32
 	if on {
 		value = 1
@@ -77,7 +55,7 @@ func (c *Comp) SetOn(index int, on bool) error {
 
 // Mode retrieves the current mode of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Mode(index int) (string, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mode"
+	address := c.AddressFunc(c.baseAddress, index) + "/mode"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return "", err
@@ -98,14 +76,14 @@ func (c *Comp) Mode(index int) (string, error) {
 
 // SetMode sets the mode of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetMode(index int, mode string) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mode"
+	address := c.AddressFunc(c.baseAddress, index) + "/mode"
 	possibleModes := []string{"comp", "exp"}
 	return c.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
 }
 
 // Threshold retrieves the threshold value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Threshold(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/thr"
+	address := c.AddressFunc(c.baseAddress, index) + "/thr"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -124,13 +102,13 @@ func (c *Comp) Threshold(index int) (float64, error) {
 
 // SetThreshold sets the threshold value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetThreshold(index int, threshold float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/thr"
+	address := c.AddressFunc(c.baseAddress, index) + "/thr"
 	return c.client.SendMessage(address, float32(linSet(-60, 0, threshold)))
 }
 
 // Ratio retrieves the ratio value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Ratio(index int) (float32, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/ratio"
+	address := c.AddressFunc(c.baseAddress, index) + "/ratio"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -152,7 +130,7 @@ func (c *Comp) Ratio(index int) (float32, error) {
 
 // SetRatio sets the ratio value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetRatio(index int, ratio float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/ratio"
+	address := c.AddressFunc(c.baseAddress, index) + "/ratio"
 	possibleValues := []float32{1.1, 1.3, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 7.0, 10, 20, 100}
 
 	return c.client.SendMessage(address, int32(indexOf(possibleValues, float32(ratio))))
@@ -160,7 +138,7 @@ func (c *Comp) SetRatio(index int, ratio float64) error {
 
 // Attack retrieves the attack time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Attack(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/attack"
+	address := c.AddressFunc(c.baseAddress, index) + "/attack"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -179,13 +157,13 @@ func (c *Comp) Attack(index int) (float64, error) {
 
 // SetAttack sets the attack time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetAttack(index int, attack float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/attack"
+	address := c.AddressFunc(c.baseAddress, index) + "/attack"
 	return c.client.SendMessage(address, float32(linSet(0, 120, attack)))
 }
 
 // Hold retrieves the hold time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Hold(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/hold"
+	address := c.AddressFunc(c.baseAddress, index) + "/hold"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -204,13 +182,13 @@ func (c *Comp) Hold(index int) (float64, error) {
 
 // SetHold sets the hold time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetHold(index int, hold float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/hold"
+	address := c.AddressFunc(c.baseAddress, index) + "/hold"
 	return c.client.SendMessage(address, float32(logSet(0.02, 2000, hold)))
 }
 
 // Release retrieves the release time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Release(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/release"
+	address := c.AddressFunc(c.baseAddress, index) + "/release"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -229,13 +207,13 @@ func (c *Comp) Release(index int) (float64, error) {
 
 // SetRelease sets the release time of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetRelease(index int, release float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/release"
+	address := c.AddressFunc(c.baseAddress, index) + "/release"
 	return c.client.SendMessage(address, float32(logSet(4, 4000, release)))
 }
 
 // Makeup retrieves the makeup gain of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Makeup(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mgain"
+	address := c.AddressFunc(c.baseAddress, index) + "/mgain"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -254,13 +232,13 @@ func (c *Comp) Makeup(index int) (float64, error) {
 
 // SetMakeup sets the makeup gain of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetMakeup(index int, makeup float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mgain"
+	address := c.AddressFunc(c.baseAddress, index) + "/mgain"
 	return c.client.SendMessage(address, float32(linSet(0, 24, makeup)))
 }
 
 // Mix retrieves the mix value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) Mix(index int) (float64, error) {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mix"
+	address := c.AddressFunc(c.baseAddress, index) + "/mix"
 	err := c.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -279,6 +257,6 @@ func (c *Comp) Mix(index int) (float64, error) {
 
 // SetMix sets the mix value of the Compressor for a specific strip or bus (1-based indexing).
 func (c *Comp) SetMix(index int, mix float64) error {
-	address := c.AddressFunc(c.baseAddress, index) + "/dyn/mix"
+	address := c.AddressFunc(c.baseAddress, index) + "/mix"
 	return c.client.SendMessage(address, float32(linSet(0, 100, mix)))
 }

internal/xair/engine.go

@@ -14,7 +14,7 @@ type parser interface {
 }
 
 type engine struct {
-	Kind      MixerKind
+	Kind      mixerKind
 	timeout   time.Duration
 	conn      *net.UDPConn
 	mixerAddr *net.UDPAddr
@@ -26,6 +26,42 @@ type engine struct {
 	respChan chan *osc.Message
 }
 
+func newEngine(mixerIP string, mixerPort int, kind mixerKind, opts ...EngineOption) (*engine, error) {
+	localAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", 0))
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve local address: %v", err)
+	}
+
+	conn, err := net.ListenUDP("udp", localAddr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create UDP connection: %v", err)
+	}
+
+	mixerAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", mixerIP, mixerPort))
+	if err != nil {
+		conn.Close()
+		return nil, fmt.Errorf("failed to resolve mixer address: %v", err)
+	}
+
+	log.Debugf("Local UDP connection: %s	", conn.LocalAddr().String())
+
+	e := &engine{
+		timeout:    100 * time.Millisecond,
+		conn:       conn,
+		mixerAddr:  mixerAddr,
+		parser:     newParser(),
+		addressMap: addressMapFromMixerKind(kind),
+		done:       make(chan bool),
+		respChan:   make(chan *osc.Message, 100),
+	}
+
+	for _, opt := range opts {
+		opt(e)
+	}
+
+	return e, nil
+}
+
 // receiveLoop handles incoming OSC messages
 func (e *engine) receiveLoop() {
 	buffer := make([]byte, 4096)

internal/xair/eq.go

@@ -4,53 +4,31 @@ import (
 	"fmt"
 )
 
+// Eq represents the EQ parameters.
 type Eq struct {
 	client      *Client
 	baseAddress string
 	AddressFunc func(fmtString string, args ...any) string
 }
 
-// Factory function to create Eq instance for Main
-func newEqForMain(c *Client) *Eq {
-	return &Eq{
+// Factory function to create Eq instance with optional configuration
+func newEq(c *Client, baseAddress string, opts ...EqOption) *Eq {
+	eq := &Eq{
 		client:      c,
-		baseAddress: c.addressMap["main"],
-		AddressFunc: func(fmtString string, args ...any) string {
-			return fmtString
-		},
-	}
-}
-
-// Factory function to create Eq instance for Strip
-func newEqForStrip(c *Client) *Eq {
-	return &Eq{
-		client:      c,
-		baseAddress: c.addressMap["strip"],
+		baseAddress: fmt.Sprintf("%s/eq", baseAddress),
 		AddressFunc: fmt.Sprintf,
 	}
-}
 
-// Factory function to create Eq instance for Bus
-func newEqForBus(c *Client) *Eq {
-	return &Eq{
-		client:      c,
-		baseAddress: c.addressMap["bus"],
-		AddressFunc: fmt.Sprintf,
+	for _, opt := range opts {
+		opt(eq)
 	}
-}
 
-// Factory function to create Eq instance for Matrix
-func newEqForMatrix(c *Client) *Eq {
-	return &Eq{
-		client:      c,
-		baseAddress: c.addressMap["matrix"],
-		AddressFunc: fmt.Sprintf,
-	}
+	return eq
 }
 
 // On retrieves the on/off status of the EQ for a specific strip or bus (1-based indexing).
 func (e *Eq) On(index int) (bool, error) {
-	address := e.AddressFunc(e.baseAddress, index) + "/eq/on"
+	address := e.AddressFunc(e.baseAddress, index) + "/on"
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return false, err
@@ -69,7 +47,7 @@ func (e *Eq) On(index int) (bool, error) {
 
 // SetOn sets the on/off status of the EQ for a specific strip or bus (1-based indexing).
 func (e *Eq) SetOn(index int, on bool) error {
-	address := e.AddressFunc(e.baseAddress, index) + "/eq/on"
+	address := e.AddressFunc(e.baseAddress, index) + "/on"
 	var value int32
 	if on {
 		value = 1
@@ -78,7 +56,7 @@ func (e *Eq) SetOn(index int, on bool) error {
 }
 
 func (e *Eq) Mode(index int) (string, error) {
-	address := e.AddressFunc(e.baseAddress, index) + "/eq/mode"
+	address := e.AddressFunc(e.baseAddress, index) + "/mode"
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return "", err
@@ -98,14 +76,14 @@ func (e *Eq) Mode(index int) (string, error) {
 }
 
 func (e *Eq) SetMode(index int, mode string) error {
-	address := e.AddressFunc(e.baseAddress, index) + "/eq/mode"
+	address := e.AddressFunc(e.baseAddress, index) + "/mode"
 	possibleModes := []string{"peq", "geq", "teq"}
 	return e.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
 }
 
 // Gain retrieves the gain for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) Gain(index int, band int) (float64, error) {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/g", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/g", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -124,13 +102,13 @@ func (e *Eq) Gain(index int, band int) (float64, error) {
 
 // SetGain sets the gain for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) SetGain(index int, band int, gain float64) error {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/g", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/g", band)
 	return e.client.SendMessage(address, float32(linSet(-15, 15, gain)))
 }
 
 // Frequency retrieves the frequency for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) Frequency(index int, band int) (float64, error) {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/f", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/f", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -149,13 +127,13 @@ func (e *Eq) Frequency(index int, band int) (float64, error) {
 
 // SetFrequency sets the frequency for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) SetFrequency(index int, band int, frequency float64) error {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/f", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/f", band)
 	return e.client.SendMessage(address, float32(logSet(20, 20000, frequency)))
 }
 
 // Q retrieves the Q factor for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) Q(index int, band int) (float64, error) {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/q", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/q", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -174,13 +152,13 @@ func (e *Eq) Q(index int, band int) (float64, error) {
 
 // SetQ sets the Q factor for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) SetQ(index int, band int, q float64) error {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/q", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/q", band)
 	return e.client.SendMessage(address, float32(1.0-logSet(0.3, 10, q)))
 }
 
 // Type retrieves the type for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) Type(index int, band int) (string, error) {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/type", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/type", band)
 	err := e.client.SendMessage(address)
 	if err != nil {
 		return "", err
@@ -201,7 +179,7 @@ func (e *Eq) Type(index int, band int) (string, error) {
 
 // SetType sets the type for a specific EQ band on a strip or bus (1-based indexing).
 func (e *Eq) SetType(index int, band int, eqType string) error {
-	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/eq/%d/type", band)
+	address := e.AddressFunc(e.baseAddress, index) + fmt.Sprintf("/%d/type", band)
 	possibleTypes := []string{"lcut", "lshv", "peq", "veq", "hshv", "hcut"}
 	return e.client.SendMessage(address, int32(indexOf(possibleTypes, eqType)))
 }

internal/xair/gate.go

@@ -2,22 +2,31 @@ package xair
 
 import "fmt"
 
+// Gate represents the gate parameters.
 type Gate struct {
 	client      *Client
 	baseAddress string
+	AddressFunc func(fmtString string, args ...any) string
 }
 
-// Factory function to create Gate instance for Strip
-func newGateForStrip(c *Client) *Gate {
-	return &Gate{
+// Factory function to create Gate instance with optional configuration
+func newGate(c *Client, baseAddress string, opts ...GateOption) *Gate {
+	gate := &Gate{
 		client:      c,
-		baseAddress: c.addressMap["strip"],
+		baseAddress: fmt.Sprintf("%s/gate", baseAddress),
+		AddressFunc: fmt.Sprintf,
 	}
+
+	for _, opt := range opts {
+		opt(gate)
+	}
+
+	return gate
 }
 
 // On retrieves the on/off status of the Gate for a specific strip (1-based indexing).
 func (g *Gate) On(index int) (bool, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/on"
+	address := g.AddressFunc(g.baseAddress, index) + "/on"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return false, err
@@ -36,7 +45,7 @@ func (g *Gate) On(index int) (bool, error) {
 
 // SetOn sets the on/off status of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetOn(index int, on bool) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/on"
+	address := g.AddressFunc(g.baseAddress, index) + "/on"
 	var value int32
 	if on {
 		value = 1
@@ -46,7 +55,7 @@ func (g *Gate) SetOn(index int, on bool) error {
 
 // Mode retrieves the current mode of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Mode(index int) (string, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/mode"
+	address := g.AddressFunc(g.baseAddress, index) + "/mode"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return "", err
@@ -67,7 +76,7 @@ func (g *Gate) Mode(index int) (string, error) {
 
 // SetMode sets the mode of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetMode(index int, mode string) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/mode"
+	address := g.AddressFunc(g.baseAddress, index) + "/mode"
 	possibleModes := []string{"exp2", "exp3", "exp4", "gate", "duck"}
 
 	return g.client.SendMessage(address, int32(indexOf(possibleModes, mode)))
@@ -75,7 +84,7 @@ func (g *Gate) SetMode(index int, mode string) error {
 
 // Threshold retrieves the threshold value of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Threshold(index int) (float64, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/thr"
+	address := g.AddressFunc(g.baseAddress, index) + "/thr"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -94,13 +103,13 @@ func (g *Gate) Threshold(index int) (float64, error) {
 
 // SetThreshold sets the threshold value of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetThreshold(index int, threshold float64) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/thr"
+	address := g.AddressFunc(g.baseAddress, index) + "/thr"
 	return g.client.SendMessage(address, float32(linSet(-80, 0, threshold)))
 }
 
 // Range retrieves the range value of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Range(index int) (float64, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/range"
+	address := g.AddressFunc(g.baseAddress, index) + "/range"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -119,13 +128,13 @@ func (g *Gate) Range(index int) (float64, error) {
 
 // SetRange sets the range value of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetRange(index int, rangeVal float64) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/range"
+	address := g.AddressFunc(g.baseAddress, index) + "/range"
 	return g.client.SendMessage(address, float32(linSet(3, 60, rangeVal)))
 }
 
 // Attack retrieves the attack time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Attack(index int) (float64, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/attack"
+	address := g.AddressFunc(g.baseAddress, index) + "/attack"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -144,13 +153,13 @@ func (g *Gate) Attack(index int) (float64, error) {
 
 // SetAttack sets the attack time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetAttack(index int, attack float64) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/attack"
+	address := g.AddressFunc(g.baseAddress, index) + "/attack"
 	return g.client.SendMessage(address, float32(linSet(0, 120, attack)))
 }
 
 // Hold retrieves the hold time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Hold(index int) (float64, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/hold"
+	address := g.AddressFunc(g.baseAddress, index) + "/hold"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -169,13 +178,13 @@ func (g *Gate) Hold(index int) (float64, error) {
 
 // SetHold sets the hold time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetHold(index int, hold float64) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/hold"
+	address := g.AddressFunc(g.baseAddress, index) + "/hold"
 	return g.client.SendMessage(address, float32(logSet(0.02, 2000, hold)))
 }
 
 // Release retrieves the release time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) Release(index int) (float64, error) {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/release"
+	address := g.AddressFunc(g.baseAddress, index) + "/release"
 	err := g.client.SendMessage(address)
 	if err != nil {
 		return 0, err
@@ -194,6 +203,6 @@ func (g *Gate) Release(index int) (float64, error) {
 
 // SetRelease sets the release time of the Gate for a specific strip (1-based indexing).
 func (g *Gate) SetRelease(index int, release float64) error {
-	address := fmt.Sprintf(g.baseAddress, index) + "/gate/release"
+	address := g.AddressFunc(g.baseAddress, index) + "/release"
 	return g.client.SendMessage(address, float32(logSet(5, 4000, release)))
 }

internal/xair/kinds.go

@@ -1,8 +1,8 @@
 package xair
 
-type MixerKind string
+type mixerKind string
 
 const (
-	KindXAir MixerKind = "xair"
-	KindX32  MixerKind = "x32"
+	kindXAir mixerKind = "xair"
+	kindX32  mixerKind = "x32"
 )

internal/xair/main.go

@@ -11,19 +11,29 @@ type Main struct {
 
 // newMainStereo creates a new Main instance for stereo main output
 func newMainStereo(c *Client) *Main {
+	addressFunc := func(fmtString string, args ...any) string {
+		return fmtString
+	}
+
 	return &Main{
 		client:      c,
 		baseAddress: c.addressMap["main"],
-		Eq:          newEqForMain(c),
-		Comp:        newCompForMain(c),
+		Eq:          newEq(c, c.addressMap["main"], WithEqAddressFunc(addressFunc)),
+		Comp:        newComp(c, c.addressMap["main"], WithCompAddressFunc(addressFunc)),
 	}
 }
 
 // newMainMono creates a new MainMono instance for mono main output (X32 only)
 func newMainMono(c *Client) *Main {
+	addressFunc := func(fmtString string, args ...any) string {
+		return fmtString
+	}
+
 	return &Main{
 		baseAddress: c.addressMap["mainmono"],
 		client:      c,
+		Eq:          newEq(c, c.addressMap["mainmono"], WithEqAddressFunc(addressFunc)),
+		Comp:        newComp(c, c.addressMap["mainmono"], WithCompAddressFunc(addressFunc)),
 	}
 }
 

internal/xair/matrix.go

@@ -14,8 +14,8 @@ func newMatrix(c *Client) *Matrix {
 	return &Matrix{
 		client:      c,
 		baseAddress: c.addressMap["matrix"],
-		Eq:          newEqForMatrix(c),
-		Comp:        newCompForMatrix(c),
+		Eq:          newEq(c, c.addressMap["matrix"]),
+		Comp:        newComp(c, c.addressMap["matrix"]),
 	}
 }
 

internal/xair/option.go

@@ -2,17 +2,38 @@ package xair
 
 import "time"
 
-type Option func(*engine)
+type EngineOption func(*engine)
 
-func WithKind(kind string) Option {
-	return func(e *engine) {
-		e.Kind = MixerKind(kind)
-		e.addressMap = addressMapForMixerKind(e.Kind)
-	}
-}
-
-func WithTimeout(timeout time.Duration) Option {
+// WithTimeout sets the timeout duration for OSC message responses
+func WithTimeout(timeout time.Duration) EngineOption {
 	return func(e *engine) {
 		e.timeout = timeout
 	}
 }
+
+type CompOption func(*Comp)
+
+// WithCompAddressFunc allows customization of the OSC address formatting for Comp parameters
+func WithCompAddressFunc(f func(fmtString string, args ...any) string) CompOption {
+	return func(c *Comp) {
+		c.AddressFunc = f
+	}
+}
+
+type EqOption func(*Eq)
+
+// WithEqAddressFunc allows customization of the OSC address formatting for Eq parameters
+func WithEqAddressFunc(f func(fmtString string, args ...any) string) EqOption {
+	return func(e *Eq) {
+		e.AddressFunc = f
+	}
+}
+
+type GateOption func(*Gate)
+
+// WithGateAddressFunc allows customization of the OSC address formatting for Gate parameters
+func WithGateAddressFunc(f func(fmtString string, args ...any) string) GateOption {
+	return func(g *Gate) {
+		g.AddressFunc = f
+	}
+}

internal/xair/snapshot.go

@@ -7,6 +7,7 @@ type Snapshot struct {
 	baseAddress string
 }
 
+// newSnapshot creates a new Snapshot instance
 func newSnapshot(c *Client) *Snapshot {
 	return &Snapshot{
 		client:      c,

internal/xair/strip.go

@@ -10,13 +10,14 @@ type Strip struct {
 	Comp        *Comp
 }
 
+// newStrip creates a new Strip instance
 func newStrip(c *Client) *Strip {
 	return &Strip{
 		client:      c,
 		baseAddress: c.addressMap["strip"],
-		Gate:        newGateForStrip(c),
-		Eq:          newEqForStrip(c),
-		Comp:        newCompForStrip(c),
+		Gate:        newGate(c, c.addressMap["strip"]),
+		Eq:          newEq(c, c.addressMap["strip"]),
+		Comp:        newComp(c, c.addressMap["strip"]),
 	}
 }