android/src/com/android/tools/idea/gradle/parser/GradleGroovyFile.java - platform/tools/adt/idea - Git at Google

 /*
  * Copyright (C) 2013 The Android Open Source Project
  *
  * 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.android.tools.idea.gradle.parser;

 import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.intellij.codeInsight.actions.ReformatCodeProcessor;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.startup.StartupManager;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
 import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.GrListOrMap;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrStatement;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral;
 import org.jetbrains.plugins.groovy.lang.psi.api.util.GrStatementOwner;

 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;

 import static com.android.tools.idea.gradle.parser.BuildFileKey.escapeLiteralString;

 /**
  * Base class for classes that parse Gradle Groovy files (e.g. settings.gradle, build.gradle). It provides a number of convenience
  * methods for its subclasses to extract interesting pieces from Gradle files.
  *
  * Note that if you do any mutations on the PSI structure you must be inside a write action. See
  * {@link com.intellij.util.ActionRunner#runInsideWriteAction}.
  */
 class GradleGroovyFile {
   private static final Logger LOG = Logger.getInstance(GradleGroovyFile.class);

   protected final Project myProject;
   protected final VirtualFile myFile;
   protected GroovyFile myGroovyFile = null;

   public GradleGroovyFile(@NotNull VirtualFile file, @NotNull Project project) {
     myProject = project;
     myFile = file;
     reload();
   }

   public Project getProject() {
     return myProject;
   }

   /**
    * Automatically reformats all the Groovy code inside the given closure.
    */
   static void reformatClosure(@NotNull GrStatementOwner closure) {
     new ReformatCodeProcessor(closure.getProject(), closure.getContainingFile(), closure.getParent().getTextRange(), false)
         .runWithoutProgress();

     // Now strip out any blank lines. They tend to accumulate otherwise. To do this, we iterate through our elements and find those that
     // consist only of whitespace, and eliminate all double-newline occurrences.
     for (PsiElement psiElement : closure.getChildren()) {
       if (psiElement instanceof LeafPsiElement) {
         String text = psiElement.getText();
         if (StringUtil.isEmptyOrSpaces(text)) {
           String newText = text;
           while (newText.contains("\n\n")) {
             newText = newText.replaceAll("\n\n", "\n");
           }
           if (!newText.equals(text)) {
             ((LeafPsiElement)psiElement).replaceWithText(newText);
           }
         }
       }
     }
   }

   /**
    * Creates a new, blank-valued property at the given path.
    */
   @Nullable
   static GrMethodCall createNewValue(@NotNull GrStatementOwner root,
                                      @NotNull BuildFileKey key,
                                      @Nullable Object value,
                                      boolean reformatClosure) {
     // First iterate through the components of the path and make sure all of the nested closures are in place.
     GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(root.getProject());
     String path = key.getPath();
     String[] parts = path.split("/");
     GrStatementOwner parent = root;
     for (int i = 0; i < parts.length - 1; i++) {
       String part = parts[i];
       GrStatementOwner closure = getMethodClosureArgument(parent, part);
       if (closure == null) {
         parent.addStatementBefore(factory.createStatementFromText(part + " {}"), null);
         closure = getMethodClosureArgument(parent, part);
         if (closure == null) {
           return null;
         }
       }
       parent = closure;
     }
     String name = parts[parts.length - 1];
     String text = name + " " + key.getType().convertValueToExpression(value);
     GrStatement statementBefore = null;
     if (key.shouldInsertAtBeginning()) {
       GrStatement[] parentStatements = parent.getStatements();
       if (parentStatements.length > 0) {
         statementBefore = parentStatements[0];
       }
     }
     parent.addStatementBefore(factory.createStatementFromText(text), statementBefore);
     if (reformatClosure) {
       reformatClosure(parent);
     }
     return getMethodCall(parent, name);
   }

   /**
    * Refreshes its state by rereading the contents from the underlying build file.
    */
   public void reload() {
     StartupManager.getInstance(myProject).runWhenProjectIsInitialized(new Runnable() {
       @Override
       public void run() {
         if (!myFile.exists()) {
           LOG.warn("File " + myFile.getPath() + " no longer exists");
           return;
         }
         PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);
         if (psiFile == null) {
           LOG.warn("Could not find PsiFile for " + myFile.getPath());
           return;
         }
         if (!(psiFile instanceof GroovyFile)) {
           LOG.warn("PsiFile " + psiFile.getName() + " is not a Groovy file");
           return;
         }
         myGroovyFile = (GroovyFile)psiFile;
         onPsiFileAvailable();
       }
     });
   }

   public VirtualFile getFile() {
     return myFile;
   }

   public PsiFile getPsiFile() {
     return myGroovyFile;
   }

   /**
    * @throws IllegalStateException if the instance has not parsed its PSI file yet in a
    * {@link StartupManager#runWhenProjectIsInitialized(Runnable)} callback. To resolve this, wait until {@link #onPsiFileAvailable()}
    * is called before invoking methods.
    */
   protected void checkInitialized() {
     if (myGroovyFile == null) {
       throw new IllegalStateException("PsiFile not parsed for file " + myFile.getPath() +". Wait until onPsiFileAvailable() is called.");
     }
   }

   /**
    * Commits any {@link Document} changes outstanding to the document that underlies the PSI representation. Call this before manipulating
    * PSI to ensure the PSI model of the document is in sync with what's on disk. Must be run inside a write action.
    */
   protected void commitDocumentChanges() {
     PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
     Document document = documentManager.getDocument(myGroovyFile);
     if (document != null) {
       documentManager.commitDocument(document);
     }
   }

   /**
    * Finds a method identified by the given path. It descends into nested closure arguments of method calls to find the leaf method.
    * For example, if you have this code in Groovy:
    *
    * method_a {
    *   method_b {
    *     method_c 'literal'
    *   }
    * }
    *
    * you can find method_c using the path "method_a/method_b/method_c"
    *
    * It returns the first eligible result. If you have code like this:
    *
    * method_a {
    *   method_b 'literal1'
    *   method_b 'literal2'
    * }
    *
    * a search for "method_a/method_b" will only return the first invocation of method_b.
    *
    * It continues searching until it has exhausted all possibilities of finding the path. If you have code like this:
    *
    * method_a {
    *   method_b 'literal1'
    * }
    *
    * method_a {
    *   method_c 'literal2'
    * }
    *
    * a search for "method_a/method_c" will succeed: it will not give up just because it doesn't find it in the first method_a block.
    *
    * @param root the block to use as the root of the path
    * @param path the slash-delimited chain of methods with closure arguments to navigate to find the final leaf.
    * @return the resultant method, or null if it could not be found.
    */
   protected static @Nullable GrMethodCall getMethodCallByPath(@NotNull GrStatementOwner root, @NotNull String path) {
     if (path.isEmpty() || path.endsWith("/")) {
       return null;
     }
     int slash = path.indexOf('/');
     String pathElement = slash == -1 ? path : path.substring(0, slash);
     for (GrMethodCall gmc : getMethodCalls(root, pathElement)) {
       if (slash == -1) {
         return gmc;
       }
       if (gmc == null) {
         return null;
       }
       GrClosableBlock[] blocks = gmc.getClosureArguments();
       if (blocks.length != 1) {
         return null;
       }
       GrMethodCall subresult = getMethodCallByPath(blocks[0], path.substring(slash + 1));
       if (subresult != null) {
         return subresult;
       }
     }
     return null;
   }

   /**
    * Returns an array of arguments for the given method call. Note that it returns only regular arguments (via the
    * {@link org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall#getArgumentList()} call), not closure arguments
    * (via the {@link org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall#getClosureArguments()} call).
    *
    * @return the array of arguments. This method never returns null; even in the case of a nonexistent argument list or error, it will
    * return an empty array.
    */
   protected static @NotNull GroovyPsiElement[] getArguments(@NotNull GrCall gmc) {
     GrArgumentList argList = gmc.getArgumentList();
     if (argList == null) {
       return GroovyPsiElement.EMPTY_ARRAY;
     }
     return argList.getAllArguments();
   }

   /**
    * Returns the first argument for the given method call (which can be a literal, expression, or closure), or null if the method has
    * no arguments.
    */
   protected static @Nullable GroovyPsiElement getFirstArgument(@NotNull GrCall gmc) {
     GroovyPsiElement[] arguments = getArguments(gmc);
     return arguments.length > 0 ? arguments[0] : null;
   }

   /**
    * Ensures that argument list has only one argument and that the argument value is a string constant.
    *
    * @return a string value of the argument or <code>null</code> if such a value cannot be deduced
    */
   @Nullable
   protected static String getSingleStringArgumentValue(@NotNull GrCall methodCall) {
     GroovyPsiElement argument = getFirstArgument(methodCall);
     if (argument instanceof GrLiteral) {
       Object value = ((GrLiteral)argument).getValue();
       return value instanceof String ? (String)value : null;
     }
     else {
       return null;
     }
   }

   /**
    * Returns the first method call of the given method name in the given parent statement block, or null if one could not be found.
    */
   protected static @Nullable GrMethodCall getMethodCall(@NotNull GrStatementOwner parent, @NotNull String methodName) {
     return Iterables.getFirst(getMethodCalls(parent, methodName), null);
   }

   /**
    * Returns all statements in the parent statement block that are method calls.
    */
   protected static @NotNull Iterable<GrMethodCall> getMethodCalls(@NotNull GrStatementOwner parent) {
     return Iterables.filter(Arrays.asList(parent.getStatements()), GrMethodCall.class);
   }

   /**
    * Returns all statements in the parent statement block that are method calls with the given method name
    */
   protected static @NotNull Iterable<GrMethodCall> getMethodCalls(@NotNull GrStatementOwner parent, @NotNull final String methodName) {
     return Iterables.filter(getMethodCalls(parent), new Predicate<GrMethodCall>() {
       @Override
       public boolean apply(@Nullable GrMethodCall input) {
         return input != null && methodName.equals(getMethodCallName(input));
       }
     });
   }

   /**
    * Returns the name of the given method call
    */
   protected static @NotNull String getMethodCallName(@NotNull GrMethodCall gmc) {
     GrExpression expression = gmc.getInvokedExpression();
     return expression.getText() != null ? expression.getText() : "";
   }

   /**
    * Returns all arguments in the given argument list that are of the given type.
    */
   protected static @NotNull <E> Iterable<E> getTypedArguments(@NotNull GrArgumentList args, @NotNull Class<E> clazz) {
     return Iterables.filter(Arrays.asList(args.getAllArguments()), clazz);
   }

   /**
    * Returns all arguments of the given method call that are literals.
    */
   protected static @NotNull Iterable<GrLiteral> getLiteralArguments(@NotNull GrMethodCall gmc) {
     GrArgumentList argumentList = gmc.getArgumentList();
     return getTypedArguments(argumentList, GrLiteral.class);
   }

   /**
    * Returns values of all literal-typed arguments of the given method call.
    */
   protected static @NotNull Iterable<Object> getLiteralArgumentValues(@NotNull GrMethodCall gmc) {
     return Iterables.filter(Iterables.transform(getLiteralArguments(gmc), new Function<GrLiteral, Object>() {
       @Override
       public Object apply(@Nullable GrLiteral input) {
         return (input != null) ? input.getValue() : null;
       }
     }), Predicates.notNull());
   }

   /**
    * If the given method takes named arguments, returns those arguments as a name:value map. Returns an empty map otherwise.
    */
   protected static @NotNull Map<String, Object> getNamedArgumentValues(@NotNull GrMethodCall gmc) {
     GrArgumentList argumentList = gmc.getArgumentList();
     Map<String, Object> values = Maps.newHashMap();
     for (GrNamedArgument grNamedArgument : getTypedArguments(argumentList, GrNamedArgument.class)) {
       values.put(grNamedArgument.getLabelName(), parseValueExpression(grNamedArgument.getExpression()));
     }
     return values;
   }

   /**
    * Given a Groovy expression, parses it as if it's literal or list type, and returns the corresponding literal value or List
    * type. Returns null if the expression cannot be evaluated as a literal or list type.
    */
   protected static @Nullable Object parseValueExpression(@Nullable GrExpression gre) {
     if (gre instanceof GrLiteral) {
       return ((GrLiteral)gre).getValue();
     } else if (gre instanceof GrListOrMap) {
       GrListOrMap grLom = (GrListOrMap)gre;
       if (grLom.isMap()) {
         return null;
       }
       List<Object> values = Lists.newArrayList();
       for (GrExpression subexpression : grLom.getInitializers()) {
         Object subValue = parseValueExpression(subexpression);
         if (subValue != null) {
           values.add(subValue);
         }
       }
       return values;
     } else {
       return null;
     }
   }

   /**
    * Returns a text string with the Groovy expression that will represent the given map as a named argument list suitable for use in
    * a method call.
    */
   protected static @NotNull String convertMapToGroovySource(@NotNull Map<String, Object> map) {
     StringBuilder sb = new StringBuilder();
     for (Map.Entry<String, Object> entry : map.entrySet()) {
       if (sb.length() > 0) {
         sb.append(", ");
       }
       sb.append(entry.getKey());
       sb.append(": ");
       sb.append(convertValueToGroovySource(entry.getValue()));
     }
     return sb.toString();
   }

   /**
    * Returns a text string with the Groovy expression that will represent the given object. It can be a literal type or a list of
    * literals or sub-lists.
    */
   protected static @NotNull String convertValueToGroovySource(@NotNull Object value) {
     if (value instanceof List) {
       StringBuilder sb = new StringBuilder();
       sb.append('[');
       for (Object v : ((List)value)) {
         if (sb.length() > 1) {
           sb.append(", ");
         }
         sb.append(convertValueToGroovySource(v));
       }
       sb.append(']');
       return sb.toString();
     } else if (value instanceof Number || value instanceof Boolean) {
       return value.toString();
     } else {
       return "'" + escapeLiteralString(value.toString()) + "'";
     }
   }
   /**
    * Returns the value of the first literal argument in the given method call's argument list.
    */
   protected static @Nullable Object getFirstLiteralArgumentValue(@NotNull GrMethodCall gmc) {
     GrLiteral lit = getFirstLiteralArgument(gmc);
     return lit != null ? lit.getValue() : null;
   }

   /**
    * Returns the first literal argument in the given method call's argument list.
    */
   protected static @Nullable GrLiteral getFirstLiteralArgument(@NotNull GrMethodCall gmc) {
     return Iterables.getFirst(getLiteralArguments(gmc), null);
   }

   /**
    * Returns the first argument of the method call with the given name in the given parent that is a closure, or null if the method
    * or its closure could not be found.
    */
   protected static @Nullable GrClosableBlock getMethodClosureArgument(@NotNull GrStatementOwner parent, @NotNull String methodName) {
     GrMethodCall methodCall = getMethodCall(parent, methodName);
     if (methodCall == null) {
       return null;
     }
     return getMethodClosureArgument(methodCall);
   }

   /**
    * Returns the first argument of the given method call that is a closure, or null if the closure could not be found.
    */
   public static @Nullable GrClosableBlock getMethodClosureArgument(@NotNull GrMethodCall methodCall) {
     return Iterables.getFirst(Arrays.asList(methodCall.getClosureArguments()), null);
   }

   /**
    * Returns the value in the file for the given key, or null if not present.
    */
   static @Nullable Object getValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key) {
     GrMethodCall method = getMethodCallByPath(root, key.getPath());
     if (method == null) {
       return null;
     }
     GroovyPsiElement arg = key.getType() == BuildFileKeyType.CLOSURE ? getMethodClosureArgument(method) : getFirstArgument(method);
     if (arg == null) {
       return null;
     }
     return key.getValue(arg);
   }

   /**
    * Sets the value for the given key
    */
   static void setValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key, @NotNull Object value, boolean reformatClosure,
                              @Nullable ValueFactory.KeyFilter filter) {
     if (value == GradleBuildFile.UNRECOGNIZED_VALUE) {
       return;
     }
     GrMethodCall method = getMethodCallByPath(root, key.getPath());
     if (method == null) {
       method = createNewValue(root, key, value, reformatClosure);
       if (key.getType() != BuildFileKeyType.CLOSURE) {
         return;
       }
     }
     if (method != null) {
       GroovyPsiElement arg = key.getType() == BuildFileKeyType.CLOSURE  ? getMethodClosureArgument(method) : getFirstArgument(method);
       if (arg == null) {
         return;
       }
       key.setValue(arg, value, filter);
     }
   }

   /**
    * Removes the build file value identified by the given key
    */
   static void removeValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key) {
     GrMethodCall method = getMethodCallByPath(root, key.getPath());
     if (method != null) {
       method.delete();
     }
   }

   /**
    * Override this method if you wish to be called when the underlying PSI file is available and you would like to parse it.
    */
   protected void onPsiFileAvailable() {
   }

   @Override
   public @NotNull String toString() {
     if (myGroovyFile == null) {
       return "<uninitialized>";
     } else {
       ToStringPsiVisitor visitor = new ToStringPsiVisitor();
       myGroovyFile.accept(visitor);
       return myFile.getPath() + ":\n" + visitor.toString();
     }
   }

   private static class ToStringPsiVisitor extends PsiRecursiveElementVisitor {
     private StringBuilder myString = new StringBuilder();
     @Override
     public void visitElement(final @NotNull PsiElement element) {
       PsiElement e = element;
       while (e.getParent() != null) {
         myString.append("  ");
         e = e.getParent();
       }
       myString.append(element.getClass().getName());
       myString.append(": ");
       myString.append(element.toString());
       if (element instanceof LeafPsiElement) {
         myString.append(" ");
         myString.append(element.getText());
       }
       myString.append("\n");
       super.visitElement(element);
     }

     public @NotNull String toString() {
       return myString.toString();
     }
   }
 }
	/*
	* Copyright (C) 2013 The Android Open Source Project
	*
	* 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.android.tools.idea.gradle.parser;

	import com.google.common.base.Function;
	import com.google.common.base.Predicate;
	import com.google.common.base.Predicates;
	import com.google.common.collect.Iterables;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Maps;
	import com.intellij.codeInsight.actions.ReformatCodeProcessor;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.openapi.editor.Document;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.startup.StartupManager;
	import com.intellij.openapi.util.text.StringUtil;
	import com.intellij.openapi.vfs.VirtualFile;
	import com.intellij.psi.*;
	import com.intellij.psi.impl.source.tree.LeafPsiElement;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;
	import org.jetbrains.plugins.groovy.lang.psi.GroovyFile;
	import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElement;
	import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
	import org.jetbrains.plugins.groovy.lang.psi.api.auxiliary.GrListOrMap;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrStatement;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgumentList;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
	import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral;
	import org.jetbrains.plugins.groovy.lang.psi.api.util.GrStatementOwner;

	import java.util.Arrays;
	import java.util.List;
	import java.util.Map;

	import static com.android.tools.idea.gradle.parser.BuildFileKey.escapeLiteralString;

	/**
	* Base class for classes that parse Gradle Groovy files (e.g. settings.gradle, build.gradle). It provides a number of convenience
	* methods for its subclasses to extract interesting pieces from Gradle files.
	*
	* Note that if you do any mutations on the PSI structure you must be inside a write action. See
	* {@link com.intellij.util.ActionRunner#runInsideWriteAction}.
	*/
	class GradleGroovyFile {
	private static final Logger LOG = Logger.getInstance(GradleGroovyFile.class);

	protected final Project myProject;
	protected final VirtualFile myFile;
	protected GroovyFile myGroovyFile = null;

	public GradleGroovyFile(@NotNull VirtualFile file, @NotNull Project project) {
	myProject = project;
	myFile = file;
	reload();
	}

	public Project getProject() {
	return myProject;
	}

	/**
	* Automatically reformats all the Groovy code inside the given closure.
	*/
	static void reformatClosure(@NotNull GrStatementOwner closure) {
	new ReformatCodeProcessor(closure.getProject(), closure.getContainingFile(), closure.getParent().getTextRange(), false)
	.runWithoutProgress();

	// Now strip out any blank lines. They tend to accumulate otherwise. To do this, we iterate through our elements and find those that
	// consist only of whitespace, and eliminate all double-newline occurrences.
	for (PsiElement psiElement : closure.getChildren()) {
	if (psiElement instanceof LeafPsiElement) {
	String text = psiElement.getText();
	if (StringUtil.isEmptyOrSpaces(text)) {
	String newText = text;
	while (newText.contains("\n\n")) {
	newText = newText.replaceAll("\n\n", "\n");
	}
	if (!newText.equals(text)) {
	((LeafPsiElement)psiElement).replaceWithText(newText);
	}
	}
	}
	}
	}

	/**
	* Creates a new, blank-valued property at the given path.
	*/
	@Nullable
	static GrMethodCall createNewValue(@NotNull GrStatementOwner root,
	@NotNull BuildFileKey key,
	@Nullable Object value,
	boolean reformatClosure) {
	// First iterate through the components of the path and make sure all of the nested closures are in place.
	GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(root.getProject());
	String path = key.getPath();
	String[] parts = path.split("/");
	GrStatementOwner parent = root;
	for (int i = 0; i < parts.length - 1; i++) {
	String part = parts[i];
	GrStatementOwner closure = getMethodClosureArgument(parent, part);
	if (closure == null) {
	parent.addStatementBefore(factory.createStatementFromText(part + " {}"), null);
	closure = getMethodClosureArgument(parent, part);
	if (closure == null) {
	return null;
	}
	}
	parent = closure;
	}
	String name = parts[parts.length - 1];
	String text = name + " " + key.getType().convertValueToExpression(value);
	GrStatement statementBefore = null;
	if (key.shouldInsertAtBeginning()) {
	GrStatement[] parentStatements = parent.getStatements();
	if (parentStatements.length > 0) {
	statementBefore = parentStatements[0];
	}
	}
	parent.addStatementBefore(factory.createStatementFromText(text), statementBefore);
	if (reformatClosure) {
	reformatClosure(parent);
	}
	return getMethodCall(parent, name);
	}

	/**
	* Refreshes its state by rereading the contents from the underlying build file.
	*/
	public void reload() {
	StartupManager.getInstance(myProject).runWhenProjectIsInitialized(new Runnable() {
	@Override
	public void run() {
	if (!myFile.exists()) {
	LOG.warn("File " + myFile.getPath() + " no longer exists");
	return;
	}
	PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);
	if (psiFile == null) {
	LOG.warn("Could not find PsiFile for " + myFile.getPath());
	return;
	}
	if (!(psiFile instanceof GroovyFile)) {
	LOG.warn("PsiFile " + psiFile.getName() + " is not a Groovy file");
	return;
	}
	myGroovyFile = (GroovyFile)psiFile;
	onPsiFileAvailable();
	}
	});
	}

	public VirtualFile getFile() {
	return myFile;
	}

	public PsiFile getPsiFile() {
	return myGroovyFile;
	}

	/**
	* @throws IllegalStateException if the instance has not parsed its PSI file yet in a
	* {@link StartupManager#runWhenProjectIsInitialized(Runnable)} callback. To resolve this, wait until {@link #onPsiFileAvailable()}
	* is called before invoking methods.
	*/
	protected void checkInitialized() {
	if (myGroovyFile == null) {
	throw new IllegalStateException("PsiFile not parsed for file " + myFile.getPath() +". Wait until onPsiFileAvailable() is called.");
	}
	}

	/**
	* Commits any {@link Document} changes outstanding to the document that underlies the PSI representation. Call this before manipulating
	* PSI to ensure the PSI model of the document is in sync with what's on disk. Must be run inside a write action.
	*/
	protected void commitDocumentChanges() {
	PsiDocumentManager documentManager = PsiDocumentManager.getInstance(myProject);
	Document document = documentManager.getDocument(myGroovyFile);
	if (document != null) {
	documentManager.commitDocument(document);
	}
	}

	/**
	* Finds a method identified by the given path. It descends into nested closure arguments of method calls to find the leaf method.
	* For example, if you have this code in Groovy:
	*
	* method_a {
	* method_b {
	* method_c 'literal'
	* }
	* }
	*
	* you can find method_c using the path "method_a/method_b/method_c"
	*
	* It returns the first eligible result. If you have code like this:
	*
	* method_a {
	* method_b 'literal1'
	* method_b 'literal2'
	* }
	*
	* a search for "method_a/method_b" will only return the first invocation of method_b.
	*
	* It continues searching until it has exhausted all possibilities of finding the path. If you have code like this:
	*
	* method_a {
	* method_b 'literal1'
	* }
	*
	* method_a {
	* method_c 'literal2'
	* }
	*
	* a search for "method_a/method_c" will succeed: it will not give up just because it doesn't find it in the first method_a block.
	*
	* @param root the block to use as the root of the path
	* @param path the slash-delimited chain of methods with closure arguments to navigate to find the final leaf.
	* @return the resultant method, or null if it could not be found.
	*/
	protected static @Nullable GrMethodCall getMethodCallByPath(@NotNull GrStatementOwner root, @NotNull String path) {
	if (path.isEmpty() \|\| path.endsWith("/")) {
	return null;
	}
	int slash = path.indexOf('/');
	String pathElement = slash == -1 ? path : path.substring(0, slash);
	for (GrMethodCall gmc : getMethodCalls(root, pathElement)) {
	if (slash == -1) {
	return gmc;
	}
	if (gmc == null) {
	return null;
	}
	GrClosableBlock[] blocks = gmc.getClosureArguments();
	if (blocks.length != 1) {
	return null;
	}
	GrMethodCall subresult = getMethodCallByPath(blocks[0], path.substring(slash + 1));
	if (subresult != null) {
	return subresult;
	}
	}
	return null;
	}

	/**
	* Returns an array of arguments for the given method call. Note that it returns only regular arguments (via the
	* {@link org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall#getArgumentList()} call), not closure arguments
	* (via the {@link org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall#getClosureArguments()} call).
	*
	* @return the array of arguments. This method never returns null; even in the case of a nonexistent argument list or error, it will
	* return an empty array.
	*/
	protected static @NotNull GroovyPsiElement[] getArguments(@NotNull GrCall gmc) {
	GrArgumentList argList = gmc.getArgumentList();
	if (argList == null) {
	return GroovyPsiElement.EMPTY_ARRAY;
	}
	return argList.getAllArguments();
	}

	/**
	* Returns the first argument for the given method call (which can be a literal, expression, or closure), or null if the method has
	* no arguments.
	*/
	protected static @Nullable GroovyPsiElement getFirstArgument(@NotNull GrCall gmc) {
	GroovyPsiElement[] arguments = getArguments(gmc);
	return arguments.length > 0 ? arguments[0] : null;
	}

	/**
	* Ensures that argument list has only one argument and that the argument value is a string constant.
	*
	* @return a string value of the argument or <code>null</code> if such a value cannot be deduced
	*/
	@Nullable
	protected static String getSingleStringArgumentValue(@NotNull GrCall methodCall) {
	GroovyPsiElement argument = getFirstArgument(methodCall);
	if (argument instanceof GrLiteral) {
	Object value = ((GrLiteral)argument).getValue();
	return value instanceof String ? (String)value : null;
	}
	else {
	return null;
	}
	}

	/**
	* Returns the first method call of the given method name in the given parent statement block, or null if one could not be found.
	*/
	protected static @Nullable GrMethodCall getMethodCall(@NotNull GrStatementOwner parent, @NotNull String methodName) {
	return Iterables.getFirst(getMethodCalls(parent, methodName), null);
	}

	/**
	* Returns all statements in the parent statement block that are method calls.
	*/
	protected static @NotNull Iterable<GrMethodCall> getMethodCalls(@NotNull GrStatementOwner parent) {
	return Iterables.filter(Arrays.asList(parent.getStatements()), GrMethodCall.class);
	}

	/**
	* Returns all statements in the parent statement block that are method calls with the given method name
	*/
	protected static @NotNull Iterable<GrMethodCall> getMethodCalls(@NotNull GrStatementOwner parent, @NotNull final String methodName) {
	return Iterables.filter(getMethodCalls(parent), new Predicate<GrMethodCall>() {
	@Override
	public boolean apply(@Nullable GrMethodCall input) {
	return input != null && methodName.equals(getMethodCallName(input));
	}
	});
	}

	/**
	* Returns the name of the given method call
	*/
	protected static @NotNull String getMethodCallName(@NotNull GrMethodCall gmc) {
	GrExpression expression = gmc.getInvokedExpression();
	return expression.getText() != null ? expression.getText() : "";
	}

	/**
	* Returns all arguments in the given argument list that are of the given type.
	*/
	protected static @NotNull <E> Iterable<E> getTypedArguments(@NotNull GrArgumentList args, @NotNull Class<E> clazz) {
	return Iterables.filter(Arrays.asList(args.getAllArguments()), clazz);
	}

	/**
	* Returns all arguments of the given method call that are literals.
	*/
	protected static @NotNull Iterable<GrLiteral> getLiteralArguments(@NotNull GrMethodCall gmc) {
	GrArgumentList argumentList = gmc.getArgumentList();
	return getTypedArguments(argumentList, GrLiteral.class);
	}

	/**
	* Returns values of all literal-typed arguments of the given method call.
	*/
	protected static @NotNull Iterable<Object> getLiteralArgumentValues(@NotNull GrMethodCall gmc) {
	return Iterables.filter(Iterables.transform(getLiteralArguments(gmc), new Function<GrLiteral, Object>() {
	@Override
	public Object apply(@Nullable GrLiteral input) {
	return (input != null) ? input.getValue() : null;
	}
	}), Predicates.notNull());
	}

	/**
	* If the given method takes named arguments, returns those arguments as a name:value map. Returns an empty map otherwise.
	*/
	protected static @NotNull Map<String, Object> getNamedArgumentValues(@NotNull GrMethodCall gmc) {
	GrArgumentList argumentList = gmc.getArgumentList();
	Map<String, Object> values = Maps.newHashMap();
	for (GrNamedArgument grNamedArgument : getTypedArguments(argumentList, GrNamedArgument.class)) {
	values.put(grNamedArgument.getLabelName(), parseValueExpression(grNamedArgument.getExpression()));
	}
	return values;
	}

	/**
	* Given a Groovy expression, parses it as if it's literal or list type, and returns the corresponding literal value or List
	* type. Returns null if the expression cannot be evaluated as a literal or list type.
	*/
	protected static @Nullable Object parseValueExpression(@Nullable GrExpression gre) {
	if (gre instanceof GrLiteral) {
	return ((GrLiteral)gre).getValue();
	} else if (gre instanceof GrListOrMap) {
	GrListOrMap grLom = (GrListOrMap)gre;
	if (grLom.isMap()) {
	return null;
	}
	List<Object> values = Lists.newArrayList();
	for (GrExpression subexpression : grLom.getInitializers()) {
	Object subValue = parseValueExpression(subexpression);
	if (subValue != null) {
	values.add(subValue);
	}
	}
	return values;
	} else {
	return null;
	}
	}

	/**
	* Returns a text string with the Groovy expression that will represent the given map as a named argument list suitable for use in
	* a method call.
	*/
	protected static @NotNull String convertMapToGroovySource(@NotNull Map<String, Object> map) {
	StringBuilder sb = new StringBuilder();
	for (Map.Entry<String, Object> entry : map.entrySet()) {
	if (sb.length() > 0) {
	sb.append(", ");
	}
	sb.append(entry.getKey());
	sb.append(": ");
	sb.append(convertValueToGroovySource(entry.getValue()));
	}
	return sb.toString();
	}

	/**
	* Returns a text string with the Groovy expression that will represent the given object. It can be a literal type or a list of
	* literals or sub-lists.
	*/
	protected static @NotNull String convertValueToGroovySource(@NotNull Object value) {
	if (value instanceof List) {
	StringBuilder sb = new StringBuilder();
	sb.append('[');
	for (Object v : ((List)value)) {
	if (sb.length() > 1) {
	sb.append(", ");
	}
	sb.append(convertValueToGroovySource(v));
	}
	sb.append(']');
	return sb.toString();
	} else if (value instanceof Number \|\| value instanceof Boolean) {
	return value.toString();
	} else {
	return "'" + escapeLiteralString(value.toString()) + "'";
	}
	}
	/**
	* Returns the value of the first literal argument in the given method call's argument list.
	*/
	protected static @Nullable Object getFirstLiteralArgumentValue(@NotNull GrMethodCall gmc) {
	GrLiteral lit = getFirstLiteralArgument(gmc);
	return lit != null ? lit.getValue() : null;
	}

	/**
	* Returns the first literal argument in the given method call's argument list.
	*/
	protected static @Nullable GrLiteral getFirstLiteralArgument(@NotNull GrMethodCall gmc) {
	return Iterables.getFirst(getLiteralArguments(gmc), null);
	}

	/**
	* Returns the first argument of the method call with the given name in the given parent that is a closure, or null if the method
	* or its closure could not be found.
	*/
	protected static @Nullable GrClosableBlock getMethodClosureArgument(@NotNull GrStatementOwner parent, @NotNull String methodName) {
	GrMethodCall methodCall = getMethodCall(parent, methodName);
	if (methodCall == null) {
	return null;
	}
	return getMethodClosureArgument(methodCall);
	}

	/**
	* Returns the first argument of the given method call that is a closure, or null if the closure could not be found.
	*/
	public static @Nullable GrClosableBlock getMethodClosureArgument(@NotNull GrMethodCall methodCall) {
	return Iterables.getFirst(Arrays.asList(methodCall.getClosureArguments()), null);
	}

	/**
	* Returns the value in the file for the given key, or null if not present.
	*/
	static @Nullable Object getValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key) {
	GrMethodCall method = getMethodCallByPath(root, key.getPath());
	if (method == null) {
	return null;
	}
	GroovyPsiElement arg = key.getType() == BuildFileKeyType.CLOSURE ? getMethodClosureArgument(method) : getFirstArgument(method);
	if (arg == null) {
	return null;
	}
	return key.getValue(arg);
	}

	/**
	* Sets the value for the given key
	*/
	static void setValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key, @NotNull Object value, boolean reformatClosure,
	@Nullable ValueFactory.KeyFilter filter) {
	if (value == GradleBuildFile.UNRECOGNIZED_VALUE) {
	return;
	}
	GrMethodCall method = getMethodCallByPath(root, key.getPath());
	if (method == null) {
	method = createNewValue(root, key, value, reformatClosure);
	if (key.getType() != BuildFileKeyType.CLOSURE) {
	return;
	}
	}
	if (method != null) {
	GroovyPsiElement arg = key.getType() == BuildFileKeyType.CLOSURE ? getMethodClosureArgument(method) : getFirstArgument(method);
	if (arg == null) {
	return;
	}
	key.setValue(arg, value, filter);
	}
	}

	/**
	* Removes the build file value identified by the given key
	*/
	static void removeValueStatic(@NotNull GrStatementOwner root, @NotNull BuildFileKey key) {
	GrMethodCall method = getMethodCallByPath(root, key.getPath());
	if (method != null) {
	method.delete();
	}
	}

	/**
	* Override this method if you wish to be called when the underlying PSI file is available and you would like to parse it.
	*/
	protected void onPsiFileAvailable() {
	}

	@Override
	public @NotNull String toString() {
	if (myGroovyFile == null) {
	return "<uninitialized>";
	} else {
	ToStringPsiVisitor visitor = new ToStringPsiVisitor();
	myGroovyFile.accept(visitor);
	return myFile.getPath() + ":\n" + visitor.toString();
	}
	}

	private static class ToStringPsiVisitor extends PsiRecursiveElementVisitor {
	private StringBuilder myString = new StringBuilder();
	@Override
	public void visitElement(final @NotNull PsiElement element) {
	PsiElement e = element;
	while (e.getParent() != null) {
	myString.append(" ");
	e = e.getParent();
	}
	myString.append(element.getClass().getName());
	myString.append(": ");
	myString.append(element.toString());
	if (element instanceof LeafPsiElement) {
	myString.append(" ");
	myString.append(element.getText());
	}
	myString.append("\n");
	super.visitElement(element);
	}

	public @NotNull String toString() {
	return myString.toString();
	}
	}
	}