blaze-base/src/com/google/idea/blaze/base/lang/buildfile/editor/BuildEnterHandler.java - intellij - Git at Google

 /*
  * Copyright 2016 The Bazel Authors. All rights reserved.
  *
  * 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.google.idea.blaze.base.lang.buildfile.editor;

 import com.google.idea.blaze.base.lang.buildfile.lexer.BuildToken;
 import com.google.idea.blaze.base.lang.buildfile.psi.*;
 import com.google.idea.blaze.base.lang.buildfile.psi.util.PsiUtils;
 import com.intellij.codeInsight.editorActions.enter.EnterHandlerDelegateAdapter;
 import com.intellij.ide.DataManager;
 import com.intellij.injected.editor.EditorWindow;
 import com.intellij.lang.injection.InjectedLanguageManager;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.LogicalPosition;
 import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
 import com.intellij.openapi.editor.actions.SplitLineAction;
 import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
 import com.intellij.psi.codeStyle.CommonCodeStyleSettings.IndentOptions;
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
 import com.intellij.util.text.CharArrayUtil;

 import javax.annotation.Nullable;

 /**
  * Inserts indents as appropriate when enter is pressed.<br>
  * This is a substitute for implementing a full FormattingModel for the BUILD language.
  * If we ever decide to do that, this code should be removed.
  */
 public class BuildEnterHandler extends EnterHandlerDelegateAdapter {

   @Override
   public Result preprocessEnter(PsiFile file,
                                 Editor editor,
                                 Ref<Integer> caretOffset,
                                 Ref<Integer> caretAdvance,
                                 DataContext dataContext,
                                 EditorActionHandler originalHandler) {
     int offset = caretOffset.get();
     if (editor instanceof EditorWindow) {
       file = InjectedLanguageManager.getInstance(file.getProject()).getTopLevelFile(file);
       editor = InjectedLanguageUtil.getTopLevelEditor(editor);
       offset = editor.getCaretModel().getOffset();
     }
     if (!isApplicable(file, dataContext)) {
       return Result.Continue;
     }

     // Previous enter handler's (e.g. EnterBetweenBracesHandler) can introduce a mismatch
     // between the editor's caret model and the offset we've been provided with.
     editor.getCaretModel().moveToOffset(offset);

     Document doc = editor.getDocument();
     PsiDocumentManager.getInstance(file.getProject()).commitDocument(doc);

     CodeStyleSettings currentSettings = CodeStyleSettingsManager.getSettings(file.getProject());
     IndentOptions indentOptions = currentSettings.getIndentOptions(file.getFileType());

     Integer indent = determineIndent(file, editor, offset, indentOptions);
     if (indent == null) {
       return Result.Continue;
     }

     removeTrailingWhitespace(doc, file, offset);
     originalHandler.execute(editor, editor.getCaretModel().getCurrentCaret(), dataContext);
     LogicalPosition position = editor.getCaretModel().getLogicalPosition();
     if (position.column == indent) {
       return Result.Stop;
     }
     if (position.column > indent) {
       //default enter handler has added too many spaces -- remove them
       int excess = position.column - indent;
       doc.deleteString(editor.getCaretModel().getOffset() - excess, editor.getCaretModel().getOffset());
     } else if (position.column < indent) {
       String spaces = StringUtil.repeatSymbol(' ', indent - position.column);
       doc.insertString(editor.getCaretModel().getOffset(), spaces);
     }
     editor.getCaretModel().moveToLogicalPosition(new LogicalPosition(position.line, indent));
     return Result.Stop;
   }

   private static void removeTrailingWhitespace(Document doc, PsiFile file, int offset) {
     CharSequence chars = doc.getCharsSequence();
     int start = offset;
     while (offset < chars.length() && chars.charAt(offset) == ' ') {
       PsiElement element = file.findElementAt(offset);
       if (element == null || !(element instanceof PsiWhiteSpace)) {
         break;
       }
       offset++;
     }
     if (start != offset) {
       doc.deleteString(start, offset);
     }
   }

   private static boolean isApplicable(PsiFile file, DataContext dataContext) {
     if (!(file instanceof BuildFile)) {
       return false;
     }
     Boolean isSplitLine = DataManager.getInstance().loadFromDataContext(dataContext, SplitLineAction.SPLIT_LINE_KEY);
     if (isSplitLine != null) {
       return false;
     }
     return true;
   }

   /**
    * Returns null if an appropriate indent cannot be found. In that case we do nothing,
    * and pass it along to the next EnterHandler.
    */
   @Nullable
   private static Integer determineIndent(PsiFile file, Editor editor, int offset, IndentOptions indentOptions) {
     if (offset == 0) {
       return null;
     }
     Document doc = editor.getDocument();
     PsiElement element = getRelevantElement(file, doc, offset);
     PsiElement parent = element != null ? element.getParent() : null;
     if (parent == null) {
       return null;
     }
     if (endsBlock(element)) {
       // current line indent subtract block indent
       return Math.max(0, getIndent(doc, element) - indentOptions.INDENT_SIZE);
     }

     if (parent instanceof BuildListType) {
       BuildListType list = (BuildListType) parent;
       int listOffset = list.getStartOffset();
       LogicalPosition caretPosition = editor.getCaretModel().getLogicalPosition();
       LogicalPosition listStart = editor.offsetToLogicalPosition(listOffset);
       if (listStart.line != caretPosition.line) {
         // take the minimum of the current line's indent and the current caret position
         return indentOfLineUpToCaret(doc, caretPosition.line, offset);
       }
       BuildElement firstChild = ((BuildListType) parent).getFirstElement();
       if (firstChild != null && firstChild.getNode().getStartOffset() < offset) {
         return getIndent(doc, firstChild);
       }
       return lineIndent(doc, listStart.line) + additionalIndent(parent, indentOptions);
     }
     if (parent instanceof StatementListContainer && afterColon(doc, offset)) {
       return getIndent(doc, parent) + additionalIndent(parent, indentOptions);
     }
     return null;
   }

   private static int additionalIndent(PsiElement parent, IndentOptions indentOptions) {
     return parent instanceof StatementListContainer
       ? indentOptions.INDENT_SIZE : indentOptions.CONTINUATION_INDENT_SIZE;
   }

   private static int lineIndent(Document doc, int line) {
     int startOffset = doc.getLineStartOffset(line);
     int indentOffset = CharArrayUtil.shiftForward(doc.getCharsSequence(), startOffset, " \t");
     return indentOffset - startOffset;
   }

   private static int getIndent(Document doc, PsiElement element) {
     int offset = element.getNode().getStartOffset();
     int lineNumber = doc.getLineNumber(offset);
     return offset - doc.getLineStartOffset(lineNumber);
   }

   private static int indentOfLineUpToCaret(Document doc, int line, int caretOffset) {
     int startOffset = doc.getLineStartOffset(line);
     int indentOffset = CharArrayUtil.shiftForward(doc.getCharsSequence(), startOffset, " \t");
     return Math.min(indentOffset, caretOffset) - startOffset;
   }

   private static boolean endsBlock(PsiElement element) {
     return element instanceof ReturnStatement
       || element instanceof PassStatement;
   }

   private static PsiElement getBlockEndingParent(PsiElement element) {
     while (element != null && !(element instanceof PsiFileSystemItem)) {
       if (endsBlock(element)) {
         return element;
       }
       element = element.getParent();
     }
     return null;
   }

   @Nullable
   private static PsiElement getRelevantElement(PsiFile file, Document doc, int offset) {
     if (offset == 0) {
       return null;
     }
     if (offset == doc.getTextLength()) {
       offset--;
     }
     PsiElement element = file.findElementAt(offset);
     while (element != null && isWhiteSpace(element)) {
       element = PsiUtils.getPreviousNodeInTree(element);
     }
     PsiElement blockTerminator = getBlockEndingParent(element);
     if (blockTerminator != null
         && blockTerminator.getTextRange().getEndOffset() == element.getTextRange().getEndOffset()) {
       return blockTerminator;
     }
     while (element != null && skipElement(element, offset)) {
       element = element.getParent();
     }
     return element;
   }

   private static boolean isWhiteSpace(PsiElement element) {
     if (element instanceof PsiWhiteSpace) {
       return true;
     }
     return BuildToken.WHITESPACE_AND_NEWLINE.contains(element.getNode().getElementType());
   }

   private static boolean skipElement(PsiElement element, int offset) {
     PsiElement parent = element.getParent();
     if (parent == null || parent.getNode() == null || parent instanceof PsiFileSystemItem) {
       return false;
     }
     TextRange childRange = element.getNode().getTextRange();
     return childRange.equals(parent.getNode().getTextRange())
       || childRange.getStartOffset() == offset && (parent instanceof Argument || parent instanceof Parameter);
   }

   private static boolean afterColon(Document doc, int offset) {
     CharSequence text = doc.getCharsSequence();
     int previousOffset = CharArrayUtil.shiftBackward(text, offset - 1, " \t");
     return text.charAt(previousOffset) == ':';
   }

 }
	/*
	* Copyright 2016 The Bazel Authors. All rights reserved.
	*
	* 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.google.idea.blaze.base.lang.buildfile.editor;

	import com.google.idea.blaze.base.lang.buildfile.lexer.BuildToken;
	import com.google.idea.blaze.base.lang.buildfile.psi.*;
	import com.google.idea.blaze.base.lang.buildfile.psi.util.PsiUtils;
	import com.intellij.codeInsight.editorActions.enter.EnterHandlerDelegateAdapter;
	import com.intellij.ide.DataManager;
	import com.intellij.injected.editor.EditorWindow;
	import com.intellij.lang.injection.InjectedLanguageManager;
	import com.intellij.openapi.actionSystem.DataContext;
	import com.intellij.openapi.editor.Document;
	import com.intellij.openapi.editor.Editor;
	import com.intellij.openapi.editor.LogicalPosition;
	import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
	import com.intellij.openapi.editor.actions.SplitLineAction;
	import com.intellij.openapi.util.Ref;
	import com.intellij.openapi.util.TextRange;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.psi.*;
	import com.intellij.psi.codeStyle.CodeStyleSettings;
	import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
	import com.intellij.psi.codeStyle.CommonCodeStyleSettings.IndentOptions;
	import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
	import com.intellij.util.text.CharArrayUtil;

	import javax.annotation.Nullable;

	/**
	* Inserts indents as appropriate when enter is pressed.<br>
	* This is a substitute for implementing a full FormattingModel for the BUILD language.
	* If we ever decide to do that, this code should be removed.
	*/
	public class BuildEnterHandler extends EnterHandlerDelegateAdapter {

	@Override
	public Result preprocessEnter(PsiFile file,
	Editor editor,
	Ref<Integer> caretOffset,
	Ref<Integer> caretAdvance,
	DataContext dataContext,
	EditorActionHandler originalHandler) {
	int offset = caretOffset.get();
	if (editor instanceof EditorWindow) {
	file = InjectedLanguageManager.getInstance(file.getProject()).getTopLevelFile(file);
	editor = InjectedLanguageUtil.getTopLevelEditor(editor);
	offset = editor.getCaretModel().getOffset();
	}
	if (!isApplicable(file, dataContext)) {
	return Result.Continue;
	}

	// Previous enter handler's (e.g. EnterBetweenBracesHandler) can introduce a mismatch
	// between the editor's caret model and the offset we've been provided with.
	editor.getCaretModel().moveToOffset(offset);

	Document doc = editor.getDocument();
	PsiDocumentManager.getInstance(file.getProject()).commitDocument(doc);

	CodeStyleSettings currentSettings = CodeStyleSettingsManager.getSettings(file.getProject());
	IndentOptions indentOptions = currentSettings.getIndentOptions(file.getFileType());

	Integer indent = determineIndent(file, editor, offset, indentOptions);
	if (indent == null) {
	return Result.Continue;
	}

	removeTrailingWhitespace(doc, file, offset);
	originalHandler.execute(editor, editor.getCaretModel().getCurrentCaret(), dataContext);
	LogicalPosition position = editor.getCaretModel().getLogicalPosition();
	if (position.column == indent) {
	return Result.Stop;
	}
	if (position.column > indent) {
	//default enter handler has added too many spaces -- remove them
	int excess = position.column - indent;
	doc.deleteString(editor.getCaretModel().getOffset() - excess, editor.getCaretModel().getOffset());
	} else if (position.column < indent) {
	String spaces = StringUtil.repeatSymbol(' ', indent - position.column);
	doc.insertString(editor.getCaretModel().getOffset(), spaces);
	}
	editor.getCaretModel().moveToLogicalPosition(new LogicalPosition(position.line, indent));
	return Result.Stop;
	}

	private static void removeTrailingWhitespace(Document doc, PsiFile file, int offset) {
	CharSequence chars = doc.getCharsSequence();
	int start = offset;
	while (offset < chars.length() && chars.charAt(offset) == ' ') {
	PsiElement element = file.findElementAt(offset);
	if (element == null \|\| !(element instanceof PsiWhiteSpace)) {
	break;
	}
	offset++;
	}
	if (start != offset) {
	doc.deleteString(start, offset);
	}
	}

	private static boolean isApplicable(PsiFile file, DataContext dataContext) {
	if (!(file instanceof BuildFile)) {
	return false;
	}
	Boolean isSplitLine = DataManager.getInstance().loadFromDataContext(dataContext, SplitLineAction.SPLIT_LINE_KEY);
	if (isSplitLine != null) {
	return false;
	}
	return true;
	}

	/**
	* Returns null if an appropriate indent cannot be found. In that case we do nothing,
	* and pass it along to the next EnterHandler.
	*/
	@Nullable
	private static Integer determineIndent(PsiFile file, Editor editor, int offset, IndentOptions indentOptions) {
	if (offset == 0) {
	return null;
	}
	Document doc = editor.getDocument();
	PsiElement element = getRelevantElement(file, doc, offset);
	PsiElement parent = element != null ? element.getParent() : null;
	if (parent == null) {
	return null;
	}
	if (endsBlock(element)) {
	// current line indent subtract block indent
	return Math.max(0, getIndent(doc, element) - indentOptions.INDENT_SIZE);
	}

	if (parent instanceof BuildListType) {
	BuildListType list = (BuildListType) parent;
	int listOffset = list.getStartOffset();
	LogicalPosition caretPosition = editor.getCaretModel().getLogicalPosition();
	LogicalPosition listStart = editor.offsetToLogicalPosition(listOffset);
	if (listStart.line != caretPosition.line) {
	// take the minimum of the current line's indent and the current caret position
	return indentOfLineUpToCaret(doc, caretPosition.line, offset);
	}
	BuildElement firstChild = ((BuildListType) parent).getFirstElement();
	if (firstChild != null && firstChild.getNode().getStartOffset() < offset) {
	return getIndent(doc, firstChild);
	}
	return lineIndent(doc, listStart.line) + additionalIndent(parent, indentOptions);
	}
	if (parent instanceof StatementListContainer && afterColon(doc, offset)) {
	return getIndent(doc, parent) + additionalIndent(parent, indentOptions);
	}
	return null;
	}

	private static int additionalIndent(PsiElement parent, IndentOptions indentOptions) {
	return parent instanceof StatementListContainer
	? indentOptions.INDENT_SIZE : indentOptions.CONTINUATION_INDENT_SIZE;
	}

	private static int lineIndent(Document doc, int line) {
	int startOffset = doc.getLineStartOffset(line);
	int indentOffset = CharArrayUtil.shiftForward(doc.getCharsSequence(), startOffset, " \t");
	return indentOffset - startOffset;
	}

	private static int getIndent(Document doc, PsiElement element) {
	int offset = element.getNode().getStartOffset();
	int lineNumber = doc.getLineNumber(offset);
	return offset - doc.getLineStartOffset(lineNumber);
	}

	private static int indentOfLineUpToCaret(Document doc, int line, int caretOffset) {
	int startOffset = doc.getLineStartOffset(line);
	int indentOffset = CharArrayUtil.shiftForward(doc.getCharsSequence(), startOffset, " \t");
	return Math.min(indentOffset, caretOffset) - startOffset;
	}

	private static boolean endsBlock(PsiElement element) {
	return element instanceof ReturnStatement
	\|\| element instanceof PassStatement;
	}

	private static PsiElement getBlockEndingParent(PsiElement element) {
	while (element != null && !(element instanceof PsiFileSystemItem)) {
	if (endsBlock(element)) {
	return element;
	}
	element = element.getParent();
	}
	return null;
	}

	@Nullable
	private static PsiElement getRelevantElement(PsiFile file, Document doc, int offset) {
	if (offset == 0) {
	return null;
	}
	if (offset == doc.getTextLength()) {
	offset--;
	}
	PsiElement element = file.findElementAt(offset);
	while (element != null && isWhiteSpace(element)) {
	element = PsiUtils.getPreviousNodeInTree(element);
	}
	PsiElement blockTerminator = getBlockEndingParent(element);
	if (blockTerminator != null
	&& blockTerminator.getTextRange().getEndOffset() == element.getTextRange().getEndOffset()) {
	return blockTerminator;
	}
	while (element != null && skipElement(element, offset)) {
	element = element.getParent();
	}
	return element;
	}

	private static boolean isWhiteSpace(PsiElement element) {
	if (element instanceof PsiWhiteSpace) {
	return true;
	}
	return BuildToken.WHITESPACE_AND_NEWLINE.contains(element.getNode().getElementType());
	}

	private static boolean skipElement(PsiElement element, int offset) {
	PsiElement parent = element.getParent();
	if (parent == null \|\| parent.getNode() == null \|\| parent instanceof PsiFileSystemItem) {
	return false;
	}
	TextRange childRange = element.getNode().getTextRange();
	return childRange.equals(parent.getNode().getTextRange())
	\|\| childRange.getStartOffset() == offset && (parent instanceof Argument \|\| parent instanceof Parameter);
	}

	private static boolean afterColon(Document doc, int offset) {
	CharSequence text = doc.getCharsSequence();
	int previousOffset = CharArrayUtil.shiftBackward(text, offset - 1, " \t");
	return text.charAt(previousOffset) == ':';
	}

	}