AttributesRule.java

/*
 * Copyright (C) 2010, 2017 Red Hat Inc. and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
package org.eclipse.jgit.attributes;

import static org.eclipse.jgit.ignore.IMatcher.NO_MATCH;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.jgit.attributes.Attribute.State;
import org.eclipse.jgit.errors.InvalidPatternException;
import org.eclipse.jgit.ignore.FastIgnoreRule;
import org.eclipse.jgit.ignore.IMatcher;
import org.eclipse.jgit.ignore.internal.PathMatcher;

/**
 * A single attributes rule corresponding to one line in a .gitattributes file.
 *
 * Inspiration from: {@link org.eclipse.jgit.ignore.FastIgnoreRule}
 *
 * @since 3.7
 */
public class AttributesRule {

    /**
     * regular expression for splitting attributes - space, tab and \r (the C
     * implementation oddly enough allows \r between attributes)
     * */
    private static final String ATTRIBUTES_SPLIT_REGEX = "[ \t\r]"; //$NON-NLS-1$

    private static List<Attribute> parseAttributes(String attributesLine) {
        // the C implementation oddly enough allows \r between attributes too.
        ArrayList<Attribute> result = new ArrayList<>();
        for (String attribute : attributesLine.split(ATTRIBUTES_SPLIT_REGEX)) {
            attribute = attribute.trim();
            if (attribute.length() == 0)
                continue;

            if (attribute.startsWith("-")) {//$NON-NLS-1$
                if (attribute.length() > 1)
                    result.add(new Attribute(attribute.substring(1),
                            State.UNSET));
                continue;
            }

            if (attribute.startsWith("!")) {//$NON-NLS-1$
                if (attribute.length() > 1)
                    result.add(new Attribute(attribute.substring(1),
                            State.UNSPECIFIED));
                continue;
            }

            final int equalsIndex = attribute.indexOf('=');
            if (equalsIndex == -1)
                result.add(new Attribute(attribute, State.SET));
            else {
                String attributeKey = attribute.substring(0, equalsIndex);
                if (attributeKey.length() > 0) {
                    String attributeValue = attribute
                            .substring(equalsIndex + 1);
                    result.add(new Attribute(attributeKey, attributeValue));
                }
            }
        }
        return result;
    }

    private final String pattern;
    private final List<Attribute> attributes;

    private final boolean nameOnly;

    private final boolean dirOnly;

    private final IMatcher matcher;

    /**
     * Create a new attribute rule with the given pattern. Assumes that the
     * pattern is already trimmed.
     *
     * @param pattern
     *            Base pattern for the attributes rule. This pattern will be
     *            parsed to generate rule parameters. It can not be
     *            <code>null</code>.
     * @param attributes
     *            the rule attributes. This string will be parsed to read the
     *            attributes.
     */
    public AttributesRule(String pattern, String attributes) {
        this.attributes = parseAttributes(attributes);

        if (pattern.endsWith("/")) { //$NON-NLS-1$
            pattern = pattern.substring(0, pattern.length() - 1);
            dirOnly = true;
        } else {
            dirOnly = false;
        }

        int slashIndex = pattern.indexOf('/');

        if (slashIndex < 0) {
            nameOnly = true;
        } else if (slashIndex == 0) {
            nameOnly = false;
        } else {
            nameOnly = false;
            // Contains "/" but does not start with one
            // Adding / to the start should not interfere with matching
            pattern = "/" + pattern; //$NON-NLS-1$
        }

        IMatcher candidateMatcher = NO_MATCH;
        try {
            candidateMatcher = PathMatcher.createPathMatcher(pattern,
                    Character.valueOf(FastIgnoreRule.PATH_SEPARATOR), dirOnly);
        } catch (InvalidPatternException e) {
            // ignore: invalid patterns are silently ignored
        }
        this.matcher = candidateMatcher;
        this.pattern = pattern;
    }

    /**
     * Whether to match directories only
     *
     * @return {@code true} if the pattern should match directories only
     * @since 4.3
     */
    public boolean isDirOnly() {
        return dirOnly;
    }

    /**
     * Return the attributes.
     *
     * @return an unmodifiable list of attributes (never returns
     *         <code>null</code>)
     */
    public List<Attribute> getAttributes() {
        return Collections.unmodifiableList(attributes);
    }

    /**
     * Whether the pattern is only a file name and not a path
     *
     * @return <code>true</code> if the pattern is just a file name and not a
     *         path
     */
    public boolean isNameOnly() {
        return nameOnly;
    }

    /**
     * Get the pattern
     *
     * @return The blob pattern to be used as a matcher (never returns
     *         <code>null</code>)
     */
    public String getPattern() {
        return pattern;
    }

    /**
     * Returns <code>true</code> if a match was made.
     *
     * @param relativeTarget
     *            Name pattern of the file, relative to the base directory of
     *            this rule
     * @param isDirectory
     *            Whether the target file is a directory or not
     * @return True if a match was made.
     */
    public boolean isMatch(String relativeTarget, boolean isDirectory) {
        if (relativeTarget == null)
            return false;
        if (relativeTarget.length() == 0)
            return false;
        boolean match = matcher.matches(relativeTarget, isDirectory, true);
        return match;
    }

    /** {@inheritDoc} */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(pattern);
        for (Attribute a : attributes) {
            sb.append(" "); //$NON-NLS-1$
            sb.append(a);
        }
        return sb.toString();

    }
}