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.SymbolConstants;
016import org.apache.tapestry5.func.F;
017import org.apache.tapestry5.internal.InternalConstants;
018import org.apache.tapestry5.ioc.annotations.Symbol;
019import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
020import org.apache.tapestry5.ioc.internal.util.InternalUtils;
021import org.apache.tapestry5.ioc.services.ClassNameLocator;
022import org.apache.tapestry5.ioc.util.AvailableValues;
023import org.apache.tapestry5.ioc.util.UnknownValueException;
024import org.apache.tapestry5.services.ComponentClassResolver;
025import org.apache.tapestry5.services.InvalidationListener;
026import org.apache.tapestry5.services.LibraryMapping;
027import org.apache.tapestry5.services.transform.ControlledPackageType;
028import org.slf4j.Logger;
029
030import java.util.*;
031import java.util.regex.Pattern;
032
033public class ComponentClassResolverImpl implements ComponentClassResolver, InvalidationListener
034{
035    private static final String CORE_LIBRARY_PREFIX = "core/";
036
037    private static final Pattern SPLIT_PACKAGE_PATTERN = Pattern.compile("\\.");
038
039    private static final Pattern SPLIT_FOLDER_PATTERN = Pattern.compile("/");
040
041    private static final int LOGICAL_NAME_BUFFER_SIZE = 40;
042
043    private final Logger logger;
044
045    private final ClassNameLocator classNameLocator;
046
047    private final String startPageName;
048
049    // Map from library name to a list of root package names (usuallly just one).
050    private final Map<String, List<String>> libraryNameToPackageNames = CollectionFactory.newCaseInsensitiveMap();
051
052    private final Map<String, ControlledPackageType> packageNameToType = CollectionFactory.newMap();
053
054    /**
055     * Maps from a root package name to a component library name, including the empty string as the
056     * library name of the application.
057     */
058    private final Map<String, String> packageNameToLibraryName = CollectionFactory.newMap();
059
060    // Flag indicating that the maps have been cleared following an invalidation
061    // and need to be rebuilt. The flag and the four maps below are not synchronized
062    // because they are only modified inside a synchronized block. That should be strong enough ...
063    // and changes made will become "visible" at the end of the synchronized block. Because of the
064    // structure of Tapestry, there should not be any reader threads while the write thread
065    // is operating.
066
067    private volatile boolean needsRebuild = true;
068
069    private final Collection<LibraryMapping> libraryMappings;
070
071    private final Pattern endsWithPagePattern = Pattern.compile(".*/?\\w+page$", Pattern.CASE_INSENSITIVE);
072
073    private boolean endsWithPage(String name)
074    {
075        // Don't treat a name that's just "page" as a suffix to strip off.
076
077        return endsWithPagePattern.matcher(name).matches();
078    }
079
080    private class Data
081    {
082
083        /**
084         * Logical page name to class name.
085         */
086        private final Map<String, String> pageToClassName = CollectionFactory.newCaseInsensitiveMap();
087
088        /**
089         * Component type to class name.
090         */
091        private final Map<String, String> componentToClassName = CollectionFactory.newCaseInsensitiveMap();
092
093        /**
094         * Mixing type to class name.
095         */
096        private final Map<String, String> mixinToClassName = CollectionFactory.newCaseInsensitiveMap();
097
098        /**
099         * Page class name to logical name (needed to build URLs). This one is case sensitive, since class names do always
100         * have a particular case.
101         */
102        private final Map<String, String> pageClassNameToLogicalName = CollectionFactory.newMap();
103
104        /**
105         * Used to convert a logical page name to the canonical form of the page name; this ensures that uniform case for
106         * page names is used.
107         */
108        private final Map<String, String> pageNameToCanonicalPageName = CollectionFactory.newCaseInsensitiveMap();
109
110
111        /**
112         * These are used to check for name overlaps: a single name (generated by different paths) that maps to more than one class.
113         */
114        private Map<String, Set<String>> pageToClassNames = CollectionFactory.newCaseInsensitiveMap();
115
116        private Map<String, Set<String>> componentToClassNames = CollectionFactory.newCaseInsensitiveMap();
117
118        private Map<String, Set<String>> mixinToClassNames = CollectionFactory.newCaseInsensitiveMap();
119
120        private boolean invalid = false;
121
122        private void rebuild(String pathPrefix, String rootPackage)
123        {
124            fill(pathPrefix, rootPackage, InternalConstants.PAGES_SUBPACKAGE, pageToClassName, pageToClassNames);
125            fill(pathPrefix, rootPackage, InternalConstants.COMPONENTS_SUBPACKAGE, componentToClassName, componentToClassNames);
126            fill(pathPrefix, rootPackage, InternalConstants.MIXINS_SUBPACKAGE, mixinToClassName, mixinToClassNames);
127        }
128
129        private void fill(String pathPrefix, String rootPackage, String subPackage,
130                          Map<String, String> logicalNameToClassName,
131                          Map<String, Set<String>> nameToClassNames)
132        {
133            String searchPackage = rootPackage + "." + subPackage;
134            boolean isPage = subPackage.equals(InternalConstants.PAGES_SUBPACKAGE);
135
136            Collection<String> classNames = classNameLocator.locateClassNames(searchPackage);
137
138            Set<String> aliases = CollectionFactory.newSet();
139
140            int startPos = searchPackage.length() + 1;
141
142            for (String className : classNames)
143            {
144                aliases.clear();
145
146                String logicalName = toLogicalName(className, pathPrefix, startPos, true);
147                String unstrippedName = toLogicalName(className, pathPrefix, startPos, false);
148
149                aliases.add(logicalName);
150                aliases.add(unstrippedName);
151
152                if (isPage)
153                {
154                    if (endsWithPage(logicalName))
155                    {
156                        logicalName = logicalName.substring(0, logicalName.length() - 4);
157                        aliases.add(logicalName);
158                    }
159
160                    int lastSlashx = logicalName.lastIndexOf("/");
161
162                    String lastTerm = lastSlashx < 0 ? logicalName : logicalName.substring(lastSlashx + 1);
163
164                    if (lastTerm.equalsIgnoreCase("index"))
165                    {
166                        String reducedName = lastSlashx < 0 ? "" : logicalName.substring(0, lastSlashx);
167
168                        // Make the super-stripped name another alias to the class.
169                        // TAP5-1444: Everything else but a start page has precedence
170
171
172                        aliases.add(reducedName);
173                    }
174
175                    if (logicalName.equals(startPageName))
176                    {
177                        aliases.add("");
178                    }
179
180                    pageClassNameToLogicalName.put(className, logicalName);
181                }
182
183                for (String alias : aliases)
184                {
185                    logicalNameToClassName.put(alias, className);
186                    addNameMapping(nameToClassNames, alias, className);
187
188                    if (isPage)
189                    {
190                        pageNameToCanonicalPageName.put(alias, logicalName);
191                    }
192                }
193            }
194        }
195
196        /**
197         * Converts a fully qualified class name to a logical name
198         *
199         * @param className
200         *         fully qualified class name
201         * @param pathPrefix
202         *         prefix to be placed on the logical name (to identify the library from in which the class
203         *         lives)
204         * @param startPos
205         *         start position within the class name to extract the logical name (i.e., after the final '.' in
206         *         "rootpackage.pages.").
207         * @param stripTerms
208         * @return a short logical name in folder format ('.' replaced with '/')
209         */
210        private String toLogicalName(String className, String pathPrefix, int startPos, boolean stripTerms)
211        {
212            List<String> terms = CollectionFactory.newList();
213
214            addAll(terms, SPLIT_FOLDER_PATTERN, pathPrefix);
215
216            addAll(terms, SPLIT_PACKAGE_PATTERN, className.substring(startPos));
217
218            StringBuilder builder = new StringBuilder(LOGICAL_NAME_BUFFER_SIZE);
219            String sep = "";
220
221            String logicalName = terms.remove(terms.size() - 1);
222
223            String unstripped = logicalName;
224
225            for (String term : terms)
226            {
227                builder.append(sep);
228                builder.append(term);
229
230                sep = "/";
231
232                if (stripTerms)
233                {
234                    logicalName = stripTerm(term, logicalName);
235                }
236            }
237
238            if (logicalName.equals(""))
239            {
240                logicalName = unstripped;
241            }
242
243            builder.append(sep);
244            builder.append(logicalName);
245
246            return builder.toString();
247        }
248
249        private void addAll(List<String> terms, Pattern splitter, String input)
250        {
251            for (String term : splitter.split(input))
252            {
253                if (term.equals(""))
254                    continue;
255
256                terms.add(term);
257            }
258        }
259
260        private String stripTerm(String term, String logicalName)
261        {
262            if (isCaselessPrefix(term, logicalName))
263            {
264                logicalName = logicalName.substring(term.length());
265            }
266
267            if (isCaselessSuffix(term, logicalName))
268            {
269                logicalName = logicalName.substring(0, logicalName.length() - term.length());
270            }
271
272            return logicalName;
273        }
274
275        private boolean isCaselessPrefix(String prefix, String string)
276        {
277            return string.regionMatches(true, 0, prefix, 0, prefix.length());
278        }
279
280        private boolean isCaselessSuffix(String suffix, String string)
281        {
282            return string.regionMatches(true, string.length() - suffix.length(), suffix, 0, suffix.length());
283        }
284
285        private void addNameMapping(Map<String, Set<String>> map, String name, String className)
286        {
287            Set<String> classNames = map.get(name);
288
289            if (classNames == null)
290            {
291                classNames = CollectionFactory.newSet();
292                map.put(name, classNames);
293            }
294
295            classNames.add(className);
296        }
297
298        private void validate()
299        {
300            validate("page name", pageToClassNames);
301            validate("component type", componentToClassNames);
302            validate("mixin type", mixinToClassNames);
303
304            // No longer needed after validation.
305            pageToClassNames = null;
306            componentToClassNames = null;
307            mixinToClassNames = null;
308
309            if (invalid)
310            {
311                throw new IllegalStateException("You must correct these validation issues to proceed.");
312            }
313        }
314
315        private void validate(String category, Map<String, Set<String>> map)
316        {
317            boolean header = false;
318
319            for (String name : F.flow(map.keySet()).sort())
320            {
321                Set<String> classNames = map.get(name);
322
323                if (classNames.size() == 1)
324                {
325                    continue;
326                }
327
328                if (!header)
329                {
330                    logger.error(String.format("Some %s(s) map to more than one Java class.", category));
331                    header = true;
332                    invalid = true;
333                }
334
335                logger.error(String.format("%s '%s' maps to %s",
336                        InternalUtils.capitalize(category),
337                        name,
338                        InternalUtils.joinSorted(classNames)));
339            }
340        }
341    }
342
343    private volatile Data data = new Data();
344
345    public ComponentClassResolverImpl(Logger logger,
346
347                                      ClassNameLocator classNameLocator,
348
349                                      @Symbol(SymbolConstants.START_PAGE_NAME)
350                                      String startPageName,
351
352                                      Collection<LibraryMapping> mappings)
353    {
354        this.logger = logger;
355        this.classNameLocator = classNameLocator;
356
357        this.startPageName = startPageName;
358        this.libraryMappings = Collections.unmodifiableCollection(mappings);
359
360        for (LibraryMapping mapping : mappings)
361        {
362            String libraryName = mapping.libraryName;
363
364            List<String> packages = this.libraryNameToPackageNames.get(libraryName);
365
366            if (packages == null)
367            {
368                packages = CollectionFactory.newList();
369                this.libraryNameToPackageNames.put(libraryName, packages);
370            }
371
372            packages.add(mapping.rootPackage);
373
374            // These packages, which will contain classes subject to class transformation,
375            // must be registered with the component instantiator (which is responsible
376            // for transformation).
377
378            addSubpackagesToPackageMapping(mapping.rootPackage);
379
380            packageNameToLibraryName.put(mapping.rootPackage, libraryName);
381        }
382    }
383
384    private void addSubpackagesToPackageMapping(String rootPackage)
385    {
386        for (String subpackage : InternalConstants.SUBPACKAGES)
387        {
388            packageNameToType.put(rootPackage + "." + subpackage, ControlledPackageType.COMPONENT);
389        }
390    }
391
392    public Map<String, ControlledPackageType> getControlledPackageMapping()
393    {
394        return Collections.unmodifiableMap(packageNameToType);
395    }
396
397    /**
398     * When the class loader is invalidated, clear any cached page names or component types.
399     */
400    public synchronized void objectWasInvalidated()
401    {
402        needsRebuild = true;
403    }
404
405    /**
406     * Returns the current data, or atomically rebuilds it. In rare race conditions, the data may be rebuilt more than once, overlapping.
407     */
408    private Data getData()
409    {
410        if (!needsRebuild)
411        {
412            return data;
413        }
414
415        Data newData = new Data();
416
417        for (String prefix : libraryNameToPackageNames.keySet())
418        {
419            List<String> packages = libraryNameToPackageNames.get(prefix);
420
421            String folder = prefix + "/";
422
423            for (String packageName : packages)
424            {
425                newData.rebuild(folder, packageName);
426            }
427        }
428
429        newData.validate();
430
431        showChanges("pages", data.pageToClassName, newData.pageToClassName);
432        showChanges("components", data.componentToClassName, newData.componentToClassName);
433        showChanges("mixins", data.mixinToClassName, newData.mixinToClassName);
434
435        needsRebuild = false;
436
437        data = newData;
438
439        return data;
440    }
441
442    private static int countUnique(Map<String, String> map)
443    {
444        return CollectionFactory.newSet(map.values()).size();
445    }
446
447    /**
448     * Log (at INFO level) the changes between the two logical-name-to-class-name maps
449     *
450     * @param title
451     *         the title of the things in the maps (e.g. "pages" or "components")
452     * @param savedMap
453     *         the old map
454     * @param newMap
455     *         the new map
456     */
457    private void showChanges(String title, Map<String, String> savedMap, Map<String, String> newMap)
458    {
459        if (savedMap.equals(newMap) || !logger.isInfoEnabled()) // nothing to log?
460        {
461            return;
462        }
463
464        Map<String, String> core = CollectionFactory.newMap();
465        Map<String, String> nonCore = CollectionFactory.newMap();
466
467
468        int maxLength = 0;
469
470        // Pass # 1: Get all the stuff in the core library
471
472        for (String name : newMap.keySet())
473        {
474            if (name.startsWith(CORE_LIBRARY_PREFIX))
475            {
476                // Strip off the "core/" prefix.
477
478                String key = name.substring(CORE_LIBRARY_PREFIX.length());
479
480                maxLength = Math.max(maxLength, key.length());
481
482                core.put(key, newMap.get(name));
483            } else
484            {
485                maxLength = Math.max(maxLength, name.length());
486
487                nonCore.put(name, newMap.get(name));
488            }
489        }
490
491        // Merge the non-core mappings into the core mappings. Where there are conflicts on name, it
492        // means the application overrode a core page/component/mixin and that's ok ... the
493        // merged core map will reflect the application's mapping.
494
495        core.putAll(nonCore);
496
497        StringBuilder builder = new StringBuilder(2000);
498        Formatter f = new Formatter(builder);
499
500        int oldCount = countUnique(savedMap);
501        int newCount = countUnique(newMap);
502
503        f.format("Available %s (%d", title, newCount);
504
505        if (oldCount > 0 && oldCount != newCount)
506        {
507            f.format(", +%d", newCount - oldCount);
508        }
509
510        builder.append("):\n");
511
512        String formatString = "%" + maxLength + "s: %s\n";
513
514        List<String> sorted = InternalUtils.sortedKeys(core);
515
516        for (String name : sorted)
517        {
518            String className = core.get(name);
519
520            if (name.equals(""))
521                name = "(blank)";
522
523            f.format(formatString, name, className);
524        }
525
526        // log multi-line string with OS-specific line endings (TAP5-2294)
527        logger.info(builder.toString().replaceAll("\\n", System.getProperty("line.separator")));
528    }
529
530
531    public String resolvePageNameToClassName(final String pageName)
532    {
533        Data data = getData();
534
535        String result = locate(pageName, data.pageToClassName);
536
537        if (result == null)
538        {
539            throw new UnknownValueException(String.format("Unable to resolve '%s' to a page class name.",
540                    pageName), new AvailableValues("Page names", presentableNames(data.pageToClassName)));
541        }
542
543        return result;
544    }
545
546    public boolean isPageName(final String pageName)
547    {
548        return locate(pageName, getData().pageToClassName) != null;
549    }
550
551    public boolean isPage(final String pageClassName)
552    {
553        return locate(pageClassName, getData().pageClassNameToLogicalName) != null;
554    }
555
556
557    public List<String> getPageNames()
558    {
559        Data data = getData();
560
561        List<String> result = CollectionFactory.newList(data.pageClassNameToLogicalName.values());
562
563        Collections.sort(result);
564
565        return result;
566    }
567
568    public List<String> getComponentNames()
569    {
570        Data data = getData();
571
572        List<String> result = CollectionFactory.newList(data.componentToClassName.keySet());
573
574        Collections.sort(result);
575
576        return result;
577    }
578
579    public List<String> getMixinNames()
580    {
581        Data data = getData();
582
583        List<String> result = CollectionFactory.newList(data.mixinToClassName.keySet());
584
585        Collections.sort(result);
586
587        return result;
588    }
589
590    public String resolveComponentTypeToClassName(final String componentType)
591    {
592        Data data = getData();
593
594        String result = locate(componentType, data.componentToClassName);
595
596        if (result == null)
597        {
598            throw new UnknownValueException(String.format("Unable to resolve '%s' to a component class name.",
599                    componentType), new AvailableValues("Component types",
600                    presentableNames(data.componentToClassName)));
601        }
602
603        return result;
604    }
605
606    Collection<String> presentableNames(Map<String, ?> map)
607    {
608        Set<String> result = CollectionFactory.newSet();
609
610        for (String name : map.keySet())
611        {
612
613            if (name.startsWith(CORE_LIBRARY_PREFIX))
614            {
615                result.add(name.substring(CORE_LIBRARY_PREFIX.length()));
616                continue;
617            }
618
619            result.add(name);
620        }
621
622        return result;
623    }
624
625    public String resolveMixinTypeToClassName(final String mixinType)
626    {
627        Data data = getData();
628
629        String result = locate(mixinType, data.mixinToClassName);
630
631        if (result == null)
632        {
633            throw new UnknownValueException(String.format("Unable to resolve '%s' to a mixin class name.",
634                    mixinType), new AvailableValues("Mixin types", presentableNames(data.mixinToClassName)));
635        }
636
637        return result;
638    }
639
640    /**
641     * Locates a class name within the provided map, given its logical name. If not found naturally, a search inside the
642     * "core" library is included.
643     *
644     * @param logicalName
645     *         name to search for
646     * @param logicalNameToClassName
647     *         mapping from logical name to class name
648     * @return the located class name or null
649     */
650    private String locate(String logicalName, Map<String, String> logicalNameToClassName)
651    {
652        String result = logicalNameToClassName.get(logicalName);
653
654        // If not found, see if it exists under the core package. In this way,
655        // anything in core is "inherited" (but overridable) by the application.
656
657        if (result != null)
658        {
659            return result;
660        }
661
662        return logicalNameToClassName.get(CORE_LIBRARY_PREFIX + logicalName);
663    }
664
665    public String resolvePageClassNameToPageName(final String pageClassName)
666    {
667        String result = getData().pageClassNameToLogicalName.get(pageClassName);
668
669        if (result == null)
670        {
671            throw new IllegalArgumentException(String.format("Unable to resolve class name %s to a logical page name.", pageClassName));
672        }
673
674        return result;
675    }
676
677    public String canonicalizePageName(final String pageName)
678    {
679        Data data = getData();
680
681        String result = locate(pageName, data.pageNameToCanonicalPageName);
682
683        if (result == null)
684        {
685            throw new UnknownValueException(String.format("Unable to resolve '%s' to a known page name.",
686                    pageName), new AvailableValues("Page names", presentableNames(data.pageNameToCanonicalPageName)));
687        }
688
689        return result;
690    }
691
692    public Map<String, String> getFolderToPackageMapping()
693    {
694        Map<String, String> result = CollectionFactory.newCaseInsensitiveMap();
695
696        for (String folder : libraryNameToPackageNames.keySet())
697        {
698            List<String> packageNames = libraryNameToPackageNames.get(folder);
699
700            String packageName = findCommonPackageNameForFolder(folder, packageNames);
701
702            result.put(folder, packageName);
703        }
704
705        return result;
706    }
707
708    static String findCommonPackageNameForFolder(String folder, List<String> packageNames)
709    {
710        String packageName = findCommonPackageName(packageNames);
711
712        if (packageName == null)
713            throw new RuntimeException(
714                    String.format(
715                            "Package names for library folder '%s' (%s) can not be reduced to a common base package (of at least one term).",
716                            folder, InternalUtils.joinSorted(packageNames)));
717        return packageName;
718    }
719
720    static String findCommonPackageName(List<String> packageNames)
721    {
722        // BTW, this is what reduce is for in Clojure ...
723
724        String commonPackageName = packageNames.get(0);
725
726        for (int i = 1; i < packageNames.size(); i++)
727        {
728            commonPackageName = findCommonPackageName(commonPackageName, packageNames.get(i));
729
730            if (commonPackageName == null)
731                break;
732        }
733
734        return commonPackageName;
735    }
736
737    static String findCommonPackageName(String commonPackageName, String packageName)
738    {
739        String[] commonExploded = explode(commonPackageName);
740        String[] exploded = explode(packageName);
741
742        int count = Math.min(commonExploded.length, exploded.length);
743
744        int commonLength = 0;
745        int commonTerms = 0;
746
747        for (int i = 0; i < count; i++)
748        {
749            if (exploded[i].equals(commonExploded[i]))
750            {
751                // Keep track of the number of shared characters (including the dot seperators)
752
753                commonLength += exploded[i].length() + (i == 0 ? 0 : 1);
754                commonTerms++;
755            } else
756            {
757                break;
758            }
759        }
760
761        if (commonTerms < 1)
762            return null;
763
764        return commonPackageName.substring(0, commonLength);
765    }
766
767    private static final Pattern DOT = Pattern.compile("\\.");
768
769    private static String[] explode(String packageName)
770    {
771        return DOT.split(packageName);
772    }
773
774    public List<String> getLibraryNames()
775    {
776        return F.flow(libraryNameToPackageNames.keySet()).remove(F.IS_BLANK).sort().toList();
777    }
778
779    public String getLibraryNameForClass(String className)
780    {
781        assert className != null;
782
783        String current = className;
784
785        while (true)
786        {
787
788            int dotx = current.lastIndexOf('.');
789
790            if (dotx < 1)
791            {
792                throw new IllegalArgumentException(String.format("Class %s is not inside any package associated with any library.",
793                        className));
794            }
795
796            current = current.substring(0, dotx);
797
798            String libraryName = packageNameToLibraryName.get(current);
799
800            if (libraryName != null)
801            {
802                return libraryName;
803            }
804        }
805    }
806
807    @Override
808    public Collection<LibraryMapping> getLibraryMappings()
809    {
810        return libraryMappings;
811    }
812
813}