JBossDeveloper

#{sel.label} -> can be evaluated

#{sel.label} - can be evaluted because this is all happening inside ui:repeat and sel is an item from the collection returned by localeSelector.supportedLocales

I do not want sel.value evaluated on post back.

It was so long conversation... I just want to check, did I understood your problem correctly.

So, do you mean that you would like to be able to dynamically generate the contents of the "action" attribute?

So, instead of writing a lot of times:

<s:link action="#{someBean.doSomeWork('value1')}" .../>
<s:link action="#{someBean.doSomeWork('value2')} ..."/>
...
<s:link action="#{someBean.doSomeWork('valueN')} ..."/>

<cycle name="some form of cycle which iterates by all possible values like 'value1', 'value2'...">

<s:link action="#{someBean.doSomeWork(valueToEvaluate)}" .../>

</cycle>

But why should we stop on such a simple solution? Let's evolve this idea (dynamic EL construction) till the whole madness?

Why only parameter value should be dynamic? What about bean name or action name? If action value used only on invoke application phase, and on rendering phase it is converted to MethodBinding object for validation (I'm not sure it is true)?

For example:

<s:link action="#{#{beanNameToEvaluate}.#{methodNameToEvaluate}(#{valueToEvaluate)})}" .../>

<s:link dynaAction="#{beanNameToEvaluate}.#{methodNameToEvaluate}(#{valueToEvaluate)})" .../>

package org.jboss.seam.ui.tag;

import javax.el.ELContext;
import javax.el.ELException;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.component.ActionSource;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.el.MethodBinding;

@SuppressWarnings("deprecation")
public class DynaLinkTag extends LinkTag {

 private String dynaAction;

 protected void setProperties(UIComponent component) {
 super.setProperties(component);
 setDynaActionProperty(getFacesContext(), component, getDynaAction());
 }

 public static void setDynaActionProperty(FacesContext context, UIComponent component, String dynaAction) {
 if (dynaAction != null) {
 if (!(component instanceof ActionSource)) {
 throw new IllegalArgumentException("Component " + component.getClientId(context) + " is no ActionSource");
 }
 if (isValueReference(dynaAction)) {
 ValueExpression vb = component.getValueExpression(dynaAction);
 ELContext elContext = FacesContext.getCurrentInstance().getELContext();
 String actionValue = null;
 try {
 actionValue = (String) vb.getValue(elContext);
 } catch (ELException ele) {
 throw new FacesException(ele);
 }
 MethodBinding mb = context.getApplication().createMethodBinding(actionValue, null);
 ((ActionSource) component).setAction(mb);
 } else {
 component.getAttributes().put("outcome", dynaAction);
 }
 }
 }

 public String getDynaAction() {
 return this.dynaAction;
 }

 public void setDynaAction(String dynaAction) {
 this.dynaAction = dynaAction;
 }
}

yew!

Folks, you can already solve this usecase with f:param. I definitely don't prefer double-interpolation.

Do you mean:

instead of trying to do:

<s:link action="#{someBean.someMethod(someValue)}" .../>

<s:link action="#{someBean.someMethod}">
<f:param name="nameForMapping" value="#{someValue}"/>
</s:link>

<s:link dynaAction="#{'itemBrowseList'}.#{'browseAll'}">#{messages['submenu.browse.all']}</s:link>

<s:link dynaAction="itemBrowseList.browseAll">#{messages['submenu.browse.all']}</s:link>

<s:link dynaAction="#{'itemBrowseList.browseAll'}">#{messages['submenu.browse.all']}</s:link>

<s:link action="#{itemBrowseList.browseAll}">#{messages['submenu.browse.all']}</s:link>

public MethodExpression getMethodPreEvaluationExpression(FaceletContext ctx, Class type,
 Class[] paramTypes) {
 try {
 ExpressionFactory f = ctx.getExpressionFactory();

 ValueExpression valueExpression = this.getValueExpression(ctx, type);

 return new TagMethodExpression(this, f.createMethodExpression(ctx,
 "#{"+(String)valueExpression.getValue(ctx)+"}", type, paramTypes));
 } catch (Exception e) {
 throw new TagAttributeException(this, e);
 }
 }

final static class DynaActionMapper extends Metadata {

 private final TagAttribute attr;

 public DynaActionMapper(TagAttribute attr) {
 this.attr = attr;
 }

 public void applyMetadata(FaceletContext ctx, Object instance) {
 ((ActionSource) instance).setAction(new LegacyMethodBinding(
 this.attr.getMethodPreEvaluationExpression(ctx, String.class,
 ActionSourceRule.ACTION_SIG)));
 }
 }

 final static class DynaActionMapper2 extends Metadata {

 private final TagAttribute attr;

 public DynaActionMapper2(TagAttribute attr) {
 this.attr = attr;
 }

 public void applyMetadata(FaceletContext ctx, Object instance) {
 ((ActionSource2) instance).setActionExpression(this.attr
 .getMethodPreEvaluationExpression(ctx, String.class,
 ActionSourceRule.ACTION_SIG));
 }

 }

 if ("dynaAction".equals(name)) {
 if (elSupport && meta.isTargetInstanceOf(ActionSource2.class)) {
 return new DynaActionMapper2(attribute);
 } else {
 return new DynaActionMapper(attribute);
 }
 }

I'm not sure it is a problem of Seam. It is a limitation of JSF EL. You cannot construct JSF EL dynamically - that is what you would like to have. You cannot have nasted EL constructions.

I just cannot understand, how would you like to fix this limitation - it will break the logic of EL, if you can use JSF page variable to construct expression. For me the problem is in specific logic you would like to have only for action attribute - don't you want this feature for ALL EL expressions?

For example:

 <s:link value="#{curLocale.label}" action="#{localeSelector.selectLanguage(curLocale.value)}"/>

 <s:link value="#{curLocale.label}" action="#{localeSelector.selectLanguage(#{curLocale.value})}"/>