drgomesp / cargo Goto Github PK

When I'm looking at the code I've several questions to ask already. I know it's early stage of development, but I guess it might be good to talk about it now than later and since there are no pull-requests to master branch I thought it would be nice to ask those in here. (btw. setting master branch as protected, without merge commits and adding some TravisCI to all PRs would be nice to add)

1. In container/builder.go method:

   // Register a new service definition
   func (b *Builder) Register(id string, fn interface{}) (builder *Builder, err error)

   is creating a definition based on fn inside and is registering this definition into the container.
   Does it really need to care about how to create definition from given interface{}?
   I was thinking that it should just receive id and definition as a parameters. Whole creation of a definition should be done somewhere else - maybe in Loader?

2. There is method Get which will fetch service or definition. There is method GetDefinition which will fetch definition, but there is no GetService method?

3. This file container/builder.go is about building the container itself, right? Should it be aware how to create a service basing on its definition? Wouldn't it be better to create ServiceBuilder that would have all the required logic to create service from some definition?

There must be a way to handle the circular dependency problem.

I can see in the code a lot of variables like fn, t, v, etc.
Wouldn't it be better to keep some naming convention with actually meaningful names for all variables?

It would be simpler to do right now, when project is young.

When registering services, it should be possible to define arguments that are going to be automatically injected once the service gets created at runtime, as the example below:

type Bar struct {}
func NewBar() *Bar {}

builder := NewBuilder()
definition := builder.Register("bar", NewBar)
definition.AddArguments(args ...interface{})

Use convey for behavioral unit testing, starting by covering the existing functionality.

• container.Container
• definition.Definition

One should be able to register service definitions through a configuration file, as the example below:

builder := NewBuilder()
definition := builder.Load("services.json")

Make use of:

https://github.com/drgomesp/gogo
https://github.com/drgomesp/groxy

When registering services, it should be possible to define arguments that are going to be automatically injected once the service gets created at runtime, as the example below:

type Bar struct {}
func NewBar() *Bar {}
func (b *Bar) foo() {}

builder := NewBuilder()
definition := builder.Register("bar", NewBar)
definition.AddMethodCall((*Bar).foo, args ...interface{})

Example:

type MyService struct {
    DepOne SomeInterface 
    DepTwo SomeOtherInterface
}

func New() *MyService {
    return &MyService{}
}

func (s *MyService) setDepOne(depOne *SomeInterface) {
    s.DepOne = depOne
}

func (s *MyService) setDepTwo(depTwo *SomeOtherInterface) {
    s.DepTwo = depTwo
}

container.Register("my_service", New)
container.AddMethodCall("setDepOne", reference.New("dep_one_implementation"))
container.AddMethodCall("setDepTwo", reference.New("dep_two_implementation"))