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