Hierarchy path predicates

Author: ComputerDaddyGuy

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+---
+## [0.0.5] - Unreleased
+
+### Added
+- New path predicates: `hasParentMatching`, `hasAncestorMatching`, `hasDirectChildMatching`, `hasDescendantMatching`, `hasSiblingMatching`
+
 ---
 ## [0.0.4] - 2025-09-27
 

ROADMAP.md

@@ -21,7 +21,7 @@
 - [x] Option: Line extension (=additional text after the file name)
 
 ## To do
-- [ ] More `PathPredicates` functions!
+- [x] More `PathPredicates` functions!
 - [ ] Option: custom emojis
 
 ## Backlog / To analyze / To implement if requested

src/main/java/io/github/computerdaddyguy/jfiletreeprettyprinter/PathPredicateBuilder.java

@@ -158,4 +158,83 @@ public PathPredicateBuilder isFile() {
 		return pathTest(PathPredicates.isFile());
 	}
 
+	// ---------- Hierarchy ----------
+
+	/**
+	 * Adds a condition that tests the direct parent of the path.
+	 *
+	 * @param parentPredicate the predicate to apply on the direct parent
+	 * 
+	 * @return this builder for chaining
+	 * 
+	 * @see PathPredicates#hasParentMatching(Predicate)
+	 */
+	public PathPredicateBuilder hasParentMatching(Predicate<Path> parentPredicate) {
+		return pathTest(PathPredicates.hasParentMatching(parentPredicate));
+	}
+
+	/**
+	 * Adds a condition that tests all ancestors of the path (stopping at the first match).
+	 *
+	 * The condition is satisfied if the given {@code ancestorPredicate} evaluates 
+	 * to {@code true} for any ancestor in the {@link Path#getParent()} chain.
+	 * 
+	 * @param ancestorPredicate the predicate to apply on each ancestor
+	 * 
+	 * @return this builder for chaining
+	 * 
+	 * @see PathPredicates#hasAncestorMatching(Predicate)
+	 */
+	public PathPredicateBuilder hasAncestorMatching(Predicate<Path> ancestorPredicate) {
+		return pathTest(PathPredicates.hasAncestorMatching(ancestorPredicate));
+	}
+
+	/**
+	 * Adds a condition that tests the direct children of the path.
+	 *
+	 * The condition is satisfied if the given {@code childPredicate} evaluates
+	 * to {@code true} for at least one direct child of the tested path.
+	 * 
+	 * @param childPredicate the predicate to apply on each direct child
+	 * 
+	 * @return this builder for chaining
+	 * 
+	 * @see PathPredicates#hasDirectChildMatching(Predicate)
+	 */
+	public PathPredicateBuilder hasDirectChildMatching(Predicate<Path> childPredicate) {
+		return pathTest(PathPredicates.hasDirectChildMatching(childPredicate));
+	}
+
+	/**
+	 * Adds a condition that tests all descendants of the path (children at any depth).
+	 *
+	 * The condition is satisfied if the given {@code descendantPredicate} evaluates
+	 * to {@code true} for at least one descendant in the directory tree.
+	 * 
+	 * @param descendantPredicate the predicate to apply on each descendant
+	 * 
+	 * @return this builder for chaining
+	 * 
+	 * @see PathPredicates#hasDescendantMatching(Predicate)
+	 */
+	public PathPredicateBuilder hasDescendantMatching(Predicate<Path> descendantPredicate) {
+		return pathTest(PathPredicates.hasDescendantMatching(descendantPredicate));
+	}
+
+	/**
+	 * Adds a condition that tests the siblings of the path.
+	 *
+	 * The condition is satisfied if the given {@code siblingPredicate} evaluates
+	 * to {@code true} for at least one sibling of the tested path.
+	 * 
+	 * @param siblingPredicate the predicate to apply on each sibling
+	 * 
+	 * @return this builder for chaining
+	 * 
+	 * @see PathPredicates#hasSiblingMatching(Predicate)
+	 */
+	public PathPredicateBuilder hasSiblingMatching(Predicate<Path> siblingPredicate) {
+		return pathTest(PathPredicates.hasSiblingMatching(siblingPredicate));
+	}
+
 }

src/main/java/io/github/computerdaddyguy/jfiletreeprettyprinter/PathPredicates.java

@@ -1,6 +1,7 @@
 package io.github.computerdaddyguy.jfiletreeprettyprinter;
 
 import java.nio.file.Path;
+import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
 import org.jspecify.annotations.NullMarked;
@@ -118,4 +119,96 @@ public static Predicate<Path> isFile() {
 		return PathUtils::isFile;
 	}
 
+	// ---------- Hierarchy ----------
+
+	/**
+	 * Creates a predicate that evaluates the direct parent of a given path.
+	 * The returned predicate applies the provided {@code parentPredicate} to {@link Path#getParent()} of the tested path.
+	 * If tested path has no parent, the returned predicate will always return {@code false}.
+	 *
+	 * @param parentPredicate the predicate to apply on the parent path (must not be {@code null})
+	 * 
+	 * @return a predicate that returns {@code true} if the parent of the tested path matches the given predicate
+	 * 
+	 * @throws NullPointerException if {@code parentPredicate} is {@code null}
+	 */
+	public static Predicate<Path> hasParentMatching(Predicate<Path> parentPredicate) {
+		Objects.requireNonNull(parentPredicate, "parentPredicate is null");
+		return path -> PathUtils.hasParentMatching(path, parentPredicate);
+	}
+
+	/**
+	 * Creates a predicate that evaluates all ancestors of a given path.
+	 * <p>
+	 * The returned predicate applies the provided {@code ancestorPredicate}
+	 * to each parent in the chain obtained via successive calls to {@link Path#getParent()}.
+	 * If any ancestor matches, the predicate returns {@code true}.
+	 * <p>
+	 * If the tested path has no parent, the returned predicate always returns {@code false}.
+	 *
+	 * @param ancestorPredicate the predicate to apply on each ancestor path (must not be {@code null})
+	 * 
+	 * @return a predicate that returns {@code true} if any ancestor of the tested path matches the given predicate
+	 * 
+	 * @throws NullPointerException if {@code ancestorPredicate} is {@code null}
+	 */
+	public static Predicate<Path> hasAncestorMatching(Predicate<Path> ancestorPredicate) {
+		Objects.requireNonNull(ancestorPredicate, "ancestorPredicate is null");
+		return path -> PathUtils.hasAncestorMatching(path, ancestorPredicate);
+	}
+
+	/**
+	 * Creates a predicate that evaluates the direct children of a given path.
+	 * <p>
+	 * The returned predicate applies the provided {@code childPredicate} to each
+	 * direct child of the tested path. The predicate returns {@code true} if at least
+	 * one child matches. If the path is not a directory, the predicate always returns {@code false}.
+	 *
+	 * @param childPredicate the predicate to apply on each direct child
+	 * 
+	 * @return a predicate that returns {@code true} if at least one direct child matches
+	 * 
+	 * @throws NullPointerException if {@code childPredicate} is {@code null}
+	 */
+	public static Predicate<Path> hasDirectChildMatching(Predicate<Path> childPredicate) {
+		Objects.requireNonNull(childPredicate, "childPredicate is null");
+		return path -> PathUtils.hasDirectChildMatching(path, childPredicate);
+	}
+
+	/**
+	 * Creates a predicate that evaluates all descendants (children at any depth) of a given path.
+	 * <p>
+	 * The returned predicate applies the provided {@code descendantPredicate} recursively to each
+	 * child and sub-child. It returns {@code true} if at least one descendant matches.
+	 *
+	 * @param descendantPredicate the predicate to apply on each descendant
+	 * 
+	 * @return a predicate that returns {@code true} if at least one descendant matches
+	 * 
+	 * @throws NullPointerException if {@code descendantPredicate} is {@code null}
+	 */
+	public static Predicate<Path> hasDescendantMatching(Predicate<Path> descendantPredicate) {
+		Objects.requireNonNull(descendantPredicate, "descendantPredicate is null");
+		return path -> PathUtils.hasDescendantMatching(path, descendantPredicate);
+	}
+
+	/**
+	 * Creates a predicate that evaluates the siblings of a given path.
+	 * <p>
+	 * The returned predicate applies the provided {@code siblingPredicate} to each
+	 * sibling of the tested path (other files/directories in the same parent).
+	 * The predicate returns {@code true} if at least one sibling matches.
+	 * If the tested path has no parent, the predicate always returns {@code false}.
+	 *
+	 * @param siblingPredicate the predicate to apply on each sibling
+	 * 
+	 * @return a predicate that returns {@code true} if at least one sibling matches
+	 * 
+	 * @throws NullPointerException if {@code siblingPredicate} is {@code null}
+	 */
+	public static Predicate<Path> hasSiblingMatching(Predicate<Path> siblingPredicate) {
+		Objects.requireNonNull(siblingPredicate, "siblingPredicate is null");
+		return path -> PathUtils.hasSiblingMatching(path, siblingPredicate);
+	}
+
 }