1. Project Clover database Tue Dec 20 2016 21:24:09 CET
  2. Package com.xpn.xwiki.internal.render

File DefaultLinkedResourceHelper.java

 

Coverage histogram

../../../../../img/srcFileCovDistChart7.png
64% of files have more coverage

Code metrics

32
49
6
1
175
111
22
0.45
8.17
6
3.67

Classes

Class Line # Actions
DefaultLinkedResourceHelper 47 49 0% 22 33
0.6206896362.1%
 

Contributing tests

This file is covered by 8 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 com.xpn.xwiki.internal.render;
21   
22    import java.util.List;
23   
24    import javax.inject.Singleton;
25   
26    import org.apache.commons.lang3.StringUtils;
27    import org.xwiki.component.annotation.Component;
28    import org.xwiki.rendering.block.Block;
29    import org.xwiki.rendering.block.LinkBlock;
30    import org.xwiki.rendering.block.MacroBlock;
31    import org.xwiki.rendering.block.XDOM;
32    import org.xwiki.rendering.block.match.ClassBlockMatcher;
33    import org.xwiki.rendering.block.match.MacroBlockMatcher;
34    import org.xwiki.rendering.block.match.OrBlockMatcher;
35    import org.xwiki.rendering.listener.reference.ResourceReference;
36    import org.xwiki.rendering.listener.reference.ResourceType;
37   
38    /**
39    * Default implementation for {@link LinkedResourceHelper}.
40    *
41    * @version $Id: 67c2173690e805a6fa420b79ed96cdc35a72907b $
42    * @since 7.4.1
43    * @since 8.0M1
44    */
45    @Component
46    @Singleton
 
47    public class DefaultLinkedResourceHelper implements LinkedResourceHelper
48    {
49    private static final String DOCUMENT_MACRO_PARAMETER = "document";
50   
51    private static final String REFERENCE_MACRO_PARAMETER = "reference";
52   
 
53  18 toggle @Override
54    public List<Block> getBlocks(XDOM xdom)
55    {
56    // @formatter:off
57  18 List<Block> blocks = xdom.getBlocks(
58    new OrBlockMatcher(
59    new ClassBlockMatcher(LinkBlock.class),
60    new MacroBlockMatcher("include"),
61    new MacroBlockMatcher("display")
62    ), Block.Axes.DESCENDANT);
63    // @formatter:on
64   
65  18 return blocks;
66    }
67   
 
68  4 toggle @Override
69    public String getResourceReferenceString(Block block)
70    {
71    // Determine the reference string and reference type for each block type.
72  4 String referenceString = null;
73  4 if (block instanceof LinkBlock) {
74  0 LinkBlock linkBlock = (LinkBlock) block;
75  0 ResourceReference linkReference = linkBlock.getReference();
76   
77  0 referenceString = linkReference.getReference();
78  4 } else if (block instanceof MacroBlock) {
79  4 referenceString = block.getParameter(REFERENCE_MACRO_PARAMETER);
80  4 if (StringUtils.isBlank(referenceString)) {
81  1 referenceString = block.getParameter(DOCUMENT_MACRO_PARAMETER);
82    }
83   
84  4 if (StringUtils.isBlank(referenceString)) {
85    // If the reference is not set or is empty, we have a recursive include which is not valid anyway.
86    // Skip it.
87  0 referenceString = null;
88    }
89    }
90   
91  4 return referenceString;
92    }
93   
 
94  0 toggle @Override
95    public ResourceType getResourceType(Block block)
96    {
97    // Determine the reference string and reference type for each block type.
98  0 ResourceType resourceType = null;
99  0 if (block instanceof LinkBlock) {
100  0 LinkBlock linkBlock = (LinkBlock) block;
101  0 ResourceReference linkReference = linkBlock.getReference();
102   
103  0 resourceType = linkReference.getType();
104  0 } else if (block instanceof MacroBlock) {
105    // We still have to look at the reference string to see if it is a valid include (i.e. non-recursive).
106  0 String referenceString = block.getParameter(REFERENCE_MACRO_PARAMETER);
107  0 if (StringUtils.isBlank(referenceString)) {
108  0 referenceString = block.getParameter(DOCUMENT_MACRO_PARAMETER);
109    }
110   
111  0 if (StringUtils.isBlank(referenceString)) {
112    // If the reference is not set or is empty, we have a recursive include which is not valid anyway.
113    // Skip it.
114  0 return null;
115    }
116   
117    // FIXME: this may be SPACE once we start hiding "WebHome" from macro reference parameters.
118  0 resourceType = ResourceType.DOCUMENT;
119    }
120   
121  0 return resourceType;
122    }
123   
 
124  20 toggle @Override
125    public void setResourceReferenceString(Block block, String newReferenceString)
126    {
127  20 if (block instanceof LinkBlock) {
128  16 LinkBlock linkBlock = (LinkBlock) block;
129  16 ResourceReference linkReference = linkBlock.getReference();
130   
131  16 linkReference.setReference(newReferenceString);
132  4 } else if (block instanceof MacroBlock) {
133  4 if (StringUtils.isNotBlank(block.getParameter(DOCUMENT_MACRO_PARAMETER))) {
134    // Backwards compatibility check.
135  1 block.setParameter(DOCUMENT_MACRO_PARAMETER, newReferenceString);
136    } else {
137  3 block.setParameter(REFERENCE_MACRO_PARAMETER, newReferenceString);
138    }
139    }
140    }
141   
 
142  16 toggle @Override
143    public void setResourceType(Block block, ResourceType newResourceType)
144    {
145  16 if (block instanceof LinkBlock) {
146  12 LinkBlock linkBlock = (LinkBlock) block;
147  12 ResourceReference linkReference = linkBlock.getReference();
148   
149  12 linkReference.setType(newResourceType);
150  4 } else if (block instanceof MacroBlock) {
151    // N/A yet.
152    }
153    }
154   
 
155  21 toggle @Override
156    public ResourceReference getResourceReference(Block block)
157    {
158  21 ResourceReference result = null;
159   
160  21 if (block instanceof LinkBlock) {
161  17 result = ((LinkBlock) block).getReference();
162  4 } else if (block instanceof MacroBlock) {
163    // Wrap it up as a ResourceReference.
164  4 String referenceString = getResourceReferenceString(block);
165  4 if (referenceString != null) {
166    // FIXME: At some point we might want to allow space references too, so the resource reference might
167    // need to become untyped.
168  4 result = new ResourceReference(referenceString, ResourceType.DOCUMENT);
169  4 result.setTyped(true);
170    }
171    }
172   
173  21 return result;
174    }
175    }