001// Copyright 2006, 2007 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.ioc.internal.services;
016
017import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
018import org.apache.tapestry5.ioc.services.SymbolProvider;
019import org.apache.tapestry5.ioc.services.SymbolSource;
020
021import java.util.LinkedList;
022import java.util.List;
023import java.util.Map;
024
025import static org.apache.tapestry5.ioc.internal.util.CollectionFactory.newLinkedList;
026
027public class SymbolSourceImpl implements SymbolSource
028{
029    private final List<SymbolProvider> providers;
030
031    /**
032     * Cache of symbol name to fully expanded symbol value.
033     */
034    private final Map<String, String> cache = CollectionFactory.newConcurrentMap();
035
036    /**
037     * Contains execution data needed when performing an expansion (largely, to check for endless recursion).
038     */
039    private class SymbolExpansion
040    {
041        private final LinkedList<String> expandingSymbols = newLinkedList();
042
043        String expandSymbols(String input)
044        {
045            StringBuilder builder = null;
046
047            int startx = 0;
048
049            while (true)
050            {
051                int symbolx = input.indexOf("${", startx);
052
053                // Special case: if the string contains no symbols then return it as is.
054
055                if (startx == 0 && symbolx < 0) return input;
056
057                // The string has at least one symbol, so its OK to create the StringBuilder
058
059                if (builder == null) builder = new StringBuilder();
060
061                // No more symbols found, so add in the rest of the string.
062
063                if (symbolx < 0)
064                {
065                    builder.append(input.substring(startx));
066                    break;
067                }
068
069                builder.append(input.substring(startx, symbolx));
070
071                int endx = input.indexOf("}", symbolx);
072
073                if (endx < 0)
074                {
075                    String message = expandingSymbols.isEmpty()
076                            ? String.format("Input string '%s' is missing a symbol closing brace.", input)
077                            : String.format("Input string '%s' is missing a symbol closing brace (in %s).", input, path());
078
079                    throw new RuntimeException(message);
080                }
081
082                String symbolName = input.substring(symbolx + 2, endx);
083
084                builder.append(valueForSymbol(symbolName));
085
086                // Restart the search after the '}'
087
088                startx = endx + 1;
089            }
090
091            return builder.toString();
092        }
093
094        String valueForSymbol(String symbolName)
095        {
096            String value = cache.get(symbolName);
097
098            if (value == null)
099            {
100                value = expandSymbol(symbolName);
101
102                cache.put(symbolName, value);
103            }
104
105            return value;
106        }
107
108        String expandSymbol(String symbolName)
109        {
110            if (expandingSymbols.contains(symbolName))
111            {
112                expandingSymbols.add(symbolName);
113                throw new RuntimeException(String.format("Symbol '%s' is defined in terms of itself (%s).",
114                        symbolName,
115                        pathFrom(symbolName)));
116            }
117
118            expandingSymbols.addLast(symbolName);
119
120            String value = null;
121
122            for (SymbolProvider provider : providers)
123            {
124                value = provider.valueForSymbol(symbolName);
125
126                if (value != null) break;
127            }
128
129            if (value == null)
130            {
131
132                String message = expandingSymbols.size() == 1
133                        ? String.format("Symbol '%s' is not defined.", symbolName)
134                        : String.format("Symbol '%s' is not defined (in %s).", symbolName, path());
135
136                throw new RuntimeException(message);
137            }
138
139            // The value may have symbols that need expansion.
140
141            String result = expandSymbols(value);
142
143            // And we're done expanding this symbol
144
145            expandingSymbols.removeLast();
146
147            return result;
148
149        }
150
151        String path()
152        {
153            StringBuilder builder = new StringBuilder();
154
155            boolean first = true;
156
157            for (String symbolName : expandingSymbols)
158            {
159                if (!first) builder.append(" --> ");
160
161                builder.append(symbolName);
162
163                first = false;
164            }
165
166            return builder.toString();
167        }
168
169        String pathFrom(String startSymbolName)
170        {
171            StringBuilder builder = new StringBuilder();
172
173            boolean first = true;
174            boolean match = false;
175
176            for (String symbolName : expandingSymbols)
177            {
178                if (!match)
179                {
180                    if (symbolName.equals(startSymbolName))
181                        match = true;
182                    else
183                        continue;
184                }
185
186                if (!first) builder.append(" --> ");
187
188                builder.append(symbolName);
189
190                first = false;
191            }
192
193            return builder.toString();
194        }
195    }
196
197    public SymbolSourceImpl(final List<SymbolProvider> providers)
198    {
199        this.providers = providers;
200    }
201
202    @Override
203    public String expandSymbols(String input)
204    {
205        return new SymbolExpansion().expandSymbols(input);
206    }
207
208    @Override
209    public String valueForSymbol(String symbolName)
210    {
211        String value = cache.get(symbolName);
212
213        // If already in the cache, then return it. Otherwise, let the SE find the value and
214        // update the cache.
215
216        return value != null ? value : new SymbolExpansion().valueForSymbol(symbolName);
217    }
218
219}