Skip to content

Commit

Permalink
issue124: add LexicalDifferenceCalculatorTest
Browse files Browse the repository at this point in the history
  • Loading branch information
@ftomassetti
ftomassetti committed Feb 23, 2017
1 parent 918a2d2 commit 1259e56
Show file tree
Hide file tree
Showing 2 changed files with 57 additions and 22 deletions.
43 changes: 21 additions & 22 deletions ...n/java/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculator.java
View file
Expand Up @@ -42,20 +42,18 @@ public CalculatedSyntaxModel sub(int start, int end) {
}

public void calculatePropertyChange(NodeText nodeText, Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
// CompilationUnit
// PACKAGE_DECLARATION
// oldValue -> aPackage
CsmElement element = ConcreteSyntaxModel.forClass(observedNode.getClass());
CalculatedSyntaxModel original = calculatedSyntaxModelFor(element, observedNode);
CalculatedSyntaxModel original = calculatedSyntaxModelForNode(element, observedNode);
CalculatedSyntaxModel after = calculatedSyntaxModelAfterPropertyChange(element, observedNode, property, oldValue, newValue);
Difference difference = Difference.calculate(original, after);
System.out.println("DIFFERENCE " + difference);
//System.out.println("DIFFERENCE " + difference);
difference.apply(nodeText);
}

private CalculatedSyntaxModel calculatedSyntaxModelFor(CsmElement csm, Node node) {
List<CsmElement> elements = new LinkedList<CsmElement>();
calculatedSyntaxModelFor(csm, node, elements, new NoChange());
// Visible for testing
CalculatedSyntaxModel calculatedSyntaxModelForNode(CsmElement csm, Node node) {
List<CsmElement> elements = new LinkedList<>();
calculatedSyntaxModelForNode(csm, node, elements, new NoChange());
return new CalculatedSyntaxModel(elements);
}

Expand Down Expand Up @@ -104,10 +102,10 @@ public static boolean isWhitespace(CsmElement csmElement) {
return csmElement instanceof CsmToken && isWhitespace(((CsmToken)csmElement).getTokenType());
}

private void calculatedSyntaxModelFor(CsmElement csm, Node node, List<CsmElement> elements, Change change) {
private void calculatedSyntaxModelForNode(CsmElement csm, Node node, List<CsmElement> elements, Change change) {
if (csm instanceof CsmSequence) {
CsmSequence csmSequence = (CsmSequence) csm;
csmSequence.getElements().forEach(e -> calculatedSyntaxModelFor(e, node, elements, change));
csmSequence.getElements().forEach(e -> calculatedSyntaxModelForNode(e, node, elements, change));
} else if (csm instanceof CsmComment) {
// nothing to do
} else if (csm instanceof CsmSingleReference) {
Expand All @@ -132,28 +130,28 @@ private void calculatedSyntaxModelFor(CsmElement csm, Node node, List<CsmElement
if (csmList.getProperty().isAboutNodes()) {
NodeList nodeList = csmList.getProperty().listValueFor(node);
if (!nodeList.isEmpty()) {
calculatedSyntaxModelFor(csmList.getPreceeding(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getPreceeding(), node, elements, change);
for (int i = 0; i < nodeList.size(); i++) {
if (i != 0) {
calculatedSyntaxModelFor(csmList.getSeparatorPre(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getSeparatorPre(), node, elements, change);
}
elements.add(new CsmChild(nodeList.get(i)));
if (i != (nodeList.size() - 1)) {
calculatedSyntaxModelFor(csmList.getSeparatorPost(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getSeparatorPost(), node, elements, change);
}

}
calculatedSyntaxModelFor(csmList.getFollowing(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getFollowing(), node, elements, change);
}
} else {
Collection collection = csmList.getProperty().listPropertyFor(node);
if (!collection.isEmpty()) {
calculatedSyntaxModelFor(csmList.getPreceeding(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getPreceeding(), node, elements, change);

boolean first = true;
for (Iterator it = collection.iterator(); it.hasNext(); ) {
if (!first) {
calculatedSyntaxModelFor(csmList.getSeparatorPre(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getSeparatorPre(), node, elements, change);
};
Object value = it.next();
if (value instanceof Modifier) {
Expand All @@ -164,20 +162,20 @@ private void calculatedSyntaxModelFor(CsmElement csm, Node node, List<CsmElement
}
//findCompulsoryTokens(it.next());
if (it.hasNext()) {
calculatedSyntaxModelFor(csmList.getSeparatorPost(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getSeparatorPost(), node, elements, change);
}
first = false;
}
calculatedSyntaxModelFor(csmList.getFollowing(), node, elements, change);
calculatedSyntaxModelForNode(csmList.getFollowing(), node, elements, change);
}
}
} else if (csm instanceof CsmConditional) {
CsmConditional csmConditional = (CsmConditional) csm;
boolean satisfied = change.evaluate(csmConditional, node);
if (satisfied) {
calculatedSyntaxModelFor(csmConditional.getThenElement(), node, elements, change);
calculatedSyntaxModelForNode(csmConditional.getThenElement(), node, elements, change);
} else {
calculatedSyntaxModelFor(csmConditional.getElseElement(), node, elements, change);
calculatedSyntaxModelForNode(csmConditional.getElseElement(), node, elements, change);
}
} else if (csm instanceof CsmIndent) {
// nothing to do
Expand All @@ -197,9 +195,10 @@ private int toToken(Modifier modifier) {
}
}

private CalculatedSyntaxModel calculatedSyntaxModelAfterPropertyChange(CsmElement csm, Node node, ObservableProperty property, Object oldValue, Object newValue) {
// Visible for testing
CalculatedSyntaxModel calculatedSyntaxModelAfterPropertyChange(CsmElement csm, Node node, ObservableProperty property, Object oldValue, Object newValue) {
List<CsmElement> elements = new LinkedList<CsmElement>();
calculatedSyntaxModelFor(csm, node, elements, new PropertyChange(property, oldValue, newValue));
calculatedSyntaxModelForNode(csm, node, elements, new PropertyChange(property, oldValue, newValue));
return new CalculatedSyntaxModel(elements);
}

Expand Down
36 changes: 36 additions & 0 deletions ...va/com/github/javaparser/printer/lexicalpreservation/LexicalDifferenceCalculatorTest.java
View file
@@ -0,0 +1,36 @@
package com.github.javaparser.printer.lexicalpreservation;

import com.github.javaparser.ast.PackageDeclaration;
import com.github.javaparser.ast.expr.Name;
import com.github.javaparser.ast.observer.ObservableProperty;
import com.github.javaparser.printer.ConcreteSyntaxModel;
import com.github.javaparser.printer.concretesyntaxmodel.CsmElement;
import com.github.javaparser.printer.concretesyntaxmodel.CsmToken;
import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class LexicalDifferenceCalculatorTest extends AbstractLexicalPreservingTest {

@Test
public void compilationUnitExampleOriginal() {
considerCode("class A {}");
CsmElement element = ConcreteSyntaxModel.forClass(cu.getClass());
LexicalDifferenceCalculator.CalculatedSyntaxModel csmOriginal = new LexicalDifferenceCalculator().calculatedSyntaxModelForNode(element, cu);
assertEquals(2, csmOriginal.elements.size());
assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmOriginal.elements.get(0));
assertEquals(new CsmToken(3), csmOriginal.elements.get(1));
}

@Test
public void compilationUnitExampleWithPackageSet() {
considerCode("class A {}");
CsmElement element = ConcreteSyntaxModel.forClass(cu.getClass());
PackageDeclaration packageDeclaration = new PackageDeclaration(new Name(new Name("foo"), "bar"));
LexicalDifferenceCalculator.CalculatedSyntaxModel csmChanged = new LexicalDifferenceCalculator().calculatedSyntaxModelAfterPropertyChange(element, cu, ObservableProperty.PACKAGE_DECLARATION, null, packageDeclaration);
assertEquals(3, csmChanged.elements.size());
assertEquals(new LexicalDifferenceCalculator.CsmChild(packageDeclaration), csmChanged.elements.get(0));
assertEquals(new LexicalDifferenceCalculator.CsmChild(cu.getType(0)), csmChanged.elements.get(1));
assertEquals(new CsmToken(3), csmChanged.elements.get(2));
}
}

0 comments on commit 1259e56

Please sign in to comment.