Add static methods for more endpoint rules functions

* Add static method and improve isValidHostLabel
* Add public version of substring

Author: mtdowling

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

@@ -6,6 +6,7 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.regex.Pattern;
 import software.amazon.smithy.rulesengine.language.evaluation.type.Type;
 import software.amazon.smithy.rulesengine.language.evaluation.value.Value;
 import software.amazon.smithy.rulesengine.language.syntax.ToExpression;
@@ -19,6 +20,7 @@
 @SmithyUnstableApi
 public final class IsValidHostLabel extends LibraryFunction {
     public static final String ID = "isValidHostLabel";
+    private static final Pattern HOST_LABEL_PATTERN = Pattern.compile("^[a-zA-Z\\d][a-zA-Z\\d\\-]{0,62}$");
     private static final Definition DEFINITION = new Definition();
 
     IsValidHostLabel(FunctionNode functionNode) {
@@ -89,23 +91,30 @@ public Value evaluate(List<Value> arguments) {
             return Value.booleanValue(isValidHostLabel(hostLabel, allowDots));
         }
 
-        private boolean isValidHostLabel(String hostLabel, boolean allowDots) {
-            if (allowDots) {
-                // ensure that empty matches at the end are included
-                for (String subLabel : hostLabel.split("[.]", -1)) {
-                    if (!isValidHostLabel(subLabel, false)) {
-                        return false;
-                    }
-                }
-                return true;
-            } else {
-                return hostLabel.matches("[a-zA-Z\\d][a-zA-Z\\d\\-]{1,62}");
-            }
-        }
-
         @Override
         public IsValidHostLabel createFunction(FunctionNode functionNode) {
             return new IsValidHostLabel(functionNode);
         }
     }
+
+    /**
+     * Check if a hostLabel is valid host.
+     *
+     * @param hostLabel Host label to check.
+     * @param allowDots Set to true to allow dots.
+     * @return true if the label is valid.
+     */
+    public static boolean isValidHostLabel(String hostLabel, boolean allowDots) {
+        if (!allowDots) {
+            return HOST_LABEL_PATTERN.matcher(hostLabel).matches();
+        } else {
+            // ensure that empty matches at the end are included
+            for (String subLabel : hostLabel.split("[.]", -1)) {
+                if (!HOST_LABEL_PATTERN.matcher(subLabel).matches()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
 }

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

@@ -97,30 +97,42 @@ public Value evaluate(List<Value> arguments) {
             int startIndex = arguments.get(1).expectIntegerValue().getValue();
             int stopIndex = arguments.get(2).expectIntegerValue().getValue();
             boolean reverse = arguments.get(3).expectBooleanValue().getValue();
+            String result = getSubstring(str, startIndex, stopIndex, reverse);
+            return result == null ? Value.emptyValue() : Value.stringValue(result);
+        }
 
-            for (int i = 0; i < str.length(); i++) {
-                char ch = str.charAt(i);
-                if (!(ch <= 127)) {
-                    return Value.emptyValue();
-                }
-            }
+        @Override
+        public Substring createFunction(FunctionNode functionNode) {
+            return new Substring(functionNode);
+        }
+    }
 
-            if (startIndex >= stopIndex || str.length() < stopIndex) {
-                return Value.emptyValue();
+    /**
+     * Get the substring of {@code value} using the same logic as the substring function.
+     *
+     * @param value Value to get the substring of.
+     * @param startIndex Start index.
+     * @param stopIndex Stop index.
+     * @param reverse True if the slice is from the end.
+     * @return the substring value or null.
+     */
+    public static String getSubstring(String value, int startIndex, int stopIndex, boolean reverse) {
+        for (int i = 0; i < value.length(); i++) {
+            if (!(value.charAt(i) <= 127)) {
+                return null;
             }
+        }
 
-            if (!reverse) {
-                return Value.stringValue(str.substring(startIndex, stopIndex));
-            } else {
-                int revStart = str.length() - stopIndex;
-                int revStop = str.length() - startIndex;
-                return Value.stringValue(str.substring(revStart, revStop));
-            }
+        if (startIndex >= stopIndex || value.length() < stopIndex) {
+            return null;
         }
 
-        @Override
-        public Substring createFunction(FunctionNode functionNode) {
-            return new Substring(functionNode);
+        if (!reverse) {
+            return value.substring(startIndex, stopIndex);
+        } else {
+            int revStart = value.length() - stopIndex;
+            int revStop = value.length() - startIndex;
+            return value.substring(revStart, revStop);
         }
     }
 }