    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.services;
    014
    015import org.apache.tapestry5.func.F;
    016import org.apache.tapestry5.internal.event.InvalidationEventHubImpl;
    017import org.apache.tapestry5.internal.util.MultiKey;
    018import org.apache.tapestry5.ioc.Messages;
    019import org.apache.tapestry5.ioc.Resource;
    020import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
    021import org.apache.tapestry5.ioc.internal.util.URLChangeTracker;
    022import org.apache.tapestry5.ioc.util.CaseInsensitiveMap;
    023import org.apache.tapestry5.services.messages.PropertiesFileParser;
    024import org.apache.tapestry5.services.pageload.ComponentResourceLocator;
    025import org.apache.tapestry5.services.pageload.ComponentResourceSelector;
    026
    027import java.util.Collections;
    028import java.util.List;
    029import java.util.Map;
    030
    031/**
    032 * A utility class that encapsulates all the logic for reading properties files and assembling {@link Messages} from
    033 * them, in accordance with extension rules and locale. This represents code that was refactored out of
    034 * {@link ComponentMessagesSourceImpl}. This class can be used as a base class, though the existing code base uses it as
    035 * a utility. Composition trumps inheritance!
    036 *
    037 * The message catalog for a component is the combination of all appropriate properties files for the component, plus
    038 * any keys inherited form base components and, ultimately, the application global message catalog. At some point we
    039 * should add support for per-library message catalogs.
    040 *
    041 * Message catalogs are read using the UTF-8 character set. This is tricky in JDK 1.5; we read the file into memory then
    042 * feed that bytestream to Properties.load().
    043 */
    044public class MessagesSourceImpl extends InvalidationEventHubImpl implements MessagesSource
    045{
    046    private final URLChangeTracker tracker;
    047
    048    private final PropertiesFileParser propertiesFileParser;
    049
    050    private final ComponentResourceLocator resourceLocator;
    051
    052    /**
    053     * Keyed on bundle id and ComponentResourceSelector.
    054     */
    055    private final Map<MultiKey, Messages> messagesByBundleIdAndSelector = CollectionFactory.newConcurrentMap();
    056
    057    /**
    058     * Keyed on bundle id and ComponentResourceSelector, the cooked properties include properties inherited from less
    059     * locale-specific properties files, or inherited from parent bundles.
    060     */
    061    private final Map<MultiKey, Map<String, String>> cookedProperties = CollectionFactory.newConcurrentMap();
    062
    063    /**
    064     * Raw properties represent just the properties read from a specific properties file, in isolation.
    065     */
    066    private final Map<Resource, Map<String, String>> rawProperties = CollectionFactory.newConcurrentMap();
    067
    068    private final Map<String, String> emptyMap = Collections.emptyMap();
    069
    070    public MessagesSourceImpl(boolean productionMode, URLChangeTracker tracker,
    071                              ComponentResourceLocator resourceLocator, PropertiesFileParser propertiesFileParser)
    072    {
    073        super(productionMode);
    074
    075        this.tracker = tracker;
    076        this.propertiesFileParser = propertiesFileParser;
    077        this.resourceLocator = resourceLocator;
    078    }
    079
    080    public void checkForUpdates()
    081    {
    082        if (tracker != null && tracker.containsChanges())
    083        {
    084            invalidate();
    085        }
    086    }
    087
    088    public void invalidate()
    089    {
    090        messagesByBundleIdAndSelector.clear();
    091        cookedProperties.clear();
    092        rawProperties.clear();
    093
    094        tracker.clear();
    095
    096        fireInvalidationEvent();
    097    }
    098
    099    public Messages getMessages(MessagesBundle bundle, ComponentResourceSelector selector)
    100    {
    101        MultiKey key = new MultiKey(bundle.getId(), selector);
    102
    103        Messages result = messagesByBundleIdAndSelector.get(key);
    104
    105        if (result == null)
    106        {
    107            result = buildMessages(bundle, selector);
    108            messagesByBundleIdAndSelector.put(key, result);
    109        }
    110
    111        return result;
    112    }
    113
    114    private Messages buildMessages(MessagesBundle bundle, ComponentResourceSelector selector)
    115    {
    116        Map<String, String> properties = findBundleProperties(bundle, selector);
    117
    118        return new MapMessages(selector.locale, properties);
    119    }
    120
    121    /**
    122     * Assembles a set of properties appropriate for the bundle in question, and the desired locale. The properties
    123     * reflect the properties of the bundles' parent (if any) for the locale, overalyed with any properties defined for
    124     * this bundle and its locale.
    125     */
    126    private Map<String, String> findBundleProperties(MessagesBundle bundle, ComponentResourceSelector selector)
    127    {
    128        if (bundle == null)
    129            return emptyMap;
    130
    131        MultiKey key = new MultiKey(bundle.getId(), selector);
    132
    133        Map<String, String> existing = cookedProperties.get(key);
    134
    135        if (existing != null)
    136            return existing;
    137
    138        // What would be cool is if we could maintain a cache of bundle id + locale -->
    139        // Resource. That would optimize quite a bit of this; may need to use an alternative to
    140        // LocalizedNameGenerator.
    141
    142        Resource propertiesResource = bundle.getBaseResource().withExtension("properties");
    143
    144        List<Resource> localizations = resourceLocator.locateMessageCatalog(propertiesResource, selector);
    145
    146        // Localizations are now in least-specific to most-specific order.
    147
    148        Map<String, String> previous = findBundleProperties(bundle.getParent(), selector);
    149
    150        for (Resource localization : F.flow(localizations).reverse())
    151        {
    152            Map<String, String> rawProperties = getRawProperties(localization);
    153
    154            // Woould be nice to write into the cookedProperties cache here,
    155            // but we can't because we don't know the selector part of the MultiKey.
    156
    157            previous = extend(previous, rawProperties);
    158        }
    159
    160        cookedProperties.put(key, previous);
    161
    162        return previous;
    163    }
    164
    165    /**
    166     * Returns a new map consisting of all the properties in previous overlayed with all the properties in
    167     * rawProperties. If rawProperties is empty, returns just the base map.
    168     */
    169    private Map<String, String> extend(Map<String, String> base, Map<String, String> rawProperties)
    170    {
    171        if (rawProperties.isEmpty())
    172            return base;
    173
    174        // Make a copy of the base Map
    175
    176        Map<String, String> result = new CaseInsensitiveMap<String>(base);
    177
    178        // Add or overwrite properties to the copy
    179
    180        result.putAll(rawProperties);
    181
    182        return result;
    183    }
    184
    185    private Map<String, String> getRawProperties(Resource localization)
    186    {
    187        Map<String, String> result = rawProperties.get(localization);
    188
    189        if (result == null)
    190        {
    191            result = readProperties(localization);
    192
    193            rawProperties.put(localization, result);
    194        }
    195
    196        return result;
    197    }
    198
    199    /**
    200     * Creates and returns a new map that contains properties read from the properties file.
    201     */
    202    private Map<String, String> readProperties(Resource resource)
    203    {
    204        if (!resource.exists())
    205            return emptyMap;
    206
    207        if (tracker != null)
    208        {
    209            tracker.add(resource.toURL());
    210        }
    211
    212        try
    213        {
    214            return propertiesFileParser.parsePropertiesFile(resource);
    215        } catch (Exception ex)
    216        {
    217            throw new RuntimeException(String.format("Unable to read message catalog from %s: %s", resource, ex), ex);
    218        }
    219    }
    220
    221}