diff --git a/src/main/java/gui/webdiff/DirComparator.java b/src/main/java/gui/webdiff/DirComparator.java index 98ef550f84..df612cb6a1 100644 --- a/src/main/java/gui/webdiff/DirComparator.java +++ b/src/main/java/gui/webdiff/DirComparator.java @@ -4,14 +4,20 @@ import org.refactoringminer.astDiff.actions.ASTDiff; import org.refactoringminer.astDiff.actions.ProjectASTDiff; +import javax.swing.tree.DefaultMutableTreeNode; import java.util.*; public class DirComparator { private final List diffs; private final ProjectASTDiff projectASTDiff; + private final DefaultMutableTreeNode compressedTree; + private final Map modifiedFilesName; private Set removedFilesName; private Set addedFilesName; - private Map modifiedFilesName; + + public DefaultMutableTreeNode getCompressedTree() { + return compressedTree; + } public Set getRemovedFilesName() { return removedFilesName; @@ -37,8 +43,9 @@ public DirComparator(ProjectASTDiff projectASTDiff) this.projectASTDiff = projectASTDiff; this.diffs = new ArrayList<>(projectASTDiff.getDiffSet()); modifiedFilesName = new LinkedHashMap<>(); - compare(); + compressedTree = new TreeViewGenerator(getModifiedFilesName(), diffs).getCompressedTree(); + System.out.println(); } private void compare() { @@ -60,4 +67,4 @@ private void compare() { public ASTDiff getASTDiff(int id) { return diffs.get(id); } -} +} \ No newline at end of file diff --git a/src/main/java/gui/webdiff/DirectoryDiffView.java b/src/main/java/gui/webdiff/DirectoryDiffView.java index 6718d95db4..1497a73e67 100644 --- a/src/main/java/gui/webdiff/DirectoryDiffView.java +++ b/src/main/java/gui/webdiff/DirectoryDiffView.java @@ -16,108 +16,14 @@ public class DirectoryDiffView implements Renderable { - private static class TreeNodeInfo { - private final String name; - private final String fullPath; - - public TreeNodeInfo(String name, String fullPath) { - this.name = name; - this.fullPath = fullPath; - } - } private final DirComparator comperator; - private final DefaultMutableTreeNode root = new DefaultMutableTreeNode(new TreeNodeInfo("", "")); - private final DefaultMutableTreeNode compressedTree = new DefaultMutableTreeNode(new TreeNodeInfo("", "")); public DirectoryDiffView(DirComparator comperator) { this.comperator = comperator; - for(Map.Entry pair : comperator.getModifiedFilesName().entrySet()) { - String fileName = pair.getValue(); - String[] tokens = fileName.split("/"); - int counter = 1; - for(String token : tokens) { - String pathToNode = concatWithSlash(tokens, counter); - DefaultMutableTreeNode parent = findNode(pathToNode); - TreeNodeInfo parentNodeInfo = (TreeNodeInfo) parent.getUserObject(); - if(!parentNodeInfo.name.equals(token)) { - TreeNodeInfo nodeInfo = new TreeNodeInfo(token, pathToNode); - DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(nodeInfo); - parent.add(newChild); - } - counter++; - } - } - compressNode(compressedTree, root); - } - - private static void compressNode(DefaultMutableTreeNode newNode, DefaultMutableTreeNode oldNode) { - Enumeration enumeration = oldNode.children(); - int childCount = oldNode.getChildCount(); - if(childCount == 1) { - while(enumeration.hasMoreElements()) { - DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); - TreeNodeInfo treeNodeInfo = (TreeNodeInfo) treeNode.getUserObject(); - String nodeName = treeNodeInfo.name; - if(!nodeName.endsWith(".java")) { - if(oldNode.isRoot()) { - TreeNodeInfo newNodeInfo = new TreeNodeInfo(nodeName, nodeName); - newNode.setUserObject(newNodeInfo); - } - else { - TreeNodeInfo newNodeInfo = (TreeNodeInfo) newNode.getUserObject(); - TreeNodeInfo updatedNodeInfo = new TreeNodeInfo(newNodeInfo.name + "/" + nodeName, newNodeInfo.fullPath + "/" + nodeName); - newNode.setUserObject(updatedNodeInfo); - } - compressNode(newNode, treeNode); - } - else { - // this node is a leaf - newNode.add(treeNode); - } - } - } - else { - while(enumeration.hasMoreElements()) { - DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); - DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(treeNode.getUserObject()); - newNode.add(newChild); - compressNode(newChild, treeNode); - } - } } - private static String concatWithSlash(String[] tokens, int numberOfTokensToConcat) { - StringBuilder sb = new StringBuilder(); - int index = 0; - for(String token : tokens) { - if(index < numberOfTokensToConcat) { - sb.append(token); - } - if(index < numberOfTokensToConcat - 1) { - sb.append("/"); - } - index++; - } - return sb.toString(); - } - private DefaultMutableTreeNode findNode(String pathToNode) { - String[] tokens = pathToNode.split("/"); - Enumeration enumeration = root.children(); - int index = 0; - DefaultMutableTreeNode lastNode = null; - while(enumeration.hasMoreElements() && index < tokens.length) { - DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); - TreeNodeInfo treeNodeInfo = (TreeNodeInfo) treeNode.getUserObject(); - if(treeNodeInfo.name.equals(tokens[index])) { - lastNode = treeNode; - index++; - enumeration = treeNode.children(); - } - } - return lastNode != null ? lastNode : root; - } @Override public void renderOn(HtmlCanvas html) throws IOException { @@ -139,7 +45,7 @@ public void renderOn(HtmlCanvas html) throws IOException { .span(class_("badge badge-secondary").style("color:black")).content(comperator.getModifiedFilesName().size()) ._h4() ._div() - .render_if(new ModifiedFiles(comperator.getModifiedFilesName(), compressedTree), !comperator.getModifiedFilesName().isEmpty()) + .render_if(new ModifiedFiles(comperator), !comperator.getModifiedFilesName().isEmpty()) ._div() ._div() ._div() @@ -180,14 +86,13 @@ private static class ModifiedFiles implements Renderable { private Map diffInfos; private final DefaultMutableTreeNode root; - private ModifiedFiles(Map diffInfos, DefaultMutableTreeNode root) { - this.diffInfos = diffInfos; - this.root = root; + private ModifiedFiles(DirComparator comparator) { + this.root = comparator.getCompressedTree(); } - private int renderNode(HtmlCanvas ul, DefaultMutableTreeNode node, int nodeId) throws IOException { + private void renderNode(HtmlCanvas ul, DefaultMutableTreeNode node) throws IOException { if (node == null) { - return nodeId; + return; } // Start a list item for this node @@ -197,22 +102,22 @@ private int renderNode(HtmlCanvas ul, DefaultMutableTreeNode node, int nodeId) t // Content of the current node if (node.getUserObject() != null) { + TreeNodeInfo nodeInfo = (TreeNodeInfo) node.getUserObject(); if (node.isLeaf()) { ul.tr() - .td().content(((TreeNodeInfo) node.getUserObject()).name) //TODO: + .td().content(nodeInfo.getName()) //TODO: .td() .div(class_("btn-toolbar justify-content-end")) .div(class_("btn-group")) - .a(class_("btn btn-primary btn-sm").href("/monaco-diff/" + nodeId)).content("MonacoDiff") - .a(class_("btn btn-primary btn-sm").href("/vanilla-diff/" + nodeId)).content("ClassicDiff") + .a(class_("btn btn-primary btn-sm").href("/monaco-diff/" + nodeInfo.getId())).content("MonacoDiff") + .a(class_("btn btn-primary btn-sm").href("/vanilla-diff/" + nodeInfo.getId())).content("ClassicDiff") ._div() ._div() ._td() ._tr(); - nodeId++; } else { - li.span().content(((TreeNodeInfo)node.getUserObject()).name); + li.span().content(nodeInfo.getName()); } } @@ -228,7 +133,7 @@ private int renderNode(HtmlCanvas ul, DefaultMutableTreeNode node, int nodeId) t childUl.table(class_("table card-table table-striped table-condensed mb-0")) .tbody(); // Recursively render the child node - nodeId = renderNode(childUl, childNode, nodeId); + renderNode(childUl, childNode); if (childNode.isLeaf()) childUl._tbody()._table(); } @@ -239,7 +144,6 @@ private int renderNode(HtmlCanvas ul, DefaultMutableTreeNode node, int nodeId) t // End the list item if (li != null) li._li(); - return nodeId; } @Override @@ -249,7 +153,7 @@ public void renderOn(HtmlCanvas html) throws IOException { HtmlCanvas ul = html.div(class_("tree-root")).ul(); // Recursively process each node - renderNode(ul, root,0); + renderNode(ul, root); // Close the list and div ul._ul()._div(); diff --git a/src/main/java/gui/webdiff/TreeNodeInfo.java b/src/main/java/gui/webdiff/TreeNodeInfo.java new file mode 100644 index 0000000000..e1fbf43480 --- /dev/null +++ b/src/main/java/gui/webdiff/TreeNodeInfo.java @@ -0,0 +1,34 @@ +package gui.webdiff; + +public class TreeNodeInfo { + private final String name; + private final String fullPath; + private int id = -1; // NonLeafNode has id = -1; + + public String getName() { + return name; + } + + public String getFullPath() { + return fullPath; + } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } + + public TreeNodeInfo(String name, String fullPath) { + this.name = name; + this.fullPath = fullPath; + } + + public TreeNodeInfo(String name, String fullPath, int id) { + this.name = name; + this.fullPath = fullPath; + this.id = id; + } +} diff --git a/src/main/java/gui/webdiff/TreeViewGenerator.java b/src/main/java/gui/webdiff/TreeViewGenerator.java new file mode 100644 index 0000000000..9c4b5c3334 --- /dev/null +++ b/src/main/java/gui/webdiff/TreeViewGenerator.java @@ -0,0 +1,121 @@ +package gui.webdiff; + +import org.refactoringminer.astDiff.actions.ASTDiff; + +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeNode; +import java.util.Enumeration; +import java.util.List; +import java.util.Map; + +/* Created by pourya on 2024-04-16*/ +public class TreeViewGenerator { + private final DefaultMutableTreeNode root = new DefaultMutableTreeNode(new TreeNodeInfo("", "")); + private final DefaultMutableTreeNode compressedTree = new DefaultMutableTreeNode(new TreeNodeInfo("", "")); + private final List diffs; + + public DefaultMutableTreeNode getCompressedTree() { + return compressedTree; + } + + public TreeViewGenerator(Map modifiedFilesName, List diffs){ + this.diffs = diffs; + for(Map.Entry pair : modifiedFilesName.entrySet()) { + String fileName = pair.getValue(); + String[] tokens = fileName.split("/"); + int counter = 1; + for(String token : tokens) { + String pathToNode = concatWithSlash(tokens, counter); + DefaultMutableTreeNode parent = findNode(pathToNode); + TreeNodeInfo parentNodeInfo = (TreeNodeInfo) parent.getUserObject(); + if(!parentNodeInfo.getName().equals(token)) { + TreeNodeInfo nodeInfo = new TreeNodeInfo(token, pathToNode); + DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(nodeInfo); + parent.add(newChild); + } + counter++; + } + } + compressNode(compressedTree, root); + } + private static String concatWithSlash(String[] tokens, int numberOfTokensToConcat) { + StringBuilder sb = new StringBuilder(); + int index = 0; + for(String token : tokens) { + if(index < numberOfTokensToConcat) { + sb.append(token); + } + if(index < numberOfTokensToConcat - 1) { + sb.append("/"); + } + index++; + } + return sb.toString(); + } + + private DefaultMutableTreeNode findNode(String pathToNode) { + String[] tokens = pathToNode.split("/"); + Enumeration enumeration = root.children(); + int index = 0; + DefaultMutableTreeNode lastNode = null; + while(enumeration.hasMoreElements() && index < tokens.length) { + DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); + TreeNodeInfo treeNodeInfo = (TreeNodeInfo) treeNode.getUserObject(); + if(treeNodeInfo.getName().equals(tokens[index])) { + lastNode = treeNode; + index++; + enumeration = treeNode.children(); + } + } + return lastNode != null ? lastNode : root; + } + + private void compressNode(DefaultMutableTreeNode newNode, DefaultMutableTreeNode oldNode) { + Enumeration enumeration = oldNode.children(); + int childCount = oldNode.getChildCount(); + if(childCount == 1) { + while(enumeration.hasMoreElements()) { + DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); + setIdAccordingly(treeNode); + TreeNodeInfo treeNodeInfo = (TreeNodeInfo) treeNode.getUserObject(); + String nodeName = treeNodeInfo.getName(); + if(!nodeName.endsWith(".java")) { + if(oldNode.isRoot()) { + TreeNodeInfo newNodeInfo = new TreeNodeInfo(nodeName, nodeName); + newNode.setUserObject(newNodeInfo); + } + else { + TreeNodeInfo newNodeInfo = (TreeNodeInfo) newNode.getUserObject(); + TreeNodeInfo updatedNodeInfo = new TreeNodeInfo(newNodeInfo.getName() + "/" + nodeName, newNodeInfo.getFullPath() + "/" + nodeName); + newNode.setUserObject(updatedNodeInfo); + } + compressNode(newNode, treeNode); + } + else { + // this node is a leaf + newNode.add(treeNode); + } + } + } + else { + while(enumeration.hasMoreElements()) { + DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode)enumeration.nextElement(); + setIdAccordingly(treeNode); + DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(treeNode.getUserObject()); + newNode.add(newChild); + compressNode(newChild, treeNode); + } + } + } + + private void setIdAccordingly(DefaultMutableTreeNode treeNode) { + if (!treeNode.isLeaf()) return; + TreeNodeInfo nodeInfo = (TreeNodeInfo) treeNode.getUserObject(); + for (int i = 0; i < diffs.size(); i++) { + if (diffs.get(i).getDstPath().equals(nodeInfo.getFullPath())) { + nodeInfo.setId(i); + break; + } + } + } +}