Classes

Class	Line #	Total Statements	% Filtered	Complexity	Uncovered Elements	TOTAL Coverage	Actions
DefaultEditorManager	49	30	0%	14	11	0.770833377.1%	Show methods

Class DefaultEditorManager

Class DefaultEditorManager	Line # 49	Total Statements 30	% Filtered 0%	Complexity 14	Uncovered Elements 11	TOTAL Coverage 0.770833377.1%
getEditors(Type) : List<Editor<D>>   getEditors(Type) : List<Editor<D>>	5858	4.04	0.00%	2.02	1.01	0.75 0.7575%
getEditors(Type,String) : List<Editor<D>>   getEditors(Type,String) : List<Editor<D>>	7070	5.05	0.00%	2.02	0.00	1.0 1.0100%
getEditor(Type,String) : Editor<D>   getEditor(Type,String) : Editor<D>	8282	7.07	0.00%	3.03	3.03	0.6666667 0.666666766.7%
getDefaultEditor(Type) : Editor<D>   getDefaultEditor(Type) : Editor<D>	100100	1.01	0.00%	1.01	1.01	0.0 0.00%
getDefaultEditor(Type,String) : Editor<D>   getDefaultEditor(Type,String) : Editor<D>	106106	9.09	0.00%	4.04	3.03	0.8 0.880%
getEditorWithFallBackOnCategory(Type,String) : Editor<D>   getEditorWithFallBackOnCategory(Type,String) : Editor<D>	127127	4.04	0.00%	2.02	2.02	0.6666667 0.666666766.7%

 

Contributing tests

Source view

1		/*
2		* See the NOTICE file distributed with this work for additional
3		* information regarding copyright ownership.
4		*
5		* This is free software; you can redistribute it and/or modify it
6		* under the terms of the GNU Lesser General Public License as
7		* published by the Free Software Foundation; either version 2.1 of
8		* the License, or (at your option) any later version.
9		*
10		* This software is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13		* Lesser General Public License for more details.
14		*
15		* You should have received a copy of the GNU Lesser General Public
16		* License along with this software; if not, write to the Free
17		* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18		* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
19		*/
20		package org.xwiki.edit.internal;
21
22		import java.lang.reflect.Type;
23		import java.util.ArrayList;
24		import java.util.Collections;
25		import java.util.List;
26		import java.util.Objects;
27
28		import javax.inject.Inject;
29		import javax.inject.Named;
30		import javax.inject.Provider;
31		import javax.inject.Singleton;
32
33		import org.xwiki.component.annotation.Component;
34		import org.xwiki.component.manager.ComponentLookupException;
35		import org.xwiki.component.manager.ComponentManager;
36		import org.xwiki.component.util.DefaultParameterizedType;
37		import org.xwiki.edit.EditConfiguration;
38		import org.xwiki.edit.Editor;
39		import org.xwiki.edit.EditorManager;
40
41		/**
42		* Default {@link EditorManager} implementation.
43		*
44		* @version $Id: a755ad08a54965237c44f409ad7cf331c9e76096 $
45		* @since 8.2RC1
46		*/
47		@Component
48		@Singleton
		77.1% Uncovered Elements: 11 (48) Complexity: 14 Complexity Density: 0.47
49		public class DefaultEditorManager implements EditorManager
50		{
51		@Inject
52		private EditConfiguration configuration;
53
54		@Inject
55		@Named("context")
56		private Provider<ComponentManager> componentManagerProvider;
57
		75% Uncovered Elements: 1 (4) Complexity: 2 Complexity Density: 0.5
58	73	@Override...
59		public <D> List<Editor<D>> getEditors(Type dataType)
60		{
61	73	DefaultParameterizedType editorType = new DefaultParameterizedType(null, Editor.class, dataType);
62	73	try {
63	73	return this.componentManagerProvider.get().getInstanceList(editorType);
64		} catch (ComponentLookupException e) {
65		// No editors found.
66	0	return Collections.emptyList();
67		}
68		}
69
		100% Uncovered Elements: 0 (7) Complexity: 2 Complexity Density: 0.4
70	73	@Override...
71		public <D> List<Editor<D>> getEditors(Type dataType, String category)
72		{
73	73	List<Editor<D>> editors = new ArrayList<>();
74	73	for (Editor<D> editor : this.<D>getEditors(dataType)) {
75	219	if (Objects.equals(category, editor.getDescriptor().getCategory())) {
76	73	editors.add(editor);
77		}
78		}
79	73	return editors;
80		}
81
		66.7% Uncovered Elements: 3 (9) Complexity: 3 Complexity Density: 0.43
82	264	@Override...
83		public <D> Editor<D> getEditor(Type dataType, String hint)
84		{
85	264	DefaultParameterizedType editorType = new DefaultParameterizedType(null, Editor.class, dataType);
86	264	ComponentManager componentManager = this.componentManagerProvider.get();
87	264	if (componentManager.hasComponent(editorType, hint)) {
88	264	try {
89	264	return componentManager.getInstance(editorType, hint);
90		} catch (ComponentLookupException e) {
91	0	throw new RuntimeException(String.format("Failed to look up the [%s] editor with hint [%s]",
92		dataType.getTypeName(), hint), e);
93		}
94		} else {
95		// No such editor component found.
96	0	return null;
97		}
98		}
99
		0% Uncovered Elements: 1 (1) Complexity: 1 Complexity Density: 1
100	0	@Override...
101		public <D> Editor<D> getDefaultEditor(Type dataType)
102		{
103	0	return getDefaultEditor(dataType, null);
104		}
105
		80% Uncovered Elements: 3 (15) Complexity: 4 Complexity Density: 0.44
106	337	@Override...
107		public <D> Editor<D> getDefaultEditor(Type dataType, String category)
108		{
109	337	Editor<D> defaultEditor;
110	337	String defaultEditorHint = this.configuration.getDefaultEditor(dataType, category);
111	337	if (defaultEditorHint == null) {
112		// There's no editor configured for the specified data type and category. See if there is any editor
113		// available in the specified category. This way we don't force the user to configure the default editor for
114		// each category when there's only one editor available per category.
115	73	List<Editor<D>> editors = getEditors(dataType, category);
116	73	if (editors.isEmpty()) {
117		// See if there is any editor available for the specified data type.
118	0	editors = getEditors(dataType);
119		}
120	73	defaultEditor = editors.isEmpty() ? null : editors.get(0);
121		} else {
122	264	defaultEditor = getEditorWithFallBackOnCategory(dataType, defaultEditorHint);
123		}
124	337	return defaultEditor;
125		}
126
		66.7% Uncovered Elements: 2 (6) Complexity: 2 Complexity Density: 0.5
127	264	private <D> Editor<D> getEditorWithFallBackOnCategory(Type dataType, String roleHint)...
128		{
129	264	Editor<D> editor = getEditor(dataType, roleHint);
130	264	if (editor == null) {
131		// Consider the roleHint to be a category of editors and return the default one.
132	0	editor = getDefaultEditor(dataType, roleHint);
133		}
134	264	return editor;
135		}
136		}