cleanup of RemovedGroup

javaparser · Jun 7, 2018 · 4107897 · 4107897
1 parent 5b277fe
commit 4107897
Showing 1 changed file with 24 additions and 53 deletions.
diff --git a/...er-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/RemovedGroup.java b/...er-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/RemovedGroup.java
@@ -9,6 +9,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -100,71 +101,41 @@ Removed getLastElement() {
      * @return true if the RemovedGroup equates to a complete line
      */
     boolean isACompleteLine() {
-        Removed firstElement = getFirstElement();
+        return hasOnlyWhitespace(getFirstElement(), hasOnlyWhitespaceInFrontFunction)
-
+                && hasOnlyWhitespace(getLastElement(), hasOnlyWhitespaceBehindFunction);
-        boolean hasOnlyWhitespaceInFront = false;
+    }
-        if (firstElement.isChild()) {
-            LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) firstElement.getElement();
-            Node child = csmChild.getChild();
-
-            Optional<TokenRange> tokenRange = child.getTokenRange();
-            if (tokenRange.isPresent()) {
-                JavaToken begin = tokenRange.get().getBegin();
 
-                hasOnlyWhitespaceInFront = hasOnlyWhitespaceInFront(begin);
+    private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenInFrontFunction = begin -> hasOnlyWhiteSpaceForTokenFunction(begin, token -> token.getPreviousToken());
-            }
+    private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenBehindFunction = end -> hasOnlyWhiteSpaceForTokenFunction(end, token -> token.getNextToken());
-        } else if (firstElement.isToken()) {
+    private final Function<TokenRange, Boolean> hasOnlyWhitespaceInFrontFunction = tokenRange -> hasOnlyWhitespaceJavaTokenInFrontFunction.apply(tokenRange.getBegin());
-            CsmToken token = (CsmToken) firstElement.getElement();
+    private final Function<TokenRange, Boolean> hasOnlyWhitespaceBehindFunction = tokenRange -> hasOnlyWhitespaceJavaTokenBehindFunction.apply(tokenRange.getEnd());
-            if (TokenTypes.isEndOfLineToken(token.getTokenType())) {
-                hasOnlyWhitespaceInFront = true;
-            }
-        }
 
-        Removed lastElement = getLastElement();
+    private boolean hasOnlyWhitespace(Removed startElement, Function<TokenRange, Boolean> hasOnlyWhitespaceFunction) {
-        boolean hasOnlyWhitespaceBehind = false;
+        boolean hasOnlyWhitespace = false;
-        if (lastElement.isChild()) {
+        if (startElement.isChild()) {
-            LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) lastElement.getElement();
+            LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) startElement.getElement();
             Node child = csmChild.getChild();
 
             Optional<TokenRange> tokenRange = child.getTokenRange();
             if (tokenRange.isPresent()) {
-                JavaToken end = tokenRange.get().getEnd();
+                hasOnlyWhitespace = hasOnlyWhitespaceFunction.apply(tokenRange.get());
-
-                hasOnlyWhitespaceBehind = hasOnlyWhitespaceBehind(end);
             }
-        } else if (lastElement.isToken()) {
+        } else if (startElement.isToken()) {
-            CsmToken token = (CsmToken) lastElement.getElement();
+            CsmToken token = (CsmToken) startElement.getElement();
             if (TokenTypes.isEndOfLineToken(token.getTokenType())) {
-                hasOnlyWhitespaceBehind = true;
+                hasOnlyWhitespace = true;
             }
         }
-
+        return hasOnlyWhitespace;
-        return hasOnlyWhitespaceInFront && hasOnlyWhitespaceBehind;
-    }
-
-    private boolean hasOnlyWhitespaceInFront(JavaToken token) {
-        Optional<JavaToken> previousToken = token.getPreviousToken();
-
-        if (previousToken.isPresent()) {
-            if (TokenTypes.isSpaceOrTab(previousToken.get().getKind())){
-                return hasOnlyWhitespaceInFront(previousToken.get());
-            } else if (TokenTypes.isEndOfLineToken(previousToken.get().getKind())) {
-                return true;
-            } else {
-                return false;
-            }
-        }
-
-        return true;
     }
 
-    private boolean hasOnlyWhitespaceBehind(JavaToken token) {
+    private boolean hasOnlyWhiteSpaceForTokenFunction(JavaToken token, Function<JavaToken, Optional<JavaToken>> tokenFunction) {
-        Optional<JavaToken> nextToken = token.getNextToken();
+        Optional<JavaToken> tokenResult = tokenFunction.apply(token);
 
-        if (nextToken.isPresent()) {
+        if (tokenResult.isPresent()) {
-            if (TokenTypes.isSpaceOrTab(nextToken.get().getKind())) {
+            if (TokenTypes.isSpaceOrTab(tokenResult.get().getKind())) {
-                return hasOnlyWhitespaceInFront(nextToken.get());
+                return hasOnlyWhiteSpaceForTokenFunction(tokenResult.get(), tokenFunction);
-            } else if (TokenTypes.isEndOfLineToken(nextToken.get().getKind())) {
+            } else if (TokenTypes.isEndOfLineToken(tokenResult.get().getKind())) {
                 return true;
             } else {
                 return false;
@@ -192,7 +163,7 @@ Optional<Integer> getIndentation() {
             if (tokenRange.isPresent()) {
                 JavaToken begin = tokenRange.get().getBegin();
 
-                if (hasOnlyWhitespaceInFront(begin)) {
+                if (hasOnlyWhitespaceJavaTokenInFrontFunction.apply(begin)) {
                     Optional<JavaToken> previousToken = begin.getPreviousToken();
 
                     while(previousToken.isPresent() && (TokenTypes.isSpaceOrTab(previousToken.get().getKind()))) {