Clover icon

magnolia-module-blossom 3.1.3

  1. Project Clover database Fri Apr 29 2016 13:24:33 CEST
  2. Package info.magnolia.module.blossom.dialog

File DialogDescriptionBuilder.java

 

Coverage histogram

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

Code metrics

36
77
10
1
216
143
33
0.43
7.7
10
3.3
1.6% of code in this file is excluded from these metrics.

Classes

Class Line # Actions
DialogDescriptionBuilder 60 77 1.6% 33 7
0.943089494.3%
 

Contributing tests

This file is covered by 24 tests. .

Source view

1    /**
2    * This file Copyright (c) 2010-2016 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  35 toggle public DialogCreator getDialogCreator() {
71  35 if (dialogCreator == null) {
72  27 DefaultDialogCreator defaultDialogCreator = new DefaultDialogCreator();
73  27 try {
74  27 defaultDialogCreator.afterPropertiesSet();
75    } catch (Exception e) {
76  0 throw new RuntimeException("Could not create DefaultDialogCreator", e);
77    }
78  27 dialogCreator = defaultDialogCreator;
79    }
80  35 return dialogCreator;
81    }
82   
 
83  7 toggle public BlossomDialogDescription buildDescription(Object factoryObject) {
84  7 return buildDescription(factoryObject, null);
85    }
86   
 
87  11 toggle public List<BlossomDialogDescription> buildDescriptions(final Object handler) {
88   
89  11 final List<Method> factoryMethods = new ArrayList<Method>();
90   
91  11 final Class<?> handlerClass = AopUtils.getTargetClass(handler);
92  11 ReflectionUtils.doWithMethods(handlerClass, new ReflectionUtils.MethodCallback() {
93   
 
94  156 toggle @Override
95    public void doWith(Method method) {
96  156 DialogFactory dialogFactory = method.getAnnotation(DialogFactory.class);
97  156 if (dialogFactory != null && method.equals(ClassUtils.getMostSpecificMethod(method, handlerClass))) {
98  4 if (Modifier.isStatic(method.getModifiers())) {
99  0 throw new IllegalStateException("DialogFactory annotation is not supported on static methods");
100    }
101  4 factoryMethods.add(method);
102    }
103    }
104    });
105   
106  11 List<BlossomDialogDescription> descriptions = new ArrayList<BlossomDialogDescription>();
107   
108  11 for (Method method : factoryMethods) {
109  4 descriptions.add(buildDescription(handler, method));
110    }
111   
112  11 return descriptions;
113    }
114   
 
115  18 toggle public BlossomDialogDescription buildDescription(Object factoryObject, Method factoryMethod) {
116  18 DialogFactory annotation = findAnnotation(DialogFactory.class, factoryObject, factoryMethod);
117  18 return buildDescription(annotation.value(), annotation.label(), factoryObject, factoryMethod);
118    }
119   
 
120  19 toggle public BlossomDialogDescription buildDescription(String id, String label, Object factoryObject) {
121  19 return buildDescription(id, label, factoryObject, null);
122    }
123   
 
124  37 toggle protected BlossomDialogDescription buildDescription(String id, String label, Object factoryObject, Method factoryMethod) {
125  37 BlossomDialogDescription dialogDescription = new BlossomDialogDescription();
126  37 dialogDescription.setId(id);
127  37 dialogDescription.setFactoryMetaData(buildFactoryMetaData(label, factoryObject, factoryMethod));
128  35 dialogDescription.setDialogCreator(getDialogCreator());
129  35 return dialogDescription;
130    }
131   
 
132  37 toggle protected DialogFactoryMetaData buildFactoryMetaData(String label, Object factoryObject, Method factoryMethod) {
133   
134  37 DialogFactoryMetaData factoryMetaData = new DialogFactoryMetaData();
135  37 factoryMetaData.setLabel(label);
136  37 factoryMetaData.setFactoryObject(factoryObject);
137  37 factoryMetaData.setFactoryMethod(factoryMethod);
138   
139  37 TabOrder tabOrder = findAnnotation(TabOrder.class, factoryObject, factoryMethod);
140  37 I18nBasename i18nBasename = findAnnotation(I18nBasename.class, factoryObject, factoryMethod);
141   
142  37 factoryMetaData.setTabOrder(tabOrder != null ? tabOrder.value() : null);
143  37 factoryMetaData.setI18nBasename(i18nBasename != null ? i18nBasename.value() : null);
144   
145  37 if (factoryMethod == null) {
146   
147  33 Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);
148   
149  33 List<Class<?>> classHierarchy = getClassHierarchyInTopToBottomOrder(factoryClass);
150   
151  33 List<Method> methodsAdded = new ArrayList<Method>();
152   
153  33 for (Class<?> clazz : classHierarchy) {
154   
155  74 DialogFactoryClassMetaData classMetaData = new DialogFactoryClassMetaData();
156  74 classMetaData.setClazz(clazz);
157   
158  74 for (Method method : clazz.getDeclaredMethods()) {
159   
160  474 if (method.isAnnotationPresent(TabFactory.class) && method.isAnnotationPresent(PostCreate.class)) {
161  0 throw new IllegalStateException("TabFactory and PostCreate annotations cannot both be used on the same method");
162    }
163  474 if (method.isAnnotationPresent(TabFactory.class)) {
164  28 if (Modifier.isStatic(method.getModifiers())) {
165  1 throw new IllegalStateException("TabFactory annotation is not supported on static methods");
166    }
167  27 Method mostSpecificMethod = ClassUtils.getMostSpecificMethod(method, factoryClass);
168  27 if (mostSpecificMethod.isAnnotationPresent(TabFactory.class) && !methodsAdded.contains(mostSpecificMethod)) {
169  26 classMetaData.addTabFactory(mostSpecificMethod);
170  26 methodsAdded.add(mostSpecificMethod);
171    }
172    }
173  473 if (method.isAnnotationPresent(PostCreate.class)) {
174  13 if (Modifier.isStatic(method.getModifiers())) {
175  1 throw new IllegalStateException("PostCreate annotation is not supported on static methods");
176    }
177  12 Method mostSpecificMethod = ClassUtils.getMostSpecificMethod(method, factoryClass);
178  12 if (mostSpecificMethod.isAnnotationPresent(PostCreate.class) && !methodsAdded.contains(mostSpecificMethod)) {
179  9 PostCreate annotation = mostSpecificMethod.getAnnotation(PostCreate.class);
180  9 if (annotation.value() == PostCreate.Phase.AFTER_TAB_FACTORIES_IN_SAME_CLASS) {
181  7 classMetaData.addPostCreateCallback(mostSpecificMethod);
182  2 } else if (annotation.value() == PostCreate.Phase.AFTER_SUB_CLASSES) {
183  2 factoryMetaData.addPostCreateCallback(mostSpecificMethod);
184    }
185  9 methodsAdded.add(mostSpecificMethod);
186    }
187    }
188    }
189   
190  72 if (!classMetaData.isEmpty()) {
191  20 factoryMetaData.addClassMetaData(classMetaData);
192    }
193    }
194    }
195   
196  35 return factoryMetaData;
197    }
198   
 
199  92 toggle protected <T extends Annotation> T findAnnotation(Class<T> annotationClass, Object factoryObject, Method factoryMethod) {
200  92 if (factoryMethod != null) {
201  12 return factoryMethod.getAnnotation(annotationClass);
202    }
203  80 Class<?> factoryClass = AopUtils.getTargetClass(factoryObject);
204  80 return factoryClass.getAnnotation(annotationClass);
205    }
206   
 
207  33 toggle private List<Class<?>> getClassHierarchyInTopToBottomOrder(Class<?> factoryClass) {
208  33 List<Class<?>> hierarchy = new ArrayList<Class<?>>();
209  107 while (factoryClass != null) {
210  74 hierarchy.add(factoryClass);
211  74 factoryClass = factoryClass.getSuperclass();
212    }
213  33 Collections.reverse(hierarchy);
214  33 return hierarchy;
215    }
216    }
  • Report generated by Atlassian Clover v 4.0.4 on Fri Apr 29 2016 13:26:42 CEST using coverage data from Fri Apr 29 2016 13:24:57 CEST.
  • Clover: Open Source License registered to Magnolia CMS.