Ocramius/ProxyManager

ProxyManager is a PHP library that generates proxy classes for existing objects to enable advanced behaviors such as lazy loading, method interception, and remote object access. It supports multiple proxy patterns including ghost objects, value holders, access interceptors, null objects, and remote proxies, allowing developers to control initialization, modify method calls, or simulate remote services. The system handles code generation, caching, and autoloading of these proxies while ensuring type safety and signature validation.

67 changes.

The project underwent a comprehensive modernization to support PHP 8.0, migrating its core code generation dependencies from Zend Framework to Laminas Code. This period involved a thorough refactoring of proxy generators, factories, and utility classes to enforce strict typing and modern PHP standards. Extensive test coverage was added to validate the new architecture, including new components for autoloading, file location, and remote object adapters.

11 changes.

This period focused on enhancing proxy integrity and performance by introducing a signature generation and validation system to secure generated classes. Concurrently, lazy loading mechanisms were optimized through the implementation of static constructors, while comprehensive testing and benchmarking were added to ensure correctness and measure efficiency.

A new AdapterProperty class has been introduced in the RemoteObject property generator to handle the generation of properties containing the remote object adapter. This class extends the Laminas Code Generator's PropertyGenerator, sets the property visibility to private, and uses the IdentifierSuffixer to generate a unique identifier for the 'adapter' property. It also sets a docblock indicating the property holds an instance of the AdapterInterface.

src/ProxyManager/ProxyGenerator/RemoteObject/PropertyGenerator · high confidence

A new \EmptyClassStub\ class has been introduced in the \ProxyManager\\Stub\ namespace. This is a simple, final, and instantiable empty class designed to serve as a basic stub or placeholder when a concrete class instance is needed but no specific behavior is required.

src/ProxyManager/Stub · high confidence

A new PublicPropertiesMap class has been introduced in the PropertyGenerator component to maintain a private, static map of public properties found in the class being proxied. This map is populated during construction by iterating over the provided Properties object and is used to generate identifier suffixes, ensuring that generated property names are unique and based on the installed versions' hashes.

src/ProxyManager/ProxyGenerator/PropertyGenerator · high confidence

Introduced two new utility classes, ParameterEncoder and ParameterHasher, within the Inflector/Util namespace. ParameterEncoder converts arbitrary parameters into a base64-encoded string safe for use in class names, while ParameterHasher generates MD5 hashes from serialized parameters to create likely unique identifiers. Both classes accept an array of mixed parameters and rely on PHP's serialize function.

src/ProxyManager/Inflector/Util · high confidence

A new example file (remote-proxy-server.php) has been added to the examples/remote-proxy directory. This file demonstrates a remote proxy server implementation that utilizes the Laminas\\XmlRpc\\Server component to expose a simple 'Foo' class method via XML-RPC.

examples/remote-proxy · high confidence

The \src/ProxyManager/Signature\ package now includes a complete system for attaching and verifying signatures on generated proxy classes. This introduces interfaces and implementations for generating signatures (\SignatureGeneratorInterface\, \ClassSignatureGeneratorInterface\) and checking their validity (\SignatureCheckerInterface\). The default \SignatureGenerator\ uses \ParameterEncoder\ and \ParameterHasher\ to create unique keys and values based on generation parameters, while \ClassSignatureGenerator\ injects a private static property into the generated class to store the signature. Conversely, \SignatureChecker\ validates existing proxies by reflecting on the class and comparing the stored property against the expected signature, throwing \MissingSignatureException\ or \InvalidSignatureException\ if validation fails.

src/ProxyManager/Signature · high confidence

The repository is initialized with essential configuration files including a \.gitattributes\ to exclude development artifacts from the packaged release, a \SECURITY.md\ for vulnerability reporting, and a \STABILITY.md\ outlining version support timelines. Development tooling is established with configurations for PHPStan (\psalm.xml\), code style (\phpcs.xml.dist\), mutation testing (\infection.json.dist\), and benchmarking (\phpbench.json\), alongside a \phpunit.xml.dist\ that defines unit and integration test suites. The project also includes an \UPGRADE.md\ documenting backward compatibility breaks, a \.phpstorm.meta.php\ for IDE support, and a \renovate.json\ for automated dependency updates.

(repo-wide) · high confidence

The library now includes a new FileLocator component (FileLocator.php and FileLocatorInterface.php) that handles the generation of proxy file paths. Users can now resolve the absolute file path for a proxy class by providing a configured proxies directory and a class name, with the implementation ensuring the directory exists and returning a valid file path string.

src/ProxyManager/FileLocator · high confidence

A new \ProxyManager\\Autoloader\ namespace has been introduced, containing \AutoloaderInterface\ and its implementation \Autoloader\. This component provides a callable autoloader that checks if a class already exists or if the name is a valid proxy before attempting to load the file, preventing unnecessary file I/O and potential conflicts. The implementation uses PHP 8 syntax, including typed constructor properties and \declare(strict\_types=1)\, and relies on \FileLocatorInterface\ and \ClassNameInflectorInterface\ to locate and validate proxy files.

src/ProxyManager/Autoloader · high confidence

Added six new PHP example scripts in the examples directory demonstrating specific ProxyManager capabilities: access-interceptor-scope-localizer.php shows proxying fluent interfaces, ghost-object.php and ghost-object-skipped-properties.php illustrate lazy-loading ghost objects (including property skipping), remote-proxy.php demonstrates remote object proxies via XML-RPC, smart-reference.php covers access interceptor value holders, and virtual-proxy.php shows lazy-loading value holders.

examples · high confidence

Added four new utility classes in the Generator/Util namespace to support proxy generation: \ClassGeneratorUtils\ provides a method to add methods to a class generator only if they are not final; \IdentifierSuffixer\ generates deterministic identifiers with a suffix based on a hash of Composer's installed versions to prevent collisions; \ProxiedMethodReturnExpression\ handles the generation of correct return statements, ensuring void methods do not return values; and \UniqueIdentifierGenerator\ creates unique identifiers using \uniqid\ for cases where determinism is not required.

src/ProxyManager/Generator/Util · high confidence

Added InterceptorGenerator, a utility class that constructs the code for pre- and post-method interceptors within the AccessInterceptorScopeLocalizer. It uses a template to wrap method execution with interceptor invocations and leverages ProxiedMethodReturnExpression to correctly handle return values, including support for void methods.

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator/Util · high confidence

The proxy generation logic for access interceptors has been refactored to rely on the Laminas Code library (replacing the previous Zend namespace) and enforces strict typing via \declare(strict\types=1)\. New method generators for magic methods (such as \\\_wakeup\) and interceptor setters (\setMethodPrefixInterceptor\, \setMethodSuffixInterceptor\) now utilize the \Properties\ utility class and \UnsetPropertiesGenerator\ to handle property unsetting and method body generation, ensuring consistent behavior and improved code maintainability.

src/ProxyManager/ProxyGenerator/AccessInterceptor/MethodGenerator · high confidence

A new \CanProxyAssertion\ class has been introduced in the \ProxyGenerator/Assertion\ namespace to enforce constraints on classes before they are proxied. This utility prevents the creation of proxies for final classes, interfaces (when disabled), and classes containing abstract protected methods, throwing specific exceptions to clarify why a class cannot be proxied.

src/ProxyManager/ProxyGenerator/Assertion · high confidence

The RemoteObjectException class in the ProxyManager proxy exception namespace has been marked as deprecated. This exception is no longer used internally and should not be relied upon in user code, signaling that it may be removed in a future release.

src/ProxyManager/Proxy/Exception · high confidence

The exception hierarchy has been refactored so that the base ExceptionInterface now extends PHP's Throwable, ensuring all proxy manager exceptions can be caught as standard PHP exceptions. Several new specific exception classes have been introduced to provide clearer error reporting: DisabledMethodException for forcefully disabled methods, InvalidProxiedClassException for issues like final classes or abstract protected methods, InvalidProxyDirectoryException for missing proxy directories, and UnsupportedProxiedClassException for unsupported property localization scenarios. FileNotWritableException has been updated to integrate with webimpress/safe-writer and includes deprecated factory methods for backward compatibility.

src/ProxyManager/Exception · high confidence

The property generators for lazy-loading value holders (InitializerProperty and ValueHolderProperty) now use an IdentifierSuffixer to create unique property names based on installed version hashes. This ensures that generated proxy classes have distinct, collision-free property names, improving reliability when multiple versions or configurations are present.

src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/PropertyGenerator · high confidence

The proxy generator now ensures that generated property names (such as those storing method prefix and suffix interceptors) are unique by incorporating a hash of the installed library versions into the identifier suffix. This change, implemented via the new \IdentifierSuffixer\ utility, prevents naming collisions when multiple versions of the proxy library or its dependencies are present in the same environment, ensuring that generated code remains stable and distinct across different installation configurations.

src/ProxyManager/ProxyGenerator/AccessInterceptor/PropertyGenerator · high confidence

The internal code generation components in \src/ProxyManager/Generator\ have been refactored to extend \laminas/laminas-code\ classes instead of the legacy Zend Framework equivalents. \ClassGenerator\ is now a thin wrapper around \Laminas\\Code\\Generator\\ClassGenerator\, \MethodGenerator\ extends \Laminas\\Code\\Generator\\MethodGenerator\ with specific fixes for signature copying and docblock/source retrieval, and \MagicMethodGenerator\ extends the new \MethodGenerator\ to handle reference return logic for magic methods. These changes remove the dependency on the \cg-lib\ and Zend namespaces, ensuring the proxy generation logic aligns with the actively maintained Laminas Code library while preserving internal behavior for proxy creation.

src/ProxyManager/Generator · high confidence

The remote object adapter implementation has been migrated from Zend Server to Laminas Server, replacing the \Zend\\Server\\Client\ dependency with \Laminas\\Server\\Client\ in the new \BaseAdapter\ class. This change introduces concrete adapters for JSON-RPC, SOAP, and XML-RPC protocols, all extending the base adapter which now handles service name mapping and client delegation using strict typing and modern PHP syntax.

src/ProxyManager/Factory/RemoteObject/Adapter · high confidence

A new AdapterInterface has been added to the RemoteObject factory, defining the contract for remote object adapters. The interface enforces strict typing via \declare(strict\_types=1)\ and specifies that method parameters are passed as \array\<int, mixed\>\. To maintain backward compatibility, the return type is left as a PHPDoc \@return mixed\ rather than a native \: mixed\ declaration, with a specific suppression for the SlevomatCodingStandard rule regarding missing native type hints.

src/ProxyManager/Factory/RemoteObject · high confidence

The library now provides a new \Configuration\ class that acts as a central facade for managing proxy generation settings, including the target directory, namespace, generator strategy, autoloader, and signature components, all with strict typing and void return types. Additionally, a \Version\ class has been added to expose the current package version and commit hash at runtime by leveraging the \composer-runtime-api:^2\ \InstalledVersions\ API, replacing previous methods of version detection.

src/ProxyManager · high confidence

The lazy-loading ghost proxy generator now creates specific internal properties to manage object state and access control. An \initializationTracker\ property is added to monitor whether the object is currently being initialized, preventing implicit initializer overwrites. Additionally, \privatePropertiesMap\ and \protectedPropertiesMap\ static properties are generated to record the visibility and declaring class of private and protected properties, enabling correct access protection checks during lazy loading. These changes rely on the \IdentifierSuffixer\ for unique naming and the \Laminas/code\ library for property generation.

src/ProxyManager/ProxyGenerator/LazyLoadingGhost/PropertyGenerator · high confidence

Lazy loading ghost proxies now initialize via a new static \staticProxyConstructor\ method instead of an instance constructor. This change moves the creation of the proxy instance, the unsetting of properties, and the assignment of the initializer closure into a single static entry point, which improves performance by caching the reflection class instance and ensures consistent property unsetting across all lazy loading ghosts.

src/ProxyManager/ProxyGenerator/LazyLoading · high confidence

The code generation for LazyLoadingGhost proxies has been restructured to improve performance and ensure compatibility with modern PHP versions. The \CallInitializer\ method now fetches all reflection properties by reference and passes them to the initializer closure in a single operation, reducing overhead. Magic methods (\\_\get\, \\\set\, \\\isset\, \\\_unset\) now utilize cached, instance-agnostic closures to access private and protected properties, avoiding repeated binding costs. Additionally, the generated proxy methods now include strict return types (e.g., \bool\, \void\, \?\\Closure\) and adhere to PSR-12 standards, while the underlying codebase has migrated from Zend to Laminas.

src/ProxyManager/ProxyGenerator/LazyLoadingGhost/MethodGenerator · high confidence

The lazy loading value holder proxy generation has been refactored to use the Laminas Code library (replacing the previous Zend Code dependency) and enforces strict typing via \declare(strict\_types=1)\. This change updates the internal method generators (such as \LazyLoadingMethodInterceptor\, \MagicGet\, \MagicSet\, and \InitializeProxy\) to produce proxy code with explicit return types (e.g., \void\, \bool\, \?\\Closure\) and consistent parameter handling, ensuring better compatibility with modern PHP versions and stricter type checking.

src/ProxyManager/ProxyGenerator/LazyLoadingValueHolder/MethodGenerator · high confidence

The remote object proxy generator now includes dedicated classes to handle magic property access (\\_\get\, \\\set\, \\\isset\, \\\_unset\) and a static factory constructor (\staticProxyConstructor\). These new components ensure that magic property operations are correctly proxied to the remote adapter and that proxy instances can be created statically without invoking the original class constructor, improving compatibility and performance for remote object usage.

src/ProxyManager/ProxyGenerator/RemoteObject/MethodGenerator · high confidence

The NullObject proxy implementation has been rewritten to ensure that only nullable or untyped public properties are set to null during initialization, preventing errors when attempting to assign null to typed properties. Additionally, generated methods now correctly handle void return types by omitting a return statement and support return-by-reference methods by assigning null to a reference variable before returning it. A new static constructor method is also generated to instantiate the proxy without invoking the original class constructor.

src/ProxyManager/ProxyGenerator/NullObject · high confidence

The proxy generation logic for access interceptor scope localizers has been restructured into dedicated method generator classes (BindProxyProperties, InterceptedMethod, MagicClone, MagicGet, MagicIsset, MagicSet, MagicSleep, MagicUnset, and StaticProxyConstructor). This change introduces a static constructor pattern to avoid overriding the proxied object's \_\construct, ensures proper handling of magic methods (\\get, \\set, \\isset, \\unset, \\clone, \\_sleep) with interceptor support, and enforces stricter property binding rules by preventing proxy generation when non-referenceable properties exist. The refactoring also improves variadic argument handling and ensures consistent behavior for private and accessible properties.

src/ProxyManager/ProxyGenerator/AccessInterceptorScopeLocalizer/MethodGenerator · high confidence

The code generation for access interceptor value holder proxies has been restructured into dedicated generator classes (InterceptedMethod, MagicClone, MagicGet, MagicSet, MagicIsset, MagicUnset, and StaticProxyConstructor). This change introduces a static factory constructor (\staticProxyConstructor\) for proxy instantiation, replaces string interpolation with templating for magic methods, and ensures that magic property access methods (\\_\get\, \\\_set\, etc.) correctly delegate to parent implementations when present while respecting public property maps.

src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator · high confidence

The generator strategy components have been restructured to use a new \GeneratorStrategyInterface\ and a \BaseGeneratorStrategy\ implementation. The \FileWriterGeneratorStrategy\ now integrates \webimpress/safe-writer\ for reliable file creation and properly throws \FileNotWritableException\ on failure, while the \EvaluatingGeneratorStrategy\ includes a fallback mechanism to write and require temporary files when \eval\ is disabled (e.g., by Suhosin). All classes now use strict types, typed properties, and return type hints.

src/ProxyManager/GeneratorStrategy · high confidence

The proxy generator for access interceptors has been rewritten to correctly handle methods with \void\ return types, ensuring that interceptors do not attempt to return values where none are expected. This change introduces strict type declarations (\declare(strict\_types=1)\) and leverages the \ProxiedMethodReturnExpression\ utility to generate appropriate return logic based on the original method's signature. Users will benefit from more robust proxy generation that aligns with modern PHP standards and correctly processes methods that do not return data.

src/ProxyManager/ProxyGenerator/AccessInterceptorValueHolder/MethodGenerator/Util · high confidence

The proxy class name inflection logic has been refactored to use a new \ClassNameInflectorInterface\ and \ClassNameInflector\ implementation that strictly type-hints inputs and outputs (e.g., \string\ for class names, \array\<string, mixed\>\ for options). The implementation now uses a dedicated \ParameterHasher\ to generate unique suffixes for proxy classes based on options, replacing previous encoding methods. This change introduces strict typing and modern PHP syntax (PHP 8+ compatible) to the inflection process, ensuring more predictable and type-safe proxy class name generation.

src/ProxyManager/Inflector · high confidence

The proxy factory classes (LazyLoadingGhostFactory, LazyLoadingValueHolderFactory, AccessInterceptorScopeLocalizerFactory, AccessInterceptorValueHolderFactory, NullObjectFactory, and RemoteObjectFactory) have been refactored to extend a new AbstractBaseFactory. This base class centralizes proxy generation logic, including caching of generated class names to avoid redundant work and mandatory signature checking via the Configuration's SignatureChecker to ensure generated proxies match their source classes. Each concrete factory now only needs to provide its specific ProxyGenerator implementation and handle the final instantiation via staticProxyConstructor, resulting in cleaner, more consistent factory behavior across all proxy types.

src/ProxyManager/Factory · high confidence

The proxy generation utilities in the Util namespace have been refactored to improve property handling and method filtering. A new \Properties\ utility class now manages non-static proxy properties, providing methods to filter by exclusion, identify non-referenceable typed properties, and retrieve properties grouped by visibility (public, protected, private) and declaring class. A new \GetMethodIfExists\ utility safely retrieves reflection methods, returning null if they do not exist. The \ProxiedMethodsFilter\ has been updated to explicitly exclude magic methods like \\_\get\, \\\set\, \\\isset\, and \\\unset\ by default, and now supports filtering for abstract methods. Additionally, a new \UnsetPropertiesGenerator\ has been introduced to generate code for unsetting properties, handling both accessible and private properties via closure binding. The \PublicScopeSimulator\ has been adjusted to respect void return semantics for \unset\ operations and to reject value parameters when not generating \\\_set\ code.

src/ProxyManager/ProxyGenerator/Util · high confidence

The proxy generation logic in src/ProxyManager/ProxyGenerator has been rewritten to depend on Laminas Code instead of the previous cg-lib, and all generator classes now enforce strict types. This change introduces new generator implementations (such as AccessInterceptorScopeLocalizerGenerator, LazyLoadingGhostGenerator, and NullObjectGenerator) that produce proxies with stricter method signatures and improved type safety, while also removing legacy constructor overrides and unused property checks to streamline the generated proxy code.

src/ProxyManager/ProxyGenerator · high confidence

The proxy marker interfaces in src/ProxyManager/Proxy have been reorganized and strictly typed. New interfaces were introduced to define specific proxy behaviors: AccessInterceptorInterface and AccessInterceptorValueHolderInterface for method interception, GhostObjectInterface and LazyLoadingInterface for lazy initialization, and markers for NullObject, RemoteObject, and VirtualProxy patterns. The base ProxyInterface was cleaned of license headers and now uses Psalm templating. Additionally, the unused FallbackValueHolderInterface and SmartReferenceInterface have been deprecated to signal they should no longer be relied upon.

src/ProxyManager/Proxy · high confidence

The proxy generation logic for value holders has been reorganized into the \ProxyManager\\ProxyGenerator\\ValueHolder\ namespace, replacing the previous Zend Code dependencies with Laminas Code. This change introduces strict types (\declare(strict\types=1)\) and specific return type hints, such as \?object\ for \getWrappedValueHolderValue\. The constructor generation now correctly handles variadic arguments when calling the original constructor and ensures static properties are skipped, while also implementing a magic \\\_sleep\ method that returns only the value holder property name.

src/ProxyManager/ProxyGenerator/ValueHolder · high confidence

The signature sub-component now introduces specific exception classes to distinguish between different validation failures: \InvalidSignatureException\ is thrown when a provided signature does not match the expected one, and \MissingSignatureException\ is thrown when no signature is found for a class. Both extend \UnexpectedValueException\ and implement the new \ExceptionInterface\ marker, providing clearer error context for developers handling proxy signature checks.

src/ProxyManager/Signature/Exception · high confidence

Added benchmark suite for proxy instantiation and property access; Added integration tests for proxy language features; Added static-analysis tests for proxy factories; Added test asset for proxy generation with two public properties; Added test assets for remote proxy argument handling; Added test coverage for AdapterProperty generator; Added test coverage for MagicMethodGenerator and MethodGenerator; Added test coverage for ParameterEncoder and ParameterHasher utilities; Added test coverage for ProxyManager exception classes; Added test coverage for access interceptor method generators; Added test coverage for access interceptor property generators; Added test coverage for generator strategies; Added test coverage for lazy-loading ghost property generators; Added test coverage for proxy generator utility classes; Added tests for CanProxyAssertion validation logic; Added tests for FileLocator; Added tests for InterceptorGenerator method body creation; Added tests for InterceptorGenerator utility; Added tests for Null Object proxy generator method and constructor logic; Added tests for StaticProxyConstructor generation; Added tests for ValueHolder proxy method generators; Added tests for signature validation exceptions; Added unit tests for Access Interceptor Value Holder method generators; Added unit tests for ClassNameInflector; Added unit tests for Configuration and Version, plus a test assertion helper; Added unit tests for LazyLoadingGhost method generators; Added unit tests for PublicPropertiesMap and unique property name generation; Added unit tests for lazy-loading value holder method generators; Added unit tests for lazy-loading value holder property generators; Added unit tests for proxy factory classes; Added unit tests for proxy generation utility classes; Added unit tests for proxy generator implementations; Added unit tests for remote object adapters; Added unit tests for remote object method generators; Added unit tests for signature generation and validation components; Added unit tests for the Autoloader component; Expanded functional test coverage for ProxyManager proxy types; Expanded test assets for proxy generation edge cases.

The project now requires PHP 8.0 and Composer runtime API 2.1, dropping support for older PHP versions. The core dependency has been migrated from \zendframework/zend-code\ to \laminas/laminas-code\ (version 4.4.2), and \webimpress/safe-writer\ (2.2.0) is now a required dependency for safe file writing. Development tooling has been updated to use PHPUnit 9.5.6, Psalm 4.8.1, and PHPBench 1.0.3, while the autoloading standard has been switched from PSR-0 to PSR-4.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 64.

• Code Health 99
• Architecture 98
• Maturity 49
• Readiness 72
• Security 73

• 300 commits — 269 feature/other, 31 fixes

• (root) — 112 commits
• (repo) — 96 commits
• tests/ProxyManagerTest — 32 commits
• src/ProxyManager — 28 commits
• .github/workflows — 20 commits
• tests/language-feature-scripts — 5 commits
• tests/ProxyManagerBench — 2 commits
• tests/ProxyManagerTestAsset — 2 commits
• docs/access-interceptor-scope-localizer.md — 1 commit
• docs/lazy-loading-value-holder.md — 1 commit
• examples/ghost-object-skipped-properties.php — 1 commit

• fix: #632 #645 #646 applied automated CS fixes via phpcbf (mostly docblock positioning, indentation)
• fix: Drop symfony/console dev-dependency: unused, fixed past/ancient hacks
• fix: Fix "Only variable references should be returned by reference"
• fix: Fix Versions checking for ocramius/package-versions instead of ocramius/proxy-manager
• fix: Fix doc url
• fix: Fix documentation examples with codelicia/xulieta
• fix: Fix lazy-loading-value-holder-internal-php-classes.phpt
• fix: Fix property initializers in ghost object examples
• fix: Fix proxy example in README.md
• fix: Fix proxying an interface and using a dynamic property on the proxy
• fix: Fix signatures to static
• fix: Fixed code style after replacing Zend with Laminas
• fix: Merge branch 'fix/#649-correct-compress-parameter-used-in-internal-class-integration-test' into 2.10.x
• fix: Merge pull request #540 from pedro-stanaka/hotfix/default-params-remote-object-method
• fix: Merge pull request #553 from Ocramius/revert-502-feature/immutability-psalm-annotations
• fix: Merge pull request #557 from ostrolucky/fix-ghost-examples
• fix: Merge pull request #567 from Ocramius/fix/better-type-inference-for-generated-classes
• fix: Merge pull request #585 from Ocramius/fix/#574-initialize-typed-non-nullable-properties-on-php-7.4.1
• fix: Merge pull request #587 from Ocramius/fix/address-test-suite-deprecations
• fix: Merge pull request #589 from Ocramius/fix/correct-type-errors-in-static-analysis
• …and 280 more

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

Ocramius/ProxyManager 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.