Updated PR: Comment transition detection in block tracking

src/main/java/org/codetracker/BlockTrackerChangeHistory.java

@@ -2,17 +2,10 @@
 
 import java.io.IOException;
 import java.io.StringReader;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.function.Predicate;
-
+import gr.uom.java.xmi.*;
+import gr.uom.java.xmi.diff.*;
 import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.codetracker.api.History;
@@ -37,6 +30,7 @@
 import org.codetracker.change.method.BodyChange;
 import org.codetracker.element.Block;
 import org.codetracker.element.Method;
+import org.codetracker.util.Util;
 import org.refactoringminer.api.Refactoring;
 
 import com.github.difflib.DiffUtils;
@@ -46,11 +40,7 @@
 import com.github.difflib.patch.InsertDelta;
 import com.github.difflib.patch.Patch;
 
-import gr.uom.java.xmi.UMLOperation;
-import gr.uom.java.xmi.UMLType;
-import gr.uom.java.xmi.VariableDeclarationContainer;
 import gr.uom.java.xmi.LocationInfo.CodeElementType;
-import gr.uom.java.xmi.UMLAnonymousClass;
 import gr.uom.java.xmi.decomposition.AbstractCodeFragment;
 import gr.uom.java.xmi.decomposition.AbstractCodeMapping;
 import gr.uom.java.xmi.decomposition.AbstractExpression;
@@ -63,23 +53,9 @@
 import gr.uom.java.xmi.decomposition.TryStatementObject;
 import gr.uom.java.xmi.decomposition.UMLOperationBodyMapper;
 import gr.uom.java.xmi.decomposition.VariableDeclaration;
-import gr.uom.java.xmi.diff.ExtractOperationRefactoring;
-import gr.uom.java.xmi.diff.InlineOperationRefactoring;
-import gr.uom.java.xmi.diff.MergeOperationRefactoring;
-import gr.uom.java.xmi.diff.MoveCodeRefactoring;
-import gr.uom.java.xmi.diff.MoveOperationRefactoring;
-import gr.uom.java.xmi.diff.PullUpOperationRefactoring;
-import gr.uom.java.xmi.diff.PushDownOperationRefactoring;
-import gr.uom.java.xmi.diff.RenameOperationRefactoring;
-import gr.uom.java.xmi.diff.ReplaceAnonymousWithClassRefactoring;
-import gr.uom.java.xmi.diff.ReplaceAnonymousWithLambdaRefactoring;
-import gr.uom.java.xmi.diff.ReplaceConditionalWithTernaryRefactoring;
-import gr.uom.java.xmi.diff.ReplaceLoopWithPipelineRefactoring;
-import gr.uom.java.xmi.diff.ReplacePipelineWithLoopRefactoring;
-import gr.uom.java.xmi.diff.SplitConditionalRefactoring;
-import gr.uom.java.xmi.diff.SplitOperationRefactoring;
-import gr.uom.java.xmi.diff.UMLAbstractClassDiff;
-import gr.uom.java.xmi.diff.UMLAnonymousClassDiff;
+
+import static org.codetracker.util.CommentTransitionAnalyzer.*;
+
 
 public class BlockTrackerChangeHistory extends AbstractChangeHistory<Block> {
 	private final ChangeHistory<Block> blockChangeHistory = new ChangeHistory<>();
@@ -693,9 +669,38 @@ public boolean checkBodyOfMatchedOperations(Version currentVersion, Version pare
         // check if it is in the matched
         if (isMatched(umlOperationBodyMapper, currentVersion, parentVersion, equalOperator))
             return true;
-        //Check if is added
+        //check if block got uncommented
+        if(isBlockUncommented(umlOperationBodyMapper, currentVersion, parentVersion, equalOperator)){
+            return true;
+        }
+//        Check if is added
         return isAdded(umlOperationBodyMapper, currentVersion, parentVersion, equalOperator);
     }
+    public boolean isBlockUncommented(UMLOperationBodyMapper umlOperationBodyMapper, Version currentVersion, Version parentVersion, Predicate<Block> equalOperator) {
+        List<CompositeStatementObject> currentNonMappedInnerNodes = umlOperationBodyMapper.getNonMappedInnerNodesT2();
+        UMLCommentListDiff umlCommentListDiff = umlOperationBodyMapper.getCommentListDiff();
+       List<UMLComment> deletedComments = umlCommentListDiff.getDeletedComments();
+        if(currentNonMappedInnerNodes.size() == 0 || deletedComments == null || deletedComments.isEmpty())
+            return false;
+        Map<String, UMLComment> deletedCommentsHashMap =  generateCommentTextHashMap(deletedComments);
+        for(CompositeStatementObject nonMappedInnerNode : currentNonMappedInnerNodes) {
+            String hashOfNonMappedInnerNode = Util.getSHA512(nonMappedInnerNode.getActualSignature());
+            if (!deletedCommentsHashMap.containsKey(hashOfNonMappedInnerNode))
+                continue;
+            Block blockAfter = Block.of(nonMappedInnerNode, umlOperationBodyMapper.getContainer2(), currentVersion);
+            if (!equalOperator.test(blockAfter))
+                continue;
+            //check block body continuity
+            if (!isBlockBodyUnchangedDuringUncomment(umlOperationBodyMapper, nonMappedInnerNode, deletedCommentsHashMap, blockAfter))
+                continue;
+            Block virtualBlockBefore = Block.of(nonMappedInnerNode, umlOperationBodyMapper.getContainer2(), parentVersion); // add metadata later, flag isVirtual = true;
+            blockChangeHistory.addChange(virtualBlockBefore, blockAfter, ChangeFactory.forBlock(Change.Type.UNCOMMENTED_BLOCK));
+            elements.add(virtualBlockBefore);
+            blockChangeHistory.connectRelatedNodes();
+            return true;
+            }
+        return false;
+    }
 
     public boolean isBlockRefactored(Collection<Refactoring> refactorings, Version currentVersion, Version parentVersion, Predicate<Block> equalOperator) {
         Set<Block> leftBlockSet = analyseBlockRefactorings(refactorings, currentVersion, parentVersion, equalOperator);
@@ -1137,7 +1142,16 @@ public boolean isMatched(UMLOperationBodyMapper umlOperationBodyMapper, Version
                         List<String> stringRepresentationBodyBefore = stringRepresentationBefore.subList(1, stringRepresentationBefore.size());
                         List<String> stringRepresentationBodyAfter = stringRepresentationAfter.subList(1, stringRepresentationAfter.size());
                         if (!stringRepresentationBodyBefore.equals(stringRepresentationBodyAfter)) {
-                            blockChangeHistory.addChange(blockBefore, blockAfter, ChangeFactory.forBlock(Change.Type.BODY_CHANGE));
+                            Set<Change.Type> commentTransitions = DetectCommentTransitionsInsideMatchedBlock(umlOperationBodyMapper, blockBefore, blockAfter, currentVersion, parentVersion);
+                            if(!commentTransitions.isEmpty()){
+                                for(Change.Type changeType : commentTransitions){
+                                    blockChangeHistory.addChange(blockBefore, blockAfter, ChangeFactory.forBlock(changeType));
+                                }
+                            }
+                            else{
+                                blockChangeHistory.addChange(blockBefore, blockAfter, ChangeFactory.forBlock(Change.Type.BODY_CHANGE));
+                            }
+
                         }
                         bodyChange = true;
                     }

src/main/java/org/codetracker/change/Change.java

@@ -56,8 +56,10 @@ enum Type {
         INITIALIZER_ADDED("initializer added"),
         INITIALIZER_REMOVED("initializer removed"),
         SUPERCLASS_CHANGE("superclass change"),
-        INTERFACE_LIST_CHANGE("interface list change");
-
+        INTERFACE_LIST_CHANGE("interface list change"),
+        COMMENTED_OUT_STATEMENT("commented out statement"),
+        UNCOMMENTED_STATEMENT("uncommented statement"),
+        UNCOMMENTED_BLOCK("uncommented Block");
         private static final Map<String, Type> lookup = new HashMap<>();
 
         static {

src/main/java/org/codetracker/change/ChangeFactory.java

@@ -141,6 +141,19 @@ public AbstractChange build() {
                 change = new BodyChange();
                 break;
             }
+            case UNCOMMENTED_STATEMENT:{
+                change = new UncommentedCodeInBlock();
+                break;
+            }
+            case COMMENTED_OUT_STATEMENT:{
+                change = new CommentedOutCodeInBlock();
+                break;
+            }
+            case UNCOMMENTED_BLOCK:{
+                change = new UncommentedBlock();
+                break;
+            }
+
             case CATCH_BLOCK_CHANGE: {
                 change = new CatchBlockChange();
                 break;

src/main/java/org/codetracker/change/block/CommentedOutCodeInBlock.java

@@ -0,0 +1,13 @@
+package org.codetracker.change.block;
+
+public class CommentedOutCodeInBlock extends BlockBodyChange {
+    public CommentedOutCodeInBlock() {
+        super(Type.COMMENTED_OUT_STATEMENT);
+    }
+
+    @Override
+    public String toString() {
+        return "Body Change, Contains Commented-out Code";
+    }
+
+}

src/main/java/org/codetracker/change/block/UncommentedBlock.java

@@ -0,0 +1,13 @@
+package org.codetracker.change.block;
+
+public class UncommentedBlock extends BlockChange {
+    public UncommentedBlock() {
+        super(Type.UNCOMMENTED_BLOCK);
+    }
+
+    @Override
+    public String toString() {
+        return "Block Change, Uncommented Block";
+    }
+
+}

src/main/java/org/codetracker/change/block/UncommentedCodeInBlock.java

@@ -0,0 +1,15 @@
+package org.codetracker.change.block;
+
+import org.codetracker.change.Change;
+
+public class UncommentedCodeInBlock extends BlockBodyChange {
+    public UncommentedCodeInBlock() {
+        super(Change.Type.UNCOMMENTED_STATEMENT);
+    }
+
+    @Override
+    public String toString() {
+        return "Body Change, Contains Uncommented Code";
+    }
+
+}