android/src/com/android/tools/idea/gradle/parser/GradleBuildFile.java

/*
 * 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.android.tools.idea.gradle.util.GradleUtil;
import com.android.tools.lint.checks.GradleDetector;
import com.google.common.base.Objects;
import com.google.common.collect.Lists;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.psi.PsiElement;
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.api.statements.expressions.GrMethodCall;
import org.jetbrains.plugins.groovy.lang.psi.api.util.GrStatementOwner;

import java.util.Collections;
import java.util.List;
import java.util.Map;

import static com.android.tools.idea.gradle.parser.ValueFactory.KeyFilter;

/**
 * GradleBuildFile uses PSI to parse build.gradle files and provides high-level methods to read and mutate the file. For many things in
 * the file it uses a simple key/value interface to set and retrieve values. Since a user can potentially edit a build.gradle file by
 * hand and make changes that we are unable to parse, there is also a
 * {@link #canParseValue(BuildFileKey)} method that will query if the value can
 * be edited by this class or not.
 *
 * 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}.
 */
public class GradleBuildFile extends GradleGroovyFile {
  /**
   * Used as a placeholder for a value in a build file we couldn't understand. We avoid overwriting these unless the explicit intent
   * is to replace an unparseable value with a new, parseable one.
   */
  public static final Object UNRECOGNIZED_VALUE = "Unrecognized value";

  @Nullable
  public static GradleBuildFile get(@NotNull Module module) {
    VirtualFile file = GradleUtil.getGradleBuildFile(module);
    return file != null ? new GradleBuildFile(file, module.getProject()) : null;
  }

  public GradleBuildFile(@NotNull VirtualFile buildFile, @NotNull Project project) {
    super(buildFile, project);
  }

  @NotNull
  public List<BuildFileStatement> getDependencies() {
    Object dependencies = getValue(BuildFileKey.DEPENDENCIES);
    if (dependencies == null) {
      return Collections.emptyList();
    }
    assert dependencies instanceof List;
    //noinspection unchecked
    return (List<BuildFileStatement>)dependencies;
  }

  /**
   * Returns the value in the file for the given key, or null if not present.
   */
  public @Nullable Object getValue(@NotNull BuildFileKey key) {
    checkInitialized();
    return getValue(myGroovyFile, key);
  }

  /**
   * Returns the value in the file for the given key, or null if not present.
   */
  public @Nullable Object getValue(@Nullable GrStatementOwner root, @NotNull BuildFileKey key) {
    checkInitialized();
    if (root == null) {
      root = myGroovyFile;
    }
    return getValueStatic(root, key);
  }

  /**
   * Given a path to a method, returns the first argument of that method that is a closure, or null.
   */
  public @Nullable GrStatementOwner getClosure(String path) {
    checkInitialized();
    GrMethodCall method = getMethodCallByPath(myGroovyFile, path);
    if (method == null) {
      return null;
    }
    return getMethodClosureArgument(method);
  }

  /**
   * Modifies the value in the file. Must be run inside a write action.
   */
  public void setValue(@NotNull BuildFileKey key, @NotNull Object value) {
    checkInitialized();
    commitDocumentChanges();
    setValue(myGroovyFile, key, value, null);
  }

  /**
   * Modifies the value in the file. Must be run inside a write action.
   */
  public void setValue(@Nullable GrStatementOwner root, @NotNull BuildFileKey key, @NotNull Object value) {
    checkInitialized();
    commitDocumentChanges();
    setValue(root, key, value, null);
  }

  /**
   * Modifies the value in the file. Must be run inside a write action. The filter is intended for composite value types (e.g.
   * {@link com.android.tools.idea.gradle.parser.NamedObject} and allows greater control over whether a sub-key gets written
   * out.
   */
  public void setValue(@NotNull BuildFileKey key, @NotNull Object value, @Nullable KeyFilter filter) {
    checkInitialized();
    commitDocumentChanges();
    setValue(myGroovyFile, key, value, filter);
  }

  /**
   * Modifies the value in the file. Must be run inside a write action. The filter is intended for composite value types (e.g.
   * {@link com.android.tools.idea.gradle.parser.NamedObject} and allows greater control over whether a sub-key gets written
   * out.
   */
  public void setValue(@Nullable GrStatementOwner root, @NotNull BuildFileKey key, @NotNull Object value, @Nullable KeyFilter filter) {
    checkInitialized();
    commitDocumentChanges();
    if (root == null) {
      root = myGroovyFile;
    }
    setValueStatic(root, key, value, true, filter);
  }

  /**
   * If the given key has a value at the given root, removes it and returns true. Returns false if there is no value for that key.
   */
  public boolean removeValue(@Nullable GrStatementOwner root, @NotNull BuildFileKey key) {
    checkInitialized();
    commitDocumentChanges();
    if (root == null) {
      root = myGroovyFile;
    }
    GrMethodCall method = getMethodCallByPath(root, key.getPath());
    if (method != null) {
      GrStatementOwner parent = (GrStatementOwner)method.getParent();
      parent.removeElements(new PsiElement[]{method});
      reformatClosure(parent);
      return true;
    }
    return false;
  }

  public boolean hasDependency(@NotNull BuildFileStatement statement) {
    List<BuildFileStatement> currentDeps = (List<BuildFileStatement>)getValue(BuildFileKey.DEPENDENCIES);
    if (currentDeps == null) {
      return false;
    }
    return hasDependency(currentDeps, statement);
  }

  public static boolean hasDependency(@NotNull List<BuildFileStatement> currentDeps, @NotNull BuildFileStatement statement) {
    if (currentDeps.contains(statement)) {
      return true;
    }
    if (!(statement instanceof Dependency)) {
      return false;
    }
    for (BuildFileStatement currentStatement : currentDeps) {
      if (currentStatement instanceof Dependency && ((Dependency)currentStatement).matches((Dependency)statement)) {
        return true;
      }
    }
    return false;
  }

  /**
   * Returns a list of all the plugins used by the given build file.
   */
  @NotNull
  public static List<String> getPlugins(GroovyFile buildScript) {
    List<String> plugins = Lists.newArrayListWithExpectedSize(1);
    for (GrMethodCall methodCall : getMethodCalls(buildScript, "apply")) {
      Map<String,Object> values = getNamedArgumentValues(methodCall);
      Object plugin = values.get("plugin");
      if (plugin != null) {
        plugins.add(plugin.toString());
      }
    }
    return plugins;
  }

  /**
   * Returns a list of all the plugins used by the build file.
   */
  @NotNull
  public List<String> getPlugins() {
    return getPlugins(myGroovyFile);
  }

  /**
   * Returns true if the build file uses the android or android-library plugin.
   */
  public boolean hasAndroidPlugin() {
    List<String> plugins = getPlugins();
    return plugins.contains(GradleDetector.APP_PLUGIN_ID) || plugins.contains(GradleDetector.OLD_APP_PLUGIN_ID) ||
           plugins.contains(GradleDetector.LIB_PLUGIN_ID) || plugins.contains(GradleDetector.OLD_LIB_PLUGIN_ID);
  }

  /**
   * Returns true if the current and new values differ in a way that should cause us to write them out to the build file. This differs from
   * simple object equality in that if the only differences between current and new are in unparseable objects, then we ignore those
   * differences for the purpose of this check -- since we don't understand unparseable statements, we can't meaningfully perform object
   * equality checks on them and we should endeavor to not write them back out to the file if we can avoid it.
   */
  public static boolean shouldWriteValue(@Nullable Object currentValue, @Nullable Object newValue) {
    if (Objects.equal(currentValue, newValue)) {
      return false;
    }
    // If it's a list type, then iterate though the elements. If each element is equal or if both the current and new values at a given list
    // position are both unparseable, then we don't need to write it out.
    if (!(currentValue instanceof List && newValue instanceof List)) {
      return true;
    }
    List currentList = (List)currentValue;
    List newList = (List)newValue;
    if (currentList.size() != newList.size()) {
      return true;
    }
    for (int i = 0; i < currentList.size(); i++) {
      Object currentObj = currentList.get(i);
      Object newObj = newList.get(i);
      if (!currentObj.equals(newObj) && !(currentObj instanceof UnparseableStatement && newObj instanceof UnparseableStatement)) {
        return true;
      }
    }
    return false;
  }
}