MessageParamParser

/*
 * Copyright 2007-2013 smartics, Kronseder & Reiner GmbH
 *
 * 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 de.smartics.exceptions.i18n.message;

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

import org.apache.commons.lang.StringUtils;

import de.smartics.exceptions.i18n.app.ParseExceptionCode;

/**
 * This class provides methods to parse message parameter.
 */
public final class MessageParamParser
{
  // ********************************* Fields *********************************

  // --- constants ------------------------------------------------------------

  // --- members --------------------------------------------------------------

  // ****************************** Initializer *******************************

  // ****************************** Constructors ******************************

  /**
   * Utility class.
   */
  private MessageParamParser()
  {
  }

  // ****************************** Inner Classes *****************************

  /**
   * Contains the placeholderId information for one message parameter.
   */
  public static final class MessageParamInfo
  {
    // ******************************** Fields ********************************

    // --- constants ----------------------------------------------------------

    // --- members ------------------------------------------------------------

    /**
     * The identifier of the placeholder (index or property name) the
     * information should be written to.
     */
    private final String placeholderId;

    /**
     * The OGNL path to the value inside the value to use.
     */
    private final String ognlPath;

    // ***************************** Initializer ******************************

    // ***************************** Constructors *****************************

    /**
     * Default constructor.
     *
     * @param placeholderId the identifier of the placeholder (index or property
     *          name) the information should be written to.
     * @param ognlPath the OGNL path to the value inside the value to use.
     */
    public MessageParamInfo(final String placeholderId, final String ognlPath)
    {
      this.placeholderId = placeholderId;
      this.ognlPath = ognlPath;
    }

    // ***************************** Inner Classes ****************************

    // ******************************** Methods *******************************

    // --- init ---------------------------------------------------------------

    // --- get&set ------------------------------------------------------------

    /**
     * Returns the identifier of the placeholder (index or property name) the
     * information should be written to.
     *
     * @return the identifier of the placeholder (index or property name) the
     *         information should be written to.
     */
    public String getPlaceholderId()
    {
      return placeholderId;
    }

    /**
     * Returns the OGNL path to the value inside the value to use.
     *
     * @return the OGNL path to the value inside the value to use.
     */
    public String getOgnlPath()
    {
      return ognlPath;
    }

    // --- business -----------------------------------------------------------

    // --- object basics ------------------------------------------------------
  }

  // ********************************* Methods ********************************

  // --- init -----------------------------------------------------------------

  // --- get&set --------------------------------------------------------------

  // --- business -------------------------------------------------------------

  /**
   * Splits the input string into message param informations.
   * <p>
   * The expected format is a comma separated list of
   * <code>placeholderId:ognlPath</code> strings. The OGNL path may be missing,
   * in this case the placeholderId alone.
   * </p>
   * <p>
   * Example: <code>0:user.name,4,3:user.id</code>.
   * </p>
   * <p>
   * Spaces between tokens are removed.
   * </p>
   * <p>
   * If the input string is <code>null</code> or empty, the empty list is
   * returned.
   * </p>
   *
   * @param propertyName the name of the property whose message parameter is to
   *          be parsed.
   * @param input the input string to parse.
   * @return the list of message parameter infos.
   * @throws ParseException if the input is violating the expected syntax.
   */
  public static List<MessageParamInfo> parse(final String propertyName,
      final String input) throws ParseException
  {
    final List<MessageParamInfo> infos = new ArrayList<MessageParamInfo>();
    if (input == null || "".equals(input.trim()))
    {
      final MessageParamInfo info = new MessageParamInfo(propertyName, null);
      infos.add(info);
      return infos;
    }

    final List<String> tokens = Helper.split(input);
    for (final String token : tokens)
    {
      final String index;
      final String ognlPath;

      final int i = token.indexOf(':');
      if (i >= 0)
      {
        final String specifiedIndex = token.substring(0, i).trim();
        ognlPath = token.substring(i + 1).trim();
        if ("".equals(ognlPath))
        {
          throw new ParseException(ParseExceptionCode.OGNL, token, i + 1);
        }
        index =
            StringUtils.isNotBlank(specifiedIndex) ? specifiedIndex
                : calcNameFromPath(ognlPath);
      }
      else
      {
        index = token;
        ognlPath = null;
      }

      final MessageParamInfo info = new MessageParamInfo(index, ognlPath); // NOPMD
      infos.add(info);
    }

    return infos;
  }

  private static String calcNameFromPath(final String ognlPath)
  {
    final int index = ognlPath.lastIndexOf('.', ognlPath.length() - 2);
    if (index == -1)
    {
      return ognlPath;
    }
    return ognlPath.substring(index + 1);
  }

  /**
   * Parses the content of the parent message parameter. The input must follow
   * the following syntax:
   * <p>
   * <code>property=placeholderId:ognl-path</code> as in
   * <code>cause=1:message</code>
   * </p>
   * <p>
   * If several properties of a referenced entity are to be displayed at
   * different indices, separate them by commas and the information for
   * different attributes separate by colons (<code>;</code>).
   * </p>
   * <p>
   * <code>cause=1:cause.message,3:message,4:localizedMessage; message=5</code>
   * </p>
   *
   * @param input the input string to parse.
   * @return the parsed information. The key of the map is the name of the
   *         attribute, the value is the placeholderId information for that
   *         attribute.
   * @throws ParseException if the input is violating the expected syntax.
   */
  public static Map<String, List<MessageParamInfo>> parseParentMessageParam(
      final String input) throws ParseException
  {
    final String norm = fix(input);
    if (norm == null || "".equals(norm.trim()))
    {
      return Collections.emptyMap();
    }

    final Map<String, List<MessageParamInfo>> map =
        new HashMap<String, List<MessageParamInfo>>(// NOPMD
            3);
    final List<String> tokens = Helper.split(norm, ";");
    int currentParsingPosition = 0; // NOPMD
    for (final String token : tokens)
    {
      parseToken(norm, map, token, currentParsingPosition);
      currentParsingPosition = currentParsingPosition + token.length();
    }

    return map;
  }

  private static String fix(final String string)
  {
    if (string == null)
    {
      return null;
    }
    final int length = string.length();
    if (length > 2 && string.charAt(0) == '"')
    {
      return string.substring(1, string.length() - 1);
    }
    return string;
  }

  /**
   * Parses the given token and throws an exception if it cannot be parsed.
   *
   * @param input the input string is only used as exception information in case
   *          an exception is thrown.
   * @param map if the token is successfully parsed, the information is set to
   *          this map.
   * @param token the token to be analyzed. There should be a key and a value
   *          separated by the equal character ("<code>=</code>").
   * @param currentParsingPosition the current parsing position in the input
   *          string. This information is only passed to the exception in case
   *          one is thrown.
   * @throws ParseException if the token cannot be parsed.
   */
  private static void parseToken(final String input,
      final Map<String, List<MessageParamInfo>> map, final String token,
      final int currentParsingPosition) throws ParseException
  {
    final int index = token.indexOf('=');
    if (index != -1)
    {
      final String attributeName = token.substring(0, index).trim();
      if ("".equals(attributeName))
      {
        throw new ParseException(
            ParseExceptionCode.MISSING_PARENT_PROPERTY_ATTRIBUTE, input,
            currentParsingPosition + index);
      }
      final String subInput = token.substring(index + 1);
      if ("".equals(subInput))
      {
        throw new ParseException(
            ParseExceptionCode.MISSING_PARENT_PROPERTY_INDEX, input,
            currentParsingPosition + index + 1);
      }
      final List<MessageParamInfo> info = parse(attributeName, subInput);
      map.put(attributeName, info);
    }
    else
    {
      throw new ParseException(
          ParseExceptionCode.MISSING_PARENT_PROPERTY_SEPARATOR, input,
          currentParsingPosition);
    }
  }

  // --- object basics --------------------------------------------------------

}