Clover icon

magnolia-module-blossom 3.0.6

  1. Project Clover database Fri Mar 6 2015 14:07:48 CET
  2. Package info.magnolia.module.blossom.dialog

File DialogDescriptionBuilder.java

 

Coverage histogram

../../../../../img/srcFileCovDistChart10.png
0% of files have more coverage

Code metrics

36
73
10
1
210
137
32
0.44
7.3
10
3.2
1.7% of code in this file is excluded from these metrics.

Classes

Class Line # Actions
DialogDescriptionBuilder 60 73 1.7% 32 6
0.9495798395%
 

Contributing tests

This file is covered by 20 tests. .

Source view

1    /**
2    * This file Copyright (c) 2010-2015 Magnolia International
3    * Ltd. (http://www.magnolia-cms.com). All rights reserved.
4    *
5    *
6    * This file is dual-licensed under both the Magnolia
7    * Network Agreement and the GNU General Public License.
8    * You may elect to use one or the other of these licenses.
9    *
10    * This file is distributed in the hope that it will be
11    * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
12    * implied warranty of MERCHANTABILITY or FITNESS FOR A
13    * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
14    * Redistribution, except as permitted by whichever of the GPL
15    * or MNA you select, is prohibited.
16    *
17    * 1. For the GPL license (GPL), you can redistribute and/or
18    * modify this file under the terms of the GNU General
19    * Public License, Version 3, as published by the Free Software
20    * Foundation. You should have received a copy of the GNU
21    * General Public License, Version 3 along with this program;
22    * if not, write to the Free Software Foundation, Inc., 51
23    * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
24    *
25    * 2. For the Magnolia Network Agreement (MNA), this file
26    * and the accompanying materials are made available under the
27    * terms of the MNA which accompanies this distribution, and
28    * is available at http://www.magnolia-cms.com/mna.html
29    *
30    * Any modifications to this file must keep this entire header
31    * intact.
32    *
33    */
34    package info.magnolia.module.blossom.dialog;
35   
36    import java.lang.annotation.Annotation;
37    import java.lang.reflect.Method;
38    import java.lang.reflect.Modifier;
39    import java.util.ArrayList;
40    import java.util.Collections;
41    import java.util.List;
42   
43    import org.slf4j.Logger;
44    import org.slf4j.LoggerFactory;
45    import org.springframework.aop.support.AopUtils;
46    import org.springframework.util.ClassUtils;
47    import org.springframework.util.ReflectionUtils;
48   
49    import info.magnolia.module.blossom.annotation.DialogFactory;
50    import info.magnolia.module.blossom.annotation.I18nBasename;
51    import info.magnolia.module.blossom.annotation.PostCreate;
52    import info.magnolia.module.blossom.annotation.TabFactory;
53    import info.magnolia.module.blossom.annotation.TabOrder;
54   
55    /**
56    * Builds dialog descriptions from annotations.
57    *
58    * @since 1.0
59    */
 
60    public class DialogDescriptionBuilder {
61   
62    private final Logger logger = LoggerFactory.getLogger(getClass());
63   
64    private DialogCreator dialogCreator;
65   
 
66    toggle public void setDialogCreator(DialogCreator dialogCreator) {
67    this.dialogCreator = dialogCreator;
68    }
69   
 
70  31 toggle public DialogCreator getDialogCreator() {
71  31 if (dialogCreator == null) {
72  23 dialogCreator = new DefaultDialogCreator();
73    }
74  31 return dialogCreator;
75    }
76   
 
77  7 toggle public BlossomDialogDescription buildDescription(Object factoryObject) {
78  7 return buildDescription(factoryObject, null);
79    }
80   
 
81  11 toggle public List<BlossomDialogDescription> buildDescriptions(final Object handler) {
82   
83  11 final List<Method> factoryMethods = new ArrayList<Method>();
84   
85  11 final Class<?> handlerClass = AopUtils.getTargetClass(handler);
86  11 ReflectionUtils.doWithMethods(handlerClass, new ReflectionUtils.MethodCallback() {
87   
 
88  156 toggle @Override
89    public void doWith(Method method) {
90  156 DialogFactory dialogFactory = method.getAnnotation(DialogFactory.class);
91  156 if (dialogFactory != null && method.equals(ClassUtils.getMostSpecificMethod(method, handlerClass))) {
92  4 if (Modifier.isStatic(method.getModifiers())) {
93  0 throw new IllegalStateException("DialogFactory annotation is not supported on static methods");
94    }
95  4 factoryMethods.add(method);
96    }
97    }
98    });
99   
100  11 List<BlossomDialogDescription> descriptions = new ArrayList<BlossomDialogDescription>();
101   
102  11 for (Method method : factoryMethods) {
103  4 descriptions.add(buildDescription(handler, method));
104    }
105   
106  11 return descriptions;
107    }
108   
 
109  14 toggle public BlossomDialogDescription buildDescription(Object factoryObject, Method factoryMethod) {
110  14 DialogFactory annotation = findAnnotation(DialogFactory.class, factoryObject, factoryMethod);
111  14 return buildDescription(annotation.value(), annotation.label(), factoryObject, factoryMethod);
112    }
113   
 
114  19 toggle public BlossomDialogDescription buildDescription(String id, String label, Object factoryObject) {
115  19 return buildDescription(id, label, factoryObject, null);
116    }
117   
 
118  33 toggle protected BlossomDialogDescription buildDescription(String id, String label, Object factoryObject, Method factoryMethod) {
119  33 BlossomDialogDescription dialogDescription = new BlossomDialogDescription();
120  33 dialogDescription.setId(id);
121  33 dialogDescription.setFactoryMetaData(buildFactoryMetaData(label, factoryObject, factoryMethod));
122  31 dialogDescription.setDialogCreator(getDialogCreator());
123  31 return dialogDescription;
124    }
125   
 
126  33 toggle protected DialogFactoryMetaData buildFactoryMetaData(String label, Object factoryObject, Method factoryMethod) {
127   
128  33 DialogFactoryMetaData factoryMetaData = new DialogFactoryMetaData();
129  33 factoryMetaData.setLabel(label);
130  33 factoryMetaData.setFactoryObject(factoryObject);
131  33 factoryMetaData.setFactoryMethod(factoryMethod);
132   
133  33 TabOrder tabOrder = findAnnotation(TabOrder.class, factoryObject, factoryMethod);
134  33 I18nBasename i18nBasename = findAnnotation(I18nBasename.class, factoryObject, factoryMethod);
135   
136  33 factoryMetaData.setTabOrder(tabOrder != null ? tabOrder.value() : null);
137  33 factoryMetaData.setI18nBasename(i18nBasename != null ? i18nBasename.value() : null);
138   
139  33 if (factoryMethod == null) {
140   
141  29 Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);
142   
143  29 List<Class<?>> classHierarchy = getClassHierarchyInTopToBottomOrder(factoryClass);
144   
145  29 List<Method> methodsAdded = new ArrayList<Method>();
146   
147  29 for (Class<?> clazz : classHierarchy) {
148   
149  66 DialogFactoryClassMetaData classMetaData = new DialogFactoryClassMetaData();
150  66 classMetaData.setClazz(clazz);
151   
152  66 for (Method method : clazz.getDeclaredMethods()) {
153   
154  414 if (method.isAnnotationPresent(TabFactory.class) && method.isAnnotationPresent(PostCreate.class)) {
155  0 throw new IllegalStateException("TabFactory and PostCreate annotations cannot both be used on the same method");
156    }
157  414 if (method.isAnnotationPresent(TabFactory.class)) {
158  18 if (Modifier.isStatic(method.getModifiers())) {
159  1 throw new IllegalStateException("TabFactory annotation is not supported on static methods");
160    }
161  17 Method mostSpecificMethod = ClassUtils.getMostSpecificMethod(method, factoryClass);
162  17 if (mostSpecificMethod.isAnnotationPresent(TabFactory.class) && !methodsAdded.contains(mostSpecificMethod)) {
163  16 classMetaData.addTabFactory(mostSpecificMethod);
164  16 methodsAdded.add(mostSpecificMethod);
165    }
166    }
167  413 if (method.isAnnotationPresent(PostCreate.class)) {
168  13 if (Modifier.isStatic(method.getModifiers())) {
169  1 throw new IllegalStateException("PostCreate annotation is not supported on static methods");
170    }
171  12 Method mostSpecificMethod = ClassUtils.getMostSpecificMethod(method, factoryClass);
172  12 if (mostSpecificMethod.isAnnotationPresent(PostCreate.class) && !methodsAdded.contains(mostSpecificMethod)) {
173  9 PostCreate annotation = mostSpecificMethod.getAnnotation(PostCreate.class);
174  9 if (annotation.value() == PostCreate.Phase.AFTER_TAB_FACTORIES_IN_SAME_CLASS) {
175  7 classMetaData.addPostCreateCallback(mostSpecificMethod);
176  2 } else if (annotation.value() == PostCreate.Phase.AFTER_SUB_CLASSES) {
177  2 factoryMetaData.addPostCreateCallback(mostSpecificMethod);
178    }
179  9 methodsAdded.add(mostSpecificMethod);
180    }
181    }
182    }
183   
184  64 if (!classMetaData.isEmpty()) {
185  16 factoryMetaData.addClassMetaData(classMetaData);
186    }
187    }
188    }
189   
190  31 return factoryMetaData;
191    }
192   
 
193  80 toggle protected <T extends Annotation> T findAnnotation(Class<T> annotationClass, Object factoryObject, Method factoryMethod) {
194  80 if (factoryMethod != null) {
195  12 return factoryMethod.getAnnotation(annotationClass);
196    }
197  68 Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);
198  68 return factoryClass.getAnnotation(annotationClass);
199    }
200   
 
201  29 toggle private List<Class<?>> getClassHierarchyInTopToBottomOrder(Class<?> factoryClass) {
202  29 List<Class<?>> hierarchy = new ArrayList<Class<?>>();
203  95 while (factoryClass != null) {
204  66 hierarchy.add(factoryClass);
205  66 factoryClass = factoryClass.getSuperclass();
206    }
207  29 Collections.reverse(hierarchy);
208  29 return hierarchy;
209    }
210    }
  • Report generated by Atlassian Clover v 4.0.2 on Fri Mar 6 2015 14:08:57 CET using coverage data from Fri Mar 6 2015 14:08:00 CET.
  • Clover: Open Source License registered to Magnolia CMS.