diff --git a/core/src/main/java/mrmathami/cia/java/project/JavaProject.java b/core/src/main/java/mrmathami/cia/java/project/JavaProject.java index 190a8b7..25ed336 100644 --- a/core/src/main/java/mrmathami/cia/java/project/JavaProject.java +++ b/core/src/main/java/mrmathami/cia/java/project/JavaProject.java @@ -22,7 +22,10 @@ import mrmathami.cia.java.JavaCiaException; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; +import java.io.IOException; import java.nio.file.Path; import java.util.List; import java.util.Map; @@ -52,7 +55,7 @@ public interface JavaProject { @Nonnull JavaProjectSnapshot createSnapshot(@Nonnull String snapshotName, @Nonnull Map>> javaSources, @Nonnull List classPaths, - @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery) throws JavaCiaException; + @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery, Path configurationPath) throws JavaCiaException, ParserConfigurationException, SAXException, IOException; /** * @param comparisonName comparison name diff --git a/core/src/main/java/mrmathami/cia/java/tree/node/JavaXMLNode.java b/core/src/main/java/mrmathami/cia/java/tree/node/JavaXMLNode.java index f2a5b05..56c6dea 100644 --- a/core/src/main/java/mrmathami/cia/java/tree/node/JavaXMLNode.java +++ b/core/src/main/java/mrmathami/cia/java/tree/node/JavaXMLNode.java @@ -22,6 +22,7 @@ default JavaXMLNode asXMLNode() { return this; } + @Nonnull String getTextContent(); diff --git a/jdt/pom.xml b/jdt/pom.xml index e5d0570..5b16d7c 100644 --- a/jdt/pom.xml +++ b/jdt/pom.xml @@ -135,6 +135,31 @@ + + + org.apache.maven.plugins + maven-assembly-plugin + 3.2.0 + + + + mrmathami.cia.java.jdt.Run + + + + jar-with-dependencies + + + + + make-assembly + package + + single + + + + diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/ProjectBuilders.java b/jdt/src/main/java/mrmathami/cia/java/jdt/ProjectBuilders.java index dc29c4e..2fc23e0 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/ProjectBuilders.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/ProjectBuilders.java @@ -28,7 +28,10 @@ import mrmathami.cia.java.project.JavaProjectSnapshotComparison; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; +import java.io.IOException; import java.nio.file.Path; import java.util.List; import java.util.Map; @@ -46,8 +49,8 @@ public static JavaProject createProject(@Nonnull String name) { @Nonnull public static JavaProjectSnapshot createProjectSnapshot(@Nonnull String snapshotName, @Nonnull Map>> javaSources, @Nonnull List classPaths, - @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery) throws JavaCiaException { - return JavaSnapshotBuilder.build(snapshotName, javaSources, classPaths, dependencyWeightTable, enableRecovery); + @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery, Path configurationPath) throws JavaCiaException, ParserConfigurationException, SAXException, IOException { + return JavaSnapshotBuilder.build(snapshotName, javaSources, classPaths, dependencyWeightTable, enableRecovery, configurationPath); } @Nonnull diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/Run.java b/jdt/src/main/java/mrmathami/cia/java/jdt/Run.java new file mode 100644 index 0000000..47028dd --- /dev/null +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/Run.java @@ -0,0 +1,78 @@ +package mrmathami.cia.java.jdt; + +import mrmathami.cia.java.JavaCiaException; +import mrmathami.cia.java.project.JavaProjectSnapshot; +import mrmathami.cia.java.tree.dependency.JavaDependency; +import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; +import mrmathami.utils.Pair; +import org.xml.sax.SAXException; + +import javax.xml.parsers.ParserConfigurationException; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.DirectoryStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +public class Run { + public static final JavaDependencyWeightTable DEPENDENCY_WEIGHT_TABLE = JavaDependencyWeightTable.of(Map.of( + JavaDependency.USE, 1.0, + JavaDependency.MEMBER, 1.0, + JavaDependency.INHERITANCE, 4.0, + JavaDependency.INVOCATION, 4.0, + JavaDependency.OVERRIDE, 1.0 + )); + //private static final Path configurationPath = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\mybatis-example-1\\resources\\SqlMapConfig.xml"); + private static Path configurationPath = null; + + public static void main(String[] args) throws JavaCiaException, IOException, ParserConfigurationException, SAXException { + Path corePath = null; + String output = ""; + if (args.length < 3) { + configurationPath = Path.of(""); + corePath = Path.of(args[0]); + output = args[1]; + } else if (args.length == 3) { + configurationPath = Path.of(args[0]); + corePath = Path.of(args[1]); + output = args[2]; + } + final List coreFiles = getFileList(new ArrayList<>(), corePath); + final Map>> javaSources = Map.of( + "core", Pair.immutableOf(corePath, coreFiles) + ); + final List classPaths = List.of( + //List classPaths in here + ); + + + long timeStart = System.nanoTime(); + final JavaProjectSnapshot projectSnapshot = ProjectBuilders.createProjectSnapshot("before", + javaSources, classPaths, DEPENDENCY_WEIGHT_TABLE, true, configurationPath); + long timeParseA = System.nanoTime(); + + final String jsonA = projectSnapshot.getRootNode().toJson(); + + Files.write(Path.of(output + "output.txt"), jsonA.getBytes(StandardCharsets.UTF_8)); + + System.out.printf("Parse A time: %s\n", (timeParseA - timeStart) / 1000000.0); + } + + private static List getFileList(List fileList, Path dir) { + try (DirectoryStream stream = Files.newDirectoryStream(dir)) { + for (Path path : stream) { + if (path.toFile().isDirectory()) { + getFileList(fileList, path); + } else { + fileList.add(path); + } + } + } catch (IOException e) { + e.printStackTrace(); + } + return fileList; + } +} diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/Printer.java b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/Printer.java new file mode 100644 index 0000000..a7da0f9 --- /dev/null +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/Printer.java @@ -0,0 +1,133 @@ +package mrmathami.cia.java.jdt.gephi; + +import mrmathami.cia.java.jdt.gephi.model.EdgeGephi; +import mrmathami.cia.java.jdt.gephi.model.NodeGephi; +import mrmathami.cia.java.project.JavaNodeWeightTable; +import mrmathami.cia.java.project.JavaProject; +import mrmathami.cia.java.project.JavaProjectSnapshot; +import mrmathami.cia.java.project.JavaProjectSnapshotComparison; +import mrmathami.cia.java.tree.node.JavaNode; +import mrmathami.utils.Pair; +import org.w3c.dom.Node; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class Printer { + public String writeGephi(JavaProjectSnapshot projectSnapshot) { + List nodeList = projectSnapshot.getRootNode().getAllNodes(); + HashMap> dependencyToMap = new HashMap<>(); + for (JavaNode node : nodeList) { + Set dependencyToNodes = node.getDependencyToNodes(); + dependencyToMap.put(node, dependencyToNodes); + } + List nodeGephiList = new ArrayList<>(); + List edgeGephiList = new ArrayList<>(); + int count = 0; + for (Map.Entry> entry : dependencyToMap.entrySet()) { + NodeGephi nodeGephi = new NodeGephi(entry.getKey().getId(), entry.getKey().getNodeName(), NodeGephi.Type.UNCHANGE); + nodeGephiList.add(nodeGephi); + Set value = entry.getValue(); + for (JavaNode javaNode : value) { + EdgeGephi edgeGephi = new EdgeGephi(count, entry.getKey().getId(), javaNode.getId()); + count++; + edgeGephiList.add(edgeGephi); + } + } + + final String open = "\n" + + "" + + "\n\n"; + + String listNode = writeListNodes(nodeGephiList); + String listEdge = writeListEdges(edgeGephiList); + + return open + listNode + listEdge + "\n\n" + ""; + } + public String writeGephiComparison(JavaProjectSnapshotComparison comparison) { + final Set addedNodes = comparison.getAddedNodes(); + final Set> changedNodes = comparison.getChangedNodes(); + final Set removedNodes = comparison.getRemovedNodes(); + final Set> unchangedNodes = comparison.getUnchangedNodes(); + + HashMap> dependencyToMap = new HashMap<>(); + final List allNodes = comparison.getCurrentSnapshot().getRootNode().getAllNodes(); + final JavaNodeWeightTable nodeImpactTable = comparison.getNodeImpactTable(); + + for (JavaNode node : allNodes) { + final Set dependencyToNodes = node.getDependencyToNodes(); + dependencyToMap.put(node, dependencyToNodes); + } + List nodeGephiList = new ArrayList<>(); + List edgeGephiList = new ArrayList<>(); + int count = 0; + for (Map.Entry> entry : dependencyToMap.entrySet()) { + NodeGephi nodeGephi = null; + if (addedNodes.contains(entry.getKey())) { + nodeGephi = new NodeGephi(entry.getKey().getId(), entry.getKey().getNodeName() + " weight: " + nodeImpactTable.getWeight(entry.getKey()), NodeGephi.Type.ADD); + } + + for (Pair pair : changedNodes) { + final JavaNode pairB = pair.getB(); + if (entry.getKey() == pairB) { + nodeGephi = new NodeGephi(pairB.getId(), pairB.getNodeName() + " weight: " + nodeImpactTable.getWeight(pairB), NodeGephi.Type.CHANGE); + } + } + for (Pair pair : unchangedNodes) { + final JavaNode pairB = pair.getB(); + if (entry.getKey() == pairB) { + nodeGephi = new NodeGephi(pairB.getId(), pairB.getNodeName() + " weight: " + nodeImpactTable.getWeight(pairB), NodeGephi.Type.UNCHANGE); + } + } + nodeGephiList.add(nodeGephi); + final Set value = entry.getValue(); + for (JavaNode javaNode : value) { + EdgeGephi edgeGephi = new EdgeGephi(count, entry.getKey().getId(), javaNode.getId()); + count++; + edgeGephiList.add(edgeGephi); + } + } + + for (JavaNode node : removedNodes) { + NodeGephi nodeGephi = new NodeGephi(node.getId() + nodeGephiList.size(), node.getNodeName(), NodeGephi.Type.DELETE); + final Set dependencyToNodes = node.getDependencyToNodes(); + for (JavaNode javaNode : dependencyToNodes) { + EdgeGephi edgeGephi = new EdgeGephi(count, node.getId() + nodeGephiList.size(), javaNode.getId()); + count++; + edgeGephiList.add(edgeGephi); + } + nodeGephiList.add(nodeGephi); + } + + final String open = "\n" + + "" + + "\n\n"; + + String listNode = writeListNodes(nodeGephiList); + String listEdge = writeListEdges(edgeGephiList); + + return open + listNode + listEdge + "\n\n" + ""; + } + + public String writeListNodes(List nodeGephiList) { + StringBuilder result = new StringBuilder("\t"); + for (NodeGephi node : nodeGephiList) { + result.append("\n\t\t").append(node.toString()); + } + result.append("\n\t"); + return result.toString(); + } + + public String writeListEdges(List edgeGephiList) { + StringBuilder result = new StringBuilder("\n\t"); + for (EdgeGephi node : edgeGephiList) { + result.append("\n\t\t").append(node.toString()); + } + result.append("\n\t"); + return result.toString(); + } + +} diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/EdgeGephi.java b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/EdgeGephi.java new file mode 100644 index 0000000..7f9ce14 --- /dev/null +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/EdgeGephi.java @@ -0,0 +1,24 @@ +package mrmathami.cia.java.jdt.gephi.model; + +public class EdgeGephi { + private int id; + private int source; + private int target; + + public EdgeGephi(int id, int source, int target) { + this.id = id; + this.source = source; + this.target = target; + } + + @Override + public String toString() { + return "" + + "\n\t\t\t" + "" + + "\n\t\t"; + } +} diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/NodeGephi.java b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/NodeGephi.java new file mode 100644 index 0000000..cf7b73e --- /dev/null +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/gephi/model/NodeGephi.java @@ -0,0 +1,50 @@ +package mrmathami.cia.java.jdt.gephi.model; + +public class NodeGephi { + public enum Type { + UNCHANGE(115, 115, 115),//charcoal blue + DELETE(255, 0, 0),//red + CHANGE(255, 255, 0),//yellow + ADD(0, 255, 153);//light green + + private final int r; + private final int g; + private final int b; + + Type(int r, int g, int b) { + this.r = r; + this.g = g; + this.b = b; + } + } + + private final int id; + private final String label; + private final String size = ""; + private final Type type; + + public NodeGephi(int id, String label, Type type) { + this.id = id; + this.label = label; + this.type = type; + } + + @Override + public String toString() { + return "' + + "\n\t\t\t" + size + + toStringType(type) + + "\n\t\t"; + } + + private String toStringType(Type type) { + return "\n\t\t\t"; + } +} diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/Project.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/Project.java index c1efec6..e7ec864 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/Project.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/Project.java @@ -27,7 +27,10 @@ import mrmathami.cia.java.project.JavaProjectSnapshotComparison; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; +import java.io.IOException; import java.io.Serializable; import java.nio.file.Path; import java.util.Collections; @@ -82,9 +85,9 @@ public List getSnapshotComparisons() { @Override public JavaProjectSnapshot createSnapshot(@Nonnull String snapshotName, @Nonnull Map>> javaSources, @Nonnull List classPaths, - @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery) throws JavaCiaException { + @Nonnull JavaDependencyWeightTable dependencyWeightTable, boolean enableRecovery, Path configurationPath) throws JavaCiaException, ParserConfigurationException, SAXException, IOException { final ProjectSnapshot snapshot = JavaSnapshotBuilder.build( - snapshotName, javaSources, classPaths, dependencyWeightTable, enableRecovery); + snapshotName, javaSources, classPaths, dependencyWeightTable, enableRecovery, configurationPath); snapshots.add(snapshot); return snapshot; } diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/ProjectSnapshotComparison.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/ProjectSnapshotComparison.java index 96d7aff..f232909 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/ProjectSnapshotComparison.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/ProjectSnapshotComparison.java @@ -50,7 +50,8 @@ public final class ProjectSnapshotComparison implements JavaProjectSnapshotCompa public ProjectSnapshotComparison(@Nonnull String name, @Nonnull JavaProjectSnapshot previousSnapshot, @Nonnull JavaProjectSnapshot currentSnapshot, - @Nonnull Set removedNodes, @Nonnull Set addedNodes, + @Nonnull Set removedNodes, + @Nonnull Set addedNodes, @Nonnull Set> changedNodes, @Nonnull Set> unchangedNodes, @Nonnull double[] dependencyImpacts, @Nonnull double[] nodeImpacts) { diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaNodes.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaNodes.java index 9bd8a72..5ac117c 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaNodes.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaNodes.java @@ -15,7 +15,6 @@ import mrmathami.cia.java.tree.node.container.JavaInterfaceContainer; import mrmathami.cia.java.tree.node.container.JavaMethodContainer; import mrmathami.utils.Pair; -import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.dom.*; import org.eclipse.jdt.core.formatter.CodeFormatter; import org.eclipse.jface.text.BadLocationException; @@ -23,18 +22,23 @@ import org.eclipse.jface.text.IDocument; import org.eclipse.text.edits.MalformedTreeException; import org.eclipse.text.edits.TextEdit; +import org.w3c.dom.NamedNodeMap; import org.w3c.dom.Node; import org.w3c.dom.traversal.DocumentTraversal; import org.w3c.dom.traversal.NodeFilter; import org.w3c.dom.traversal.TreeWalker; +import java.io.File; +import java.nio.file.Path; import java.util.ArrayList; +import java.util.Arrays; import java.util.HashMap; import java.util.IdentityHashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; +import java.util.regex.Pattern; final class JavaNodes { @@ -44,8 +48,6 @@ final class JavaNodes { @Nonnull private final JavaDependencies dependencies = new JavaDependencies(); @Nonnull private final JavaAnnotates annotates = new JavaAnnotates(dependencies); @Nonnull private final JavaTypes types = new JavaTypes(dependencies, annotates); - - @Nonnull private final RootNode rootNode = new RootNode(); @Nonnull private final Map> packageNodeMap = new HashMap<>(); @@ -59,6 +61,7 @@ final class JavaNodes { @Nonnull private final List> delayedDependencyWalkers = new LinkedList<>(); @Nullable private Set perFileNodeSet; + private Map> mapXMlDependency; JavaNodes(@Nonnull CodeFormatter formatter, boolean enableRecovery) { @@ -66,9 +69,10 @@ final class JavaNodes { this.enableRecovery = enableRecovery; } - void build(@Nonnull Set perFileNodeSet, @Nonnull CompilationUnit compilationUnit) + void build(@Nonnull Set perFileNodeSet, @Nonnull CompilationUnit compilationUnit, Map> mapXMlDependency) throws JavaCiaException { this.perFileNodeSet = perFileNodeSet; + this.mapXMlDependency = mapXMlDependency; final PackageDeclaration packageDeclaration = compilationUnit.getPackage(); if (packageDeclaration != null) { @@ -86,11 +90,11 @@ void build(@Nonnull Set perFileNodeSet, @Nonnull CompilationUnit c } } } - this.perFileNodeSet = null; } - void build(@Nonnull Set perFileNodeSet, @Nonnull org.w3c.dom.Document document, String pathFile) throws JavaCiaException { + //for xml file in src + void build(@Nonnull Set perFileNodeSet, @Nonnull org.w3c.dom.Document document, String pathFile) { this.perFileNodeSet = perFileNodeSet; DocumentTraversal traversal = (DocumentTraversal) document; PackageNode packageNode = createPackageNodeFromPath(pathFile); @@ -109,7 +113,7 @@ void build(@Nonnull Set perFileNodeSet, @Nonnull org.w3c.dom.Docum this.perFileNodeSet = null; } - private static void traverseLevel(TreeWalker walker, XMLNode parent, boolean isFirstChild) { + private void traverseLevel(TreeWalker walker, XMLNode parent, boolean isFirstChild) { Node currentNode = walker.getCurrentNode(); if (!isFirstChild) { for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { @@ -117,6 +121,7 @@ private static void traverseLevel(TreeWalker walker, XMLNode parent, boolean isF } } else { XMLNode xmlNode = parent.createChildXMlNode(currentNode.getNodeName(), currentNode.getTextContent(), currentNode.getChildNodes(), currentNode.getAttributes()); + dependencies.createDependencyToNode(parent, xmlNode, JavaDependency.MEMBER); for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { traverseLevel(walker, xmlNode, true); } @@ -124,6 +129,218 @@ private static void traverseLevel(TreeWalker walker, XMLNode parent, boolean isF walker.setCurrentNode(currentNode); } + //for mapper file + void build(@Nonnull Set perFileNodeSet, @Nonnull org.w3c.dom.Document document, String pathFile, Map> mapXMlDependency) { + this.perFileNodeSet = perFileNodeSet; + + DocumentTraversal traversal = (DocumentTraversal) document; + PackageNode packageNode = createPackageNodeFromPath(pathFile); + + TreeWalker walker = traversal.createTreeWalker(document.getDocumentElement(), + NodeFilter.SHOW_ELEMENT, null, true); + + XMLNode rootNode = packageNode.createChildXMlNode(document.getDocumentElement().getNodeName(), document.getDocumentElement().getTextContent(), document.getDocumentElement().getChildNodes(), + document.getDocumentElement().getAttributes()); + + String namespace = document.getDocumentElement().getAttribute("namespace"); + if (namespace.contains(".")) { + putInMap(mapXMlDependency, namespace, rootNode); + traverseLevel(walker, rootNode, false, mapXMlDependency); + } else { + traverseLevel(walker, rootNode, false, mapXMlDependency, namespace); + } + + dependencies.createDependencyToNode(packageNode, rootNode, JavaDependency.MEMBER); + perFileNodeSet.add(rootNode); + + if (mapXMlDependency.containsKey(pathFile)) { + for (int i = 0; i < mapXMlDependency.get(pathFile).size(); i++) { + dependencies.createDependencyToNode(mapXMlDependency.get(pathFile).get(i), rootNode, JavaDependency.USE); + } + } + this.perFileNodeSet = null; + } + + private void traverseLevel(TreeWalker walker, XMLNode parent, boolean isFirstChild, Map> mapXMlDependency) { + Node currentNode = walker.getCurrentNode(); + if (!isFirstChild) { + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, parent, true, mapXMlDependency); + } + } else { + XMLNode xmlNode = parent.createChildXMlNode(currentNode.getNodeName(), currentNode.getTextContent(), currentNode.getChildNodes(), currentNode.getAttributes()); + dependencies.createDependencyToNode(parent, xmlNode, JavaDependency.MEMBER); + NamedNodeMap listAttributes = xmlNode.getAttributes(); + if (xmlNode.getNodeName().equals("select")) { + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("resultMap")) { + putInMap(mapXMlDependency, listAttributes.item(i).getNodeValue(), xmlNode); + } + } + } + if (xmlNode.getNodeName().equals("resultMap")) { + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("id")) { + String key = listAttributes.item(i).getNodeValue(); + if (mapXMlDependency.containsKey(key)) { + for (int j = 0; j < mapXMlDependency.get(key).size(); j++) { + dependencies.createDependencyToNode(mapXMlDependency.get(key).get(j), xmlNode, JavaDependency.USE); + } + } + } + } + } + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("parameterType") || listAttributes.item(i).getNodeName().equals("resultType")) { + String key = listAttributes.item(i).getNodeValue(); + if (mapXMlDependency.containsKey(key)) { + for (int j = 0; j < mapXMlDependency.get(key).size(); j++) { + dependencies.createDependencyToNode(xmlNode, mapXMlDependency.get(key).get(j), JavaDependency.USE); + } + } + } + } + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, xmlNode, true, mapXMlDependency); + } + } + walker.setCurrentNode(currentNode); + } + + private void traverseLevel(TreeWalker walker, XMLNode parent, boolean isFirstChild, Map> mapXMlDependency, String namespace) { + Node currentNode = walker.getCurrentNode(); + if (!isFirstChild) { + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, parent, true, mapXMlDependency, namespace); + } + } else { + XMLNode xmlNode = parent.createChildXMlNode(currentNode.getNodeName(), currentNode.getTextContent(), currentNode.getChildNodes(), currentNode.getAttributes()); + dependencies.createDependencyToNode(parent, xmlNode, JavaDependency.MEMBER); + NamedNodeMap listAttributes = xmlNode.getAttributes(); + if (xmlNode.getNodeName().equals("select")) { + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("resultMap")) { + putInMap(mapXMlDependency, listAttributes.item(i).getNodeValue(), xmlNode); + } + } + } + if (xmlNode.getNodeName().equals("resultMap")) { + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("id")) { + String key = listAttributes.item(i).getNodeValue(); + if (mapXMlDependency.containsKey(key)) { + for (int j = 0; j < mapXMlDependency.get(key).size(); j++) { + dependencies.createDependencyToNode(mapXMlDependency.get(key).get(j), xmlNode, JavaDependency.USE); + } + } + } + } + } + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("parameterType") || listAttributes.item(i).getNodeName().equals("resultType") || listAttributes.item(i).getNodeName().equals("type")) { + String value = listAttributes.item(i).getNodeValue(); + if (value.contains(".")) { + putInMap(mapXMlDependency, value, xmlNode); + } + if (mapXMlDependency.containsKey(value) && !value.contains(".")) { + for (int j = 0; j < mapXMlDependency.get(value).size(); j++) { + dependencies.createDependencyToNode(xmlNode, mapXMlDependency.get(value).get(j), JavaDependency.USE); + } + } + } else if (listAttributes.item(i).getNodeName().equals("id") && !xmlNode.getNodeName().equals("resultMap")) { + String value = listAttributes.item(i).getNodeValue(); + putInMap(mapXMlDependency, namespace + "." + value, xmlNode); + } + } + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, xmlNode, true, mapXMlDependency, namespace); + } + } + walker.setCurrentNode(currentNode); + } + + + //for configuration is not in src + void build(org.w3c.dom.Document document, @Nonnull String[] sourcePathArray, Map> mapXMLDependency, Path sourcePath) { + XMLNode rootXMLNode = rootNode.createChildXMlNode(document.getDocumentElement().getNodeName(), document.getDocumentElement().getTextContent(), + document.getDocumentElement().getChildNodes(), document.getDocumentElement().getAttributes()); + String key = String.valueOf(sourcePath.getFileName()); + putInMap(mapXMLDependency, key, rootXMLNode); + + DocumentTraversal traversal = (DocumentTraversal) document; + TreeWalker walker = traversal.createTreeWalker(document.getDocumentElement(), + NodeFilter.SHOW_ELEMENT, null, true); + traverseLevel(walker, rootXMLNode, false, sourcePathArray, mapXMLDependency); + dependencies.createDependencyToNode(rootNode, rootXMLNode, JavaDependency.MEMBER); + } + + private void traverseLevel(TreeWalker walker, XMLNode parent, boolean isFirstChild, String[] sourcePathArray, Map> mapXMLDependency) { + Node currentNode = walker.getCurrentNode(); + if (!isFirstChild) { + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, parent, true, sourcePathArray, mapXMLDependency); + } + } else { + XMLNode xmlNode = parent.createChildXMlNode(currentNode.getNodeName(), currentNode.getTextContent(), currentNode.getChildNodes(), currentNode.getAttributes()); + dependencies.createDependencyToNode(parent, xmlNode, JavaDependency.MEMBER); + if (xmlNode.getNodeName().equals("typeAlias")) { + NamedNodeMap listAttributes = xmlNode.getAttributes(); + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("alias")) { + putInMap(mapXMLDependency, listAttributes.item(i).getNodeValue(), xmlNode); + } else if (listAttributes.item(i).getNodeName().equals("type")) { + putInMap(mapXMLDependency, listAttributes.item(i).getNodeValue(), xmlNode); + } + } + } else if (xmlNode.getNodeName().equals("mapper")) { + NamedNodeMap listAttributes = xmlNode.getAttributes(); + for (int i = 0; i < listAttributes.getLength(); i++) { + if (listAttributes.item(i).getNodeName().equals("resource")) { + String value = listAttributes.item(i).getNodeValue(); + String path = convertResourceToPath(sourcePathArray, value); + putInMap(mapXMLDependency, path, xmlNode); + } + } + } + for (Node n = walker.firstChild(); n != null; n = walker.nextSibling()) { + traverseLevel(walker, xmlNode, true, sourcePathArray, mapXMLDependency); + } + } + walker.setCurrentNode(currentNode); + } + + public static void putInMap(Map> mapXMLDependency, String key, XMLNode xmlNode) { + if (mapXMLDependency.containsKey(key)) { + if (!mapXMLDependency.get(key).contains(xmlNode)) { + mapXMLDependency.get(key).add(xmlNode); + } + } else { + mapXMLDependency.put(key, new ArrayList<>(Arrays.asList(xmlNode))); + } + } + + public static String convertResourceToPath(@Nonnull String[] sourcePathArray, String resource) { + String fullPath = ""; + for (String sourcePath : sourcePathArray) { + String[] temp = resource.split("/"); + boolean sign = true; + for (String s : temp) { + if (!sourcePath.contains(s)) { + sign = false; + break; + } + } + if (sign) { + fullPath = sourcePath; + } + } + return fullPath; + } + + public RootNode getRootNode() { + return rootNode; + } + @Nonnull RootNode postprocessing() throws JavaCiaException { // delay dependency walkers @@ -150,6 +367,7 @@ RootNode postprocessing() throws JavaCiaException { // freeze root node rootNode.freeze(); + mapXMlDependency.clear(); return rootNode; } @@ -246,9 +464,10 @@ private PackageNode createPackageNodeFromPackageDeclaration(@Nonnull PackageDecl @Nonnull private PackageNode createPackageNodeFromPath(@Nonnull String path) { - int startPackageIndex = path.indexOf("src\\"); + int startPackageIndex = path.indexOf("src" + File.separator); String simplePath = path.substring(startPackageIndex); - String[] pathComponent = simplePath.split("\\\\"); + String pattern = Pattern.quote(System.getProperty("file.separator")); + String[] pathComponent = simplePath.split(pattern); // remove name of file // remove src component String[] nameComponent = new String[pathComponent.length - 2]; @@ -258,12 +477,6 @@ private PackageNode createPackageNodeFromPath(@Nonnull String path) { ? oldPair : internalCreatePackagePairFromNameComponents(nameComponent); PackageNode packageNode = pair.getA(); - /*IPackageBinding packageBinding = createPackageBinding(nameComponent); - if (pair.getB() == null) { - pair.setB(packageBinding); - packageNode.setAnnotates(annotates.createAnnotatesFromAnnotationBindings(packageBinding.getAnnotations(), - packageNode, JavaDependency.USE)); - }*/ System.out.println("packageNode " + packageNode); assert perFileNodeSet != null; for (AbstractNode node = packageNode; !node.isRoot(); node = node.getParent()) { @@ -272,70 +485,6 @@ private PackageNode createPackageNodeFromPath(@Nonnull String path) { return packageNode; } - private IPackageBinding createPackageBinding(String[] nameComponent) { - IPackageBinding packageBinding = new IPackageBinding() { - @Override - public String getName() { - return nameComponent[nameComponent.length - 1]; - } - - @Override - public boolean isUnnamed() { - return false; - } - - @Override - public String[] getNameComponents() { - return nameComponent; - } - - @Override - public IAnnotationBinding[] getAnnotations() { - return new IAnnotationBinding[0]; - } - - @Override - public int getKind() { - return 0; - } - - @Override - public int getModifiers() { - return 0; - } - - @Override - public boolean isDeprecated() { - return false; - } - - @Override - public boolean isRecovered() { - return false; - } - - @Override - public boolean isSynthetic() { - return false; - } - - @Override - public IJavaElement getJavaElement() { - return null; - } - - @Override - public String getKey() { - return null; - } - - @Override - public boolean isEqualTo(IBinding iBinding) { - return false; - } - }; - return packageBinding; - } //endregion Package //region Parser @@ -388,6 +537,12 @@ private void parseClassTypeDeclaration(@Nonnull AbstractNode parentNode, final ClassNode classNode = parentNode.createChildClass(typeBinding.getName(), typeBinding.getBinaryName()); dependencies.createDependencyToNode(parentNode, classNode, JavaDependency.MEMBER); + if (mapXMlDependency.containsKey(classNode.getBinaryName())) { + for (int i = 0; i < mapXMlDependency.get(classNode.getBinaryName()).size(); i++) { + dependencies.createDependencyToNode(mapXMlDependency.get(classNode.getBinaryName()).get(i), classNode, JavaDependency.USE); + } + } + // add to node set assert perFileNodeSet != null; perFileNodeSet.add(classNode); @@ -395,6 +550,7 @@ private void parseClassTypeDeclaration(@Nonnull AbstractNode parentNode, internalParseClassTypeBinding(classNode, typeBinding, typeDeclaration.bodyDeclarations()); } + private void internalParseClassTypeBinding(@Nonnull ClassNode classNode, @Nonnull ITypeBinding typeBinding, @Nonnull List bodyDeclarations) throws JavaCiaException { // put binding map @@ -442,6 +598,12 @@ private void parseInterfaceTypeDeclaration(@Nonnull AbstractNode parentNode, @No .createChildInterface(typeBinding.getName(), typeBinding.getBinaryName()); dependencies.createDependencyToNode(parentNode, interfaceNode, JavaDependency.MEMBER); + if (mapXMlDependency.containsKey(interfaceNode.getBinaryName())) { + for (int i = 0; i < mapXMlDependency.get(interfaceNode.getBinaryName()).size(); i++) { + dependencies.createDependencyToNode(mapXMlDependency.get(interfaceNode.getBinaryName()).get(i), interfaceNode, JavaDependency.USE); + } + } + // add to node set assert perFileNodeSet != null; perFileNodeSet.add(interfaceNode); @@ -902,6 +1064,24 @@ public boolean visit(@Nonnull SuperMethodInvocation node) { @Override public boolean visit(@Nonnull MethodInvocation node) { + Expression expression = node.getExpression(); + if (expression instanceof SimpleName) { + IBinding expressionBinding = visitFromSimpleName((SimpleName) expression); + if (expressionBinding instanceof IVariableBinding) { + IVariableBinding iVariableBinding = (IVariableBinding) visitFromSimpleName((SimpleName) expression); + if (iVariableBinding != null) { + ITypeBinding iTypeBinding = iVariableBinding.getType(); + String binaryName = iTypeBinding.getBinaryName(); + if (binaryName.equals("SqlSession")) { + createDependencyFromInvocation(node); + } + } + } else if (expressionBinding == null) { + if (((SimpleName) expression).getIdentifier().equals("Resources")) { + createDependencyFromInvocation(node); + } + } + } final IMethodBinding binding = node.resolveMethodBinding(); if (binding != null) { createDependencyFromInvocation(binding, node.typeArguments(), node.arguments()); @@ -911,6 +1091,44 @@ public boolean visit(@Nonnull MethodInvocation node) { return false; } + private void createDependencyFromInvocation(@Nonnull MethodInvocation node) { + List listArgument = node.arguments(); + String argumentValue = null; + for (Object argument : listArgument) { + if (argument instanceof StringLiteral) { + argumentValue = ((StringLiteral) argument).getLiteralValue(); + } else if (argument instanceof QualifiedName) { + IVariableBinding iBinding = (IVariableBinding) ((QualifiedName) argument).getName().resolveBinding(); + IVariableBinding variableBinding = iBinding.getVariableDeclaration(); + argumentValue = (String) variableBinding.getConstantValue(); + } + } + if (argumentValue != null && mapXMlDependency.containsKey(argumentValue)) { + for (int i = 0; i < mapXMlDependency.get(argumentValue).size(); i++) { + dependencies.createDependencyToNode(javaNode, mapXMlDependency.get(argumentValue).get(i), JavaDependency.USE); + } + } + } + + private IBinding visitFromSimpleName(SimpleName simpleName) { + final IBinding binding = simpleName.resolveBinding(); + if (binding == null && !enableRecovery) { + exceptionProxy[0] = new JavaCiaException("Cannot resolve binding on simple name!"); + } + final IBinding originalBinding = binding instanceof ITypeBinding + ? JavaDependencies.getOriginTypeBinding((ITypeBinding) binding) + : binding instanceof IMethodBinding + ? JavaDependencies.getOriginMethodBinding((IMethodBinding) binding) + : binding instanceof IVariableBinding + ? JavaDependencies.getOriginVariableBinding((IVariableBinding) binding) + : null; + + if (originalBinding != null) { + dependencies.createDelayDependency(javaNode, originalBinding, JavaDependency.USE); + } + return originalBinding; + } + private void createDependencyFromInvocation(@Nonnull IMethodBinding binding, @Nonnull List typeArguments, @Nonnull List arguments) { dependencies.createDelayDependency(javaNode, @@ -952,7 +1170,6 @@ public boolean visit(@Nonnull TypeDeclaration node) { public boolean visit(@Nonnull AnonymousClassDeclaration node) { return false; } - }); if (exceptionProxy[0] != null) throw exceptionProxy[0]; } diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotBuilder.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotBuilder.java index 89645bd..d95a841 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotBuilder.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotBuilder.java @@ -27,7 +27,10 @@ import mrmathami.cia.java.tree.node.JavaNode; import mrmathami.cia.java.tree.node.JavaRootNode; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; +import java.io.IOException; import java.nio.file.Path; import java.util.List; import java.util.Map; @@ -41,9 +44,9 @@ private JavaSnapshotBuilder() { @Nonnull public static ProjectSnapshot build(@Nonnull String snapshotName, @Nonnull Map>> javaSources, @Nonnull List classPaths, - @Nonnull JavaDependencyWeightTable dependencyWeightMap, boolean enableRecovery) throws JavaCiaException { + @Nonnull JavaDependencyWeightTable dependencyWeightMap, boolean enableRecovery, Path configurationPath) throws JavaCiaException, IOException, SAXException, ParserConfigurationException { - final JavaRootNode rootNode = JavaSnapshotParser.build(javaSources, classPaths, enableRecovery); + final JavaRootNode rootNode = JavaSnapshotParser.build(javaSources, classPaths, enableRecovery, configurationPath); final double[] dependencyWeights = new double[JavaDependency.valueList.size()]; for (final JavaDependency type : JavaDependency.valueList) { diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotParser.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotParser.java index f3c51a7..a8ee8bf 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotParser.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/builder/JavaSnapshotParser.java @@ -23,6 +23,7 @@ import mrmathami.cia.java.JavaCiaException; import mrmathami.cia.java.jdt.tree.node.AbstractNode; import mrmathami.cia.java.jdt.tree.node.RootNode; +import mrmathami.cia.java.jdt.tree.node.XMLNode; import mrmathami.cia.java.tree.node.JavaRootNode; import mrmathami.utils.Pair; import org.eclipse.jdt.core.JavaCore; @@ -40,7 +41,6 @@ import java.nio.charset.StandardCharsets; import java.nio.file.LinkOption; import java.nio.file.Path; -import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -63,6 +63,8 @@ final class JavaSnapshotParser extends FileASTRequestor { @Nonnull private final Map> sourceNodeMap = new HashMap<>(); + private static final Map> mapXMlDependency = new HashMap<>(); + @Nullable private JavaCiaException exception; @@ -72,10 +74,9 @@ private JavaSnapshotParser(@Nonnull Map sourceNameMap, @Nonnull this.nodes = new JavaNodes(codeFormatter, enableRecovery); } - @Nonnull static JavaRootNode build(@Nonnull Map>> javaSources, @Nonnull List classPaths, - boolean enableRecovery) throws JavaCiaException { + boolean enableRecovery, Path configurationPath) throws JavaCiaException, IOException, SAXException, ParserConfigurationException { final List classPathList = new ArrayList<>(classPaths.size() + javaSources.size()); final List projectFileList = new ArrayList<>(); @@ -104,13 +105,13 @@ static JavaRootNode build(@Nonnull Map>> javaSourc final String[] classPathArray = classPathList.toArray(EMPTY); - return parse(sourcePathArray, sourceEncodingArray, classPathArray, sourceNameMap, enableRecovery); + return parse(sourcePathArray, sourceEncodingArray, classPathArray, sourceNameMap, enableRecovery, configurationPath); } @Nonnull private static JavaRootNode parse(@Nonnull String[] sourcePathArray, @Nonnull String[] sourceEncodingArray, - @Nonnull String[] classPathArray, @Nonnull Map sourceNameMap, boolean enableRecovery) - throws JavaCiaException { + @Nonnull String[] classPathArray, @Nonnull Map sourceNameMap, boolean enableRecovery, Path configuration) + throws JavaCiaException, ParserConfigurationException, SAXException, IOException { final ASTParser astParser = ASTParser.newParser(AST.JLS14); final Map options = JavaCore.getOptions(); @@ -125,12 +126,93 @@ private static JavaRootNode parse(@Nonnull String[] sourcePathArray, @Nonnull St final CodeFormatter codeFormatter = ToolFactory.createCodeFormatter(options, ToolFactory.M_FORMAT_EXISTING); final JavaSnapshotParser parser = new JavaSnapshotParser(sourceNameMap, codeFormatter, enableRecovery); + + if (configuration.toString().equals("")) { + List listMapperPaths = parser.filterMapFiles(sourcePathArray); + parser.acceptXMLMapper(listMapperPaths, mapXMlDependency); + } else { + parser.acceptXMlConfig(configuration, sourcePathArray, mapXMlDependency); + parser.acceptXMlMapper(mapXMlDependency); + } + astParser.createASTs(sourcePathArray, sourceEncodingArray, EMPTY, parser, null); // TODO: add source name info to tree return parser.postProcessing(); } + public List filterMapFiles(@Nonnull String[] sourcePathArray) throws IOException, SAXException, ParserConfigurationException { + List list = new ArrayList<>(); + for (String sourcePath : sourcePathArray) { + if (sourcePath.endsWith(".xml")) { + Document document = parseXML(Path.of(sourcePath)); + String type = document.getDocumentElement().getNodeName(); + if (type.equals("mapper")) { + list.add(sourcePath); + } + } + } + return list; + } + + public void acceptXMlConfig(@Nonnull Path sourcePath, @Nonnull String[] sourcePathArray, Map> mapXMlDependency) { + if (exception != null) return; + try { + Document doc = parseXML(sourcePath); + nodes.build(doc, sourcePathArray, mapXMlDependency, sourcePath); + } catch (ParserConfigurationException | IOException | SAXException e) { + e.printStackTrace(); + } + } + + public void acceptXMLMapper(List listMapperPaths, Map> mapXMlDependency) { + for (String path : listMapperPaths) { + if (exception != null) return; + try { + final String sourceName = sourceNameMap.get(path); + if (sourceName == null) throw new JavaCiaException("Unknown source path!"); + final Set perFileNodeSet + = sourceNodeMap.computeIfAbsent(sourceName, JavaSnapshotParser::createLinkedHashSet); + + Document doc = parseXML(Path.of(path)); + nodes.build(perFileNodeSet, doc, path, mapXMlDependency); + + } catch (JavaCiaException javaCiaException) { + exception = javaCiaException; + } catch (ParserConfigurationException | IOException | SAXException e) { + e.printStackTrace(); + } + } + } + + public void acceptXMlMapper(Map> mapXMlDependency) { + List listMapperPaths = new ArrayList<>(); + for (String path : mapXMlDependency.keySet()) { + if (path.endsWith(".xml") && path.contains("\\")) { + System.out.println("mapper file path: " + path); + listMapperPaths.add(path); + } + } + for (String path : listMapperPaths) { + if (exception != null) return; + try { + final String sourceName = sourceNameMap.get(path); + if (sourceName == null) throw new JavaCiaException("Unknown source path!"); + final Set perFileNodeSet + = sourceNodeMap.computeIfAbsent(sourceName, JavaSnapshotParser::createLinkedHashSet); + + Document doc = parseXML(Path.of(path)); + nodes.build(perFileNodeSet, doc, path, mapXMlDependency); + + } catch (JavaCiaException javaCiaException) { + exception = javaCiaException; + } catch (ParserConfigurationException | IOException | SAXException e) { + e.printStackTrace(); + } + } + } + + @Override public void acceptAST(@Nonnull String sourcePath, @Nonnull CompilationUnit compilationUnit) { if (exception != null) return; @@ -139,29 +221,32 @@ public void acceptAST(@Nonnull String sourcePath, @Nonnull CompilationUnit compi if (sourceName == null) throw new JavaCiaException("Unknown source path!"); final Set perFileNodeSet = sourceNodeMap.computeIfAbsent(sourceName, JavaSnapshotParser::createLinkedHashSet); - //for xml file - if (sourcePath.endsWith(".xml")) { - Document doc = parseXML(sourcePath); + + //for xml file except mapper file and configuration file + if (sourcePath.endsWith(".xml") && !mapXMlDependency.containsKey(sourcePath)) { + Document doc = parseXML(Path.of(sourcePath)); nodes.build(perFileNodeSet, doc, sourcePath); } else { - nodes.build(perFileNodeSet, compilationUnit); + //for java file + nodes.build(perFileNodeSet, compilationUnit, mapXMlDependency); } } catch (JavaCiaException exception) { this.exception = exception; - } catch (SAXException | IOException | ParserConfigurationException e) { + } catch (ParserConfigurationException | SAXException | IOException e) { e.printStackTrace(); } } - private static Document parseXML(String sourcePath) throws ParserConfigurationException, IOException, SAXException { + + private static Document parseXML(Path sourcePath) throws ParserConfigurationException, IOException, SAXException { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); dbf.setIgnoringComments(true); dbf.setCoalescing(true); dbf.setIgnoringElementContentWhitespace(true); DocumentBuilder db = dbf.newDocumentBuilder(); - Document doc = db.parse(Paths.get(sourcePath).toFile()); + Document doc = db.parse(sourcePath.toFile()); doc.normalizeDocument(); return doc; } @@ -172,6 +257,7 @@ private RootNode postProcessing() throws JavaCiaException { return nodes.postprocessing(); } + //region Misc @Nonnull diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityMatcher.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityMatcher.java index b45407f..9e61038 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityMatcher.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityMatcher.java @@ -22,11 +22,15 @@ import mrmathami.annotations.Nullable; import mrmathami.cia.java.tree.JavaIdentifiedEntity; import mrmathami.utils.Pair; +import org.w3c.dom.NamedNodeMap; +import org.w3c.dom.Node; +import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.IdentityHashMap; import java.util.Iterator; +import java.util.List; import java.util.Map; final class EntityMatcher { @@ -91,6 +95,46 @@ boolean matchNonOrdered(@Nonnull Collection coll return true; } + boolean matchNonOrderedNameNodeMap(NamedNodeMap namedNodeMapA, NamedNodeMap namedNodeMapB) { + if (namedNodeMapA.getLength() != namedNodeMapB.getLength()) return false; +// List listA = getListNode(namedNodeMapA); +// List listB = getListNode(namedNodeMapB); +// for (Node node : listA) { +// if (!listB.contains(node)) { +// return false; +// } +// } + + HashMap hashNodeA = getHash(namedNodeMapA); + HashMap hashNodeB = getHash(namedNodeMapB); + for (String key : hashNodeA.keySet()) { + if (hashNodeB.containsKey(key)) { + if (!hashNodeA.get(key).equals(hashNodeB.get(key))) { + return false; + } + } else { + return false; + } + } + return true; + } + + private HashMap getHash(NamedNodeMap namedNodeMap) { + HashMap hashMap = new HashMap<>(); + for (int i = 0; i < namedNodeMap.getLength(); i++) { + hashMap.put(namedNodeMap.item(i).getNodeName(), namedNodeMap.item(i).getNodeValue()); + } + return hashMap; + } + + private List getListNode(NamedNodeMap namedNodeMap) { + List list = new ArrayList<>(); + for (int i = 0; i < namedNodeMap.getLength(); i++) { + list.add(namedNodeMap.item(i)); + } + return list; + } + @Nonnull EntityWrapper wrap(@Nonnull JavaIdentifiedEntity entity, boolean identicalMatch) { return identicalMatch diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityPartialMatcher.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityPartialMatcher.java index 2b6cf2a..4c87d09 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityPartialMatcher.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/EntityPartialMatcher.java @@ -20,8 +20,10 @@ import mrmathami.annotations.Nonnull; import mrmathami.annotations.Nullable; +import mrmathami.cia.java.jdt.tree.dependency.DependencyCountTable; import mrmathami.cia.java.tree.JavaIdentifiedEntity; import mrmathami.cia.java.tree.annotate.JavaAnnotate; +import mrmathami.cia.java.tree.dependency.JavaDependency; import mrmathami.cia.java.tree.dependency.JavaDependencyCountTable; import mrmathami.cia.java.tree.node.JavaClassNode; import mrmathami.cia.java.tree.node.JavaEnumNode; @@ -30,6 +32,7 @@ import mrmathami.cia.java.tree.node.JavaInterfaceNode; import mrmathami.cia.java.tree.node.JavaMethodNode; import mrmathami.cia.java.tree.node.JavaNode; +import mrmathami.cia.java.tree.node.JavaXMLNode; import mrmathami.cia.java.tree.node.attribute.JavaAnnotatedNode; import mrmathami.cia.java.tree.node.attribute.JavaModifiedNode; import mrmathami.cia.java.tree.node.attribute.JavaParameterizedNode; @@ -39,6 +42,7 @@ import mrmathami.cia.java.tree.type.JavaSyntheticType; import mrmathami.cia.java.tree.type.JavaType; import mrmathami.utils.Pair; +import org.w3c.dom.NamedNodeMap; import java.util.HashMap; import java.util.Iterator; @@ -97,6 +101,66 @@ protected boolean partialMatch(@Nonnull JavaIdentifiedEntity entityA, @Nonnull J return true; } }, + XML_NODE(JavaXMLNode.class) { + @Override + protected int partialMatchCode(JavaIdentifiedEntity entity, boolean identicalMatch) { + + assert entity instanceof JavaXMLNode; + final JavaXMLNode node = (JavaXMLNode) entity; +// System.out.println("-----------"+ node.getNodeName() +"-------------"); +// int matchCode = identicalMatch ? node.getNodeName() != null ? 1 : 0 : -1; +// System.out.println(matchCode); +// matchCode = matchCode * 31 + node.getAttributes().hashCode(); +// System.out.println("attribute hashcode " + node.getAttributes().hashCode()); +// System.out.println(matchCode); +// matchCode = matchCode * 31 + node.getTextContent().hashCode(); +// System.out.println(matchCode); +// System.out.println(matchCode * 31 + (node.getChildNodes() != null ? 1 : 0)); +// return matchCode * 31 + (node.getChildNodes() != null ? 1 : 0); + + int matchCode = node.getEntityClass().hashCode(); + matchCode = matchCode * 31 + node.getNodeName().hashCode(); + matchCode = matchCode * 31 + (identicalMatch ? node.getDependencyToNodes().size() : -1); + matchCode = matchCode * 31 + (identicalMatch ? node.getTextContent().hashCode() : -1); + matchCode = matchCode * 31 + attributeHasCode(node); + return matchCode * 31 + ( identicalMatch ? node.getAttributes().getLength() : -1 ); + } + private int attributeHasCode(JavaXMLNode node) { + NamedNodeMap listAttribute = node.getAttributes(); + int hashCode = listAttribute.getLength(); + for (int i = 0; i < listAttribute.getLength(); i++) { + hashCode = hashCode * 31 + listAttribute.item(i).getNodeName().hashCode() + listAttribute.item(i).getNodeValue().hashCode(); + } + return hashCode; + } + + @Override + protected boolean partialMatch(JavaIdentifiedEntity entityA, JavaIdentifiedEntity entityB, EntityMatcher matcher, boolean identicalMatch) { + assert entityA instanceof JavaXMLNode && entityB instanceof JavaXMLNode; + final JavaXMLNode nodeA = (JavaXMLNode) entityA, nodeB = (JavaXMLNode) entityB; + boolean compareName = (nodeA.getNodeName().equals(nodeB.getNodeName())); + boolean compareTextContent = true; + if (permissionCheckTextContent(nodeA) && permissionCheckTextContent(nodeB)) { + compareTextContent = (nodeA.getTextContent().equals(nodeB.getTextContent())); + } + boolean compareAttributes = (matcher.matchNonOrderedNameNodeMap(nodeA.getAttributes(), nodeB.getAttributes())); + boolean returnBool = !identicalMatch || ((nodeA.getNodeName().equals(nodeB.getNodeName())) + && compareTextContent + && (matcher.matchNonOrderedNameNodeMap(nodeA.getAttributes(), nodeB.getAttributes()))); + return returnBool; + } + + private boolean permissionCheckTextContent(JavaXMLNode javaXMLNode) { + for (Map.Entry entry : javaXMLNode.getDependencyTo().entrySet()) { + if ((entry.getKey() instanceof JavaXMLNode) && + (entry.getValue() instanceof DependencyCountTable) && + (entry.getValue().getCount(JavaDependency.MEMBER) > 0)) { + return false; + } + } + return true; + } + }, ANNOTATED_NODE(JavaAnnotatedNode.class) { @Override @@ -493,6 +557,11 @@ private boolean internalMismatchValue(@Nullable JavaAnnotate.Value valueA, @Null } }; + void printAttributes(NamedNodeMap namedNodeMap) { + for (int i = 0; i < namedNodeMap.getLength(); i++) { + System.out.println(namedNodeMap.item(i).getNodeName() + " : " + namedNodeMap.item(i).getNodeValue()); + } + } @Nonnull private static final EntityPartialMatcher[] PARTIAL_MATCHERS = values(); diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/JavaSnapshotComparator.java b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/JavaSnapshotComparator.java index 0a49484..8b25785 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/JavaSnapshotComparator.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/project/differ/JavaSnapshotComparator.java @@ -73,14 +73,13 @@ public static ProjectSnapshotComparison compare(@Nonnull String comparisonName, private static void compareRootNodes(@Nonnull JavaRootNode previousRootNode, @Nonnull JavaRootNode currentRootNode, - @Nonnull Set addedNodes, @Nonnull Set removedNodes, + @Nonnull Set removedNodes, @Nonnull Set addedNodes, @Nonnull Set> changedNodes, @Nonnull Set> unchangedNodes) { final EntityMatcher matcher = new EntityMatcher(); final Map previousNodeMap = new HashMap<>(); final Map currentNodeMap = new HashMap<>(); - for (final JavaNode node : previousRootNode.getAllNodes()) { previousNodeMap.put(matcher.wrap(node, false), node); } @@ -92,6 +91,7 @@ private static void compareRootNodes(@Nonnull JavaRootNode previousRootNode, @No final EntityWrapper previousWrapper = previousEntry.getKey(); final JavaNode previousNode = previousEntry.getValue(); final JavaNode currentNode = currentNodeMap.get(previousWrapper); + if (currentNode != null) { if (matcher.match(previousNode, currentNode, true)) { unchangedNodes.add(Pair.immutableOf(previousNode, currentNode)); @@ -102,6 +102,8 @@ private static void compareRootNodes(@Nonnull JavaRootNode previousRootNode, @No removedNodes.add(previousNode); } } + + for (final Map.Entry currentEntry : currentNodeMap.entrySet()) { final EntityWrapper currentWrapper = currentEntry.getKey(); final JavaNode currentNode = currentEntry.getValue(); diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/RootNode.java b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/RootNode.java index fac35d7..7d14c6e 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/RootNode.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/RootNode.java @@ -108,6 +108,7 @@ public List getAllNodes() { return isFrozen() ? allNodes : Collections.unmodifiableList(allNodes); } + // void setAllNodes(@Nonnull List allNodes) { // checkFrozen(); // this.allNodes = allNodes; diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/XMLNode.java b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/XMLNode.java index 1595d55..17c3aa2 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/XMLNode.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/XMLNode.java @@ -1,6 +1,7 @@ package mrmathami.cia.java.jdt.tree.node; import mrmathami.annotations.Nonnull; +import mrmathami.cia.java.jdt.tree.AbstractEntity; import mrmathami.cia.java.tree.node.JavaXMLNode; import org.w3c.dom.NamedNodeMap; import org.w3c.dom.NodeList; @@ -53,21 +54,20 @@ public AbstractNode getParent() { return parent; } - @Override public String getTextContent() { return textContent; } - @Override public NodeList getChildNodes() { return children; } - @Override public NamedNodeMap getAttributes() { return listAttributes; } + + public void setTextContent(String textContent) { this.textContent = textContent; } @@ -84,8 +84,9 @@ public void setListAttributes(NamedNodeMap listAttributes) { protected void internalToReferenceJsonStart(@Nonnull StringBuilder builder) { builder.append(", \"nodeName\": \"").append(nodeName) - .append("\", \"textContent\": \"").append(textContent) - .append("\", \"listAttributes\": ").append(internalToReferenceJson(listAttributes)); + .append("\", \"textContent\": \""); + AbstractEntity.internalEscapeString(builder, textContent); + builder.append("\", \"listAttributes\": ").append(internalToReferenceJson(listAttributes)); } private static String internalToReferenceJson(NamedNodeMap namedNodeMap) { @@ -103,5 +104,6 @@ private static String internalToReferenceJson(NamedNodeMap namedNodeMap) { return listAttributes; } + //endregion Jsonify } diff --git a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/attribute/AbstractNonRootNode.java b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/attribute/AbstractNonRootNode.java index 865704e..7c05f60 100644 --- a/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/attribute/AbstractNonRootNode.java +++ b/jdt/src/main/java/mrmathami/cia/java/jdt/tree/node/attribute/AbstractNonRootNode.java @@ -108,7 +108,6 @@ public final AbstractNode getParent() { } @Nonnull - @Override public final String getNodeName() { return simpleName; } diff --git a/jdt/src/test/JSON-java.proj b/jdt/src/test/JSON-java.proj index ec59ccf..855c58b 100644 Binary files a/jdt/src/test/JSON-java.proj and b/jdt/src/test/JSON-java.proj differ diff --git a/jdt/src/test/java/mrmathami/cia/java/jdt/X.java b/jdt/src/test/java/mrmathami/cia/java/jdt/X.java index 35c73a3..2f04414 100644 --- a/jdt/src/test/java/mrmathami/cia/java/jdt/X.java +++ b/jdt/src/test/java/mrmathami/cia/java/jdt/X.java @@ -1,13 +1,16 @@ package mrmathami.cia.java.jdt; import mrmathami.cia.java.JavaCiaException; +import mrmathami.cia.java.jdt.gephi.Printer; import mrmathami.cia.java.project.JavaProject; import mrmathami.cia.java.project.JavaProjectSnapshot; import mrmathami.cia.java.project.JavaProjectSnapshotComparison; import mrmathami.cia.java.tree.dependency.JavaDependency; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; import java.io.IOException; import java.io.ObjectOutputStream; import java.nio.charset.StandardCharsets; @@ -34,23 +37,27 @@ public class X { JavaDependency.OVERRIDE, 0.3 )); - public static void main(String[] args) throws JavaCiaException, IOException { + public static void main(String[] args) throws JavaCiaException, IOException, ParserConfigurationException, SAXException { // System.in.read(); // // for (int i = 0; i < 10; i++) { -// final Path javaSourcePathA = Path.of("..\\test\\JSON-java-before\\src\\main\\java"); -// final Path javaSourcePathB = Path.of("..\\test\\JSON-java\\src\\main\\java"); - final Path javaSourcePathA = Path.of("D:\\test-weight-1806\\test1\\src\\src"); - final Path javaSourcePathB = Path.of("D:\\test-weight-1806\\test1\\new\\src\\src"); + //final Path javaSourcePathA = Path.of("D:\\test-weight-1806\\test1\\src\\src"); + //final Path javaSourcePathB = Path.of("D:\\test-weight-1806\\test1\\new\\src\\src"); + final Path javaSourcePathA = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\mybatis-example-1\\src"); + final Path javaSourcePathB = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\new\\mybatis-example-1\\src"); final List fileNamesA = getFileList(new ArrayList<>(), javaSourcePathA); final List fileNamesB = getFileList(new ArrayList<>(), javaSourcePathB); + final Path configurationPathA = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\mybatis-example-1\\resources\\SqlMapConfig.xml"); + //final Path configurationPathA = Path.of(""); + final Path configurationPathB = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\new\\mybatis-example-1\\resources\\SqlMapConfig.xml"); + //final Path configurationPathB = Path.of(""); final long timeStart = System.nanoTime(); final JavaProjectSnapshot projectSnapshotA = ProjectBuilders.createProjectSnapshot("JSON-java-before", - Map.of("main", Pair.immutableOf(javaSourcePathA, fileNamesA)), List.of(), DEPENDENCY_WEIGHT_TABLE, true); + Map.of("main", Pair.immutableOf(javaSourcePathA, fileNamesA)), List.of(), DEPENDENCY_WEIGHT_TABLE, true, configurationPathA); final long timeParseA = System.nanoTime(); final JavaProjectSnapshot projectSnapshotB = ProjectBuilders.createProjectSnapshot("JSON-java-after", - Map.of("main", Pair.immutableOf(javaSourcePathB, fileNamesB)), List.of(), DEPENDENCY_WEIGHT_TABLE, true); + Map.of("main", Pair.immutableOf(javaSourcePathB, fileNamesB)), List.of(), DEPENDENCY_WEIGHT_TABLE, true, configurationPathB); final long timeParseB = System.nanoTime(); final String jsonA = projectSnapshotA.getRootNode().toJson(); @@ -72,10 +79,13 @@ public static void main(String[] args) throws JavaCiaException, IOException { javaProject.addSnapshot(projectSnapshotB); javaProject.addSnapshotComparison(snapshotComparison); + try (final ObjectOutputStream objectOutputStream = new ObjectOutputStream(Files.newOutputStream(Path.of("jdt\\src\\test\\JSON-java.proj")))) { objectOutputStream.writeObject(javaProject); } + Printer printer = new Printer(); + Files.write(javaSourcePathB.resolve("gephi.gexf"), printer.writeGephiComparison(snapshotComparison).getBytes(StandardCharsets.UTF_8)); System.out.printf("Compare time: %s\n", (timeCompareFinish - timeCompareStart) / 1000000.0); diff --git a/jdt/src/test/java/mrmathami/cia/java/jdt/Y.java b/jdt/src/test/java/mrmathami/cia/java/jdt/Y.java index b832be2..4e9de79 100644 --- a/jdt/src/test/java/mrmathami/cia/java/jdt/Y.java +++ b/jdt/src/test/java/mrmathami/cia/java/jdt/Y.java @@ -1,11 +1,14 @@ package mrmathami.cia.java.jdt; import mrmathami.cia.java.JavaCiaException; +import mrmathami.cia.java.jdt.gephi.Printer; import mrmathami.cia.java.project.JavaProjectSnapshot; import mrmathami.cia.java.tree.dependency.JavaDependency; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.DirectoryStream; @@ -23,51 +26,33 @@ public class Y { JavaDependency.INVOCATION, 4.0, JavaDependency.OVERRIDE, 1.0 )); + private static final Path configurationPath = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\mybatis-example-1\\resources\\SqlMapConfig.xml"); + //private static final Path configurationPath = Path.of(""); - public static void main(String[] args) throws JavaCiaException, IOException { -// System.in.read(); - -// CodeFormatter - -// final Path corePath = Path.of("D:\\project\\JavaCIA\\core\\src\\main\\java"); -// final List coreFiles = getFileList(new ArrayList<>(), corePath); -// final Path jdtPath = Path.of("D:\\project\\JavaCIA\\jdt\\src\\main\\java"); -// final List jdtFiles = getFileList(new ArrayList<>(), jdtPath); -// final Map>> javaSources = Map.of( -// "core", Pair.immutableOf(corePath, coreFiles), -// "jdt", Pair.immutableOf(jdtPath, jdtFiles) -// ); - - //final Path corePath = Path.of("D:\\project\\LearningStruts\\src\\mrmathami\\struts2\\model"); - final Path corePath = Path.of("D:\\project\\MyBatis Collection\\LearningStruts\\src"); + public static void main(String[] args) throws JavaCiaException, IOException, ParserConfigurationException, SAXException { + final Path corePath = Path.of("D:\\project\\MyBatis Collection\\mybatis-XML\\mybatis-example-1\\src"); + //final Path corePath = Path.of("D:\\project\\MyBatis Collection\\myBatisExample\\src"); + //final Path corePath = Path.of("D:\\project\\MyBatis Collection\\myBatisExample\\src"); final List coreFiles = getFileList(new ArrayList<>(), corePath); final Map>> javaSources = Map.of( "core", Pair.immutableOf(corePath, coreFiles) ); + final List classPaths = List.of( + //List classPaths in here + ); -// final Path calculatorPath = Path.of("D:\\project\\calculator\\src\\main\\java"); -// final List calculatorFiles = getFileList(new ArrayList<>(), calculatorPath); -// final Map>> javaSources = Map.of("calculator", Pair.immutableOf(calculatorPath, calculatorFiles)); -// -// final List classPaths = List.of( -//// Path.of("C:\\Users\\Meo\\.m2\\repository\\org\\eclipse\\jdt\\org.eclipse.jdt.core\\3.22.0\\org.eclipse.jdt.core-3.22.0.jar"), -//// Path.of("C:\\Users\\Meo\\.m2\\repository\\org\\eclipse\\platform\\org.eclipse.text\\3.10.200\\org.eclipse.text-3.10.200.jar"), -//// Path.of("C:\\Users\\Meo\\.m2\\repository\\mrmathami\\utils\\1.0.0\\utils-1.0.0.jar") -// Path.of("C:\\Users\\S14\\.m2\\repository\\junit\\junit\\4.12\\junit-4.12.jar"), -// Path.of("C:\\Users\\S14\\.m2\\repository\\log4j\\log4j\\1.2.17\\log4j-1.2.17.jar"), -// Path.of("C:\\Users\\S14\\.m2\\repository\\org\\hamcrest\\hamcrest-core\\1.3\\hamcrest-core-1.3.jar") -// ); - long timeStart = System.nanoTime(); final JavaProjectSnapshot projectSnapshot = ProjectBuilders.createProjectSnapshot("before", - javaSources, List.of(), DEPENDENCY_WEIGHT_TABLE, true); + javaSources, classPaths, DEPENDENCY_WEIGHT_TABLE, true, configurationPath); long timeParseA = System.nanoTime(); final String jsonA = projectSnapshot.getRootNode().toJson(); Files.write(corePath.resolve("output.txt"), jsonA.getBytes(StandardCharsets.UTF_8)); - //Files.write(calculatorPath.resolve("output.txt"), jsonA.getBytes(StandardCharsets.UTF_8)); + + Printer printer = new Printer(); + Files.write(corePath.resolve("gephi.gexf"), printer.writeGephi(projectSnapshot).getBytes(StandardCharsets.UTF_8)); System.out.printf("Parse A time: %s\n", (timeParseA - timeStart) / 1000000.0); } diff --git a/jdt/src/test/java/mrmathami/cia/java/jdt/Z.java b/jdt/src/test/java/mrmathami/cia/java/jdt/Z.java index 456983d..daa809e 100644 --- a/jdt/src/test/java/mrmathami/cia/java/jdt/Z.java +++ b/jdt/src/test/java/mrmathami/cia/java/jdt/Z.java @@ -5,7 +5,9 @@ import mrmathami.cia.java.tree.dependency.JavaDependency; import mrmathami.cia.java.tree.dependency.JavaDependencyWeightTable; import mrmathami.utils.Pair; +import org.xml.sax.SAXException; +import javax.xml.parsers.ParserConfigurationException; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.DirectoryStream; @@ -23,8 +25,9 @@ public class Z { JavaDependency.INVOCATION, 4.0, JavaDependency.OVERRIDE, 1.0 )); + private static final Path configurationPath = Path.of(""); - public static void main(String[] args) throws JavaCiaException, IOException { + public static void main(String[] args) throws JavaCiaException, IOException, ParserConfigurationException, SAXException { // System.in.read(); // CodeFormatter @@ -43,7 +46,7 @@ public static void main(String[] args) throws JavaCiaException, IOException { long timeStart = System.nanoTime(); final JavaProjectSnapshot projectSnapshot = ProjectBuilders.createProjectSnapshot("before", - javaSources, classPaths, DEPENDENCY_WEIGHT_TABLE, true); + javaSources, classPaths, DEPENDENCY_WEIGHT_TABLE, true, configurationPath); long timeParseA = System.nanoTime(); final String jsonA = projectSnapshot.getRootNode().toJson();