/*
* Copyright 2000-2017 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.codeInsight.editorActions.wordSelection;
import com.intellij.codeInsight.editorActions.ExtendWordSelectionHandlerBase;
import com.intellij.codeInsight.editorActions.SelectWordUtil;
import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.fileTypes.impl.CustomSyntaxTableFileType;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.PsiComment;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiPlainText;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class NaturalLanguageTextSelectioner extends ExtendWordSelectionHandlerBase {
private static final Set<Character> NATURAL = ContainerUtil.newTroveSet(
'(', ')', '.', ',', ':', ';', '!', '?', '$', '@', '%', '\"', '\'', '<', '>', '[', ']', '_'
);
private static final Set<Character> SENTENCE_END = ContainerUtil.newTroveSet('.', '!', '?');
@Override
public boolean canSelect(PsiElement e) {
return (e instanceof PsiPlainText || e instanceof PsiComment) &&
!(e.getContainingFile().getFileType() instanceof CustomSyntaxTableFileType);
}
private static TextRange findParagraphRange(String text, int start, int end) {
int paragraphStart = text.lastIndexOf("\n\n", start);
int paragraphEnd = text.indexOf("\n\n", end);
if (paragraphStart >= paragraphEnd) {
return new TextRange(0, text.length());
}
return new TextRange(paragraphStart >= 0 ? paragraphStart + 2 : 0, paragraphEnd < 0 ? text.length() : paragraphEnd);
}
@Nullable
private static TextRange findCustomRange(String text, int start, int end, char startChar, char endChar) {
int prev = text.lastIndexOf(startChar, start);
int next = text.indexOf(endChar, end);
if (prev < 0 || next < 0) {
return null;
}
if (prev + 1 < start || next > end) {
return new TextRange(prev + 1, next);
}
return new TextRange(prev, next + 1);
}
@Nullable
private static TextRange findSentenceRange(String editorText, int start, int end) {
int sentenceStart = start;
while (sentenceStart > 0) {
if (start - sentenceStart > 1000) return null;
if (isSentenceEnd(editorText, sentenceStart - 1) || !isNatural(editorText.charAt(sentenceStart - 1))) {
break;
}
sentenceStart--;
}
while (sentenceStart < end && Character.isWhitespace(editorText.charAt(sentenceStart))) {
sentenceStart++;
}
int sentenceEnd = Math.max(0, end - 1);
while (sentenceEnd < editorText.length()) {
sentenceEnd++;
if (sentenceEnd - end > 1000) return null;
if (isSentenceEnd(editorText, sentenceEnd - 1)) {
break;
}
}
return new TextRange(sentenceStart, sentenceEnd);
}
private static boolean isSentenceEnd(String text, final int i) {
return SENTENCE_END.contains(text.charAt(i)) && (i + 1 == text.length() || Character.isWhitespace(text.charAt(i + 1)));
}
private static TextRange findNaturalRange(String editorText, int start, int end) {
while (start > 0) {
if (!isNatural(editorText.charAt(start - 1))) {
break;
}
start--;
}
while (end < editorText.length()) {
final char c = editorText.charAt(end);
if (!isNatural(c)) {
break;
}
end++;
}
return new TextRange(start, end);
}
@Override
public List<TextRange> select(PsiElement e, CharSequence editorText, int cursorOffset, Editor editor) {
ArrayList<TextRange> result = new ArrayList<>();
addWordRange(editorText, cursorOffset, result);
TextRange range = expandSelection(e, editorText, cursorOffset, cursorOffset);
if (range != null) {
result.add(range);
while (true) {
TextRange next = expandSelection(e, editorText, range.getStartOffset(), range.getEndOffset());
if (next == null || range.contains(next)) {
break;
}
result.add(next);
range = next;
}
}
return result;
}
private static void addWordRange(CharSequence editorText, int cursorOffset, ArrayList<TextRange> result) {
SelectWordUtil.addWordSelection(false, editorText, cursorOffset, result,
ch -> Character.isJavaIdentifierPart(ch) || ch == '\'');
SelectWordUtil.addWordSelection(false, editorText, cursorOffset, result,
ch -> Character.isJavaIdentifierPart(ch) || ch == '\'' || ch == '-');
}
@Nullable
private static TextRange expandSelection(PsiElement e, CharSequence editorText, int selStart, int selEnd) {
TextRange range = e.getTextRange();
int shift = range.getStartOffset();
if (selStart <= shift || selEnd >= range.getEndOffset()) {
return null;
}
String elementText = editorText.subSequence(shift, range.getEndOffset()).toString();
int start = selStart - shift;
int end = selEnd - shift;
TextRange best = findSentenceRange(elementText, start, end);
if (best == null) return null;
best = narrowRange(best, findCustomRange(elementText, start, end, '\"', '\"'));
best = narrowRange(best, findCustomRange(elementText, start, end, '(', ')'));
best = narrowRange(best, findCustomRange(elementText, start, end, '<', '>'));
best = narrowRange(best, findCustomRange(elementText, start, end, '[', ']'));
TextRange natural = findNaturalRange(elementText, start, end);
if (!natural.contains(best)) {
return null;
}
TextRange paragraph = findParagraphRange(elementText, start, end);
if (best.getStartOffset() == start && best.getEndOffset() == end || !paragraph.contains(best)) {
return paragraph.shiftRight(shift);
}
return best.shiftRight(shift);
}
private static TextRange narrowRange(TextRange best, TextRange candidate) {
return candidate != null && best.contains(candidate) ? candidate : best;
}
private static boolean isNatural(char c) {
return Character.isWhitespace(c) || Character.isLetterOrDigit(c) || NATURAL.contains(c);
}
}