Minify::restore() - Code Metrics - ArjanSchouten/HtmlMinifier - Measure and Improve Code Quality continuously with Scrutinizer

Minify::restore() A
last analyzed 2017-10-02 19:22 UTC

↳ Parent: Minify

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
c	0
b	0
f	0
rs	9.4285
ccs	3
cts	3
cp	1
cc	1
eloc	3
nc	1
nop	1
crap	1

<?php

namespace ArjanSchouten\HtmlMinifier;

use ArjanSchouten\HtmlMinifier\Minifiers\Html\AttributeQuoteMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\BooleanAttributeMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\CommentMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\EmptyAttributeMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\JavascriptEventsMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\OptionalElementMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\RedundantAttributeMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\Html\WhitespaceMinifier;
use ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface;
use ArjanSchouten\HtmlMinifier\Placeholders\CommentPlaceholder;
use ArjanSchouten\HtmlMinifier\Placeholders\Php\PhpPlaceholder;
use ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface;
use ArjanSchouten\HtmlMinifier\Placeholders\WhitespacePlaceholder;
use InvalidArgumentException;

class Minify
{
    /**
     * @var \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]
     */
    protected $placeholders = [
        PhpPlaceholder::class,
        CommentPlaceholder::class,
        WhitespacePlaceholder::class,
    ];

    /**
     * @var \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]
     */
    protected $minifiers = [
        CommentMinifier::class,
        WhitespaceMinifier::class,
        AttributeQuoteMinifier::class,
        EmptyAttributeMinifier::class,
        OptionalElementMinifier::class,
        BooleanAttributeMinifier::class,
        JavascriptEventsMinifier::class,
        RedundantAttributeMinifier::class,
    ];

    /**
     * @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
     * @param array                                     $options
     *
     * @return \ArjanSchouten\HtmlMinifier\MinifyContext
     */
    public function run(MinifyContext $context, $options = [])
    {
        $context->addMinificationStep($context->getContents(), 'Initial step');
        $context = $this->placeholders($context);
        $context = $this->minifiers($context, $options);

        return $this->restore($context);
    }

    /**
     * @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
     *
     * @return \ArjanSchouten\HtmlMinifier\MinifyContext
     */
    protected function placeholders(MinifyContext $context)
    {
        foreach ($this->placeholders as $placeholder) {
            $placeholder = new $placeholder();
            $context = $placeholder->process($context);
        }

        return $context;
    }

    /**
     * @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
     * @param array                                     $options
     *
     * @return \ArjanSchouten\HtmlMinifier\MinifyContext
     */
    protected function minifiers(MinifyContext $context, $options = [])
    {
        foreach ($this->minifiers as $minifier) {
            $minifier = new $minifier();

            $provides = $minifier->provides();
            if ($this->runAll($options) || $this->isOptionSet($provides, $options)) {
                $context = $minifier->process($context);
                $context->addMinificationStep($context->getContents(), $this->getClassName($minifier).'|'.$minifier->provides());
            }
        }

        return $context;
    }

    /**
     * Checks if all minifiers should be runned.
     *
     * @param array $options
     *
     * @return bool
     */
    protected function runAll($options = [])
    {
        return isset($options[Options::ALL]) && $options[Options::ALL];
    }

    /**
     * Check whether an option is set in the options aray.
     *
     * @param string $provides
     * @param array  $options
     *
     * @return bool
     */
    protected function isOptionSet($provides, $options = [])
    {
        if (isset($options[$provides]) && $options[$provides] === true) {
            return true;
        } elseif (!isset($options[$provides]) && Options::options()[$provides]->isDefault()) {
            return true;
        }

        return false;
    }

    /**
     * Restore placeholders with their original content.
     *
     * @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
     *
     * @return \ArjanSchouten\HtmlMinifier\MinifyContext
     */
    protected function restore(MinifyContext $context)
    {
        $withoutPlaceholders = $context->getPlaceholderContainer()->restorePlaceholders($context->getContents());

        return $context->setContents($withoutPlaceholders);
    }

    /**
     * @return \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]
     */
    public function getPlaceholders()
    {
        return $this->placeholders;
    }

    /**
     * Add a placeholder strategy to the registered placeholders.
     *
     * @param string $placeholder
     *
     * @return \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]

     */
    public function addPlaceholder($placeholder)

    {
        if (!isset(class_implements($placeholder)[PlaceholderInterface::class])) {
            throw new InvalidArgumentException('The class ['.$placeholder.'] should be a member of the ['.PlaceholderInterface::class.']');
        } elseif (in_array($placeholder, $this->placeholders)) {
            throw new InvalidArgumentException('The placeholder ['.$placeholder.'] is already added to the minifier!');
        }

        $this->placeholders[] = $placeholder;

        return $this->placeholders;
    }

    /**
     * @return \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]
     */
    public function getMinifiers()
    {
        return $this->minifiers;
    }

    /**
     * Add a placeholder strategy to the registered placeholders.
     *
     * @param string $minifier
     *
     * @return \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]

     */
    public function addMinifier($minifier)

    {
        if (!isset(class_implements($minifier)[MinifierInterface::class])) {
            throw new InvalidArgumentException('The class ['.$minifier.'] should be a member of the ['.MinifierInterface::class.']');
        } elseif (in_array($minifier, $this->minifiers)) {
            throw new InvalidArgumentException('The minifier ['.$minifier.'] is already added to the minifier!');
        }

        $this->minifiers[] = $minifier;

        return $this->minifiers;
    }

    /**
     * Get the classname without the namespace.
     *
     * @param $object
     *
     * @return string
     */
    private function getClassName($object)
    {
        $class = get_class($object);
        if (($index = strrpos($class, '\\'))) {
            $fixForTrailingBackslash = 1;

            return substr($class, $index + $fixForTrailingBackslash);
        }

        return $class;
    }
}


1			<?php
2
3			namespace ArjanSchouten\HtmlMinifier;
4
5			use ArjanSchouten\HtmlMinifier\Minifiers\Html\AttributeQuoteMinifier;
6			use ArjanSchouten\HtmlMinifier\Minifiers\Html\BooleanAttributeMinifier;
7			use ArjanSchouten\HtmlMinifier\Minifiers\Html\CommentMinifier;
8			use ArjanSchouten\HtmlMinifier\Minifiers\Html\EmptyAttributeMinifier;
9			use ArjanSchouten\HtmlMinifier\Minifiers\Html\JavascriptEventsMinifier;
10			use ArjanSchouten\HtmlMinifier\Minifiers\Html\OptionalElementMinifier;
11			use ArjanSchouten\HtmlMinifier\Minifiers\Html\RedundantAttributeMinifier;
12			use ArjanSchouten\HtmlMinifier\Minifiers\Html\WhitespaceMinifier;
13			use ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface;
14			use ArjanSchouten\HtmlMinifier\Placeholders\CommentPlaceholder;
15			use ArjanSchouten\HtmlMinifier\Placeholders\Php\PhpPlaceholder;
16			use ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface;
17			use ArjanSchouten\HtmlMinifier\Placeholders\WhitespacePlaceholder;
18			use InvalidArgumentException;
19
20			class Minify
21			{
22			/**
23			* @var \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]
24			*/
25			protected $placeholders = [
26			PhpPlaceholder::class,
27			CommentPlaceholder::class,
28			WhitespacePlaceholder::class,
29			];
30
31			/**
32			* @var \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]
33			*/
34			protected $minifiers = [
35			CommentMinifier::class,
36			WhitespaceMinifier::class,
37			AttributeQuoteMinifier::class,
38			EmptyAttributeMinifier::class,
39			OptionalElementMinifier::class,
40			BooleanAttributeMinifier::class,
41			JavascriptEventsMinifier::class,
42			RedundantAttributeMinifier::class,
43			];
44
45			/**
46			* @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
47			* @param array $options
48			*
49			* @return \ArjanSchouten\HtmlMinifier\MinifyContext
50			*/
51	3		public function run(MinifyContext $context, $options = [])
52			{
53	3		$context->addMinificationStep($context->getContents(), 'Initial step');
54	3		$context = $this->placeholders($context);
55	3		$context = $this->minifiers($context, $options);
56
57	3		return $this->restore($context);
58			}
59
60			/**
61			* @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
62			*
63			* @return \ArjanSchouten\HtmlMinifier\MinifyContext
64			*/
65	3		protected function placeholders(MinifyContext $context)
66			{
67	3		foreach ($this->placeholders as $placeholder) {
68	3		$placeholder = new $placeholder();
69	3		$context = $placeholder->process($context);
70			}
71
72	3		return $context;
73			}
74
75			/**
76			* @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
77			* @param array $options
78			*
79			* @return \ArjanSchouten\HtmlMinifier\MinifyContext
80			*/
81	3		protected function minifiers(MinifyContext $context, $options = [])
82			{
83	3		foreach ($this->minifiers as $minifier) {
84	3		$minifier = new $minifier();
85
86	3		$provides = $minifier->provides();
87	3		if ($this->runAll($options) \|\| $this->isOptionSet($provides, $options)) {
88	3		$context = $minifier->process($context);
89	3		$context->addMinificationStep($context->getContents(), $this->getClassName($minifier).'\|'.$minifier->provides());
90			}
91			}
92
93	3		return $context;
94			}
95
96			/**
97			* Checks if all minifiers should be runned.
98			*
99			* @param array $options
100			*
101			* @return bool
102			*/
103	3		protected function runAll($options = [])
104			{
105	3		return isset($options[Options::ALL]) && $options[Options::ALL];
106			}
107
108			/**
109			* Check whether an option is set in the options aray.
110			*
111			* @param string $provides
112			* @param array $options
113			*
114			* @return bool
115			*/
116	2		protected function isOptionSet($provides, $options = [])
117			{
118	2		if (isset($options[$provides]) && $options[$provides] === true) {
119	2		return true;
120	2		} elseif (!isset($options[$provides]) && Options::options()[$provides]->isDefault()) {
121	2		return true;
122			}
123
124	2		return false;
125			}
126
127			/**
128			* Restore placeholders with their original content.
129			*
130			* @param \ArjanSchouten\HtmlMinifier\MinifyContext $context
131			*
132			* @return \ArjanSchouten\HtmlMinifier\MinifyContext
133			*/
134	3		protected function restore(MinifyContext $context)
135			{
136	3		$withoutPlaceholders = $context->getPlaceholderContainer()->restorePlaceholders($context->getContents());
137
138	3		return $context->setContents($withoutPlaceholders);
139			}
140
141			/**
142			* @return \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]
143			*/
144	1		public function getPlaceholders()
145			{
146	1		return $this->placeholders;
147			}
148
149			/**
150			* Add a placeholder strategy to the registered placeholders.
151			*
152			* @param string $placeholder
153			*
154			* @return \ArjanSchouten\HtmlMinifier\Placeholders\PlaceholderInterface[]
			0 ignored issues – show Documentation introduced 2016-02-02 21:08 UTC by Report Bug Copy Issue Report Should the return type not be `array<PlaceholderInterface\|string>`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
155			*/
156	1	View Code Duplication	public function addPlaceholder($placeholder)
			0 ignored issues – show Duplication introduced 2017-09-16 12:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
157			{
158	1		if (!isset(class_implements($placeholder)[PlaceholderInterface::class])) {
159	1		throw new InvalidArgumentException('The class ['.$placeholder.'] should be a member of the ['.PlaceholderInterface::class.']');
160	1		} elseif (in_array($placeholder, $this->placeholders)) {
161			throw new InvalidArgumentException('The placeholder ['.$placeholder.'] is already added to the minifier!');
162			}
163
164	1		$this->placeholders[] = $placeholder;
165
166	1		return $this->placeholders;
167			}
168
169			/**
170			* @return \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]
171			*/
172	1		public function getMinifiers()
173			{
174	1		return $this->minifiers;
175			}
176
177			/**
178			* Add a placeholder strategy to the registered placeholders.
179			*
180			* @param string $minifier
181			*
182			* @return \ArjanSchouten\HtmlMinifier\Minifiers\MinifierInterface[]
			0 ignored issues – show Documentation introduced 2016-02-02 21:08 UTC by Report Bug Copy Issue Report Should the return type not be `array<MinifierInterface\|string>`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
183			*/
184	1	View Code Duplication	public function addMinifier($minifier)
			0 ignored issues – show Duplication introduced 2017-09-16 12:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
185			{
186	1		if (!isset(class_implements($minifier)[MinifierInterface::class])) {
187			throw new InvalidArgumentException('The class ['.$minifier.'] should be a member of the ['.MinifierInterface::class.']');
188	1		} elseif (in_array($minifier, $this->minifiers)) {
189			throw new InvalidArgumentException('The minifier ['.$minifier.'] is already added to the minifier!');
190			}
191
192	1		$this->minifiers[] = $minifier;
193
194	1		return $this->minifiers;
195			}
196
197			/**
198			* Get the classname without the namespace.
199			*
200			* @param $object
201			*
202			* @return string
203			*/
204	3		private function getClassName($object)
205			{
206	3		$class = get_class($object);
207	3		if (($index = strrpos($class, '\\'))) {
208	3		$fixForTrailingBackslash = 1;
209
210	3		return substr($class, $index + $fixForTrailingBackslash);
211			}
212
213			return $class;
214			}
215			}
216

ArjanSchouten / HtmlMinifier

Minify::restore() A last analyzed 2017-10-02 19:22 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Minify::restore() A
last analyzed 2017-10-02 19:22 UTC