Popularity
2.6
Growing
Activity
0.0
-
31
1
7

Description

Wire is runtime depedency injection/wiring for golang. It's designed to be strict to avoid your go application running without proper dependency injected.

Programming language: Go
Latest version: v1.0.2

wire alternatives and similar packages

Based on the "Utilities" category

Do you think we are missing an alternative of wire or a related project?

Add another 'Utilities' Package

README

wire

GoDoc Build Status Go Report Card Maintainability Test Coverage FOSSA Status

Wire is runtime depedency injection/wiring for golang. It's designed to be strict to avoid your go application running without proper dependency injected.

Features:

  • Strictly validates dependency and prevents missing or ambiguous dependency.
  • Check againts possible forgotten wire tag.
  • Easily connect and resolve object anywhere.
  • Annotates ambiguous interface type using connection name or implementation name.

Install

go get github.com/Fs02/wire

Example

package wire_test

import (
    "fmt"

    "github.com/Fs02/wire"
)

type Listener struct{}

func (listener Listener) Next() string {
    return "system"
}

type Printer interface {
    Exec(string) error
}

type SystemPrint struct {
    App string `wire:""`
}

func (systemPrint SystemPrint) Exec(msg string) error {
    fmt.Println("[" + systemPrint.App + "] System: " + msg)
    return nil
}

type UserPrint struct {
    App    string `wire:""`
    Target string
}

func (userPrint UserPrint) Exec(msg string) error {
    fmt.Println("[" + userPrint.App + "]" + userPrint.Target + ": " + msg)
    return nil
}

type Service struct {
    // Each of `wire`` tag below indicate fields to be wired with apporpriate component.
    // value inside `wire` tag indicate the name of the component and optionally it's type.
    // `wire` with empty value will be wired with default value (named using empty string).
    // Ambiguous field can be resolved by adding it's type, name or both (separated using comma) to the `wire` tag.
    // Don't worry if you forgot to add wire tag to an interface or a pointer, wire will warn you if any nil field are found.
    // To ignore wiring on specific field, you can use add `wire:"-"`.
    Listener     Listener `wire:""`
    SystemPrint  Printer  `wire:",SystemPrint"`
    FooUserPrint Printer  `wire:"foo"`
    BooUserPrint Printer  `wire:"boo,UserPrint"`
}

func (service Service) Update() error {
    switch service.Listener.Next() {
    case "system":
        return service.SystemPrint.Exec("hello from system")
    case "user-foo":
        return service.FooUserPrint.Exec("hello from foo")
    case "user-boo":
        return service.BooUserPrint.Exec("hello from boo")
    default:
        return nil
    }
}

func init() {
    // add components to be wired by the library.
    // wire all components only once and as early as possible.
    wire.Connect("CoolApp")
    wire.Connect(Listener{})                       // we don't need to pass by reference here, since it doesn't require any wiring.
    wire.Connect(&SystemPrint{})                   // we need to pass by reference it to allow wiring, wire will panic if we pass by value.
    wire.Connect(&UserPrint{Target: "foo"}, "foo") // wire a UserPrint named by "foo".
    wire.Connect(&UserPrint{Target: "boo"}, "boo") // wire a UserPrint named by "boo", wire will panic if there's duplicate components detected.
    wire.Connect(&Service{})

    // Apply wiring
    wire.Apply()
}

func Example() {
    // Resolve a service component to be used later.
    var service Service
    wire.Resolve(&service)

    service.Update()
    // Output: [CoolApp] System: hello from system
}

License

Released under the MIT License

FOSSA Status


*Note that all licence references and agreements mentioned in the wire README section above are relevant to that project's source code only.