com.google.template.soy.jssrc.internal

Class GenCallCodeUtils

java.lang.Object

com.google.template.soy.jssrc.internal.GenCallCodeUtils

public class GenCallCodeUtils
extends Object

Generates JS code for {call}s and {delcall}s.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	GenCallCodeUtils(SoyJsSrcOptions options, DelTemplateNamer delTemplateNamer, IsComputableAsJsExprsVisitor isComputableAsJsExprsVisitor, GenJsExprsVisitor.GenJsExprsVisitorFactory genJsExprsVisitorFactory)

Method Summary

Modifier and Type	Method and Description
CodeChunk.WithValue	gen(CallNode callNode, TemplateAliases templateAliases, TranslationContext translationContext, ErrorReporter errorReporter) Generates the JS expression for a given call.
protected CodeChunk.WithValue	maybeWrapContent(CodeChunk.Generator generator, CallParamContentNode node, CodeChunk.WithValue content) If the param node had a content kind specified, it was autoescaped in the corresponding context.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

GenCallCodeUtils

protected GenCallCodeUtils(SoyJsSrcOptions options,
                           DelTemplateNamer delTemplateNamer,
                           IsComputableAsJsExprsVisitor isComputableAsJsExprsVisitor,
                           GenJsExprsVisitor.GenJsExprsVisitorFactory genJsExprsVisitorFactory)

Method Detail

gen

public CodeChunk.WithValue gen(CallNode callNode,
                               TemplateAliases templateAliases,
                               TranslationContext translationContext,
                               ErrorReporter errorReporter)

Generates the JS expression for a given call.

Important: If there are CallParamContentNode children whose contents are not computable as JS expressions, then this function assumes that, elsewhere, code has been generated to define their respective 'param<n>' temporary variables.

Here are five example calls:

   {call some.func data="all" /}
   {call some.func data="$boo.foo" /}
   {call some.func}
     {param goo = $moo /}
   {/call}
   {call some.func data="$boo"}
     {param goo}Blah{/param}
   {/call}
   {call some.func}
     {param goo}
       {for $i in range(3)}{$i}{/for}
     {/param}
   {/call}
 

Their respective generated calls might be the following:

   some.func(opt_data)
   some.func(opt_data.boo.foo)
   some.func({goo: opt_data.moo})
   some.func(soy.$$assignDefaults({goo: 'Blah'}, opt_data.boo))
   some.func({goo: param65})
 

Note that in the last case, the param content is not computable as JS expressions, so we assume that code has been generated to define the temporary variable 'param<n>'.

Parameters:

callNode - The call to generate code for.

templateAliases - A mapping of fully qualified calls to a variable in scope.

Returns:

The JS expression for the call.

maybeWrapContent

protected CodeChunk.WithValue maybeWrapContent(CodeChunk.Generator generator,
                                               CallParamContentNode node,
                                               CodeChunk.WithValue content)

If the param node had a content kind specified, it was autoescaped in the corresponding context. Hence the result of evaluating the param block is wrapped in a SanitizedContent instance of the appropriate kind.

The expression for the constructor of SanitizedContent of the appropriate kind (e.g., "new SanitizedHtml"), or null if the node has no 'kind' attribute. This uses the variant used in internal blocks.