kitgen implementation

[nyarly]

So far what I've got is simple generation based on a basic interface definition.

Not complete: different layout engines.

Specific design decision here was to construct the generated AST and then
format it out, as opposed to using a text/template. There's some things that
are made much easier this way (i.e. the output is more likely to be correct
code), but the generation code is a bit more opaque. In working with this
process I've found a few things that make the process clearer, and I'm looking
to implement those before this is merged. Specifically, I think many of the
repeated structures could be snagged from an example codefile and then
processed into target structures, rather than built out of whole cloth or
partial inline parses.

[nyarly]

I'll be proceeding with this, but I wanted to get a little oversight to see if it's in a useful vein, @peterbourgon

[peterbourgon]

Ah! I missed the notification! This is great. Let me dig in later today and I'll give some more specific comments...

[peterbourgon]

Yeah, this is badass. Pretty much exactly what I had in mind, modulo the parameterization that you've already acknowledged. I also noticed it panics when I don't name the parameters in my service definition, i.e.

type Service interface {
    Foo(context.Context, int, int) (int, error)     // panic
    Bar(ctx context.Context, i, j int) (int, error) // OK
}

If you have enough to move forward, great! If not, please let me know how I can help: clarifying, requirements-gathering, etc.

[peterbourgon]

Hehe, fun!

$ cat test.go
package main

import "context"

type Service interface {
	Foo(_ context.Context, _ int) (int, error)
}

$ kitgen test.go
 ...
func (s stubService) Foo(ctx context.Context, _ int) (int, error) {
        return "", errors.New("not implemented")
}

type FooRequest struct {
        _ int
}
type FooResponse struct {
        I   int
        Err error
}

func makeFooEndpoint(s stubService) endpoint.Endpoint {
        return func(ctx context.Context, request interface{}) (interface{}, error) {
                req := request.(FooRequest)
                i, err := s.Foo(ctx, req._)
                return FooResponse{I: i, Err: err}, nil
        }
}
 ...

[nyarly]

I'm good. Just wanted to make sure I wasn't running down a rathole. :)

The edge cases are great. Thanks!

[nyarly]

Okay - there's the rebase 🤞

[peterbourgon]

Woohoo!

[zkanda]

I've been trying it out and it works great, thank you @nyarly