| /******************************************************************************* |
| * Copyright (c) 2022 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.internal.ui.text.javadoc; |
| |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.ListIterator; |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.regex.PatternSyntaxException; |
| |
| import org.eclipse.jdt.core.IJavaElement; |
| import org.eclipse.jdt.core.dom.ASTNode; |
| import org.eclipse.jdt.core.dom.JavaDocRegion; |
| import org.eclipse.jdt.core.dom.MemberRef; |
| import org.eclipse.jdt.core.dom.MethodRef; |
| import org.eclipse.jdt.core.dom.MethodRefParameter; |
| import org.eclipse.jdt.core.dom.Name; |
| import org.eclipse.jdt.core.dom.SimpleName; |
| import org.eclipse.jdt.core.dom.TagElement; |
| import org.eclipse.jdt.core.dom.TagProperty; |
| import org.eclipse.jdt.core.dom.TextElement; |
| |
| import org.eclipse.jdt.internal.corext.dom.ASTNodes; |
| |
| import org.eclipse.jdt.internal.ui.JavaPlugin; |
| import org.eclipse.jdt.internal.ui.viewsupport.JavaElementLinks; |
| |
| public class JavaDocSnippetStringEvaluator { |
| |
| /** |
| * Either an IMember or an IPackageFragment. |
| */ |
| private final IJavaElement fElement; |
| |
| public enum ReplacementStringIntervalStatus { |
| /** |
| * replacement interval occurs before the given ActionElement interval |
| */ |
| BEFORE, |
| /** |
| * replacement interval occurs after the given ActionElement interval |
| */ |
| AFTER, |
| /** |
| * replacement interval occurs within the given ActionElement interval |
| */ |
| WITHIN, |
| /** |
| * replacement interval contains the given ActionElement interval |
| */ |
| ENCOMPASS, |
| /** |
| * replacement interval starts before the given ActionElement interval and ends within the ActionElement interval |
| */ |
| PREV_OVERLAP, |
| /** |
| * replacement interval starts within the given ActionElement interval and ends after the ActionElement interval |
| */ |
| POST_OVERLAP, |
| /** |
| * Default Value, do nothing |
| */ |
| DEFAULT |
| } |
| |
| public class ActionElement{ |
| public int start; |
| public int end; |
| public String startTag; |
| public String endTag; |
| |
| public ActionElement(int start, int end, String startTag, String endTag) { |
| this.start= start; |
| this.end= end; |
| this.startTag= startTag; |
| this.endTag= endTag; |
| } |
| |
| public ReplacementStringIntervalStatus getIntervalStatus(int replacementIntervalStart, int replacementIntervalEnd) { |
| ReplacementStringIntervalStatus intervalStatus= ReplacementStringIntervalStatus.DEFAULT; |
| int startDiff = replacementIntervalStart - this.start; |
| int endDiff = replacementIntervalEnd - this.end; |
| |
| if (this.end <= replacementIntervalStart) { |
| intervalStatus= ReplacementStringIntervalStatus.AFTER; |
| } else if (this.start >= replacementIntervalEnd) { |
| intervalStatus= ReplacementStringIntervalStatus.BEFORE; |
| } else if (startDiff <= 0 && endDiff >= 0) { |
| intervalStatus= ReplacementStringIntervalStatus.ENCOMPASS; |
| } else if (startDiff > 0 && endDiff < 0) { |
| intervalStatus= ReplacementStringIntervalStatus.WITHIN; |
| } else if (startDiff > 0) { |
| intervalStatus= ReplacementStringIntervalStatus.POST_OVERLAP; |
| } else if (endDiff < 0) { |
| intervalStatus= ReplacementStringIntervalStatus.PREV_OVERLAP; |
| } |
| |
| return intervalStatus; |
| } |
| |
| } |
| |
| public class StringItem{ |
| public int index; |
| public String tag; |
| public StringItem(int index, String tag) { |
| this.index= index; |
| this.tag= tag; |
| } |
| } |
| |
| public JavaDocSnippetStringEvaluator(IJavaElement element) { |
| this.fElement= element; |
| } |
| |
| public void AddTagElementString(TagElement snippetTag, StringBuffer buffer) { |
| if (snippetTag != null) { |
| List<Object> fragments = snippetTag.fragments(); |
| for( Object fragment : fragments) { |
| String str= ""; //$NON-NLS-1$ |
| if (fragment instanceof TextElement) { |
| TextElement textElement= (TextElement) fragment; |
| List<TagElement> tagElements= getTagElementsForTextElement(snippetTag, textElement); |
| str = getModifiedString(textElement, tagElements); |
| } else if (fragment instanceof JavaDocRegion) { |
| JavaDocRegion region = (JavaDocRegion) fragment; |
| if (region.isDummyRegion()) { |
| List<TagElement> tagElements= getTagElementsForDummyJavaDocRegion(snippetTag, region); |
| str = getModifiedString(region, tagElements); |
| } |
| } else if (fragment instanceof TagElement) { |
| TagElement tagElement= (TagElement) fragment; |
| List<TagElement> tagElements= getTagElementsForTagElement(snippetTag, tagElement); |
| str = getModifiedString(tagElement, tagElements); |
| } |
| buffer.append(str); |
| } |
| } |
| } |
| |
| private String getModifiedString(TextElement textElement, List<TagElement> tags) { |
| return getModifiedString(textElement.getText(), tags); |
| } |
| |
| private String getModifiedString(TagElement tagElement, List<TagElement> tags) { |
| return getModifiedString(((TextElement)tagElement.fragments().get(0)).getText(), tags); |
| } |
| |
| private String getModifiedString(JavaDocRegion region, List<TagElement> tags) { |
| return getModifiedString(((TextElement)region.fragments().get(0)).getText(), tags); |
| } |
| |
| private String getModifiedString(String str, List<TagElement> tags) { |
| List<ActionElement> actionElements= new ArrayList<>(); |
| String modifiedStr= str; |
| for (TagElement tag : tags) { |
| String name= tag.getTagName(); |
| if (TagElement.TAG_HIGHLIGHT.equals(name)) { |
| handleSnippetHighlight(modifiedStr, tag, actionElements); |
| } else if (TagElement.TAG_REPLACE.equals(name)) { |
| modifiedStr= handleSnippetReplace(modifiedStr, tag, actionElements); |
| } else if (TagElement.TAG_LINK.equals(name)) { |
| handleSnippetLink(modifiedStr, tag, actionElements); |
| } |
| } |
| return getString( modifiedStr, actionElements); |
| } |
| |
| private String getString(String str, List<ActionElement> actionElements) { |
| String modifiedStr = str; |
| List<StringItem> items= new ArrayList<>(); |
| for (ActionElement actElem : actionElements) { |
| StringItem startItem = new StringItem(actElem.start, actElem.startTag); |
| StringItem endItem = new StringItem(actElem.end, actElem.endTag); |
| ListIterator<StringItem> iterator = items.listIterator(); |
| boolean endIndexAdded = false; |
| boolean startIndexAdded = false; |
| while (iterator.hasNext()) { |
| StringItem elem= iterator.next(); |
| if (!endIndexAdded && elem.index < endItem.index) { |
| iterator.previous(); |
| iterator.add(endItem); |
| endIndexAdded = true; |
| iterator.next(); |
| } |
| if (!startIndexAdded && elem.index < startItem.index) { |
| iterator.previous(); |
| iterator.add(startItem); |
| startIndexAdded = true; |
| iterator.next(); |
| } |
| if (startIndexAdded && endIndexAdded) { |
| break; |
| } |
| } |
| if (!endIndexAdded) { |
| items.add(endItem); |
| } |
| if (!startIndexAdded) { |
| items.add(startItem); |
| } |
| } |
| for (StringItem item : items) { |
| modifiedStr = modifiedStr.substring(0, item.index) + item.tag + modifiedStr.substring(item.index); |
| } |
| return modifiedStr; |
| } |
| |
| private void modifyPrevActionItemsReplacement(int replacementIntervalStart, int relacementIntervalEnd, int replacementStrNewLength, List<ActionElement> actionElements) { |
| ListIterator<ActionElement> iterator = actionElements.listIterator(); |
| int oldLength = relacementIntervalEnd - replacementIntervalStart; |
| int diff = replacementStrNewLength - oldLength; |
| while (iterator.hasNext()) { |
| ActionElement elem= iterator.next(); |
| ReplacementStringIntervalStatus intervalStatus= elem.getIntervalStatus(replacementIntervalStart, relacementIntervalEnd); |
| switch(intervalStatus) { |
| case AFTER: |
| //do nothing., nothing needs to be done here |
| break; |
| case BEFORE: |
| if (diff != 0) { |
| elem.start+= diff; |
| elem.end+= diff; |
| } |
| break; |
| case ENCOMPASS: |
| iterator.remove(); |
| break; |
| case POST_OVERLAP: |
| elem.end= replacementIntervalStart; |
| break; |
| case PREV_OVERLAP: |
| elem.end += diff; |
| elem.start = relacementIntervalEnd + diff; |
| break; |
| case WITHIN: |
| // modify the old ActionElement to end before the replacement string start |
| // Create a new Element element to start from the replacement string end |
| int newEnd = elem.end + diff; |
| elem.end= replacementIntervalStart; |
| int newStart = relacementIntervalEnd + diff; |
| ActionElement newElem= new ActionElement(newStart, newEnd, elem.startTag, elem.endTag); |
| iterator.add(newElem); |
| break; |
| case DEFAULT: |
| default: |
| break; |
| } |
| } |
| } |
| |
| private List<TagElement> getTagElementsForTextElement(TagElement snippetTag, TextElement textElement) { |
| List<TagElement> tagElements= new ArrayList<>(); |
| List<JavaDocRegion> regions= snippetTag.tagRegionsStartingAtTextElement(textElement); |
| List<JavaDocRegion> masterList= snippetTag.tagRegionsContainingTextElement(textElement); |
| masterList.removeAll(regions); |
| for (JavaDocRegion region : masterList) { |
| for (Object tagObj : region.tags()) { |
| tagElements.add((TagElement) tagObj); |
| } |
| } |
| for (JavaDocRegion region : regions) { |
| for (Object tagObj : region.tags()) { |
| if (tagObj instanceof TagElement) { |
| TagElement tagElem= (TagElement) tagObj; |
| Object prop= tagElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop instanceof Integer) { |
| int val = ((Integer)prop).intValue(); |
| ListIterator<TagElement> listIterator= tagElements.listIterator(); |
| TagElement addBefore= null; |
| while (listIterator.hasNext()) { |
| TagElement tElem= listIterator.next(); |
| Object prop2= tElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop2 instanceof Integer) { |
| int val2 = ((Integer)prop2).intValue(); |
| if (val2 > val) { |
| addBefore= tElem; |
| break; |
| } |
| } |
| } |
| if (addBefore == null) { |
| tagElements.add(tagElem); |
| } else { |
| tagElements.add(tagElements.indexOf(addBefore), tagElem); |
| } |
| } |
| } |
| } |
| } |
| return tagElements; |
| } |
| |
| private List<TagElement> getTagElementsForDummyJavaDocRegion(TagElement snippetTag, JavaDocRegion javaDocRegion) { |
| List<TagElement> tagElements= new ArrayList<>(); |
| TextElement textElement= (TextElement) javaDocRegion.fragments().get(0); |
| List<JavaDocRegion> regions= snippetTag.tagRegionsStartingAtTextElement(textElement); |
| List<JavaDocRegion> masterList= snippetTag.tagRegionsContainingTextElement(textElement); |
| masterList.removeAll(regions); |
| for (JavaDocRegion region : masterList) { |
| for (Object tagObj : region.tags()) { |
| tagElements.add((TagElement) tagObj); |
| } |
| } |
| regions.add(javaDocRegion); |
| for (JavaDocRegion region : regions) { |
| for (Object tagObj : region.tags()) { |
| if (tagObj instanceof TagElement) { |
| TagElement tagElem= (TagElement) tagObj; |
| Object prop= tagElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop instanceof Integer) { |
| int val = ((Integer)prop).intValue(); |
| ListIterator<TagElement> listIterator= tagElements.listIterator(); |
| TagElement addBefore= null; |
| while (listIterator.hasNext()) { |
| TagElement tElem= listIterator.next(); |
| Object prop2= tElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop2 instanceof Integer) { |
| int val2 = ((Integer)prop2).intValue(); |
| if (val2 > val) { |
| addBefore= tElem; |
| break; |
| } |
| } |
| } |
| if (addBefore == null) { |
| tagElements.add(tagElem); |
| } else { |
| tagElements.add(tagElements.indexOf(addBefore), tagElem); |
| } |
| } |
| } |
| } |
| } |
| |
| return tagElements; |
| } |
| |
| private List<TagElement> getTagElementsForTagElement(TagElement snippetTag, TagElement tag) { |
| List<TagElement> tagElements= new ArrayList<>(); |
| TextElement textElement= (TextElement) tag.fragments().get(0); |
| List<JavaDocRegion> regions= snippetTag.tagRegionsStartingAtTextElement(textElement); |
| List<JavaDocRegion> masterList= snippetTag.tagRegionsContainingTextElement(textElement); |
| masterList.removeAll(regions); |
| for (JavaDocRegion region : masterList) { |
| for (Object tagObj : region.tags()) { |
| tagElements.add((TagElement) tagObj); |
| } |
| } |
| for (JavaDocRegion region : regions) { |
| for (Object tagObj : region.tags()) { |
| if (tagObj instanceof TagElement) { |
| TagElement tagElem= (TagElement) tagObj; |
| Object prop= tagElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop instanceof Integer) { |
| int val = ((Integer)prop).intValue(); |
| ListIterator<TagElement> listIterator= tagElements.listIterator(); |
| TagElement addBefore= null; |
| while (listIterator.hasNext()) { |
| TagElement tElem= listIterator.next(); |
| Object prop2= tElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop2 instanceof Integer) { |
| int val2 = ((Integer)prop).intValue(); |
| if (val2 > val) { |
| addBefore= tElem; |
| break; |
| } |
| } |
| } |
| if (addBefore == null) { |
| tagElements.add(tagElem); |
| } else { |
| tagElements.add(tagElements.indexOf(addBefore), tagElem); |
| } |
| } |
| } |
| } |
| } |
| Object prop3= tag.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop3 instanceof Integer) { |
| int val = ((Integer)prop3).intValue(); |
| ListIterator<TagElement> listIterator= tagElements.listIterator(); |
| TagElement addBefore= null; |
| while (listIterator.hasNext()) { |
| TagElement tElem= listIterator.next(); |
| Object prop2= tElem.getProperty(TagProperty.TAG_PROPERTY_SNIPPET_INLINE_TAG_COUNT); |
| if (prop2 instanceof Integer) { |
| int val2 = ((Integer)prop2).intValue(); |
| if (val2 > val) { |
| addBefore= tElem; |
| break; |
| } |
| } |
| } |
| if (addBefore == null) { |
| tagElements.add(tag); |
| } else { |
| tagElements.add(tagElements.indexOf(addBefore), tag); |
| } |
| } |
| return tagElements; |
| } |
| |
| private void handleSnippetHighlight(String text, TagElement tagElement, List<ActionElement> actionElements) { |
| try { |
| List<? extends TagProperty> tagProperties= tagElement.tagProperties(); |
| String defHighlight= getHighlightHtmlTag(tagProperties); |
| String startDefHighlight = '<' + defHighlight + '>'; |
| String endDefHighlight = "</" + defHighlight + '>'; //$NON-NLS-1$ |
| String regExValue = getPropertyValue("regex", tagProperties); //$NON-NLS-1$ |
| String subStringValue = getPropertyValue("substring", tagProperties); //$NON-NLS-1$ |
| Pattern regexPattern = null; |
| if (regExValue != null) { |
| regexPattern = Pattern.compile(regExValue); |
| } |
| if (regexPattern != null) { |
| Matcher matcher = regexPattern.matcher(text); |
| while (matcher.find()) { |
| actionElements.add(new ActionElement(matcher.start(), matcher.end(), startDefHighlight, endDefHighlight)); |
| } |
| } else if (subStringValue != null) { |
| int startIndex = 0; |
| while ((startIndex = text.indexOf(subStringValue, startIndex)) != -1) { |
| actionElements.add(new ActionElement(startIndex, startIndex + subStringValue.length(), startDefHighlight, endDefHighlight)); |
| startIndex += subStringValue.length(); |
| } |
| } else { |
| actionElements.add(new ActionElement(0, text.length(), startDefHighlight, endDefHighlight)); |
| } |
| return; |
| } catch (PatternSyntaxException e) { |
| // do nothing |
| } |
| return; |
| } |
| |
| private String handleSnippetReplace(String text, TagElement tagElement, List<ActionElement> actionElements) { |
| try { |
| List<? extends TagProperty> tagProperties= tagElement.tagProperties(); |
| String regExValue = getPropertyValue("regex", tagProperties); //$NON-NLS-1$ |
| String subStringValue = getPropertyValue("substring", tagProperties); //$NON-NLS-1$ |
| String substitution = getPropertyValue("replacement", tagProperties); //$NON-NLS-1$ |
| Pattern regexPattern = null; |
| if (regExValue != null) { |
| regexPattern = Pattern.compile(regExValue); |
| } |
| String modifiedText = text; |
| if (regexPattern != null) { |
| Matcher matcher = regexPattern.matcher(modifiedText); |
| StringBuilder strBuild= new StringBuilder(); |
| int finalMatchIndex = 0; |
| while (matcher.find()) { |
| finalMatchIndex = matcher.end(); |
| modifyPrevActionItemsReplacement(matcher.start(), matcher.end(), substitution.length(), actionElements); |
| matcher.appendReplacement(strBuild, substitution); |
| } |
| modifiedText = strBuild.toString() + modifiedText.substring(finalMatchIndex); |
| } else if (subStringValue != null) { |
| int startIndex = 0; |
| while ((startIndex = modifiedText.indexOf(subStringValue, startIndex)) != -1) { |
| modifyPrevActionItemsReplacement(startIndex, startIndex+ subStringValue.length(), substitution.length(), actionElements); |
| modifiedText = modifiedText.substring(0, startIndex) + substitution + modifiedText.substring(startIndex + subStringValue.length()); |
| startIndex += substitution.length() ; |
| } |
| } else { |
| actionElements.clear(); |
| modifiedText = substitution; |
| } |
| return modifiedText; |
| } catch (PatternSyntaxException e) { |
| // do nothing |
| } |
| return text; |
| } |
| |
| |
| private void handleSnippetLink(String text, TagElement tagElement, List<ActionElement> actionElements) { |
| try { |
| List<? extends TagProperty> tagProperties= tagElement.tagProperties(); |
| String regExValue = getPropertyValue("regex", tagProperties); //$NON-NLS-1$ |
| String subStringValue = getPropertyValue("substring", tagProperties); //$NON-NLS-1$ |
| String additionalStartTag= getLinkHtmlTag(tagProperties); |
| String additionalEndTag= ""; //$NON-NLS-1$ |
| if (additionalStartTag.length() > 0) { |
| additionalEndTag= "</" + additionalStartTag + '>'; //$NON-NLS-1$ |
| additionalStartTag= '<' + additionalStartTag + '>'; |
| } |
| ASTNode target = getPropertyNodeValue("target", tagProperties); //$NON-NLS-1$ |
| String linkRefTxt = getLinkRef(target); |
| String startDefLink = linkRefTxt + additionalStartTag; |
| String endDefLink = additionalEndTag+"</a>"; //$NON-NLS-1$ |
| Pattern regexPattern = null; |
| if (regExValue != null) { |
| regexPattern = Pattern.compile(regExValue); |
| } |
| String modifiedText = text; |
| if (regexPattern != null) { |
| Matcher matcher = regexPattern.matcher(modifiedText); |
| while (matcher.find()) { |
| actionElements.add(new ActionElement(matcher.start(), matcher.end(), startDefLink, endDefLink)); |
| } |
| } else if (subStringValue != null) { |
| int startIndex = 0; |
| while ((startIndex = modifiedText.indexOf(subStringValue, startIndex)) != -1) { |
| actionElements.add(new ActionElement(startIndex, startIndex+ subStringValue.length(), startDefLink, endDefLink)); |
| startIndex = startIndex+ subStringValue.length() ; |
| } |
| } else { |
| String subText = modifiedText.trim(); |
| if (subText.length() < text.length()) { |
| int startIndex = text.indexOf(subText); |
| actionElements.add(new ActionElement(startIndex, startIndex + subText.length(), startDefLink, endDefLink)); |
| } |
| } |
| return; |
| } catch (PatternSyntaxException e) { |
| // do nothing |
| } |
| return; |
| } |
| |
| private String getLinkRef(ASTNode node) { |
| String str= ""; //$NON-NLS-1$ |
| String refTypeName= null; |
| String refMemberName= null; |
| String[] refMethodParamTypes= null; |
| String[] refMethodParamNames= null; |
| if (node instanceof Name) { |
| Name name = (Name) node; |
| refTypeName= name.getFullyQualifiedName(); |
| } else if (node instanceof MemberRef) { |
| MemberRef memberRef= (MemberRef) node; |
| Name qualifier= memberRef.getQualifier(); |
| refTypeName= qualifier == null ? "" : qualifier.getFullyQualifiedName(); //$NON-NLS-1$ |
| refMemberName= memberRef.getName().getIdentifier(); |
| } else if (node instanceof MethodRef) { |
| MethodRef methodRef= (MethodRef) node; |
| Name qualifier= methodRef.getQualifier(); |
| refTypeName= qualifier == null ? "" : qualifier.getFullyQualifiedName(); //$NON-NLS-1$ |
| refMemberName= methodRef.getName().getIdentifier(); |
| List<MethodRefParameter> params= methodRef.parameters(); |
| int ps= params.size(); |
| refMethodParamTypes= new String[ps]; |
| refMethodParamNames= new String[ps]; |
| for (int i= 0; i < ps; i++) { |
| MethodRefParameter param= params.get(i); |
| refMethodParamTypes[i]= ASTNodes.asString(param.getType()); |
| SimpleName paramName= param.getName(); |
| if (paramName != null) |
| refMethodParamNames[i]= paramName.getIdentifier(); |
| } |
| } |
| |
| if (refTypeName != null) { |
| str +="<a href='"; //$NON-NLS-1$ |
| try { |
| String scheme= JavaElementLinks.JAVADOC_SCHEME; |
| String uri= JavaElementLinks.createURI(scheme, fElement, refTypeName, refMemberName, refMethodParamTypes); |
| str += uri; |
| } catch (URISyntaxException e) { |
| JavaPlugin.log(e); |
| } |
| str += "'>"; //$NON-NLS-1$ |
| } |
| return str; |
| } |
| |
| private String getLinkHtmlTag(List<? extends ASTNode> tagProperties) { |
| String defaultTag= "code"; //$NON-NLS-1$ |
| if (tagProperties != null) { |
| for (ASTNode node : tagProperties) { |
| if (node instanceof TagProperty) { |
| TagProperty tagProp = (TagProperty) node; |
| if ("type".equals(tagProp.getName())) { //$NON-NLS-1$ |
| String tagValue = tagProp.getStringValue(); |
| switch (tagValue) { |
| case "linkplain" : //$NON-NLS-1$ |
| defaultTag= ""; //$NON-NLS-1$ |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| } |
| } |
| } |
| return defaultTag; |
| } |
| |
| private String getPropertyValue(String property, List<? extends ASTNode> tagProperties) { |
| String defaultTag= null; |
| if (tagProperties != null && property!= null) { |
| for (ASTNode node : tagProperties) { |
| if (node instanceof TagProperty) { |
| TagProperty tagProp = (TagProperty) node; |
| if (property.equals(tagProp.getName())) { |
| defaultTag= tagProp.getStringValue(); |
| break; |
| } |
| } |
| } |
| } |
| return defaultTag; |
| } |
| private ASTNode getPropertyNodeValue(String property, List<? extends ASTNode> tagProperties) { |
| ASTNode defaultTag= null; |
| if (tagProperties != null && property!= null) { |
| for (ASTNode node : tagProperties) { |
| if (node instanceof TagProperty) { |
| TagProperty tagProp = (TagProperty) node; |
| if (property.equals(tagProp.getName())) { |
| defaultTag= tagProp.getNodeValue(); |
| break; |
| } |
| } |
| } |
| } |
| return defaultTag; |
| } |
| |
| private String getHighlightHtmlTag(List<? extends ASTNode> tagProperties) { |
| String defaultTag= "b"; //$NON-NLS-1$ |
| if (tagProperties != null) { |
| for (ASTNode node : tagProperties) { |
| if (node instanceof TagProperty) { |
| TagProperty tagProp = (TagProperty) node; |
| if ("type".equals(tagProp.getName())) { //$NON-NLS-1$ |
| String tagValue = tagProp.getStringValue(); |
| switch (tagValue) { |
| case "bold" : //$NON-NLS-1$ |
| defaultTag= "b"; //$NON-NLS-1$ |
| break; |
| case "italic" : //$NON-NLS-1$ |
| defaultTag= "i"; //$NON-NLS-1$ |
| break; |
| case "highlighted" : //$NON-NLS-1$ |
| defaultTag= "mark"; //$NON-NLS-1$ |
| break; |
| default : |
| defaultTag= ""; //$NON-NLS-1$ |
| break; |
| } |
| break; |
| } |
| } |
| } |
| } |
| return defaultTag; |
| } |
| |
| } |
