PHP Bundle::exists方法代码示例

 /**
  * Upgrade the given bundles for the application.
  *
  * @param  array  $bundles
  * @return void
  */
 public function upgrade($bundles)
 {
     if (count($bundles) == 0) {
         $bundles = Bundle::names();
     }
     foreach ($bundles as $name) {
         if (!Bundle::exists($name)) {
             echo "Bundle [{$name}] is not installed!";
             continue;
         }
         // First we want to retrieve the information for the bundle, such as
         // where it is currently installed. This will allow us to upgrade
         // the bundle into it's current installation path.
         $location = Bundle::path($name);
         // If the bundle exists, we will grab the data about the bundle from
         // the API so we can make the right bundle provider for the bundle,
         // since we don't know the provider used to install.
         $response = $this->retrieve($name);
         if ($response['status'] == 'not-found') {
             continue;
         }
         // Once we have the bundle information from the API, we'll simply
         // recursively delete the bundle and then re-download it using
         // the correct provider assigned to the bundle.
         File::rmdir($location);
         $this->download($response['bundle'], $location);
         echo "Bundle [{$name}] has been upgraded!" . PHP_EOL;
     }
 }

 /**
  * Generate documentation for a given bundles.  If no bundles are provided
  * documentation will be generated for all registered bundles.
  * 
  * @param  array  $bundles
  * @return void
  */
 public function bundle(array $bundles = array())
 {
     // If no bundles are provided documentation will be generated for all
     // registered bundles.
     if (count($bundles) === 0) {
         $bundles = Bundle::names();
     }
     // Remove any bundles that have not been registered, and give a
     // warning for each one we come across.
     $bundles = array_filter($bundles, function ($name) {
         if (!Bundle::exists($name)) {
             if ($name == DEFAULT_BUNDLE) {
                 return true;
             }
             echo "Bundle [{$name}] is not registered.", PHP_EOL;
             return false;
         }
         return true;
     });
     // If there are no registered bundles then exit with a message
     if (count($bundles) === 0) {
         echo PHP_EOL, "Please register your bundles and try again.", PHP_EOL;
         return;
     }
     // Get the options
     $options = $this->config(array_map(array('Bundle', 'path'), $bundles));
     // Run ApiGen
     $this->apigen($options);
 }

 /**
  * Delete a bundle's assets from the public directory
  *
  * @param  string  $bundle
  * @return void
  */
 public function unpublish($bundle)
 {
     if (!Bundle::exists($bundle)) {
         echo "Bundle [{$bundle}] is not registered.";
         return;
     }
     File::rmdir(path('public') . 'bundles' . DS . $bundle);
     echo "Assets deleted for bundle [{$bundle}]." . PHP_EOL;
 }

 /**
  * Publish a bundle's assets to the public directory.
  *
  * @param  string  $bundle
  * @return void
  */
 public function publish($bundle)
 {
     if (!Bundle::exists($bundle)) {
         echo "Bundle [{$bundle}] is not registered.";
         return;
     }
     $path = Bundle::path($bundle);
     $this->move($path . 'public', path('public') . 'bundles' . DS . $bundle);
     echo "Assets published for bundle [{$bundle}]." . PHP_EOL;
 }

 /**
  * Run a CLI task with the given arguments.
  *
  * <code>
  *		// Call the migrate artisan task
  *		Command::run(array('migrate'));
  *
  *		// Call the migrate task with some arguments
  *		Command::run(array('migrate:rollback', 'bundle-name'))
  * </code>
  *
  * @param  array  $arguments
  * @return void
  */
 public static function run($arguments = array())
 {
     static::validate($arguments);
     list($bundle, $task, $method) = static::parse($arguments[0]);
     // If the task exists within a bundle, we will start the bundle so that any
     // dependencies can be registered in the application IoC container. If the
     // task is registered in the container,  we'll resolve it.
     if (Bundle::exists($bundle)) {
         Bundle::start($bundle);
     }
     $task = static::resolve($bundle, $task);
     // Once the bundle has been resolved, we'll make sure we could actually
     // find that task, and then verify that the method exists on the task
     // so we can successfully call it without a problem.
     if (is_null($task)) {
         throw new \Exception("Sorry, I can't find that task.");
     }
     if (is_callable(array($task, $method))) {
         $task->{$method}(array_slice($arguments, 1));
     } else {
         throw new \Exception("Sorry, I can't find that method!");
     }
 }

 /**
  * Create a new module instance.
  *
  * <code>
  *      // Create a new module instance
  *      $module = new Modules\Module('registration');
  *
  *      // Create a new module instance with a path
  *      $module = new Modules\Module('registration', 'registration/extended');
  *
  *      // Create a new module instance with a full path
  *      $module = new Modules\Module('registration', 'path: /var/www/project/registration');
  * </code>
  *
  * @param  string  $module
  * @param  string  $path
  * @return void
  */
 public function __construct($module_slug, $path = null)
 {
     $this->slug = $module_slug;
     $ins = \Laravel\Config::get('installed_modules.' . $module_slug);
     $this->installed = isset($ins) and !empty($ins) ? true : false;
     $this->enabled = \Laravel\Bundle::exists($this->slug);
     $this->installer = Installer::make($module_slug);
     // if path starts with "path: "
     // its a custom path
     if (!isset($path)) {
         $this->path = path('bundle') . $this->slug . DS;
     } else {
         if (starts_with($path, 'path: ')) {
             $this->path = substr($path, 6);
         } else {
             // sets the path to modules
             // folder + path
             // module with different folder name?
             $this->path = path('bundle') . $path;
         }
     }
     // If a session driver has been specified, we will bind an instance of the
     // module error message container. If an error instance
     // exists in the session, we will use that instance.
     if (!isset($this->errors)) {
         if (Session::started() and Session::has('errors')) {
             $this->errors = Session::get('errors');
         } else {
             $this->errors = new Messages();
         }
     }
 }