SteveDunn/Vogen

Vogen is a .NET source generator library that simplifies the creation of immutable value objects, automatically generating boilerplate code for equality, serialization, and database mapping. It provides seamless integration with major .NET ecosystems, including Entity Framework Core, Dapper, and various JSON serializers, while enforcing best practices through built-in Roslyn analyzers. The system supports a wide range of underlying types and modern C\# features, ensuring type safety and validation across web, desktop, and microservices architectures.

46 changes.

This period focused on refactoring the Vogen source generator into a modular, interface-based architecture that supports granular configuration and automatic integration with various serialization and database mapping frameworks. The team removed legacy implementation code and significantly expanded the test suite, introducing comprehensive snapshot and integration tests to verify code generation, serialization, and conversion behaviors across multiple .NET versions.

33 changes.

This period focused on expanding test coverage for the Vogen source generator, particularly for serialization, casting, and validation logic. It also introduced numerous sample projects demonstrating integration with external libraries such as EF Core, MongoDB, Orleans, and various JSON serializers.

13 changes.

This period focused on broadening the project's example suite to cover new features like gRPC, Blazor, and XML serialization, while simultaneously adding comprehensive snapshot and unit tests for source generator behavior. The work also established the foundational structure for an AI-driven development team through the introduction of Squad templates and configuration files.

A new sample project, AotTrimmedSample, has been added to demonstrate using Vogen with System.Text.Json's source-generated serialization. This addresses the limitation where reflection and standard converters are unavailable in trimmed/AOT-compiled .NET applications. The sample shows how to use the generated VogenTypesFactory for serialization and deserialization, ensuring compatibility with AOT scenarios. The project configuration has also been updated to ignore this component completely during instrumentation.

samples/AotTrimmedSample · high confidence

A new Blazor example project has been added to the samples directory, providing a complete reference implementation of a Blazor Server application. The project includes the standard layout components (App, MainLayout, NavMenu), page components (Home, Counter, Weather, Error, NotFound), and the necessary CSS and JavaScript to support interactive server-side rendering. The example demonstrates key Blazor features, including a weather forecast page that simulates asynchronous data loading and utilizes value objects for type safety. It also includes a reconnect modal to handle connection drops, showcasing how the framework manages reconnection states and user feedback during network interruptions.

samples/BlazorExample · high confidence

The samples/Onion/Infra area now includes new demonstration scenarios for serializing and deserializing value objects. EfCoreScenario.cs introduces a new example of configuring Entity Framework Core value converters for Vogen-generated types, utilizing marker classes to register converters via ConfigureConventions. Additionally, SystemTextJsonSourceGenerationScenario\_UsingTypesFromTheDomainLayer.cs and SystemTextJsonSourceGenerationScenario\_UsingTypesInThisLayer.cs provide examples of using System.Text.Json serialization, covering both external domain types and locally generated types with custom type factories.

samples/Onion/Infra · medium confidence

A new sample project under samples/Vogen.Examples/SerializationAndConversion/EFCore demonstrates how to use value objects with Entity Framework Core. The addition includes a DbContext configuration that applies Vogen's EF Core value converters to entity properties, a custom ID value generator, and a PersonEntity model using required properties for non-nullable value objects. This provides a concrete example of integrating Vogen with EF Core's persistence layer.

samples/Vogen.Examples/SerializationAndConversion/EFCore · high confidence

Added two new example files demonstrating how to serialize and deserialize Vogen value objects using the MessagePack library. The first example shows serialization using conversion attributes, while the second demonstrates serialization using custom markers. Both examples include a Person class with required properties for Id, Name, and Age, illustrating practical usage patterns for MessagePack integration.

samples/Vogen.Examples/SerializationAndConversion/MessagePack · high confidence

A new example scenario demonstrates serializing and deserializing Value Objects to and from MongoDB using the official MongoDB.Bson library. The sample includes a Person class with required Name and Age properties, along with a custom BsonVogenSerializer to handle the conversion. The scenario is configured to run only in local or Linux environments and utilizes Testcontainers to spin up a temporary MongoDB instance for testing.

samples/Vogen.Examples/SerializationAndConversion/Mongo · high confidence

A new sample project, OrleansExample, has been added to showcase the integration of Vogen value objects with the Microsoft Orleans framework. This includes a URL shortener implementation using Orleans grains, a CustomUrl value object for validation, and supporting files like the HTTP test file and configuration settings.

samples/OrleansExample · high confidence

A new sample application has been added to the WebApplicationConsumer/RefitExample directory, featuring a RefitRunner that demonstrates how to consume a REST API using the Refit library. The example showcases calling endpoints for retrieving weather forecasts by city, using URL parameters, and fetching historical data, providing a practical reference for integrating Refit in a .NET web application.

samples/WebApplicationConsumer/RefitExample · medium confidence

The WebApplication sample project now includes a complete example of using value objects in a web API, including controllers, models, and configuration for generating OpenAPI schemas. The sample supports multiple OpenAPI tooling stacks—Swashbuckle (for .NET 8 and .NET 10) and Microsoft OpenAPI with Scalar (.NET 9)—allowing users to switch between them via the OpenApiMode MSBuild property. The project also includes launch settings, HTTP test files, and diagnostic helpers to demonstrate how value objects are mapped to appropriate OpenAPI types (e.g., string, number, char) in the generated API documentation.

samples/WebApplication · high confidence

A new sample project, WebApplicationConsumer, has been added to demonstrate the library's usage with ServiceStack.Text and Refit. The sample includes a Program entry point, example runner classes, and value object type definitions to showcase how the library integrates with these specific libraries.

samples/WebApplicationConsumer · high confidence

A new example file demonstrates how to serialize and deserialize value objects using both the standard XmlSerializer and the DataContractSerializer. The example shows that classes are used instead of structs to work around known deserialization issues, and illustrates the use of attributes like \[DataContract\], \[DataMember\], and \[IgnoreDataMember\] to customize the XML output.

samples/Vogen.Examples/SerializationAndConversion/Xml · medium confidence

The Vogen analyzer suite gains new code fixers that automatically refactor C\# code: structs can be made readonly, missing input normalization and validation methods can be added to types, and existing methods can be made static or have their input types corrected. These changes allow developers to resolve diagnostics with one click, ensuring structs are immutable, inputs are sanitized, and validation logic is properly structured.

src/Vogen.CodeFixers · high confidence

The samples/Onion/Domain project now includes a complete set of domain entities and value objects, including Age, CustomerId, CustomerName, Department, EmployeeEntity, Id, HireDate, Name, Order, and OrderId. These files establish the domain layer's structure for the sample application, utilizing the Vogen library for value object implementation and configuring System.Text.Json serialization.

samples/Onion/Domain · high confidence

A new gRPC scenario has been added to the Vogen examples, demonstrating how to serialize and deserialize value objects over gRPC using protobuf-net. The example implements a simple server and client that exchange a Person object containing wrapped types (Name, Age, BoxId, Temperature) via a generic VogenSurrogate, showing that value objects can be seamlessly integrated into gRPC services.

samples/Vogen.Examples/SerializationAndConversion/Grpc · high confidence

Added new example files demonstrating value object integration with Dapper, LinqToDB, and ServiceStack.Text, alongside a comprehensive IConvertible support example. The IConvertible example shows how value objects can now implement the IConvertible interface, enabling dynamic type conversions via Convert.ChangeType and specific conversion methods. The Dapper and LinqToDB examples illustrate database mapping scenarios, while the ServiceStack example demonstrates JSON serialization with that library alongside Newtonsoft.Json and System.Text.Json.

samples/Vogen.Examples/SerializationAndConversion · medium confidence

Added sample value object definitions for int, float, string, and DateTimeOffset underlying types, each demonstrating various conversion configurations such as TypeConverter, Newtonsoft.Json, System.Text.Json, EF Core, Dapper, and LinqToDb. The FloatVo example also includes a custom IConvertible.ToInt32 implementation to show how user-defined methods are respected by the generator.

samples/Vogen.Examples/Types · high confidence

The Blazor example project now includes the Bootstrap 5.3.3 grid system CSS (bootstrap-grid.css and its source map). This provides standard CSS classes for responsive layouts, including container widths, row/column structures, and utility classes for spacing and display, enabling the sample application to use Bootstrap's grid system for its UI.

samples/BlazorExample/wwwroot · high confidence

A new SVG asset, cavey.svg, has been added to the assets folder. This file provides a high-quality vector graphic used for the project's social preview image, ensuring consistent branding across shared links and social media platforms.

assets · high confidence

Added templates for Dapper, LinqToDB, Newtonsoft.Json, System.Text.Json, and TypeConverter implementations for Boolean, Byte, Char, DateOnly, DateTime, DateTimeOffset, and AnyOtherType. This enables seamless serialization and database mapping for these specific value types within the Vogen library.

src/Vogen/Templates · high confidence

The samples/Vogen.Examples/SyntaxExamples directory now includes new example files demonstrating Value Object usage: CanHaveOtherMethods.cs shows a Duration struct with a validation method; Nesting.cs illustrates namespace nesting rules; NoDefaulting.cs demonstrates restrictions on default construction; and NoUserDefinedConstructors.cs enforces the use of the From method over constructors. Additionally, the previous StringlyTyped.Examples/Program.cs was renamed to ReadOnlyStructs.cs to better reflect its content.

samples/Vogen.Examples/SyntaxExamples · medium confidence

Added a new set of extension methods in the Vogen.Extensions namespace to support code analysis and refactoring. This includes helpers for inspecting attribute constructor parameters, identifying method overrides (such as Equals, GetHashCode, ToString, and Finalizer), checking for specific interface implementations, and determining if a type targets .NET Framework. These utilities enable the analyzer to more accurately detect patterns like multiple partial EF Core markers and explicitly specified constructor arguments in attributes.

src/Vogen/Extensions · medium confidence

The Vogen library now centralizes all diagnostic rule identifiers and their corresponding message templates in dedicated files. This includes a new \DiagnosticsCatalogue\ that maps each VOG error code (VOG001–VOG040) to specific error messages and a \RuleCategories\ class that defines the classification of each rule (e.g., Design, Naming, Security). This change provides a single source of truth for all analyzer and code-fixer diagnostics, ensuring consistent error reporting and easier maintenance of the diagnostic suite.

src/Vogen/Diagnostics · high confidence

Added new sample code demonstrating basic value object creation, equality and casting, GUID generation, instance creation, normalization, nullable reference types, static abstracts, and interface usage. Moved the validation example from the StringlyTyped.Examples project to the Vogen.Examples.TypicalScenarios namespace.

samples/Vogen.Examples/TypicalScenarios · high confidence

The \.squad\ directory has been initialized with the complete Squad AI team framework. This includes the team roster, agent charters, and routing rules that define how work is distributed among the Lead, Backend, Frontend, and Tester roles. Additionally, a set of Markdown and JSON templates (e.g., \casting-policy.json\, \mcp-config.md\, \run-output.md\) are provided to standardize how the team operates, makes decisions, and logs sessions. This establishes the foundational structure for the AI team's collaboration and memory.

.squad · high confidence

The Vogen.Examples project now features a centralized entry point (Program.cs) that automatically discovers and executes all classes implementing the new IScenario interface, providing a consistent way to run each example. Additionally, a ModuleInitializer has been added to configure global defaults for static abstracts generation, conversions (including Bson), and Dapper type handlers, ensuring that all examples run with the correct Vogen and serialization settings out of the box.

samples/Vogen.Examples · high confidence

The codebase now includes new internal classes—EscapedSymbolFullName, EscapedSymbolName, EscapedSymbolNames, Filename, and ProjectName—to encapsulate the logic for generating safe, escaped identifiers and filenames. Specifically, ProjectName normalizes the MSBuild RootNamespace or assembly name by replacing special characters with underscores and ensuring identifiers do not start with digits, while the EscapedSymbol\* classes manage the full and short names of type symbols. These changes support more robust generation of C\# identifiers and file names within the Vogen library.

src/Vogen/Types · medium confidence

The Vogen library introduces a suite of new Roslyn analyzers in the \src/Vogen/Rules\ directory to enforce best practices for value objects. These include preventing the use of \new\ or \default\ for construction, blocking reflection-based instantiation, and ensuring that validation and normalization methods are static and correctly typed. Additional rules warn about uninitialized properties, improper comparisons in EF Core expressions, and the use of \GetValueOrDefault\ on nullable value objects. These changes guide developers toward safer, more robust value object implementations.

src/Vogen/Rules · high confidence

The ExampleExtensions sample now demonstrates how to create nullable value objects using the new FromNullable method. This allows for safe handling of null inputs by returning a null result rather than throwing an exception, with specific extension methods provided for both struct and class-based value objects.

samples/ExampleExtensions · high confidence

The Vogen source generator has been refactored to use new internal classes for building configuration from attributes and discovering marker classes for serialization and schema generation. This change introduces \BuildConfigurationFromAttributes\ to handle global and local configuration merging, and \ConversionMarkers\ to detect and validate markers for EF Core, MessagePack, BSON, and OpenAPI. The generator now processes these markers to automatically generate necessary converters and schema filters when the respective libraries are referenced, ensuring that value objects integrate seamlessly with these ecosystems without manual setup.

src/Vogen · high confidence

The legacy source generator implementation has been removed from the Vogen.Generator project. This includes the deletion of the \ValueObjectGenerator\ class, the \ValueObjectReceiver\ syntax receiver, and all associated generator classes (\ClassGeneratorForReferenceType\, \ClassGeneratorForValueType\, \StructGeneratorForValueAndReferenceTypes\) and their supporting utilities (\Util.cs\, \ValueObjectWorkItem.cs\). Additionally, the \Diagnostics\ folder containing \DiagnosticCode.cs\, \DiagnosticCollection.cs\, and \ValueObjectReceiver.cs\ has been removed entirely. This change eliminates the previous code-generation logic, likely in favor of a new implementation not present in this diff.

src/Vogen.Generator · high confidence

The legacy source generator implementation has been removed. This includes the main \ValueObjectGenerator\ class and its associated generator components (\ClassGeneratorForReferenceType\, \ClassGeneratorForValueType\, \StructGeneratorForValueAndReferenceTypes\) as well as the \IGenerateSourceCode\ interface and \Util\ helper class. Additionally, example files (\BasicExample.cs\, \RepresentingNullObject.cs\) from the \samples/StringlyTyped.Examples\ directory have been deleted.

samples/StringlyTyped.Examples, src/generators · high confidence

The codebase for generating type conversions has been restructured to use a new \IGenerateConversion\ interface, with each conversion type (such as EF Core, Dapper, Newtonsoft.Json, and System.Text.Json) now handled by its own dedicated generator class. This change improves code organization and clarity by separating the logic for each conversion strategy into distinct, testable components, making it easier to maintain and extend the library's support for various serialization and database mapping frameworks.

src/Vogen/Generators/Conversions · high confidence

Added new Roslyn diagnostic suppressors to silence specific warnings on Vogen value objects. The new files implement suppressors for CA1036 (implement IComparable), CA1822 (non-essential instance methods like Validate and NormalizeInput), and Sonar S1210 (implementing IComparable). These suppressors target types decorated with \[ValueObjectAttribute\], ensuring that the library's design choices do not trigger common code analysis warnings.

src/Vogen/Suppressors · high confidence

The Vogen.SharedTypes library has been significantly refactored to support granular control over code generation. A new set of configuration enums (e.g., Conversions, Customizations, DeserializationStrictness) and attributes (e.g., ValueObjectAttribute\<T\>) now allow users to specify exactly which features to generate, such as numeric interfaces (INumber\<T\>), OpenAPI schema filters, and various serialization converters (BSON, MessagePack, Orleans). Additionally, the Validation class now supports attaching arbitrary data to validation errors, and the ValueObjectOrError type provides a safer way to handle validation failures without exceptions.

src/Vogen.SharedTypes · medium confidence

The Vogen library has refactored its source generation logic by introducing a new \IGenerateValueObjectSourceCode\ interface and four dedicated generator classes: \ClassGenerator\, \StructGenerator\, \RecordClassGenerator\, and \RecordStructGenerator\. This change restructures how the library generates code for value objects, separating the logic for standard classes/structs from record types, while maintaining support for features like validation, serialization, and EF Core integration within each specific generator.

src/Vogen/Generators · high confidence

The project introduces a new 'Consumers' solution (Consumers.sln) that groups all consumer projects, including end-to-end tests, sample applications, and benchmarks. A new Build.ps1 script orchestrates the build, test, and packaging process, utilizing a solution filter (Consumers.NoBenchmarks.slnf) to exclude benchmarks from the debug build. The Directory.Build.targets file is updated to support building against multiple Roslyn versions (4.4, 4.6, 4.8, 4.11, 4.12) and includes reproducible build settings. Additionally, a RunSnapshots.ps1 script is added to manage snapshot tests, and the .gitignore is updated to exclude generated files and local package folders.

(repo-wide) · high confidence

The sample application in samples/1MyProg has been updated to correctly utilize the RootNamespace build property for generating type names, resolving issue \#918. This ensures that generated types, such as the partial class MyId, are properly namespaced according to the project's root namespace configuration.

samples/1MyProg · medium confidence

The file previously located at tests/Vogen.Benchmarks/Benchmarks.cs has been renamed and moved to samples/MultiTarget/Types.cs. The content has been replaced with sample ValueObject definitions (Age and Name) for the MultiTarget sample, removing the previous BenchmarkDotNet benchmark implementations.

samples/MultiTarget · low confidence

Add unit tests for parsing, formatting, and value object initialization; Added 45 snapshot tests for various bug fixes; Added C\# analyzer and code-fix test verifiers; Added Testbench project for source generator debugging; Added consumer tests for value object serialization, creation, and behavior; Added integration tests for Bson, MessagePack, and System.Text.Json serialization; Added integration tests for record class value objects; Added integration tests for struct-based value objects; Added integration tests for various value object types and serialization formats; Added shared test infrastructure for multi-targeting; Added snapshot test for OpenAPI marker generation; Added snapshot test infrastructure and initial test cases; Added snapshot tests for Bson serialization generation; Added snapshot tests for EF Core generation; Added snapshot tests for OpenAPI and Swashbuckle schema generation; Added snapshot tests for Orleans serialization generation; Added snapshot tests for PolyType support; Added snapshot tests for System.Text.Json generation and deserialization strictness; Added snapshot tests for ToString generation; Added snapshot tests for casting and null-propagation behavior; Added snapshot tests for code generation scenarios; Added snapshot tests for conversion permutations; Added snapshot tests for escaped C\# keywords and namespaces; Added snapshot tests for global and local configuration options; Added snapshot tests for instance field generation; Added snapshot tests for internal diagnostics behavior; Added snapshot tests for primitive and string parsing behavior; Added snapshot tests for static abstracts generation; Added snapshot tests for string comparison generation; Added snapshot tests for value object generation permutations; Added tests for JSON deserialization of ValueObjects; Added tests for Vogen analyzer configuration; Added tests for deserialization validation across multiple serializers and ORMs; Added tests for generic deserialization validation; Added tests for implicit casting and normalization; Added tests for infinite loop behavior in IFormattable handling; Added tests for multiple new and existing analyzers; Added tests for string comparison behaviors; Added tests for value object generation and serialization edge cases; Added tests for value object instance fields and type definitions; Added tests for value object validation and exception handling; Added unit tests for ValueObject ToString behavior; Added unit tests for Vogen code generation and validation; Added unit tests for Vogen configuration merging and defaults; Added unit tests for serializing value objects as dictionary keys; Added unit tests for the ValidationMethodAnalyzer; Consolidated and expanded type-level tests in the ConsumerTests suite; Expanded test coverage for value object serialization and conversion; Removed unused test file for nested types; Snapshot tests for INumber generation across multiple numeric types; Snapshot tests for partial method modifiers; Updated Vogen benchmark tests to use generic ValueObject attributes; Updated benchmarks for NoValidation scenarios.

The Vogen test suite and sample projects have been upgraded to target .NET 10.0, with the benchmarking project also retargeted to .NET 10.0. This change includes updating various test dependencies such as xUnit, FluentAssertions, and Microsoft.NET.Test.Sdk, as well as updating the MinVer and DotNet.ReproducibleBuilds packages to versions 7.0.0 and 2.0.2 respectively. The Vogen.SharedTypes project has been updated to support .NET 10.0 and includes improvements to version stamping. Additionally, the old Vogen.Generator project has been removed, and new sample projects like BlazorExample and AotTrimmedSample have been added, reflecting the broader migration to .NET 10 and updated dependency versions across the solution.

(dependencies) · high confidence

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

• CAI 64 → 57 (-7.2)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 87 → 81 (-5.9)
• Architecture 99 → 100 (+0.2)
• Maturity 65 → 62 (-2.3)
• Readiness 62 → 46 (-15.1)
• Security 59 → 59 (-0.2)
• Performance 78 → 78 (-0.6)

• BarePragmaDisable (src/Vogen/Extensions/IEnumerableOfIMethodSymbolExtensions.cs)
• BarePragmaDisable (src/Vogen/Extensions/INamedTypeSymbolExtensions.cs)
• BarePragmaDisable (src/Vogen/Extensions/IPropertySymbolExtensions.cs)
• BarePragmaDisable (src/Vogen/Extensions/ISymbolExtensions.cs)
• BarePragmaDisable (src/Vogen/Extensions/ITypeSymbolExtensions.cs)
• BarePragmaDisable (src/Vogen/IndentedTextWriter.cs)
• BarePragmaDisable (src/Vogen/ObjectPool.cs)
• Bounded contexts not declared
• Build status unknown
• Change coupling: BuildWorkItems.cs ↔ GenerateCodeForCastingOperators.cs (src/Vogen/BuildWorkItems.cs)
• Change coupling: BuildWorkItems.cs ↔ ManageAttributes.cs (src/Vogen/BuildWorkItems.cs)
• Change coupling: GenerateCodeForBsonSerializers.cs ↔ GenerateCodeForOrleansSerializers.cs (src/Vogen/GenerateCodeForBsonSerializers.cs)
• Change coupling: GenerateCodeForEfCoreMarkers.cs ↔ GenerateCodeForMessagePack.cs (src/Vogen/GenerateCodeForEfCoreMarkers.cs)
• Change coupling: GenerateCodeForParse.cs ↔ GenerateCodeForTryParse.cs (src/Vogen/GenerateCodeForParse.cs)
• Change coupling: ManageAttributes.cs ↔ Templates.cs (src/Vogen/ManageAttributes.cs)
• CommentedOutCode (tests/SnapshotTests/Markers/OpenApiTests.cs)
• Duplicated block (11 lines × 2) (src/Vogen/Rules/DoNotUseNewAnalyzer.cs)
• Duplicated block (12 lines × 2) (src/Vogen/GenerateCodeForParse.cs)
• Duplicated block (12 lines × 2) (src/Vogen/Generators/ClassGenerator.cs)
• Duplicated block (13 lines × 2) (src/Vogen.CodeFixers/Rules/NormalizeInputMethodFixers/AddMethodCodeFixProvider.cs)
• …and 84 more

• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (.editorconfig)
• AnalyzerSeverityNone (tests/.editorconfig)
• DeadPreprocessorBranch (src/Vogen/Extensions/CompilationExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/CompilationExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/IMethodSymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/IMethodSymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/ISymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/ITypeSymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/ITypeSymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/ITypeSymbolExtensions.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/MethodKindEx.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/OperationBlockAnalysisContextExtension.cs)
• DeadPreprocessorBranch (src/Vogen/Extensions/OperationKinds.cs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• …and 129 more

• Unchanged — 8 HTTP endpoints

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

SteveDunn/Vogen 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.