├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── composer.json
├── phpunit.xml
├── src
    ├── Fitztrev
    │   └── LaravelHtmlMinify
    │   │   ├── LaravelHtmlMinifyCompiler.php
    │   │   └── LaravelHtmlMinifyServiceProvider.php
    └── config
    │   └── config.php
└── tests
    └── BaseMinifyTest.php


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | composer.phar
3 | composer.lock
4 | .DS_Store
5 | 
6 | report
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 5.3
 5 |   - 5.4
 6 |   - 5.5
 7 | 
 8 | before_install:
 9 |   - wget http://cs.sensiolabs.org/get/php-cs-fixer.phar
10 | 
11 | before_script:
12 |   - composer self-update
13 |   - composer install --dev
14 | 
15 | script:
16 |   - phpunit
17 |   - output=$(php php-cs-fixer.phar fix -v --dry-run --level=psr2 .); if [[ $output ]]; then while read -r line; do echo -e "\e[00;31m$line\e[00m"; done <<< "$output"; false; fi;
18 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 Trevor Fitzgerald
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## UPDATE for Laravel 5/5.1+
 2 | 
 3 | Read my preferred way of minifying HTML in Laravel 5/5.1+ apps here: [Using Gulp to Minify Laravel Blade Templates](https://github.com/fitztrev/laravel-html-minify/wiki/Laravel-5---5.1-HTML-Minifying)
 4 | 
 5 | ---
 6 | 
 7 | # Laravel HTML Minify
 8 | 
 9 | ### For Laravel 4 - See [here](https://github.com/fitztrev/laravel-html-minify/wiki/Laravel-5---5.1-HTML-Minifying) for L5+
10 | 
11 | [![Build Status](https://travis-ci.org/fitztrev/laravel-html-minify.png)](https://travis-ci.org/fitztrev/laravel-html-minify)
12 | [![Total Downloads](https://poser.pugx.org/fitztrev/laravel-html-minify/downloads.png)](https://packagist.org/packages/fitztrev/laravel-html-minify)
13 | 
14 | ## About
15 | 
16 | This package compresses the HTML output from your Laravel 4 application, seamlessly reducing the overall response size of your pages.
17 | 
18 | Other scripts that I've seen will compress the HTML output on-the-fly for each request. Instead, this package extends the Blade compiler to save the compiled template files to disk in their compressed state, reducing the overhead for each request.
19 | 
20 | ## Why?
21 | 
22 | Even with gzip enabled, there is still an improvement in the response size for HTML content-type documents.
23 | 
24 | Test Page | w/o Gzip | w/ Gzip | w/ Gzip + Laravel HTML Minify
25 | --- | ---: | ---: | :---:
26 | **#1** | 8,039 bytes | 1,944 bytes | **1,836 bytes** (5.6% improvement)
27 | **#2** | 377,867 bytes | 5,247 bytes | **4,314 bytes** (17.8% improvement)
28 | 
29 | ## Installation
30 | 
31 | 1. Add `"fitztrev/laravel-html-minify": "1.*"` to **composer.json**.
32 | 2. Run `composer update`
33 | 3. Add `Fitztrev\LaravelHtmlMinify\LaravelHtmlMinifyServiceProvider` to the list of providers in **app/config/app.php**.
34 | 4. **Important:** You won't see any changes until you edit your `*.blade.php` template files. Once Laravel detects a change, it will recompile them, which is when this package will go to work. To force all views to be recompiled, just run this command: `find . -name "*.blade.php" -exec touch {} \;`
35 | 
36 | ## Config
37 | 
38 | Optionally, you can choose to customize how the minifier functions for different environments. Publish the configuration file and edit accordingly.
39 | 
40 |     $ php artisan config:publish fitztrev/laravel-html-minify
41 | 
42 | ### Options
43 | 
44 | - **`enabled`** - *boolean*, default **true**
45 | 
46 | If you are using a javascript framework that conflicts with Blade's tags, you can change them.
47 | 
48 | - **`blade.contentTags`** - *array*, default `{{` and `}}`
49 | - **`blade.escapedContentTags`** - *array*, default `{{{` and `}}}`
50 | 
51 | #### Skipping minification
52 | 
53 | To prevent the minification of a view file, add `skipmin` somewhere in the view.
54 | 
55 | ```
56 | {{-- skipmin --}}
57 | <!-- skipmin -->
58 | ```
59 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "fitztrev/laravel-html-minify",
 3 |     "description": "Minifies the HTML output of Laravel 4 applications",
 4 |     "keywords": ["laravel", "l4", "html", "optimization", "performance", "compress", "minify", "minifier", "blade"],
 5 |     "homepage": "https://github.com/fitztrev/laravel-html-minify",
 6 |     "license": "MIT",
 7 |     "authors": [
 8 |         {
 9 |             "name": "Trevor Fitzgerald",
10 |             "email": "fitztrev@gmail.com"
11 |         }
12 |     ],
13 |     "require": {
14 |         "illuminate/view": "4.x"
15 |     },
16 |     "require-dev": {
17 |         "mockery/mockery": "dev-master",
18 |         "phpunit/phpunit": "3.7.*",
19 |         "phpunit/php-code-coverage": ">=1.2.10,<1.3.0"
20 |     },
21 |     "autoload": {
22 |         "psr-0": {
23 |             "Fitztrev\\LaravelHtmlMinify": "src/"
24 |         }
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          syntaxCheck="false"
12 | >
13 |     <testsuites>
14 |         <testsuite name="Package Test Suite">
15 |             <directory suffix=".php">./tests/</directory>
16 |         </testsuite>
17 |     </testsuites>
18 | 
19 |     <filter>
20 |         <whitelist>
21 |             <file>src/Fitztrev/LaravelHtmlMinify/LaravelHtmlMinifyCompiler.php</file>
22 |         </whitelist>
23 |     </filter>
24 | 
25 |     <logging>
26 |         <log type="coverage-html" target="report/coverage" charset="UTF-8" yui="true" highlight="true"/>
27 |         <log type="coverage-clover" target="report/build/logs/clover.xml"/>
28 |     </logging>
29 | </phpunit>
30 | 


--------------------------------------------------------------------------------
/src/Fitztrev/LaravelHtmlMinify/LaravelHtmlMinifyCompiler.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Fitztrev\LaravelHtmlMinify;
 2 | 
 3 | use Illuminate\View\Compilers\BladeCompiler;
 4 | 
 5 | class LaravelHtmlMinifyCompiler extends BladeCompiler
 6 | {
 7 |     private $_config;
 8 | 
 9 |     public function __construct($config, $files, $cachePath)
10 |     {
11 |         parent::__construct($files, $cachePath);
12 | 
13 |         $this->_config = $config;
14 | 
15 |         // Add Minify to the list of compilers
16 |         if ($this->_config['enabled'] === true) {
17 |             $this->compilers[] = 'Minify';
18 |         }
19 | 
20 |         // Set Blade contentTags and escapedContentTags
21 |         $this->setContentTags(
22 |             $this->_config['blade']['contentTags'][0],
23 |             $this->_config['blade']['contentTags'][1]
24 |         );
25 | 
26 |         $this->setEscapedContentTags(
27 |             $this->_config['blade']['escapedContentTags'][0],
28 |             $this->_config['blade']['escapedContentTags'][1]
29 |         );
30 | 
31 |     }
32 | 
33 |     /**
34 |     * We'll only compress a view if none of the following conditions are met.
35 |     * 1) <pre> or <textarea> tags
36 |     * 2) Embedded javascript (opening <script> tag not immediately followed
37 |     * by </script>)
38 |     * 3) Value attribute that contains 2 or more adjacent spaces
39 |     *
40 |     * @param string $value the contents of the view file
41 |     *
42 |     * @return bool
43 |     */
44 |     public function shouldMinify($value)
45 |     {
46 |         if (preg_match('/skipmin/', $value)
47 |          || preg_match('/<(pre|textarea)/', $value)
48 |          || preg_match('/<script[^\??>]*>[^<\/script>]/', $value)
49 |          || preg_match('/value=("|\')(.*)([ ]{2,})(.*)("|\')/', $value)
50 |         ) {
51 |             return false;
52 |         } else {
53 |             return true;
54 |         }
55 |     }
56 | 
57 |     /**
58 |     * Compress the HTML output before saving it
59 |     *
60 |     * @param string $value the contents of the view file
61 |     *
62 |     * @return string
63 |     */
64 |     protected function compileMinify($value)
65 |     {
66 |         if ($this->shouldMinify($value)) {
67 |             $replace = array(
68 |                 '/<!--[^\[](.*?)[^\]]-->/s' => '',
69 |                 "/<\?php/"                  => '<?php ',
70 |                 "/\n([\S])/"                => ' $1',
71 |                 "/\r/"                      => '',
72 |                 "/\n/"                      => '',
73 |                 "/\t/"                      => ' ',
74 |                 "/ +/"                      => ' ',
75 |             );
76 | 
77 |             return preg_replace(
78 |                 array_keys($replace), array_values($replace), $value
79 |             );
80 |         } else {
81 |             return $value;
82 |         }
83 | 
84 |     }
85 | 
86 | }
87 | 


--------------------------------------------------------------------------------
/src/Fitztrev/LaravelHtmlMinify/LaravelHtmlMinifyServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php namespace Fitztrev\LaravelHtmlMinify;
 2 | 
 3 | use Illuminate\Support\ServiceProvider;
 4 | use Illuminate\View\Engines\CompilerEngine;
 5 | 
 6 | class LaravelHtmlMinifyServiceProvider extends ServiceProvider
 7 | {
 8 |     /**
 9 |      * Indicates if loading of the provider is deferred.
10 |      *
11 |      * @var bool
12 |      */
13 |     protected $defer = false;
14 | 
15 |     /**
16 |      * Bootstrap the application events.
17 |      *
18 |      * @return void
19 |      */
20 |     public function boot()
21 |     {
22 |         $this->package('fitztrev/laravel-html-minify');
23 |     }
24 | 
25 |     /**
26 |      * Register the service provider.
27 |      *
28 |      * @return void
29 |      */
30 |     public function register()
31 |     {
32 |         $app = $this->app;
33 |         $app->view->getEngineResolver()->register(
34 |             'blade.php',
35 |             function () use ($app) {
36 |                     $cachePath = storage_path() . '/views';
37 |                     $compiler  = new LaravelHtmlMinifyCompiler(
38 |                         $app->make('config')->get('laravel-html-minify::config'),
39 |                         $app['files'],
40 |                         $cachePath
41 |                     );
42 | 
43 |                     return new CompilerEngine($compiler);
44 |             }
45 |         );
46 |         $app->view->addExtension('blade.php', 'blade.php');
47 |     }
48 | 
49 |     /**
50 |      * Get the services provided by the provider.
51 |      *
52 |      * @return array
53 |      */
54 |     public function provides()
55 |     {
56 |         return array();
57 |     }
58 | 
59 | }
60 | 


--------------------------------------------------------------------------------
/src/config/config.php:
--------------------------------------------------------------------------------
 1 | <?php return array(
 2 | 
 3 |     // Turn on/off minification
 4 |     'enabled' => true,
 5 | 
 6 |     // If you are using a javascript framework that conflicts
 7 |     // with Blade's tags, you can change them here
 8 |     'blade' => array(
 9 |         'contentTags' => array('{{', '}}'),
10 |         'escapedContentTags' => array('{{{', '}}}')
11 |     )
12 | 
13 | );
14 | 


--------------------------------------------------------------------------------
/tests/BaseMinifyTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Mockery as m;
  4 | use Fitztrev\LaravelHtmlMinify\LaravelHtmlMinifyCompiler;
  5 | 
  6 | abstract class BaseMinifyTester extends PHPUnit_Framework_TestCase
  7 | {
  8 |     protected $config;
  9 | 
 10 |     public function setUp()
 11 |     {
 12 |         $this->compiler = new LaravelHtmlMinifyCompiler(
 13 |             $this->config,
 14 |             m::mock('Illuminate\Filesystem\Filesystem'),
 15 |             __DIR__
 16 |         );
 17 |     }
 18 | 
 19 |     /* *** */
 20 | 
 21 |     public function testRemoveHtmlComments()
 22 |     {
 23 |         $string = '<html>
 24 |             <body>
 25 |                 <!-- start content -->
 26 |                 <p>hello</p> <!-- greet the user -->
 27 |                 <!--
 28 |                     <p>old code that is commented out</p>
 29 |                 -->
 30 |                 <!-- end content -->
 31 |             </body>
 32 |         </html>';
 33 |         $expected = '<html> <body> <p>hello</p> </body> </html>';
 34 | 
 35 |         $result = $this->compiler->compileString($string);
 36 | 
 37 |         if ($this->config['enabled']) {
 38 |             $this->assertEquals($expected, $result);
 39 |         } else {
 40 |             $this->assertEquals($string, $result);
 41 |         }
 42 |     }
 43 | 
 44 |     public function testKeepConditionalComments()
 45 |     {
 46 |         $string = '<html>
 47 |             <body>
 48 |                 <!--[if IE 6]>
 49 |                     <p>hello, IE6 user</p>
 50 |                 <![endif]-->
 51 | 
 52 |                 <!--[if IE 8]><p>hello, IE8 user</p><![endif]-->
 53 |             </body>
 54 |         </html>';
 55 |         $expected = '<html> <body> <!--[if IE 6]> <p>hello, IE6 user</p> <![endif]--> <!--[if IE 8]><p>hello, IE8 user</p><![endif]--> </body> </html>';
 56 | 
 57 |         $result = $this->compiler->compileString($string);
 58 | 
 59 |         if ($this->config['enabled']) {
 60 |             $this->assertEquals($expected, $result);
 61 |         } else {
 62 |             $this->assertEquals($string, $result);
 63 |         }
 64 |     }
 65 | 
 66 |     /* *** */
 67 | 
 68 |     public function testPreTag()
 69 |     {
 70 |         $string = '<html>
 71 |             <body>
 72 |                 <pre>hello</pre>
 73 |             </body>
 74 |         </html>';
 75 |         $expected = '<html>
 76 |             <body>
 77 |                 <pre>hello</pre>
 78 |             </body>
 79 |         </html>';
 80 | 
 81 |         $result = $this->compiler->compileString($string);
 82 |         $this->assertEquals($expected, $result);
 83 |     }
 84 | 
 85 |     public function testPreTagWithClass()
 86 |     {
 87 |         $string = '<html>
 88 |             <body>
 89 |                 <pre class="test">hello</pre>
 90 |             </body>
 91 |         </html>';
 92 |         $expected = '<html>
 93 |             <body>
 94 |                 <pre class="test">hello</pre>
 95 |             </body>
 96 |         </html>';
 97 | 
 98 |         $result = $this->compiler->compileString($string);
 99 |         $this->assertEquals($expected, $result);
100 |     }
101 | 
102 |     public function testTextareaTag()
103 |     {
104 |         $string = '<html>
105 |             <body>
106 |                 <textarea>hello</textarea>
107 |             </body>
108 |         </html>';
109 |         $expected = '<html>
110 |             <body>
111 |                 <textarea>hello</textarea>
112 |             </body>
113 |         </html>';
114 | 
115 |         $result = $this->compiler->compileString($string);
116 |         $this->assertEquals($expected, $result);
117 |     }
118 | 
119 |     public function testTextareaTagWithAttributes()
120 |     {
121 |         $string = '<html>
122 |             <body>
123 |                 <textarea rows="5" cols="5"">hello</textarea>
124 |             </body>
125 |         </html>';
126 |         $expected = '<html>
127 |             <body>
128 |                 <textarea rows="5" cols="5"">hello</textarea>
129 |             </body>
130 |         </html>';
131 | 
132 |         $result = $this->compiler->compileString($string);
133 |         $this->assertEquals($expected, $result);
134 |     }
135 | 
136 |     /* *** */
137 | 
138 |     public function testSingleExternalScriptTag()
139 |     {
140 |         $string = '<html>
141 |             <head>
142 |                 <script type="text/javascript" src="script.js"></script>
143 |             </head>
144 |         </html>';
145 |         $expected = '<html> <head> <script type="text/javascript" src="script.js"></script> </head> </html>';
146 | 
147 |         $result = $this->compiler->compileString($string);
148 | 
149 |         if ($this->config['enabled']) {
150 |             $this->assertEquals($expected, $result);
151 |         } else {
152 |             $this->assertEquals($string, $result);
153 |         }
154 |     }
155 | 
156 |     public function testSingleExternalScriptTagWithCacheBuster()
157 |     {
158 |         $string = '<html>
159 |             <head>
160 |                 <script type="text/javascript" src="script.<?php echo filemtime("script.js"); ?>.js"></script>
161 |             </head>
162 |         </html>';
163 |         $expected = '<html> <head> <script type="text/javascript" src="script.<?php echo filemtime("script.js"); ?>.js"></script> </head> </html>';
164 | 
165 |         $result = $this->compiler->compileString($string);
166 | 
167 |         if ($this->config['enabled']) {
168 |             $this->assertEquals($expected, $result);
169 |         } else {
170 |             $this->assertEquals($string, $result);
171 |         }
172 |     }
173 | 
174 |     public function testMultipleExternalScriptTag()
175 |     {
176 |         $string = '<html>
177 |             <head>
178 |                 <script type="text/javascript" src="script1.js"></script>
179 |                 <script type="text/javascript" src="script2.js"></script>
180 |             </head>
181 |         </html>';
182 |         $expected = '<html> <head> <script type="text/javascript" src="script1.js"></script> <script type="text/javascript" src="script2.js"></script> </head> </html>';
183 | 
184 |         $result = $this->compiler->compileString($string);
185 | 
186 |         if ($this->config['enabled']) {
187 |             $this->assertEquals($expected, $result);
188 |         } else {
189 |             $this->assertEquals($string, $result);
190 |         }
191 |     }
192 | 
193 |     public function testExternalAndEmbeddedScriptTag()
194 |     {
195 |         $string = '<html>
196 |             <head>
197 |                 <script type="text/javascript" src="script.js"></script>
198 |                 <script type="text/javascript">
199 |                     alert("ok");
200 |                 </script>
201 |             </head>
202 |         </html>';
203 |         $expected = '<html>
204 |             <head>
205 |                 <script type="text/javascript" src="script.js"></script>
206 |                 <script type="text/javascript">
207 |                     alert("ok");
208 |                 </script>
209 |             </head>
210 |         </html>';
211 | 
212 |         $result = $this->compiler->compileString($string);
213 |         $this->assertEquals($expected, $result);
214 |     }
215 | 
216 |     public function testGoogleAdSenseEmbedTag()
217 |     {
218 |         $string = '<html>
219 |             <body>
220 |                 <script type="text/javascript"><!--
221 |                     google_ad_client = "ca-pub-XXX";
222 |                     /* faviconit */
223 |                     google_ad_slot = "XXX";
224 |                     google_ad_width = 300;
225 |                     google_ad_height = 600;
226 |                     //-->
227 |                 </script>
228 |                 <script type="text/javascript"
229 |                     src="//pagead2.googlesyndication.com/pagead/show_ads.js">
230 |                 </script>
231 |             </body>
232 |         </html>';
233 | 
234 |         $expected = '<html>
235 |             <body>
236 |                 <script type="text/javascript"><!--
237 |                     google_ad_client = "ca-pub-XXX";
238 |                     /* faviconit */
239 |                     google_ad_slot = "XXX";
240 |                     google_ad_width = 300;
241 |                     google_ad_height = 600;
242 |                     //-->
243 |                 </script>
244 |                 <script type="text/javascript"
245 |                     src="//pagead2.googlesyndication.com/pagead/show_ads.js">
246 |                 </script>
247 |             </body>
248 |         </html>';
249 | 
250 |         $result = $this->compiler->compileString($string);
251 |         $this->assertEquals($expected, $result);
252 |     }
253 | 
254 |     public function testEmbeddedScriptTagSingleLine()
255 |     {
256 |         $string = '<html>
257 |             <head>
258 |                 <script>alert("ok");</script>
259 |             </head>
260 |         </html>';
261 |         $expected = '<html>
262 |             <head>
263 |                 <script>alert("ok");</script>
264 |             </head>
265 |         </html>';
266 | 
267 |         $result = $this->compiler->compileString($string);
268 |         $this->assertEquals($expected, $result);
269 |     }
270 | 
271 |     public function testEmbeddedScriptTagMultipleLines()
272 |     {
273 |         $string = '<html>
274 |             <head>
275 |                 <script>
276 |                     alert("ok");
277 |                     alert("ok");
278 |                 </script>
279 |             </head>
280 |         </html>';
281 |         $expected = '<html>
282 |             <head>
283 |                 <script>
284 |                     alert("ok");
285 |                     alert("ok");
286 |                 </script>
287 |             </head>
288 |         </html>';
289 | 
290 |         $result = $this->compiler->compileString($string);
291 |         $this->assertEquals($expected, $result);
292 |     }
293 | 
294 |     /* *** */
295 | 
296 |     public function testValueWithoutMultipleSpacesSingleWord()
297 |     {
298 |         $string = '<html>
299 |             <body>
300 |                 <form>
301 |                     <input type="submit" value="Submit" />
302 |                 </form>
303 |             </body>
304 |         </html>';
305 |         $expected = '<html> <body> <form> <input type="submit" value="Submit" /> </form> </body> </html>';
306 | 
307 |         $result = $this->compiler->compileString($string);
308 | 
309 |         if ($this->config['enabled']) {
310 |             $this->assertEquals($expected, $result);
311 |         } else {
312 |             $this->assertEquals($string, $result);
313 |         }
314 |     }
315 | 
316 |     public function testValueWithoutMultipleSpacesSingleWordSingleQuotes()
317 |     {
318 |         $string = '<html>
319 |             <body>
320 |                 <form>
321 |                     <input type="submit" value=\'Submit\' />
322 |                 </form>
323 |             </body>
324 |         </html>';
325 |         $expected = '<html> <body> <form> <input type="submit" value=\'Submit\' /> </form> </body> </html>';
326 | 
327 |         $result = $this->compiler->compileString($string);
328 | 
329 |         if ($this->config['enabled']) {
330 |             $this->assertEquals($expected, $result);
331 |         } else {
332 |             $this->assertEquals($string, $result);
333 |         }
334 |     }
335 | 
336 |     public function testValueWithoutMultipleSpacesMultipleWords()
337 |     {
338 |         $string = '<html>
339 |             <body>
340 |                 <form>
341 |                     <input type="submit" value="Add Document" />
342 |                 </form>
343 |             </body>
344 |         </html>';
345 |         $expected = '<html> <body> <form> <input type="submit" value="Add Document" /> </form> </body> </html>';
346 | 
347 |         $result = $this->compiler->compileString($string);
348 | 
349 |         if ($this->config['enabled']) {
350 |             $this->assertEquals($expected, $result);
351 |         } else {
352 |             $this->assertEquals($string, $result);
353 |         }
354 |     }
355 | 
356 |     public function testValueWithMultipleSpaces()
357 |     {
358 |         $string = '<html>
359 |             <body>
360 |                 <form>
361 |                     <input type="submit" value="     Submit     " />
362 |                 </form>
363 |             </body>
364 |         </html>';
365 |         $expected = '<html>
366 |             <body>
367 |                 <form>
368 |                     <input type="submit" value="     Submit     " />
369 |                 </form>
370 |             </body>
371 |         </html>';
372 | 
373 |         $result = $this->compiler->compileString($string);
374 |         $this->assertEquals($expected, $result);
375 |     }
376 | 
377 |     public function testValueWithMultipleSpacesSingleQuotes()
378 |     {
379 |         $string = '<html>
380 |             <body>
381 |                 <form>
382 |                     <input type="submit" value=\'     Submit     \' />
383 |                 </form>
384 |             </body>
385 |         </html>';
386 |         $expected = '<html>
387 |             <body>
388 |                 <form>
389 |                     <input type="submit" value=\'     Submit     \' />
390 |                 </form>
391 |             </body>
392 |         </html>';
393 | 
394 |         $result = $this->compiler->compileString($string);
395 |         $this->assertEquals($expected, $result);
396 |     }
397 | 
398 |     /* *** */
399 | 
400 |     public function testAllowedHtml()
401 |     {
402 |         $string = '<html>
403 |             <body>
404 |                 <p>hello</p>
405 |             </body>
406 |         </html>';
407 |         $expected = '<html> <body> <p>hello</p> </body> </html>';
408 | 
409 |         $result = $this->compiler->compileString($string);
410 | 
411 |         if ($this->config['enabled']) {
412 |             $this->assertEquals($expected, $result);
413 |         } else {
414 |             $this->assertEquals($string, $result);
415 |         }
416 |     }
417 | 
418 |     public function testMultipleSpaces()
419 |     {
420 |         $string = '<html>
421 |             <body>
422 |                 <p>hello  with     random     spaces</p>
423 |             </body>
424 |         </html>';
425 |         $expected = '<html> <body> <p>hello with random spaces</p> </body> </html>';
426 | 
427 |         $result = $this->compiler->compileString($string);
428 | 
429 |         if ($this->config['enabled']) {
430 |             $this->assertEquals($expected, $result);
431 |         } else {
432 |             $this->assertEquals($string, $result);
433 |         }
434 |     }
435 | 
436 |     public function testNoIndentation()
437 |     {
438 |         $string = '<input
439 | type="text"
440 | name="myinput">';
441 |         $expected = '<input type="text" name="myinput">';
442 | 
443 |         $result = $this->compiler->compileString($string);
444 | 
445 |         if ($this->config['enabled']) {
446 |             $this->assertEquals($expected, $result);
447 |         } else {
448 |             $this->assertEquals($string, $result);
449 |         }
450 |     }
451 | 
452 |     public function testSkipMinification()
453 |     {
454 |         $string = '<p>
455 | <!-- skipmin -->
456 | </p>';
457 |         $expected = '<p>
458 | <!-- skipmin -->
459 | </p>';
460 | 
461 |         $result = $this->compiler->compileString($string);
462 |         $this->assertEquals($expected, $result);
463 |     }
464 | 
465 | }
466 | 
467 | class EnabledTester extends BaseMinifyTester
468 | {
469 |     public function __construct()
470 |     {
471 |         $this->config = array(
472 |             'enabled' => true,
473 |             'blade' => array(
474 |                 'contentTags' => array('{{', '}}'),
475 |                 'escapedContentTags' => array('{{{', '}}}')
476 |             )
477 |         );
478 |     }
479 | 
480 |     public function testConfigEnabled()
481 |     {
482 |         $this->assertEquals($this->config['enabled'], true);
483 |     }
484 | }
485 | 
486 | class DisabledTester extends BaseMinifyTester
487 | {
488 |     public function __construct()
489 |     {
490 |         $this->config = array(
491 |             'enabled' => false,
492 |             'blade' => array(
493 |                 'contentTags' => array('{{', '}}'),
494 |                 'escapedContentTags' => array('{{{', '}}}')
495 |             )
496 |         );
497 |     }
498 | 
499 |     public function testConfigDisabled()
500 |     {
501 |         $this->assertEquals($this->config['enabled'], false);
502 |     }
503 | }
504 | 
505 | class DefaultContentTags extends BaseMinifyTester
506 | {
507 |     public function __construct()
508 |     {
509 |         $this->config = array(
510 |             'enabled' => false,
511 |             'blade' => array(
512 |                 'contentTags' => array('{{', '}}'),
513 |                 'escapedContentTags' => array('{{{', '}}}')
514 |             )
515 |         );
516 |     }
517 | 
518 |     public function testDefaultContentTags()
519 |     {
520 |         $string = '{{ "hello world" }}';
521 |         $expected = '<?php echo "hello world"; ?>';
522 | 
523 |         $result = $this->compiler->compileString($string);
524 | 
525 |         $this->assertEquals($expected, $result);
526 |     }
527 | 
528 |     public function testDefaultEscapedContentTags()
529 |     {
530 |         $string = '{{{ "hello world" }}}';
531 |         $expected = '<?php echo e("hello world"); ?>';
532 | 
533 |         $result = $this->compiler->compileString($string);
534 | 
535 |         $this->assertEquals($expected, $result);
536 |     }
537 | }
538 | 
539 | class ChangedContentTags extends BaseMinifyTester
540 | {
541 |     public function __construct()
542 |     {
543 |         $this->config = array(
544 |             'enabled' => false,
545 |             'blade' => array(
546 |                 'contentTags' => array('[[', ']]'),
547 |                 'escapedContentTags' => array('[[[', ']]]')
548 |             )
549 |         );
550 |     }
551 | 
552 |     public function testChangedContentTags()
553 |     {
554 |         $string = '[[ "hello world" ]]';
555 |         $expected = '<?php echo "hello world"; ?>';
556 | 
557 |         $result = $this->compiler->compileString($string);
558 | 
559 |         $this->assertEquals($expected, $result);
560 |     }
561 | 
562 |     public function testChangedEscapedContentTags()
563 |     {
564 |         $string = '[[[ "hello world" ]]]';
565 |         $expected = '<?php echo e("hello world"); ?>';
566 | 
567 |         $result = $this->compiler->compileString($string);
568 | 
569 |         $this->assertEquals($expected, $result);
570 |     }
571 | }
572 | 


--------------------------------------------------------------------------------