Add public static utilities to ParseUrl

First, I copied the IP address detection code from
https://github.com/aws/aws-sdk-java-v2/blob/93f914840a071fb162693d1ebd753803281253cf/codegen/src/main/resources/software/amazon/awssdk/codegen/rules2/RuleUrl.java.resource#L58-L111
This should be much more performant than catching integer parsing errors.

I also exposed this method and the method for normalizing a path as
a public utility method. This will allow me to use the method directly
in smithy-java.

Author: mtdowling

smithy-rules-engine/src/main/java/software/amazon/smithy/rulesengine/language/syntax/expressions/functions/ParseUrl.java

@@ -99,41 +99,9 @@ public Value evaluate(List<Value> arguments) {
                     return Value.emptyValue();
                 }
 
-                boolean isIpAddr = false;
-                String host = parsed.getHost();
-                if (host.startsWith("[") && host.endsWith("]")) {
-                    isIpAddr = true;
-                }
-                String[] dottedParts = host.split("\\.");
-                if (dottedParts.length == 4) {
-                    isIpAddr = true;
-                    for (String dottedPart : dottedParts) {
-                        try {
-                            int value = Integer.parseInt(dottedPart);
-                            if (value < 0 || value > 255) {
-                                isIpAddr = false;
-                            }
-                        } catch (NumberFormatException ex) {
-                            isIpAddr = false;
-                        }
-                    }
-                }
-
+                boolean isIpAddr = isIpAddr(parsed.getHost());
                 String path = parsed.getPath();
-                String normalizedPath;
-                if (StringUtils.isBlank(path)) {
-                    normalizedPath = "/";
-                } else {
-                    StringBuilder builder = new StringBuilder();
-                    if (!path.startsWith("/")) {
-                        builder.append("/");
-                    }
-                    builder.append(path);
-                    if (!path.endsWith("/")) {
-                        builder.append("/");
-                    }
-                    normalizedPath = builder.toString();
-                }
+                String normalizedPath = normalizePath(path);
 
                 Map<Identifier, Value> values = new LinkedHashMap<>();
                 values.put(SCHEME, Value.stringValue(parsed.getProtocol()));
@@ -152,4 +120,92 @@ public ParseUrl createFunction(FunctionNode functionNode) {
             return new ParseUrl(functionNode);
         }
     }
+
+    /**
+     * Checks if a host is an IP address for use with endpoint rules.
+     *
+     * @param host Host to check.
+     * @return true if it is an IP address.
+     */
+    public static boolean isIpAddr(String host) {
+        if (host == null || host.length() < 2) {
+            return false;
+        }
+
+        // Simple check for IPv6 (enclosed in square brackets)
+        if (host.charAt(0) == '[' && host.charAt(host.length() - 1) == ']') {
+            return true;
+        }
+
+        int from = 0;
+        int segments = 0;
+        boolean done = false;
+        while (!done) {
+            int index = host.indexOf('.', from);
+            if (index == -1) {
+                if (segments != 3) {
+                    // E.g., 123.com
+                    return false;
+                }
+                index = host.length();
+                done = true;
+            } else if (segments == 3) {
+                // E.g., 1.2.3.4.5
+                return false;
+            }
+            int length = index - from;
+            if (length == 1) {
+                char ch0 = host.charAt(from);
+                if (ch0 < '0' || ch0 > '9') {
+                    return false;
+                }
+            } else if (length == 2) {
+                char ch0 = host.charAt(from);
+                char ch1 = host.charAt(from + 1);
+                if ((ch0 <= '0' || ch0 > '9') || (ch1 < '0' || ch1 > '9')) {
+                    return false;
+                }
+            } else if (length == 3) {
+                char ch0 = host.charAt(from);
+                char ch1 = host.charAt(from + 1);
+                char ch2 = host.charAt(from + 2);
+                if ((ch0 <= '0' || ch0 > '9')
+                        || (ch1 < '0' || ch1 > '9')
+                        || (ch2 < '0' || ch2 > '9')) {
+                    return false;
+                }
+                int value = ((ch0 - '0') * 100) + ((ch1 - '0') * 10) + (ch2 - '0');
+                if (value > 255) {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+            from = index + 1;
+            segments += 1;
+        }
+        return true;
+    }
+
+    /**
+     * Normalizes a path string according to the ParseURL function.
+     *
+     * @param path Path string to normalize.
+     * @return the normalized path.
+     */
+    public static String normalizePath(String path) {
+        if (StringUtils.isBlank(path)) {
+            return "/";
+        } else {
+            StringBuilder builder = new StringBuilder();
+            if (!path.startsWith("/")) {
+                builder.append("/");
+            }
+            builder.append(path);
+            if (!path.endsWith("/")) {
+                builder.append("/");
+            }
+            return builder.toString();
+        }
+    }
 }