1449

pending completion

Build # 1449

Build Type

push

travis-ci

Committed by

mcaskill

Commit Message

<a href="https://github.com/locomotivemtl/charcoal-admin/commit/bc34c4153">Add support for Admin-only metadata configset

Added:
- Extension on container entry &quot;metadata/config&quot; to merge any &quot;admin.config.metadata&quot;

Changed:
- Fallback container entry &quot;metadata/config&quot; to merge any &quot;config.metadata&quot;

Related: </a><a class="double-link" href="https://github.com/locomotivemtl/charcoal-admin/commit/989aa11aa">989aa11aa</a>

Run Details

8 of 8 new or added lines in 1 file covered. (100.0%)

1190 of 14204 relevant lines covered (8.38%)

2.03 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

21.95

/src/Charcoal/Admin/ServiceProvider/AdminServiceProvider.php

<?php

namespace Charcoal\Admin\ServiceProvider;

// From Pimple
use Charcoal\Admin\AssetsConfig;
use Pimple\Container;
use Pimple\ServiceProviderInterface;
use Assetic\Asset\AssetReference;
use Charcoal\Attachment\Object\File;
use Charcoal\Factory\GenericResolver;

// from 'kriswallsmith/assetic'
use Assetic\AssetManager;

// From PSR-7
use Psr\Http\Message\UriInterface;

// From Slim
use Slim\Http\Uri;

// From Mustache
use Mustache_LambdaHelper as LambdaHelper;

// From 'charcoal-config'
use Charcoal\Config\ConfigInterface;
use Charcoal\Config\GenericConfig as Config;

// From 'charcoal-factory'
use Charcoal\Factory\FactoryInterface;

// From 'charcoal-core'
use Charcoal\Model\Service\MetadataConfig;

// From 'charcoal-ui'
use Charcoal\Ui\ServiceProvider\UiServiceProvider;

// From 'charcoal-email'
use Charcoal\Email\ServiceProvider\EmailServiceProvider;

// From 'charcoal-factory'
use Charcoal\Factory\GenericFactory as Factory;

// From 'charcoal-user'
use Charcoal\User\Authenticator;
use Charcoal\User\Authorizer;

// From 'charcoal-admin'
use Charcoal\Admin\Config as AdminConfig;
use Charcoal\Admin\Property\PropertyInputInterface;
use Charcoal\Admin\Property\PropertyDisplayInterface;
use Charcoal\Admin\Service\SelectizeRenderer;
use Charcoal\Admin\Ui\SecondaryMenu\GenericSecondaryMenuGroup;
use Charcoal\Admin\Ui\SecondaryMenu\SecondaryMenuGroupInterface;
use Charcoal\Admin\User;
use Charcoal\Admin\User\AuthToken;

/**
 * Charcoal Administration Service Provider
 *
 * ## Services
 *
 * - Module
 * - Config
 * - Widget Factory
 */
class AdminServiceProvider implements ServiceProviderInterface
{
    /**
     * Registers services on the given container.
     *
     * This method should only be used to configure services and parameters.
     * It should not get services.
     *
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    public function register(Container $container)
    {
        // Ensure dependencies are set
        $container->register(new EmailServiceProvider());
        $container->register(new UiServiceProvider());
        $container->register(new AssetsManagerServiceProvider());

        $this->registerAdminServices($container);
        $this->registerFactoryServices($container);
        $this->registerElfinderServices($container);
        $this->registerSelectizeServices($container);
        $this->registerMetadataExtensions($container);
        $this->registerAuthExtensions($container);
        $this->registerViewExtensions($container);
        $this->registerAssetsManager($container);

        // Register Access-Control-List (acl)
        $container->register(new AclServiceProvider());
    }

    /**
     * Registers admin services.
     *
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    protected function registerAdminServices(Container $container)
    {
        /**
         * The admin configset.
         *
         * @param  Container $container The Pimple DI Container.
         * @return AdminConfig
         */
        $container['admin/config'] = function (Container $container) {
            $appConfig = $container['config'];

            // The `admin.json` file is not part of regular config
            $extraConfigs = (array)$appConfig['admin_config'];

            $moduleAdminConfigs = [];

            foreach ($container['module/classes'] as $module) {
                if (defined(sprintf('%s::ADMIN_CONFIG', $module))) {
                    $moduleAdminConfigs[] = $module::ADMIN_CONFIG;
                };
            }

            if (!empty($moduleAdminConfigs)) {
                $extraConfigs = array_merge(
                    $extraConfigs,
                    $moduleAdminConfigs
                );
            }

            if (!empty($extraConfigs)) {
                $basePath = $appConfig['base_path'];
                foreach ($extraConfigs as $path) {
                    $appConfig->addFile($basePath.$path);
                }
            }

            return new AdminConfig($appConfig['admin']);
        };

        if (!isset($container['admin/base-url'])) {
            /**
             * Base Admin URL as a PSR-7 UriInterface object for the current request
             * or the Charcoal application.
             *
             * @param  Container $container The Pimple DI Container.
             * @return \Psr\Http\Message\UriInterface
             */
            $container['admin/base-url'] = function (Container $container) {
                $adminConfig = $container['admin/config'];

                if (isset($adminConfig['base_url'])) {
                    $adminUrl = $adminConfig['base_url'];
                } else {
                    $adminUrl = clone $container['base-url'];
                    if ($adminConfig['base_path']) {
                        $basePath  = rtrim($adminUrl->getBasePath(), '/');
                        $adminPath = ltrim($adminConfig['base_path'], '/');
                        $adminUrl  = $adminUrl->withBasePath($basePath.'/'.$adminPath);
                    }
                }

                $adminUrl = Uri::createFromString($adminUrl)->withUserInfo('');

                /** Fix the base path */
                $path = $adminUrl->getPath();
                if ($path) {
                    $adminUrl = $adminUrl->withBasePath($path)->withPath('');
                }

                return $adminUrl;
            };
        }
    }

    /**
     * Registers metadata extensions.
     *
     * @see    \Charcoal\Model\ServiceProvider\ModelServiceProvider
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    protected function registerMetadataExtensions(Container $container)
    {
        if (!isset($container['metadata/config'])) {
            /**
             * @return MetadataConfig
             */
            $container['metadata/config'] = function () {
                $settings   = $container['admin/config']['metadata'];
                $metaConfig = new MetadataConfig($settings);

                return $metaConfig;
            };
        } else {
            /**
             * Alters the application's metadata configset.
             *
             * This extension will merge any Admin-only metadata settings.
             *
             * @param  MetadataConfig $metaConfig The metadata configset.
             * @param  Container      $container  The Pimple DI container.
             * @return MetadataConfig
             */
            $container->extend('metadata/config', function (MetadataConfig $metaConfig, Container $container) {
                $settings = $container['admin/config']['metadata'];
                if (is_array($settings) && !empty($settings)) {
                    $metaConfig->merge($settings);
                }

                return $metaConfig;
            });
        }

        /**
         * Alters the application's metadata configset.
         *
         * This extension will duplicate each previously defined
         * metadata include path to introduce an "admin" subdirectory
         * which adds support for Admin-only metadata settings.
         *
         * For example, if a developer defines the following paths:
         *
         * ```json
         * "paths": [
         *     "my-app/metadata/",
         *     "vendor/locomotivemtl/charcoal-cms/metadata/"
         * ]
         * ```
         *
         * The Admin's service provider will duplicate like so:
         *
         * ```json
         * "paths": [
         *     "my-app/metadata/admin/",
         *     "my-app/metadata/",
         *     "vendor/locomotivemtl/charcoal-cms/metadata/admin/"
         *     "vendor/locomotivemtl/charcoal-cms/metadata/"
         * ]
         * ```
         *
         * Any data included from the "admin" subdirectory will override
         * any "base" data that's been imported.
         *
         * @param  MetadataConfig $metaConfig The metadata configset.
         * @param  Container      $container  The Pimple DI container.
         * @return MetadataConfig
         */
        $container->extend('metadata/config', function (MetadataConfig $metaConfig, Container $container) {
            $adminConfig = $container['admin/config'];
            $adminDir    = '/'.trim($adminConfig['base_path'], '/');

            $metaPaths   = $metaConfig->paths();
            $parsedPaths = [];
            foreach ($metaPaths as $basePath) {
                $adminPath = rtrim($basePath, '/').$adminDir;

                array_push($parsedPaths, $adminPath, $basePath);
            }

            $metaConfig->setPaths($parsedPaths);

            return $metaConfig;
        });
    }

    /**
     * Registers user-authentication extensions.
     *
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    protected function registerAuthExtensions(Container $container)
    {
        /**
         * @param  Container $container The Pimple DI Container.
         * @return Authenticator
         */
        $container['admin/authenticator'] = function (Container $container) {
            return new Authenticator([
                'logger'        => $container['logger'],
                'user_type'     => User::class,
                'user_factory'  => $container['model/factory'],
                'token_type'    => AuthToken::class,
                'token_factory' => $container['model/factory']
            ]);
        };

        /**
         * For 'charcoal-ui'
         *
         * @todo   Do this right!
         * @param  Container $container The Pimple DI Container.
         * @return Authenticator
         */
        $container['authenticator'] = function (Container $container) {
            return $container['admin/authenticator'];
        };

        /**
         * @param  Container $container The Pimple DI container.
         * @return Authorizer
         */
        $container['admin/authorizer'] = function (Container $container) {
            return new Authorizer([
                'logger'   => $container['logger'],
                'acl'      => $container['admin/acl'],
                'resource' => 'admin'
            ]);
        };

        /**
         * For 'charcoal-ui'
         *
         * @todo   Do this right!
         * @param  Container $container The Pimple DI Container.
         * @return Authorizer
         */
        $container['authorizer'] = function (Container $container) {
            return $container['admin/authorizer'];
        };
    }

    /**
     * Registers view extensions.
     *
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    protected function registerViewExtensions(Container $container)
    {
        if (!isset($container['view/mustache/helpers'])) {
            $container['view/mustache/helpers'] = function () {
                return [];
            };
        }

        /**
         * Extend helpers for the Mustache Engine
         *
         * @return array
         */
        $container->extend('view/mustache/helpers', function (array $helpers, Container $container) {
            $adminUrl = $container['admin/base-url'];

            $urls = [
                /**
                 * Alias of "siteUrl"
                 *
                 * @return UriInterface|null
                 */
                'adminUrl'     => $adminUrl,
                /**
                 * Prepend the administration-area URI to the given path.
                 *
                 * @see    \Charcoal\App\ServiceProvider\AppServiceProvider::registerViewServices()
                 * @param  string $uri A URI path to wrap.
                 * @return UriInterface|null
                 */
                'withAdminUrl' => function ($uri, LambdaHelper $helper = null) use ($adminUrl) {
                    if ($helper) {
                        $uri = $helper->render($uri);
                    }

                    $uri = strval($uri);
                    if ($uri === '') {
                        $uri = $adminUrl->withPath('');
                    } else {
                        $parts = parse_url($uri);
                        if (!isset($parts['scheme'])) {
                            if (!in_array($uri[0], ['/', '#', '?'])) {
                                $path  = isset($parts['path']) ? ltrim($parts['path'], '/') : '';
                                $query = isset($parts['query']) ? $parts['query'] : '';
                                $hash  = isset($parts['fragment']) ? $parts['fragment'] : '';

                                return $adminUrl->withPath($path)
                                                ->withQuery($query)
                                                ->withFragment($hash);
                            }
                        }
                    }

                    return $uri;
                }
            ];

            return array_merge($helpers, $urls);
        });
    }

    /**
     * Registers services for {@link https://studio-42.github.io/elFinder/ elFinder}.
     *
     * @param  Container $container The Pimple DI Container.
     * @return void
     */
    protected function registerElfinderServices(Container $container)
    {
        /**
         * Configure the "config.admin.elfinder" dataset.
         *
         * @param  AdminConfig $adminConfig The admin configset.
         * @return AdminConfig
         */
        $container->extend('admin/config', function (AdminConfig $adminConfig) {
            $adminConfig['elfinder'] = new Config($adminConfig['elfinder']);

            return $adminConfig;
        });

        /**
         * The elFinder configset.
         *
         * @param  Container $container The Pimple DI Container.
         * @return ConfigInterface
         */
        $container['elfinder/config'] = function (Container $container) {
            return $container['admin/config']['elfinder'];
        };
    }

    /**
     * Registers services for {@link https://selectize.github.io/selectize.js/ Selectize}.
     *
     * @param  Container $container The Pimple DI Container.
     * @return void
     */
    protected function registerSelectizeServices(Container $container)
    {
        /**
         * The Selectize Renderer.
         *
         * @param  Container $container The Pimple DI container.
         * @return SelectizeRenderer
         */
        $container['selectize/renderer'] = function (Container $container) {
            return new SelectizeRenderer([
                'logger'           => $container['logger'],
                'translator'       => $container['translator'],
                'template_factory' => $container['template/factory'],
                'view'             => $container['view']
            ]);
        };
    }

    /**
     * @param Container $container Pimple DI container.
     * @return void
     */
    protected function registerAssetsManager(Container $container)
    {
        $container['assets/config'] = function (Container $container) {
            $config = $container['admin/config']->get('assets');

            return new AssetsConfig($config);
        };
    }

    /**
     * Registers the admin factories.
     *
     * @param  Container $container The Pimple DI container.
     * @return void
     */
    protected function registerFactoryServices(Container $container)
    {
        /**
         * @param  Container $container The Pimple DI container.
         * @return FactoryInterface
         */
        $container['property/input/factory'] = function (Container $container) {
            return new Factory([
                'base_class'       => PropertyInputInterface::class,
                'arguments'        => [[
                    'container' => $container,
                    'logger'    => $container['logger']
                ]],
                'resolver_options' => [
                    'suffix' => 'Input'
                ]
            ]);
        };

        /**
         * @param  Container $container The Pimple DI container.
         * @return FactoryInterface
         */
        $container['property/display/factory'] = function (Container $container) {
            return new Factory([
                'base_class'       => PropertyDisplayInterface::class,
                'arguments'        => [[
                    'container' => $container,
                    'logger'    => $container['logger']
                ]],
                'resolver_options' => [
                    'suffix' => 'Display'
                ]
            ]);
        };

        /**
         * @param  Container $container A Pimple DI container.
         * @return FactoryInterface
         */
        $container['secondary-menu/group/factory'] = function (Container $container) {
            return new Factory([
                'base_class'       => SecondaryMenuGroupInterface::class,
                'default_class'    => GenericSecondaryMenuGroup::class,
                'arguments'        => [[
                    'container'      => $container,
                    'logger'         => $container['logger'],
                    'view'           => $container['view'],
                    'layout_builder' => $container['layout/builder']
                ]],
                'resolver_options' => [
                    'suffix' => 'SecondaryMenuGroup'
                ]
            ]);
        };
    }
}

1	<?php
2
3	namespace Charcoal\Admin\ServiceProvider;
4
5	// From Pimple
6	use Charcoal\Admin\AssetsConfig;
7	use Pimple\Container;
8	use Pimple\ServiceProviderInterface;
9	use Assetic\Asset\AssetReference;
10	use Charcoal\Attachment\Object\File;
11	use Charcoal\Factory\GenericResolver;
12
13	// from 'kriswallsmith/assetic'
14	use Assetic\AssetManager;
15
16	// From PSR-7
17	use Psr\Http\Message\UriInterface;
18
19	// From Slim
20	use Slim\Http\Uri;
21
22	// From Mustache
23	use Mustache_LambdaHelper as LambdaHelper;
24
25	// From 'charcoal-config'
26	use Charcoal\Config\ConfigInterface;
27	use Charcoal\Config\GenericConfig as Config;
28
29	// From 'charcoal-factory'
30	use Charcoal\Factory\FactoryInterface;
31
32	// From 'charcoal-core'
33	use Charcoal\Model\Service\MetadataConfig;
34
35	// From 'charcoal-ui'
36	use Charcoal\Ui\ServiceProvider\UiServiceProvider;
37
38	// From 'charcoal-email'
39	use Charcoal\Email\ServiceProvider\EmailServiceProvider;
40
41	// From 'charcoal-factory'
42	use Charcoal\Factory\GenericFactory as Factory;
43
44	// From 'charcoal-user'
45	use Charcoal\User\Authenticator;
46	use Charcoal\User\Authorizer;
47
48	// From 'charcoal-admin'
49	use Charcoal\Admin\Config as AdminConfig;
50	use Charcoal\Admin\Property\PropertyInputInterface;
51	use Charcoal\Admin\Property\PropertyDisplayInterface;
52	use Charcoal\Admin\Service\SelectizeRenderer;
53	use Charcoal\Admin\Ui\SecondaryMenu\GenericSecondaryMenuGroup;
54	use Charcoal\Admin\Ui\SecondaryMenu\SecondaryMenuGroupInterface;
55	use Charcoal\Admin\User;
56	use Charcoal\Admin\User\AuthToken;
57
58	/**
59	* Charcoal Administration Service Provider
60	*
61	* ## Services
62	*
63	* - Module
64	* - Config
65	* - Widget Factory
66	*/
67	class AdminServiceProvider implements ServiceProviderInterface
68	{
69	/**
70	* Registers services on the given container.
71	*
72	* This method should only be used to configure services and parameters.
73	* It should not get services.
74	*
75	* @param Container $container The Pimple DI container.
76	* @return void
77	*/
78	public function register(Container $container)
79	{
80	// Ensure dependencies are set
81	$container->register(new EmailServiceProvider());	4✔
82	$container->register(new UiServiceProvider());	4✔
83	$container->register(new AssetsManagerServiceProvider());	4✔
84
85	$this->registerAdminServices($container);	4✔
86	$this->registerFactoryServices($container);	4✔
87	$this->registerElfinderServices($container);	4✔
88	$this->registerSelectizeServices($container);	4✔
89	$this->registerMetadataExtensions($container);	4✔
90	$this->registerAuthExtensions($container);	4✔
91	$this->registerViewExtensions($container);	4✔
92	$this->registerAssetsManager($container);	4✔
93
94	// Register Access-Control-List (acl)
95	$container->register(new AclServiceProvider());	4✔
96	}	4✔
97
98	/**
99	* Registers admin services.
100	*
101	* @param Container $container The Pimple DI container.
102	* @return void
103	*/
104	protected function registerAdminServices(Container $container)
105	{
106	/**
107	* The admin configset.
108	*
109	* @param Container $container The Pimple DI Container.
110	* @return AdminConfig
111	*/
112	$container['admin/config'] = function (Container $container) {
113	$appConfig = $container['config'];	×
114
115	// The `admin.json` file is not part of regular config
116	$extraConfigs = (array)$appConfig['admin_config'];	×
117
118	$moduleAdminConfigs = [];	×
119
120	foreach ($container['module/classes'] as $module) {	×
121	if (defined(sprintf('%s::ADMIN_CONFIG', $module))) {	×
122	$moduleAdminConfigs[] = $module::ADMIN_CONFIG;	×
123	};
124	}
125
126	if (!empty($moduleAdminConfigs)) {	×
127	$extraConfigs = array_merge(	×
128	$extraConfigs,	×
129	$moduleAdminConfigs
130	);
131	}
132
133	if (!empty($extraConfigs)) {	×
134	$basePath = $appConfig['base_path'];	×
135	foreach ($extraConfigs as $path) {	×
136	$appConfig->addFile($basePath.$path);	×
137	}
138	}
139
140	return new AdminConfig($appConfig['admin']);	×
141	};
142
143	if (!isset($container['admin/base-url'])) {	4✔
144	/**
145	* Base Admin URL as a PSR-7 UriInterface object for the current request
146	* or the Charcoal application.
147	*
148	* @param Container $container The Pimple DI Container.
149	* @return \Psr\Http\Message\UriInterface
150	*/
151	$container['admin/base-url'] = function (Container $container) {
152	$adminConfig = $container['admin/config'];	×
153
154	if (isset($adminConfig['base_url'])) {	×
155	$adminUrl = $adminConfig['base_url'];	×
156	} else {
157	$adminUrl = clone $container['base-url'];	×
158	if ($adminConfig['base_path']) {	×
159	$basePath = rtrim($adminUrl->getBasePath(), '/');	×
160	$adminPath = ltrim($adminConfig['base_path'], '/');	×
161	$adminUrl = $adminUrl->withBasePath($basePath.'/'.$adminPath);	×
162	}
163	}
164
165	$adminUrl = Uri::createFromString($adminUrl)->withUserInfo('');	×
166
167	/** Fix the base path */
168	$path = $adminUrl->getPath();	×
169	if ($path) {	×
170	$adminUrl = $adminUrl->withBasePath($path)->withPath('');	×
171	}
172
173	return $adminUrl;	×
174	};
175	}	1✔
176	}	4✔
177
178	/**
179	* Registers metadata extensions.
180	*
181	* @see \Charcoal\Model\ServiceProvider\ModelServiceProvider
182	* @param Container $container The Pimple DI container.
183	* @return void
184	*/
185	protected function registerMetadataExtensions(Container $container)
186	{
187	if (!isset($container['metadata/config'])) {	4✔
188	/**
189	* @return MetadataConfig
190	*/
191	$container['metadata/config'] = function () {
192	$settings = $container['admin/config']['metadata'];	×
193	$metaConfig = new MetadataConfig($settings);	×
194
195	return $metaConfig;	×
196	};	3✔
197	} else {	1✔
198	/**
199	* Alters the application's metadata configset.
200	*
201	* This extension will merge any Admin-only metadata settings.
202	*
203	* @param MetadataConfig $metaConfig The metadata configset.
204	* @param Container $container The Pimple DI container.
205	* @return MetadataConfig
206	*/
207	$container->extend('metadata/config', function (MetadataConfig $metaConfig, Container $container) {
208	$settings = $container['admin/config']['metadata'];	×
209	if (is_array($settings) && !empty($settings)) {	×
210	$metaConfig->merge($settings);	×
211	}
212
213	return $metaConfig;	×
214	});	×
215	}
216
217	/**
218	* Alters the application's metadata configset.
219	*
220	* This extension will duplicate each previously defined
221	* metadata include path to introduce an "admin" subdirectory
222	* which adds support for Admin-only metadata settings.
223	*
224	* For example, if a developer defines the following paths:
225	*
226	* ```json
227	* "paths": [
228	* "my-app/metadata/",
229	* "vendor/locomotivemtl/charcoal-cms/metadata/"
230	* ]
231	* ```
232	*
233	* The Admin's service provider will duplicate like so:
234	*
235	* ```json
236	* "paths": [
237	* "my-app/metadata/admin/",
238	* "my-app/metadata/",
239	* "vendor/locomotivemtl/charcoal-cms/metadata/admin/"
240	* "vendor/locomotivemtl/charcoal-cms/metadata/"
241	* ]
242	* ```
243	*
244	* Any data included from the "admin" subdirectory will override
245	* any "base" data that's been imported.
246	*
247	* @param MetadataConfig $metaConfig The metadata configset.
248	* @param Container $container The Pimple DI container.
249	* @return MetadataConfig
250	*/
251	$container->extend('metadata/config', function (MetadataConfig $metaConfig, Container $container) {
252	$adminConfig = $container['admin/config'];	×
253	$adminDir = '/'.trim($adminConfig['base_path'], '/');	×
254
255	$metaPaths = $metaConfig->paths();	×
256	$parsedPaths = [];	×
257	foreach ($metaPaths as $basePath) {	×
258	$adminPath = rtrim($basePath, '/').$adminDir;	×
259
260	array_push($parsedPaths, $adminPath, $basePath);	×
261	}
262
263	$metaConfig->setPaths($parsedPaths);	×
264
265	return $metaConfig;	×
266	});	4✔
267	}	4✔
268
269	/**
270	* Registers user-authentication extensions.
271	*
272	* @param Container $container The Pimple DI container.
273	* @return void
274	*/
275	protected function registerAuthExtensions(Container $container)
276	{
277	/**
278	* @param Container $container The Pimple DI Container.
279	* @return Authenticator
280	*/
281	$container['admin/authenticator'] = function (Container $container) {
282	return new Authenticator([	×
283	'logger' => $container['logger'],	×
284	'user_type' => User::class,
285	'user_factory' => $container['model/factory'],	×
286	'token_type' => AuthToken::class,
287	'token_factory' => $container['model/factory']	×
288	]);
289	};
290
291	/**
292	* For 'charcoal-ui'
293	*
294	* @todo Do this right!
295	* @param Container $container The Pimple DI Container.
296	* @return Authenticator
297	*/
298	$container['authenticator'] = function (Container $container) {
299	return $container['admin/authenticator'];	×
300	};
301
302	/**
303	* @param Container $container The Pimple DI container.
304	* @return Authorizer
305	*/
306	$container['admin/authorizer'] = function (Container $container) {
307	return new Authorizer([	×
308	'logger' => $container['logger'],	×
309	'acl' => $container['admin/acl'],	×
310	'resource' => 'admin'
311	]);
312	};
313
314	/**
315	* For 'charcoal-ui'
316	*
317	* @todo Do this right!
318	* @param Container $container The Pimple DI Container.
319	* @return Authorizer
320	*/
321	$container['authorizer'] = function (Container $container) {
322	return $container['admin/authorizer'];	×
323	};
324	}	4✔
325
326	/**
327	* Registers view extensions.
328	*
329	* @param Container $container The Pimple DI container.
330	* @return void
331	*/
332	protected function registerViewExtensions(Container $container)
333	{
334	if (!isset($container['view/mustache/helpers'])) {	4✔
335	$container['view/mustache/helpers'] = function () {
336	return [];	×
337	};
338	}
339
340	/**
341	* Extend helpers for the Mustache Engine
342	*
343	* @return array
344	*/
345	$container->extend('view/mustache/helpers', function (array $helpers, Container $container) {
346	$adminUrl = $container['admin/base-url'];	×
347
348	$urls = [
349	/**
350	* Alias of "siteUrl"
351	*
352	* @return UriInterface\|null
353	*/
354	'adminUrl' => $adminUrl,	×
355	/**
356	* Prepend the administration-area URI to the given path.
357	*
358	* @see \Charcoal\App\ServiceProvider\AppServiceProvider::registerViewServices()
359	* @param string $uri A URI path to wrap.
360	* @return UriInterface\|null
361	*/
362	'withAdminUrl' => function ($uri, LambdaHelper $helper = null) use ($adminUrl) {
363	if ($helper) {	×
364	$uri = $helper->render($uri);	×
365	}
366
367	$uri = strval($uri);	×
368	if ($uri === '') {	×
369	$uri = $adminUrl->withPath('');	×
370	} else {
371	$parts = parse_url($uri);	×
372	if (!isset($parts['scheme'])) {	×
373	if (!in_array($uri[0], ['/', '#', '?'])) {	×
374	$path = isset($parts['path']) ? ltrim($parts['path'], '/') : '';	×
375	$query = isset($parts['query']) ? $parts['query'] : '';	×
376	$hash = isset($parts['fragment']) ? $parts['fragment'] : '';	×
377
378	return $adminUrl->withPath($path)	×
379	->withQuery($query)	×
380	->withFragment($hash);	×
381	}
382	}
383	}
384
385	return $uri;	×
386	}
387	];
388
389	return array_merge($helpers, $urls);	×
390	});	4✔
391	}	4✔
392
393	/**
394	* Registers services for {@link https://studio-42.github.io/elFinder/ elFinder}.
395	*
396	* @param Container $container The Pimple DI Container.
397	* @return void
398	*/
399	protected function registerElfinderServices(Container $container)
400	{
401	/**
402	* Configure the "config.admin.elfinder" dataset.
403	*
404	* @param AdminConfig $adminConfig The admin configset.
405	* @return AdminConfig
406	*/
407	$container->extend('admin/config', function (AdminConfig $adminConfig) {
408	$adminConfig['elfinder'] = new Config($adminConfig['elfinder']);	×
409
410	return $adminConfig;	×
411	});	4✔
412
413	/**
414	* The elFinder configset.
415	*
416	* @param Container $container The Pimple DI Container.
417	* @return ConfigInterface
418	*/
419	$container['elfinder/config'] = function (Container $container) {
420	return $container['admin/config']['elfinder'];	×
421	};
422	}	4✔
423
424	/**
425	* Registers services for {@link https://selectize.github.io/selectize.js/ Selectize}.
426	*
427	* @param Container $container The Pimple DI Container.
428	* @return void
429	*/
430	protected function registerSelectizeServices(Container $container)
431	{
432	/**
433	* The Selectize Renderer.
434	*
435	* @param Container $container The Pimple DI container.
436	* @return SelectizeRenderer
437	*/
438	$container['selectize/renderer'] = function (Container $container) {
439	return new SelectizeRenderer([	×
440	'logger' => $container['logger'],	×
441	'translator' => $container['translator'],	×
442	'template_factory' => $container['template/factory'],	×
443	'view' => $container['view']	×
444	]);
445	};
446	}	4✔
447
448	/**
449	* @param Container $container Pimple DI container.
450	* @return void
451	*/
452	protected function registerAssetsManager(Container $container)
453	{
454	$container['assets/config'] = function (Container $container) {
455	$config = $container['admin/config']->get('assets');	×
456
457	return new AssetsConfig($config);	×
458	};
459	}	4✔
460
461	/**
462	* Registers the admin factories.
463	*
464	* @param Container $container The Pimple DI container.
465	* @return void
466	*/
467	protected function registerFactoryServices(Container $container)
468	{
469	/**
470	* @param Container $container The Pimple DI container.
471	* @return FactoryInterface
472	*/
473	$container['property/input/factory'] = function (Container $container) {
474	return new Factory([	×
475	'base_class' => PropertyInputInterface::class,	×
476	'arguments' => [[
477	'container' => $container,	×
478	'logger' => $container['logger']	×
479	]],
480	'resolver_options' => [
481	'suffix' => 'Input'
482	]
483	]);
484	};
485
486	/**
487	* @param Container $container The Pimple DI container.
488	* @return FactoryInterface
489	*/
490	$container['property/display/factory'] = function (Container $container) {
491	return new Factory([	×
492	'base_class' => PropertyDisplayInterface::class,	×
493	'arguments' => [[
494	'container' => $container,	×
495	'logger' => $container['logger']	×
496	]],
497	'resolver_options' => [
498	'suffix' => 'Display'
499	]
500	]);
501	};
502
503	/**
504	* @param Container $container A Pimple DI container.
505	* @return FactoryInterface
506	*/
507	$container['secondary-menu/group/factory'] = function (Container $container) {
508	return new Factory([	×
509	'base_class' => SecondaryMenuGroupInterface::class,	×
510	'default_class' => GenericSecondaryMenuGroup::class,
511	'arguments' => [[
512	'container' => $container,	×
513	'logger' => $container['logger'],	×
514	'view' => $container['view'],	×
515	'layout_builder' => $container['layout/builder']	×
516	]],
517	'resolver_options' => [
518	'suffix' => 'SecondaryMenuGroup'
519	]
520	]);
521	};
522	}	4✔
523	}

locomotivemtl / charcoal-admin / 1449

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous