title: Intervention laravel 5
body: <p>I'm trying to install intervention. I run this command 
  <code>composer require intervention/image</code>
  and composer.json is updated.
  I add 'Image' => 'Intervention\Image\Facades\Image::class'<code>in $aliases array and it's ok. Then i add</code>Intervention\Image\ImageServiceProvider::class` in the $providers array and it didn't work. </p>
  
  <p>This is what i obtain when type composer update</p>
  
  <pre><code>PHP Fatal error:  Class 'Intervention\Image\ImageServiceProvider' not found in /home/vagrant/Code/laravel-basics/vendor/laravel/framework/src/Illuminate/Foundation/ProviderRepository.php on line 146
  
  [Symfony\Component\Debug\Exception\FatalErrorException]    
  Class 'Intervention\Image\ImageServiceProvider' not found `
  
  &lt;?php
  </code></pre>
  
  <p>ProviderRepository.php</p>
  
  <pre><code>&lt;?php
  </code></pre>
  
  <p>namespace Illuminate\Foundation;</p>
  
  <p>use Illuminate\Filesystem\Filesystem;
     use Illuminate\Contracts\Foundation\Application as ApplicationContract;</p>
  
  <p>class ProviderRepository
     {
      /**
       * The application implementation.
       *
       * @var \Illuminate\Contracts\Foundation\Application
       */
      protected $app;</p>
  
  <pre><code>/**
   * The filesystem instance.
   *
   * @var \Illuminate\Filesystem\Filesystem
   */
  protected $files;
  
  /**
   * The path to the manifest file.
   *
   * @var string
   */
  protected $manifestPath;
  
  /**
   * Create a new service repository instance.
   *
   * @param  \Illuminate\Contracts\Foundation\Application  $app
   * @param  \Illuminate\Filesystem\Filesystem  $files
   * @param  string  $manifestPath
   * @return void
   */
  public function __construct(ApplicationContract $app, Filesystem $files, $manifestPath)
  {
      $this-&gt;app = $app;
      $this-&gt;files = $files;
      $this-&gt;manifestPath = $manifestPath;
  }
  
  /**
   * Register the application service providers.
   *
   * @param  array  $providers
   * @return void
   */
  public function load(array $providers)
  {
      $manifest = $this-&gt;loadManifest();
  
      // First we will load the service manifest, which contains information on all
      // service providers registered with the application and which services it
      // provides. This is used to know which services are "deferred" loaders.
      if ($this-&gt;shouldRecompile($manifest, $providers)) {
          $manifest = $this-&gt;compileManifest($providers);
      }
  
      // Next, we will register events to load the providers for each of the events
      // that it has requested. This allows the service provider to defer itself
      // while still getting automatically loaded when a certain event occurs.
      foreach ($manifest['when'] as $provider =&gt; $events) {
          $this-&gt;registerLoadEvents($provider, $events);
      }
  
      // We will go ahead and register all of the eagerly loaded providers with the
      // application so their services can be registered with the application as
      // a provided service. Then we will set the deferred service list on it.
      foreach ($manifest['eager'] as $provider) {
          $this-&gt;app-&gt;register($this-&gt;createProvider($provider));
      }
  
      $this-&gt;app-&gt;setDeferredServices($manifest['deferred']);
  }
  
  /**
   * Register the load events for the given provider.
   *
   * @param  string  $provider
   * @param  array  $events
   * @return void
   */
  protected function registerLoadEvents($provider, array $events)
  {
      if (count($events) &lt; 1) {
          return;
      }
  
      $app = $this-&gt;app;
  
      $app-&gt;make('events')-&gt;listen($events, function () use ($app, $provider) {
          $app-&gt;register($provider);
      });
  }
  
  /**
   * Compile the application manifest file.
   *
   * @param  array  $providers
   * @return array
   */
  protected function compileManifest($providers)
  {
      // The service manifest should contain a list of all of the providers for
      // the application so we can compare it on each request to the service
      // and determine if the manifest should be recompiled or is current.
      $manifest = $this-&gt;freshManifest($providers);
  
      foreach ($providers as $provider) {
          $instance = $this-&gt;createProvider($provider);
  
          // When recompiling the service manifest, we will spin through each of the
          // providers and check if it's a deferred provider or not. If so we'll
          // add it's provided services to the manifest and note the provider.
          if ($instance-&gt;isDeferred()) {
              foreach ($instance-&gt;provides() as $service) {
                  $manifest['deferred'][$service] = $provider;
              }
  
              $manifest['when'][$provider] = $instance-&gt;when();
          }
  
          // If the service providers are not deferred, we will simply add it to an
          // array of eagerly loaded providers that will get registered on every
          // request to this application instead of "lazy" loading every time.
          else {
              $manifest['eager'][] = $provider;
          }
      }
  
      return $this-&gt;writeManifest($manifest);
  }
  
  /**
   * Create a new provider instance.
   *
   * @param  string  $provider
   * @return \Illuminate\Support\ServiceProvider
   */
  public function createProvider($provider)
  {
      return new $provider($this-&gt;app);
  }
  
  /**
   * Determine if the manifest should be compiled.
   *
   * @param  array  $manifest
   * @param  array  $providers
   * @return bool
   */
  public function shouldRecompile($manifest, $providers)
  {
      return is_null($manifest) || $manifest['providers'] != $providers;
  }
  
  /**
   * Load the service provider manifest JSON file.
   *
   * @return array
   */
  public function loadManifest()
  {
      // The service manifest is a file containing a JSON representation of every
      // service provided by the application and whether its provider is using
      // deferred loading or should be eagerly loaded on each request to us.
      if ($this-&gt;files-&gt;exists($this-&gt;manifestPath)) {
          $manifest = json_decode($this-&gt;files-&gt;get($this-&gt;manifestPath), true);
  
          return array_merge(['when' =&gt; []], $manifest);
      }
  }
  
  /**
   * Write the service manifest file to disk.
   *
   * @param  array  $manifest
   * @return array
   */
  public function writeManifest($manifest)
  {
      $this-&gt;files-&gt;put(
          $this-&gt;manifestPath, json_encode($manifest,  JSON_PRETTY_PRINT)
      );
  
      return $manifest;
  }
  
  /**
   * Create a fresh service manifest data structure.
   *
   * @param  array  $providers
   * @return array
   */
  protected function freshManifest(array $providers)
  {
      return ['providers' =&gt; $providers, 'eager' =&gt; [], 'deferred' =&gt;    []];
  }
  </code></pre>
  
  <p>}</p>
  
  <p>composer.json</p>
  
  <pre><code>{
  "name": "laravel/laravel",
  "description": "The Laravel Framework.",
  "keywords": ["framework", "laravel"],
  "license": "MIT",
  "type": "project",
  "require": {
      "php": "&gt;=5.5.9",
      "laravel/framework": "5.1.*",
      "intervention/image": "dev-master"
  },
  "require-dev": {
      "fzaninotto/faker": "~1.4",
      "mockery/mockery": "0.9.*",
      "phpunit/phpunit": "~4.0",
      "phpspec/phpspec": "~2.1"
  },
  "autoload": {
      "classmap": [
          "database",
          "app/Models"
      ],
      "psr-4": {
          "App\\": "app/"
      }
  },
  "autoload-dev": {
      "classmap": [
          "tests/TestCase.php"
      ]
  },
  "scripts": {
      "post-install-cmd": [
          "php artisan clear-compiled",
          "php artisan optimize"
      ],
      "post-update-cmd": [
          "php artisan clear-compiled",
          "php artisan optimize"
      ],
      "post-root-package-install": [
          "php -r \"copy('.env.example', '.env');\""
      ],
      "post-create-project-cmd": [
          "php artisan key:generate"
      ]
  },
  "config": {
      "preferred-install": "dist"
  },
  
  "require": {
  "illuminate/html": "5.*"
  },
  
  "minimum-stability": "dev",
  "prefer-stable": true
  </code></pre>
  
  <p>}</p>