Pineapple Bundle Laravel Package

Getting Started

Minimal Setup

1. Installation Add the bundle via Composer (though note the last release was in 2014—verify compatibility with your Symfony/Laravel version):

   composer require big-room-studios/pineapple-bundle
   

   Register the bundle in config/app.php (Symfony) or manually in Laravel via a service provider (if adapted).

2. First Use Case The README lacks specifics, but assume this is a legacy Symfony bundle. For Laravel, check for:

   • A PineappleService or PineappleManager class in vendor/big-room-studios/pineapple-bundle.
   • Look for a PineappleBundle.php file to inspect services/dependencies.
   • Test basic functionality (e.g., Pineapple::doSomething()) in routes/web.php or a controller.

3. Where to Look First

   • Source Code: Navigate to vendor/big-room-studios/pineapple-bundle/src/ for core classes.
   • Symfony Docs: Compare with Symfony’s Bundle structure for expected patterns.
   • Laravel Adaptation: If using in Laravel, wrap the bundle in a Laravel service provider to bridge Symfony dependencies (e.g., ContainerAwareTrait → Laravel’s Container binding).

Implementation Patterns

Workflows

1. Service Integration

   • Symfony: Bind the bundle’s services in services.yaml (if using Symfony) or manually in config/services.php (Laravel).

     // Laravel example (hypothetical)
     $this->app->bind('pineapple', function ($app) {
         return new \BigRoomStudios\PineappleBundle\Service\PineappleService($app['container']);
     });
     

   • Dependency Injection: Pass Laravel’s Illuminate\Container\Container to the bundle’s classes where ContainerInterface is expected.

2. Event Listeners/Subscribers

   • If the bundle uses Symfony’s event system, create Laravel event listeners:

     use BigRoomStudios\PineappleBundle\Event\PineappleEvent;
     
     class PineappleListener {
         public function handle(PineappleEvent $event) {
             // Logic here
         }
     }
     

   • Register in EventServiceProvider:

     protected $listen = [
         'pineapple.event' => [
             'PineappleListener',
         ],
     ];
     

3. Configuration

   • Check for a Resources/config/config.yml in the bundle. Adapt to Laravel’s config/pineapple.php:

     return [
         'setting' => env('PINEAPPLE_SETTING', 'default'),
     ];
     

Laravel-Specific Tips

• Service Providers: Create a custom provider to initialize the bundle:

  class PineappleServiceProvider extends ServiceProvider {
      public function register() {
          $this->app->singleton('pineapple', function ($app) {
              return new \BigRoomStudios\PineappleBundle\PineappleBundle($app);
          });
      }
  }
  

• Facade (Optional): Generate a facade for cleaner syntax:

  php artisan make:facade Pineapple
  

  // Usage:
  Pineapple::action();
  

Gotchas and Tips

Pitfalls

1. Outdated Codebase

   • The last release was in 2014. Expect:
     • PHP 5.4/5.5 syntax (e.g., use statements, traits).
     • Symfony 2.x dependencies (e.g., ContainerAwareTrait).
     • No PHP 8+ support (e.g., named arguments, union types).
   • Mitigation: Use a compatibility layer (e.g., nikic/php-parser for syntax updates) or fork the repo.

2. Symfony-Specific Assumptions

   • Kernel/Container: The bundle may assume Symfony’s Kernel or Container. Override or mock these in Laravel:

     $bundle = new \BigRoomStudios\PineappleBundle\PineappleBundle();
     $bundle->setContainer($this->app); // Laravel's container
     

   • Routing: If the bundle adds routes, manually define them in Laravel’s routes/web.php.

3. Lack of Documentation

   • No README details or PHPDoc. Reverse-engineer usage from:
     • Class methods (e.g., public function slice() → likely a core function).
     • Tests (if any exist in Tests/).
     • Dependents (none exist, so no real-world examples).

4. Namespace Collisions

   • The bundle may use Pineapple as a class name. Laravel’s Pineapple facade or pineapple config key could conflict. Rename or alias:

     config(['pineapple_bundle' => [...]]);
     

Debugging

1. Enable Debugging

   • Add logging to the bundle’s classes:

     \Log::debug('Pineapple action triggered', ['data' => $data]);
     

   • Use Laravel’s dd() or Symfony’s var_dump() in critical paths.

2. Dependency Dumping

   • List loaded services to verify the bundle is initialized:

     php artisan container:dump
     

   • Check for errors in storage/logs/laravel.log.

3. Isolation Testing

   • Test the bundle in isolation by creating a minimal Laravel app:

     composer create-project laravel/laravel pineapple-test
     cd pineapple-test
     composer require big-room-studios/pineapple-bundle
     

Extension Points

1. Customizing Behavior

   • Override bundle classes by publishing config/assets (if any) or extending core classes:

     class CustomPineappleService extends \BigRoomStudios\PineappleBundle\Service\PineappleService {
         public function slice() {
             // Custom logic
         }
     }
     

   • Bind the custom class in the service provider.

2. Adding Features

   • Extend the bundle’s functionality by creating Laravel-specific features (e.g., a PineappleService facade or queue jobs):

     class PineappleJob implements ShouldQueue {
         use Dispatchable, InteractsWithQueue;
     
         public function handle() {
             Pineapple::process();
         }
     }
     

3. Event-Driven Extensions

   • Listen for hypothetical PineappleEvents and trigger Laravel events:

     Pineapple::on('sliced', function ($data) {
         event(new PineappleSliced($data));
     });