@Override protected String getImageSrcAttributeValue(ResourceReference reference, Map<String, String> parameters) { return String.format("%s:%s", reference.getType().getScheme(), reference.getReference()); } }
@Override public String serialize(ResourceReference reference) { StringBuilder result = new StringBuilder(); result.append(reference.getType().getScheme()); result.append(DefaultResourceReferenceParser.TYPE_SEPARATOR); String interWikiAlias = reference.getParameter(InterWikiResourceReference.INTERWIKI_ALIAS); if (interWikiAlias != null) { result.append(interWikiAlias); result.append(InterWikiResourceReferenceTypeParser.INTERWIKI_ALIAS_SEPARATOR); } result.append(reference.getReference()); return result.toString(); } }
/** * Recognize the passed reference and figure out what type of link it should be: * <ul> * <li>UC1: the reference points to a valid URL, we return a reference of type "url", * e.g. {@code http://server/path/reference#anchor}</li> * <li>UC2: the reference is not a valid URL, we return a reference of type "path", * e.g. {@code path/reference#anchor}</li> * </ul> * * @param rawReference the full reference (e.g. "/some/path/something#other") * @return the properly typed {@link ResourceReference} matching the use cases */ private ResourceReference computeResourceReference(String rawReference) { ResourceReference reference; // Do we have a valid URL? Matcher matcher = URL_SCHEME_PATTERN.matcher(rawReference); if (matcher.lookingAt()) { // We have UC1 reference = new ResourceReference(rawReference, ResourceType.URL); } else { // We have UC2 reference = new ResourceReference(rawReference, ResourceType.PATH); } return reference; }
/** * {@inheritDoc} * @see Object#hashCode() */ @Override public int hashCode() { return new HashCodeBuilder(1, 9) .append(getType()) .append(isTyped()) .append(getReference()) .append(getParameters()) .toHashCode(); }
@Override public String serialize(ResourceReference reference) { StringBuffer result = new StringBuffer(); if (reference.isTyped() && isSupportedType(reference.getType())) { result.append(reference.getType().getScheme()); result.append(DefaultResourceReferenceParser.TYPE_SEPARATOR); } result.append(reference.getReference()); return result.toString(); }
@Override protected void beginLinkExtraAttributes(ResourceReference reference, Map<String, String> spanAttributes, Map<String, String> anchorAttributes) { // Look for an InterWiki definition for the passed Link. If not found then simply use the InterWiki Path. String interWikiAlias = reference.getParameter(InterWikiResourceReference.INTERWIKI_ALIAS); Properties definitions = this.renderingConfiguration.getInterWikiDefinitions(); if (definitions.containsKey(interWikiAlias)) { anchorAttributes.put(XHTMLLinkRenderer.HREF, definitions.getProperty(interWikiAlias) + reference.getReference()); } else { anchorAttributes.put(XHTMLLinkRenderer.HREF, reference.getReference()); } } }
@Override protected String getImageSrcAttributeValue(ResourceReference reference, Map<String, String> parameters) { return reference.getReference(); } }
/** * @param document the document whose anchors to update * @param fragments see {@link #collectDocumentFragments(List)} */ private void updateAnchors(WikiDocument document, Map<String, String> fragments) { for (LinkBlock linkBlock : document.getXdom().<LinkBlock> getBlocks(new ClassBlockMatcher(LinkBlock.class), Axes.DESCENDANT)) { ResourceReference reference = linkBlock.getReference(); ResourceType resoureceType = reference.getType(); String fragment = null; if (isDocument(resoureceType) && StringUtils.isEmpty(reference.getReference())) { fragment = reference.getParameter(ANCHOR_PARAMETER); } else if (StringUtils.startsWith(reference.getReference(), "#") && (ResourceType.PATH.equals(resoureceType) || ResourceType.URL.equals(resoureceType))) { fragment = reference.getReference().substring(1); } String targetDocument = fragments.get(fragment); if (targetDocument != null && !targetDocument.equals(document.getFullName())) { // The fragment has been moved so we need to update the link. reference.setType(ResourceType.DOCUMENT); reference.setReference(targetDocument); reference.setParameter(ANCHOR_PARAMETER, fragment); } } }
@Override protected void onImage(ResourceReference reference, boolean freestanding, Map<String, String> parameters) { // Since 2.5M2, handle the special case when the image syntax used for an image has a query string specified. if (ResourceType.ATTACHMENT.equals(reference.getType())) { String queryString = parameters.remove(QUERY_STRING); if (queryString != null) { reference.setParameter(DocumentResourceReference.QUERY_STRING, queryString); } } super.onImage(reference, freestanding, parameters); } }
/** * @since 2.2M1 */ private void refactorDocumentLinks(DocumentReference oldDocumentReference, DocumentReference newDocumentReference, XWikiContext context) throws XWikiException { XDOM xdom = getXDOM(); List<LinkBlock> linkBlockList = xdom.getChildrenByType(LinkBlock.class, true); for (LinkBlock linkBlock : linkBlockList) { ResourceReference linkReference = linkBlock.getReference(); if (linkReference.getType().equals(ResourceType.DOCUMENT)) { DocumentReference documentReference = this.explicitDocumentReferenceResolver.resolve( linkReference.getReference(), getDocumentReference()); if (documentReference.equals(oldDocumentReference)) { linkReference.setReference(this.compactEntityReferenceSerializer.serialize(newDocumentReference, getDocumentReference())); } } } setContent(xdom); }
if (reference.getType().equals(ResourceType.DOCUMENT)) { String queryString = reference.getParameter(DocumentResourceReference.QUERY_STRING); if (!StringUtils.isEmpty(queryString)) { printer.print(PARAMETER_SEPARATOR); String anchor = reference.getParameter(DocumentResourceReference.ANCHOR); if (!StringUtils.isEmpty(anchor)) { if (shouldPrintSeparator) { shouldPrintSeparator = false; } else if (reference.getType().equals(ResourceType.ATTACHMENT)) { String queryString = reference.getParameter(AttachmentResourceReference.QUERY_STRING); if (!StringUtils.isEmpty(queryString)) { printer.print(PARAMETER_SEPARATOR);
/** * {@inheritDoc} * @see ResourceReferenceParser#parse(String) */ public ResourceReference parse(String rawReference) { ResourceReference reference = this.defaultResourceReferenceParser.parse(rawReference); if (reference.getType().equals(ResourceType.UNKNOWN)) { reference = this.untypedImageReferenceParser.parse(rawReference); } return reference; } }
List<ImageBlock> imgBlocks = xdom.getBlocks(new ClassBlockMatcher(ImageBlock.class), Block.Axes.DESCENDANT); for (ImageBlock imgBlock : imgBlocks) { String imageReference = imgBlock.getReference().getReference(); this.urlTemporaryResourceReferenceSerializer.serialize(temporaryResourceReference).serialize(); ResourceReference urlImageReference = new ResourceReference(temporaryResourceURL, ResourceType.PATH); urlImageReference.setTyped(true);
/** * {@inheritDoc} * * @since 2.5RC1 */ @Override public String getLinkURL(ResourceReference linkReference) { String queryString = linkReference.getParameter(AttachmentResourceReference.QUERY_STRING); return "attachmenturl" + (queryString != null ? QM + queryString : ""); }
@Override public ResourceReference parse(String rawReference) { String[] tokens = StringUtils.splitByWholeSeparatorPreserveAllTokens(rawReference, COMMENT_SEPARATOR); boolean isTyped = "true".equalsIgnoreCase(tokens[0]); ResourceType type = new ResourceType(tokens[1]); String reference = tokens[2]; ResourceReference resourceReference = new ResourceReference(reference, type); resourceReference.setTyped(isTyped); if (tokens.length == 4) { for (WikiParameter parameter : WikiParameters.newWikiParameters(tokens[3])) { resourceReference.setParameter(parameter.getKey(), parameter.getValue()); } } return resourceReference; } }
/** * {@inheritDoc} * * @see org.xwiki.rendering.parser.ResourceReferenceParser#parse(String) */ public ResourceReference parse(String rawReference) { ResourceType type; if (rawReference.startsWith("http://") || !isInWikiMode()) { type = ResourceType.URL; } else { type = ResourceType.ATTACHMENT; } ResourceReference result = new ResourceReference(rawReference, type); result.setTyped(false); return result; }
/** * {@inheritDoc} * @see ResourceReferenceParser#parse(String) */ public ResourceReference parse(String rawReference) { // Try to guess the link type. It can be either: // - a URL (specified without the "url" type) // - a reference to a document (specified without the "doc" type) ResourceReference reference = this.urlResourceReferenceTypeParser.parse(rawReference); if (reference == null) { // What remains is considered to be a link to a document, use the document link type parser to parse it. reference = this.documentResourceReferenceTypeParser.parse(rawReference); } reference.setTyped(false); return reference; } }
/** * {@inheritDoc} * @see Object#equals(Object) */ @Override public boolean equals(Object object) { if (object == null) { return false; } if (object == this) { return true; } if (object.getClass() != getClass()) { return false; } ResourceReference rhs = (ResourceReference) object; return new EqualsBuilder() .append(getType(), rhs.getType()) .append(isTyped(), rhs.isTyped()) .append(getReference(), rhs.getReference()) .append(getParameters(), rhs.getParameters()) .isEquals(); } }
@Override public String serialize(ResourceReference reference) { String interWikiAlias = reference.getParameter(InterWikiResourceReference.INTERWIKI_ALIAS); String result = addEscapesToReferencePart(reference.getReference()); if (interWikiAlias != null) { result = addEscapesToReferencePart(reference.getReference()) + XWiki20LinkReferenceParser.SEPARATOR_INTERWIKI + addEscapesToExtraParts(interWikiAlias); } return result; }
/** * {@inheritDoc} * @see org.xwiki.rendering.renderer.reference.link.URILabelGenerator#generateLabel( *org.xwiki.rendering.listener.reference.ResourceReference) */ public String generateLabel(ResourceReference reference) { return reference.getReference(); } }