001// Copyright 2006, 2007, 2008, 2009, 2011 The Apache Software Foundation
002//
003// Licensed under the Apache License, Version 2.0 (the "License");
004// you may not use this file except in compliance with the License.
005// You may obtain a copy of the License at
006//
007//     http://www.apache.org/licenses/LICENSE-2.0
008//
009// Unless required by applicable law or agreed to in writing, software
010// distributed under the License is distributed on an "AS IS" BASIS,
011// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
012// See the License for the specific language governing permissions and
013// limitations under the License.
014
015package org.apache.tapestry5.internal.services;
016
017import org.apache.tapestry5.Binding;
018import org.apache.tapestry5.BindingConstants;
019import org.apache.tapestry5.ComponentResources;
020import org.apache.tapestry5.MarkupWriter;
021import org.apache.tapestry5.internal.InternalConstants;
022import org.apache.tapestry5.internal.parser.AttributeToken;
023import org.apache.tapestry5.internal.parser.ExpansionToken;
024import org.apache.tapestry5.internal.structure.ExpansionPageElement;
025import org.apache.tapestry5.ioc.Location;
026import org.apache.tapestry5.ioc.internal.util.TapestryException;
027import org.apache.tapestry5.ioc.services.TypeCoercer;
028import org.apache.tapestry5.runtime.RenderCommand;
029import org.apache.tapestry5.runtime.RenderQueue;
030import org.apache.tapestry5.services.BindingSource;
031
032import java.util.List;
033
034import static org.apache.tapestry5.ioc.internal.util.CollectionFactory.newList;
035
036public class PageElementFactoryImpl implements PageElementFactory
037{
038    private final TypeCoercer typeCoercer;
039
040    private final BindingSource bindingSource;
041
042    private static class LiteralStringProvider implements StringProvider
043    {
044        private final String string;
045
046        LiteralStringProvider(String string)
047        {
048            this.string = string;
049        }
050
051        public String provideString()
052        {
053            return string;
054        }
055    }
056
057    public PageElementFactoryImpl(TypeCoercer typeCoercer, BindingSource bindingSource)
058    {
059        this.typeCoercer = typeCoercer;
060        this.bindingSource = bindingSource;
061    }
062
063    public RenderCommand newAttributeElement(ComponentResources componentResources, final AttributeToken token)
064    {
065        final StringProvider provider = parseAttributeExpansionExpression(token.value, componentResources,
066                token.getLocation());
067
068        return new RenderCommand()
069        {
070            public void render(MarkupWriter writer, RenderQueue queue)
071            {
072                writer.attributeNS(token.namespaceURI, token.name, provider.provideString());
073            }
074
075            public String toString()
076            {
077                return String.format("AttributeNS[%s %s \"%s\"]", token.namespaceURI, token.name, token.value);
078            }
079        };
080    }
081
082    private StringProvider parseAttributeExpansionExpression(String expression, ComponentResources resources,
083                                                             final Location location)
084    {
085        final List<StringProvider> providers = newList();
086
087        int startx = 0;
088
089        while (true)
090        {
091            int expansionx = expression.indexOf(InternalConstants.EXPANSION_START, startx);
092
093            // No more expansions, add in the rest of the string as a literal.
094
095            if (expansionx < 0)
096            {
097                if (startx < expression.length())
098                    providers.add(new LiteralStringProvider(expression.substring(startx)));
099                break;
100            }
101
102            // Add in a literal string chunk for the characters between the last expansion and
103            // this expansion.
104
105            if (startx != expansionx)
106                providers.add(new LiteralStringProvider(expression.substring(startx, expansionx)));
107
108            int endx = expression.indexOf("}", expansionx);
109
110            if (endx < 0) throw new TapestryException(String.format("Attribute expression '%s' is missing a closing brace.", expression), location, null);
111
112            String expansion = expression.substring(expansionx + 2, endx);
113
114            final Binding binding = bindingSource.newBinding("attribute expansion", resources, resources,
115                    BindingConstants.PROP, expansion, location);
116
117            final StringProvider provider = new StringProvider()
118            {
119                public String provideString()
120                {
121                    try
122                    {
123                        Object raw = binding.get();
124
125                        return typeCoercer.coerce(raw, String.class);
126                    } catch (Exception ex)
127                    {
128                        throw new TapestryException(ex.getMessage(), location, ex);
129                    }
130                }
131            };
132
133            providers.add(provider);
134
135            // Restart the search after '}'
136
137            startx = endx + 1;
138        }
139
140        // Simplify the typical case, where the entire attribute is just a single expansion:
141
142        if (providers.size() == 1) return providers.get(0);
143
144        return new StringProvider()
145        {
146
147            public String provideString()
148            {
149                StringBuilder builder = new StringBuilder();
150
151                for (StringProvider provider : providers)
152                    builder.append(provider.provideString());
153
154                return builder.toString();
155            }
156        };
157    }
158
159    public RenderCommand newExpansionElement(ComponentResources componentResources, ExpansionToken token)
160    {
161        Binding binding = bindingSource.newBinding("expansion", componentResources, componentResources,
162                BindingConstants.PROP, token.getExpression(), token.getLocation());
163
164        return new ExpansionPageElement(binding, typeCoercer);
165    }
166
167    public Binding newBinding(String parameterName, ComponentResources loadingComponentResources,
168                              ComponentResources embeddedComponentResources, String defaultBindingPrefix,
169                              String expression, Location location)
170    {
171
172        if (expression.contains(InternalConstants.EXPANSION_START))
173        {
174            StringProvider provider = parseAttributeExpansionExpression(expression, loadingComponentResources,
175                    location);
176
177            return new AttributeExpansionBinding(location, provider);
178        }
179
180        return bindingSource.newBinding(parameterName, loadingComponentResources,
181                embeddedComponentResources, defaultBindingPrefix, expression, location);
182    }
183}