JavaAbstractAstNodeModelAdapter.java

/* license-start
 * 
 * Copyright (C) 2008 - 2013 Crispico, <http://www.crispico.com/>.
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation version 3.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details, at <http://www.gnu.org/licenses/>.
 * 
 * Contributors:
 *   Crispico - Initial API and implementation
 *
 * license-end
 */
package com.crispico.flower.mp.codesync.code.java.adapter;

import java.util.Collections;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.BodyDeclaration;
import org.eclipse.jdt.core.dom.Expression;
import org.eclipse.jdt.core.dom.IExtendedModifier;
import org.eclipse.jdt.core.dom.Javadoc;
import org.eclipse.jdt.core.dom.MarkerAnnotation;
import org.eclipse.jdt.core.dom.MemberRef;
import org.eclipse.jdt.core.dom.MethodRef;
import org.eclipse.jdt.core.dom.Modifier;
import org.eclipse.jdt.core.dom.NormalAnnotation;
import org.eclipse.jdt.core.dom.PrimitiveType;
import org.eclipse.jdt.core.dom.QualifiedName;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
import org.eclipse.jdt.core.dom.TagElement;
import org.eclipse.jdt.core.dom.TextElement;
import org.eclipse.jdt.core.dom.Type;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.core.dom.VariableDeclarationStatement;

import com.crispico.flower.mp.codesync.code.adapter.AstModelElementAdapter;
import com.crispico.flower.mp.model.astcache.code.AstCacheCodePackage;
import com.crispico.flower.mp.model.codesync.CodeSyncPackage;

/**
 * Mapped to {@link ASTNode}.
 * 
 * @author Mariana
 */
@SuppressWarnings("unchecked")
public abstract class JavaAbstractAstNodeModelAdapter extends AstModelElementAdapter {

	@Override
	public boolean hasChildren(Object modelElement) {
		return getChildren(modelElement).size() > 0;
	}

	@Override
	public Object removeFromMap(Object element, Map<Object, Object> leftOrRightMap, boolean isRight) {
		return leftOrRightMap.remove(getMatchKey(element));
	}
	
	/**
	 * Must handle all the containment features provided by <code>common</code>.
	 */
	@Override
	public Iterable<?> getContainmentFeatureIterable(Object element, Object feature, Iterable<?> correspondingIterable) {
		if (CodeSyncPackage.eINSTANCE.getCodeSyncElement_Children().equals(feature)) {
			return getChildren(element);
		}
		
		// handle modifiers here to avoid using the same code in multiple adapters
		if (AstCacheCodePackage.eINSTANCE.getModifiableElement_Modifiers().equals(feature)) {
			if (element instanceof BodyDeclaration) {
				return ((BodyDeclaration) element).modifiers();
			}
			if (element instanceof SingleVariableDeclaration) {
				return ((SingleVariableDeclaration) element).modifiers();
			}
			return Collections.emptyList();
		}
		
		return Collections.emptyList();
	}
	
	/**
	 * Must handle all the features provided by <code>common</code>, except for containment features.
	 */
	@Override
	public Object getValueFeatureValue(Object element, Object feature, Object correspondingValue) {
		if (AstCacheCodePackage.eINSTANCE.getDocumentableElement_Documentation().equals(feature)) {
			return getJavaDoc(element);
		}
		return null;
	}
	
	@Override
	public void setValueFeatureValue(Object element, Object feature, Object value) {
		if (AstCacheCodePackage.eINSTANCE.getDocumentableElement_Documentation().equals(feature)) {
			setJavaDoc(element, value);
		}
	}

	@Override
	public Object createChildOnContainmentFeature(Object element, Object feature, Object correspondingChild) {
		if (AstCacheCodePackage.eINSTANCE.getModifiableElement_Modifiers().equals(feature)) {
			if (!(element instanceof BodyDeclaration || element instanceof SingleVariableDeclaration)) {
				return null;
			} else {
				IExtendedModifier extendedModifier = null;
				
				if (correspondingChild instanceof com.crispico.flower.mp.model.astcache.code.Modifier) {
					ASTNode parent = (ASTNode) element;
					AST ast = parent.getAST();
					com.crispico.flower.mp.model.astcache.code.Modifier modifier = 
							(com.crispico.flower.mp.model.astcache.code.Modifier) correspondingChild;
					
					extendedModifier = ast.newModifier(Modifier.ModifierKeyword.fromFlagValue(modifier.getType()));
					if (parent instanceof BodyDeclaration) {
						((BodyDeclaration) parent).modifiers().add(extendedModifier);
					} else {
						((SingleVariableDeclaration) parent).modifiers().add(extendedModifier);
					}
				}
				
				if (correspondingChild instanceof com.crispico.flower.mp.model.astcache.code.Annotation) {
					ASTNode parent = (ASTNode) element;
					AST ast = parent.getAST();
					com.crispico.flower.mp.model.astcache.code.Annotation annotation = 
							(com.crispico.flower.mp.model.astcache.code.Annotation) correspondingChild;
					if (annotation.getValues().size() == 0) {
						MarkerAnnotation markerAnnotation = ast.newMarkerAnnotation();
						extendedModifier = markerAnnotation;
					}
					if (annotation.getValues().size() == 1) {
						SingleMemberAnnotation singleMemberAnnotation = ast.newSingleMemberAnnotation();
						extendedModifier = singleMemberAnnotation;
					} else {
						NormalAnnotation normalAnnotation = ast.newNormalAnnotation();
						extendedModifier = normalAnnotation;
					}
					if (parent instanceof BodyDeclaration) {
						((BodyDeclaration) parent).modifiers().add(extendedModifier);
					} else {
						((SingleVariableDeclaration) parent).modifiers().add(extendedModifier);
					}
				}
				return extendedModifier;
			}
		}
		
		return null;
	}

	@Override
	public void removeChildrenOnContainmentFeature(Object parent, Object feature, Object child) {
		((ASTNode) child).delete();
	}

	@Override
	abstract public List<?> getChildren(Object modelElement);

	@Override
	public String getLabel(Object modelElement) {
		return (String) getMatchKey(modelElement);
	}

	@Override
	public List<String> getIconUrls(Object modelElement) {
		return null;
	}
	
	@Override
	public boolean save(Object element) {
		// nothing to do, the changes to the AST will be saved when the file is saved
		return false;
	}
	
	@Override
	public boolean discard(Object element) {
		// nothing to do, the changes to the AST will be discarded when the file is discarded
		return false;
	}

	@Override
	protected void updateUID(Object element, Object correspondingElement) {
		if (element instanceof BodyDeclaration) {
			BodyDeclaration node = (BodyDeclaration) element;
			Javadoc javadoc = node.getJavadoc();
			// if it doesn't have any doc, create it
			if (javadoc == null) {
				javadoc = node.getAST().newJavadoc();
				node.setJavadoc(javadoc);
			}
			// first remove the existing flower tag, this way we also make sure that it's the last tag
			// note: if we only change the id, the rewriter won't format it correctly
			for (Object obj : javadoc.tags()) {
				if (FLOWER_UID.equals(((TagElement) obj).getTagName())) {
					javadoc.tags().remove(obj);
					break;
				}
			}
			// create new tag element for UID
			TagElement tag = javadoc.getAST().newTagElement();
			tag.setTagName(FLOWER_UID);
			javadoc.tags().add(tag);
			TextElement text = javadoc.getAST().newTextElement();
			tag.fragments().add(text);
			EObject eObject = (EObject) correspondingElement;
			text.setText(eObject.eResource().getURIFragment(eObject));
			System.out.println(javadoc);
		}
	}

	protected Object getJavaDoc(Object element) {
		if (element instanceof BodyDeclaration) {
			BodyDeclaration node = (BodyDeclaration) element;
			if (node.getJavadoc() != null) {
				String docComment = null;
				for (Object o : node.getJavadoc().tags()) {
					TagElement tag = (TagElement) o;
					String tagName = tag.getTagName();
					if (getModelAdapterFactorySet().useUIDs() && FLOWER_UID.equals(tagName)) {
						continue;
					}
					if (docComment == null) {
						docComment = new String();
					}
					if (tagName != null) {
						docComment += tag.getTagName() + " ";
					}
					for (Object o2 : tag.fragments()) {
						docComment += getTextFromDocElement(o2);
					}
					docComment += "\n";
				}
				return docComment;
			}
		}
		return null;
	}
	
	/**
	 * @param node an IDocElement
	 */
	private String getTextFromDocElement(Object node) {
		if (node instanceof MemberRef) {
			return ((MemberRef) node).getName().getIdentifier();
		}
		if (node instanceof MethodRef) {
			return ((MethodRef) node).getName().getIdentifier();
		}
		if (node instanceof SimpleName) {
			return ((SimpleName) node).getIdentifier();
		}
		if (node instanceof QualifiedName) {
			return ((QualifiedName) node).getFullyQualifiedName();
		}
		if (node instanceof TagElement) {
			return ((TagElement) node).getTagName();
		}
		if (node instanceof TextElement) {
			return ((TextElement) node).getText();
		}
		return "";
	}
	
	protected void setJavaDoc(Object element, Object docComment) {
		if (element instanceof BodyDeclaration) {
			BodyDeclaration node = (BodyDeclaration) element;
			ASTParser parser = ASTParser.newParser(AST.JLS4);
			parser.setKind(ASTParser.K_CLASS_BODY_DECLARATIONS);
			parser.setSource(("/** " + docComment + "*/ int x;").toCharArray());
			TypeDeclaration type = (TypeDeclaration) parser.createAST(null);
			BodyDeclaration x = (BodyDeclaration) type.bodyDeclarations().get(0);
			Javadoc javadoc = x.getJavadoc();
			node.setJavadoc((Javadoc) ASTNode.copySubtree(node.getAST(), javadoc));
		}
	}
	
	/**
	 * Creates an {@link Expression} from the given string, owned by the given AST. 
	 */
	protected Expression getExpressionFromString(AST ast, String expression) {
		if (expression == null) {
			return null;
		}
		ASTParser parser = ASTParser.newParser(AST.JLS4);
		parser.setKind(ASTParser.K_EXPRESSION);
		parser.setSource(expression.toCharArray());
		ASTNode node = parser.createAST(null);
		return (Expression) ASTNode.copySubtree(ast, node);
	}
	
	protected String getStringFromExpression(Expression expression) {
		if (expression == null) {
			return null;
		}
		return expression.toString();
	}
	
	/**
	 * Creates a {@link Type} from the given name, owned by the given AST.
	 */
	protected Type getTypeFromString(AST ast, String name) {
		if (name == null) {
			return ast.newPrimitiveType(PrimitiveType.VOID);
		}
		PrimitiveType.Code primitiveTypeCode = PrimitiveType.toCode(name);
		if (primitiveTypeCode != null) {
			return ast.newPrimitiveType(primitiveTypeCode);
		}
		
		ASTParser parser = ASTParser.newParser(AST.JLS4);
		parser.setKind(ASTParser.K_STATEMENTS);
		parser.setSource((name + " a;").toCharArray());
		
		Block block = (Block) parser.createAST(null);
		VariableDeclarationStatement declaration = (VariableDeclarationStatement) block.statements().get(0);
		return (Type) ASTNode.copySubtree(ast, declaration.getType());
	}
	
	protected String getStringFromType(Type type) {
		if (type == null) {
			return null;
		}
		return type.toString();
	}
	
}