XmlAttribute.java

/*
 * Copyright (C) 2014 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.manifmerger;

import com.android.SdkConstants;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.blame.SourceFile;
import com.android.ide.common.blame.SourceFilePosition;
import com.android.ide.common.blame.SourcePosition;
import com.google.common.base.Joiner;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.ImmutableSet;

import org.w3c.dom.Attr;

/**
 * Defines an XML attribute inside a {@link XmlElement}.
 *
 * Basically a facade object on {@link Attr} objects with some added features like automatic
 * namespace handling, manifest merger friendly identifiers and smart replacement of shortened
 * full qualified class names using manifest node's package setting from the the owning Android's
 * document.
 */
public class XmlAttribute extends XmlNode {

    private final XmlElement mOwnerElement;
    private final Attr mXml;
    @Nullable
    private final AttributeModel mAttributeModel;

    /**
     * Creates a new facade object to a {@link Attr} xml attribute in a
     * {@link XmlElement}.
     *
     * @param ownerElement the xml node object owning this attribute.
     * @param xml the xml definition of the attribute.
     */
    public XmlAttribute(
            @NonNull XmlElement ownerElement,
            @NonNull Attr xml,
            @Nullable AttributeModel attributeModel) {
        this.mOwnerElement = Preconditions.checkNotNull(ownerElement);
        this.mXml = Preconditions.checkNotNull(xml);
        this.mAttributeModel = attributeModel;
        if (mAttributeModel != null && mAttributeModel.isPackageDependent()) {
            String value = mXml.getValue();
            if (value == null || value.isEmpty()) return;
            // placeholders are never expanded.
            if (!PlaceholderHandler.isPlaceHolder(value)) {
                String pkg = mOwnerElement.getDocument().getPackageNameForAttributeExpansion();
                // We know it's a shortened FQCN if it starts with a dot
                // or does not contain any dot.
                if (value.indexOf('.') == -1 || value.charAt(0) == '.') {
                    if (value.charAt(0) == '.') {
                        value = pkg + value;
                    } else {
                        value = pkg + '.' + value;
                    }
                    mXml.setValue(value);
                }
            }
        }
    }

    /**
     * Returns the attribute's name, providing isolation from details like namespaces handling.
     */
    @Override
    public NodeName getName() {
        return XmlNode.unwrapName(mXml);
    }

    /**
     * Returns the attribute's value
     */
    public String getValue() {
        return mXml.getValue();
    }

    /**
     * Returns a display friendly identification string that can be used in machine and user
     * readable messages.
     */
    @Override
    public NodeKey getId() {
        // (Id of the parent element)@(my name)
        String myName = mXml.getNamespaceURI() == null ? mXml.getName() : mXml.getLocalName();
        return new NodeKey(mOwnerElement.getId() + "@" + myName);
    }

    @NonNull
    @Override
    public SourcePosition getPosition() {
        try {
            return mOwnerElement.getDocument().getNodePosition(this);
        } catch(Exception e) {
            return SourcePosition.UNKNOWN;
        }
    }

    @NonNull
    @Override
    public Attr getXml() {
        return mXml;
    }

    @Nullable
    public AttributeModel getModel() {
        return mAttributeModel;
    }

    XmlElement getOwnerElement() {
        return mOwnerElement;
    }

    void mergeInHigherPriorityElement(XmlElement higherPriorityElement,
            MergingReport.Builder mergingReport) {

        // does the higher priority has the same attribute as myself ?
        Optional<XmlAttribute> higherPriorityAttributeOptional =
                higherPriorityElement.getAttribute(getName());

        AttributeOperationType attributeOperationType =
                higherPriorityElement.getAttributeOperationType(getName());

        if (higherPriorityAttributeOptional.isPresent()) {

            XmlAttribute higherPriorityAttribute = higherPriorityAttributeOptional.get();
            handleBothAttributePresent(
                    mergingReport, higherPriorityAttribute, attributeOperationType);
            return;
        }

        // it does not exist, verify if we are supposed to remove it.
        if (attributeOperationType == AttributeOperationType.REMOVE) {
            // record the fact the attribute was actively removed.
            mergingReport.getActionRecorder().recordAttributeAction(
                    this,
                    Actions.ActionType.REJECTED,
                    AttributeOperationType.REMOVE);
            return;
        }

        // the node is not defined in the higher priority element, it's defined in this lower
        // priority element, we need to merge this lower priority attribute value with a potential
        // higher priority default value (implicitly set on the higher priority element).
        String mergedValue = mergeThisAndDefaultValue(mergingReport, higherPriorityElement);
        if (mergedValue == null) {
            return;
        }

        // ok merge it in the higher priority element.
        getName().addToNode(higherPriorityElement.getXml(), mergedValue);

        // and record the action.
        mergingReport.getActionRecorder().recordAttributeAction(
                this,
                Actions.ActionType.ADDED,
                getOwnerElement().getAttributeOperationType(getName()));
    }

    /**
     * Handles merging of two attributes value explicitly declared in xml elements.
     *
     * @param report report to log errors and actions.
     * @param higherPriority higher priority attribute we should merge this attribute with.
     * @param operationType user operation type optionally requested by the user.
     */
    private void handleBothAttributePresent(
            MergingReport.Builder report,
            XmlAttribute higherPriority,
            AttributeOperationType operationType) {

        // handles tools: attribute separately.

        if (getXml().getNamespaceURI() != null
                && getXml().getNamespaceURI().equals(SdkConstants.TOOLS_URI)) {
            handleBothToolsAttributePresent(higherPriority);
            return;
        }

        // the attribute is present on both elements, there are 2 possibilities :
        // 1. tools:replace was specified, replace the value.
        // 2. nothing was specified, the values should be equal or this is an error.
        if (operationType == AttributeOperationType.REPLACE) {
            // record the fact the lower priority attribute was rejected.
            report.getActionRecorder().recordAttributeAction(
                    this,
                    Actions.ActionType.REJECTED,
                    AttributeOperationType.REPLACE);
            return;
        }
        // if the values are the same, then it's fine, otherwise flag the error.
        if (mAttributeModel != null) {
            String mergedValue = mAttributeModel.getMergingPolicy()
                    .merge(higherPriority.getValue(), getValue());
            if (mergedValue != null) {
                higherPriority.mXml.setValue(mergedValue);
            } else {
                addConflictingValueMessage(report, higherPriority);
            }
            return;
        }
        // no merging policy, for now revert on checking manually for equality.
        if (!getValue().equals(higherPriority.getValue())) {
            addConflictingValueMessage(report, higherPriority);
        }
    }

    /**
     * Handles tools: namespace attributes presence in both documents.
     * @param higherPriority the higherPriority attribute
     */
    private void handleBothToolsAttributePresent(
            XmlAttribute higherPriority) {

        // do not merge tools:node attributes, the higher priority one wins.
        if (getName().getLocalName().equals(NodeOperationType.NODE_LOCAL_NAME)) {
            return;
        }

        // everything else should be merged, duplicates should be eliminated.
        Splitter splitter = Splitter.on(',');
        ImmutableSet.Builder<String> targetValues = ImmutableSet.builder();
        targetValues.addAll(splitter.split(higherPriority.getValue()));
        targetValues.addAll(splitter.split(getValue()));
        higherPriority.getXml().setValue(Joiner.on(',').join(targetValues.build()));
    }

    /**
     * Merge this attribute value (on a lower priority element) with a implicit default value
     * (implicitly declared on the implicitNode).
     * @param mergingReport report to log errors and actions.
     * @param implicitNode the lower priority node where the implicit attribute value resides.
     * @return the merged value that should be stored in the attribute or null if nothing should
     * be stored.
     */
    private String mergeThisAndDefaultValue(MergingReport.Builder mergingReport,
            XmlElement implicitNode) {

        String mergedValue = getValue();
        if (mAttributeModel == null || mAttributeModel.getDefaultValue() == null
                || !mAttributeModel.getMergingPolicy().shouldMergeDefaultValues()) {
            return mergedValue;
        }
        String defaultValue = mAttributeModel.getDefaultValue();
        if (defaultValue.equals(mergedValue)) {
            // even though the lower priority attribute is only declared and its value is the same
            // as the default value, ensure it gets added to the higher priority node.
            return mergedValue;
        } else {
            // ok, the default value and actual declaration are different, delegate to the
            // merging policy to figure out what value should be used if any.
            mergedValue = mAttributeModel.getMergingPolicy().merge(defaultValue, mergedValue);
            if (mergedValue == null) {
                addIllegalImplicitOverrideMessage(mergingReport, mAttributeModel, implicitNode);
                return null;
            }
            if (mergedValue.equals(defaultValue)) {
                // no need to forcefully add an attribute to the parent with its default value
                // since it was not declared to start with.
                return null;
            }
        }
        return mergedValue;
    }

    /**
     * Merge this attribute value with a lower priority node attribute default value.
     * The attribute is not explicitly set on the implicitNode, yet it exist on this attribute
     * {@link com.android.manifmerger.XmlElement} higher priority owner.
     *
     * @param mergingReport report to log errors and actions.
     * @param implicitNode the lower priority node where the implicit attribute value resides.
     */
    void mergeWithLowerPriorityDefaultValue(
            MergingReport.Builder mergingReport, XmlElement implicitNode) {

        if (mAttributeModel == null || mAttributeModel.getDefaultValue() == null
                || !mAttributeModel.getMergingPolicy().shouldMergeDefaultValues()) {
            return;
        }
        // if this value has been explicitly set to replace the implicit default value, just
        // log the action.
        if (mOwnerElement.getAttributeOperationType(getName()) == AttributeOperationType.REPLACE) {
            mergingReport.getActionRecorder().recordImplicitRejection(this, implicitNode);
            return;
        }
        String mergedValue = mAttributeModel.getMergingPolicy().merge(
                getValue(), mAttributeModel.getDefaultValue());
        if (mergedValue == null) {
            addIllegalImplicitOverrideMessage(mergingReport, mAttributeModel, implicitNode);
        } else {
            getXml().setValue(mergedValue);
            mergingReport.getActionRecorder().recordAttributeAction(
                    this,
                    Actions.ActionType.MERGED,
                    null /* attributeOperationType */);
        }
    }

    private void addIllegalImplicitOverrideMessage(
            @NonNull MergingReport.Builder mergingReport,
            @NonNull AttributeModel attributeModel,
            @NonNull XmlElement implicitNode) {
        String error = String.format("Attribute %1$s value=(%2$s) at %3$s"
                        + " cannot override implicit default value=(%4$s) at %5$s",
                getId(),
                getValue(),
                printPosition(),
                attributeModel.getDefaultValue(),
                implicitNode.printPosition());
        addMessage(mergingReport, MergingReport.Record.Severity.ERROR, error);
    }

    private void addConflictingValueMessage(
            MergingReport.Builder report,
            XmlAttribute higherPriority) {

        Actions.AttributeRecord attributeRecord = report.getActionRecorder()
                .getAttributeCreationRecord(higherPriority);

        String error;
        if (getOwnerElement().getType().getMergeType() == MergeType.MERGE_CHILDREN_ONLY) {
            error = String.format(
                    "Attribute %1$s value=(%2$s) from %3$s\n"
                            + "\tis also present at %4$s value=(%5$s).\n"
                            + "\tAttributes of <%6$s> elements are not merged.",
                    higherPriority.getId(),
                    higherPriority.getValue(),
                    attributeRecord != null
                            ? attributeRecord.getActionLocation().print(true /*shortFormat*/)
                            : "(unknown)",
                    printPosition(),
                    getValue(),
                    getOwnerElement().getType().toXmlName());
        } else {
            error = String.format(
                    "Attribute %1$s value=(%2$s) from %3$s\n"
                            + "\tis also present at %4$s value=(%5$s).\n"
                            + "\tSuggestion: add 'tools:replace=\"%6$s\"' to <%7$s> element "
                            + "at %8$s to override.",
                    higherPriority.getId(),
                    higherPriority.getValue(),
                    attributeRecord != null
                            ? attributeRecord.getActionLocation().print(true /*shortFormat*/)
                            : "(unknown)",
                    printPosition(),
                    getValue(),
                    mXml.getName(),
                    getOwnerElement().getType().toXmlName(),
                    higherPriority.getOwnerElement().printPosition());
        }
        higherPriority.addMessage(report,
                attributeRecord != null
                        ? attributeRecord.getActionLocation().getPosition()
                        : SourcePosition.UNKNOWN,
                MergingReport.Record.Severity.ERROR, error);
    }

    void addMessage(MergingReport.Builder report,
            MergingReport.Record.Severity severity,
            String message) {
        addMessage(report, getPosition(), severity, message);
    }

    void addMessage(MergingReport.Builder report,
            SourcePosition position,
            MergingReport.Record.Severity severity,
            String message) {
        report.addMessage(
                new SourceFilePosition(getOwnerElement().getDocument().getSourceFile(), position),
                severity, message);
    }

    @NonNull
    @Override
    public SourceFile getSourceFile() {
        return getOwnerElement().getSourceFile();
    }
}