| /* | |
| * Copyright 2008 Google Inc. | |
| * | |
| * 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.google.gwt.i18n.rebind; | |
| import com.google.gwt.core.ext.UnableToCompleteException; | |
| import java.text.ParseException; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| /** | |
| * Helper class for parsing MessageFormat-style format strings. | |
| * | |
| * @deprecated use {@link com.google.gwt.i18n.server.MessageFormatUtils} instead | |
| */ | |
| @Deprecated | |
| public class MessageFormatParser { | |
| /** | |
| * Represents an argument in a template string. | |
| */ | |
| public static class ArgumentChunk extends TemplateChunk { | |
| private final int argNumber; | |
| private final String format; | |
| private final Map<String, String> formatArgs; | |
| private final String subFormat; | |
| private final Map<String, String> listArgs; | |
| public ArgumentChunk(int argNumber, Map<String, String> listArgs, | |
| String format, Map<String, String> formatArgs, String subformat) { | |
| this.argNumber = argNumber; | |
| this.format = format; | |
| this.subFormat = subformat; | |
| this.listArgs = listArgs; | |
| this.formatArgs = formatArgs; | |
| } | |
| @Override | |
| public void accept(TemplateChunkVisitor visitor) | |
| throws UnableToCompleteException { | |
| visitor.visit(this); | |
| } | |
| /** | |
| * Get the argument number this chunk refers to. | |
| * | |
| * @return the argument number or -1 to refer to the right-most plural | |
| * argument | |
| */ | |
| public int getArgumentNumber() { | |
| return argNumber; | |
| } | |
| public String getFormat() { | |
| return format; | |
| } | |
| public Map<String, String> getFormatArgs() { | |
| return formatArgs; | |
| } | |
| public Map<String, String> getListArgs() { | |
| return listArgs; | |
| } | |
| public String getSubFormat() { | |
| return subFormat; | |
| } | |
| public boolean isList() { | |
| return listArgs != null; | |
| } | |
| @Override | |
| public String toString() { | |
| return "Argument: #=" + argNumber + ", format=" + format + ", subformat=" | |
| + subFormat; | |
| } | |
| @Override | |
| protected String getStringValue(boolean quote) { | |
| StringBuilder buf = new StringBuilder(); | |
| buf.append('{'); | |
| if (argNumber < 0) { | |
| buf.append('#'); | |
| } else { | |
| buf.append(argNumber); | |
| } | |
| Map<String, String> map = listArgs; | |
| if (map != null) { | |
| buf.append(",list"); | |
| appendArgs(buf, map, quote); | |
| } | |
| if (format != null || subFormat != null) { | |
| buf.append(','); | |
| } | |
| if (format != null) { | |
| buf.append(quoteMessageFormatChars(format, quote)); | |
| appendArgs(buf, formatArgs, quote); | |
| } | |
| if (subFormat != null) { | |
| buf.append(','); | |
| buf.append(subFormat); | |
| } | |
| buf.append('}'); | |
| return buf.toString(); | |
| } | |
| /** | |
| * @param buf | |
| * @param map | |
| * @param quote | |
| */ | |
| private void appendArgs( | |
| StringBuilder buf, Map<String, String> map, boolean quote) { | |
| char prefix = ':'; | |
| for (Map.Entry<String, String> entry : map.entrySet()) { | |
| String key = entry.getKey(); | |
| if (quote) { | |
| key = quoteMessageFormatChars(key); | |
| } | |
| buf.append(prefix).append(key); | |
| String value = entry.getValue(); | |
| if (value != null) { | |
| if (quote) { | |
| value = quoteMessageFormatChars(value); | |
| } | |
| buf.append('=').append(value); | |
| } | |
| prefix = ','; | |
| } | |
| } | |
| } | |
| /** | |
| * Default implementation of TemplateChunkVisitor -- other implementations | |
| * should extend this if possible to avoid breakage when new TemplateChunk | |
| * subtypes are added. | |
| */ | |
| public static class DefaultTemplateChunkVisitor | |
| implements TemplateChunkVisitor { | |
| public void visit(ArgumentChunk argChunk) throws UnableToCompleteException { | |
| } | |
| public void visit(StaticArgChunk staticArgChunk) | |
| throws UnableToCompleteException { | |
| } | |
| public void visit(StringChunk stringChunk) | |
| throws UnableToCompleteException { | |
| } | |
| } | |
| /** | |
| * Represents a static argument, which is used to remove markup from | |
| * translator view without having to supply it at each callsite. | |
| */ | |
| public static class StaticArgChunk extends TemplateChunk { | |
| private final String argName; | |
| private final String replacement; | |
| public StaticArgChunk(String argName, String replacement) { | |
| this.argName = argName; | |
| this.replacement = replacement; | |
| } | |
| @Override | |
| public void accept(TemplateChunkVisitor visitor) | |
| throws UnableToCompleteException { | |
| visitor.visit(this); | |
| } | |
| public String getArgName() { | |
| return argName; | |
| } | |
| public String getReplacement() { | |
| return replacement; | |
| } | |
| @Override | |
| protected String getStringValue(boolean quoted) { | |
| StringBuilder buf = new StringBuilder(); | |
| buf.append('{').append(argName); | |
| if (replacement != null) { | |
| buf.append(',').append(quoteMessageFormatChars(replacement, quoted)); | |
| } | |
| buf.append('}'); | |
| return buf.toString(); | |
| } | |
| } | |
| /** | |
| * Represents a literal string portion of a template string. | |
| */ | |
| public static class StringChunk extends TemplateChunk { | |
| private StringBuilder buf = new StringBuilder(); | |
| public StringChunk() { | |
| } | |
| public StringChunk(String str) { | |
| buf.append(str); | |
| } | |
| @Override | |
| public void accept(TemplateChunkVisitor visitor) | |
| throws UnableToCompleteException { | |
| visitor.visit(this); | |
| } | |
| public void append(String str) { | |
| buf.append(str); | |
| } | |
| @Override | |
| public boolean isLiteral() { | |
| return true; | |
| } | |
| @Override | |
| public String toString() { | |
| return "StringLiteral: \"" + buf.toString() + "\""; | |
| } | |
| @Override | |
| protected String getStringValue(boolean quote) { | |
| String str = buf.toString(); | |
| return quoteMessageFormatChars(str, quote); | |
| } | |
| } | |
| /** | |
| * Represents a parsed chunk of a template. | |
| */ | |
| public abstract static class TemplateChunk { | |
| /** | |
| * Quote a string in the MessageFormat-style. | |
| * | |
| * @param str string to quote, must not be null | |
| * @return quoted string | |
| */ | |
| protected static String quoteMessageFormatChars(String str) { | |
| str = str.replace("'", "''"); | |
| str = str.replace("{", "'{'"); | |
| str = str.replace("}", "'}'"); | |
| return str; | |
| } | |
| /** | |
| * Possibly quote a string in the MessageFormat-style. | |
| * | |
| * @param str | |
| * @return quoted string | |
| */ | |
| protected static String quoteMessageFormatChars(String str, boolean quote) { | |
| return quote ? quoteMessageFormatChars(str) : str; | |
| } | |
| public abstract void accept(TemplateChunkVisitor visitor) | |
| throws UnableToCompleteException; | |
| /** | |
| * Returns the string as this chunk would be represented in a MessageFormat | |
| * template, with any required quoting such that reparsing this value would | |
| * produce an equivalent (note, not identical) parse. | |
| * | |
| * Note that the default implementation may not be sufficient for all | |
| * subclasses. | |
| */ | |
| public String getAsMessageFormatString() { | |
| return getStringValue(true); | |
| } | |
| /** | |
| * Returns the string as this chunk would be represented in a MessageFormat | |
| * template, with any quoting removed. Note that this is distinct from | |
| * toString in that the latter is intend for human consumption. | |
| */ | |
| public String getString() { | |
| return getStringValue(false); | |
| } | |
| public boolean isLiteral() { | |
| return false; | |
| } | |
| /** | |
| * Returns the optionally quoted string value of this chunk as represented | |
| * in a MessgeFormat string. | |
| * | |
| * @param quote true if the result should be quoted | |
| * @return optionally quoted MessageFormat string | |
| */ | |
| protected abstract String getStringValue(boolean quote); | |
| } | |
| /** | |
| * Visitor for template chunks. | |
| */ | |
| public interface TemplateChunkVisitor { | |
| void visit(ArgumentChunk argChunk) throws UnableToCompleteException; | |
| void visit(StaticArgChunk staticArgChunk) throws UnableToCompleteException; | |
| void visit(StringChunk stringChunk) throws UnableToCompleteException; | |
| } | |
| /** | |
| * Generate a MessageFormat-style string representing the supplied components, | |
| * properly quoting any special characters in string literal portions. | |
| * | |
| * Note that additional quoting may be required depending on how it will be | |
| * used, such as backslash-escaping double quotes if it will be used in a | |
| * generated string constant. | |
| * | |
| * @param parts list of TemplateChunks to assemble | |
| * @return assembled/quoted string | |
| */ | |
| public static String assemble(Iterable<TemplateChunk> parts) { | |
| final StringBuilder buf = new StringBuilder(); | |
| for (TemplateChunk part : parts) { | |
| buf.append(part.getAsMessageFormatString()); | |
| } | |
| return buf.toString(); | |
| } | |
| public static List<TemplateChunk> parse(String template) | |
| throws ParseException { | |
| int curPos = 0; | |
| boolean inQuote = false; | |
| int templateLen = template.length(); | |
| ArrayList<TemplateChunk> chunks = new ArrayList<TemplateChunk>(); | |
| TemplateChunk curChunk = null; | |
| while (curPos < templateLen) { | |
| char ch = template.charAt(curPos++); | |
| switch (ch) { | |
| case '\'': | |
| if (curPos < templateLen && template.charAt(curPos) == '\'') { | |
| curChunk = appendString(chunks, curChunk, "'"); | |
| ++curPos; | |
| break; | |
| } | |
| inQuote = !inQuote; | |
| break; | |
| case '{': | |
| if (inQuote) { | |
| curChunk = appendString(chunks, curChunk, "{"); | |
| break; | |
| } | |
| StringBuilder argBuf = new StringBuilder(); | |
| boolean argQuote = false; | |
| while (curPos < templateLen) { | |
| ch = template.charAt(curPos++); | |
| if (ch == '\'') { | |
| if (curPos < templateLen && template.charAt(curPos) == '\'') { | |
| argBuf.append(ch); | |
| ++curPos; | |
| } else { | |
| argQuote = !argQuote; | |
| } | |
| } else { | |
| if (!argQuote && ch == '}') { | |
| break; | |
| } | |
| argBuf.append(ch); | |
| } | |
| } | |
| if (ch != '}') { | |
| throw new ParseException( | |
| "Invalid message format - { not start of valid argument" | |
| + template, curPos); | |
| } | |
| if (curChunk != null) { | |
| chunks.add(curChunk); | |
| } | |
| String arg = argBuf.toString(); | |
| int firstComma = arg.indexOf(','); | |
| String format = null; | |
| if (firstComma > 0) { | |
| format = arg.substring(firstComma + 1); | |
| arg = arg.substring(0, firstComma); | |
| } | |
| if (!"#".equals(arg) && !Character.isDigit(arg.charAt(0))) { | |
| // static argument | |
| chunks.add(new StaticArgChunk(arg, format)); | |
| } else { | |
| int argNumber = -1; | |
| if (!"#".equals(arg)) { | |
| argNumber = Integer.valueOf(arg); | |
| } | |
| Map<String, String> formatArgs = new HashMap<String, String>(); | |
| Map<String, String> listArgs = null; | |
| String subFormat = null; | |
| if (format != null) { | |
| int comma = format.indexOf(','); | |
| if (comma >= 0) { | |
| subFormat = format.substring(comma + 1); | |
| format = format.substring(0, comma); | |
| } | |
| format = parseFormatArgs(format, formatArgs); | |
| if ("list".equals(format)) { | |
| listArgs = formatArgs; | |
| formatArgs = new HashMap<String, String>(); | |
| format = subFormat; | |
| subFormat = null; | |
| if (format != null) { | |
| comma = format.indexOf(','); | |
| if (comma >= 0) { | |
| subFormat = format.substring(comma + 1); | |
| format = format.substring(0, comma); | |
| } | |
| format = parseFormatArgs(format, formatArgs); | |
| } | |
| } | |
| } | |
| chunks.add(new ArgumentChunk( | |
| argNumber, listArgs, format, formatArgs, subFormat)); | |
| } | |
| curChunk = null; | |
| break; | |
| case '\n': | |
| curChunk = appendString(chunks, curChunk, "\\n"); | |
| break; | |
| case '\r': | |
| curChunk = appendString(chunks, curChunk, "\\r"); | |
| break; | |
| case '\\': | |
| curChunk = appendString(chunks, curChunk, "\\\\"); | |
| break; | |
| case '"': | |
| curChunk = appendString(chunks, curChunk, "\\\""); | |
| break; | |
| default: | |
| curChunk = appendString(chunks, curChunk, String.valueOf(ch)); | |
| break; | |
| } | |
| } | |
| if (inQuote) { | |
| throw new ParseException( | |
| "Unterminated single quote: " + template, template.length()); | |
| } | |
| if (curChunk != null) { | |
| chunks.add(curChunk); | |
| } | |
| return chunks; | |
| } | |
| private static TemplateChunk appendString( | |
| ArrayList<TemplateChunk> chunks, TemplateChunk curChunk, String string) { | |
| if (curChunk != null && !curChunk.isLiteral()) { | |
| chunks.add(curChunk); | |
| curChunk = null; | |
| } | |
| if (curChunk == null) { | |
| curChunk = new StringChunk(string); | |
| } else { | |
| ((StringChunk) curChunk).append(string); | |
| } | |
| return curChunk; | |
| } | |
| /** | |
| * Parse any arguments appended to a format. The syntax is: | |
| * format[:tag[=value][:tag[=value]]... for example: "date:tz=EST:showoffset" | |
| * | |
| * @param format format value to parse | |
| * @param formatArgs map to add tag/value pairs to | |
| * @return format portion of supplied string | |
| */ | |
| private static String parseFormatArgs( | |
| String format, Map<String, String> formatArgs) { | |
| int colon = format.indexOf(':'); | |
| if (colon >= 0) { | |
| for (String tagValue : format.substring(colon + 1).split(":")) { | |
| int equals = tagValue.indexOf('='); | |
| String value = ""; | |
| if (equals >= 0) { | |
| value = tagValue.substring(equals + 1).trim(); | |
| tagValue = tagValue.substring(0, equals); | |
| } | |
| formatArgs.put(tagValue.trim(), value); | |
| } | |
| format = format.substring(0, colon); | |
| } | |
| return format; | |
| } | |
| } |