0.1.6 🚀 The Processing Floor

🚀 The Processing Floor

The factory valves are open! This release expands Vanguard Brew from the espresso machine's internal state directly onto the industrial factory floor. We are introducing the Processing Suite to master Java Streams.

🏭 The Processing Suite (Java Streams)

Graduate from simple loops and master the modern Java Stream API. This suite takes you through the entire lifecycle of industrial data pipelines:

• Bean Sorter: Master the fundamental trinity of stream processing (filter, map, sorted) while enforcing domain-level data sanitization.
• Hopper Pipeline: Escape deeply nested data hierarchies and continuously feed the roasters using flatMap.
• Quality Control: Save CPU cycles and optimize performance using lazy, short-circuiting terminal operations (allMatch, anyMatch, findFirst).
• Blend Aggregator: Replace dozens of lines of boilerplate with elegant, heavy-duty analytics using advanced downstream Collectors (partitioningBy, groupingBy, summingInt).

Anti-Cheat Engaged: The factory floor tests are strict. Attempting to use a traditional for loop or .forEach() on the conveyor belt will immediately trigger the factory alarms!

---

🛠️ Sidenote: Printerface Upgrades Reading deeply nested data structures in the console just got a massive readability upgrade. We've overhauled the internal regex engine in Printerface so it now intelligently wraps long output lines based on whitespace and array brackets [ ]. No more mangled data—just exceptionally clean terminal output, no matter how complex your records get.

---

Stop looping around and start streamlining your factory floor. May your pipelines be pure and your coffee always flow! ☕🌊🚀

0.1.5 Pulling the perfect shot with the State Machine Suite

It is time to stop writing messy, brittle if-else chains and start engineering bulletproof, state-driven workflows!

This release introduces our biggest learning module yet: The State Machine Suite. We are taking developers from basic Enum transitions all the way to orchestrating commercial-grade, parallel-processing hardware using Java 25's most powerful pattern-matching features.

☕ What's Brewing? (The 4 New Katas)

• The Rookie Barista: A gentle introduction to state transitions. Learners will use modern switch expressions to map out a simple Enum-based lifecycle, catching invalid commands before the coffee spills.
• The Master Barista: We upgrade the architecture! Learners will use the modern State Pattern (Sealed Interfaces + Records) to pass physical context (like recipes) through the workflow, heavily utilizing when guard clauses to route Espresso and Cappuccino logic.
• Audit Log: Time to play detective! We introduce Event Sourcing, where developers must replay a historical list of events from a crashed machine to pinpoint the exact millisecond—and the exact event—that caused the failure.
• The Leviathan: The boss fight. A fully automated, dual-boiler espresso machine. Learners must construct an advanced state machine that handles Context-Aware transitions (checking physical inventory), Orthogonal States (brewing and steaming in parallel), and Hierarchical Overrides (the big red E-STOP button).

🧠 Modern Java Features Unlocked

By completing this suite, developers will master:

• Deeply nested Record Pattern Matching (e.g., case State.Active(BrewState.Idle b, var s)).
• Advanced when Guard Clauses to protect physical hardware and evaluate context.
• Orthogonal State Management (updating one parallel subsystem while perfectly preserving another).
• Enriching generic exceptions with precise, event-sourced diagnostic data.

🛠️ Framework Updates

• Added verifySameExceptionClassAndMessage to the Validators utility to rigorously test custom exception payloads without custom lambda boilerplate.

---

Barista's Note: This suite will take you from a Rookie spilling coffee on the counter, to a Master perfectly timing your milk steaming, to a forensic tech digging through an Audit Log to figure out exactly who broke the machine. Happy brewing! ☕🐙

0.1.4 Updates to framework and The Sealing Suite

🛠️ Framework & Base Test Upgrades

• Explicit Method Naming: We banished generic type confusion! Renaming the overloads to verifyBasicKata, verifyNoArgKata, verifyClass, and verifyException makes the test classes incredibly crisp and readable.
• Zero-Boilerplate Overloads: Added streamlined wrappers for verifyClass and verifyException so we no longer have to pass empty lambdas or repetitive verifiers.
• The Interface Extractor: Wrote the beautiful parentInterfaceForClass function into the base class, perfectly extracting implemented interfaces without hardcoding brittle array indexes.
• Nested Kata Domains: Shifted the architectural design so domain models (like Shape or Transaction) live as static components inside the Kata class, keeping the package namespace perfectly clean.
• The "Lazy Fall-Through" Catcher: We added a standardized test that passes null into our solvers. While a stubborn dev can manually throw an NPE to bypass it, it brilliantly catches the lazy if-else chains that accidentally fall through to default return values, gently nudging learners toward native switch expressions!

🛡️ The "Sealing" Suite (5 New Katas)

• Domain Gatekeeper: Learn to control the flow of an application by utilizing exhaustive pattern matching. You'll route user accounts through a system securely, proving to the compiler that a default case isn't even necessary.
• Architectural Inspector: Take an old, wide-open Vehicle inheritance tree and lock it down. You will decide exactly which classes get to be completely closed off (final), which are restricted (sealed), and which remain open for future extension (non-sealed).
• Functional Result: Say goodbye to throwing exceptions for expected business failures. You will model an elegant Algebraic Data Type (ADT) to represent operations that can only ever result in a concrete Success or Failure.
• Cascading Tree: Sealing isn't just for flat structures! You will navigate a multi-level hierarchy, carefully propagating structural access rules from a root Shape interface all the way down to concrete geometric data carriers.
• Guarded Vault: The boss-level pattern matching challenge. You will process financial transactions using a modern switch expression, leveraging Java 21's when keyword to apply inline business rules and guard clauses on the fly.

0.1.3 Constructing exceptional brews

🚀 Release Notes: The "Master Builder" Update

Welcome to the latest update of the Kata Training Framework! We have officially graduated from testing simple "Input -> Output" algorithms to engineering robust, enterprise-grade Java architectures.

Grab your hard hats, because the Construction Suite is officially live. 👷‍♀️👷‍♂️

---

🛠️ Framework Level-Up: BasicKataTestBase is now Unstoppable

Your test base has undergone a massive architectural overhaul. We are no longer bound to testing pure functions. With our newly overloaded verify methods, the framework can now test Time, State, and Explosions.

• Stateful Verification: We can now instantiate objects, mutate them over time using a Consumer<K>, and extract their final state using a Function<K, R>.
• Fail-Fast Exception Handling: Testing bad inputs? Just pass an Executable lambda to the new exception verify method. If it doesn't blow up exactly how we expect, the test fails.
• Zero Boilerplate: Thanks to the new doVerify funnel and the legendary Printerface, every single Kata—whether it returns a String or throws an IllegalArgumentException—prints exactly the same beautiful, standardized console logs.

---

🏗️ New Kata Suite: "Constructing"

The new keyword is a dangerous tool in the wrong hands. This suite teaches learners how to control object creation like senior architects. Some new katas are:

🏰 1. The Immutable Fortress (Builder Pattern)

Telescoping constructors with 10 parameters are officially banned! In this Kata, learners must lock down their class with a private constructor and force all instantiation through a fluent Builder. Miss a mandatory field? The framework will catch your IllegalStateException.

🛡️ 2. Compact Guardian (Java Records)

Boilerplate is out; Records are in. But what happens when your data carrier needs validation? Learners will use Java's sleek Compact Constructors to validate usernames and passwords before the Record is even allowed to exist.

⚔️ 3. The Caching Highlander (Static Factory Methods)

There can be only one. Sometimes, object creation is too expensive to repeat. Learners must bypass standard constructors entirely, implementing a getInstance() Static Factory Method that caches DatabaseConnection objects. If they ask for the same URL twice, our framework uses strict == memory reference checks to ensure they get the exact same object back.

0.1.2 First pour of Vanguard Brew

feat: first pour of Vanguard Brew ☕

The daily grind begins! Initializing the ultimate Java 25 kata collection.
This commit includes the core framework, the base test classes, and the
foundational collection suites. Perfect crema, zero linting errors.