Skip to content
CAI
Software that uses CAICheck a score

andrebaltieri/Flunt

37.7

Weak · 8 November 2026

7.5k

lines of production code

C#

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Flunt is a .NET validation library that provides a comprehensive set of tools for data validation and error handling. It enables developers to enforce business rules through a fluent API, covering common data types like emails, dates, and credit cards. The system also includes a notification mechanism to track and manage validation failures, supported by localized error messages and extensive unit tests.

Features

Added localization error messages and regex patterns for validation

The Flunt library now includes a new localization layer to provide user-friendly error messages for validation failures. This change introduces three new files: \FluntErrorMessages.cs\ defines the text for various validation states (e.g., email, URL, passport, credit card), \FluntFormats.cs\ sets default date/time formats, and \FluntRegexPatterns.cs\ contains the regular expressions used for validation, including a corrected URL pattern that now supports localhost addresses.

Flunt/Localization · high confidence

Expanded validation contract for multiple data types

The Flunt validation library now includes new validation contracts for boolean, credit card, date/time, decimal, double, email, float, GUID, integer, list, and passport values. Users can now enforce rules such as checking if a boolean is true or false, validating credit card numbers, ensuring dates fall within a specific range, verifying email formats, and checking if lists are null or empty. These additions provide a more comprehensive set of built-in validation methods for common data types.

Flunt/Validations · high confidence

Flunt v2 release with updated project structure and documentation

The Flunt library has been updated to version 2, introducing a new solution structure that includes the main Flunt library, a Flunt.Tests project for unit testing, and a Flunt.Samples project. The release includes a comprehensive README.md file detailing the library's purpose, installation instructions, and usage examples for .NET Standard 2.0. Additionally, the repository now features an MIT License and an updated .gitignore file that reflects the new project structure and excludes node\_modules and other build artifacts.

(repo-wide) · high confidence

New notification system for tracking validation errors

A new notification system has been introduced to the library, allowing objects to track and manage a collection of notifications (typically validation errors). The \Notifiable\<T\>\ base class provides methods to add single or multiple notifications, access the full list via the \Notifications\ property, and check validity via \IsValid\. A new \INotifiable\ interface and \Notification\ class are also included to support this pattern.

Flunt/Notifications · high confidence

Behavioural changes

Added customer and email validation contracts

Added new validation contracts for creating and updating customers, including a CreateCustomerContract that enforces a non-empty name, and an UpdateCustomerBirthDateContract that ensures the birth date is at least 18 years in the past. The Customer entity now uses these contracts to validate creation and updates, while the CreateCustomerRequest and Email value objects also incorporate validation contracts to ensure the name and email address are valid before processing.

Flunt.Samples, Flunt.Samples/Handlers/Requests · high confidence

Test coverage

Added unit tests for the SampleEnum enumeration; Added unit tests for validation methods.

Dependencies

Flunt library updated to v2 with .NET Standard 2.0 and new project structure

The Flunt library has been updated to version 2.0.5, targeting .NET Standard 2.0, which may require migration from previous versions due to breaking changes. The solution now includes a new sample project (Flunt.Samples) targeting .NET 5.0 and a test project (Flunt.Tests) targeting .NET 6.0 with updated test SDKs and frameworks. This reflects a structural shift in the repository, separating the core library, samples, and tests into distinct project files.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 39 → 38 (-1.5)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 76 → 76 (+0.0)
  • Architecture 100 → 100 (+0.0)
  • Maturity 43 → 38 (-4.3)
  • Readiness 48 → 51 (+2.7)
  • Security 23 → 20 (-2.9)
  • Performance 70 → 77 (+7.4)

Resolved (6)

  • Inconsistent test method naming conventions within the same test class. Some tests use 'Is...' (IsNullOrWhiteSpace, IsLowerThan), some use 'Not...' (NotContains), and one uses 'AreNotEqualsLen'. This lack of uniformity in how test behaviors are named (predicate vs action vs result) makes the test suite harder to scan and understand.
  • Inconsistent test method naming for equality/inequality assertions. Some tests use 'Require...AreNotEquals' (e.g., RequireTwoFloatsAreNotEquals) while others use 'RequiresDatesAreEquals' or 'RequiresDatesAreNotEquals'. The mix of 'Require' vs 'Requires' and 'AreEquals' vs 'AreNotEquals' (vs 'IsNotEqual') indicates a lack of consistent naming convention for test cases involving equality checks.
  • Inconsistent test naming style across different test classes. One test uses a descriptive sentence structure ('ShouldNotUpdateACustomerWithoutAnEmail') while others use short predicate names ('AreNotEquals', 'AreEquals'). This suggests a lack of global test naming convention.
  • Inconsistent verb usage for equality checks. The codebase uses 'Are' (plural) for equality comparisons (AreEquals, AreNotEquals) but switches to 'Is' (singular) for inequality/non-equality checks in other contexts (e.g., IsNotNull, IsLowerThan). While 'Are' is grammatically correct for comparing two values, the inconsistency with the broader 'Is...' predicate convention used for single-value validations (IsNull, IsEmpty, IsBetween) creates a fragmented API vocabulary.
  • Low XML-doc coverage: Flunt.Samples (Flunt.Samples/Flunt.Samples.csproj)
  • XML-doc coverage: Flunt (Flunt/Flunt.csproj)

Architecture

  • Unchanged — 1 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

andrebaltieri/Flunt was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 8 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 38f159b1fd48e5fab68d19b2f5f5eb2af7eafabf — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-45ab2cab63de.