Added containsType and getChildrenOfType methods to CollectionProvider.

api/src/main/groovy/com/jessebrault/ssg/provider/AbstractCollectionProvider.groovy

@@ -40,6 +40,29 @@ abstract class AbstractCollectionProvider<T> implements CollectionProvider<T> {
         collectionProvider in this
     }
 
+    @Override
+    <C extends CollectionProvider<T>> boolean containsType(Class<C> childCollectionProviderClass) {
+        if (childCollectionProviderClass.isAssignableFrom(this.class)) {
+            true
+        } else {
+            this.collectionProviderChildren.inject(false) { acc, childProvider ->
+                acc || childCollectionProviderClass.isAssignableFrom(childProvider.class)
+                        || childProvider.containsType(childCollectionProviderClass)
+            }
+        }
+    }
+
+    @Override
+    <C extends CollectionProvider<T>> Collection<C> getChildrenOfType(Class<C> childCollectionProviderClass) {
+        this.collectionProviderChildren.inject([] as Collection<C>) { acc, childProvider ->
+            if (childCollectionProviderClass.isAssignableFrom(childProvider.class)) {
+                acc + childProvider.getChildrenOfType(childCollectionProviderClass) + (childProvider as C)
+            } else {
+                acc + childProvider.getChildrenOfType(childCollectionProviderClass)
+            }
+        }
+    }
+
     @Override
     CollectionProvider<T> plus(Provider<T> other) {
         concat(this, other)
@@ -50,11 +73,24 @@ abstract class AbstractCollectionProvider<T> implements CollectionProvider<T> {
         concat(this, other)
     }
 
+    private boolean searchProviderChildrenFor(Provider<T> descendant) {
+        this.providerChildren.inject(false) { acc, childProvider ->
+            acc || descendant in childProvider
+        }
+    }
+
+    private boolean searchCollectionProviderChildrenFor(Provider<T> descendant) {
+        this.collectionProviderChildren.inject(false) { acc, childProvider ->
+            acc || descendant in childProvider
+        }
+    }
+
     @Override
     boolean isCase(Provider<T> provider) {
-        provider in this.providerChildren || this.providerChildren.inject(false) { acc, childProvider ->
+        provider in this.providerChildren
-            acc || provider in childProvider
+                || this.searchProviderChildrenFor(provider)
-        }
+                || this.searchCollectionProviderChildrenFor(provider)
+
     }
 
     @Override

api/src/main/groovy/com/jessebrault/ssg/provider/AbstractProvider.groovy

@@ -6,16 +6,30 @@ abstract class AbstractProvider<T> implements Provider<T> {
             Provider<T> p0,
             Provider<T> p1
     ) {
-        new SupplierBasedCollectionProvider<>({
+        new SupplierBasedCollectionProvider<>([], [p0, p1], {
             [p0.provide(), p1.provide()]
         })
     }
 
+    static <T> CollectionProvider<T> concat(
+            Provider<T> p0,
+            CollectionProvider<T> p1
+    ) {
+        new SupplierBasedCollectionProvider<>([p1], [p0], {
+            [p0.provide(), *p1.provide()]
+        })
+    }
+
     @Override
     CollectionProvider<T> plus(Provider<T> other) {
         concat(this, other)
     }
 
+    @Override
+    CollectionProvider<T> plus(CollectionProvider<T> other) {
+        concat(this, other)
+    }
+
     @Override
     CollectionProvider<T> asType(Class<CollectionProvider> collectionProviderClass) {
         new SupplierBasedCollectionProvider<>({

api/src/main/groovy/com/jessebrault/ssg/provider/CollectionProvider.groovy

@@ -1,14 +0,0 @@
-package com.jessebrault.ssg.provider
-
-interface CollectionProvider<T> {
-    Collection<T> provide()
-
-    boolean contains(Provider<T> provider)
-    boolean contains(CollectionProvider<T> collectionProvider)
-
-    CollectionProvider<T> plus(Provider<T> other)
-    CollectionProvider<T> plus(CollectionProvider<T> other)
-
-    boolean isCase(Provider<T> provider)
-    boolean isCase(CollectionProvider<T> collectionProvider)
-}

api/src/main/groovy/com/jessebrault/ssg/provider/CollectionProvider.java

@@ -0,0 +1,19 @@
+package com.jessebrault.ssg.provider;
+
+import java.util.Collection;
+
+public interface CollectionProvider<T> {
+    Collection<T> provide();
+
+    boolean contains(Provider<T> provider);
+    boolean contains(CollectionProvider<T> collectionProvider);
+
+    <C extends CollectionProvider<T>> boolean containsType(Class<C> childCollectionProviderClass);
+    <C extends CollectionProvider<T>> Collection<C> getChildrenOfType(Class<C> childCollectionProviderClass);
+
+    CollectionProvider<T> plus(Provider<T> other);
+    CollectionProvider<T> plus(CollectionProvider<T> other);
+
+    boolean isCase(Provider<T> provider);
+    boolean isCase(CollectionProvider<T> collectionProvider);
+}

api/src/main/groovy/com/jessebrault/ssg/provider/CollectionProviders.groovy

@@ -19,7 +19,7 @@ final class CollectionProviders {
         new SupplierBasedCollectionProvider<>(supplier)
     }
 
-    static <T> CollectionProvider<T> fromDirectory(
+    static <T> DirectoryCollectionProvider<T> fromDirectory(
             File baseDirectory,
             BiFunction<File, String, @Nullable T> elementFunction
     ) {

api/src/main/groovy/com/jessebrault/ssg/provider/DirectoryCollectionProvider.java

@@ -0,0 +1,11 @@
+package com.jessebrault.ssg.provider;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.util.function.BiFunction;
+
+public interface DirectoryCollectionProvider<T> extends CollectionProvider<T> {
+    File getBaseDirectory();
+    BiFunction<File, String, @Nullable T> getMapper();
+}

api/src/main/groovy/com/jessebrault/ssg/provider/EmptyProvider.groovy

@@ -14,6 +14,13 @@ final class EmptyProvider<T> implements Provider<T> {
         throw new NullPointerException('EmptyProvider cannot provide a value.')
     }
 
+    @Override
+    CollectionProvider<T> plus(CollectionProvider<T> other) {
+        CollectionProviders.fromSupplier {
+            other.provide()
+        }
+    }
+
     @Override
     CollectionProvider<T> plus(Provider<T> other) {
         CollectionProviders.fromSupplier {

api/src/main/groovy/com/jessebrault/ssg/provider/FileBasedCollectionProvider.groovy

@@ -14,7 +14,7 @@ import java.util.function.BiFunction
 @PackageScope
 @NullCheck
 @EqualsAndHashCode(includeFields = true, callSuper = true)
-final class FileBasedCollectionProvider<T> extends AbstractCollectionProvider<T> {
+final class FileBasedCollectionProvider<T> extends AbstractCollectionProvider<T> implements DirectoryCollectionProvider<T> {
 
     private static final Logger logger = LoggerFactory.getLogger(FileBasedCollectionProvider)
 
@@ -27,6 +27,16 @@ final class FileBasedCollectionProvider<T> extends AbstractCollectionProvider<T>
         this.elementFunction = elementFunction
     }
 
+    @Override
+    File getBaseDirectory() {
+        this.baseDirectory
+    }
+
+    @Override
+    BiFunction<File, String, T> getMapper() {
+        this.elementFunction
+    }
+
     @Override
     Collection<T> provide() {
         if (!this.baseDirectory.isDirectory()) {

api/src/main/groovy/com/jessebrault/ssg/provider/Provider.groovy

@@ -3,5 +3,6 @@ package com.jessebrault.ssg.provider
 interface Provider<T> {
     T provide()
     CollectionProvider<T> plus(Provider<T> other)
+    CollectionProvider<T> plus(CollectionProvider<T> other)
     CollectionProvider<T> asType(Class<CollectionProvider> collectionProviderClass)
 }

api/src/test/groovy/com/jessebrault/ssg/provider/FileBasedCollectionProviderTests.groovy

@@ -1,5 +1,9 @@
 package com.jessebrault.ssg.provider
 
+import org.junit.jupiter.api.Test
+
+import static org.junit.jupiter.api.Assertions.assertTrue
+
 final class FileBasedCollectionProviderTests extends AbstractCollectionProviderTests {
 
     @Override
@@ -18,4 +22,10 @@ final class FileBasedCollectionProviderTests extends AbstractCollectionProviderT
         })
     }
 
+    @Test
+    void containsSelfType() {
+        def p = new FileBasedCollectionProvider<String>(new File(''), { f -> '' })
+        assertTrue(p.containsType(DirectoryCollectionProvider))
+    }
+
 }

api/src/testFixtures/groovy/com/jessebrault/ssg/provider/AbstractCollectionProviderTests.groovy

@@ -3,17 +3,28 @@ package com.jessebrault.ssg.provider
 import org.junit.jupiter.api.DynamicTest
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestFactory
+import org.mockito.Answers
+import org.mockito.Mockito
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
 
 import java.util.function.Consumer
 
+import static org.junit.jupiter.api.Assertions.assertEquals
 import static org.junit.jupiter.api.Assertions.assertTrue
+import static org.mockito.ArgumentMatchers.any
+import static org.mockito.Mockito.mock
+import static org.mockito.Mockito.when
 
 abstract class AbstractCollectionProviderTests {
 
     protected static final Logger logger = LoggerFactory.getLogger(AbstractCollectionProviderTests)
 
+    @SuppressWarnings('GrMethodMayBeStatic')
+    protected Provider<Integer> getProvider(Integer t) {
+        Providers.of(t)
+    }
+
     protected abstract CollectionProvider<Integer> getCollectionProvider(Collection<Integer> ts)
 
     @Test
@@ -43,7 +54,6 @@ abstract class AbstractCollectionProviderTests {
         })
     }
 
-    @SuppressWarnings('GrMethodMayBeStatic')
     @TestFactory
     Collection<DynamicTest> containsAndIsCaseCollectionProviderChildren() {
         def p0 = this.getCollectionProvider([])
@@ -63,10 +73,9 @@ abstract class AbstractCollectionProviderTests {
         }
     }
 
-    @SuppressWarnings('GrMethodMayBeStatic')
     @TestFactory
     Collection<DynamicTest> containsAndIsCaseProviderChildren() {
-        def p0 = this.getCollectionProvider([])
+        def p0 = this.getProvider(0)
         def p1 = this.getCollectionProvider([])
         def sum = p0 + p1
         ([
@@ -83,4 +92,28 @@ abstract class AbstractCollectionProviderTests {
         }
     }
 
+    @Test
+    void containsDirectoryCollectionProvider() {
+        final CollectionProvider<Integer> dirProvider = CollectionProviders.fromDirectory(
+                new File(''),
+                { 0 }
+        )
+        final CollectionProvider<Integer> dummy = CollectionProviders.getEmpty()
+        def sum = dirProvider + dummy
+        assertTrue(sum.containsType(DirectoryCollectionProvider))
+    }
+
+    @Test
+    void getDirectoryCollectionProviderChild() {
+        final CollectionProvider<Integer> dirProvider = CollectionProviders.fromDirectory(
+                new File(''),
+                { 0 }
+        )
+        final CollectionProvider<Integer> dummy = CollectionProviders.getEmpty()
+        def sum = dirProvider + dummy
+        def children =
+                sum.<DirectoryCollectionProvider<Integer>>getChildrenOfType(DirectoryCollectionProvider)
+        assertTrue(dirProvider in children)
+    }
+
 }