Popularity
2.8
Growing
Activity
1.3
-
34
2
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
License: MIT License
Latest version: v1.0.2

wire alternatives and similar packages

Based on the "Utilities" category.
Alternatively, view wire alternatives based on common mentions on social networks and blogs.

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.