Add scoped selectors and data model

This change updates selectors to use more of a data model when selecting
attribute values. All selector values and path traversal is now
implemented using AttributeValue objects, allowing for easier expansion,
and adding support for generalities like universal (keys) and (values).

smithy-model/src/main/java/software/amazon/smithy/model/selector/AttributeComparator.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ *
+ *  http://aws.amazon.com/apache2.0
+ *
+ * or in the "license" file accompanying this file. This file 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 software.amazon.smithy.model.selector;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * Compares two selector attribute values.
+ */
+@FunctionalInterface
+interface AttributeComparator {
+
+    AttributeComparator EQUALS = stringComparator(String::equals);
+    AttributeComparator NOT_EQUALS = stringComparator((a, b) -> !a.equals(b));
+    AttributeComparator STARTS_WITH = stringComparator(String::startsWith);
+    AttributeComparator ENDS_WITH = stringComparator(String::endsWith);
+    AttributeComparator CONTAINS = stringComparator(String::contains);
+    AttributeComparator GT = stringComparator((a, b) -> numericComparison(a, b, result -> result == 1));
+    AttributeComparator GTE = stringComparator((a, b) -> numericComparison(a, b, result -> result >= 0));
+    AttributeComparator LT = stringComparator((a, b) -> numericComparison(a, b, result -> result <= -1));
+    AttributeComparator LTE = stringComparator((a, b) -> numericComparison(a, b, result -> result <= 0));
+    AttributeComparator EXISTS = AttributeComparator::existsCheck;
+
+    /**
+     * Compares the left hand side value against the right using a comparator.
+     *
+     * @param lhs Left value of the comparison.
+     * @param rhs Right value of the comparison.
+     * @param caseInsensitive Whether or not the comparison is case-insensitive.
+     * @return Returns true if the values match the comparator.
+     */
+    boolean compare(AttributeValue lhs, AttributeValue rhs, boolean caseInsensitive);
+
+    /**
+     * Compares the given attribute values by flattening each side of the
+     * comparison, and comparing each value.
+     *
+     * <p>This method is necessary in order to support matching on projections.
+     *
+     * @param lhs The left hand side of the comparison.
+     * @param rhs The right hand side of the comparison.
+     * @param insensitive Whether or not to use a case-insensitive comparison.
+     * @return Returns true if the attributes match the comparator.
+     */
+    default boolean flattenedCompare(AttributeValue lhs, AttributeValue rhs, boolean insensitive) {
+        for (AttributeValue l : lhs.getFlattenedValues()) {
+            for (AttributeValue r : rhs.getFlattenedValues()) {
+                if (compare(l, r, insensitive)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    // String comparators simplify how comparisons are made on attribute
+    // values that MUST resolve to strings.
+    static AttributeComparator stringComparator(BiFunction<String, String, Boolean> compare) {
+        return (lhs, rhs, caseInsensitive) -> {
+            // Both values MUST be present to compare.
+            if (!lhs.isPresent() || !rhs.isPresent()) {
+                return false;
+            }
+
+            String lhsString = lhs.toString();
+            String rhsString = rhs.toString();
+
+            // Convert both sides of the comparison to lowercase when case insensitive.
+            if (caseInsensitive) {
+                lhsString = lhsString.toLowerCase(Locale.ENGLISH);
+                rhsString = rhsString.toLowerCase(Locale.ENGLISH);
+            }
+
+            return compare.apply(lhsString, rhsString);
+        };
+    }
+
+    // Try to parse both numbers, ignore numeric failures since that's acceptable,
+    // then pass the result of calling compareTo on the numbers to the given
+    // evaluator. The evaluator then determines if the comparison is what was expected.
+    static boolean numericComparison(String lhs, String rhs, Function<Integer, Boolean> evaluator) {
+        BigDecimal lhsNumber = parseNumber(lhs);
+        if (lhsNumber == null) {
+            return false;
+        }
+
+        BigDecimal rhsNumber = parseNumber(rhs);
+        if (rhsNumber == null) {
+            return false;
+        }
+
+        return evaluator.apply(lhsNumber.compareTo(rhsNumber));
+    }
+
+    // Invalid numbers do not fail the parser or evaluation of a selector.
+    static BigDecimal parseNumber(String token) {
+        try {
+            return new BigDecimal(token);
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    // Checks if a value "exists" and if the expected boolean string matches
+    // the resolved existence boolean.
+    static boolean existsCheck(AttributeValue a, AttributeValue b, boolean caseInsensitive) {
+        String bString = b.toString();
+        return (a.isPresent() && bString.equals("true"))
+               || (!a.isPresent() && b.toString().equals("false"));
+    }
+}

smithy-model/src/main/java/software/amazon/smithy/model/selector/AttributeSelector.java

@@ -15,138 +15,70 @@
 
 package software.amazon.smithy.model.selector;
 
-import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Locale;
 import java.util.Set;
-import java.util.function.BiFunction;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 import software.amazon.smithy.model.Model;
 import software.amazon.smithy.model.neighbor.NeighborProvider;
-import software.amazon.smithy.model.shapes.ServiceShape;
 import software.amazon.smithy.model.shapes.Shape;
-import software.amazon.smithy.utils.ListUtils;
 
 /**
- * Matches shapes with a specific attribute.
+ * Matches shapes with a specific attribute or that matches an attribute comparator.
  */
 final class AttributeSelector implements Selector {
 
-    static final Comparator EQUALS = String::equals;
-    static final Comparator NOT_EQUALS = (a, b) -> !a.equals(b);
-    static final Comparator STARTS_WITH = String::startsWith;
-    static final Comparator ENDS_WITH = String::endsWith;
-    static final Comparator CONTAINS = String::contains;
-
-    static final Comparator GT = (a, b) -> numericComparison(a, b, i -> i == 1);
-    static final Comparator GTE = (a, b) -> numericComparison(a, b, i -> i >= 0);
-    static final Comparator LT = (a, b) -> numericComparison(a, b, i -> i <= -1);
-    static final Comparator LTE = (a, b) -> numericComparison(a, b, i -> i <= 0);
-
-    static final KeyGetter KEY_ID = (shape) -> ListUtils.of(shape.getId().toString());
-    static final KeyGetter KEY_ID_NAMESPACE = (shape) -> ListUtils.of(shape.getId().getNamespace());
-    static final KeyGetter KEY_ID_NAME = (shape) -> ListUtils.of(shape.getId().getName());
-    static final KeyGetter KEY_ID_MEMBER = (shape) -> shape.getId().getMember()
-            .map(Collections::singletonList)
-            .orElseGet(Collections::emptyList);
-    static final KeyGetter KEY_SERVICE_VERSION = (shape) -> shape.asServiceShape()
-            .map(ServiceShape::getVersion)
-            .map(Collections::singletonList)
-            .orElseGet(Collections::emptyList);
-
-    private final KeyGetter key;
-    private final List<String> expected;
-    private final Comparator comparator;
+    private final AttributeValue.Factory key;
+    private final List<AttributeValue> expected;
+    private final AttributeComparator comparator;
     private final boolean caseInsensitive;
 
-    interface KeyGetter extends Function<Shape, List<String>> {}
-
-    interface Comparator extends BiFunction<String, String, Boolean> {}
-
-    AttributeSelector(KeyGetter key) {
-        this.key = key;
-        expected = null;
-        comparator = null;
-        caseInsensitive = false;
-    }
-
     AttributeSelector(
-            KeyGetter key,
-            Comparator comparator,
+            AttributeValue.Factory key,
             List<String> expected,
+            AttributeComparator comparator,
             boolean caseInsensitive
     ) {
-        this.expected = expected;
         this.key = key;
         this.caseInsensitive = caseInsensitive;
         this.comparator = comparator;
 
-        // Case insensitive comparisons are made by converting both
-        // side of the comparison to lowercase.
-        if (caseInsensitive) {
-            for (int i = 0; i < expected.size(); i++) {
-                expected.set(i, expected.get(i).toLowerCase(Locale.ENGLISH));
+        // Create the valid values of the expected selector.
+        if (expected == null) {
+            this.expected = Collections.emptyList();
+        } else {
+            this.expected = new ArrayList<>(expected.size());
+            for (String validValue : expected) {
+                this.expected.add(new AttributeValue.Literal(validValue));
             }
         }
     }
 
+    static AttributeSelector existence(AttributeValue.Factory key) {
+        return new AttributeSelector(key, null, null, false);
+    }
+
     @Override
     public Set<Shape> select(Model model, NeighborProvider neighborProvider, Set<Shape> shapes) {
         return shapes.stream()
-                .filter(shape -> matchesAttribute(key.apply(shape)))
+                .filter(this::matchesAttribute)
                 .collect(Collectors.toSet());
     }
 
-    private boolean matchesAttribute(List<String> result) {
-        if (comparator == null) {
-            return !result.isEmpty();
-        }
-
-        for (String attribute : result) {
-            // The returned attribute value might be null if
-            // the value exists, but isn't comparable.
-            if (attribute == null) {
-                continue;
-            }
+    private boolean matchesAttribute(Shape shape) {
+        AttributeValue lhs = key.create(shape);
 
-            if (caseInsensitive) {
-                attribute = attribute.toLowerCase(Locale.ENGLISH);
-            }
+        if (expected.isEmpty()) {
+            return lhs.isPresent();
+        }
 
-            for (String value : expected) {
-                if (comparator.apply(attribute, value)) {
-                    return true;
-                }
+        for (AttributeValue rhs : expected) {
+            if (comparator.flattenedCompare(lhs, rhs, caseInsensitive)) {
+                return true;
             }
         }
 
         return false;
     }
-
-    // Try to parse both numbers, ignore numeric failures since that's acceptable,
-    // then pass the result of calling compareTo on the numbers to the given
-    // evaluator. The evaluator then determines if the comparison is what was expected.
-    private static boolean numericComparison(String lhs, String rhs, Function<Integer, Boolean> evaluator) {
-        BigDecimal lhsNumber = parseNumber(lhs);
-        if (lhsNumber == null) {
-            return false;
-        }
-
-        BigDecimal rhsNumber = parseNumber(rhs);
-        if (rhsNumber == null) {
-            return false;
-        }
-
-        return evaluator.apply(lhsNumber.compareTo(rhsNumber));
-    }
-
-    private static BigDecimal parseNumber(String token) {
-        try {
-            return new BigDecimal(token);
-        } catch (NumberFormatException e) {
-            return null;
-        }
-    }
 }