    001// Licensed under the Apache License, Version 2.0 (the "License");
    002// you may not use this file except in compliance with the License.
    003// You may obtain a copy of the License at
    004//
    005// http://www.apache.org/licenses/LICENSE-2.0
    006//
    007// Unless required by applicable law or agreed to in writing, software
    008// distributed under the License is distributed on an "AS IS" BASIS,
    009// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    010// See the License for the specific language governing permissions and
    011// limitations under the License.
    012
    013package org.apache.tapestry5.internal.pageload;
    014
    015import org.apache.tapestry5.internal.TapestryInternalUtils;
    016import org.apache.tapestry5.internal.services.ComponentInstantiatorSource;
    017import org.apache.tapestry5.internal.services.Instantiator;
    018import org.apache.tapestry5.internal.structure.ComponentPageElement;
    019import org.apache.tapestry5.ioc.Location;
    020import org.apache.tapestry5.ioc.Orderable;
    021import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
    022import org.apache.tapestry5.ioc.internal.util.InternalUtils;
    023import org.apache.tapestry5.ioc.internal.util.TapestryException;
    024import org.apache.tapestry5.model.ComponentModel;
    025import org.apache.tapestry5.model.EmbeddedComponentModel;
    026import org.apache.tapestry5.services.ComponentClassResolver;
    027import org.apache.tapestry5.services.pageload.ComponentResourceSelector;
    028
    029import java.util.HashSet;
    030import java.util.Map;
    031import java.util.Set;
    032
    033public class EmbeddedComponentAssemblerImpl implements EmbeddedComponentAssembler
    034{
    035    private final ComponentInstantiatorSource instantiatorSource;
    036
    037    private final ComponentAssemblerSource assemblerSource;
    038
    039    private final ComponentResourceSelector selector;
    040
    041    private final ComponentModel componentModel;
    042
    043    private final Location location;
    044
    045    private final Map<String, Instantiator> mixinIdToInstantiator = CollectionFactory.newCaseInsensitiveMap();
    046
    047    private final Map<String, String[]> mixinsIdToOrderConstraints = CollectionFactory.newCaseInsensitiveMap();
    048
    049    /**
    050     * Maps parameter names (both simple, and qualified with the mixin id) to the corresponding QualifiedParameterName.
    051     */
    052    private final Map<String, ParameterBinder> parameterNameToBinder = CollectionFactory.newCaseInsensitiveMap();
    053
    054    // The id of the mixin to receive informal parameters. If null, the component itself recieves them.
    055    // If the component doesn't support them, they are quietly dropped.
    056
    057    private final String informalParametersMixinId;
    058
    059    private final String componentPsuedoMixinId;
    060
    061    private Map<String, Boolean> bound;
    062
    063    /**
    064     * @param assemblerSource
    065     * @param instantiatorSource
    066     *         used to access component models
    067     * @param componentClassResolver
    068     *         used to convert mixin types to component models
    069     * @param componentClassName
    070     *         class name of embedded component
    071     * @param selector
    072     *         used to select template and other resources
    073     * @param embeddedModel
    074     *         embedded model (may be null for components defined in the template)
    075     * @param templateMixins
    076     *         list of mixins from the t:mixins element (possibly null)
    077     * @param location
    078     *         location of components element in its container's template
    079     * @param strictMixinParameters
    080     *         if true (e.g., the 5.4 DTD) then mixin parameters must be fully qualified
    081     */
    082    public EmbeddedComponentAssemblerImpl(ComponentAssemblerSource assemblerSource,
    083                                          ComponentInstantiatorSource instantiatorSource, ComponentClassResolver componentClassResolver,
    084                                          String componentClassName, ComponentResourceSelector selector, EmbeddedComponentModel embeddedModel,
    085                                          String templateMixins, Location location, boolean strictMixinParameters)
    086    {
    087        this.assemblerSource = assemblerSource;
    088        this.instantiatorSource = instantiatorSource;
    089        this.selector = selector;
    090        this.location = location;
    091
    092        componentModel = getModel(componentClassName);
    093
    094        // Add the implementation mixins defined by the component model.
    095
    096        for (String className : componentModel.getMixinClassNames())
    097        {
    098            addMixin(className, componentModel.getOrderForMixin(className));
    099        }
    100
    101        // If there's an embedded model (i.e., there was an @Component annotation)
    102        // then it may define some mixins.
    103
    104        if (embeddedModel != null)
    105        {
    106            for (String className : embeddedModel.getMixinClassNames())
    107            {
    108                addMixin(className, embeddedModel.getConstraintsForMixin(className));
    109            }
    110        }
    111
    112        // And the template may include a t:mixins element to define yet more mixins.
    113        // Template strings specified as:
    114        for (String mixinDef : TapestryInternalUtils.splitAtCommas(templateMixins))
    115        {
    116            Orderable<String> order = TapestryInternalUtils.mixinTypeAndOrder(mixinDef);
    117            String className = componentClassResolver.resolveMixinTypeToClassName(order.getId());
    118
    119            addMixin(className, order.getConstraints());
    120        }
    121
    122        // Finally (new in 5.3, for TAP5-1680), the component itself can sometimes acts as a mixin;
    123        // this allows for dealing with parameter name conflicts between the component and the mixin
    124        // (especially where informal parameters are involved).
    125
    126        componentPsuedoMixinId = InternalUtils.lastTerm(componentClassName);
    127
    128        // A bit ugly ... side-effects PLUS a return value ... but that's final variables
    129        // for you.
    130        informalParametersMixinId = prescanMixins(strictMixinParameters);
    131    }
    132
    133    private String prescanMixins(boolean strictMixinParameters)
    134    {
    135        // Mixin id found to support informal parameters
    136
    137        String supportsInformals = null;
    138
    139        for (Map.Entry<String, Instantiator> entry : mixinIdToInstantiator.entrySet())
    140        {
    141            String mixinId = entry.getKey();
    142            ComponentModel mixinModel = entry.getValue().getModel();
    143
    144            updateParameterNameToQualified(mixinId, mixinModel, strictMixinParameters);
    145
    146            if (supportsInformals == null && mixinModel.getSupportsInformalParameters())
    147                supportsInformals = mixinId;
    148        }
    149
    150        // The component comes last and overwrites simple names from the others.
    151
    152        updateParameterNameToQualified(null, componentModel, false);
    153
    154        return supportsInformals;
    155    }
    156
    157    private void updateParameterNameToQualified(String mixinId, ComponentModel model, boolean strictMixinParameters)
    158    {
    159        for (String parameterName : model.getParameterNames())
    160        {
    161            String defaultBindingPrefix = model.getParameterModel(parameterName).getDefaultBindingPrefix();
    162
    163            ParameterBinderImpl binder = new ParameterBinderImpl(mixinId, parameterName, defaultBindingPrefix);
    164
    165            if (mixinId == null)
    166            {
    167                // This is a formal parameter of the root component so it's always unqualified.
    168                parameterNameToBinder.put(parameterName, binder);
    169            } else
    170            {
    171                // This is a formal parameter of a mixin, it must be qualified.
    172                parameterNameToBinder.put(mixinId + "." + parameterName, binder);
    173
    174                // When not strict (the older DTDs, before 5.4), then register an unqualified alias.
    175                if (!strictMixinParameters)
    176                {
    177                    parameterNameToBinder.put(parameterName, binder);
    178                }
    179            }
    180        }
    181    }
    182
    183    private void addMixin(String className, String... order)
    184    {
    185        Instantiator mixinInstantiator = instantiatorSource.getInstantiator(className);
    186
    187        String mixinId = InternalUtils.lastTerm(className);
    188
    189        if (mixinIdToInstantiator.containsKey(mixinId))
    190            throw new TapestryException(String.format("Mixins applied to a component must be unique. Mixin '%s' has already been applied.", mixinId), location, null);
    191
    192        mixinIdToInstantiator.put(mixinId, mixinInstantiator);
    193        mixinsIdToOrderConstraints.put(mixinId, order);
    194    }
    195
    196    private ComponentModel getModel(String className)
    197    {
    198        return instantiatorSource.getInstantiator(className).getModel();
    199    }
    200
    201    public ComponentAssembler getComponentAssembler()
    202    {
    203        return assemblerSource.getAssembler(componentModel.getComponentClassName(), selector);
    204    }
    205
    206
    207    public ParameterBinder createParameterBinder(String qualifiedParameterName)
    208    {
    209        int dotx = qualifiedParameterName.indexOf('.');
    210
    211        if (dotx < 0)
    212        {
    213            return createParameterBinderFromSimpleParameterName(qualifiedParameterName);
    214        }
    215
    216        return createParameterBinderFromQualifiedParameterName(qualifiedParameterName, qualifiedParameterName.substring(0, dotx),
    217                qualifiedParameterName.substring(dotx + 1));
    218    }
    219
    220    private ParameterBinder createParameterBinderFromSimpleParameterName(String parameterName)
    221    {
    222
    223        // Look for a *formal* parameter with the simple name on the component itself.
    224
    225        ParameterBinder binder = getComponentAssembler().getBinder(parameterName);
    226
    227        if (binder != null)
    228        {
    229            return binder;
    230        }
    231
    232        // Next see if any mixin has a formal parameter with this simple name.
    233
    234        binder = parameterNameToBinder.get(parameterName);
    235
    236        if (binder != null)
    237        {
    238            return binder;
    239        }
    240
    241
    242        // So, is there an mixin that's claiming all informal parameters?
    243
    244        if (informalParametersMixinId != null)
    245        {
    246            return new ParameterBinderImpl(informalParametersMixinId, parameterName, null);
    247        }
    248
    249        // Maybe the component claims informal parameters?
    250        if (componentModel.getSupportsInformalParameters())
    251            return new ParameterBinderImpl(null, parameterName, null);
    252
    253        // Otherwise, informal parameter are not supported by the component or any mixin.
    254
    255        return null;
    256    }
    257
    258    private ParameterBinder createParameterBinderFromQualifiedParameterName(String qualifiedParameterName, String mixinId, String parameterName)
    259    {
    260
    261        if (mixinId.equalsIgnoreCase(componentPsuedoMixinId))
    262        {
    263            return createParameterBinderForComponent(qualifiedParameterName, parameterName);
    264        }
    265
    266        if (!mixinIdToInstantiator.containsKey(mixinId))
    267        {
    268            throw new TapestryException(
    269                    String.format("Mixin id for parameter '%s' not found. Attached mixins: %s.", qualifiedParameterName,
    270                            InternalUtils.joinSorted(mixinIdToInstantiator.keySet())), location,
    271                    null);
    272        }
    273
    274        ParameterBinder binder = parameterNameToBinder.get(qualifiedParameterName);
    275
    276        if (binder != null)
    277        {
    278            return binder;
    279        }
    280
    281        // Ok, so perhaps this is a qualified name for an informal parameter of the mixin.
    282
    283        Instantiator instantiator = mixinIdToInstantiator.get(mixinId);
    284
    285        assert instantiator != null;
    286
    287        return bindInformalParameter(qualifiedParameterName, mixinId, parameterName, instantiator.getModel());
    288    }
    289
    290    private ParameterBinder bindInformalParameter(String qualifiedParameterName, String mixinId, String parameterName, ComponentModel model)
    291    {
    292        if (model.getSupportsInformalParameters())
    293        {
    294            return new ParameterBinderImpl(mixinId, parameterName, null);
    295        }
    296
    297        // Pretty sure this was not caught as an error in 5.2.
    298
    299        throw new TapestryException(String.format("Binding parameter %s as an informal parameter does not make sense, as %s does not support informal parameters.",
    300                qualifiedParameterName, model.getComponentClassName()), location, null);
    301    }
    302
    303    private ParameterBinder createParameterBinderForComponent(String qualifiedParameterName, String parameterName)
    304    {
    305        ParameterBinder binder = getComponentAssembler().getBinder(parameterName);
    306
    307        if (binder != null)
    308        {
    309            return binder;
    310        }
    311
    312        return bindInformalParameter(qualifiedParameterName, null, parameterName, componentModel);
    313    }
    314
    315
    316    public boolean isBound(String parameterName)
    317    {
    318        return InternalUtils.get(bound, parameterName) != null;
    319    }
    320
    321    public void setBound(String parameterName)
    322    {
    323        if (bound == null)
    324            bound = CollectionFactory.newCaseInsensitiveMap();
    325
    326        bound.put(parameterName, true);
    327    }
    328
    329    public int addMixinsToElement(ComponentPageElement newElement)
    330    {
    331        for (Map.Entry<String, Instantiator> entry : mixinIdToInstantiator.entrySet())
    332        {
    333            String mixinId = entry.getKey();
    334            Instantiator instantiator = entry.getValue();
    335
    336            newElement.addMixin(mixinId, instantiator, mixinsIdToOrderConstraints.get(mixinId));
    337        }
    338
    339        return mixinIdToInstantiator.size();
    340    }
    341
    342    public Location getLocation()
    343    {
    344        return location;
    345    }
    346
    347    public Set<String> getFormalParameterNames()
    348    {
    349        return new HashSet<String>(componentModel.getParameterNames());
    350    }
    351}