camel-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From davscl...@apache.org
Subject [3/6] camel git commit: Rename catalog to runtimecatalog to avoid clash with same package name in camel-catalog.
Date Fri, 14 Apr 2017 10:52:57 GMT
http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaHelper.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaHelper.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaHelper.java
new file mode 100644
index 0000000..1e69269
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaHelper.java
@@ -0,0 +1,424 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class JSonSchemaHelper {
+
+    // 0 = text, 1 = enum, 2 = boolean, 3 = integer or number
+    private static final Pattern PATTERN = Pattern.compile("\"(.+?)\"|\\[(.+)\\]|(true|false)|(-?\\d+\\.?\\d*)");
+    private static final String QUOT = """;
+
+    private JSonSchemaHelper() {
+    }
+
+    /**
+     * Parses the json schema to split it into a list or rows, where each row contains key value pairs with the metadata
+     *
+     * @param group the group to parse from such as <tt>component</tt>, <tt>componentProperties</tt>, or <tt>properties</tt>.
+     * @param json the json
+     * @return a list of all the rows, where each row is a set of key value pairs with metadata
+     */
+    public static List<Map<String, String>> parseJsonSchema(String group, String json, boolean parseProperties) {
+        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();
+        if (json == null) {
+            return answer;
+        }
+
+        boolean found = false;
+
+        // parse line by line
+        String[] lines = json.split("\n");
+        for (String line : lines) {
+            // we need to find the group first
+            if (!found) {
+                String s = line.trim();
+                found = s.startsWith("\"" + group + "\":") && s.endsWith("{");
+                continue;
+            }
+
+            // we should stop when we end the group
+            if (line.equals("  },") || line.equals("  }")) {
+                break;
+            }
+
+            // need to safe encode \" so we can parse the line
+            line = line.replaceAll("\"\\\\\"\"", '"' + QUOT + '"');
+
+            Map<String, String> row = new LinkedHashMap<String, String>();
+            Matcher matcher = PATTERN.matcher(line);
+
+            String key;
+            if (parseProperties) {
+                // when parsing properties the first key is given as name, so the first parsed token is the value of the name
+                key = "name";
+            } else {
+                key = null;
+            }
+            while (matcher.find()) {
+                if (key == null) {
+                    key = matcher.group(1);
+                } else {
+                    String value = matcher.group(1);
+                    if (value != null) {
+                        // its text based
+                        value = value.trim();
+                        // decode
+                        value = value.replaceAll(QUOT, "\"");
+                        value = decodeJson(value);
+                    }
+                    if (value == null) {
+                        // not text then its maybe an enum?
+                        value = matcher.group(2);
+                        if (value != null) {
+                            // its an enum so strip out " and trim spaces after comma
+                            value = value.replaceAll("\"", "");
+                            value = value.replaceAll(", ", ",");
+                            value = value.trim();
+                        }
+                    }
+                    if (value == null) {
+                        // not text then its maybe a boolean?
+                        value = matcher.group(3);
+                    }
+                    if (value == null) {
+                        // not text then its maybe a integer?
+                        value = matcher.group(4);
+                    }
+                    if (value != null) {
+                        row.put(key, value);
+                    }
+                    // reset
+                    key = null;
+                }
+            }
+            if (!row.isEmpty()) {
+                answer.add(row);
+            }
+        }
+
+        return answer;
+    }
+
+    private static String decodeJson(String value) {
+        // json encodes a \ as \\ so we need to decode from \\ back to \
+        if ("\\\\".equals(value)) {
+            value = "\\";
+        }
+        return value;
+    }
+
+    public static boolean isComponentLenientProperties(List<Map<String, String>> rows) {
+        for (Map<String, String> row : rows) {
+            if (row.containsKey("lenientProperties")) {
+                return "true".equals(row.get("lenientProperties"));
+            }
+        }
+        return false;
+    }
+
+    public static boolean isComponentConsumerOnly(List<Map<String, String>> rows) {
+        for (Map<String, String> row : rows) {
+            if (row.containsKey("consumerOnly")) {
+                return "true".equals(row.get("consumerOnly"));
+            }
+        }
+        return false;
+    }
+
+    public static boolean isComponentProducerOnly(List<Map<String, String>> rows) {
+        for (Map<String, String> row : rows) {
+            if (row.containsKey("producerOnly")) {
+                return "true".equals(row.get("producerOnly"));
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyConsumerOnly(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String labels = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("label")) {
+                labels = row.get("label");
+            }
+            if (found) {
+                return labels != null && labels.contains("consumer");
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyProducerOnly(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String labels = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("label")) {
+                labels = row.get("label");
+            }
+            if (found) {
+                return labels != null && labels.contains("producer");
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyRequired(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            boolean required = false;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("required")) {
+                required = "true".equals(row.get("required"));
+            }
+            if (found) {
+                return required;
+            }
+        }
+        return false;
+    }
+
+    public static String getPropertyKind(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String kind = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("kind")) {
+                kind = row.get("kind");
+            }
+            if (found) {
+                return kind;
+            }
+        }
+        return null;
+    }
+
+    public static boolean isPropertyBoolean(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String type = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("type")) {
+                type = row.get("type");
+            }
+            if (found) {
+                return "boolean".equals(type);
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyInteger(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String type = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("type")) {
+                type = row.get("type");
+            }
+            if (found) {
+                return "integer".equals(type);
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyNumber(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String type = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("type")) {
+                type = row.get("type");
+            }
+            if (found) {
+                return "number".equals(type);
+            }
+        }
+        return false;
+    }
+
+    public static boolean isPropertyObject(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String type = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("type")) {
+                type = row.get("type");
+            }
+            if (found) {
+                return "object".equals(type);
+            }
+        }
+        return false;
+    }
+
+    public static String getPropertyDefaultValue(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String defaultValue = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("defaultValue")) {
+                defaultValue = row.get("defaultValue");
+            }
+            if (found) {
+                return defaultValue;
+            }
+        }
+        return null;
+    }
+
+    public static String stripOptionalPrefixFromName(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String optionalPrefix = null;
+            boolean found = false;
+            if (row.containsKey("optionalPrefix")) {
+                optionalPrefix = row.get("optionalPrefix");
+            }
+            if (row.containsKey("name")) {
+                if (optionalPrefix != null && name.startsWith(optionalPrefix)) {
+                    name = name.substring(optionalPrefix.length());
+                    // try again
+                    return stripOptionalPrefixFromName(rows, name);
+                } else {
+                    found = name.equals(row.get("name"));
+                }
+            }
+            if (found) {
+                return name;
+            }
+        }
+        return name;
+    }
+
+    public static String getPropertyEnum(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String enums = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("enum")) {
+                enums = row.get("enum");
+            }
+            if (found) {
+                return enums;
+            }
+        }
+        return null;
+    }
+
+    public static String getPropertyPrefix(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String prefix = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("prefix")) {
+                prefix = row.get("prefix");
+            }
+            if (found) {
+                return prefix;
+            }
+        }
+        return null;
+    }
+
+    public static boolean isPropertyMultiValue(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            boolean multiValue = false;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                found = name.equals(row.get("name"));
+            }
+            if (row.containsKey("multiValue")) {
+                multiValue = "true".equals(row.get("multiValue"));
+            }
+            if (found) {
+                return multiValue;
+            }
+        }
+        return false;
+    }
+
+    public static String getPropertyNameFromNameWithPrefix(List<Map<String, String>> rows, String name) {
+        for (Map<String, String> row : rows) {
+            String propertyName = null;
+            boolean found = false;
+            if (row.containsKey("name")) {
+                propertyName = row.get("name");
+            }
+            if (row.containsKey("prefix")) {
+                String preifx = row.get("prefix");
+                found = name.startsWith(preifx);
+            }
+            if (found) {
+                return propertyName;
+            }
+        }
+        return null;
+    }
+
+    public static Map<String, String> getRow(List<Map<String, String>> rows, String key) {
+        for (Map<String, String> row : rows) {
+            if (key.equals(row.get("name"))) {
+                return row;
+            }
+        }
+        return null;
+    }
+
+    public static Set<String> getNames(List<Map<String, String>> rows) {
+        Set<String> answer = new LinkedHashSet<String>();
+        for (Map<String, String> row : rows) {
+            if (row.containsKey("name")) {
+                answer.add(row.get("name"));
+            }
+        }
+        return answer;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaResolver.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaResolver.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaResolver.java
new file mode 100644
index 0000000..dbd6f45
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/JSonSchemaResolver.java
@@ -0,0 +1,64 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+/**
+ * Pluggable resolver to load JSon schema files for components, data formats, languages etc.
+ */
+public interface JSonSchemaResolver {
+
+    /**
+     * Returns the component information as JSon format.
+     *
+     * @param name the component name
+     * @return component details in JSon
+     */
+    String getComponentJSonSchema(String name);
+
+    /**
+     * Returns the data format information as JSon format.
+     *
+     * @param name the data format name
+     * @return data format details in JSon
+     */
+    String getDataFormatJSonSchema(String name);
+
+    /**
+     * Returns the language information as JSon format.
+     *
+     * @param name the language name
+     * @return language details in JSon
+     */
+    String getLanguageJSonSchema(String name);
+
+    /**
+     * Returns the other (miscellaneous) information as JSon format.
+     *
+     * @param name the other (miscellaneous) name
+     * @return other (miscellaneous) details in JSon
+     */
+    String getOtherJSonSchema(String name);
+
+    /**
+     * Returns the model information as JSon format.
+     *
+     * @param name the model name
+     * @return model details in JSon
+     */
+    String getModelJSonSchema(String name);
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/LanguageValidationResult.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/LanguageValidationResult.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/LanguageValidationResult.java
new file mode 100644
index 0000000..dbb5525
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/LanguageValidationResult.java
@@ -0,0 +1,65 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.io.Serializable;
+
+/**
+ * Validation result of parsing a language expression or predicate
+ */
+public class LanguageValidationResult implements Serializable {
+    private final String text;
+    private String error;
+    private String shortError;
+    private int index;
+
+    public LanguageValidationResult(String text) {
+        this.text = text;
+    }
+
+    public String getText() {
+        return text;
+    }
+
+    public boolean isSuccess() {
+        return error == null;
+    }
+
+    public void setError(String error) {
+        this.error = error;
+    }
+
+    public String getError() {
+        return error;
+    }
+
+    public String getShortError() {
+        return shortError;
+    }
+
+    public void setShortError(String shortError) {
+        this.shortError = shortError;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public void setIndex(int index) {
+        this.index = index;
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/RuntimeCamelCatalog.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/RuntimeCamelCatalog.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/RuntimeCamelCatalog.java
new file mode 100644
index 0000000..86c4b53
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/RuntimeCamelCatalog.java
@@ -0,0 +1,234 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.net.URISyntaxException;
+import java.util.Map;
+
+import org.apache.camel.StaticService;
+
+/**
+ * Runtime based CamelCatalog which are included in camel-core that can provided limit CamelCatalog capabilities
+ */
+public interface RuntimeCamelCatalog extends StaticService {
+
+    /**
+     * Returns the component information as JSon format.
+     *
+     * @param name the component name
+     * @return component details in JSon
+     */
+    String componentJSonSchema(String name);
+
+    /**
+     * Returns the data format information as JSon format.
+     *
+     * @param name the data format name
+     * @return data format details in JSon
+     */
+    String dataFormatJSonSchema(String name);
+
+    /**
+     * Returns the language information as JSon format.
+     *
+     * @param name the language name
+     * @return language details in JSon
+     */
+    String languageJSonSchema(String name);
+
+    /**
+     * Returns the model information as JSon format.
+     *
+     * @param name the model name
+     * @return model details in JSon
+     */
+    String modelJSonSchema(String name);
+
+    /**
+     * Parses the endpoint uri and constructs a key/value properties of each option
+     *
+     * @param uri  the endpoint uri
+     * @return properties as key value pairs of each endpoint option
+     */
+    Map<String, String> endpointProperties(String uri) throws URISyntaxException;
+
+    /**
+     * Parses the endpoint uri and constructs a key/value properties of only the lenient properties (eg custom options)
+     * <p/>
+     * For example using the HTTP components to provide query parameters in the endpoint uri.
+     *
+     * @param uri  the endpoint uri
+     * @return properties as key value pairs of each lenient properties
+     */
+    Map<String, String> endpointLenientProperties(String uri) throws URISyntaxException;
+
+    /**
+     * Validates the pattern whether its a valid time pattern.
+     *
+     * @param pattern  the pattern such as 5000, 5s, 5sec, 4min, 4m30s, 1h, etc.
+     * @return <tt>true</tt> if valid, <tt>false</tt> if invalid
+     */
+    boolean validateTimePattern(String pattern);
+
+    /**
+     * Validates the properties for the given scheme against component and endpoint
+     *
+     * @param scheme  the endpoint scheme
+     * @param properties  the endpoint properties
+     * @return validation result
+     */
+    EndpointValidationResult validateProperties(String scheme, Map<String, String> properties);
+
+    /**
+     * Parses and validates the endpoint uri and constructs a key/value properties of each option.
+     *
+     * @param uri  the endpoint uri
+     * @return validation result
+     */
+    EndpointValidationResult validateEndpointProperties(String uri);
+
+    /**
+     * Parses and validates the endpoint uri and constructs a key/value properties of each option.
+     * <p/>
+     * The option ignoreLenientProperties can be used to ignore components that uses lenient properties.
+     * When this is true, then the uri validation is stricter but would fail on properties that are not part of the component
+     * but in the uri because of using lenient properties.
+     * For example using the HTTP components to provide query parameters in the endpoint uri.
+     *
+     * @param uri  the endpoint uri
+     * @param ignoreLenientProperties  whether to ignore components that uses lenient properties.
+     * @return validation result
+     */
+    EndpointValidationResult validateEndpointProperties(String uri, boolean ignoreLenientProperties);
+
+    /**
+     * Parses and validates the endpoint uri and constructs a key/value properties of each option.
+     * <p/>
+     * The option ignoreLenientProperties can be used to ignore components that uses lenient properties.
+     * When this is true, then the uri validation is stricter but would fail on properties that are not part of the component
+     * but in the uri because of using lenient properties.
+     * For example using the HTTP components to provide query parameters in the endpoint uri.
+     *
+     * @param uri  the endpoint uri
+     * @param ignoreLenientProperties  whether to ignore components that uses lenient properties.
+     * @param consumerOnly whether the endpoint is only used as a consumer
+     * @param producerOnly whether the endpoint is only used as a producer
+     * @return validation result
+     */
+    EndpointValidationResult validateEndpointProperties(String uri, boolean ignoreLenientProperties, boolean consumerOnly, boolean producerOnly);
+
+    /**
+     * Parses and validates the simple expression.
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> on the classpath
+     *
+     * @param simple  the simple expression
+     * @return validation result
+     * @deprecated use {@link #validateSimpleExpression(ClassLoader, String)}
+     */
+    @Deprecated
+    SimpleValidationResult validateSimpleExpression(String simple);
+
+    /**
+     * Parses and validates the simple expression.
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> on the classpath
+     *
+     * @param classLoader a custom classloader to use for loading the language from the classpath, or <tt>null</tt> for using default classloader
+     * @param simple  the simple expression
+     * @return validation result
+     */
+    SimpleValidationResult validateSimpleExpression(ClassLoader classLoader, String simple);
+
+    /**
+     * Parses and validates the simple predicate
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> on the classpath
+     *
+     * @param simple  the simple predicate
+     * @return validation result
+     * @deprecated use {@link #validateSimplePredicate(ClassLoader, String)}
+     */
+    @Deprecated
+    SimpleValidationResult validateSimplePredicate(String simple);
+
+    /**
+     * Parses and validates the simple predicate
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> on the classpath
+     *
+     * @param classLoader a custom classloader to use for loading the language from the classpath, or <tt>null</tt> for using default classloader
+     * @param simple  the simple predicate
+     * @return validation result
+     */
+    SimpleValidationResult validateSimplePredicate(ClassLoader classLoader, String simple);
+
+    /**
+     * Parses and validates the language as a predicate
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> and the language dependencies on the classpath
+     *
+     * @param classLoader a custom classloader to use for loading the language from the classpath, or <tt>null</tt> for using default classloader
+     * @param language the name of the language
+     * @param text  the predicate text
+     * @return validation result
+     */
+    LanguageValidationResult validateLanguagePredicate(ClassLoader classLoader, String language, String text);
+
+    /**
+     * Parses and validates the language as an expression
+     * <p/>
+     * <b>Important:</b> This requires having <tt>camel-core</tt> and the language dependencies on the classpath
+     *
+     * @param classLoader a custom classloader to use for loading the language from the classpath, or <tt>null</tt> for using default classloader
+     * @param language the name of the language
+     * @param text  the expression text
+     * @return validation result
+     */
+    LanguageValidationResult validateLanguageExpression(ClassLoader classLoader, String language, String text);
+
+    /**
+     * Returns the component name from the given endpoint uri
+     *
+     * @param uri  the endpoint uri
+     * @return the component name (aka scheme), or <tt>null</tt> if not possible to determine
+     */
+    String endpointComponentName(String uri);
+
+    /**
+     * Creates an endpoint uri in Java style from the information from the properties
+     *
+     * @param scheme the endpoint schema
+     * @param properties the properties as key value pairs
+     * @param encode whether to URL encode the returned uri or not
+     * @return the constructed endpoint uri
+     * @throws java.net.URISyntaxException is thrown if there is encoding error
+     */
+    String asEndpointUri(String scheme, Map<String, String> properties, boolean encode) throws URISyntaxException;
+
+    /**
+     * Creates an endpoint uri in XML style (eg escape & as &ampl;) from the information from the properties
+     *
+     * @param scheme the endpoint schema
+     * @param properties the properties as key value pairs
+     * @param encode whether to URL encode the returned uri or not
+     * @return the constructed endpoint uri
+     * @throws java.net.URISyntaxException is thrown if there is encoding error
+     */
+    String asEndpointUriXml(String scheme, Map<String, String> properties, boolean encode) throws URISyntaxException;
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/SimpleValidationResult.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/SimpleValidationResult.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/SimpleValidationResult.java
new file mode 100644
index 0000000..1b8dd0e
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/SimpleValidationResult.java
@@ -0,0 +1,32 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+/**
+ * To be backwards compatible, but favor using {@link LanguageValidationResult} instead.
+ */
+public class SimpleValidationResult extends LanguageValidationResult {
+
+    public SimpleValidationResult(String text) {
+        super(text);
+    }
+
+    public String getSimple() {
+        return getText();
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/SuggestionStrategy.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/SuggestionStrategy.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/SuggestionStrategy.java
new file mode 100644
index 0000000..e29afc6
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/SuggestionStrategy.java
@@ -0,0 +1,34 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.util.Set;
+
+/**
+ * Strategy to provide suggestions for unknown endpoint options
+ */
+public interface SuggestionStrategy {
+
+    /**
+     * Provides a list of valid option names for a did you mean function.
+     *
+     * @param names         valid names
+     * @param unknownOption unknown option name
+     * @return a list of suggested names (did you mean)
+     */
+    String[] suggestEndpointOptions(Set<String> names, String unknownOption);
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/TimePatternConverter.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/TimePatternConverter.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/TimePatternConverter.java
new file mode 100644
index 0000000..ed5585c
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/TimePatternConverter.java
@@ -0,0 +1,120 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * This class is a copy from camel-core so we can use it independent to validate uris with time patterns
+ */
+public final class TimePatternConverter {
+    private static final Pattern NUMBERS_ONLY_STRING_PATTERN = Pattern.compile("^[-]?(\\d)+$", Pattern.CASE_INSENSITIVE);
+    private static final Pattern HOUR_REGEX_PATTERN = Pattern.compile("((\\d)*(\\d))h(our(s)?)?", Pattern.CASE_INSENSITIVE);
+    private static final Pattern MINUTES_REGEX_PATTERN = Pattern.compile("((\\d)*(\\d))m(in(ute(s)?)?)?", Pattern.CASE_INSENSITIVE);
+    private static final Pattern SECONDS_REGEX_PATTERN = Pattern.compile("((\\d)*(\\d))s(ec(ond)?(s)?)?", Pattern.CASE_INSENSITIVE);
+
+    /**
+     * Utility classes should not have a public constructor.
+     */
+    private TimePatternConverter() {
+    }
+
+    public static long toMilliSeconds(String source) throws IllegalArgumentException {
+        long milliseconds = 0;
+        boolean foundFlag = false;
+
+        checkCorrectnessOfPattern(source);
+        Matcher matcher;
+
+        matcher = createMatcher(NUMBERS_ONLY_STRING_PATTERN, source);
+        if (matcher.find()) {
+            // Note: This will also be used for regular numeric strings.
+            //       This String -> long converter will be used for all strings.
+            milliseconds = Long.valueOf(source);
+        } else {
+            matcher = createMatcher(HOUR_REGEX_PATTERN, source);
+            if (matcher.find()) {
+                milliseconds = milliseconds + (3600000 * Long.valueOf(matcher.group(1)));
+                foundFlag = true;
+            }
+
+            matcher = createMatcher(MINUTES_REGEX_PATTERN, source);
+            if (matcher.find()) {
+                long minutes = Long.valueOf(matcher.group(1));
+                if ((minutes > 59) && foundFlag) {
+                    throw new IllegalArgumentException("Minutes should contain a valid value between 0 and 59: " + source);
+                }
+                foundFlag = true;
+                milliseconds = milliseconds + (60000 * minutes);
+            }
+
+            matcher = createMatcher(SECONDS_REGEX_PATTERN, source);
+            if (matcher.find()) {
+                long seconds = Long.valueOf(matcher.group(1));
+                if ((seconds > 59) && foundFlag) {
+                    throw new IllegalArgumentException("Seconds should contain a valid value between 0 and 59: " + source);
+                }
+                foundFlag = true;
+                milliseconds = milliseconds + (1000 * seconds);
+            }
+
+            // No pattern matched... initiating fallback check and conversion (if required).
+            // The source at this point may contain illegal values or special characters
+            if (!foundFlag) {
+                milliseconds = Long.valueOf(source);
+            }
+        }
+
+        return milliseconds;
+    }
+
+    private static void checkCorrectnessOfPattern(String source) {
+        //replace only numbers once
+        Matcher matcher = createMatcher(NUMBERS_ONLY_STRING_PATTERN, source);
+        String replaceSource = matcher.replaceFirst("");
+
+        //replace hour string once
+        matcher = createMatcher(HOUR_REGEX_PATTERN, replaceSource);
+        if (matcher.find() && matcher.find()) {
+            throw new IllegalArgumentException("Hours should not be specified more then once: " + source);
+        }
+        replaceSource = matcher.replaceFirst("");
+
+        //replace minutes once
+        matcher = createMatcher(MINUTES_REGEX_PATTERN, replaceSource);
+        if (matcher.find() && matcher.find()) {
+            throw new IllegalArgumentException("Minutes should not be specified more then once: " + source);
+        }
+        replaceSource = matcher.replaceFirst("");
+
+        //replace seconds once
+        matcher = createMatcher(SECONDS_REGEX_PATTERN, replaceSource);
+        if (matcher.find() && matcher.find()) {
+            throw new IllegalArgumentException("Seconds should not be specified more then once: " + source);
+        }
+        replaceSource = matcher.replaceFirst("");
+
+        if (replaceSource.length() > 0) {
+            throw new IllegalArgumentException("Illegal characters: " + source);
+        }
+    }
+
+    private static Matcher createMatcher(Pattern pattern, String source) {
+        return pattern.matcher(source);
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/URISupport.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/URISupport.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/URISupport.java
new file mode 100644
index 0000000..8389590
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/URISupport.java
@@ -0,0 +1,392 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Copied from org.apache.camel.util.URISupport
+ */
+public final class URISupport {
+
+    public static final String RAW_TOKEN_START = "RAW(";
+    public static final String RAW_TOKEN_END = ")";
+
+    private static final String CHARSET = "UTF-8";
+
+    private URISupport() {
+        // Helper class
+    }
+
+    /**
+     * Normalizes the URI so unsafe characters is encoded
+     *
+     * @param uri the input uri
+     * @return as URI instance
+     * @throws URISyntaxException is thrown if syntax error in the input uri
+     */
+    public static URI normalizeUri(String uri) throws URISyntaxException {
+        return new URI(UnsafeUriCharactersEncoder.encode(uri, true));
+    }
+
+    public static Map<String, Object> extractProperties(Map<String, Object> properties, String optionPrefix) {
+        Map<String, Object> rc = new LinkedHashMap<String, Object>(properties.size());
+
+        for (Iterator<Map.Entry<String, Object>> it = properties.entrySet().iterator(); it.hasNext();) {
+            Map.Entry<String, Object> entry = it.next();
+            String name = entry.getKey();
+            if (name.startsWith(optionPrefix)) {
+                Object value = properties.get(name);
+                name = name.substring(optionPrefix.length());
+                rc.put(name, value);
+                it.remove();
+            }
+        }
+
+        return rc;
+    }
+
+    /**
+     * Strips the query parameters from the uri
+     *
+     * @param uri  the uri
+     * @return the uri without the query parameter
+     */
+    public static String stripQuery(String uri) {
+        int idx = uri.indexOf('?');
+        if (idx > -1) {
+            uri = uri.substring(0, idx);
+        }
+        return uri;
+    }
+
+    /**
+     * Parses the query parameters of the uri (eg the query part).
+     *
+     * @param uri the uri
+     * @return the parameters, or an empty map if no parameters (eg never null)
+     * @throws URISyntaxException is thrown if uri has invalid syntax.
+     */
+    public static Map<String, Object> parseParameters(URI uri) throws URISyntaxException {
+        String query = uri.getQuery();
+        if (query == null) {
+            String schemeSpecificPart = uri.getSchemeSpecificPart();
+            int idx = schemeSpecificPart.indexOf('?');
+            if (idx < 0) {
+                // return an empty map
+                return new LinkedHashMap<String, Object>(0);
+            } else {
+                query = schemeSpecificPart.substring(idx + 1);
+            }
+        } else {
+            query = stripPrefix(query, "?");
+        }
+        return parseQuery(query);
+    }
+
+    /**
+     * Strips the prefix from the value.
+     * <p/>
+     * Returns the value as-is if not starting with the prefix.
+     *
+     * @param value  the value
+     * @param prefix the prefix to remove from value
+     * @return the value without the prefix
+     */
+    public static String stripPrefix(String value, String prefix) {
+        if (value != null && value.startsWith(prefix)) {
+            return value.substring(prefix.length());
+        }
+        return value;
+    }
+
+    /**
+     * Parses the query part of the uri (eg the parameters).
+     * <p/>
+     * The URI parameters will by default be URI encoded. However you can define a parameter
+     * values with the syntax: <tt>key=RAW(value)</tt> which tells Camel to not encode the value,
+     * and use the value as is (eg key=value) and the value has <b>not</b> been encoded.
+     *
+     * @param uri the uri
+     * @return the parameters, or an empty map if no parameters (eg never null)
+     * @throws URISyntaxException is thrown if uri has invalid syntax.
+     * @see #RAW_TOKEN_START
+     * @see #RAW_TOKEN_END
+     */
+    public static Map<String, Object> parseQuery(String uri) throws URISyntaxException {
+        return parseQuery(uri, false);
+    }
+
+    /**
+     * Parses the query part of the uri (eg the parameters).
+     * <p/>
+     * The URI parameters will by default be URI encoded. However you can define a parameter
+     * values with the syntax: <tt>key=RAW(value)</tt> which tells Camel to not encode the value,
+     * and use the value as is (eg key=value) and the value has <b>not</b> been encoded.
+     *
+     * @param uri the uri
+     * @param useRaw whether to force using raw values
+     * @return the parameters, or an empty map if no parameters (eg never null)
+     * @throws URISyntaxException is thrown if uri has invalid syntax.
+     * @see #RAW_TOKEN_START
+     * @see #RAW_TOKEN_END
+     */
+    public static Map<String, Object> parseQuery(String uri, boolean useRaw) throws URISyntaxException {
+        // must check for trailing & as the uri.split("&") will ignore those
+        if (uri != null && uri.endsWith("&")) {
+            throw new URISyntaxException(uri, "Invalid uri syntax: Trailing & marker found. "
+                    + "Check the uri and remove the trailing & marker.");
+        }
+
+        if (isEmpty(uri)) {
+            // return an empty map
+            return new LinkedHashMap<String, Object>(0);
+        }
+
+        // need to parse the uri query parameters manually as we cannot rely on splitting by &,
+        // as & can be used in a parameter value as well.
+
+        try {
+            // use a linked map so the parameters is in the same order
+            Map<String, Object> rc = new LinkedHashMap<String, Object>();
+
+            boolean isKey = true;
+            boolean isValue = false;
+            boolean isRaw = false;
+            StringBuilder key = new StringBuilder();
+            StringBuilder value = new StringBuilder();
+
+            // parse the uri parameters char by char
+            for (int i = 0; i < uri.length(); i++) {
+                // current char
+                char ch = uri.charAt(i);
+                // look ahead of the next char
+                char next;
+                if (i <= uri.length() - 2) {
+                    next = uri.charAt(i + 1);
+                } else {
+                    next = '\u0000';
+                }
+
+                // are we a raw value
+                isRaw = value.toString().startsWith(RAW_TOKEN_START);
+
+                // if we are in raw mode, then we keep adding until we hit the end marker
+                if (isRaw) {
+                    if (isKey) {
+                        key.append(ch);
+                    } else if (isValue) {
+                        value.append(ch);
+                    }
+
+                    // we only end the raw marker if its )& or at the end of the value
+
+                    boolean end = ch == RAW_TOKEN_END.charAt(0) && (next == '&' || next == '\u0000');
+                    if (end) {
+                        // raw value end, so add that as a parameter, and reset flags
+                        addParameter(key.toString(), value.toString(), rc, useRaw || isRaw);
+                        key.setLength(0);
+                        value.setLength(0);
+                        isKey = true;
+                        isValue = false;
+                        isRaw = false;
+                        // skip to next as we are in raw mode and have already added the value
+                        i++;
+                    }
+                    continue;
+                }
+
+                // if its a key and there is a = sign then the key ends and we are in value mode
+                if (isKey && ch == '=') {
+                    isKey = false;
+                    isValue = true;
+                    isRaw = false;
+                    continue;
+                }
+
+                // the & denote parameter is ended
+                if (ch == '&') {
+                    // parameter is ended, as we hit & separator
+                    String aKey = key.toString();
+                    // the key may be a placeholder of options which we then do not know what is
+                    boolean validKey = !aKey.startsWith("{{") && !aKey.endsWith("}}");
+                    if (validKey) {
+                        addParameter(aKey, value.toString(), rc, useRaw || isRaw);
+                    }
+                    key.setLength(0);
+                    value.setLength(0);
+                    isKey = true;
+                    isValue = false;
+                    isRaw = false;
+                    continue;
+                }
+
+                // regular char so add it to the key or value
+                if (isKey) {
+                    key.append(ch);
+                } else if (isValue) {
+                    value.append(ch);
+                }
+            }
+
+            // any left over parameters, then add that
+            if (key.length() > 0) {
+                String aKey = key.toString();
+                // the key may be a placeholder of options which we then do not know what is
+                boolean validKey = !aKey.startsWith("{{") && !aKey.endsWith("}}");
+                if (validKey) {
+                    addParameter(aKey, value.toString(), rc, useRaw || isRaw);
+                }
+            }
+
+            return rc;
+
+        } catch (UnsupportedEncodingException e) {
+            URISyntaxException se = new URISyntaxException(e.toString(), "Invalid encoding");
+            se.initCause(e);
+            throw se;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void addParameter(String name, String value, Map<String, Object> map, boolean isRaw) throws UnsupportedEncodingException {
+        name = URLDecoder.decode(name, CHARSET);
+        if (!isRaw) {
+            // need to replace % with %25
+            value = URLDecoder.decode(value.replaceAll("%", "%25"), CHARSET);
+        }
+
+        // does the key already exist?
+        if (map.containsKey(name)) {
+            // yes it does, so make sure we can support multiple values, but using a list
+            // to hold the multiple values
+            Object existing = map.get(name);
+            List<String> list;
+            if (existing instanceof List) {
+                list = (List<String>) existing;
+            } else {
+                // create a new list to hold the multiple values
+                list = new ArrayList<String>();
+                String s = existing != null ? existing.toString() : null;
+                if (s != null) {
+                    list.add(s);
+                }
+            }
+            list.add(value);
+            map.put(name, list);
+        } else {
+            map.put(name, value);
+        }
+    }
+
+    /**
+     * Assembles a query from the given map.
+     *
+     * @param options  the map with the options (eg key/value pairs)
+     * @param ampersand to use & for Java code, and &amp; for XML
+     * @return a query string with <tt>key1=value&key2=value2&...</tt>, or an empty string if there is no options.
+     * @throws URISyntaxException is thrown if uri has invalid syntax.
+     */
+    public static String createQueryString(Map<String, String> options, String ampersand, boolean encode) throws URISyntaxException {
+        try {
+            if (options.size() > 0) {
+                StringBuilder rc = new StringBuilder();
+                boolean first = true;
+                for (Object o : options.keySet()) {
+                    if (first) {
+                        first = false;
+                    } else {
+                        rc.append(ampersand);
+                    }
+
+                    String key = (String) o;
+                    Object value = options.get(key);
+
+                    // use the value as a String
+                    String s = value != null ? value.toString() : null;
+                    appendQueryStringParameter(key, s, rc, encode);
+                }
+                return rc.toString();
+            } else {
+                return "";
+            }
+        } catch (UnsupportedEncodingException e) {
+            URISyntaxException se = new URISyntaxException(e.toString(), "Invalid encoding");
+            se.initCause(e);
+            throw se;
+        }
+    }
+
+    private static void appendQueryStringParameter(String key, String value, StringBuilder rc, boolean encode) throws UnsupportedEncodingException {
+        if (encode) {
+            rc.append(URLEncoder.encode(key, CHARSET));
+        } else {
+            rc.append(key);
+        }
+        // only append if value is not null
+        if (value != null) {
+            rc.append("=");
+            if (value.startsWith(RAW_TOKEN_START) && value.endsWith(RAW_TOKEN_END)) {
+                // do not encode RAW parameters
+                rc.append(value);
+            } else {
+                if (encode) {
+                    rc.append(URLEncoder.encode(value, CHARSET));
+                } else {
+                    rc.append(value);
+                }
+            }
+        }
+    }
+
+    /**
+     * Tests whether the value is <tt>null</tt> or an empty string.
+     *
+     * @param value  the value, if its a String it will be tested for text length as well
+     * @return true if empty
+     */
+    public static boolean isEmpty(Object value) {
+        return !isNotEmpty(value);
+    }
+
+    /**
+     * Tests whether the value is <b>not</b> <tt>null</tt> or an empty string.
+     *
+     * @param value  the value, if its a String it will be tested for text length as well
+     * @return true if <b>not</b> empty
+     */
+    public static boolean isNotEmpty(Object value) {
+        if (value == null) {
+            return false;
+        } else if (value instanceof String) {
+            String text = (String) value;
+            return text.trim().length() > 0;
+        } else {
+            return true;
+        }
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/UnsafeUriCharactersEncoder.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/UnsafeUriCharactersEncoder.java b/camel-core/src/main/java/org/apache/camel/runtimecatalog/UnsafeUriCharactersEncoder.java
new file mode 100644
index 0000000..a11c810
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/UnsafeUriCharactersEncoder.java
@@ -0,0 +1,206 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.camel.runtimecatalog;
+
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Encoder for unsafe URI characters.
+ * <p/>
+ * A good source for details is <a href="http://en.wikipedia.org/wiki/Url_encode">wikipedia url encode</a> article.
+ */
+public final class UnsafeUriCharactersEncoder {
+    private static BitSet unsafeCharactersRfc1738;
+    private static BitSet unsafeCharactersHttp;
+    private static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
+        'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f'};
+    private static final Pattern RAW_PATTERN = Pattern.compile("RAW\\([^\\)]+\\)");
+
+    static {
+        unsafeCharactersRfc1738 = new BitSet(256);
+        unsafeCharactersRfc1738.set(' ');
+        unsafeCharactersRfc1738.set('"');
+        unsafeCharactersRfc1738.set('<');
+        unsafeCharactersRfc1738.set('>');
+        unsafeCharactersRfc1738.set('#');
+        unsafeCharactersRfc1738.set('%');
+        unsafeCharactersRfc1738.set('{');
+        unsafeCharactersRfc1738.set('}');
+        unsafeCharactersRfc1738.set('|');
+        unsafeCharactersRfc1738.set('\\');
+        unsafeCharactersRfc1738.set('^');
+        unsafeCharactersRfc1738.set('~');
+        unsafeCharactersRfc1738.set('[');
+        unsafeCharactersRfc1738.set(']');
+        unsafeCharactersRfc1738.set('`');
+    }
+
+    static {
+        unsafeCharactersHttp = new BitSet(256);
+        unsafeCharactersHttp.set(' ');
+        unsafeCharactersHttp.set('"');
+        unsafeCharactersHttp.set('<');
+        unsafeCharactersHttp.set('>');
+        unsafeCharactersHttp.set('#');
+        unsafeCharactersHttp.set('%');
+        unsafeCharactersHttp.set('{');
+        unsafeCharactersHttp.set('}');
+        unsafeCharactersHttp.set('|');
+        unsafeCharactersHttp.set('\\');
+        unsafeCharactersHttp.set('^');
+        unsafeCharactersHttp.set('~');
+        unsafeCharactersHttp.set('`');
+    }
+
+    private UnsafeUriCharactersEncoder() {
+        // util class
+    }
+
+    public static String encode(String s) {
+        return encode(s, unsafeCharactersRfc1738);
+    }
+
+    public static String encodeHttpURI(String s) {
+        return encode(s, unsafeCharactersHttp);
+    }
+
+    public static String encode(String s, BitSet unsafeCharacters) {
+        return encode(s, unsafeCharacters, false);
+    }
+
+    public static String encode(String s, boolean checkRaw) {
+        return encode(s, unsafeCharactersRfc1738, checkRaw);
+    }
+
+    public static String encodeHttpURI(String s, boolean checkRaw) {
+        return encode(s, unsafeCharactersHttp, checkRaw);
+    }
+
+    private static List<Pair> checkRAW(String s) {
+        Matcher matcher = RAW_PATTERN.matcher(s);
+        List<Pair> answer = new ArrayList<Pair>();
+        // Check all occurrences
+        while (matcher.find()) {
+            answer.add(new Pair(matcher.start(), matcher.end()));
+        }
+        return answer;
+    }
+
+    private static boolean isRaw(int index, List<Pair> pairs) {
+        for (Pair pair : pairs) {
+            if (index < pair.left) {
+                return false;
+            } else {
+                if (index >= pair.left) {
+                    if (index <= pair.right) {
+                        return true;
+                    } else {
+                        continue;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private static class Pair {
+        int left;
+        int right;
+
+        Pair(int left, int right) {
+            this.left = left;
+            this.right = right;
+        }
+    }
+
+    // Just skip the encode for isRAW part
+    public static String encode(String s, BitSet unsafeCharacters, boolean checkRaw) {
+        List<Pair> rawPairs;
+        if (checkRaw) {
+            rawPairs = checkRAW(s);
+        } else {
+            rawPairs = new ArrayList<Pair>();
+        }
+
+        int n = s == null ? 0 : s.length();
+        if (n == 0) {
+            return s;
+        }
+
+        // First check whether we actually need to encode
+        char chars[] = s.toCharArray();
+        for (int i = 0;;) {
+            // just deal with the ascii character
+            if (chars[i] > 0 && chars[i] < 128) {
+                if (unsafeCharacters.get(chars[i])) {
+                    break;
+                }
+            }
+            if (++i >= chars.length) {
+                return s;
+            }
+        }
+
+        // okay there are some unsafe characters so we do need to encode
+        // see details at: http://en.wikipedia.org/wiki/Url_encode
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < chars.length; i++) {
+            char ch = chars[i];
+            if (ch > 0 && ch < 128 && unsafeCharacters.get(ch)) {
+                // special for % sign as it may be a decimal encoded value
+                if (ch == '%') {
+                    char next = i + 1 < chars.length ? chars[i + 1] : ' ';
+                    char next2 = i + 2 < chars.length ? chars[i + 2] : ' ';
+
+                    if (isHexDigit(next) && isHexDigit(next2) && !isRaw(i, rawPairs)) {
+                        // its already encoded (decimal encoded) so just append as is
+                        sb.append(ch);
+                    } else {
+                        // must escape then, as its an unsafe character
+                        appendEscape(sb, (byte) ch);
+                    }
+                } else {
+                    // must escape then, as its an unsafe character
+                    appendEscape(sb, (byte) ch);
+                }
+            } else {
+                sb.append(ch);
+            }
+        }
+        return sb.toString();
+    }
+
+    private static void appendEscape(StringBuilder sb, byte b) {
+        sb.append('%');
+        sb.append(HEX_DIGITS[(b >> 4) & 0x0f]);
+        sb.append(HEX_DIGITS[(b >> 0) & 0x0f]);
+    }
+
+    private static boolean isHexDigit(char ch) {
+        for (char hex : HEX_DIGITS) {
+            if (hex == ch) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/runtimecatalog/package.html
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/runtimecatalog/package.html b/camel-core/src/main/java/org/apache/camel/runtimecatalog/package.html
new file mode 100644
index 0000000..2f15a04
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/runtimecatalog/package.html
@@ -0,0 +1,25 @@
+<!--
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.
+    The ASF licenses this file to You 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.
+-->
+<html>
+<head>
+</head>
+<body>
+
+Runtime Camel Catalog
+
+</body>
+</html>

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/main/java/org/apache/camel/util/EndpointHelper.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/util/EndpointHelper.java b/camel-core/src/main/java/org/apache/camel/util/EndpointHelper.java
index fd22f55..a32c109 100644
--- a/camel-core/src/main/java/org/apache/camel/util/EndpointHelper.java
+++ b/camel-core/src/main/java/org/apache/camel/util/EndpointHelper.java
@@ -37,8 +37,8 @@ import org.apache.camel.PollingConsumer;
 import org.apache.camel.Processor;
 import org.apache.camel.ResolveEndpointFailedException;
 import org.apache.camel.Route;
-import org.apache.camel.catalog.DefaultRuntimeCamelCatalog;
-import org.apache.camel.catalog.RuntimeCamelCatalog;
+import org.apache.camel.runtimecatalog.DefaultRuntimeCamelCatalog;
+import org.apache.camel.runtimecatalog.RuntimeCamelCatalog;
 import org.apache.camel.spi.BrowsableEndpoint;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -523,7 +523,7 @@ public final class EndpointHelper {
      * @param uri          the endpoint uri
      * @return a map for each option in the uri with the corresponding information from the json
      * @throws Exception is thrown in case of error
-     * @deprecated use {@link org.apache.camel.catalog.RuntimeCamelCatalog#endpointProperties(String)}
+     * @deprecated use {@link org.apache.camel.runtimecatalog.RuntimeCamelCatalog#endpointProperties(String)}
      */
     @Deprecated
     public static Map<String, Object> endpointProperties(CamelContext camelContext, String uri) throws Exception {

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/test/java/org/apache/camel/catalog/AbstractCamelCatalogTest.java
----------------------------------------------------------------------
diff --git a/camel-core/src/test/java/org/apache/camel/catalog/AbstractCamelCatalogTest.java b/camel-core/src/test/java/org/apache/camel/catalog/AbstractCamelCatalogTest.java
deleted file mode 100644
index ed7e997..0000000
--- a/camel-core/src/test/java/org/apache/camel/catalog/AbstractCamelCatalogTest.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.camel.catalog;
-
-import java.net.URISyntaxException;
-import java.util.HashMap;
-import java.util.Map;
-
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.mock;
-import static org.easymock.EasyMock.replay;
-import static org.junit.Assert.assertEquals;
-
-public class AbstractCamelCatalogTest {
-
-    AbstractCamelCatalog catalog = new AbstractCamelCatalog() {
-    };
-
-    JSonSchemaResolver resolver;
-
-    @Before
-    public void setupMockCatalog() {
-        resolver = mock(JSonSchemaResolver.class);
-
-        catalog.setJSonSchemaResolver(resolver);
-    }
-
-    @Test
-    public void shouldConstructEndpointUris() throws URISyntaxException {
-        expect(resolver.getComponentJSonSchema("comp")).andReturn("{\n"//
-            + "  \"component\": {\n"//
-            + "    \"syntax\": \"comp:param1:param2\"\n"//
-            + "  }\n"//
-            + "}");
-
-        replay(resolver);
-
-        final Map<String, String> properties = new HashMap<>();
-        properties.put("param1", "value1");
-        properties.put("param2", "value2");
-        properties.put("param3", "value3");
-
-        final String endpointUri = catalog.doAsEndpointUri("comp", properties, "&", false);
-
-        assertEquals("comp:value1:value2?param3=value3", endpointUri);
-    }
-
-    @Test
-    public void shouldConstructEndpointUrisWithPropertyPlaceholders() throws URISyntaxException {
-        expect(resolver.getComponentJSonSchema("comp")).andReturn("{\n"//
-            + "  \"component\": {\n"//
-            + "    \"syntax\": \"comp:param1:param2\"\n"//
-            + "  }\n"//
-            + "}");
-
-        replay(resolver);
-
-        final Map<String, String> properties = new HashMap<>();
-        properties.put("param1", "{{prop1}}");
-        properties.put("param2", "{{prop2}}");
-        properties.put("param3", "{{prop3}}");
-
-        final String endpointUri = catalog.doAsEndpointUri("comp", properties, "&", false);
-
-        assertEquals("comp:{{prop1}}:{{prop2}}?param3={{prop3}}", endpointUri);
-    }
-
-    @Test
-    public void shouldConstructEndpointUrisWhenValuesContainTokens() throws URISyntaxException {
-        expect(resolver.getComponentJSonSchema("comp")).andReturn("{\n"//
-            + "  \"component\": {\n"//
-            + "    \"syntax\": \"comp:param1:param2\"\n"//
-            + "  }\n"//
-            + "}");
-
-        replay(resolver);
-
-        final Map<String, String> properties = new HashMap<>();
-        properties.put("param1", "{value1}");
-        properties.put("param2", "/value2/");
-        properties.put("param3", "/value3/{param}");
-
-        final String endpointUri = catalog.doAsEndpointUri("comp", properties, "&", false);
-
-        assertEquals("comp:{value1}:/value2/?param3=/value3/{param}", endpointUri);
-    }
-}

http://git-wip-us.apache.org/repos/asf/camel/blob/c66be7a8/camel-core/src/test/java/org/apache/camel/catalog/RuntimeCamelCatalogTest.java
----------------------------------------------------------------------
diff --git a/camel-core/src/test/java/org/apache/camel/catalog/RuntimeCamelCatalogTest.java b/camel-core/src/test/java/org/apache/camel/catalog/RuntimeCamelCatalogTest.java
deleted file mode 100644
index 78e51a2..0000000
--- a/camel-core/src/test/java/org/apache/camel/catalog/RuntimeCamelCatalogTest.java
+++ /dev/null
@@ -1,393 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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 org.apache.camel.catalog;
-
-import java.util.HashMap;
-import java.util.Map;
-
-import org.apache.camel.impl.DefaultCamelContext;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-public class RuntimeCamelCatalogTest {
-
-    static RuntimeCamelCatalog catalog;
-
-    private static final Logger LOG = LoggerFactory.getLogger(RuntimeCamelCatalogTest.class);
-
-    @BeforeClass
-    public static void createCamelCatalog() {
-        catalog = new DefaultRuntimeCamelCatalog(new DefaultCamelContext());
-    }
-
-    @Test
-    public void testFromCamelContext() throws Exception {
-        String schema = new DefaultCamelContext().getRuntimeCamelCatalog().modelJSonSchema("choice");
-        assertNotNull(schema);
-    }
-
-    @Test
-    public void testJsonSchema() throws Exception {
-        String schema = catalog.modelJSonSchema("aggregate");
-        assertNotNull(schema);
-
-        // lets make it possible to find bean/method using both names
-        schema = catalog.modelJSonSchema("method");
-        assertNotNull(schema);
-        schema = catalog.modelJSonSchema("bean");
-        assertNotNull(schema);
-    }
-
-    @Test
-    public void testAsEndpointUriMapFile() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("directoryName", "src/data/inbox");
-        map.put("noop", "true");
-        map.put("delay", "5000");
-
-        String uri = catalog.asEndpointUri("file", map, true);
-        assertEquals("file:src/data/inbox?delay=5000&noop=true", uri);
-
-        String uri2 = catalog.asEndpointUriXml("file", map, true);
-        assertEquals("file:src/data/inbox?delay=5000&amp;noop=true", uri2);
-    }
-
-    @Test
-    public void testAsEndpointUriTimer() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("timerName", "foo");
-        map.put("period", "5000");
-
-        String uri = catalog.asEndpointUri("timer", map, true);
-        assertEquals("timer:foo?period=5000", uri);
-    }
-
-    @Test
-    public void testAsEndpointUriPropertiesPlaceholders() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("timerName", "foo");
-        map.put("period", "{{howoften}}");
-        map.put("repeatCount", "5");
-
-        String uri = catalog.asEndpointUri("timer", map, true);
-        assertEquals("timer:foo?period=%7B%7Bhowoften%7D%7D&repeatCount=5", uri);
-
-        uri = catalog.asEndpointUri("timer", map, false);
-        assertEquals("timer:foo?period={{howoften}}&repeatCount=5", uri);
-    }
-
-    @Test
-    public void testAsEndpointUriBeanLookup() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("resourceUri", "foo.xslt");
-        map.put("converter", "#myConverter");
-
-        String uri = catalog.asEndpointUri("xslt", map, true);
-        assertEquals("xslt:foo.xslt?converter=%23myConverter", uri);
-
-        uri = catalog.asEndpointUri("xslt", map, false);
-        assertEquals("xslt:foo.xslt?converter=#myConverter", uri);
-    }
-
-    @Test
-    public void testEndpointPropertiesPlaceholders() throws Exception {
-        Map<String, String> map = catalog.endpointProperties("timer:foo?period={{howoften}}&repeatCount=5");
-        assertNotNull(map);
-        assertEquals(3, map.size());
-
-        assertEquals("foo", map.get("timerName"));
-        assertEquals("{{howoften}}", map.get("period"));
-        assertEquals("5", map.get("repeatCount"));
-    }
-
-    @Test
-    public void testAsEndpointUriLog() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("loggerName", "foo");
-        map.put("loggerLevel", "WARN");
-        map.put("multiline", "true");
-        map.put("showAll", "true");
-        map.put("showBody", "false");
-        map.put("showBodyType", "false");
-        map.put("showExchangePattern", "false");
-        map.put("style", "Tab");
-
-        assertEquals("log:foo?loggerLevel=WARN&multiline=true&showAll=true&style=Tab", catalog.asEndpointUri("log", map, false));
-    }
-
-    @Test
-    public void testAsEndpointUriLogShort() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("loggerName", "foo");
-        map.put("loggerLevel", "DEBUG");
-
-        assertEquals("log:foo?loggerLevel=DEBUG", catalog.asEndpointUri("log", map, false));
-    }
-
-    @Test
-    public void testAsEndpointUriWithplaceholder() throws Exception {
-        Map<String, String> map = new HashMap<String, String>();
-        map.put("name", "foo");
-        map.put("blockWhenFull", "{{block}}");
-        assertEquals("seda:foo?blockWhenFull={{block}}", catalog.asEndpointUri("seda", map, false));
-    }
-
-    @Test
-    public void testEndpointPropertiesSedaRequired() throws Exception {
-        Map<String, String> map = catalog.endpointProperties("seda:foo");
-        assertNotNull(map);
-        assertEquals(1, map.size());
-
-        assertEquals("foo", map.get("name"));
-
-        map = catalog.endpointProperties("seda:foo?blockWhenFull=true");
-        assertNotNull(map);
-        assertEquals(2, map.size());
-
-        assertEquals("foo", map.get("name"));
-        assertEquals("true", map.get("blockWhenFull"));
-    }
-
-    @Test
-    public void validateProperties() throws Exception {
-        // valid
-        EndpointValidationResult result = catalog.validateEndpointProperties("log:mylog");
-        assertTrue(result.isSuccess());
-
-        // unknown
-        result = catalog.validateEndpointProperties("log:mylog?level=WARN&foo=bar");
-        assertFalse(result.isSuccess());
-        assertTrue(result.getUnknown().contains("foo"));
-        assertEquals(1, result.getNumberOfErrors());
-
-        // enum
-        result = catalog.validateEndpointProperties("seda:foo?waitForTaskToComplete=blah");
-        assertFalse(result.isSuccess());
-        assertEquals("blah", result.getInvalidEnum().get("waitForTaskToComplete"));
-        assertEquals(1, result.getNumberOfErrors());
-
-        // reference okay
-        result = catalog.validateEndpointProperties("seda:foo?queue=#queue");
-        assertTrue(result.isSuccess());
-        assertEquals(0, result.getNumberOfErrors());
-
-        // unknown component
-        result = catalog.validateEndpointProperties("foo:bar?me=you");
-        assertFalse(result.isSuccess());
-        assertTrue(result.getUnknownComponent().equals("foo"));
-        assertEquals(1, result.getNumberOfErrors());
-
-        // invalid boolean but default value
-        result = catalog.validateEndpointProperties("log:output?showAll=ggg");
-        assertFalse(result.isSuccess());
-        assertEquals("ggg", result.getInvalidBoolean().get("showAll"));
-        assertEquals(1, result.getNumberOfErrors());
-
-        // dataset
-        result = catalog.validateEndpointProperties("dataset:foo?minRate=50");
-        assertTrue(result.isSuccess());
-
-        // time pattern
-        result = catalog.validateEndpointProperties("timer://foo?fixedRate=true&delay=0&period=2s");
-        assertTrue(result.isSuccess());
-
-        // reference lookup
-        result = catalog.validateEndpointProperties("timer://foo?fixedRate=#fixed&delay=#myDelay");
-        assertTrue(result.isSuccess());
-
-        // optional consumer. prefix
-        result = catalog.validateEndpointProperties("file:inbox?consumer.delay=5000&consumer.greedy=true");
-        assertTrue(result.isSuccess());
-
-        // optional without consumer. prefix
-        result = catalog.validateEndpointProperties("file:inbox?delay=5000&greedy=true");
-        assertTrue(result.isSuccess());
-
-        // mixed optional without consumer. prefix
-        result = catalog.validateEndpointProperties("file:inbox?delay=5000&consumer.greedy=true");
-        assertTrue(result.isSuccess());
-
-        // prefix
-        result = catalog.validateEndpointProperties("file:inbox?delay=5000&scheduler.foo=123&scheduler.bar=456");
-        assertTrue(result.isSuccess());
-
-        // stub
-        result = catalog.validateEndpointProperties("stub:foo?me=123&you=456");
-        assertTrue(result.isSuccess());
-
-        // lenient on
-        result = catalog.validateEndpointProperties("dataformat:string:marshal?foo=bar");
-        assertTrue(result.isSuccess());
-
-        // lenient off
-        result = catalog.validateEndpointProperties("dataformat:string:marshal?foo=bar", true);
-        assertFalse(result.isSuccess());
-        assertTrue(result.getUnknown().contains("foo"));
-
-        // data format
-        result = catalog.validateEndpointProperties("dataformat:string:marshal?charset=utf-8", true);
-        assertTrue(result.isSuccess());
-
-        // incapable to parse
-        result = catalog.validateEndpointProperties("{{getFtpUrl}}?recursive=true");
-        assertFalse(result.isSuccess());
-        assertTrue(result.getIncapable() != null);
-    }
-
-    @Test
-    public void validatePropertiesSummary() throws Exception {
-        EndpointValidationResult result = catalog.validateEndpointProperties("yammer:MESSAGES?blah=yada&accessToken=aaa&consumerKey=&useJson=no&initialDelay=five&pollStrategy=myStrategy");
-        assertFalse(result.isSuccess());
-        String reason = result.summaryErrorMessage(true);
-        LOG.info(reason);
-
-        result = catalog.validateEndpointProperties("jms:unknown:myqueue");
-        assertFalse(result.isSuccess());
-        reason = result.summaryErrorMessage(false);
-        LOG.info(reason);
-    }
-
-    @Test
-    public void validateTimePattern() throws Exception {
-        assertTrue(catalog.validateTimePattern("0"));
-        assertTrue(catalog.validateTimePattern("500"));
-        assertTrue(catalog.validateTimePattern("10000"));
-        assertTrue(catalog.validateTimePattern("5s"));
-        assertTrue(catalog.validateTimePattern("5sec"));
-        assertTrue(catalog.validateTimePattern("5secs"));
-        assertTrue(catalog.validateTimePattern("3m"));
-        assertTrue(catalog.validateTimePattern("3min"));
-        assertTrue(catalog.validateTimePattern("3minutes"));
-        assertTrue(catalog.validateTimePattern("5m15s"));
-        assertTrue(catalog.validateTimePattern("1h"));
-        assertTrue(catalog.validateTimePattern("1hour"));
-        assertTrue(catalog.validateTimePattern("2hours"));
-
-        assertFalse(catalog.validateTimePattern("bla"));
-        assertFalse(catalog.validateTimePattern("2year"));
-        assertFalse(catalog.validateTimePattern("60darn"));
-    }
-
-    @Test
-    public void testEndpointComponentName() throws Exception {
-        String name = catalog.endpointComponentName("jms:queue:foo");
-        assertEquals("jms", name);
-    }
-
-    @Test
-    public void testSimpleExpression() throws Exception {
-        SimpleValidationResult result = catalog.validateSimpleExpression(null, "${body}");
-        assertTrue(result.isSuccess());
-        assertEquals("${body}", result.getSimple());
-
-        result = catalog.validateSimpleExpression(null, "${body");
-        assertFalse(result.isSuccess());
-        assertEquals("${body", result.getSimple());
-        LOG.info(result.getError());
-        assertTrue(result.getError().startsWith("expected symbol functionEnd but was eol at location 5"));
-        assertEquals("expected symbol functionEnd but was eol", result.getShortError());
-        assertEquals(5, result.getIndex());
-    }
-
-    @Test
-    public void testSimplePredicate() throws Exception {
-        SimpleValidationResult result = catalog.validateSimplePredicate(null, "${body} == 'abc'");
-        assertTrue(result.isSuccess());
-        assertEquals("${body} == 'abc'", result.getSimple());
-
-        result = catalog.validateSimplePredicate(null, "${body} > ${header.size");
-        assertFalse(result.isSuccess());
-        assertEquals("${body} > ${header.size", result.getSimple());
-        LOG.info(result.getError());
-        assertTrue(result.getError().startsWith("expected symbol functionEnd but was eol at location 22"));
-        assertEquals("expected symbol functionEnd but was eol", result.getShortError());
-        assertEquals(22, result.getIndex());
-    }
-
-    @Test
-    public void testSimplePredicatePlaceholder() throws Exception {
-        SimpleValidationResult result = catalog.validateSimplePredicate(null, "${body} contains '{{danger}}'");
-        assertTrue(result.isSuccess());
-        assertEquals("${body} contains '{{danger}}'", result.getSimple());
-
-        result = catalog.validateSimplePredicate(null, "${bdy} contains '{{danger}}'");
-        assertFalse(result.isSuccess());
-        assertEquals("${bdy} contains '{{danger}}'", result.getSimple());
-        LOG.info(result.getError());
-        assertTrue(result.getError().startsWith("Unknown function: bdy at location 0"));
-        assertTrue(result.getError().contains("'{{danger}}'"));
-        assertEquals("Unknown function: bdy", result.getShortError());
-        assertEquals(0, result.getIndex());
-    }
-
-    @Test
-    public void testValidateLanguage() throws Exception {
-        LanguageValidationResult result = catalog.validateLanguageExpression(null, "simple", "${body}");
-        assertTrue(result.isSuccess());
-        assertEquals("${body}", result.getText());
-
-        result = catalog.validateLanguageExpression(null, "header", "foo");
-        assertTrue(result.isSuccess());
-        assertEquals("foo", result.getText());
-
-        result = catalog.validateLanguagePredicate(null, "simple", "${body} > 10");
-        assertTrue(result.isSuccess());
-        assertEquals("${body} > 10", result.getText());
-
-        result = catalog.validateLanguagePredicate(null, "header", "bar");
-        assertTrue(result.isSuccess());
-        assertEquals("bar", result.getText());
-
-        result = catalog.validateLanguagePredicate(null, "foobar", "bar");
-        assertFalse(result.isSuccess());
-        assertEquals("Unknown language foobar", result.getError());
-    }
-
-    @Test
-    public void testValidateEndpointConsumerOnly() throws Exception {
-        String uri = "file:inbox?bufferSize=4096&readLock=changed&delete=true";
-        EndpointValidationResult result = catalog.validateEndpointProperties(uri, false, true, false);
-        assertTrue(result.isSuccess());
-
-        uri = "file:inbox?bufferSize=4096&readLock=changed&delete=true&fileExist=Append";
-        result = catalog.validateEndpointProperties(uri, false, true, false);
-        assertFalse(result.isSuccess());
-
-        assertEquals("fileExist", result.getNotConsumerOnly().iterator().next());
-    }
-
-    @Test
-    public void testValidateEndpointProducerOnly() throws Exception {
-        String uri = "file:outbox?bufferSize=4096&fileExist=Append";
-        EndpointValidationResult result = catalog.validateEndpointProperties(uri, false, false, true);
-        assertTrue(result.isSuccess());
-
-        uri = "file:outbox?bufferSize=4096&fileExist=Append&delete=true";
-        result = catalog.validateEndpointProperties(uri, false, false, true);
-        assertFalse(result.isSuccess());
-
-        assertEquals("delete", result.getNotProducerOnly().iterator().next());
-    }
-
-}


Mime
View raw message