Squash sketch

src/main/java/com/github/jinahya/assertj/validation/AbstractPathAssert.java

@@ -22,19 +22,19 @@
 
 import org.assertj.core.api.AbstractAssert;
 import org.assertj.core.api.AbstractBooleanAssert;
+import org.assertj.core.api.AbstractClassAssert;
 import org.assertj.core.api.AbstractComparableAssert;
 import org.assertj.core.api.AbstractIntegerAssert;
 import org.assertj.core.api.AbstractIterableAssert;
+import org.assertj.core.api.AbstractListAssert;
 import org.assertj.core.api.AbstractObjectAssert;
 import org.assertj.core.api.AbstractStringAssert;
-import org.assertj.core.api.Assert;
 import org.assertj.core.api.AssertFactory;
-import org.assertj.core.api.Assertions;
-import org.assertj.core.api.InstanceOfAssertFactories;
-import org.assertj.core.api.ListAssert;
 
 import javax.validation.ElementKind;
 import javax.validation.Path;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
 
@@ -114,25 +114,6 @@ public abstract static class AbstractNodeAssert<SELF extends AbstractNodeAssert<
         AbstractNodeAssert(final Path.Node actual, final Class<?> selfType) {
             super(actual, selfType);
         }
-
-        // ---------------------------------------------------------------------------------------------------------- as
-//        @Override
-        public <NODE extends Path.Node, ASSERT extends PathAssert.NodeAssert<?, ? extends NODE>> ASSERT extractingAs(
-                final Class<NODE> nodeType,
-                final AssertFactory<? super NODE, ? extends ASSERT> assertFactory) {
-            Objects.requireNonNull(nodeType, "nodeType is null");
-            // TODO: implement!
-            return null;
-        }
-    }
-
-    abstract static class AbstractParameterizedNodeAssert<SELF extends AbstractParameterizedNodeAssert<SELF>>
-            extends _AbstractNodeAssert<SELF, Path.ParameterNode>
-            implements ParameterNodeAssert<SELF> {
-
-        AbstractParameterizedNodeAssert(final Path.ParameterNode actual, final Class<?> selfType) {
-            super(actual, selfType);
-        }
     }
 
     abstract static class AbstractBeanNodeAssert<SELF extends AbstractBeanNodeAssert<SELF>>
@@ -144,15 +125,17 @@ abstract static class AbstractBeanNodeAssert<SELF extends AbstractBeanNodeAssert
         }
 
         @Override
-        public Assert<?, ? extends Class<?>> extractingContainerClass() {
+        public <ASSERT extends AbstractClassAssert<? extends ASSERT>> ASSERT extractingContainerClass(
+                AssertFactory<? super Class<?>, ? extends ASSERT> factory) {
             return isNotNull()
-                    .extracting(Path.BeanNode::getContainerClass, InstanceOfAssertFactories.CLASS);
+                    .extracting(Path.BeanNode::getContainerClass, factory);
         }
 
         @Override
-        public Assert<?, Integer> extractingTypeArgumentIndex() {
+        public <ASSERT extends AbstractIntegerAssert<? extends ASSERT>> ASSERT extractingTypeArgumentIndex(
+                final AssertFactory<? super Integer, ? extends ASSERT> factory) {
             return isNotNull()
-                    .extracting(Path.BeanNode::getContainerClass, InstanceOfAssertFactories.INTEGER);
+                    .extracting(Path.BeanNode::getTypeArgumentIndex, factory);
         }
     }
 
@@ -165,17 +148,33 @@ abstract static class AbstractConstructorNodeAssert<SELF extends AbstractConstru
         }
 
         @Override
-        public AbstractIterableAssert<?, ?, ? super Class<?>, ?> extractingParameterTypes4() {
-            return extracting(
-                    Path.ConstructorNode::getParameterTypes, InstanceOfAssertFactories.list(Class.class)
-            );
+        public <ASSERT extends AbstractListAssert<?, List<Class<?>>, Class<?>, ? extends AbstractClassAssert<?>>>
+        ASSERT extractingParameterTypes(final AssertFactory<? super List<Class<?>>, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.ConstructorNode::getParameterTypes, factory);
+        }
+    }
+
+    abstract static class AbstractContainerElementNodeAssert<SELF extends AbstractContainerElementNodeAssert<SELF>>
+            extends _AbstractNodeAssert<SELF, Path.ContainerElementNode>
+            implements ContainerElementNodeAssert<SELF> {
+
+        AbstractContainerElementNodeAssert(final Path.ContainerElementNode actual, final Class<?> selfType) {
+            super(actual, selfType);
+        }
+
+        @Override
+        public <ASSERT extends AbstractClassAssert<? extends ASSERT>> ASSERT extractingContainerClass(
+                final AssertFactory<? super Class<?>, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.ContainerElementNode::getContainerClass, factory);
         }
 
         @Override
-        public ListAssert<? super Class<?>> extractingParameterTypes5() {
-            return extracting(
-                    Path.ConstructorNode::getParameterTypes, InstanceOfAssertFactories.list(Class.class)
-            );
+        public <ASSERT extends AbstractIntegerAssert<? extends ASSERT>> ASSERT extractingTypeArgumentIndex(
+                final AssertFactory<? super Integer, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.ContainerElementNode::getTypeArgumentIndex, factory);
         }
     }
 
@@ -197,20 +196,11 @@ protected AbstractMethodNodeAssert(final Path.MethodNode actual, Class<?> selfTy
             super(actual, selfType);
         }
 
-        @SuppressWarnings({"unchecked"})
-        public ListAssert<Class<?>> extractingParameterTypes() {
-            return (ListAssert<Class<?>>) (Object) isNotNull()
-                    .extracting(v -> ((Path.MethodNode) v).getParameterTypes(), Assertions::assertThat);
-        }
-
         @Override
-        public AbstractIterableAssert<?, ?, ? super Class<?>, ?> extractingParameterTypes4() {
-            return null;
-        }
-
-        @Override
-        public ListAssert<? super Class<?>> extractingParameterTypes5() {
-            return null;
+        public <ASSERT extends AbstractListAssert<?, List<Class<?>>, Class<?>, ? extends AbstractClassAssert<?>>>
+        ASSERT extractingParameterTypes(final AssertFactory<? super List<Class<?>>, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.MethodNode::getParameterTypes, factory);
         }
     }
 
@@ -222,45 +212,35 @@ protected AbstractParameterNodeAssert(final Path.ParameterNode actual, final Cla
             super(actual, selfType);
         }
 
-        public AbstractIntegerAssert<?> extractingParameterIndex() {
+        @Override
+        public <ASSERT extends AbstractIntegerAssert<? extends ASSERT>> ASSERT extractingParameterIndex(
+                final AssertFactory<? super Integer, ? extends ASSERT> factory) {
             return isNotNull()
-                    .extracting(
-                            v -> ((Path.ParameterNode) v).getParameterIndex(),
-                            InstanceOfAssertFactories.INTEGER
-                    );
-        }
-
-        /**
-         * Asserts that the {@link Path.ParameterNode#getParameterIndex() actual.parameterIndex} is equal to specified
-         * value.
-         *
-         * @param expectedParameterIndex the expected value of
-         *                               {@link Path.ParameterNode#getParameterIndex() actual.parameterIndex}.
-         * @return this assertion object.
-         */
-        public SELF hasParameterIndex(final int expectedParameterIndex) {
-            extractingParameterIndex().isEqualTo(expectedParameterIndex);
-            @SuppressWarnings({"unchecked"})
-            final SELF self = (SELF) myself;
-            return self;
+                    .extracting(Path.ParameterNode::getParameterIndex, factory);
         }
     }
 
     public abstract static class AbstractPropertyNodeAssert<SELF extends AbstractPropertyNodeAssert<SELF>>
             extends _AbstractNodeAssert<SELF, Path.PropertyNode>
             implements PropertyNodeAssert<SELF> {
 
-//        public static class DefaultPropertyNodeAssert
-//                extends AbstractPropertyNodeAssert<DefaultPropertyNodeAssert, Path.PropertyNode> {
-//
-//            public DefaultPropertyNodeAssert(final Path.PropertyNode actual) {
-//                super(actual, DefaultPropertyNodeAssert.class);
-//            }
-//        }
-
         protected AbstractPropertyNodeAssert(final Path.PropertyNode actual, final Class<?> selfType) {
             super(actual, selfType);
         }
+
+        @Override
+        public <ASSERT extends AbstractClassAssert<? extends ASSERT>> ASSERT extractingContainerClass(
+                final AssertFactory<? super Class<?>, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.PropertyNode::getContainerClass, factory);
+        }
+
+        @Override
+        public <ASSERT extends AbstractIntegerAssert<? extends ASSERT>> ASSERT extractingTypeArgumentIndex(
+                final AssertFactory<? super Integer, ? extends ASSERT> factory) {
+            return isNotNull()
+                    .extracting(Path.PropertyNode::getTypeArgumentIndex, factory);
+        }
     }
 
     public abstract static class AbstractReturnValueNodeAssert<SELF extends AbstractReturnValueNodeAssert<SELF>>
@@ -280,7 +260,72 @@ protected AbstractReturnValueNodeAssert(final Path.ReturnValueNode actual, final
         }
     }
 
+    // -----------------------------------------------------------------------------------------------------------------
+    protected static Path.Node nodeAt(final Iterable<? extends Path.Node> iterable, final int index) {
+        Objects.requireNonNull(iterable, "iterable is null");
+        if (index < 0) {
+            throw new IllegalArgumentException("negative index: " + index);
+        }
+        final Iterator<? extends Path.Node> iterator = iterable.iterator();
+        Path.Node node = iterator.next(); // NoSuchElementException
+        for (int i = 1; i < index; i++) {
+            node = iterator.next(); // NoSuchElementException
+        }
+        return node;
+    }
+
+    protected static <N extends Path.Node> N nodeAt(final Iterable<? extends Path.Node> iterable, final int index,
+                                                    final Class<N> nodeType) {
+        final Path.Node node = nodeAt(iterable, index);
+        if (nodeType == Path.Node.class) {
+            @SuppressWarnings({"unchecked"})
+            final N casted = (N) node;
+            return casted;
+        }
+        return node.as(nodeType);
+    }
+
     protected AbstractPathAssert(final Path actual, final Class<?> selfType) {
         super(actual, selfType);
     }
+
+    @Override
+    public <A extends _AbstractNodeAssert<? extends A, ? extends N>, N extends Path.Node> A extractingNode(
+            final int index, final Class<N> nodeType, final AssertFactory<? super N, ? extends A> factory) {
+        return isNotNull()
+                .extracting(a -> nodeAt(a, index, nodeType), factory);
+    }
+
+    @Override
+    public <A extends AbstractNodeAssert<? extends A>> A extractingNode(
+            final int index, final AssertFactory<? super Path.Node, ? extends A> factory) {
+        return extractingNode(index, Path.Node.class, factory);
+    }
+
+    @Override
+    public AbstractNodeAssert<?> extractingNode(final int index) {
+        return extractingNode(index, DefaultPathAssert.DefaultNodeAssert::new);
+    }
+
+    @Override
+    public <A extends AbstractBeanNodeAssert<? extends A>> A extractingBeanNode(
+            final int index, AssertFactory<? super Path.BeanNode, ? extends A> factory) {
+        return extractingNode(index, Path.BeanNode.class, factory);
+    }
+
+    @Override
+    public AbstractBeanNodeAssert<?> extractingBeanNode(final int index) {
+        return extractingBeanNode(index, DefaultPathAssert.DefaultNodeAssert.DefaultBeanNodeAssert::new);
+    }
+
+    @Override
+    public <A extends AbstractPropertyNodeAssert<? extends A>> A extractingPropertyNode(
+            final int index, AssertFactory<? super Path.PropertyNode, ? extends A> factory) {
+        return extractingNode(index, Path.PropertyNode.class, factory);
+    }
+
+    @Override
+    public AbstractPropertyNodeAssert<?> extractingPropertyNode(final int index) {
+        return extractingPropertyNode(index, DefaultPathAssert.DefaultNodeAssert.DefaultPropertyNodeAssert::new);
+    }
 }

src/main/java/com/github/jinahya/assertj/validation/AssertFactories.java

@@ -0,0 +1,18 @@
+package com.github.jinahya.assertj.validation;
+
+final class AssertFactories {
+
+//    public static <NODE extends Path.Node, ASSERT extends PathAssert.NodeAssert<? extends ASSERT, NODE>> ASSERT nodeAssert(
+//            final Class<NODE> nodeType, final AssertFactory<? super NODE, ? extends ASSERT> factory) {
+//        return null;
+//    }
+//
+//    public static <NODE extends Path.Node, ASSERT extends PathAssert.NodeAssert<? extends ASSERT, NODE>> InstanceOfAssertFactory<NODE, ASSERT> nodeAssert(
+//            final Class<NODE> nodeType, final AssertFactory<? super NODE, ? extends ASSERT> factory) {
+//        return null;
+//    }
+
+    private AssertFactories() {
+        throw new AssertionError("instantiation is not allowed");
+    }
+}

src/main/java/com/github/jinahya/assertj/validation/BeanConditions.java

@@ -0,0 +1,49 @@
+package com.github.jinahya.assertj.validation;
+
+/*-
+ * #%L
+ * assertj-bean-validation-javax
+ * %%
+ * Copyright (C) 2021 - 2022 Jinahya, Inc.
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+import org.assertj.core.api.Condition;
+
+import static com.github.jinahya.assertj.validation.ValidationAssertions.assertThatBean;
+
+/**
+ * Conditions for beans.
+ *
+ * @author Jin Kwon <onacit_at_gmail.com>
+ */
+final class BeanConditions {
+
+    public static final Condition<Object> valid = new Condition<Object>() {
+        @Override
+        public boolean matches(final Object value) {
+            try {
+                assertThatBean(value).isValid();
+                return true;
+            } catch (final AssertionError ae) {
+            }
+            return false;
+        }
+    };
+
+    private BeanConditions() {
+        throw new AssertionError("instantiation is not allowed");
+    }
+}

src/main/java/com/github/jinahya/assertj/validation/DefaultPathAssert.java

@@ -28,10 +28,10 @@
  *
  * @author Jin Kwon <onacit_at_gmail.com>
  */
-class DefaultPathAssert
+public class DefaultPathAssert
         extends AbstractPathAssert<DefaultPathAssert, DefaultPathAssert.DefaultNodeAssert> {
 
-    static class DefaultNodeAssert
+    public static class DefaultNodeAssert
             extends AbstractNodeAssert<DefaultNodeAssert> {
 
         static class DefaultBeanNodeAssert
@@ -43,7 +43,7 @@ static class DefaultBeanNodeAssert
         }
 
         static class DefaultParameterizedNodeAssert
-                extends AbstractParameterizedNodeAssert<DefaultParameterizedNodeAssert> {
+                extends AbstractParameterNodeAssert<DefaultParameterizedNodeAssert> {
 
             DefaultParameterizedNodeAssert(final Path.ParameterNode actual, final Class<?> selfType) {
                 super(actual, selfType);
@@ -82,6 +82,14 @@ static class DefaultParameterNodeAssert
             }
         }
 
+        public static class DefaultPropertyNodeAssert
+                extends AbstractPropertyNodeAssert<DefaultPropertyNodeAssert> {
+
+            DefaultPropertyNodeAssert(final Path.PropertyNode actual) {
+                super(actual, DefaultPropertyNodeAssert.class);
+            }
+        }
+
         // -------------------------------------------------------------------------------------------------------------
         DefaultNodeAssert(final Path.Node actual) {
             super(actual, DefaultNodeAssert.class);