decorator

README

Decorator

The decorator pattern provide a lot of benefits when working with legacy code. In this example legacy code is represented by a legacy recipe. A decorator add functionality and in this example decorators are new ingredients.

type LegacyRecipe struct {
}

Starting from legacy code, we must have a default behavior. For example LegacyRecipe could have a method called Decorate that provide the recipe.

func (lr *LegacyRecipe) Decorate() (string, error) {
	return "Original behavior: ", nil
}

All object needed to implement the decorator pattern should implement same interface. Because of we must improve the functionality of Decorate method we'll create an interface like this.

type Decorable interface {
	Decorate() (string, error)
}

And because of we are treating with a legacy recipe, all new ingredient must implement a Decorable interface.

type NewIngredient struct {
	recipe Decorable
}

func (ni *NewIngredient) Decorate() (string, error) {
	if ni.recipe == nil {
		return "", errors.New("decorable recipe is needed")
	}
	s, err := ni.recipe.Decorate()
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("%s %s,", s, "with decoration"), nil
}

As you can see we can use this decorator with:

dec := &NewIngredient{&LegacyRecipe{}}
dev.Decorate() // Original behavior: with decoration

Documentation

Index

• type Decorable
• type LegacyRecipe
  • func (lr *LegacyRecipe) Decorate() (string, error)
• type NewIngredient
  • func (ni *NewIngredient) Decorate() (string, error)

Types

type Decorable

type Decorable interface {
	Decorate() (string, error)
}

type LegacyRecipe

type LegacyRecipe struct {
}

func (*LegacyRecipe) Decorate

func (lr *LegacyRecipe) Decorate() (string, error)

type NewIngredient

type NewIngredient struct {
	// contains filtered or unexported fields
}

func (*NewIngredient) Decorate

func (ni *NewIngredient) Decorate() (string, error)