Add Lazy function

gomponents.go

@@ -254,9 +254,47 @@ func Group(children []Node) Node {
 
 // If condition is true, return the given Node. Otherwise, return nil.
 // This helper function is good for inlining elements conditionally.
+// This doesn't behave entirely like a regular if statement, because nested Nodes and their parameters are evaluated
+// from the deepest level and up before hitting If (because that's how Go works).
+// If you need lazy evaluation of the given Node, see Lazy.
 func If(condition bool, n Node) Node {
  if condition {
  return n
  }
  return nil
 }
+
+// Lazy returns a Node which calls the given callback function only when rendered.
+// Used with If, it enables lazy evaluation of the node to return, depending on the condition passed to If.
+// It defaults to being an ElementType, but can be set to AttributeType by passing a NodeType.
+// Even though nodeType is variadic, only the first NodeType is used.
+func Lazy(cb func() Node, nodeType ...NodeType) Node {
+ if cb == nil {
+ panic("lazy callback cannot be nil")
+ }
+
+ switch len(nodeType) {
+ case 0:
+ return &lazy{CB: cb}
+ case 1:
+ return &lazy{CB: cb, T: nodeType[0]}
+ default:
+ panic("lazy only accepts one node type")
+ }
+}
+
+// Lazy is returned by Lazy.
+type lazy struct {
+ CB func() Node
+ T NodeType
+}
+
+// Render satisfies Node.
+func (l *lazy) Render(w io.Writer) error {
+ return l.CB().Render(w)
+}
+
+// Type satisfies nodeTypeDescriber.
+func (l *lazy) Type() NodeType {
+ return l.T
+}

gomponents_test.go

@@ -284,3 +284,64 @@ func ExampleIf() {
  _ = e.Render(os.Stdout)
  // Output: <div><span>You lost your hat!</span></div>
 }
+
+func TestLazy(t *testing.T) {
+ t.Run("panics when callback is nil", func(t *testing.T) {
+ defer func() {
+ if r := recover(); r == nil {
+ t.FailNow()
+ }
+ }()
+ g.Lazy(nil)
+ })
+
+ t.Run("calls callback on render", func(t *testing.T) {
+ n := g.Lazy(func() g.Node {
+ return g.El("div")
+ })
+ assert.Equal(t, "<div></div>", n)
+ })
+
+ t.Run("can render elements with node type passed", func(t *testing.T) {
+ n := g.El("div", g.Lazy(func() g.Node {
+ return g.El("span")
+ }, g.ElementType))
+ assert.Equal(t, "<div><span></span></div>", n)
+ })
+
+ t.Run("can render attributes", func(t *testing.T) {
+ n := g.El("input", g.Lazy(func() g.Node {
+ return g.Attr("disabled")
+ }, g.AttributeType))
+ assert.Equal(t, "<input disabled>", n)
+ })
+
+ t.Run("panics when passed multiple node types", func(t *testing.T) {
+ defer func() {
+ if r := recover(); r == nil {
+ t.FailNow()
+ }
+ }()
+ g.Lazy(func() g.Node {
+ return nil
+ }, g.ElementType, g.AttributeType)
+ })
+}
+
+func ExampleIf_lazy() {
+ type User struct {
+ Name string
+ }
+
+ var u *User
+
+ e := g.El("div",
+ // This would panic without the Lazy call.
+ g.If(u != nil, g.Lazy(func() g.Node {
+ return g.El("span", g.Text(u.Name))
+ })),
+ g.If(u == nil, g.El("span", g.Text("Anonymous"))),
+ )
+ _ = e.Render(os.Stdout)
+ // Output: <div><span>Anonymous</span></div>
+}