2683

pending completion

Build # 2683

Build Type

Pull #1637

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/javaparser/javaparser/commit/<a class=hub.com/javaparser/javaparser/commit/<a class="double-link" href="https://git"><a class=hub.com/javaparser/javaparser/commit/<a class="double-link" href="https://git"><a class=hub.com/javaparser/javaparser/commit/<a class="double-link" href="https://git"><a class=hub.com/javaparser/javaparser/commit/2c2bd85b56e09e87124975139d3f3a73377276fa">2c2bd85b5">&lt;a href=&quot;https://github.com/javaparser/javaparser/commit/</a><a class="double-link" href="https://github.com/javaparser/javaparser/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/javaparser/javaparser/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/javaparser/javaparser/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/javaparser/javaparser/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/javaparser/javaparser/commit/2c2bd85b56e09e87124975139d3f3a73377276fa">2c2bd85b5</a><a href="https://github.com/javaparser/javaparser/commit/2c2bd85b56e09e87124975139d3f3a73377276fa">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/javaparser/javaparser/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/javaparser/javaparser/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/javaparser/javaparser/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/javaparser/javaparser/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/javaparser/javaparser/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/javaparser/javaparser/commit/2c2bd85b56e09e87124975139d3f3a73377276fa&quot;&gt;2c2bd85b5&lt;/a&gt;&lt;a href=&quot;https://github.com/javaparser/javaparser/commit/2c2bd85b56e09e87124975139d3f3a73377276fa&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/javaparser/javaparser/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp... (continued)

Pull Request Pull Request #1637:

Run Details

199 of 199 new or added lines in 3 files covered. (100.0%)

17321 of 27651 relevant lines covered (62.64%)

0.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.65

/javaparser-core/src/main/java/com/github/javaparser/printer/lexicalpreservation/RemovedGroup.java

package com.github.javaparser.printer.lexicalpreservation;

import com.github.javaparser.JavaToken;
import com.github.javaparser.TokenRange;
import com.github.javaparser.TokenTypes;
import com.github.javaparser.ast.Node;
import com.github.javaparser.printer.concretesyntaxmodel.CsmToken;

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;

class RemovedGroup implements Iterable<Removed> {

    private final Integer firstElementIndex;
    private final List<Removed> removedList;

    private boolean isProcessed = false;

    private RemovedGroup(Integer firstElementIndex, List<Removed> removedList) {
        if (firstElementIndex == null) {
            throw new IllegalArgumentException("firstElementIndex should not be null");
        }

        if (removedList == null || removedList.isEmpty()) {
            throw new IllegalArgumentException("removedList should not be null or empty");
        }

        this.firstElementIndex = firstElementIndex;
        this.removedList = removedList;
    }

    /**
     * Factory method to create a RemovedGroup which consists of consecutive Removed elements
     *
     * @param firstElementIndex the difference index at which the RemovedGroup starts
     * @param removedList list of the consecutive Removed elements
     * @return a RemovedGroup object
     */
    public static RemovedGroup of(Integer firstElementIndex, List<Removed> removedList) {
        return new RemovedGroup(firstElementIndex, removedList);
    }

    /**
     * Marks the RemovedGroup as processed which indicates that it should not be processed again
     */
    void processed() {
        isProcessed = true;
    }

    /**
     * Returns whether the RemovedGroup was already processed and should not be processed again
     *
     * @return wheter the RemovedGroup was already processed
     */
    boolean isProcessed() {
        return isProcessed;
    }

    private List<Integer> getIndicesBeingRemoved() {
        return IntStream.range(firstElementIndex, firstElementIndex + removedList.size())
                .boxed()
                .collect(Collectors.toList());
    }

    /**
     * Returns the difference index of the last element being removed with this RemovedGroup
     *
     * @return the last difference incex of this RemovedGroup
     */
    Integer getLastElementIndex() {
        List<Integer> indicesBeingRemoved = getIndicesBeingRemoved();
        return indicesBeingRemoved.get(indicesBeingRemoved.size() - 1);
    }

    /**
     * Returns the first element of this RemovedGroup
     *
     * @return the first element of this RemovedGroup
     */
    Removed getFirstElement() {
        return removedList.get(0);
    }

    /**
     * Returns the last element of this RemovedGroup
     *
     * @return the last element of this RemovedGroup
     */
    Removed getLastElement() {
        return removedList.get(removedList.size() - 1);
    }

    /**
     * Returns true if the RemovedGroup equates to a complete line
     * This is the case if there are only spaces and tabs left on the line besides the Removed elements.
     * <br/>
     * Example:
     * <pre>
     * "  [Removed] [EOL]" -> this would be a complete line, regardless of spaces or tabs before or after the [Removed] element
     * "  [Removed] void [EOL]" -> this would not be a complete line because of the "void"
     * "  public [Removed] [EOL]" -> this would not be a complete line because of the "public"
     * </pre>
     *
     * @return true if the RemovedGroup equates to a complete line
     */
    boolean isACompleteLine() {
        return hasOnlyWhitespace(getFirstElement(), hasOnlyWhitespaceInFrontFunction)
                && hasOnlyWhitespace(getLastElement(), hasOnlyWhitespaceBehindFunction);
    }

    private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenInFrontFunction = begin -> hasOnlyWhiteSpaceForTokenFunction(begin, token -> token.getPreviousToken());
    private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenBehindFunction = end -> hasOnlyWhiteSpaceForTokenFunction(end, token -> token.getNextToken());
    private final Function<TokenRange, Boolean> hasOnlyWhitespaceInFrontFunction = tokenRange -> hasOnlyWhitespaceJavaTokenInFrontFunction.apply(tokenRange.getBegin());
    private final Function<TokenRange, Boolean> hasOnlyWhitespaceBehindFunction = tokenRange -> hasOnlyWhitespaceJavaTokenBehindFunction.apply(tokenRange.getEnd());

    private boolean hasOnlyWhitespace(Removed startElement, Function<TokenRange, Boolean> hasOnlyWhitespaceFunction) {
        boolean hasOnlyWhitespace = false;
        if (startElement.isChild()) {
            LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) startElement.getElement();
            Node child = csmChild.getChild();

            Optional<TokenRange> tokenRange = child.getTokenRange();
            if (tokenRange.isPresent()) {
                hasOnlyWhitespace = hasOnlyWhitespaceFunction.apply(tokenRange.get());
            }
        } else if (startElement.isToken()) {
            CsmToken token = (CsmToken) startElement.getElement();
            if (TokenTypes.isEndOfLineToken(token.getTokenType())) {
                hasOnlyWhitespace = true;
            }
        }
        return hasOnlyWhitespace;
    }

    private boolean hasOnlyWhiteSpaceForTokenFunction(JavaToken token, Function<JavaToken, Optional<JavaToken>> tokenFunction) {
        Optional<JavaToken> tokenResult = tokenFunction.apply(token);

        if (tokenResult.isPresent()) {
            if (TokenTypes.isSpaceOrTab(tokenResult.get().getKind())) {
                return hasOnlyWhiteSpaceForTokenFunction(tokenResult.get(), tokenFunction);
            } else if (TokenTypes.isEndOfLineToken(tokenResult.get().getKind())) {
                return true;
            } else {
                return false;
            }
        }

        return true;
    }

    /**
     * Returns the indentation in front of this RemovedGroup if possible.
     * If there is something else than whitespace in front, Optional.empty() is returned.
     *
     * @return the indentation in front of this RemovedGroup or Optional.empty()
     */
    Optional<Integer> getIndentation() {
        Removed firstElement = getFirstElement();

        int indentation = 0;
        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();

                if (hasOnlyWhitespaceJavaTokenInFrontFunction.apply(begin)) {
                    Optional<JavaToken> previousToken = begin.getPreviousToken();

                    while(previousToken.isPresent() && (TokenTypes.isSpaceOrTab(previousToken.get().getKind()))) {
                        indentation++;

                        previousToken = previousToken.get().getPreviousToken();
                    }

                    if (previousToken.isPresent()) {
                        if (TokenTypes.isEndOfLineToken(previousToken.get().getKind())) {
                            return Optional.of(Integer.valueOf(indentation));
                        } else {
                            return Optional.empty();
                        }
                    } else {
                        return Optional.of(Integer.valueOf(indentation));
                    }
                }
            }
        }

        return Optional.empty();
    }

    @Override
    public Iterator<Removed> iterator() {
        return new Iterator<Removed>() {
            private int currentIndex = 0;

            @Override
            public boolean hasNext() {
                return currentIndex < removedList.size() && removedList.get(currentIndex) != null;
            }

            @Override
            public Removed next() {
                return removedList.get(currentIndex++);
            }

        };
    }
}

1	package com.github.javaparser.printer.lexicalpreservation;
2
3	import com.github.javaparser.JavaToken;
4	import com.github.javaparser.TokenRange;
5	import com.github.javaparser.TokenTypes;
6	import com.github.javaparser.ast.Node;
7	import com.github.javaparser.printer.concretesyntaxmodel.CsmToken;
8
9	import java.util.Iterator;
10	import java.util.List;
11	import java.util.Optional;
12	import java.util.function.Function;
13	import java.util.stream.Collectors;
14	import java.util.stream.IntStream;
15
16	class RemovedGroup implements Iterable<Removed> {
17
18	private final Integer firstElementIndex;
19	private final List<Removed> removedList;
20
21	private boolean isProcessed = false;	1✔
22
23	private RemovedGroup(Integer firstElementIndex, List<Removed> removedList) {	1✔
24	if (firstElementIndex == null) {	1✔
25	throw new IllegalArgumentException("firstElementIndex should not be null");	×
26	}
27
28	if (removedList == null \|\| removedList.isEmpty()) {	1✔
29	throw new IllegalArgumentException("removedList should not be null or empty");	×
30	}
31
32	this.firstElementIndex = firstElementIndex;	1✔
33	this.removedList = removedList;	1✔
34	}	1✔
35
36	/**
37	* Factory method to create a RemovedGroup which consists of consecutive Removed elements
38	*
39	* @param firstElementIndex the difference index at which the RemovedGroup starts
40	* @param removedList list of the consecutive Removed elements
41	* @return a RemovedGroup object
42	*/
43	public static RemovedGroup of(Integer firstElementIndex, List<Removed> removedList) {
44	return new RemovedGroup(firstElementIndex, removedList);	1✔
45	}
46
47	/**
48	* Marks the RemovedGroup as processed which indicates that it should not be processed again
49	*/
50	void processed() {
51	isProcessed = true;	1✔
52	}	1✔
53
54	/**
55	* Returns whether the RemovedGroup was already processed and should not be processed again
56	*
57	* @return wheter the RemovedGroup was already processed
58	*/
59	boolean isProcessed() {
60	return isProcessed;	1✔
61	}
62
63	private List<Integer> getIndicesBeingRemoved() {
64	return IntStream.range(firstElementIndex, firstElementIndex + removedList.size())	1✔
65	.boxed()	1✔
66	.collect(Collectors.toList());	1✔
67	}
68
69	/**
70	* Returns the difference index of the last element being removed with this RemovedGroup
71	*
72	* @return the last difference incex of this RemovedGroup
73	*/
74	Integer getLastElementIndex() {
75	List<Integer> indicesBeingRemoved = getIndicesBeingRemoved();	1✔
76	return indicesBeingRemoved.get(indicesBeingRemoved.size() - 1);	1✔
77	}
78
79	/**
80	* Returns the first element of this RemovedGroup
81	*
82	* @return the first element of this RemovedGroup
83	*/
84	Removed getFirstElement() {
85	return removedList.get(0);	1✔
86	}
87
88	/**
89	* Returns the last element of this RemovedGroup
90	*
91	* @return the last element of this RemovedGroup
92	*/
93	Removed getLastElement() {
94	return removedList.get(removedList.size() - 1);	1✔
95	}
96
97	/**
98	* Returns true if the RemovedGroup equates to a complete line
99	* This is the case if there are only spaces and tabs left on the line besides the Removed elements.
100	* <br/>
101	* Example:
102	* <pre>
103	* " [Removed] [EOL]" -> this would be a complete line, regardless of spaces or tabs before or after the [Removed] element
104	* " [Removed] void [EOL]" -> this would not be a complete line because of the "void"
105	* " public [Removed] [EOL]" -> this would not be a complete line because of the "public"
106	* </pre>
107	*
108	* @return true if the RemovedGroup equates to a complete line
109	*/
110	boolean isACompleteLine() {
111	return hasOnlyWhitespace(getFirstElement(), hasOnlyWhitespaceInFrontFunction)	1✔
112	&& hasOnlyWhitespace(getLastElement(), hasOnlyWhitespaceBehindFunction);	1✔
113	}
114
115	private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenInFrontFunction = begin -> hasOnlyWhiteSpaceForTokenFunction(begin, token -> token.getPreviousToken());	1✔
116	private final Function<JavaToken, Boolean> hasOnlyWhitespaceJavaTokenBehindFunction = end -> hasOnlyWhiteSpaceForTokenFunction(end, token -> token.getNextToken());	1✔
117	private final Function<TokenRange, Boolean> hasOnlyWhitespaceInFrontFunction = tokenRange -> hasOnlyWhitespaceJavaTokenInFrontFunction.apply(tokenRange.getBegin());	1✔
118	private final Function<TokenRange, Boolean> hasOnlyWhitespaceBehindFunction = tokenRange -> hasOnlyWhitespaceJavaTokenBehindFunction.apply(tokenRange.getEnd());	1✔
119
120	private boolean hasOnlyWhitespace(Removed startElement, Function<TokenRange, Boolean> hasOnlyWhitespaceFunction) {
121	boolean hasOnlyWhitespace = false;	1✔
122	if (startElement.isChild()) {	1✔
123	LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) startElement.getElement();	1✔
124	Node child = csmChild.getChild();	1✔
125
126	Optional<TokenRange> tokenRange = child.getTokenRange();	1✔
127	if (tokenRange.isPresent()) {	1✔
128	hasOnlyWhitespace = hasOnlyWhitespaceFunction.apply(tokenRange.get());	1✔
129	}
130	} else if (startElement.isToken()) {	1✔
131	CsmToken token = (CsmToken) startElement.getElement();	1✔
132	if (TokenTypes.isEndOfLineToken(token.getTokenType())) {	1✔
133	hasOnlyWhitespace = true;	1✔
134	}
135	}
136	return hasOnlyWhitespace;	1✔
137	}
138
139	private boolean hasOnlyWhiteSpaceForTokenFunction(JavaToken token, Function<JavaToken, Optional<JavaToken>> tokenFunction) {
140	Optional<JavaToken> tokenResult = tokenFunction.apply(token);	1✔
141
142	if (tokenResult.isPresent()) {	1✔
143	if (TokenTypes.isSpaceOrTab(tokenResult.get().getKind())) {	1✔
144	return hasOnlyWhiteSpaceForTokenFunction(tokenResult.get(), tokenFunction);	1✔
145	} else if (TokenTypes.isEndOfLineToken(tokenResult.get().getKind())) {	1✔
146	return true;	1✔
147	} else {
148	return false;	1✔
149	}
150	}
151
152	return true;	1✔
153	}
154
155	/**
156	* Returns the indentation in front of this RemovedGroup if possible.
157	* If there is something else than whitespace in front, Optional.empty() is returned.
158	*
159	* @return the indentation in front of this RemovedGroup or Optional.empty()
160	*/
161	Optional<Integer> getIndentation() {
162	Removed firstElement = getFirstElement();	1✔
163
164	int indentation = 0;	1✔
165	if (firstElement.isChild()) {	1✔
166	LexicalDifferenceCalculator.CsmChild csmChild = (LexicalDifferenceCalculator.CsmChild) firstElement.getElement();	1✔
167	Node child = csmChild.getChild();	1✔
168
169	Optional<TokenRange> tokenRange = child.getTokenRange();	1✔
170	if (tokenRange.isPresent()) {	1✔
171	JavaToken begin = tokenRange.get().getBegin();	1✔
172
173	if (hasOnlyWhitespaceJavaTokenInFrontFunction.apply(begin)) {	1✔
174	Optional<JavaToken> previousToken = begin.getPreviousToken();	1✔
175
176	while(previousToken.isPresent() && (TokenTypes.isSpaceOrTab(previousToken.get().getKind()))) {	1✔
177	indentation++;	1✔
178
179	previousToken = previousToken.get().getPreviousToken();	1✔
180	}
181
182	if (previousToken.isPresent()) {	1✔
183	if (TokenTypes.isEndOfLineToken(previousToken.get().getKind())) {	1✔
184	return Optional.of(Integer.valueOf(indentation));	1✔
185	} else {
186	return Optional.empty();	×
187	}
188	} else {
189	return Optional.of(Integer.valueOf(indentation));	1✔
190	}
191	}
192	}
193	}
194
195	return Optional.empty();	1✔
196	}
197
198	@Override
199	public Iterator<Removed> iterator() {
200	return new Iterator<Removed>() {	1✔
201	private int currentIndex = 0;	1✔
202
203	@Override
204	public boolean hasNext() {
205	return currentIndex < removedList.size() && removedList.get(currentIndex) != null;	1✔
206	}
207
208	@Override
209	public Removed next() {
210	return removedList.get(currentIndex++);	1✔
211	}
212
213	};
214	}
215	}

javaparser / javaparser / 2683

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous