Classy Laravel Package

Getting Started

Minimal Setup

1. Installation:

   composer require ergebnis/classy
   

   Add to composer.json if not auto-discovered:

   "autoload": {
       "psr-4": {
           "App\\": "app/",
           "Ergebnis\\Classy\\": "vendor/ergebnis/classy/src/"
       }
   }
   

   Run composer dump-autoload.

2. First Use Case: List all classes in a namespace (e.g., App\Models):

   use Ergebnis\Classy\Classy;
   
   $classes = Classy::classes('App\Models');
   foreach ($classes as $class) {
       echo $class->getName() . "\n";
   }
   

3. Key Classes:

   • Classy: Main facade for collectors.
   • ClassCollector: Core collector for classes/enums/interfaces/traits.
   • ClassReflection: Reflection wrapper with caching.

Implementation Patterns

Common Workflows

1. Namespace Scanning:

   // Get all classes in a namespace (recursive)
   $collector = new \Ergebnis\Classy\ClassCollector('App\\');
   $classes = $collector->getClasses();
   
   // Filter by trait
   $traitClasses = $collector->getClassesWithTrait(\Illuminate\Foundation\Testing\Concerns\InteractsWithContainer::class);
   

2. Reflection with Caching:

   $reflection = Classy::reflect('App\Models\User');
   $methods = $reflection->getMethods();
   $properties = $reflection->getProperties();
   

3. Integration with Laravel:

   • Service Providers:

     public function boot()
     {
         $this->app->singleton(Classy::class, function ($app) {
             return new Classy(new ClassCollector('App\\'));
         });
     }
     

   • Dynamic Registration: Use Classy to auto-register classes (e.g., for event listeners):

     $listeners = Classy::classes('App\\Events\\Handlers')
         ->filter(fn ($class) => $class->isSubclassOf(\Illuminate\Contracts\Queue\ShouldQueue::class))
         ->map(fn ($class) => [$class->getName(), 'handle']);
     

4. Custom Collectors: Extend ClassCollector to add filters:

   class CustomCollector extends ClassCollector
   {
       public function getClassesWithAnnotation(string $annotation)
       {
           return $this->getClasses()
               ->filter(fn ($class) => $class->hasAnnotation($annotation));
       }
   }
   

Gotchas and Tips

Pitfalls

1. Caching:

   • ClassReflection caches results by default. Clear cache manually if classes change:

     Classy::clearCache();
     

   • Disable caching in constructor:

     new ClassCollector('App\\', cache: false);
     

2. Performance:

   • Avoid scanning large namespaces repeatedly. Cache results in a service container or Redis:

     $this->app->singleton('app.classes', function () {
         return cache()->remember('app.classes', now()->addHours(1), fn () =>
             Classy::classes('App\\')->all()
         );
     });
     

3. Edge Cases:

   • Anonymous Classes: Not supported (expected behavior).
   • Dynamic Proxies: May cause reflection errors. Use isProxy() check:

     if (!$reflection->isProxy()) {
         // Safe to inspect
     }
     

4. Laravel-Specific:

   • Facades: Use Classy::reflect(FooFacade::class)->getOriginalClass() to resolve facades.
   • Service Bindings: Classes bound via bind() may not appear in scans. Use app()->bound() to verify.

Tips

1. Combining Collectors:

   $collector = new ClassCollector('App\\');
   $models = $collector->getClasses()
       ->filter(fn ($class) => $class->isSubclassOf(\Illuminate\Database\Eloquent\Model::class));
   

2. Annotation Support: Use with packages like doctrine/annotations for metadata:

   $annotatedClasses = $collector->getClasses()
       ->filter(fn ($class) => $class->hasAnnotation('\\Some\\Annotation'));
   

3. Testing: Mock Classy in tests:

   $this->mock(Classy::class)->shouldReceive('classes')
       ->andReturn(collect([new ClassReflection('Mock\\Class')]));
   

4. Extension Points:

   • Override ClassReflection to add custom methods (e.g., hasMethodWithAttribute).
   • Extend ClassCollector to support custom file patterns (e.g., *.test.php).