Symfony Bundle Content Laravel Package

Getting Started

Minimal Steps

1. Installation:

   composer require binsoul/symfony-bundle-content
   

   Ensure your project uses Symfony (this bundle is Symfony-specific, but Laravel can adapt concepts).

2. Bundle Registration: Add the bundle to config/bundles.php (Symfony) or manually integrate its core logic (e.g., content management) into Laravel’s service container.

3. First Use Case:

   • Symfony: Register the bundle in AppKernel.php or config/bundles.php.
   • Laravel: Study the bundle’s ContentManager (or equivalent) to replicate its functionality using Laravel’s ServiceProvider and Facade patterns. For example:

     // app/Providers/AppServiceProvider.php
     public function register()
     {
         $this->app->singleton('content.manager', function ($app) {
             return new \Binsoul\ContentBundle\Manager\ContentManager();
         });
     }
     

   • Use the manager to fetch/store content (adapt to Laravel’s Eloquent or API calls if needed).

4. Key Classes to Explore:

   • ContentManager: Core logic for content operations.
   • ContentInterface: Contract for content entities (useful for defining Laravel models).
   • EventDispatcher: For extending content lifecycle (map to Laravel’s Events system).

Implementation Patterns

Workflows

1. Content Management:

   • Symfony: Use the bundle’s ContentManager to CRUD content entities (e.g., Article, Page).
   • Laravel:
     • Create a Laravel model (e.g., Content) with fields like title, body, slug, and published_at.
     • Wrap the bundle’s logic in a Laravel service:

       // app/Services/ContentService.php
       class ContentService {
           protected $manager;
       
           public function __construct(ContentManager $manager) {
               $this->manager = $manager;
           }
       
           public function getPublishedContents() {
               return $this->manager->findBy(['published' => true]);
           }
       }
       

     • Register the service in AppServiceProvider and use it in controllers.

2. Event-Driven Extensions:

   • The bundle uses Symfony’s EventDispatcher for hooks (e.g., ContentCreateEvent). In Laravel, replace with:

     // Listen to content creation
     event(new ContentCreated($content));
     

   • Create listeners in EventServiceProvider:

     protected $listen = [
         'ContentCreated' => [
             'NotifyContentTeam',
         ],
     ];
     

3. Dependency Injection:

   • Inject the ContentManager into controllers/services:

     public function show(ContentManager $manager, $slug) {
         $content = $manager->findOneBy(['slug' => $slug]);
         return view('content.show', compact('content'));
     }
     

4. Configuration:

   • The bundle uses Symfony’s Configuration component. In Laravel, replicate in config/content.php:

     return [
         'default_locale' => 'en',
         'storage' => 'database', // or 'filesystem'
     ];
     

Integration Tips

• Database: The bundle likely uses Doctrine ORM. In Laravel, use Eloquent migrations:

  php artisan make:migration create_contents_table
  

  Define fields matching the bundle’s ContentInterface.

• APIs: If the bundle fetches remote content, adapt to Laravel’s Http client or Guzzle:

  $client = new \GuzzleHttp\Client();
  $response = $client->get('https://api.example.com/content');
  

• Caching: Use Laravel’s cache (e.g., Cache::remember) to store fetched content:

  $content = Cache::remember("content_{$slug}", now()->addHours(1), function () use ($manager, $slug) {
      return $manager->findOneBy(['slug' => $slug]);
  });
  

Gotchas and Tips

Pitfalls

1. Symfony-Specific Dependencies:

   • The bundle relies on Symfony components (e.g., EventDispatcher, DependencyInjection). In Laravel:
     • Replace EventDispatcher with Laravel’s Event system.
     • Use Laravel’s Container instead of Symfony’s ContainerInterface.
   • Fix: Abstract Symfony-specific logic into a thin layer (e.g., SymfonyAdapter service).

2. Doctrine ORM:

   • The bundle assumes Doctrine ORM. Laravel uses Eloquent.
   • Fix: Create a DoctrineToEloquentAdapter to translate queries:

     class DoctrineToEloquentAdapter {
         public function findBy(array $criteria) {
             return Content::where($criteria)->get();
         }
     }
     

3. Configuration Overrides:

   • The bundle’s Configuration class may not play nicely with Laravel’s config() helper.
   • Fix: Merge configs manually in AppServiceProvider:

     $this->app->singleton('content.config', function () {
         return array_merge(
             require __DIR__.'/../config/content.php',
             $this->app['config']['content.custom'] ?? []
         );
     });
     

4. Event Naming Collisions:

   • Symfony events (e.g., ContentCreateEvent) may conflict with Laravel’s Creating events.
   • Fix: Prefix events (e.g., Binsoul\ContentCreated) or namespace them:

     event(new \App\Events\Binsoul\ContentCreated($content));
     

5. Testing:

   • The bundle’s tests use Symfony’s TestCase. In Laravel:
     • Use PHPUnit with Laravel’s RefreshDatabase trait.
     • Mock the ContentManager in tests:

       $manager = Mockery::mock(\Binsoul\ContentBundle\Manager\ContentManager::class);
       $manager->shouldReceive('findOneBy')->andReturn($content);
       $this->app->instance('content.manager', $manager);
       

Debugging Tips

1. Log Symfony Exceptions:

   • Wrap bundle calls in try-catch to log Symfony-specific errors:

     try {
         $content = $manager->findOneBy(['slug' => $slug]);
     } catch (\Symfony\Component\DependencyInjection\Exception\ServiceNotFoundException $e) {
         Log::error('ContentManager not bound: '.$e->getMessage());
         abort(500);
     }
     

2. Dump Container Bindings:

   • Check if the ContentManager is properly bound:

     dd($this->app->bound('content.manager') ? $this->app->make('content.manager') : 'Not bound');
     

3. Configuration Validation:

   • Validate config/content.php against the bundle’s expected structure:

     if (!isset(config('content.storage'))) {
         throw new \RuntimeException('Content storage not configured.');
     }
     

Extension Points

1. Custom Content Types:

   • Extend the ContentInterface to add fields (e.g., VideoContent):

     interface VideoContent extends ContentInterface {
         public function getEmbedUrl();
     }
     

   • In Laravel, create a polymorphic relationship:

     class Content extends Model {
         public function getContentType() {
             return $this->type;
         }
     }
     

2. Storage Backends:

   • Replace the default storage (e.g., database/filesystem) with S3 or Redis:

     // app/Services/ContentStorage.php
     class ContentStorage {
         public function save($content) {
             // Use Laravel's Filesystem or cache
             Storage::disk('s3')->put("content/{$content->slug}.json", $content);
         }
     }
     

3. Validation:

   • Add Laravel’s validation rules to content creation:

     use Illuminate\Support\Facades\Validator;
     
     $validator = Validator::make($data, [
         'title' => 'required|max:255',
         'body' => 'required',
     ]);
     

4. API Resources:

   • Transform content into API responses using Laravel’s Resource classes:

     class ContentResource extends JsonResource {
         public function toArray($request) {
             return [
                 'title' => $this->title,
                 'slug' => $this->slug,
                 'published_at' => $this->published_at->toDateTimeString(),
             ];
         }
     }