haveapi-go-client 0.13.0

data/template/action.go.erb

@@ -0,0 +1,475 @@
+package <%= package %>
+
+import (
+<% if action.has_path_params? -%>
+	"strings"
+<% end -%>
+)
+
+// <%= action.go_type %> is a type for action <%= action.full_dot_name %>
+type <%= action.go_type %> struct {
+	// Pointer to client
+	Client *Client
+}
+
+func New<%= action.go_type %>(client *Client) *<%= action.go_type %> {
+	return &<%= action.go_type %>{
+		Client: client,
+	}
+}
+
+<% if action.metadata.has_global_input? -%>
+// <%= action.metadata.global.input.go_type %> is a type for action global meta input parameters
+type <%= action.metadata.global.input.go_type %> struct {
+<% action.metadata.global.input.parameters.each do |p| -%>
+	<%= p.go_name %> <%= p.go_in_type %> `json:"<%= p.name %>"`
+<% end -%>
+	// Only selected parameters are sent to the API. Ignored if empty.
+	_selectedParameters map[string]interface{}
+}
+
+<% action.metadata.global.input.parameters.each do |p| -%>
+// Set<%= p.go_name %> sets parameter <%= p.go_name %> to value and selects it for sending
+func (in *<%= action.metadata.global.input.go_type %>) Set<%= p.go_name %>(value <%= p.go_in_type %>) *<%= action.metadata.global.input.go_type %> {
+	in.<%= p.go_name %> = value
+
+	if in._selectedParameters == nil {
+		in._selectedParameters = make(map[string]interface{})
+	}
+
+	in._selectedParameters["<%= p.go_name %>"] = nil
+	return in
+}
+<% end -%>
+
+// SelectParameters sets parameters from <%= action.metadata.global.input.go_type %>
+// that will be sent to the API.
+// SelectParameters can be called multiple times.
+func (in *<%= action.metadata.global.input.go_type %>) SelectParameters(params ...string) *<%= action.metadata.global.input.go_type %> {
+	if in._selectedParameters == nil {
+		in._selectedParameters = make(map[string]interface{})
+	}
+
+	for _, param := range params {
+		in._selectedParameters[param] = nil
+	}
+
+	return in
+}
+
+func (in *<%= action.metadata.global.input.go_type %>) AnySelected() bool {
+	if in._selectedParameters == nil {
+		return false
+	}
+
+	return len(in._selectedParameters) > 0
+}
+<% end -%>
+
+<% if action.has_input? -%>
+// <%= action.input.go_type %> is a type for action input parameters
+type <%= action.input.go_type %> struct {
+<% action.input.parameters.each do |p| -%>
+	<%= p.go_name %> <%= p.go_in_type %> `json:"<%= p.name %>"`
+<% end -%>
+	// Only selected parameters are sent to the API. Ignored if empty.
+	_selectedParameters map[string]interface{}
+}
+
+<% action.input.parameters.each do |p| -%>
+// Set<%= p.go_name %> sets parameter <%= p.go_name %> to value and selects it for sending
+func (in *<%= action.input.go_type %>) Set<%= p.go_name %>(value <%= p.go_in_type %>) *<%= action.input.go_type %> {
+	in.<%= p.go_name %> = value
+
+	if in._selectedParameters == nil {
+		in._selectedParameters = make(map[string]interface{})
+	}
+
+	in._selectedParameters["<%= p.go_name %>"] = nil
+	return in
+}
+<% end -%>
+
+// SelectParameters sets parameters from <%= action.input.go_type %>
+// that will be sent to the API.
+// SelectParameters can be called multiple times.
+func (in *<%= action.input.go_type %>) SelectParameters(params ...string) *<%= action.input.go_type %> {
+	if in._selectedParameters == nil {
+		in._selectedParameters = make(map[string]interface{})
+	}
+
+	for _, param := range params {
+		in._selectedParameters[param] = nil
+	}
+
+	return in
+}
+
+func (in *<%= action.input.go_type %>) AnySelected() bool {
+	if in._selectedParameters == nil {
+		return false
+	}
+
+	return len(in._selectedParameters) > 0
+}
+<% end -%>
+
+<% if (action.has_input? || action.metadata.has_global_input?) && action.http_method != 'GET' -%>
+// <%= action.go_request_type %> is a type for the entire action request
+type <%= action.go_request_type %> struct {
+<% if action.has_input? -%>
+	<%= action.input.go_namespace %> map[string]interface{} `json:"<%= action.input.namespace %>"`
+<% end -%>
+<% if action.metadata.has_global_input? -%>
+	Meta map[string]interface{} `json:"<%= action.resource.api_version.metadata_namespace %>"`
+<% end -%>
+}
+<% end -%>
+
+<% if action.has_output? -%>
+// <%= action.output.go_type %> is a type for action output parameters
+type <%= action.output.go_type %> struct {
+<% action.output.parameters.each do |p| -%>
+<% if p.respond_to?(:association) -%>
+	<%= p.go_name %> *<%= p.go_out_type %> `json:"<%= p.name %>"`
+<% else -%>
+	<%= p.go_name %> <%= p.go_out_type %> `json:"<%= p.name %>"`
+<% end -%>
+<% end -%>
+}
+<% end -%>
+
+<% if action.blocking? -%>
+// <%= action.metadata.global.output.go_type %> is a type for global output metadata parameters
+type <%= action.metadata.global.output.go_type %> struct {
+<% action.metadata.global.output.parameters.each do |p| -%>
+	<%= p.go_name %> <%= p.go_out_type %> `json:"<%= p.name %>"`
+<% end -%>
+}
+<% end -%>
+
+// Type for action response, including envelope
+type <%= action.go_response_type %> struct {
+	Action *<%= action.go_type %> `json:"-"`
+	*Envelope
+<% if action.has_output? -%>
+<% if %w(hash object).include?(action.output.layout) -%>
+	// Action output encapsulated within a namespace
+	Response *struct {
+		<%= action.output.go_namespace %> *<%= action.output.go_type %> `json:"<%= action.output.namespace %>"`
+<% if action.blocking? -%>
+		// Global output metadata
+		Meta *<%= action.metadata.global.output.go_type %> `json:"<%= action.resource.api_version.metadata_namespace %>"`
+<% end -%>
+	}
+
+	// Action output without the namespace
+	Output *<%= action.output.go_type %>
+<% elsif %w(hash_list object_list).include?(action.output.layout) -%>
+	// Action output encapsulated within a namespace
+	Response *struct {
+		<%= action.output.go_namespace %> []*<%= action.output.go_type %> `json:"<%= action.output.namespace %>"`
+<% if action.blocking? -%>
+		// Global output metadata
+		Meta *<%= action.metadata.global.output.go_type %> `json:"<%= action.resource.api_version.metadata_namespace %>"`
+<% end -%>
+	}
+
+	// Action output without the namespace
+	Output []*<%= action.output.go_type %>
+<% end -%>
+<% elsif action.blocking? -%>
+	// Action output encapsulated within a namespace
+	Response *struct {
+		// Global output metadata
+		Meta *<%= action.metadata.global.output.go_type %> `json:"<%= action.resource.api_version.metadata_namespace %>"`
+	}
+<% end -%>
+}
+
+<% if !action.has_path_params? && !action.has_input? -%>
+// Call the action directly without any path or input parameters
+func (action *<%= action.go_type %>) Call() (*<%= action.go_response_type %>, error) {
+	return action.Prepare().Call()
+}
+<% end -%>
+
+// Prepare the action for invocation
+func (action *<%= action.go_type %>) Prepare() *<%= action.go_invocation_type%> {
+	return &<%= action.go_invocation_type %>{
+		Action: action,
+		Path: "<%= action.path %>",
+	}
+}
+
+// <%= action.go_invocation_type %> is used to configure action for invocation
+type <%= action.go_invocation_type %> struct {
+	// Pointer to the action
+	Action *<%= action.go_type %>
+
+	// Path which may contain parameters that need to be set
+	Path string
+<% if action.has_input? -%>
+	// Input parameters
+	Input *<%= action.input.go_type %>
+<% end -%>
+<% if action.metadata.has_global_input? -%>
+	// Global meta input parameters
+	MetaInput *<%= action.metadata.global.input.go_type %>
+<% end -%>
+}
+
+<% if action.has_path_params? -%>
+// SetPathParamInt sets integer path parameter
+func (inv *<%= action.go_invocation_type %>) SetPathParamInt(param string, value int64) *<%= action.go_invocation_type %> {
+	return inv.SetPathParamString(param, convertInt64ToString(value))
+}
+
+// SetPathParamString sets string path parameter
+func (inv *<%= action.go_invocation_type %>) SetPathParamString(param string, value string) *<%= action.go_invocation_type %> {
+	inv.Path = strings.Replace(inv.Path, "{"+param+"}", value, 1)
+	return inv
+}
+<% end -%>
+
+<% if action.has_input? -%>
+// NewInput returns a new struct for input parameters and sets it as with SetInput
+func (inv *<%= action.go_invocation_type %>) NewInput() *<%= action.input.go_type %> {
+	inv.Input = &<%= action.input.go_type %>{}
+	return inv.Input
+}
+
+// SetInput provides input parameters to send to the API
+func (inv *<%= action.go_invocation_type %>) SetInput(input *<%= action.input.go_type %>) *<%= action.go_invocation_type %> {
+	inv.Input = input
+	return inv
+}
+
+// IsParameterSelected returns true if param is to be sent to the API
+func (inv *<%= action.go_invocation_type %>) IsParameterSelected(param string) bool {
+	if inv.Input._selectedParameters == nil {
+		return true
+	}
+
+	_, exists := inv.Input._selectedParameters[param]
+	return exists
+}
+<% end -%>
+<% if action.metadata.has_global_input? -%>
+// NewMetaInput returns a new struct for global meta input parameters and sets
+// it as with SetMetaInput
+func (inv *<%= action.go_invocation_type %>) NewMetaInput() *<%= action.metadata.global.input.go_type %> {
+	inv.MetaInput = &<%= action.metadata.global.input.go_type %>{}
+	return inv.MetaInput
+}
+
+// SetMetaInput provides global meta input parameters to send to the API
+func (inv *<%= action.go_invocation_type %>) SetMetaInput(input *<%= action.metadata.global.input.go_type %>) *<%= action.go_invocation_type %> {
+	inv.MetaInput = input
+	return inv
+}
+
+// IsMetaParameterSelected returns true if global meta param is to be sent to the API
+func (inv *<%= action.go_invocation_type %>) IsMetaParameterSelected(param string) bool {
+	if inv.MetaInput._selectedParameters == nil {
+		return true
+	}
+
+	_, exists := inv.MetaInput._selectedParameters[param]
+	return exists
+}
+<% end -%>
+
+// Call() invokes the action and returns a response from the API server
+func (inv *<%= action.go_invocation_type %>) Call() (*<%= action.go_response_type %>, error) {
+<% if action.http_method == 'GET' -%>
+	return inv.callAsQuery()
+<% else -%>
+	return inv.callAsBody()
+<% end -%>
+}
+
+<% if action.http_method == 'GET' -%>
+func (inv *<%= action.go_invocation_type %>) callAsQuery() (*<%= action.go_response_type %>, error) {
+	queryParams := make(map[string]string)
+<% if action.has_input? -%>
+	inv.convertInputToQueryParams(queryParams)
+<% end -%>
+<% if action.metadata.has_global_input? -%>
+	inv.convertMetaInputToQueryParams(queryParams)
+<% end -%>
+	resp := &<%= action.go_response_type %>{Action: inv.Action}
+	err := inv.Action.Client.DoQueryStringRequest(inv.Path, queryParams, resp)
+<% if action.has_output? -%>
+	if err == nil && resp.Status {
+		resp.Output = resp.Response.<%= action.output.go_namespace %>
+	}
+<% end -%>
+	return resp, err
+}
+<% end -%>
+
+<% if action.http_method != 'GET' -%>
+func (inv *<%= action.go_invocation_type %>) callAsBody() (*<%= action.go_response_type %>, error) {
+<% if action.has_input? || action.metadata.has_global_input? -%>
+	input := inv.makeAllInputParams()
+<% else -%>
+	input := make(map[string]interface{})
+<% end -%>
+	resp := &<%= action.go_response_type %>{Action: inv.Action}
+	err := inv.Action.Client.DoBodyRequest("<%= action.http_method %>", inv.Path, input, resp)
+<% if action.has_output? -%>
+	if err == nil && resp.Status {
+		resp.Output = resp.Response.<%= action.output.go_namespace %>
+	}
+<% end -%>
+	return resp, err
+}
+<% end -%>
+
+<% if action.blocking? -%>
+// IsBlocking checks whether the current invocation resulted in a blocking operation
+func (resp *<%= action.go_response_type %>) IsBlocking() bool {
+	return resp.Response.Meta != nil && resp.Response.Meta.ActionStateId > 0
+}
+
+// OperationStatus queries the current state of the blocking operation
+func (resp *<%= action.go_response_type %>) OperationStatus() (*ActionActionStateShowResponse, error) {
+	req := resp.Action.Client.ActionState.Show.Prepare()
+	req.SetPathParamInt("action_state_id", resp.Response.Meta.ActionStateId)
+	return req.Call()
+}
+
+// WaitForOperation waits for a blocking operation to finish
+func (resp *<%= action.go_response_type %>) WaitForOperation(timeout float64) (*ActionActionStatePollResponse, error) {
+	req := resp.Action.Client.ActionState.Poll.Prepare()
+	req.SetPathParamInt("action_state_id", resp.Response.Meta.ActionStateId)
+
+	input := req.NewInput()
+	input.SetTimeout(timeout)
+
+	return req.Call()
+}
+
+// WatchOperation waits for a blocking operation to finish and calls a callback
+// function with progress updates
+func (resp *<%= action.go_response_type %>) WatchOperation(timeout float64, updateIn float64, callback OperationProgressCallback) (*ActionActionStatePollResponse, error) {
+	req := resp.Action.Client.ActionState.Poll.Prepare()
+	req.SetPathParamInt("action_state_id", resp.Response.Meta.ActionStateId)
+
+	input := req.NewInput()
+	input.SetTimeout(timeout)
+	input.SetUpdateIn(updateIn)
+
+	pollResp, err := req.Call()
+
+	if err != nil {
+		return pollResp, err
+	} else if pollResp.Output.Finished {
+		return pollResp, nil
+	}
+
+	if callback(pollResp.Output) == StopWatching {
+		return pollResp, nil
+	}
+
+	for {
+		req = resp.Action.Client.ActionState.Poll.Prepare()
+		req.SetPathParamInt("action_state_id", resp.Response.Meta.ActionStateId)
+		req.SetInput(&ActionActionStatePollInput{
+			Timeout: timeout,
+			UpdateIn: updateIn,
+			Status: pollResp.Output.Status,
+			Current: pollResp.Output.Current,
+			Total: pollResp.Output.Total,
+		})
+		pollResp, err = req.Call()
+
+		if err != nil {
+			return pollResp, err
+		} else if pollResp.Output.Finished {
+			return pollResp, nil
+		}
+
+		if callback(pollResp.Output) == StopWatching {
+			return pollResp, nil
+		}
+	}
+}
+
+// CancelOperation cancels the current blocking operation
+func (resp *<%= action.go_response_type %>) CancelOperation() (*ActionActionStateCancelResponse, error) {
+	req := resp.Action.Client.ActionState.Cancel.Prepare()
+	req.SetPathParamInt("action_state_id", resp.Response.Meta.ActionStateId)
+	return req.Call()
+}
+<% end -%>
+
+<% if action.http_method == 'GET' && action.has_input? -%>
+func (inv *<%= action.go_invocation_type %>) convertInputToQueryParams(ret map[string]string) {
+	if inv.Input != nil {
+<% action.input.parameters.each do |p| -%>
+		if inv.IsParameterSelected("<%= p.go_name %>") {
+			ret["<%= action.input.namespace %>[<%= p.name %>]"] = <% if p.go_in_type == 'string' %>inv.Input.<%= p.go_name %><% else %>convert<%= p.go_in_type.capitalize %>ToString(inv.Input.<%= p.go_name %>)<% end %>
+		}
+<% end -%>
+	}
+}
+<% end -%>
+
+<% if action.http_method == 'GET' && action.metadata.has_global_input? -%>
+func (inv *<%= action.go_invocation_type %>) convertMetaInputToQueryParams(ret map[string]string) {
+	if inv.MetaInput != nil {
+<% action.metadata.global.input.parameters.each do |p| -%>
+		if inv.IsMetaParameterSelected("<%= p.go_name %>") {
+			ret["<%= action.resource.api_version.metadata_namespace %>[<%= p.name %>]"] = <% if p.go_in_type == 'string' %>inv.MetaInput.<%= p.go_name %><% else %>convert<%= p.go_in_type.capitalize %>ToString(inv.MetaInput.<%= p.go_name %>)<% end %>
+		}
+<% end -%>
+	}
+}
+<% end -%>
+
+<% if action.http_method != 'GET' && (action.has_input? || action.metadata.has_global_input?) -%>
+func (inv *<%= action.go_invocation_type %>) makeAllInputParams() *<%= action.go_request_type %> {
+	return &<%= action.go_request_type %>{
+<% if action.has_input? -%>
+		<%= action.input.go_namespace %>: inv.makeInputParams(),
+<% end -%>
+<% if action.metadata.has_global_input? -%>
+		Meta: inv.makeMetaInputParams(),
+<% end -%>
+	}
+}
+
+<% if action.has_input? -%>
+func (inv *<%= action.go_invocation_type %>) makeInputParams() map[string]interface{} {
+	ret := make(map[string]interface{})
+
+	if inv.Input != nil {
+<% action.input.parameters.each do |p| -%>
+		if inv.IsParameterSelected("<%= p.go_name %>") {
+			ret["<%= p.name %>"] = inv.Input.<%= p.go_name %>
+		}
+<% end -%>
+	}
+
+	return ret
+}
+<% end -%>
+
+<% if action.metadata.has_global_input? -%>
+func (inv *<%= action.go_invocation_type %>) makeMetaInputParams() map[string]interface{} {
+	ret := make(map[string]interface{})
+
+	if inv.MetaInput != nil {
+<% action.metadata.global.input.parameters.each do |p| -%>
+		if inv.IsMetaParameterSelected("<%= p.go_name %>") {
+			ret["<%= p.name %>"] = inv.MetaInput.<%= p.go_name %>
+		}
+<% end -%>
+	}
+
+	return ret
+}
+<% end -%>
+<% end -%>

data/template/authentication/basic.go.erb

@@ -0,0 +1,22 @@
+package <%= package %>
+
+import (
+	"net/http"
+)
+
+type BasicAuth struct {
+	Username string
+	Password string
+}
+
+func (auth *BasicAuth) Authenticate(request *http.Request) {
+	request.SetBasicAuth(auth.Username, auth.Password)
+}
+
+// SetBasicAuthentication enables HTTP basic auth on the client
+func (client *Client) SetBasicAuthentication(username string, password string) {
+	client.Authentication = &BasicAuth{
+		Username: username,
+		Password: password,
+	}
+}

data/template/authentication/token.go.erb

@@ -0,0 +1,164 @@
+package <%= package %>
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type Mode int
+
+const (
+	// Send the token via HTTP header <%= auth.http_header %>
+	HttpHeader Mode = iota
+
+	// Send the token via query parameter <%= auth.query_parameter %>
+	QueryParameter = iota
+)
+
+type TokenAuth struct {
+	// Resource for token manipulation
+	Resource *AuthTokenResourceToken
+
+	// The authentication token
+	Token string
+
+	// Mode determines how is the authentication token sent to the API
+	Mode Mode
+}
+
+func (auth *TokenAuth) Authenticate(request *http.Request) {
+	switch auth.Mode {
+	case HttpHeader:
+		request.Header.Set("<%= auth.http_header %>", auth.Token)
+
+	case QueryParameter:
+		q := request.URL.Query()
+		q.Add("<%= auth.query_parameter %>", auth.Token)
+		request.URL.RawQuery = q.Encode()
+	}
+}
+
+type TokenAuthOptions struct {
+<% auth.request_action.input.parameters.each do |p| -%>
+	<%= p.go_name %> <%= p.go_in_type %>
+<% end -%>
+<% auth.custom_actions.each do |a| -%>
+	<%= "#{a.go_name}Callback" %> func(input *<%= a.input.go_type %>) error
+<% end -%>
+}
+
+// SetNewTokenAuth obtains a new authentication token with login credentials
+func (client *Client) SetNewTokenAuth(options *TokenAuthOptions) error {
+	resource := NewAuthTokenResourceToken(client)
+	auth := &TokenAuth{Resource: resource, Mode: HttpHeader}
+	auth.setDefaultOptions(options)
+
+	request := resource.Request.Prepare()
+	request.SetInput(&AuthTokenActionTokenRequestInput{
+<% auth.request_action.input.parameters.each do |p| -%>
+		<%= p.go_name %>: options.<%= p.go_name %>,
+<% end -%>
+	})
+
+	resp, err := request.Call()
+
+	if err != nil {
+		return err
+	} else if !resp.Status {
+		return fmt.Errorf("Unable to request token: %v", resp.Message)
+	}
+
+	if resp.Output.Complete {
+		auth.Token = resp.Output.Token
+		client.Authentication = auth
+		return nil
+	}
+
+	return auth.nextAuthenticationStep(
+		options,
+		resp.Output.NextAction,
+		resp.Output.Token,
+	);
+}
+
+func (auth *TokenAuth) setDefaultOptions(options *TokenAuthOptions) {
+	if options.Lifetime == "" {
+		options.Lifetime = "renewable_auto"
+	}
+
+	if options.Interval == 0 {
+		options.Interval = 300
+	}
+}
+
+// nextAuthenticationStep performs authentication steps recursively, until
+// the authentication is completed
+func (auth *TokenAuth) nextAuthenticationStep(options *TokenAuthOptions, action string, token string) error {
+<% auth.custom_actions.each do |a| -%>
+	if action == "<%= a.name %>" {
+		action := auth.Resource.<%= a.go_name %>.Prepare()
+		input := action.NewInput()
+		input.SetToken(token)
+
+		if options.<%= "#{a.go_name}Callback" %> == nil {
+			return fmt.Errorf("Implement callback <%= "#{a.go_name}Callback" %>")
+		}
+
+		if err := options.<%= "#{a.go_name}Callback" %>(input); err != nil {
+			return fmt.Errorf("<%= "#{a.go_name}Callback" %> failed: %v", err)
+		}
+
+		resp, err := action.Call()
+
+		if err != nil {
+			return err
+		} else if !resp.Status {
+			return fmt.Errorf("Failed at authentication step '%s': %v", action, resp.Message)
+		}
+
+		if resp.Output.Complete {
+			auth.Token = resp.Output.Token
+			auth.Resource.Client.Authentication = auth
+			return nil
+		}
+
+		return auth.nextAuthenticationStep(
+			options,
+			resp.Output.NextAction,
+			resp.Output.Token,
+		);
+	}
+<% end -%>
+
+	return fmt.Errorf("Unsupported authentication action '%s'", action)
+}
+
+// SetExistingTokenAuth will use a previously acquired token
+func (client *Client) SetExistingTokenAuth(token string) {
+	client.Authentication = &TokenAuth{
+		Resource: NewAuthTokenResourceToken(client),
+		Token: token,
+		Mode: HttpHeader,
+	}
+}
+
+// SetTokenAuthMode can be used to change the way the token is sent to the API
+func (client *Client) SetTokenAuthMode(mode Mode) {
+	client.Authentication.(*TokenAuth).Mode = mode
+}
+
+// RevokeAuthToken will revoke the authentication token and remove authentication
+// from the client
+func (client *Client) RevokeAuthToken() error {
+	revoke := client.Authentication.(*TokenAuth).Resource.Revoke.Prepare()
+	resp, err := revoke.Call()
+
+	if err != nil {
+		return err
+	} else if !resp.Status {
+		return fmt.Errorf("Unable to revoke token: %v", resp.Message)
+	}
+
+	client.Authentication = nil
+	return nil
+}

data/template/authentication.go.erb

@@ -0,0 +1,10 @@
+package <%= package %>
+
+import (
+	"net/http"
+)
+
+// Authenticator is used to provide authentication for HTTP requests
+type Authenticator interface {
+	Authenticate(request *http.Request)
+}

data/template/client.go.erb

@@ -0,0 +1,26 @@
+package <%= package %>
+
+// Client represents a connection to an API server
+type Client struct {
+	// API URL
+	Url string
+
+	// Options for authentication method
+	Authentication Authenticator
+
+<% api.resources.each do |r| -%>
+	// Resource <%= r.full_dot_name %>
+	<%= r.go_name %> *<%= r.go_type %>
+<% end -%>
+}
+
+// Create a new client for API at url
+func New(url string) *Client {
+	c := &Client{Url: url}
+
+<% api.resources.each do |r| -%>
+	c.<%= r.go_name %> = New<%= r.go_type %>(c)
+<% end -%>
+
+	return c
+}

data/template/go.mod.erb

@@ -0,0 +1 @@
+module <%= mod %>