NodeNameHelper

/**
 * This file Copyright (c) 2017-2018 Magnolia International
 * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
 *
 *
 * This file is dual-licensed under both the Magnolia
 * Network Agreement and the GNU General Public License.
 * You may elect to use one or the other of these licenses.
 *
 * This file is distributed in the hope that it will be
 * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
 * Redistribution, except as permitted by whichever of the GPL
 * or MNA you select, is prohibited.
 *
 * 1. For the GPL license (GPL), you can redistribute and/or
 * modify this file under the terms of the GNU General
 * Public License, Version 3, as published by the Free Software
 * Foundation.  You should have received a copy of the GNU
 * General Public License, Version 3 along with this program;
 * if not, write to the Free Software Foundation, Inc., 51
 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * 2. For the Magnolia Network Agreement (MNA), this file
 * and the accompanying materials are made available under the
 * terms of the MNA which accompanies this distribution, and
 * is available at http://www.magnolia-cms.com/mna.html
 *
 * Any modifications to this file must keep this entire header
 * intact.
 *
 */
package info.magnolia.jcr.util;

import info.magnolia.cms.util.SelectorUtil;
import info.magnolia.init.MagnoliaConfigurationProperties;

import java.nio.charset.StandardCharsets;

import javax.inject.Inject;
import javax.inject.Singleton;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;

/**
 * Util component for creation of an unique and validated node name.
 */
@Singleton
public class NodeNameHelper {

    private final String DEFAULT_UNTITLED_NODE_NAME = "untitled";

    private final MagnoliaConfigurationProperties magnoliaConfigurationProperties;

    @Inject
    public NodeNameHelper(MagnoliaConfigurationProperties magnoliaConfigurationProperties) {
        this.magnoliaConfigurationProperties = magnoliaConfigurationProperties;
    }

    /**
     * Checks if an item already exists with given name in JCR, and returns a unique name;
     * if necessary, an increment is appended to the name.
     *
     * <p>Given the following tree:</p>
     * <pre>
     * /
     * ├── a
     * ├── b
     * └── b0
     *
     * NodeUtil.getUniqueName(session, "/", "a")  = "a0"
     * NodeUtil.getUniqueName(session, "/", "b")  = "b1"
     * NodeUtil.getUniqueName(session, "/", "b0") = "b1"
     * NodeUtil.getUniqueName(session, "/", "c")  = "c"
     * </pre>
     */
    public String getUniqueName(Session session, String parentPath, String name) throws RepositoryException {
        if (parentPath.equals("/")) {
            parentPath = StringUtils.EMPTY;
        }
        while (session.itemExists(parentPath + "/" + name)) {
            name = createUniqueName(name);
        }
        return name;
    }

    /**
     * Checks if an item already exists with given name in JCR, and returns a unique name;
     * if necessary, an increment is inserted into the name, before the given extension.
     *
     * <p>Given the following tree:</p>
     * <pre>
     * /
     * ├── a.txt
     * ├── b.txt
     * └── b0.txt
     *
     * NodeUtil.getUniqueName(session, "/", "a.txt", "txt")  = "a0.txt"
     * NodeUtil.getUniqueName(session, "/", "b.txt", "txt")  = "b1.txt"
     * NodeUtil.getUniqueName(session, "/", "b0.txt", "txt") = "b1.txt"
     * NodeUtil.getUniqueName(session, "/", "c.txt", "txt")  = "c.txt"
     * NodeUtil.getUniqueName(session, "/", "a.foo", "txt")  = "a.foo"
     * </pre>
     */
    public String getUniqueName(Session session, String parentPath, String name, String extension) throws RepositoryException {
        if (StringUtils.isNotEmpty(extension) && extension.equals(FilenameUtils.getExtension(name))) {
            parentPath = "/".equals(parentPath) ? StringUtils.EMPTY : parentPath;
            String basename = FilenameUtils.getBaseName(name);
            String fullName = name;

            while (session.itemExists(parentPath + "/" + fullName)) {
                basename = createUniqueName(basename);
                fullName = basename + FilenameUtils.EXTENSION_SEPARATOR + extension;
            }
            return fullName;
        }

        return getUniqueName(session, parentPath, name);
    }

    public String getUniqueName(Node parent, String name) throws RepositoryException {
        while (parent.hasNode(name) || parent.hasProperty(name)) {
            name = createUniqueName(name);
        }
        return name;
    }

    /**
     * Replace illegal characters based on magnolia property magnolia.ut8.enabled.
     *
     * @return validated label
     */
    public String getValidatedName(String name) {
        String charset = StringUtils.EMPTY;
        if (magnoliaConfigurationProperties.getBooleanProperty(MagnoliaConfigurationProperties.MAGNOLIA_UTF8_ENABLED)) {
            charset = StandardCharsets.UTF_8.name();
        }
        return getValidatedName(name, charset);
    }

    /**
     * If charset equals <code>UTF-8</code>, replaces the following characters with a dash <code>-</code> :
     * <p>
     * Jackrabbit not allowed {@code 32: [ ] 91: [[] 93: []] 42: [*] 34: ["] 58 [:] 92: [\] 39 :[']}
     * <p>
     * URL not valid {@code 59: [;] 47: [/] 63: [?] 43: [+] 37: [%] 33: [!] 35:[#] 94: [^]}.
     * <p>
     * Otherwise, replaces illegal characters with a dash <code>-</code> except for {@code [_] [0-9], [A-Z], [a-z], [-], [_], [.]}.
     * <p>
     * Please notice that a valid name can not begin with dot or period <code>[.]</code>.
     *
     * @return a validated name for a node.
     */
    public String getValidatedName(String name, String charset) {
        if (StringUtils.isEmpty(name)) {
            return DEFAULT_UNTITLED_NODE_NAME;
        }
        final StringBuilder newLabel = new StringBuilder(name.length());

        // name cannot begin with . (dot)
        int ch = name.charAt(0);
        if (!isCharValid(ch, charset) || ch == 46) {
            newLabel.append("-");
        } else {
            newLabel.append(name.charAt(0));
        }

        for (int i = 1; i < name.length(); i++) {
            int charCode = name.charAt(i);
            if (isCharValid(charCode, charset)) {
                newLabel.append(name.charAt(i));
            } else {
                newLabel.append("-");
            }
        }
        if (newLabel.length() == 0) {
            newLabel.append(DEFAULT_UNTITLED_NODE_NAME);
        }
        return newLabel.toString();
    }

    public boolean isValidName(String name) {
        String charset = StringUtils.EMPTY;
        if (magnoliaConfigurationProperties.getBooleanProperty(MagnoliaConfigurationProperties.MAGNOLIA_UTF8_ENABLED)) {
            charset = StandardCharsets.UTF_8.name();
        }
        return isValidName(name, charset);
    }

    public boolean isValidName(String name, String charset) {
        return name.equals(getValidatedName(name, charset));
    }

    private boolean isCharValid(int charCode, String charset) {
        // TODO fgrilli: we now allow dots (.) in JR local names but actually in JR 2.0 other chars could be allowed as well
        // (see http://www.day.com/specs/jcr/2.0/3_Repository_Model.html paragraph 2.2 and org.apache.jackrabbit.util.XMLChar.isValid()).
        // Also, now that we're on java 6 and JR 2.0 should the check for the charset be dropped?

        // http://www.ietf.org/rfc/rfc1738.txt
        // safe = "$" | "-" | "_" | "." | "+"
        // extra = "!" | "*" | "'" | "(" | ")" | ","
        // national = "{" | "}" | "|" | "\" | "^" | "~" | "[" | "]" | "`"
        // punctuation = "<" | ">" | "#" | "%" | <">
        // reserved = ";" | "/" | "?" | ":" | "@" | "&" | "="

        if (StandardCharsets.UTF_8.name().equals(charset)) {
            // jackrabbit not allowed 32: [ ] 91: [[] 93: []] 42: [*] 34: ["] 46: [.] 58 [:] 92: [\] 39 :[']
            // url not valid 59: [;] 47: [/] 63: [?] 43: [+] 37: [%] 33: [!] 35:[#]
            if (charCode != 32
                    && charCode != '['
                    && charCode != ']'
                    && charCode != '*'
                    && charCode != '"'
                    && charCode != ':'
                    && charCode != 92
                    && charCode != 39
                    && charCode != ';'
                    && charCode != '/'
                    && charCode != '?'
                    && charCode != '+'
                    && charCode != '%'
                    && charCode != '!'
                    && charCode != '#'
                    && charCode != '@'
                    && charCode != '='
                    && charCode != '&'
                    && charCode != SelectorUtil.SELECTOR_DELIMITER.charAt(0)) {
                return true;
            }
        } else {
            // charCodes: 48-57: [0-9]; 65-90: [A-Z]; 97-122: [a-z]; 45: [-]; 95:[_]
            if (((charCode >= 48) && (charCode <= 57))
                    || ((charCode >= 65) && (charCode <= 90))
                    || ((charCode >= 97) && (charCode <= 122))
                    || charCode == 45
                    || charCode == 46
                    || charCode == 95) {
                return true;
            }

        }
        return false;
    }

    private String createUniqueName(String baseName) {
        int pos;
        for (pos = baseName.length() - 1; pos >= 0; pos--) {
            char c = baseName.charAt(pos);
            if (c < '0' || c > '9') {
                break;
            }
        }
        String base;
        int cnt;
        if (pos == -1) {
            if (baseName.length() > 1) {
                pos = baseName.length() - 2;
            }
        }
        if (pos == -1) {
            base = baseName;
            cnt = -1;
        } else {
            pos++;
            base = baseName.substring(0, pos);
            if (pos == baseName.length()) {
                cnt = -1;
            } else {
                cnt = Integer.parseInt(baseName.substring(pos));
            }
        }
        return (base + ++cnt);
    }
}