ConcatResolver::collect() - Code Metrics - wshafer/assetmanager-core - Measure and Improve Code Quality continuously with Scrutinizer

ConcatResolver::collect() A
last analyzed 2017-09-21 22:56 UTC

↳ Parent: ConcatResolver

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace AssetManager\Core\Resolver;

use Assetic\Asset\AssetInterface;
use AssetManager\Core\Asset\AggregateAsset;
use AssetManager\Core\Exception;
use AssetManager\Core\Service\AssetFilterManager;
use AssetManager\Core\Service\AssetFilterManagerAwareInterface;
use AssetManager\Core\Service\MimeResolver;
use Traversable;
use Zend\Stdlib\ArrayUtils;

/**
 * This resolver allows the resolving of concatenated files.
 * Concatted files are added as an StringAsset and filters get applied to concatenated string.
 */
class ConcatResolver implements
    ResolverInterface,
    AggregateResolverAwareInterface,
    AssetFilterManagerAwareInterface,
    MimeResolverAwareInterface
{
    /**
     * @var null|ResolverInterface
     */
    protected $aggregateResolver;

    /**
     * @var null|AssetFilterManager The filterManager service.
     */
    protected $filterManager;

    /**
     * @var array the concats
     */
    protected $concats = array();

    /**
     * @var MimeResolver The mime resolver.
     */
    protected $mimeResolver;

    /**
     * Constructor
     *
     * Instantiate and optionally populate concats.
     *
     * @param array|Traversable $concats
     */
    public function __construct($concats = array())
    {
        $this->setConcats($concats);
    }

    /**
     * Set the mime resolver
     *
     * @param MimeResolver $resolver
     */
    public function setMimeResolver(MimeResolver $resolver)
    {
        $this->mimeResolver = $resolver;
    }

    /**
     * Get the mime resolver
     *
     * @return MimeResolver
     */
    public function getMimeResolver()
    {
        return $this->mimeResolver;
    }

    /**
     * Set (overwrite) concats
     *
     * Concats should be arrays or Traversable objects with name => path pairs
     *
     * @param  array|Traversable                  $concats
     * @throws Exception\InvalidArgumentException
     */
    public function setConcats($concats)
    {
        $this->concats = ArrayUtils::iteratorToArray($concats);
    }

    /**
     * Set the aggregate resolver.
     *
     * @param ResolverInterface $aggregateResolver
     */
    public function setAggregateResolver(ResolverInterface $aggregateResolver)
    {
        $this->aggregateResolver = $aggregateResolver;
    }

    /**
     * Get the aggregate resolver.
     *
     * @return ResolverInterface
     */
    public function getAggregateResolver()
    {
        return $this->aggregateResolver;
    }

    /**
     * Retrieve the concats
     *
     * @return array
     */
    public function getConcats()
    {
        return $this->concats;
    }

    /**
     * {@inheritDoc}
     */
    public function resolve($name)
    {
        if (!isset($this->concats[$name])) {
            return null;
        }

        $resolvedAssets = array();

        foreach ((array) $this->concats[$name] as $assetName) {
            $resolvedAsset = $this->getAggregateResolver()->resolve((string) $assetName);

            if (!$resolvedAsset instanceof AssetInterface) {
                throw new Exception\RuntimeException(
                    sprintf(
                        'Asset "%s" from collection "%s" can\'t be resolved '
                        .'to an Asset implementing Assetic\Asset\AssetInterface.',
                        $assetName,
                        $name
                    )
                );
            }

            $resolvedAsset->mimetype = $this->getMimeResolver()->getMimeType(
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                $resolvedAsset->getSourceRoot() . $resolvedAsset->getSourcePath()
            );

            $this->getAssetFilterManager()->setFilters($assetName, $resolvedAsset);

            $resolvedAssets[] = $resolvedAsset;
        }
        $aggregateAsset = new AggregateAsset($resolvedAssets);
        $this->getAssetFilterManager()->setFilters($name, $aggregateAsset);
        $aggregateAsset->setTargetPath($name);
        $aggregateAsset->mimetype = $this->getMimeResolver()->getMimeType($name);

        return $aggregateAsset;
    }

    /**
     * Set the AssetFilterManager.
     *
     * @param AssetFilterManager $filterManager
     */
    public function setAssetFilterManager(AssetFilterManager $filterManager)
    {
        $this->filterManager = $filterManager;
    }

    /**
     * Get the AssetFilterManager
     *
     * @return AssetFilterManager
     */
    public function getAssetFilterManager()
    {
        return $this->filterManager;
    }

    /**
     * {@inheritDoc}
     */
    public function collect()
    {
        return array_keys($this->concats);
    }
}


1			<?php
2
3			namespace AssetManager\Core\Resolver;
4
5			use Assetic\Asset\AssetInterface;
6			use AssetManager\Core\Asset\AggregateAsset;
7			use AssetManager\Core\Exception;
8			use AssetManager\Core\Service\AssetFilterManager;
9			use AssetManager\Core\Service\AssetFilterManagerAwareInterface;
10			use AssetManager\Core\Service\MimeResolver;
11			use Traversable;
12			use Zend\Stdlib\ArrayUtils;
13
14			/**
15			* This resolver allows the resolving of concatenated files.
16			* Concatted files are added as an StringAsset and filters get applied to concatenated string.
17			*/
18			class ConcatResolver implements
19			ResolverInterface,
20			AggregateResolverAwareInterface,
21			AssetFilterManagerAwareInterface,
22			MimeResolverAwareInterface
23			{
24			/**
25			* @var null\|ResolverInterface
26			*/
27			protected $aggregateResolver;
28
29			/**
30			* @var null\|AssetFilterManager The filterManager service.
31			*/
32			protected $filterManager;
33
34			/**
35			* @var array the concats
36			*/
37			protected $concats = array();
38
39			/**
40			* @var MimeResolver The mime resolver.
41			*/
42			protected $mimeResolver;
43
44			/**
45			* Constructor
46			*
47			* Instantiate and optionally populate concats.
48			*
49			* @param array\|Traversable $concats
50			*/
51			public function __construct($concats = array())
52			{
53			$this->setConcats($concats);
54			}
55
56			/**
57			* Set the mime resolver
58			*
59			* @param MimeResolver $resolver
60			*/
61			public function setMimeResolver(MimeResolver $resolver)
62			{
63			$this->mimeResolver = $resolver;
64			}
65
66			/**
67			* Get the mime resolver
68			*
69			* @return MimeResolver
70			*/
71			public function getMimeResolver()
72			{
73			return $this->mimeResolver;
74			}
75
76			/**
77			* Set (overwrite) concats
78			*
79			* Concats should be arrays or Traversable objects with name => path pairs
80			*
81			* @param array\|Traversable $concats
82			* @throws Exception\InvalidArgumentException
83			*/
84			public function setConcats($concats)
85			{
86			$this->concats = ArrayUtils::iteratorToArray($concats);
87			}
88
89			/**
90			* Set the aggregate resolver.
91			*
92			* @param ResolverInterface $aggregateResolver
93			*/
94			public function setAggregateResolver(ResolverInterface $aggregateResolver)
95			{
96			$this->aggregateResolver = $aggregateResolver;
97			}
98
99			/**
100			* Get the aggregate resolver.
101			*
102			* @return ResolverInterface
103			*/
104			public function getAggregateResolver()
105			{
106			return $this->aggregateResolver;
107			}
108
109			/**
110			* Retrieve the concats
111			*
112			* @return array
113			*/
114			public function getConcats()
115			{
116			return $this->concats;
117			}
118
119			/**
120			* {@inheritDoc}
121			*/
122			public function resolve($name)
123			{
124			if (!isset($this->concats[$name])) {
125			return null;
126			}
127
128			$resolvedAssets = array();
129
130			foreach ((array) $this->concats[$name] as $assetName) {
131			$resolvedAsset = $this->getAggregateResolver()->resolve((string) $assetName);
132
133			if (!$resolvedAsset instanceof AssetInterface) {
134			throw new Exception\RuntimeException(
135			sprintf(
136			'Asset "%s" from collection "%s" can\'t be resolved '
137			.'to an Asset implementing Assetic\Asset\AssetInterface.',
138			$assetName,
139			$name
140			)
141			);
142			}
143
144			$resolvedAsset->mimetype = $this->getMimeResolver()->getMimeType(
			0 ignored issues – show Bug introduced 2017-09-21 22:55 UTC by Report Bug Copy Issue Report Accessing `mimetype` on the interface `Assetic\Asset\AssetInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
145			$resolvedAsset->getSourceRoot() . $resolvedAsset->getSourcePath()
146			);
147
148			$this->getAssetFilterManager()->setFilters($assetName, $resolvedAsset);
149
150			$resolvedAssets[] = $resolvedAsset;
151			}
152			$aggregateAsset = new AggregateAsset($resolvedAssets);
153			$this->getAssetFilterManager()->setFilters($name, $aggregateAsset);
154			$aggregateAsset->setTargetPath($name);
155			$aggregateAsset->mimetype = $this->getMimeResolver()->getMimeType($name);
156
157			return $aggregateAsset;
158			}
159
160			/**
161			* Set the AssetFilterManager.
162			*
163			* @param AssetFilterManager $filterManager
164			*/
165			public function setAssetFilterManager(AssetFilterManager $filterManager)
166			{
167			$this->filterManager = $filterManager;
168			}
169
170			/**
171			* Get the AssetFilterManager
172			*
173			* @return AssetFilterManager
174			*/
175			public function getAssetFilterManager()
176			{
177			return $this->filterManager;
178			}
179
180			/**
181			* {@inheritDoc}
182			*/
183			public function collect()
184			{
185			return array_keys($this->concats);
186			}
187			}
188

wshafer / assetmanager-core

ConcatResolver::collect() A last analyzed 2017-09-21 22:56 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

ConcatResolver::collect() A
last analyzed 2017-09-21 22:56 UTC