RegularExpressionConverter.java

/*******************************************************************************
 * Copyright 2012 André Rouél
 * 
 * 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 net.sf.uadetector.internal.util;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;

import net.sf.qualitycheck.Check;

public final class RegularExpressionConverter {

    public enum Flag {

        /**
         * Enables canonical equivalence.
         */
        CANON_EQ(Pattern.CANON_EQ, 'c'),

        /**
         * Enables case-insensitive matching.
         */
        CASE_INSENSITIVE(Pattern.CASE_INSENSITIVE, 'i'),

        /**
         * Permits whitespace and comments in pattern.
         */
        COMMENTS(Pattern.COMMENTS, 'x'),

        /**
         * Enables dotall mode.
         */
        DOTALL(Pattern.DOTALL, 's'),

        /**
         * Enables literal parsing of the pattern.
         */
        LITERAL(Pattern.LITERAL, 'l'),

        /**
         * Enables multiline mode.
         */
        MULTILINE(Pattern.MULTILINE, 'm'),

        /**
         * Enables Unicode-aware case folding.
         */
        UNICODE_CASE(Pattern.UNICODE_CASE, 'u'),

        /**
         * Enables Unix lines mode.
         */
        UNIX_LINES(Pattern.UNIX_LINES, 'e');

        private static class FlagByCharacterComparator extends CompareNullSafe<Flag> {
            private static final long serialVersionUID = 1L;

            @Override
            public int compareType(@Nonnull final Flag f1, @Nonnull final Flag f2) {
                final Character c1 = Character.valueOf(f1.getCharacter());
                final Character c2 = Character.valueOf(f2.getCharacter());
                return c1.compareTo(c2);
            }
        }

        private static final FlagByCharacterComparator FLAG_COMPARATOR = new FlagByCharacterComparator();

        /**
         * Converts a set of flags as to a bitmask (sum of numerical values).
         * 
         * @param flags
         *            a set of flags
         * @return sum of numerical values of passed flags or 0
         */
        public static int convertToBitmask(@Nonnull final Collection<Flag> flags) {
            Check.notNull(flags, "flags");

            int bitmask = 0;
            for (final Flag flag : flags) {
                bitmask = bitmask | flag.getNumber();
            }
            return bitmask;
        }

        /**
         * Converts a set of flags as to a string representation. The flags {@link Flag#CASE_INSENSITIVE},
         * {@link Flag#DOTALL}, {@link Flag#MULTILINE} and {@link Flag#COMMENTS} are identical to the PERL regular
         * expression modifiers.
         * 
         * @param flags
         *            a set of flags
         * @return sum of numerical values of passed flags or 0
         */
        public static String convertToModifiers(@Nonnull final Collection<Flag> flags) {
            Check.notNull(flags, "flags");

            final StringBuilder modifiers = new StringBuilder(8);
            final Set<Flag> sortedFlags = new TreeSet<Flag>(Collections.reverseOrder(FLAG_COMPARATOR));
            sortedFlags.addAll(flags);
            for (final Flag flag : sortedFlags) {
                modifiers.append(flag.getCharacter());
            }
            return modifiers.toString();
        }

        /**
         * This method try to find a matching enum value by the given character representation. The character will be
         * evaluated against the stored character of a flag.
         * 
         * @param flag
         *            representation of a flag as a character
         * @return the matching enum value or {@code null}
         * @throws net.sf.qualitycheck.exception.IllegalNegativeArgumentException
         *             if the given number is smaller than zero
         */
        public static Flag evaluateByCharacter(final char flag) {
            Check.notNegative(flag, "flag");
            Flag result = null;
            for (final Flag value : values()) {
                if (value.getCharacter() == flag) {
                    result = value;
                    break;
                }
            }
            return result;
        }

        /**
         * This method try to find a matching enum value by the given numerical representation. The number will be
         * evaluated against the stored number of a flag.
         * 
         * @param flag
         *            representation of a flag as a character
         * @return the matching enum value or {@code null}
         * @throws net.sf.qualitycheck.exception.IllegalNegativeArgumentException
         *             if the given number is smaller than zero
         */
        public static Flag evaluateByNumber(final int flag) {
            Check.notNegative(flag, "flag");
            Flag result = null;
            for (final Flag value : values()) {
                if (value.getNumber() == flag) {
                    result = value;
                    break;
                }
            }
            return result;
        }

        /**
         * Parses a sum of flags as numerical values (bitmask) and translates it to set of enum values.
         * 
         * @param bitmask
         *            Sum of numerical values of flags
         * @return a set of flags
         * @throws net.sf.qualitycheck.exception.IllegalNegativeArgumentException
         *             if the given number is smaller than zero
         */
        @Nonnull
        public static Set<Flag> parse(@Nonnegative final int bitmask) {
            Check.notNegative(bitmask, "bitmask");

            final Set<Flag> flags = new HashSet<Flag>();
            for (final Flag flag : values()) {
                if ((bitmask & flag.getNumber()) != 0) {
                    flags.add(flag);
                }
            }
            return flags;
        }

        /**
         * Translates PERL style modifiers to a set of {@code Pattern} compatible ones.
         * 
         * @param modifiers
         *            modifiers as string of a PERL style regular expression
         * @return a set of modifier flags that may include CASE_INSENSITIVE, MULTILINE, DOTALL and COMMENTS
         */
        public static Set<Flag> parse(@Nonnull final String modifiers) {
            Check.notNull(modifiers, "modifiers");

            final Set<Flag> flags = new HashSet<Flag>();
            for (int i = 0; i < modifiers.length(); i++) {
                final Flag flag = Flag.evaluateByCharacter(modifiers.charAt(i));
                if (flag != null) {
                    flags.add(flag);
                }
            }
            return flags;
        }

        /**
         * Representation of a flag as a character
         */
        private final char character;

        /**
         * Representation of a flag as a number
         */
        private final int number;

        private Flag(final int value, final char character) {
            number = value;
            this.character = character;
        }

        /**
         * Returns this flag as character representation.
         * 
         * @return representation as a character
         */
        public char getCharacter() {
            return character;
        }

        /**
         * Returns this flag as numerical representation.
         * 
         * @return representation as a number
         */
        public int getNumber() {
            return number;
        }

    }

    /**
     * Template to support the conversion into a PERL style regular expression
     */
    private static final String PATTERN_TO_REGEX_TEMPLATE = "/%s/%s";

    /**
     * Pattern for PERL style regular expression strings
     */
    private static final Pattern PERL_STYLE = Pattern.compile("^/.*/((i|m|s|x)*)?$");

    /**
     * Pattern for PERL style regular expression strings with more fault-tolerance to the modifiers
     */
    private static final Pattern PERL_STYLE_TOLERANT = Pattern.compile("^/.*/(([A-z])*)?$");

    /**
     * Converts a given {@code Pattern} into a PERL style regular expression.
     * 
     * @param pattern
     *            regular expression pattern
     * @return PERL style regular expression as string
     */
    public static String convertPatternToPerlRegex(@Nonnull final Pattern pattern) {
        Check.notNull(pattern, "pattern");
        final String modifiers = Flag.convertToModifiers(Flag.parse(pattern.flags()));
        return String.format(PATTERN_TO_REGEX_TEMPLATE, pattern.pattern(), modifiers);
    }

    /**
     * Converts a PERL style regular expression into Java style.<br>
     * <br>
     * The leading and ending slash and the modifiers will be removed. The modifiers will be translated into equivalents
     * flags of <code>java.util.Pattern</code>. If there are modifiers that are not valid an exception will be thrown.
     * 
     * @param regex
     *            A PERL style regular expression
     * @return Pattern
     */
    public static Pattern convertPerlRegexToPattern(@Nonnull final String regex) {
        return convertPerlRegexToPattern(regex, false);
    }

    /**
     * Converts a PERL style regular expression into Java style.<br>
     * <br>
     * The leading and ending slash and the modifiers will be removed.
     * 
     * @param regex
     *            A PERL style regular expression
     * @param faultTolerant
     *            Fault-tolerant translating the flags
     * @return Pattern
     */
    public static Pattern convertPerlRegexToPattern(@Nonnull final String regex, @Nonnull final boolean faultTolerant) {
        Check.notNull(regex, "regex");

        String pattern = regex.trim();
        final Matcher matcher = faultTolerant ? PERL_STYLE_TOLERANT.matcher(pattern) : PERL_STYLE.matcher(pattern);
        if (!matcher.matches()) {
            throw new IllegalArgumentException("The given regular expression '" + pattern
                    + "' seems to be not in PERL style or has unsupported modifiers.");
        }

        pattern = pattern.substring(1);
        final int lastIndex = pattern.lastIndexOf('/');
        pattern = pattern.substring(0, lastIndex);

        final int flags = Flag.convertToBitmask(Flag.parse(matcher.group(1)));
        return Pattern.compile(pattern, flags);
    }

    /**
     * <strong>Attention:</strong> This class is not intended to create objects from it.
     */
    private RegularExpressionConverter() {
        // This class is not intended to create objects from it.
    }

}