android/src/com/android/tools/idea/gradle/parser/NamedObject.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.google.common.base.Predicate;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.intellij.psi.PsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall;
import org.jetbrains.plugins.groovy.lang.psi.api.util.GrStatementOwner;

import java.text.Collator;
import java.util.List;
import java.util.Map;

/**
 * This is a container class for configurable objects in build.gradle files like signing configs, flavors, build types, and the like.
 * These are named entities that live inside a parent closure, like buildType1 and buildType2 in this example:
 * <p>
 * <code>
 *   android {
 *     buildTypes {
 *       buildType1 {
 *         someProperty "someValue"
 *         anotherProperty "anotherValue"
 *       }
 *       buildType2 {
 *         someProperty "differentValue"
 *         anotherProperty "anotherDifferentValue"
 *       }
 *     }
 *   }
 * </code>
 *
 * <p>
 * These objects are syntactically method calls in Groovy; the method name is the object's name, and the argument is a closure that
 * takes property/value statements (which are themselves method calls).
 */
public class NamedObject implements Comparable<NamedObject> {
  private String myName;
  private final boolean myAlwaysOnTop;
  private final Map<BuildFileKey, Object> myValues = Maps.newHashMap();

  public NamedObject(@NotNull String name) {
    this(name, false);
  }

  protected NamedObject(@NotNull String name, boolean alwaysOnTop) {
    myName = name;
    myAlwaysOnTop = alwaysOnTop;
  }

  public NamedObject(@NotNull NamedObject obj) {
    myName = obj.myName;
    myAlwaysOnTop = obj.myAlwaysOnTop;
    myValues.putAll(obj.myValues);
  }

  @NotNull
  public String getName() {
    return myName;
  }

  @NotNull
  public Map<BuildFileKey, Object> getValues() {
    return myValues;
  }

  @Nullable
  public Object getValue(@NotNull BuildFileKey buildFileKey) {
    return myValues.get(buildFileKey);
  }

  public void setName(@NotNull String name) {
    myName = name;
  }

  public void setValue(@NotNull BuildFileKey property, @Nullable Object value) {
    if (value == null) {
      myValues.remove(property);
    } else {
      myValues.put(property, value);
    }
  }

  public static ValueFactory getFactory(@NotNull List<BuildFileKey> properties) {
    return new Factory(properties);
  }

  @Override
  public int compareTo(NamedObject o) {
    if (myAlwaysOnTop != o.myAlwaysOnTop) {
      return myAlwaysOnTop ? -1 : 1;
    }
    return Collator.getInstance().compare(myName, o.myName);
  }

  public static class Factory extends ValueFactory<NamedObject> {
    private final List<BuildFileKey> myProperties;

    private Factory(@NotNull List<BuildFileKey> properties) {
      myProperties = properties;
    }

    /**
     * When looking for values to delete, do a less fragile comparison based only on object names and not identity.
     */
    @Override
    protected Iterable<NamedObject> findValuesToDelete(@NotNull GrStatementOwner closure,
                                                       @NotNull final List<NamedObject> replacementValues) {
      return Iterables.filter(getValues(closure), new Predicate<NamedObject>() {
        @Override
        public boolean apply(NamedObject input) {
          for (NamedObject value : replacementValues) {
            if (value.getName().equals(input.getName())) {
              return false;
            }
          }
          return true;
        }
      });
    }

    @Override
    protected void setValue(@NotNull GrStatementOwner closure, @NotNull NamedObject object, @Nullable KeyFilter filter) {
      GrClosableBlock subclosure = GradleGroovyFile.getMethodClosureArgument(closure, object.myName);
      GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(closure.getProject());
      if (subclosure == null) {
        closure.addBefore(factory.createStatementFromText(object.getName() + " {\n}\n"), closure.getLastChild());
        subclosure = GradleGroovyFile.getMethodClosureArgument(closure, object.myName);
        if (subclosure == null) {
          return;
        }
      }
      for (BuildFileKey property : myProperties) {
        if (filter != null && !filter.shouldWriteKey(property, object)) {
          continue;
        }
        Object value = object.getValue(property);
        if (value != null) {
          // Don't need to pass the filter along. It's already done its job on the parent key.
          GradleGroovyFile.setValueStatic(subclosure, property, value, false, null);
        } else if (GradleGroovyFile.getValueStatic(subclosure, property) != GradleBuildFile.UNRECOGNIZED_VALUE) {
          GradleGroovyFile.removeValueStatic(subclosure, property);
        }
      }
      GradleGroovyFile.reformatClosure(subclosure);
    }

    @Nullable
    @Override
    public List<NamedObject> getValues(@NotNull PsiElement statement) {
      if (!(statement instanceof GrMethodCall)) {
        return null;
      }
      GrMethodCall method = (GrMethodCall)statement;

      NamedObject item = new NamedObject(GradleGroovyFile.getMethodCallName((GrMethodCall)statement));
        GrClosableBlock subclosure = GradleGroovyFile.getMethodClosureArgument(method);
        if (subclosure == null) {
          return null;
        }
        for (BuildFileKey property : myProperties) {
          Object value = GradleGroovyFile.getValueStatic(subclosure, property);
          if (value != null) {
            item.setValue(property, value);
          }
        }
      return ImmutableList.of(item);
    }

    @Override
    protected void removeValue(@NotNull GrStatementOwner closure, @NotNull NamedObject value) {
      GrMethodCall call = GradleGroovyFile.getMethodCall(closure, value.getName());
      if (call != null) {
        call.removeStatement();
      }
    }

    @NotNull
    public List<BuildFileKey> getProperties() {
      return myProperties;
    }
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof NamedObject)) return false;

    NamedObject that = (NamedObject)o;

    if (!myName.equals(that.myName)) return false;
    if (!myValues.equals(that.myValues)) return false;

    return true;
  }

  @Override
  public int hashCode() {
    int result = myName.hashCode();
    result = 31 * result + myValues.hashCode();
    return result;
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("NamedObject ");
    sb.append(myName);
    sb.append(' ');
    sb.append(myValues.toString());
    return sb.toString();
  }
}