├── .github
    └── workflows
    │   └── tests.yml
├── .gitignore
├── .styleci.yml
├── composer.json
├── config
    └── shortcodes.php
├── contributing.md
├── license.md
├── phpunit.xml
├── readme.md
├── src
    ├── Commands
    │   └── MakeShortcodeCommand.php
    ├── Debugbar
    │   └── ShortcodesCollector.php
    ├── Facades
    │   └── Shortcodes.php
    ├── LaravelShortcodesServiceProvider.php
    ├── Manager.php
    ├── Renderer.php
    ├── Shortcode.php
    ├── ShortcodeContract.php
    ├── Shortcodes
    │   └── BShortcode.php
    ├── View
    │   ├── Factory.php
    │   └── View.php
    └── helpers.php
├── stubs
    └── shortcode.stub
├── tests
    ├── Resources
    │   ├── BShortcode.php
    │   ├── CastsShortcode.php
    │   ├── ExceptionShortcode.php
    │   ├── ExceptionViewShortcode.php
    │   ├── HrShortcode.php
    │   └── ValidationShortcode.php
    ├── TestCase.php
    ├── Unit
    │   ├── BladeTest.php
    │   ├── HelpersTest.php
    │   ├── ManagerTest.php
    │   ├── ShortcodeTest.php
    │   └── ViewTest.php
    └── views
    │   ├── bold.blade.php
    │   ├── directive-block.blade.php
    │   ├── directive-inline.blade.php
    │   ├── exception.blade.php
    │   └── shortcode-exception.blade.php
└── views
    └── b.blade.php


/.github/workflows/tests.yml:
--------------------------------------------------------------------------------
 1 | name: Tests
 2 | on: [push]
 3 | jobs:
 4 |   run-tests:
 5 |     runs-on: ubuntu-latest
 6 |     name: PHP ${{ matrix.php }} - Laravel ${{ matrix.laravel }}
 7 |     strategy:
 8 |       fail-fast: true
 9 |       matrix:
10 |         php: [ 7.4, 8.0, 8.1 ]
11 |         laravel: [ 6.*, 8.*, 9.* ]
12 |         exclude:
13 |           - php: 8.0
14 |             laravel: 6.*
15 |           - php: 8.1
16 |             laravel: 6.*
17 |           - php: 7.4
18 |             laravel: 9.*
19 |         include:
20 |           - aravel: 6.*
21 |             testbench: 4.*
22 |             phpunit: 8.*
23 |           - laravel: 8.*
24 |             testbench: 6.*
25 |             phpunit: 9.*
26 |           - laravel: 9.*
27 |             testbench: 7.*
28 |             phpunit: 9.*
29 |     steps:
30 |       - name: Check out repository code
31 |         uses: actions/checkout@v2
32 |       - name: Setup PHP
33 |         uses: shivammathur/setup-php@v2
34 |         with:
35 |           php-version: ${{ matrix.php }}
36 |       - name: Install dependencies
37 |         run: |
38 |           composer require "illuminate/support:${{ matrix.laravel }}" "orchestra/testbench:${{ matrix.testbench }}" "phpunit/phpunit:${{ matrix.phpunit }}" --no-interaction --no-update
39 |           composer update --prefer-stable --prefer-dist --no-interaction --no-suggest
40 |       - name: Cache dependencies
41 |         uses: actions/cache@v1
42 |         with:
43 |           path: ~/.composer/cache/files
44 |           key: dependencies-${{ matrix.dependency-version }}-laravel-${{ matrix.laravel }}-php-${{ matrix.php }}-composer-${{ hashFiles('composer.json') }}
45 |       - name: Execute tests
46 |         run: vendor/bin/phpunit
47 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | /vendor
3 | npm-debug.log
4 | yarn-error.log
5 | composer.lock
6 | .phpunit.result.cache
7 | 


--------------------------------------------------------------------------------
/.styleci.yml:
--------------------------------------------------------------------------------
1 | preset: laravel
2 | 
3 | finder:
4 |    not-name:
5 |       - "Renderer.php"
6 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "vedmant/laravel-shortcodes",
 3 |     "description": "Wordress like shortcodes for Laravel",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Vedmant",
 8 |             "email": "vedmant@gmail.com",
 9 |             "homepage": "https://vedmant.com/laravel-shortcodes"
10 |         }
11 |     ],
12 |     "homepage": "https://github.com/vedmant/laravel-shortcodes",
13 |     "keywords": ["Laravel", "Shortcodes"],
14 |     "require": {
15 |         "php": ">=7.0.0",
16 |         "illuminate/contracts": ">=5.5.0",
17 |         "illuminate/view": ">=5.5.0",
18 |         "illuminate/support": ">=5.5.0"
19 |     },
20 |     "require-dev": {
21 |         "phpunit/phpunit": "9.*",
22 |         "mockery/mockery": "^1.2",
23 |         "orchestra/testbench": "^4",
24 |         "sempro/phpunit-pretty-print": "^1.0"
25 |     },
26 |     "autoload": {
27 |         "files": [
28 |             "src/helpers.php"
29 |         ],
30 |         "psr-4": {
31 |             "Vedmant\\LaravelShortcodes\\": "src/"
32 |         }
33 |     },
34 |     "autoload-dev": {
35 |         "psr-4": {
36 |             "Vedmant\\LaravelShortcodes\\Tests\\": "tests"
37 |         }
38 |     },
39 |     "extra": {
40 |         "laravel": {
41 |             "providers": [
42 |                 "Vedmant\\LaravelShortcodes\\LaravelShortcodesServiceProvider"
43 |             ],
44 |             "aliases": {
45 |                 "FeedReader": "Vedmant\\LaravelShortcodes\\Facades\\FeedReader"
46 |             }
47 |         }
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/config/shortcodes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | return [
 4 | 
 5 |     /*
 6 |     |--------------------------------------------------------------------------
 7 |     | Trow exeptions
 8 |     |--------------------------------------------------------------------------
 9 |     |
10 |     | True to throw exceptions, false to render exception message in place of
11 |     | shortcode.
12 |     |
13 |     */
14 | 
15 |     'throw_exceptions' => true,
16 | 
17 |     /*
18 |     |--------------------------------------------------------------------------
19 |     | Automatically render views
20 |     |--------------------------------------------------------------------------
21 |     |
22 |     | If it should automatically render shortcodes in views.
23 |     |
24 |     */
25 | 
26 |     'render_views' => true,
27 | 
28 |     /*
29 |     |--------------------------------------------------------------------------
30 |     | Laravel Debugbar integration
31 |     |--------------------------------------------------------------------------
32 |     |
33 |     | If it should integrate in the Laravel Debug Bar.
34 |     |
35 |     */
36 | 
37 |     'debugbar' => true,
38 | 
39 | ];
40 | 


--------------------------------------------------------------------------------
/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | Contributions are welcome and will be fully credited.
 4 | 
 5 | Contributions are accepted via Pull Requests on [Github](https://github.com/vedmant/laravelshortcodes).
 6 | 
 7 | ## Pull Requests
 8 | 
 9 | - **Add tests!** - Your patch won't be accepted if it doesn't have tests.
10 | 
11 | - **Document any change in behaviour** - Make sure the `readme.md` and any other relevant documentation are kept up-to-date.
12 | 
13 | - **Consider our release cycle** - We try to follow [SemVer v2.0.0](http://semver.org/). Randomly breaking public APIs is not an option.
14 | 
15 | - **One pull request per feature** - If you want to do more than one thing, send multiple pull requests.
16 | 
17 | - **Send coherent history** - Make sure each individual commit in your pull request is meaningful. If you had to make multiple intermediate commits while developing, please [squash them](http://www.git-scm.com/book/en/v2/Git-Tools-Rewriting-History#Changing-Multiple-Commit-Messages) before submitting.
18 | 
19 | 
20 | **Happy coding**!
21 | 


--------------------------------------------------------------------------------
/license.md:
--------------------------------------------------------------------------------
 1 | The MIT License
 2 | 
 3 | Copyright (c) 2019 Vedmat, Inc. http://vedmant.com
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all 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,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit bootstrap="vendor/autoload.php"
 3 |          backupGlobals="false"
 4 |          backupStaticAttributes="false"
 5 |          colors="true"
 6 |          verbose="true"
 7 |          convertErrorsToExceptions="true"
 8 |          convertNoticesToExceptions="true"
 9 |          convertWarningsToExceptions="true"
10 |          processIsolation="false"
11 |          stopOnFailure="false">
12 |    <testsuites>
13 |       <testsuite name="Unit">
14 |          <directory suffix="Test.php">./tests/Unit</directory>
15 |       </testsuite>
16 |    </testsuites>
17 |     <filter>
18 |         <whitelist>
19 |             <directory>src/</directory>
20 |         </whitelist>
21 |     </filter>
22 | </phpunit>
23 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
  1 | # Laravel Shortcodes
  2 | 
  3 | [![Latest Version on Packagist][ico-version]][link-packagist]
  4 | [![Software License][ico-license]](license.md)
  5 | [![Total Downloads][ico-downloads]][link-downloads]
  6 | ![Tests](https://github.com/vedmant/laravel-shortcodes/actions/workflows/tests.yml/badge.svg)
  7 | [![StyleCI](https://styleci.io/repos/182276041/shield)](https://styleci.io/repos/182276041)
  8 | 
  9 | Wordpress based Shortcodes for [Laravel Framework](https://github.com/laravel/laravel) with shared variables, debugbar integration, 
 10 | flexible configurations and other useful features.
 11 | 
 12 | Build powerful and simple layouts using shortcodes in the content or views like this:
 13 | 
 14 | ```php
 15 | [b]Bold text[/b]
 16 | 
 17 | [row]
 18 |   [col md=8]
 19 |     [posts_list types="post,gallery" show_tags="yes"]
 20 |   [/col]
 21 |   [col md=4]
 22 |     [poll id="1"]
 23 |     [user_info username="test_user" website="mywebsite.com" active="yes"]
 24 |     [last_free_post title="Free Posts"]
 25 |   [/col]
 26 | [/row]
 27 | ``` 
 28 | 
 29 | ## Installation
 30 | 
 31 | Via Composer
 32 | 
 33 | ``` bash
 34 | $ composer require vedmant/laravel-shortcodes
 35 | ```
 36 | 
 37 | ## Configuraton 
 38 | 
 39 | Publish configuration.
 40 | ```bash
 41 | php artisan vendor:publish --tag=shortcodes
 42 | ```
 43 | 
 44 | It will publish configuration file `shortcodes.php`, edit it as needed.
 45 | 
 46 | 
 47 | ## Usage
 48 | 
 49 | 
 50 | ### Shortcode class
 51 | 
 52 | Shortcode class should extend abstract \Vedmant\LaravelShortcodes\Shortcode class.
 53 | 
 54 | This packages adds the `make:shortcode` artisan command:
 55 | ```bash
 56 | php artisan make:shortcode PostsListShortcode
 57 | ```
 58 | Which generates a shortcode class in the `app/Shortcodes` folder by default.
 59 | 
 60 | 
 61 | ### Register shortcodes
 62 | 
 63 | You can use `AppServiceProvider::boot` method to register all needed shortcodes.
 64 | 
 65 | Using shortcode class:
 66 | ```php
 67 | Shortcodes::add('b', BShortcode::class);
 68 | ```
 69 | 
 70 | Using shortcode classes in array, preferable for lots of shortcodes:
 71 | ```php
 72 | Shortcodes::add([
 73 |    'a' => AShortcode::class,
 74 |    'b' => BShortcode::class,
 75 | ]);
 76 | ```
 77 | 
 78 | Using closure:
 79 | ```php
 80 | Shortcodes::add('test', function ($atts, $content, $tag, $manager) {
 81 |    return new HtmlString('<strong>some test shortcode</strong>');
 82 | });
 83 | ```
 84 | 
 85 | ### Render shortcodes
 86 | 
 87 | #### Views auto-render
 88 | 
 89 | By default this package extends the `View` class to parse all shortcodes during views rendering.
 90 | This feature can be disabled in the config file: `'render_views' => false`. 
 91 | For better performance with lots of views it's advised to disable views auto-render.
 92 | 
 93 | #### Enable / disable rendering per view
 94 | 
 95 | Also to enable / disable rendering shortcodes for a specific view you can use:
 96 | 
 97 | ```php
 98 | view('some-view')->withShortcodes();
 99 | // Or
100 | view('some-view')->withoutShortcodes();
101 | ```
102 | 
103 | #### Render shortcodes with the facade
104 | 
105 | ```blade
106 | {{ Shortcodes::render('[b]bold[/b]') }}
107 | ```
108 | 
109 | #### Render shortcodes with blade directive
110 | 
111 | ```blade
112 | @shortcodes
113 |    [b class="block"]Content[/b]
114 | @endshortcodes
115 | 
116 | Or
117 | 
118 | @shortcodes('[b]bold[/b]')
119 | ```
120 | 
121 | #### Render shortcodes with `shortcodes()` helper
122 | 
123 | ```blade
124 | <div class="some-block">
125 |    {{ shortcodes('[b]bold[/b]') }}
126 | </div>
127 | ```
128 | 
129 | ### Shared attributes
130 | 
131 | Occasionally, you may need to share a piece of data with all shortcodes that are rendered by your application. 
132 | You may do so using the shortode facade's `share` method. 
133 | Typically, you should place calls to share in the controller, or within a service provider's boot method.
134 | ```php
135 | Shortcodes::share('post', $post);
136 | ```
137 | 
138 | Then you can get shared attributes in the shortcode class:
139 | 
140 | ```php
141 | $post = $this->shared('post');
142 | $allShared = $this->shared();
143 | ```
144 | 
145 | ### Attribute casting
146 | 
147 | The $casts property on your shortcode class provides a convenient method of converting attributes to 
148 | common data types. The $casts property should be an array where the key is the name of the attribute 
149 | being cast and the value is the type you wish to cast the column to. The supported cast types are: 
150 | `int`, `integer`, `real`, `float`, `double`, `boolean`, `array` (comma separated values) and `date`. 
151 | 
152 | ```php
153 | class YourShortcode extends Shortcode
154 | {
155 |     /**
156 |      * The attributes that should be cast to native types.
157 |      *
158 |      * @var array
159 |      */
160 |     protected $casts = [
161 |         'show_ids' => 'array',
162 |     ];
163 | }
164 | ```
165 | 
166 | Now the `show_ids` attribute will always be cast to an array when you access it.
167 | (array attributes are casted from comma separated string, eg. "1,2,3").
168 | 
169 | 
170 | ### Attribute validation
171 | 
172 | There is a simple way to validate attributes.
173 | Error messages will be rendered on the shortcode place.
174 | For convenients it will return attributes.
175 | 
176 | ```php
177 | class YourShortcode extends Shortcode
178 | {
179 |     /**
180 |      * Render shortcode
181 |      *
182 |      * @param string $content
183 |      * @return string
184 |      */
185 |     public function render($content)
186 |     {
187 |         $atts = $this->validate([
188 |             'post_id' => 'required|numeric|exists:posts,id', 
189 |         ]);
190 |     
191 |         //
192 |     }
193 | }
194 | ```
195 | 
196 | ### Option to not throw exceptions from shortcodes
197 | 
198 | There is a useful option to aviod server (500) error for whole page when one of shortocode has thrown an exception.
199 | 
200 | To enable it set `'throw_exceptions' => false,` in the `shortcodes.php` config file. 
201 | 
202 | This will render exception details in the place of a shortcode and will not crash whole page request with 500 error.
203 | It will still log exception to a log file and report to [Sentry](https://sentry.io/) if it's integrated.
204 | 
205 | 
206 | ### Generate data for documentation
207 | 
208 | There can be hundreds of registered shortcodes and having a way to show documentation for all 
209 | shortcodes is quite a good feature. There is simple method that will collect descriptions and attributes data
210 | from all registered shortcodes:
211 | ```php
212 | $data = Shortcodes::registeredData();
213 | ```
214 | It returns Collection object with generated data that can be used to generate any help information.
215 | 
216 | 
217 | ### Integration with Laravel Debugbar
218 | 
219 | This packages supports [Laravel Debugbar](https://github.com/barryvdh/laravel-debugbar) 
220 | and adds a tab with detailed info about rendered shortcodes. 
221 | Integration can be disabled in the config file with option: `'debugbar' => false,`.
222 | 
223 | 
224 | ## Testing
225 | 
226 | ``` bash
227 | $ vendor/bin/phpunit
228 | ```
229 | 
230 | 
231 | ## TODO
232 | 
233 | 1. Add custom widget for debugbar integration
234 | 1. Create performance profile tests, optimize performance
235 | 
236 | ## Contributing
237 | 
238 | Please see [contributing.md](contributing.md) for details and a todolist.
239 | 
240 | ## Security
241 | 
242 | If you discover any security related issues, please email vedmant@gmail.com instead of using the issue tracker.
243 | 
244 | ## Credits
245 | 
246 | - [All Contributors][link-contributors]
247 | 
248 | ## License
249 | 
250 | MIT. Please see the [license file](license.md) for more information.
251 | 
252 | [ico-version]: https://img.shields.io/packagist/v/vedmant/laravel-shortcodes.svg?style=flat-square
253 | [ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square
254 | [ico-downloads]: https://img.shields.io/packagist/dt/vedmant/laravel-shortcodes.svg?style=flat-square
255 | [ico-travis]: https://img.shields.io/travis/vedmant/laravel-shortcodes/master.svg?style=flat-square
256 | 
257 | [link-packagist]: https://packagist.org/packages/vedmant/laravel-shortcodes
258 | [link-downloads]: https://packagist.org/packages/vedmant/laravel-shortcodes
259 | [link-styleci]: https://github.styleci.io/repos/182276041
260 | [link-author]: https://github.com/vedmant
261 | [link-contributors]: ../../contributors
262 | 


--------------------------------------------------------------------------------
/src/Commands/MakeShortcodeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Commands;
 4 | 
 5 | use Illuminate\Console\GeneratorCommand;
 6 | 
 7 | class MakeShortcodeCommand extends GeneratorCommand
 8 | {
 9 |     /**
10 |      * The console command name.
11 |      *
12 |      * @var string
13 |      */
14 |     protected $name = 'make:shortcode';
15 | 
16 |     /**
17 |      * The console command description.
18 |      *
19 |      * @var string
20 |      */
21 |     protected $description = 'Create a new shortcode class';
22 | 
23 |     /**
24 |      * The type of class being generated.
25 |      *
26 |      * @var string
27 |      */
28 |     protected $type = 'Shortcode';
29 | 
30 |     /**
31 |      * Get the stub file for the generator.
32 |      *
33 |      * @return string
34 |      */
35 |     protected function getStub()
36 |     {
37 |         return __DIR__.'/../../stubs/shortcode.stub';
38 |     }
39 | 
40 |     /**
41 |      * Determine if the class already exists.
42 |      *
43 |      * @param  string  $rawName
44 |      * @return bool
45 |      */
46 |     protected function alreadyExists($rawName)
47 |     {
48 |         return class_exists($rawName);
49 |     }
50 | 
51 |     /**
52 |      * Get the default namespace for the class.
53 |      *
54 |      * @param  string  $rootNamespace
55 |      * @return string
56 |      */
57 |     protected function getDefaultNamespace($rootNamespace)
58 |     {
59 |         return $rootNamespace.'\Shortcodes';
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/Debugbar/ShortcodesCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Debugbar;
 4 | 
 5 | use DebugBar\DataCollector\DataCollector;
 6 | use DebugBar\DataCollector\Renderable;
 7 | use Illuminate\Support\Collection;
 8 | use Illuminate\Support\Traits\Macroable;
 9 | 
10 | /**
11 |  * Collects info about shortcodes.
12 |  */
13 | class ShortcodesCollector extends DataCollector implements Renderable
14 | {
15 |     use Macroable;
16 | 
17 |     /**
18 |      * @var array Shortcodes list
19 |      */
20 |     protected $shortcodes = [];
21 | 
22 |     /**
23 |      * Adds an shortcode to be profiled in the debug bar.
24 |      *
25 |      * @param  array  $data
26 |      */
27 |     public function addShortcode(array $data)
28 |     {
29 |         $this->shortcodes[] = $data;
30 |     }
31 | 
32 |     /**
33 |      * Returns the list of shortcodes being profiled.
34 |      *
35 |      * @return array
36 |      */
37 |     public function getShortcodes(): array
38 |     {
39 |         return $this->shortcodes;
40 |     }
41 | 
42 |     /**
43 |      * Called by the DebugBar when data needs to be collected.
44 |      *
45 |      * @return array Collected data
46 |      */
47 |     public function collect()
48 |     {
49 |         $shortcodes = new Collection($this->shortcodes);
50 | 
51 |         $shortcodesData = $shortcodes->mapWithKeys(function ($data) {
52 |             $time = $this->getDataFormatter()->formatDuration($data['time']);
53 | 
54 |             return [
55 |                 "[{$data['tag']}] - {$time}" => $this->getVarDumper()->renderVar($data['shortcode']->atts()),
56 |             ];
57 |         });
58 | 
59 |         return [
60 |             'count'      => count($this->shortcodes),
61 |             'shortcodes' => $shortcodesData->prepend(
62 |                 $this->getDataFormatter()->formatDuration($shortcodes->sum('time')),
63 |                 'Total time'
64 |             ),
65 |         ];
66 |     }
67 | 
68 |     /**
69 |      * @return string
70 |      */
71 |     public function getName()
72 |     {
73 |         return 'shortcodes';
74 |     }
75 | 
76 |     /**
77 |      * @return array
78 |      */
79 |     public function getWidgets()
80 |     {
81 |         return [
82 |             'shortcodes'       => [
83 |                 'icon'    => 'tags',
84 |                 'widget'  => 'PhpDebugBar.Widgets.HtmlVariableListWidget',
85 |                 'map'     => 'shortcodes.shortcodes',
86 |                 'default' => '[]',
87 |             ],
88 |             'shortcodes:badge' => [
89 |                 'map'     => 'shortcodes.count',
90 |                 'default' => 'null',
91 |             ],
92 |         ];
93 |     }
94 | }
95 | 


--------------------------------------------------------------------------------
/src/Facades/Shortcodes.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Facades;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | use Illuminate\Support\HtmlString;
 7 | use Vedmant\LaravelShortcodes\Manager;
 8 | 
 9 | /**
10 |  * @method static Manager share(string $key, $value)
11 |  * @method static mixed shared($key = null, $value = null)
12 |  * @method static Manager add($name, $callable = null)
13 |  * @method static Manager remove($name)
14 |  * @method static array registered()
15 |  * @method static array rendered()
16 |  * @method static HtmlString render($content)
17 |  *
18 |  * @see \Vedmant\LaravelShortcodes\Manager
19 |  */
20 | class Shortcodes extends Facade
21 | {
22 |     /**
23 |      * Get the registered name of the component.
24 |      *
25 |      * @return string
26 |      */
27 |     protected static function getFacadeAccessor()
28 |     {
29 |         return 'shortcodes';
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/LaravelShortcodesServiceProvider.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes;
  4 | 
  5 | use Illuminate\Support\Facades\Blade;
  6 | use Illuminate\Support\ServiceProvider;
  7 | use Vedmant\LaravelShortcodes\Commands\MakeShortcodeCommand;
  8 | use Vedmant\LaravelShortcodes\Debugbar\ShortcodesCollector;
  9 | use Vedmant\LaravelShortcodes\View\Factory;
 10 | 
 11 | class LaravelShortcodesServiceProvider extends ServiceProvider
 12 | {
 13 |     /**
 14 |      * Perform post-registration booting of services.
 15 |      *
 16 |      * @return void
 17 |      */
 18 |     public function boot()
 19 |     {
 20 |         $this->loadViewsFrom(__DIR__.'/../views', 'shortcodes');
 21 | 
 22 |         // Publishing is only necessary when using the CLI.
 23 |         if ($this->app->runningInConsole()) {
 24 |             $this->bootForConsole();
 25 |         }
 26 | 
 27 |         if ($this->app['config']->get('shortcodes.debugbar') && $this->app->bound('debugbar')) {
 28 |             $this->app['debugbar']->addCollector(new ShortcodesCollector());
 29 |         }
 30 | 
 31 |         Blade::directive('shortcodes', function ($expression) {
 32 |             if ($expression === '') {
 33 |                 return '<?php ob_start() ?>';
 34 |             } else {
 35 |                 return "<?php echo app('shortcodes')->render($expression); ?>";
 36 |             }
 37 |         });
 38 | 
 39 |         Blade::directive('endshortcodes', function () {
 40 |             return "<?php echo app('shortcodes')->render(ob_get_clean()); ?>";
 41 |         });
 42 |     }
 43 | 
 44 |     /**
 45 |      * Console-specific booting.
 46 |      *
 47 |      * @return void
 48 |      */
 49 |     protected function bootForConsole()
 50 |     {
 51 |         // Publishing the configuration file.
 52 |         $this->publishes([
 53 |             __DIR__.'/../config/shortcodes.php' => config_path('shortcodes.php'),
 54 |         ], 'shortcodes');
 55 | 
 56 |         // Registering package commands.
 57 |         $this->commands([
 58 |             MakeShortcodeCommand::class,
 59 |         ]);
 60 |     }
 61 | 
 62 |     /**
 63 |      * Register any package services.
 64 |      *
 65 |      * @return void
 66 |      */
 67 |     public function register()
 68 |     {
 69 |         $this->mergeConfigFrom(__DIR__.'/../config/shortcodes.php', 'shortcodes');
 70 | 
 71 |         // Register the service the package provides.
 72 |         $this->app->singleton('shortcodes', function ($app) {
 73 |             return new Manager($app, $app->make('config')->get('shortcodes'));
 74 |         });
 75 | 
 76 |         $this->registerView();
 77 |     }
 78 | 
 79 |     /**
 80 |      * Register the view environment.
 81 |      *
 82 |      * @return void
 83 |      */
 84 |     public function registerView()
 85 |     {
 86 |         $this->app->singleton('view', function ($app) {
 87 |             // Next we need to grab the engine resolver instance that will be used by the
 88 |             // environment. The resolver will be used by an environment to get each of
 89 |             // the various engine implementations such as plain PHP or Blade engine.
 90 |             $resolver = $app['view.engine.resolver'];
 91 | 
 92 |             $finder = $app['view.finder'];
 93 | 
 94 |             $factory = new Factory($resolver, $finder, $app['events']);
 95 | 
 96 |             // We will also set the container instance on this view environment since the
 97 |             // view composers may be classes registered in the container, which allows
 98 |             // for great testable, flexible composers for the application developer.
 99 |             $factory->setContainer($app);
100 | 
101 |             $factory->share('app', $app);
102 | 
103 |             return $factory;
104 |         });
105 |     }
106 | 
107 |     /**
108 |      * Get the services provided by the provider.
109 |      *
110 |      * @return array
111 |      */
112 |     public function provides()
113 |     {
114 |         return ['shortcodes', 'view'];
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/src/Manager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes;
  4 | 
  5 | use Illuminate\Contracts\Foundation\Application;
  6 | use Illuminate\Support\Arr;
  7 | use Illuminate\Support\Collection;
  8 | use Illuminate\Support\HtmlString;
  9 | use Illuminate\Support\Traits\Macroable;
 10 | 
 11 | class Manager
 12 | {
 13 |     use Macroable;
 14 | 
 15 |     /**
 16 |      * @var array Configuration
 17 |      */
 18 |     public $config;
 19 | 
 20 |     /**
 21 |      * @var array Shared attributes
 22 |      */
 23 |     public $shared = [];
 24 | 
 25 |     /**
 26 |      * @var Application
 27 |      */
 28 |     protected $app;
 29 | 
 30 |     /**
 31 |      * @var Renderer
 32 |      */
 33 |     protected $renderer;
 34 | 
 35 |     /**
 36 |      * Shortcodes manager constructor.
 37 |      *
 38 |      * @param  Application  $app
 39 |      * @param  array  $config
 40 |      */
 41 |     public function __construct(Application $app, array $config)
 42 |     {
 43 |         $this->app = $app;
 44 |         $this->config = $config;
 45 |         $this->renderer = new Renderer($app, $this);
 46 |     }
 47 | 
 48 |     /**
 49 |      * Share attribute.
 50 |      *
 51 |      * @param  string  $key
 52 |      * @param  mixed  $value
 53 |      * @return Manager
 54 |      */
 55 |     public function share($key, $value)
 56 |     {
 57 |         $this->shared[$key] = $value;
 58 | 
 59 |         return $this;
 60 |     }
 61 | 
 62 |     /**
 63 |      * Set / get shared variable.
 64 |      *
 65 |      * @param  string  $key
 66 |      * @param  null  $default
 67 |      * @return mixed
 68 |      */
 69 |     public function shared($key = null, $default = null)
 70 |     {
 71 |         if ($key === null) {
 72 |             return $this->shared;
 73 |         }
 74 | 
 75 |         return Arr::get($this->shared, $key, $default);
 76 |     }
 77 | 
 78 |     /**
 79 |      * Register a shortcode.
 80 |      *
 81 |      * @param  string|array  $name
 82 |      * @param  string|callable  $callable
 83 |      * @return Manager
 84 |      */
 85 |     public function add($name, $callable = null)
 86 |     {
 87 |         if (is_array($name)) {
 88 |             $this->renderer->shortcodes = array_merge($this->renderer->shortcodes, $name);
 89 |         } else {
 90 |             $this->renderer->shortcodes[$name] = $callable;
 91 |         }
 92 | 
 93 |         return $this;
 94 |     }
 95 | 
 96 |     /**
 97 |      * Unregister a shortcode.
 98 |      *
 99 |      * @param  string  $name
100 |      * @return Manager
101 |      */
102 |     public function remove($name)
103 |     {
104 |         unset($this->renderer->shortcodes[$name]);
105 | 
106 |         return $this;
107 |     }
108 | 
109 |     /**
110 |      * Get all registered shortcodes.
111 |      *
112 |      * @return array
113 |      */
114 |     public function registered(): array
115 |     {
116 |         return $this->renderer->shortcodes;
117 |     }
118 | 
119 |     /**
120 |      * Get list of rendered shortcodes.
121 |      *
122 |      * @return array
123 |      */
124 |     public function rendered(): array
125 |     {
126 |         return $this->renderer->rendered;
127 |     }
128 | 
129 |     /**
130 |      * Render shortcodes in the content.
131 |      *
132 |      * @param  string  $content
133 |      * @return HtmlString
134 |      */
135 |     public function render($content)
136 |     {
137 |         return new HtmlString($this->renderer->apply($content));
138 |     }
139 | 
140 |     /**
141 |      * Generate all registered shortcodes info.
142 |      *
143 |      * @return Collection
144 |      */
145 |     public function registeredData(): Collection
146 |     {
147 |         return (new Collection($this->renderer->shortcodes))->mapWithKeys(function ($class, $name) {
148 |             if (! is_string($class) || ! class_exists($class)) {
149 |                 return [];
150 |             }
151 |             /** @var Shortcode $shortcode */
152 |             $shortcode = new $class($this->app, $this, [], $name);
153 | 
154 |             return [$name => [
155 |                 'class'       => $class,
156 |                 'name'        => $name,
157 |                 'description' => $shortcode->description,
158 |                 'attributes'  => $shortcode->attributes(),
159 |             ]];
160 |         });
161 |     }
162 | }
163 | 


--------------------------------------------------------------------------------
/src/Renderer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes;
  4 | 
  5 | use Exception;
  6 | use Illuminate\Contracts\Foundation\Application;
  7 | use Illuminate\Support\Arr;
  8 | use Illuminate\Support\Facades\Log;
  9 | use Illuminate\Support\Traits\Macroable;
 10 | use Illuminate\Validation\ValidationException;
 11 | use Throwable;
 12 | 
 13 | class Renderer
 14 | {
 15 |     use Macroable;
 16 | 
 17 |     /**
 18 |      * @var Application Application
 19 |      */
 20 |     public $app;
 21 | 
 22 |     /**
 23 |      * @var Manager
 24 |      */
 25 |     protected $manager;
 26 | 
 27 |     /**
 28 |      * @var array Registered shortcodes
 29 |      */
 30 |     public $shortcodes = [];
 31 | 
 32 |     /**
 33 |      * @var array List of shortcodes that was rendered during the session
 34 |      */
 35 |     public $rendered = [];
 36 | 
 37 |     /**
 38 |      * Shortcodes renderer constructor.
 39 |      *
 40 |      * @param Application $app
 41 |      * @param Manager     $manager
 42 |      */
 43 |     public function __construct(Application $app, Manager $manager)
 44 |     {
 45 |         $this->app = $app;
 46 |         $this->manager = $manager;
 47 |     }
 48 | 
 49 |     /**
 50 |      * Apply shortcodes to content.
 51 |      *
 52 |      * @param string $content
 53 |      * @return string
 54 |      */
 55 |     public function apply($content)
 56 |     {
 57 |         return $this->doShortcode($content);
 58 |     }
 59 | 
 60 |     /**
 61 |      * Search content for shortcodes and filter shortcodes through their hooks.
 62 |      *
 63 |      * If there are no shortcode tags defined, then the content will be returned
 64 |      * without any filtering. This might cause issues when plugins are disabled but
 65 |      * the shortcode will still show up in the post or content.
 66 |      *
 67 |      * @param string $content Content to search for shortcodes.
 68 |      * @return string Content with shortcodes filtered out.
 69 |      */
 70 |     private function doShortcode($content)
 71 |     {
 72 |         if (false === strpos($content, '[')) {
 73 |             return $content;
 74 |         }
 75 | 
 76 |         if (empty($this->shortcodes) || ! is_array($this->shortcodes)) {
 77 |             return $content;
 78 |         }
 79 | 
 80 |         // Find all registered tag names in $content.
 81 |         preg_match_all('@\[([^<>&/\[\]\x00-\x20=]++)@', $content, $matches);
 82 |         $tagnames = array_intersect(array_keys($this->shortcodes), $matches[1]);
 83 | 
 84 |         if (empty($tagnames)) {
 85 |             return $content;
 86 |         }
 87 | 
 88 |         $pattern = $this->getShortcodeRegex($tagnames);
 89 |         $content = preg_replace_callback("/$pattern/", [$this, 'doShortcodeTag'], $content);
 90 | 
 91 |         // Always restore square braces so we don't break things like <!--[if IE ]>
 92 |         $content = $this->unescapeInvalidShortcodes($content);
 93 | 
 94 |         return $content;
 95 |     }
 96 | 
 97 |     /**
 98 |      * Regular Expression callable for do_shortcode() for calling shortcode hook.
 99 |      *
100 |      * @param array $m Regular expression match array
101 |      * @return false|string False on failure.
102 |      * @throws Exception
103 |      * @see    getShortcodeRegex for details of the match array contents.
104 |      *
105 |      * @global      array self::$shortcode_tags
106 |      */
107 |     private function doShortcodeTag($m)
108 |     {
109 |         $startTime = microtime(true);
110 |         // allow [[foo]] syntax for escaping a tag
111 |         if ($m[1] == '[' && $m[6] == ']') {
112 |             return substr($m[0], 1, -1);
113 |         }
114 | 
115 |         $tag = $m[2];
116 |         $atts = $this->shortcodeParseAtts($m[3]);
117 |         /* @var Shortcode $shortcode */
118 |         $shortcode = $this->shortcodes[$tag];
119 |         $instance = null;
120 | 
121 |         if (is_callable($shortcode)) {
122 |             $content = $m[1] . $shortcode($atts, isset($m[5]) ? $m[5] : null, $tag, $this->manager) . $m[6];
123 |         } elseif (class_exists($shortcode)) {
124 |             $instance = new $shortcode($this->app, $this->manager, (array) $atts, $tag);
125 |             if (! $instance instanceof Shortcode) {
126 |                 $content = "Class {$shortcode} is not an instance of " . Shortcode::class;
127 |             } else {
128 |                 $content = $m[1] . $this->renderShortcode($instance, isset($m[5]) ? $m[5] : null) . $m[6];
129 |             }
130 |         } else {
131 |             $content = "Class {$shortcode} doesn't exists";
132 |         }
133 | 
134 |         $this->shortcodeDone($tag, $instance, microtime(true) - $startTime);
135 | 
136 |         return $content;
137 |     }
138 | 
139 |     /**
140 |      * Render shortcode from the class instance
141 |      *
142 |      * @param Shortcode   $shortcode
143 |      * @param string|null $content
144 |      * @return string
145 |      */
146 |     private function renderShortcode(Shortcode $shortcode, $content)
147 |     {
148 |         try {
149 |             return $shortcode->render($content);
150 |         } catch (ValidationException $e) {
151 |             return 'Validation error: <br>' . implode('<br>', Arr::flatten($e->errors()));
152 |         } catch (Throwable $e) {
153 |             if ($this->manager->config['throw_exceptions']) {
154 |                 throw $e;
155 |             }
156 | 
157 |             Log::error($e);
158 |             // Report to sentry if it's intergated
159 |             if (class_exists('Sentry')) {
160 |                 if (app()->environment('production')) {
161 |                     \Sentry::captureException($e);
162 |                 }
163 |             }
164 | 
165 |             return "[$shortcode->tag] " . get_class($e) . ' ' . $e->getMessage();
166 |         }
167 |     }
168 | 
169 |     /**
170 |      * Record rendered shortcode info.
171 |      *
172 |      * @param string             $tag
173 |      * @param Shortcode|callable $shortcode
174 |      * @param float              $time
175 |      */
176 |     private function shortcodeDone($tag, $shortcode, $time)
177 |     {
178 |         $this->rendered[] = $tag;
179 | 
180 |         if ($this->app->bound('debugbar')) {
181 |             $this->app['debugbar']
182 |                 ->getCollector('shortcodes')
183 |                 ->addShortcode(compact('tag', 'shortcode', 'time'));
184 |         }
185 |     }
186 | 
187 |     /**
188 |      * Retrieve the shortcode regular expression for searching.
189 |      *
190 |      * The regular expression combines the shortcode tags in the regular expression
191 |      * in a regex class.
192 |      *
193 |      * The regular expression contains 6 different sub matches to help with parsing.
194 |      *
195 |      * 1 - An extra [ to allow for escaping shortcodes with double [[]]
196 |      * 2 - The shortcode name
197 |      * 3 - The shortcode argument list
198 |      * 4 - The self closing /
199 |      * 5 - The content of a shortcode when it wraps some content.
200 |      * 6 - An extra ] to allow for escaping shortcodes with double [[]]
201 |      *
202 |      * @param array $tagnames List of shortcodes to find. Optional. Defaults to all registered shortcodes.
203 |      * @return string The shortcode search regular expression
204 |      */
205 |     private function getShortcodeRegex($tagnames = null)
206 |     {
207 |         if (empty($tagnames)) {
208 |             $tagnames = array_keys($this->shortcodes);
209 |         }
210 |         $tagregexp = join('|', array_map('preg_quote', $tagnames));
211 | 
212 |         // WARNING! Do not change this regex without changing do_shortcode_tag() and strip_shortcode_tag()
213 |         // Also, see shortcode_unautop() and shortcode.js.
214 |         return
215 |             '\\['                              // Opening bracket
216 |             . '(\\[?)'                           // 1: Optional second opening bracket for escaping shortcodes: [[tag]]
217 |             . "($tagregexp)"                     // 2: Shortcode name
218 |             . '(?![\\w-])'                       // Not followed by word character or hyphen
219 |             . '('                                // 3: Unroll the loop: Inside the opening shortcode tag
220 |             .     '[^\\]\\/]*'                   // Not a closing bracket or forward slash
221 |             .     '(?:'
222 |             .         '\\/(?!\\])'               // A forward slash not followed by a closing bracket
223 |             .         '[^\\]\\/]*'               // Not a closing bracket or forward slash
224 |             .     ')*?'
225 |             . ')'
226 |             . '(?:'
227 |             .     '(\\/)'                        // 4: Self closing tag ...
228 |             .     '\\]'                          // ... and closing bracket
229 |             . '|'
230 |             .     '\\]'                          // Closing bracket
231 |             .     '(?:'
232 |             .         '('                        // 5: Unroll the loop: Optionally, anything between the opening and closing shortcode tags
233 |             .             '[^\\[]*+'             // Not an opening bracket
234 |             .             '(?:'
235 |             .                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag
236 |             .                 '[^\\[]*+'         // Not an opening bracket
237 |             .             ')*+'
238 |             .         ')'
239 |             .         '\\[\\/\\2\\]'             // Closing shortcode tag
240 |             .     ')?'
241 |             . ')'
242 |             . '(\\]?)';                          // 6: Optional second closing brocket for escaping shortcodes: [[tag]]
243 |     }
244 | 
245 |     /**
246 |      * Retrieve the shortcode attributes regex.
247 |      *
248 |      * @return string The shortcode attribute regular expression
249 |      */
250 |     private function getShortcodeAttsRegex()
251 |     {
252 |         return '/([\w-]+)\s*=\s*"([^"]*)"(?:\s|$)|([\w-]+)\s*=\s*\'([^\']*)\'(?:\s|$)|([\w-]+)\s*=\s*([^\s\'"]+)(?:\s|$)|"([^"]*)"(?:\s|$)|(\S+)(?:\s|$)/';
253 |     }
254 | 
255 |     /**
256 |      * Retrieve all attributes from the shortcodes tag.
257 |      *
258 |      * The attributes list has the attribute name as the key and the value of the
259 |      * attribute as the value in the key/value pair. This allows for easier
260 |      * retrieval of the attributes, since all attributes have to be known.
261 |      *
262 |      * @param string $text
263 |      * @return array|string List of attribute values.
264 |      *                      Returns empty array if trim( $text ) == '""'.
265 |      *                      Returns empty string if trim( $text ) == ''.
266 |      *                      All other matches are checked for not empty().
267 |      */
268 |     private function shortcodeParseAtts($text)
269 |     {
270 |         $atts = [];
271 |         $pattern = $this->getShortcodeAttsRegex();
272 |         $text = preg_replace("/[\x{00a0}\x{200b}]+/u", ' ', $text);
273 |         if (preg_match_all($pattern, $text, $match, PREG_SET_ORDER)) {
274 |             foreach ($match as $m) {
275 |                 if (! empty($m[1])) {
276 |                     $atts[strtolower($m[1])] = stripcslashes($m[2]);
277 |                 } elseif (! empty($m[3])) {
278 |                     $atts[strtolower($m[3])] = stripcslashes($m[4]);
279 |                 } elseif (! empty($m[5])) {
280 |                     $atts[strtolower($m[5])] = stripcslashes($m[6]);
281 |                 } elseif (isset($m[7]) && strlen($m[7])) {
282 |                     $atts[] = stripcslashes($m[7]);
283 |                 } elseif (isset($m[8])) {
284 |                     $atts[] = stripcslashes($m[8]);
285 |                 }
286 |             }
287 | 
288 |             // Reject any unclosed HTML elements
289 |             foreach ($atts as &$value) {
290 |                 if (false !== strpos($value, '<')) {
291 |                     if (1 !== preg_match('/^[^<]*+(?:<[^>]*+>[^<]*+)*+$/', $value)) {
292 |                         $value = '';
293 |                     }
294 |                 }
295 |             }
296 |         } else {
297 |             $atts = ltrim($text);
298 |         }
299 | 
300 |         return $atts;
301 |     }
302 | 
303 |     /**
304 |      * Remove placeholders added by do_shortcodes_in_html_tags().
305 |      *
306 |      * @param string $content Content to search for placeholders.
307 |      * @return string Content with placeholders removed.
308 |      */
309 |     private function unescapeInvalidShortcodes($content)
310 |     {
311 |         // Clean up entire string, avoids re-parsing HTML.
312 |         $trans = ['&#91;' => '[', '&#93;' => ']'];
313 |         $content = strtr($content, $trans);
314 | 
315 |         return $content;
316 |     }
317 | }
318 | 


--------------------------------------------------------------------------------
/src/Shortcode.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes;
  4 | 
  5 | use Carbon\Carbon;
  6 | use Illuminate\Contracts\Foundation\Application;
  7 | use Illuminate\Support\Arr;
  8 | use Illuminate\Support\Collection;
  9 | use Illuminate\Support\Traits\Macroable;
 10 | 
 11 | abstract class Shortcode implements ShortcodeContract
 12 | {
 13 |     use Macroable;
 14 | 
 15 |     /**
 16 |      * @var Application Application
 17 |      */
 18 |     public $app;
 19 | 
 20 |     /**
 21 |      * @var string Shortcode description
 22 |      */
 23 |     public $description;
 24 | 
 25 |     /**
 26 |      * @var array Shortcode attributes with default values
 27 |      */
 28 |     public $attributes = [];
 29 | 
 30 |     /**
 31 |      * @var string Rendered tag name
 32 |      */
 33 |     public $tag;
 34 | 
 35 |     /**
 36 |      * @var Manager
 37 |      */
 38 |     protected $manager;
 39 | 
 40 |     /**
 41 |      * @var array Shortcode attributes
 42 |      */
 43 |     protected $atts;
 44 | 
 45 |     /**
 46 |      * The attributes that should be cast to native types.
 47 |      *
 48 |      * @var array
 49 |      */
 50 |     protected $casts = [];
 51 | 
 52 |     /**
 53 |      * AbstractShortcode constructor.
 54 |      *
 55 |      * @param  Application  $app
 56 |      * @param  Manager  $manager
 57 |      * @param  array  $atts
 58 |      * @param  string  $tag
 59 |      */
 60 |     public function __construct(Application $app, Manager $manager, array $atts, $tag)
 61 |     {
 62 |         $this->app = $app;
 63 |         $this->manager = $manager;
 64 |         $this->atts = $this->castAttributes($atts);
 65 |         $this->tag = $tag;
 66 |     }
 67 | 
 68 |     /**
 69 |      * Get shortcode attributes.
 70 |      *
 71 |      * @return array
 72 |      */
 73 |     public function atts(): array
 74 |     {
 75 |         return $this->applyDefaultAtts($this->attributes(), $this->atts);
 76 |     }
 77 | 
 78 |     /**
 79 |      * Validate and return attributes.
 80 |      *
 81 |      * @param  array  $rules
 82 |      * @return array
 83 |      */
 84 |     public function validate(array $rules)
 85 |     {
 86 |         $atts = $this->atts();
 87 | 
 88 |         $this->app->make('validator')->validate($this->atts(), $rules);
 89 | 
 90 |         return $atts;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Combine user attributes with known attributes and fill in defaults when needed.
 95 |      *
 96 |      * @param  array  $defaults
 97 |      * @param  array  $atts
 98 |      * @return array Combined and filtered attribute list.
 99 |      */
100 |     protected function applyDefaultAtts(array $defaults, array $atts)
101 |     {
102 |         $atts = (array) $atts;
103 |         $out = [];
104 |         foreach ($defaults as $name => $default) {
105 |             if (array_key_exists($name, $atts)) {
106 |                 $out[$name] = $atts[$name];
107 |             } else {
108 |                 if (is_array($default)) {
109 |                     $out[$name] = $default['default'];
110 |                 } else {
111 |                     $out[$name] = $default;
112 |                 }
113 |             }
114 |         }
115 | 
116 |         return $out;
117 |     }
118 | 
119 |     /**
120 |      * Get attributes config.
121 |      *
122 |      * @return mixed
123 |      */
124 |     public function attributes()
125 |     {
126 |         return $this->attributes;
127 |     }
128 | 
129 |     /**
130 |      * Get shortcode attributes.
131 |      *
132 |      * @param  string  $key
133 |      * @param  mixed  $defatul
134 |      * @return array
135 |      */
136 |     public function shared($key = null, $defatul = null)
137 |     {
138 |         return $this->manager->shared($key, $defatul);
139 |     }
140 | 
141 |     /**
142 |      * Render a view with supressed exceptions.
143 |      *
144 |      * @param  string  $name
145 |      * @param  array|Collection  $data
146 |      * @return string
147 |      */
148 |     protected function view($name, $data = [])
149 |     {
150 |         return $this->app['view']->make($name, $data)->render();
151 |     }
152 | 
153 |     /**
154 |      * Cast attributes.
155 |      *
156 |      * @param $atts
157 |      * @return array
158 |      */
159 |     protected function castAttributes($atts)
160 |     {
161 |         if (! $this->casts) {
162 |             return $atts;
163 |         }
164 | 
165 |         foreach ($atts as $key => $value) {
166 |             $atts[$key] = $this->castAttribute($key, $value);
167 |         }
168 | 
169 |         return $atts;
170 |     }
171 | 
172 |     /**
173 |      * Cast an attribute to a native PHP type.
174 |      *
175 |      * @param  string  $key
176 |      * @param  mixed  $value
177 |      * @return mixed
178 |      */
179 |     protected function castAttribute($key, $value)
180 |     {
181 |         switch (Arr::get($this->casts, $key)) {
182 |             case 'int':
183 |             case 'integer':
184 |                 return (int) $value;
185 |             case 'real':
186 |             case 'float':
187 |             case 'double':
188 |                 return (float) $value;
189 |             case 'bool':
190 |             case 'boolean':
191 |                 return $value === 'true';
192 |             case 'array':
193 |                 return $this->parseCommaSeparated($value);
194 |             case 'json':
195 |                 return json_decode($value, true);
196 |             case 'date':
197 |                 return Carbon::parse($value);
198 |             default:
199 |                 return $value;
200 |         }
201 |     }
202 | 
203 |     /**
204 |      * Parse comma separated values.
205 |      *
206 |      * @param $string
207 |      * @return array
208 |      */
209 |     protected function parseCommaSeparated($string)
210 |     {
211 |         return array_filter(array_map('trim', explode(',', $string)));
212 |     }
213 | }
214 | 


--------------------------------------------------------------------------------
/src/ShortcodeContract.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes;
 4 | 
 5 | interface ShortcodeContract
 6 | {
 7 |     /**
 8 |      * Get attributes config.
 9 |      *
10 |      * @return array
11 |      */
12 |     public function attributes();
13 | 
14 |     /**
15 |      * Render shortcode.
16 |      *
17 |      * @param  string  $content
18 |      * @return mixed
19 |      */
20 |     public function render($content);
21 | 
22 |     /**
23 |      * Get shortcode attributes.
24 |      *
25 |      * @return array
26 |      */
27 |     public function atts(): array;
28 | 
29 |     /**
30 |      * Get shortcode attributes.
31 |      *
32 |      * @param  string  $key
33 |      * @param  mixed  $defatul
34 |      * @return array
35 |      */
36 |     public function shared($key = null, $defatul = null);
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Shortcodes/BShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Shortcodes;
 4 | 
 5 | class BShortcode extends Shortcode
 6 | {
 7 |     /**
 8 |      * @var string Shortcode description
 9 |      */
10 |     public $description = 'Render [b] shortcode for bold text';
11 | 
12 |     /**
13 |      * @var array Shortcode attributes with default values
14 |      */
15 |     public $attributes = [
16 |         'test' => [
17 |             'default'     => 'Name',
18 |             'description' => 'Artist username',
19 |             'sample'      => 'Sample',
20 |         ],
21 |     ];
22 | 
23 |     /**
24 |      * Render shortcode.
25 |      *
26 |      * @param  string  $content
27 |      * @return string
28 |      */
29 |     public function render($content)
30 |     {
31 |         return $this->view('shortcodes::b', [
32 |             'atts'    => $this->atts(),
33 |             'content' => $content,
34 |         ]);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/View/Factory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\View;
 4 | 
 5 | use Illuminate\View\Factory as IlluminateViewFactory;
 6 | 
 7 | class Factory extends IlluminateViewFactory
 8 | {
 9 |     /**
10 |      * Create a new view instance from the given arguments.
11 |      *
12 |      * @param  string  $view
13 |      * @param  string  $path
14 |      * @param  \Illuminate\Contracts\Support\Arrayable|array  $data
15 |      * @return \Illuminate\Contracts\View\View
16 |      */
17 |     protected function viewInstance($view, $path, $data)
18 |     {
19 |         return new View($this, $this->getEngineFromPath($path), $view, $path, $data, $this->container['shortcodes']);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/View/View.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\View;
 4 | 
 5 | use Illuminate\Contracts\View\Engine;
 6 | use Illuminate\View\Factory;
 7 | use Illuminate\View\View as IlluminateView;
 8 | use Vedmant\LaravelShortcodes\Manager;
 9 | 
10 | class View extends IlluminateView
11 | {
12 |     /**
13 |      * @var Manager Shortcode manager
14 |      */
15 |     private $shortcodes;
16 | 
17 |     /**
18 |      * @var bool If should render shortcodes
19 |      */
20 |     private $renderShortcodes = false;
21 | 
22 |     /**
23 |      * Create a new view instance.
24 |      *
25 |      * @param  \Illuminate\View\Factory  $factory
26 |      * @param  \Illuminate\Contracts\View\Engine  $engine
27 |      * @param  string  $view
28 |      * @param  string  $path
29 |      * @param  mixed  $data
30 |      * @param  Manager  $shortcodes
31 |      * @return void
32 |      */
33 |     public function __construct(
34 |         Factory $factory,
35 |         Engine $engine,
36 |         $view,
37 |         $path,
38 |         $data,
39 |         Manager $shortcodes
40 |     ) {
41 |         parent::__construct($factory, $engine, $view, $path, $data);
42 | 
43 |         $this->shortcodes = $shortcodes;
44 |         $this->renderShortcodes = $this->shortcodes->config['render_views'];
45 |     }
46 | 
47 |     /**
48 |      * Should render shortcodes.
49 |      */
50 |     public function withShortcodes()
51 |     {
52 |         $this->renderShortcodes = true;
53 | 
54 |         return $this;
55 |     }
56 | 
57 |     /**
58 |      * Should not render shortcodes.
59 |      */
60 |     public function withoutShortcodes()
61 |     {
62 |         $this->renderShortcodes = false;
63 | 
64 |         return $this;
65 |     }
66 | 
67 |     /**
68 |      * Render without catching exceptions.
69 |      *
70 |      * @return string
71 |      */
72 |     public function renderSimple()
73 |     {
74 |         return $this->renderContents();
75 |     }
76 | 
77 |     /**
78 |      * Get the evaluated contents of the view.
79 |      *
80 |      * @return string
81 |      */
82 |     protected function getContents()
83 |     {
84 |         $contents = $this->engine->get($this->path, $this->gatherData());
85 | 
86 |         if ($this->renderShortcodes) {
87 |             return $this->shortcodes->render($contents);
88 |         }
89 | 
90 |         return $contents;
91 |     }
92 | }
93 | 


--------------------------------------------------------------------------------
/src/helpers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Support\HtmlString;
 4 | 
 5 | if (! function_exists('shortcodes')) {
 6 | 
 7 |     /**
 8 |      * Render shortcodes.
 9 |      *
10 |      * @param  string  $string
11 |      * @return string|HtmlString
12 |      */
13 |     function shortcodes($string)
14 |     {
15 |         return app('shortcodes')->render($string);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/stubs/shortcode.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace DummyNamespace;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class DummyClass extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Shortcode description';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'example'  => [
19 |             'default'     => 'default',
20 |             'description' => 'Example attribute',
21 |             'sample'      => 'some-sample-value',
22 |         ],
23 |     ];
24 | 
25 |     /**
26 |      * Render shortcode
27 |      *
28 |      * @param string $content
29 |      * @return string
30 |      */
31 |     public function render($content)
32 |     {
33 |         $atts = $this->atts();
34 |         $shared = $this->shared();
35 | 
36 |         return $this->view('shortcodes.some-shortcode', compact('atts', 'shared', 'content'));
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Resources/BShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class BShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Render [b] shortcode for bold text';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'class' => [
19 |             'default'     => '',
20 |             'description' => 'Class name',
21 |             'sample'      => 'some-class',
22 |         ],
23 |     ];
24 | 
25 |     /**
26 |      * Render shortcode.
27 |      *
28 |      * @param  string  $content
29 |      * @return string
30 |      */
31 |     public function render($content)
32 |     {
33 |         $atts = $this->atts();
34 | 
35 |         return "<b class=\"{$atts['class']}\">{$content}</b>";
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Resources/CastsShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class CastsShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'List of casts';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'string' => [
19 |             'default' => '',
20 |         ],
21 |         'int' => [
22 |             'default' => '',
23 |         ],
24 |         'integer' => [
25 |             'default' => '',
26 |         ],
27 |         'real' => [
28 |             'default' => '',
29 |         ],
30 |         'float' => [
31 |             'default' => '',
32 |         ],
33 |         'double' => [
34 |             'default' => '',
35 |         ],
36 |         'bool' => [
37 |             'default' => '',
38 |         ],
39 |         'boolean' => [
40 |             'default' => '',
41 |         ],
42 |         'array' => [
43 |             'default' => '',
44 |         ],
45 |         'json' => [
46 |             'default' => '',
47 |         ],
48 |         'date' => [
49 |             'default' => '',
50 |         ],
51 |     ];
52 | 
53 |     /**
54 |      * The attributes that should be cast to native types.
55 |      *
56 |      * @var array
57 |      */
58 |     protected $casts = [
59 |         'int' => 'int',
60 |         'integer' => 'integer',
61 |         'real' => 'real',
62 |         'float' => 'float',
63 |         'double' => 'double',
64 |         'bool' => 'bool',
65 |         'boolean' => 'boolean',
66 |         'array' => 'array',
67 |         'json' => 'json',
68 |         'date' => 'date',
69 |     ];
70 | 
71 |     /**
72 |      * Render shortcode.
73 |      *
74 |      * @param  string  $content
75 |      * @return string
76 |      */
77 |     public function render($content)
78 |     {
79 |         $atts = $this->atts();
80 | 
81 |         return "<b class=\"{$atts['class']}\">{$content}</b>";
82 |     }
83 | }
84 | 


--------------------------------------------------------------------------------
/tests/Resources/ExceptionShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class ExceptionShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Exception shortcode for test';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'class' => [
19 |             'default'     => '',
20 |             'description' => 'Class name',
21 |             'sample'      => 'some-class',
22 |         ],
23 |     ];
24 | 
25 |     /**
26 |      * Render shortcode.
27 |      *
28 |      * @param  string  $content
29 |      * @return string
30 |      */
31 |     public function render($content)
32 |     {
33 |         return $someUnknownVar;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Resources/ExceptionViewShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class ExceptionViewShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Exception shortcode for test';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'class' => [
19 |             'default'     => '',
20 |             'description' => 'Class name',
21 |             'sample'      => 'some-class',
22 |         ],
23 |     ];
24 | 
25 |     /**
26 |      * Render shortcode.
27 |      *
28 |      * @param  string  $content
29 |      * @return string
30 |      */
31 |     public function render($content)
32 |     {
33 |         return $this->view('shortcode-exception');
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Resources/HrShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class HrShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Render [br] shortcode for horizontal line';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'class' => [
19 |             'default'     => '',
20 |             'description' => 'Class name',
21 |             'sample'      => 'some-class',
22 |         ],
23 |     ];
24 | 
25 |     /**
26 |      * Render shortcode.
27 |      *
28 |      * @param  string  $content
29 |      * @return string
30 |      */
31 |     public function render($content)
32 |     {
33 |         $atts = $this->atts();
34 | 
35 |         return "<hr class=\"{$atts['class']}\"/>";
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/Resources/ValidationShortcode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Resources;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Shortcode;
 6 | 
 7 | class ValidationShortcode extends Shortcode
 8 | {
 9 |     /**
10 |      * @var string Shortcode description
11 |      */
12 |     public $description = 'Test shortcode with validation';
13 | 
14 |     /**
15 |      * @var array Shortcode attributes with default values
16 |      */
17 |     public $attributes = [
18 |         'required' => [
19 |             'default' => '',
20 |         ],
21 |         'string' => [
22 |             'default' => '',
23 |         ],
24 |         'numeric' => [
25 |             'default' => '',
26 |         ],
27 |     ];
28 | 
29 |     /**
30 |      * Render shortcode.
31 |      *
32 |      * @param  string  $content
33 |      * @return string
34 |      */
35 |     public function render($content)
36 |     {
37 |         $this->validate([
38 |             'required' => 'required',
39 |             'string'   => 'required|string',
40 |             'numeric'  => 'required|numeric',
41 |         ]);
42 | 
43 |         return 'Success';
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests;
 4 | 
 5 | use Orchestra\Testbench\TestCase as TestBenchTestCase;
 6 | use Vedmant\LaravelShortcodes\Manager;
 7 | 
 8 | class TestCase extends TestBenchTestCase
 9 | {
10 |     /**
11 |      * @var Manager
12 |      */
13 |     protected $manager;
14 | 
15 |     public function __construct($name = null, array $data = [], $dataName = '')
16 |     {
17 |         parent::__construct($name, $data, $dataName);
18 | 
19 |         $this->afterApplicationCreated(function () {
20 |             $this->manager = app()->make('shortcodes');
21 |         });
22 |     }
23 | 
24 |     protected function getPackageProviders($app)
25 |     {
26 |         return [\Vedmant\LaravelShortcodes\LaravelShortcodesServiceProvider::class];
27 |     }
28 | 
29 |     protected function getPackageAliases($app)
30 |     {
31 |         return [
32 |             'Shortcodes' => \Vedmant\LaravelShortcodes\Facades\Shortcodes::class,
33 |         ];
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Unit/BladeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Unit;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Tests\Resources\BShortcode;
 6 | use Vedmant\LaravelShortcodes\Tests\TestCase;
 7 | 
 8 | class BladeTest extends TestCase
 9 | {
10 |     public function testDirective()
11 |     {
12 |         $directives = $this->app['blade.compiler']->getCustomDirectives();
13 |         $this->assertArrayHasKey('shortcodes', $directives);
14 |         $this->assertArrayHasKey('endshortcodes', $directives);
15 |     }
16 | 
17 |     public function testRenderWithDirectiveInline()
18 |     {
19 |         $this->manager->add('b', BShortcode::class);
20 | 
21 |         app('view')->addLocation(__DIR__.'/../views');
22 |         $rendered = $this->app['view']->make('directive-inline')->render();
23 |         $this->assertEquals('<b class="inline">Content</b>', (string) $rendered);
24 |     }
25 | 
26 |     public function testRenderWithDirectiveBlock()
27 |     {
28 |         $this->manager->add('b', BShortcode::class);
29 | 
30 |         app('view')->addLocation(__DIR__.'/../views');
31 |         $rendered = $this->app['view']->make('directive-block')->render();
32 |         $this->assertEquals("<b class=\"block\">Content</b>\n", (string) $rendered);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/Unit/HelpersTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Unit;
 4 | 
 5 | use Vedmant\LaravelShortcodes\Tests\Resources\BShortcode;
 6 | use Vedmant\LaravelShortcodes\Tests\TestCase;
 7 | 
 8 | class HelpersTest extends TestCase
 9 | {
10 |     public function testFunction()
11 |     {
12 |         $this->assertTrue(function_exists('shortcodes'));
13 |     }
14 | 
15 |     public function testRenderWithHelper()
16 |     {
17 |         $this->manager->add('b', BShortcode::class);
18 | 
19 |         $rendered = \shortcodes('[b class="test"]Content[/b]');
20 |         $this->assertEquals('<b class="test">Content</b>', (string) $rendered);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/Unit/ManagerTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes\Tests\Unit;
  4 | 
  5 | use Vedmant\LaravelShortcodes\Tests\Resources\BShortcode;
  6 | use Vedmant\LaravelShortcodes\Tests\Resources\HrShortcode;
  7 | use Vedmant\LaravelShortcodes\Tests\TestCase;
  8 | 
  9 | class ManagerTest extends TestCase
 10 | {
 11 |     public function testInstance()
 12 |     {
 13 |         $this->assertInstanceOf(\Vedmant\LaravelShortcodes\Manager::class, $this->manager);
 14 |     }
 15 | 
 16 |     public function testAdd()
 17 |     {
 18 |         $this->manager->add('b', BShortcode::class);
 19 | 
 20 |         $this->assertCount(1, $this->manager->registered());
 21 |         $this->assertArrayHasKey('b', $this->manager->registered());
 22 |     }
 23 | 
 24 |     public function testRemove()
 25 |     {
 26 |         $this->manager->add('b', BShortcode::class);
 27 |         $this->manager->remove('b');
 28 | 
 29 |         $this->assertCount(0, $this->manager->registered());
 30 |     }
 31 | 
 32 |     public function testShare()
 33 |     {
 34 |         $this->manager->share('shared', 'value');
 35 |         $this->assertEquals('value', $this->manager->shared('shared'));
 36 |     }
 37 | 
 38 |     public function testRenderScope()
 39 |     {
 40 |         $this->manager->add('b', function ($atts, $content, $tag, $manager) {
 41 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 42 |         });
 43 |         $rendered = $this->manager->render('[b class="test"]Content[/b]');
 44 | 
 45 |         $this->assertEquals('<b class="test">Content</b>', (string) $rendered);
 46 |     }
 47 | 
 48 |     public function testRenderClassSingle()
 49 |     {
 50 |         $this->manager->add('b', BShortcode::class);
 51 |         $rendered = $this->manager->render('[b class="test"]Content[/b]');
 52 | 
 53 |         $this->assertEquals('<b class="test">Content</b>', (string) $rendered);
 54 |     }
 55 | 
 56 |     public function testRenderClassMultiple()
 57 |     {
 58 |         $this->manager->add([
 59 |             'hr' => HrShortcode::class,
 60 |             'b'  => BShortcode::class,
 61 |         ]);
 62 |         $rendered = $this->manager->render('[b class="test"]Content[/b][hr class="bold"]');
 63 | 
 64 |         $this->assertEquals('<b class="test">Content</b><hr class="bold"/>', (string) $rendered);
 65 |     }
 66 | 
 67 |     public function testRegisteredData()
 68 |     {
 69 |         $this->manager->add([
 70 |             'hr' => HrShortcode::class,
 71 |             'b'  => BShortcode::class,
 72 |         ]);
 73 | 
 74 |         // Should skip closures
 75 |         $this->manager->add('test', function ($atts, $content, $tag, $manager) {
 76 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 77 |         });
 78 | 
 79 |         $data = $this->manager->registeredData();
 80 | 
 81 |         $this->assertEquals([
 82 |             'hr' => [
 83 |                 'class'       => 'Vedmant\\LaravelShortcodes\\Tests\\Resources\\HrShortcode',
 84 |                 'name'        => 'hr',
 85 |                 'description' => 'Render [br] shortcode for horizontal line',
 86 |                 'attributes'  => [
 87 |                     'class' => [
 88 |                         'default'     => '',
 89 |                         'description' => 'Class name',
 90 |                         'sample'      => 'some-class',
 91 |                     ],
 92 |                 ],
 93 |             ],
 94 |             'b'  => [
 95 |                 'class'       => 'Vedmant\\LaravelShortcodes\\Tests\\Resources\\BShortcode',
 96 |                 'name'        => 'b',
 97 |                 'description' => 'Render [b] shortcode for bold text',
 98 |                 'attributes'  => [
 99 |                     'class' => [
100 |                         'default'     => '',
101 |                         'description' => 'Class name',
102 |                         'sample'      => 'some-class',
103 |                     ],
104 |                 ],
105 |             ],
106 |         ], $data->toArray());
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/tests/Unit/ShortcodeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Vedmant\LaravelShortcodes\Tests\Unit;
 4 | 
 5 | use Carbon\Carbon;
 6 | use Illuminate\Validation\ValidationException;
 7 | use Vedmant\LaravelShortcodes\Tests\Resources\CastsShortcode;
 8 | use Vedmant\LaravelShortcodes\Tests\Resources\ValidationShortcode;
 9 | use Vedmant\LaravelShortcodes\Tests\TestCase;
10 | 
11 | class ShortcodeTest extends TestCase
12 | {
13 |     public function testCasts()
14 |     {
15 |         $shortcode = new CastsShortcode($this->app, $this->manager, [
16 |             'string' => 'string',
17 |             'int' => '123',
18 |             'integer' => '123',
19 |             'real' => '12.34',
20 |             'float' => '12.34',
21 |             'double' => '12.34',
22 |             'bool' => 'true',
23 |             'boolean' => 'false',
24 |             'array' => '1,2,3,4',
25 |             'json' => '{"test": 123}',
26 |             'date' => '2019-01-01',
27 |         ], 'casts');
28 | 
29 |         $atts = $shortcode->atts();
30 | 
31 |         $this->assertIsString($atts['string']);
32 |         $this->assertIsInt($atts['int']);
33 |         $this->assertIsInt($atts['integer']);
34 |         $this->assertIsFloat($atts['real']);
35 |         $this->assertIsFloat($atts['float']);
36 |         $this->assertIsFloat($atts['double']);
37 |         $this->assertIsBool($atts['bool']);
38 |         $this->assertIsBool($atts['boolean']);
39 |         $this->assertIsArray($atts['array']);
40 |         $this->assertIsArray($atts['json']);
41 |         $this->assertInstanceOf(Carbon::class, $atts['date']);
42 |     }
43 | 
44 |     public function testValidation()
45 |     {
46 |         $shortcode = new ValidationShortcode($this->app, $this->manager, [], 'validation');
47 | 
48 |         try {
49 |             $shortcode->render(null);
50 |             $this->fail('Expected ValidationException not thrown');
51 |         } catch (ValidationException $e) {
52 |             $this->assertCount(3, $e->errors());
53 |         }
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/tests/Unit/ViewTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Vedmant\LaravelShortcodes\Tests\Unit;
  4 | 
  5 | use Vedmant\LaravelShortcodes\Tests\Resources\ExceptionShortcode;
  6 | use Vedmant\LaravelShortcodes\Tests\Resources\ExceptionViewShortcode;
  7 | use Vedmant\LaravelShortcodes\Tests\Resources\ValidationShortcode;
  8 | use Vedmant\LaravelShortcodes\Tests\TestCase;
  9 | 
 10 | class ViewTest extends TestCase
 11 | {
 12 |     public function testInstances()
 13 |     {
 14 |         $this->assertInstanceOf(\Vedmant\LaravelShortcodes\View\Factory::class, $this->app['view']);
 15 |         $this->assertInstanceOf(\Vedmant\LaravelShortcodes\View\View::class, $this->app['view']->make('shortcodes::b'));
 16 |     }
 17 | 
 18 |     public function testRenderDefault()
 19 |     {
 20 |         $this->addViewsPath();
 21 | 
 22 |         $this->manager->add('b', function ($atts, $content, $tag, $manager) {
 23 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 24 |         });
 25 | 
 26 |         $rendered = $this->app['view']->make('bold')->render();
 27 |         $this->assertEquals('<b class="test">Content</b>', (string) $rendered);
 28 |     }
 29 | 
 30 |     public function testRenderDisabled()
 31 |     {
 32 |         $this->manager->config['render_views'] = false;
 33 |         $this->addViewsPath();
 34 | 
 35 |         $this->manager->add('b', function ($atts, $content, $tag, $manager) {
 36 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 37 |         });
 38 | 
 39 |         $rendered = $this->app['view']->make('bold')->render();
 40 | 
 41 |         $this->assertEquals('[b class="test"]Content[/b]', (string) $rendered);
 42 |     }
 43 | 
 44 |     public function testRenderWithShortcodes()
 45 |     {
 46 |         $this->manager->config['render_views'] = false;
 47 |         $this->addViewsPath();
 48 | 
 49 |         $this->manager->add('b', function ($atts, $content, $tag, $manager) {
 50 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 51 |         });
 52 | 
 53 |         $rendered = $this->app['view']->make('bold')->withShortcodes()->render();
 54 |         $this->assertEquals('<b class="test">Content</b>', (string) $rendered);
 55 |     }
 56 | 
 57 |     public function testRenderWithoutShortcodes()
 58 |     {
 59 |         $this->manager->config['render_views'] = true;
 60 |         $this->addViewsPath();
 61 | 
 62 |         $this->manager->add('b', function ($atts, $content, $tag, $manager) {
 63 |             return "<b class=\"{$atts['class']}\">{$content}</b>";
 64 |         });
 65 | 
 66 |         $rendered = $this->app['view']->make('bold')->withoutShortcodes()->render();
 67 |         $this->assertEquals('[b class="test"]Content[/b]', (string) $rendered);
 68 |     }
 69 | 
 70 |     public function testRenderWithoutThrowing()
 71 |     {
 72 |         $this->manager->config['throw_exceptions'] = false;
 73 |         $this->addViewsPath();
 74 |         $this->manager->add('exception', ExceptionShortcode::class);
 75 | 
 76 |         $rendered = $this->app['view']->make('exception')->render();
 77 | 
 78 |         $this->assertStringStartsWith('[exception] ErrorException Undefined variable', (string) $rendered);
 79 |     }
 80 | 
 81 |     public function testRenderWithoutThrowingInView()
 82 |     {
 83 |         $this->manager->config['throw_exceptions'] = false;
 84 |         $this->addViewsPath();
 85 |         $this->manager->add('exception', ExceptionViewShortcode::class);
 86 | 
 87 |         $rendered = $this->app['view']->make('exception')->render();
 88 | 
 89 |         $this->assertStringContainsString('Undefined variable', (string) $rendered);
 90 |     }
 91 | 
 92 |     public function testRenderWithThrowing()
 93 |     {
 94 |         $this->manager->config['throw_exceptions'] = true;
 95 |         $this->addViewsPath();
 96 |         $this->manager->add('exception', ExceptionShortcode::class);
 97 | 
 98 |         $this->expectExceptionMessage('Undefined variable');
 99 | 
100 |         $rendered = $this->app['view']->make('exception')->render();
101 |     }
102 | 
103 |     public function testRenderWithThrowingInView()
104 |     {
105 |         $this->manager->config['throw_exceptions'] = true;
106 |         $this->addViewsPath();
107 |         $this->manager->add('exception', ExceptionViewShortcode::class);
108 | 
109 |         $this->expectExceptionMessage('Undefined variable');
110 | 
111 |         $rendered = $this->app['view']->make('exception')->render();
112 |     }
113 | 
114 |     public function testRenderWithValidation()
115 |     {
116 |         $this->addViewsPath();
117 | 
118 |         $this->manager->add('validation', ValidationShortcode::class);
119 | 
120 |         $rendered = $this->manager->render('[validation]');
121 |         $this->assertEquals('Validation error: <br>The required field is required.<br>The string field is required.<br>The numeric field is required.', (string) $rendered);
122 |     }
123 | 
124 |     private function addViewsPath()
125 |     {
126 |         app('view')->addLocation(__DIR__.'/../views');
127 |     }
128 | }
129 | 


--------------------------------------------------------------------------------
/tests/views/bold.blade.php:
--------------------------------------------------------------------------------
1 | [b class="test"]Content[/b]


--------------------------------------------------------------------------------
/tests/views/directive-block.blade.php:
--------------------------------------------------------------------------------
1 | @shortcodes
2 | [b class="block"]Content[/b]
3 | @endshortcodes
4 | 


--------------------------------------------------------------------------------
/tests/views/directive-inline.blade.php:
--------------------------------------------------------------------------------
1 | @shortcodes('[b class="inline"]Content[/b]')
2 | 


--------------------------------------------------------------------------------
/tests/views/exception.blade.php:
--------------------------------------------------------------------------------
1 | [exception]


--------------------------------------------------------------------------------
/tests/views/shortcode-exception.blade.php:
--------------------------------------------------------------------------------
1 | {{ $notExisting }}


--------------------------------------------------------------------------------
/views/b.blade.php:
--------------------------------------------------------------------------------
1 | <b>{{ Shortcodes::render($content) }}</b>
2 | 


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