Create groups in my code?

[endigma]

Create groups in my code?

[endigma]

If Group is meant for internal use only, perhaps another type for creating snippets functionally?

[endigma]

Is this what Custom/CustomFunc is for?

[dave]

Sorry I don't understand

[endigma]

I'd like to make a function like, say:

func generateType(typespec *spec.Type) jen.Code {
    ...
}

that produces some g.Add(...)-able code to allow me to compose different functions to generate a more complex file.

currently, I'm doing it like this:

func generateType(typespec *spec.Type) jen.Code {
    g := new(jen.Group)
    g.Commentf("foo").Line()
    return g
}

but new(jen.Group) doesn't have newlines, so I have to add them manually.

I found jen.CustomFunc, and it seems to work for what I want, but I'm not sure if it's the right way to do it.

func generateType(typespec *spec.Type) jen.Code {
    return CustomFunc(Options{
	Multi: true,
    }, func(g *Group) {
	g.Comment("foo")
    })
}

Does that make sense?

[endigma]

Perhaps we could get a method like CustomGroup(options) *Group that uses the Options from Custom/CustomFunc?

func CustomGroup(options Options) *Group {
	return &Group{
		close:     options.Close,
		multi:     options.Multi,
		name:      "custom",
		open:      options.Open,
		separator: options.Separator,
	}
}

CustomFunc works but wrapping my entire function wastes an indent.

[dave]

Can't you just do this?

func generateType(typespec *spec.Type) jen.Code {
    c := jen.Commentf("foo").Line()
    return c
}

[endigma]

Yes, but my actual generators are a lot larger than that and consist of tens of different structures. Writing them all as one statement would be very unreadable. I'd essentially like a function that creates groups with options, that way I can use them as builders.

[dave]

How about returning a []jen.Code?

[dave]

Basically a Group contains extra information about the separators between items, the braces a the start and end... that sort of thing... so I don't think Group is the right this for this usage...

[endigma]

I used to use []jen.Code, but then I had to write a bunch of logic for handling newlines etc. Perhaps a new construct for this usage would be best then?

Similar to *Group in that it has helpers for append(g, ...), but with only basic options like separator to join all the items with jen.Line().

[endigma]

Or just implying it's multiline, sort of like a file.

returning []jen.Code doesn't work so well because of the way it would get added back onto the parent.

results in

so I have to write like

to interleave the newlines

[dave]

How about:

	code := []jen.Code{...}
	for _, c := range code {
		g.Add(c)
	}

[endigma]

That doesn't add newlines, and there's still no append helpers for []jen.Code though, and all the extra code does start to add up. I don't see why there shouldn't be a simpler way to achieve this pattern, using []jen.Code with a workaround here and a workaround there doesn't make so much sense if the library could include all of the boilerplate.

I'm sure I'm not the only one who will ever want to build code like this, so a type like Builder or something that wraps all of this would be good.

// update:, no it doesn't add newlines

code := []Code{Comment("1"), Comment("2"), Comment("3")}
for _, c := range code {
	g.Add(c)
}

==

// 1// 2// 3

[dave]

Where are you getting g from in that code?

[endigma]

it's a &Group, I'd have to repeatedly do the same pattern which is the "all the extra code does start to add up" I mentioned.

[dave]

This example test passes:

func ExampleFoo() {
	block := BlockFunc(func(group *Group) {
		code := []Code{Comment("1"), Comment("2"), Comment("3")}
		for _, c := range code {
			group.Add(c)
		}
	})
	fmt.Printf("%#v", block)
	// Output:
	// {
	//	// 1
	//	// 2
	//	// 3
	// }
}

[endigma]

Block has {} though, literally block without {} would be perfect. Block works because block's group is configured to put newlines inbetween entries. I would like to be able to create my own Group-like things that are also have entries separated by newlines. Exactly like Group in DX, except created in isolation.

[endigma]

CustomFunc does it, but it puts the Group it makes into a closure instead of returning it. Perhaps the group creation bit can be factored out and put in package scope?

[dave]

Yeah the solution is to use []Code, and only add to a Group when it's actually being added to code.

(BTW I'm not going to add anything to Jennifer unless there's a bug to fix... the API is far too cluttered already to add more convenience methods)