Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
0.00% |
0 / 11 |
CRAP | |
0.00% |
0 / 50 |
| StreamWrapperManager | |
0.00% |
0 / 1 |
|
0.00% |
0 / 11 |
650 | |
0.00% |
0 / 50 |
| getWrappers | |
0.00% |
0 / 1 |
30 | |
0.00% |
0 / 9 |
|||
| getNames | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| getDescriptions | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 4 |
|||
| getViaScheme | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getViaUri | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| getClass | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| getWrapper | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 5 |
|||
| addStreamWrapper | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 5 |
|||
| register | |
0.00% |
0 / 1 |
6 | |
0.00% |
0 / 3 |
|||
| unregister | |
0.00% |
0 / 1 |
12 | |
0.00% |
0 / 4 |
|||
| registerWrapper | |
0.00% |
0 / 1 |
20 | |
0.00% |
0 / 10 |
|||
| <?php | |
| /** | |
| * @file | |
| * Contains \Drupal\Core\StreamWrapper\StreamWrapperManager. | |
| */ | |
| namespace Drupal\Core\StreamWrapper; | |
| use Symfony\Component\DependencyInjection\ContainerAware; | |
| /** | |
| * Provides a StreamWrapper manager. | |
| * | |
| * @see \Drupal\Core\StreamWrapper\StreamWrapperInterface | |
| */ | |
| class StreamWrapperManager extends ContainerAware implements StreamWrapperManagerInterface { | |
| /** | |
| * Contains stream wrapper info. | |
| * | |
| * An associative array where keys are scheme names and values are themselves | |
| * associative arrays with the keys class, type and (optionally) service_id, | |
| * and string values. | |
| * | |
| * @var array | |
| */ | |
| protected $info = array(); | |
| /** | |
| * Contains collected stream wrappers. | |
| * | |
| * Keyed by filter, each value is itself an associative array keyed by scheme. | |
| * Each of those values is an array representing a stream wrapper, with the | |
| * following keys and values: | |
| * - class: stream wrapper class name | |
| * - type: a bitmask corresponding to the type constants in | |
| * StreamWrapperInterface | |
| * - service_id: name of service | |
| * | |
| * The array on key StreamWrapperInterface::ALL contains representations of | |
| * all schemes and corresponding wrappers. | |
| * | |
| * @var array | |
| */ | |
| protected $wrappers = array(); | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getWrappers($filter = StreamWrapperInterface::ALL) { | |
| if (isset($this->wrappers[$filter])) { | |
| return $this->wrappers[$filter]; | |
| } | |
| elseif (isset($this->wrappers[StreamWrapperInterface::ALL])) { | |
| $this->wrappers[$filter] = array(); | |
| foreach ($this->wrappers[StreamWrapperInterface::ALL] as $scheme => $info) { | |
| // Bit-wise filter. | |
| if (($info['type'] & $filter) == $filter) { | |
| $this->wrappers[$filter][$scheme] = $info; | |
| } | |
| } | |
| return $this->wrappers[$filter]; | |
| } | |
| else { | |
| return array(); | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getNames($filter = StreamWrapperInterface::ALL) { | |
| $names = array(); | |
| foreach (array_keys($this->getWrappers($filter)) as $scheme) { | |
| $names[$scheme] = $this->getViaScheme($scheme)->getName(); | |
| } | |
| return $names; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getDescriptions($filter = StreamWrapperInterface::ALL) { | |
| $descriptions = array(); | |
| foreach (array_keys($this->getWrappers($filter)) as $scheme) { | |
| $descriptions[$scheme] = $this->getViaScheme($scheme)->getDescription(); | |
| } | |
| return $descriptions; | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getViaScheme($scheme) { | |
| return $this->getWrapper($scheme, $scheme . '://'); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getViaUri($uri) { | |
| $scheme = file_uri_scheme($uri); | |
| return $this->getWrapper($scheme, $uri); | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function getClass($scheme) { | |
| if (isset($this->info[$scheme])) { | |
| return $this->info[$scheme]['class']; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Returns a stream wrapper instance. | |
| * | |
| * @param string $scheme | |
| * The scheme of the desired stream wrapper. | |
| * @param string $uri | |
| * The URI of the stream. | |
| * | |
| * @return \Drupal\Core\StreamWrapper\StreamWrapperInterface|bool | |
| * A stream wrapper object, or false if the scheme is not available. | |
| */ | |
| protected function getWrapper($scheme, $uri) { | |
| if (isset($this->info[$scheme]['service_id'])) { | |
| $instance = $this->container->get($this->info[$scheme]['service_id']); | |
| $instance->setUri($uri); | |
| return $instance; | |
| } | |
| return FALSE; | |
| } | |
| /** | |
| * Adds a stream wrapper. | |
| * | |
| * Internal use only. | |
| * | |
| * @param string $service_id | |
| * The service id. | |
| * @param string $class | |
| * The stream wrapper class. | |
| * @param string $scheme | |
| * The scheme for which the wrapper should be registered. | |
| */ | |
| public function addStreamWrapper($service_id, $class, $scheme) { | |
| $this->info[$scheme] = array( | |
| 'class' => $class, | |
| 'type' => $class::getType(), | |
| 'service_id' => $service_id, | |
| ); | |
| } | |
| /** | |
| * Registers the tagged stream wrappers. | |
| * | |
| * Internal use only. | |
| */ | |
| public function register() { | |
| foreach ($this->info as $scheme => $info) { | |
| $this->registerWrapper($scheme, $info['class'], $info['type']); | |
| } | |
| } | |
| /** | |
| * Unregisters the tagged stream wrappers. | |
| * | |
| * Internal use only. | |
| */ | |
| public function unregister() { | |
| // Normally, there are definitely wrappers set for the ALL filter. However, | |
| // in some cases involving many container rebuilds (e.g. WebTestBase), | |
| // $this->wrappers may be empty although wrappers are still registered | |
| // globally. Thus an isset() check is needed before iterating. | |
| if (isset($this->wrappers[StreamWrapperInterface::ALL])) { | |
| foreach (array_keys($this->wrappers[StreamWrapperInterface::ALL]) as $scheme) { | |
| stream_wrapper_unregister($scheme); | |
| } | |
| } | |
| } | |
| /** | |
| * {@inheritdoc} | |
| */ | |
| public function registerWrapper($scheme, $class, $type) { | |
| if (in_array($scheme, stream_get_wrappers(), TRUE)) { | |
| stream_wrapper_unregister($scheme); | |
| } | |
| if (($type & StreamWrapperInterface::LOCAL) == StreamWrapperInterface::LOCAL) { | |
| stream_wrapper_register($scheme, $class); | |
| } | |
| else { | |
| stream_wrapper_register($scheme, $class, STREAM_IS_URL); | |
| } | |
| // Pre-populate the static cache with the filters most typically used. | |
| $info = array('type' => $type, 'class' => $class); | |
| $this->wrappers[StreamWrapperInterface::ALL][$scheme] = $info; | |
| if (($type & StreamWrapperInterface::WRITE_VISIBLE) == StreamWrapperInterface::WRITE_VISIBLE) { | |
| $this->wrappers[StreamWrapperInterface::WRITE_VISIBLE][$scheme] = $info; | |
| } | |
| } | |
| } |