diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..39a3187 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +/.github/ export-ignore +.gitattributes export-ignore +.gitignore export-ignore +package.json export-ignore +package-lock.json export-ignore diff --git a/.gitignore b/.gitignore index 3c3629e..022b988 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ node_modules +vendor diff --git a/.phpstorm.meta.php b/.phpstorm.meta.php new file mode 100644 index 0000000..49680e2 --- /dev/null +++ b/.phpstorm.meta.php @@ -0,0 +1,12 @@ + '@', + '' => '@Class', + ] ) + ); +} diff --git a/composer.json b/composer.json new file mode 100644 index 0000000..6794a0d --- /dev/null +++ b/composer.json @@ -0,0 +1,16 @@ +{ + "name": "ashleyfae/novelist", + "type": "wordpress-plugin", + "description": "Easily organize and display your portfolio of books.", + "homepage": "https://novelistplugin.com/", + "license": "GPL-2.0-or-later", + "require": { + "php": ">=7.1", + "composer/installers": "~1.2" + }, + "autoload": { + "psr-4": { + "Novelist\\": "src" + } + } +} diff --git a/composer.lock b/composer.lock new file mode 100644 index 0000000..ed4ad40 --- /dev/null +++ b/composer.lock @@ -0,0 +1,171 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "788be1118f552fe07909725b37972f7b", + "packages": [ + { + "name": "composer/installers", + "version": "v1.11.0", + "source": { + "type": "git", + "url": "https://github.com/composer/installers.git", + "reference": "ae03311f45dfe194412081526be2e003960df74b" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/installers/zipball/ae03311f45dfe194412081526be2e003960df74b", + "reference": "ae03311f45dfe194412081526be2e003960df74b", + "shasum": "" + }, + "require": { + "composer-plugin-api": "^1.0 || ^2.0" + }, + "replace": { + "roundcube/plugin-installer": "*", + "shama/baton": "*" + }, + "require-dev": { + "composer/composer": "1.6.* || ^2.0", + "composer/semver": "^1 || ^3", + "phpstan/phpstan": "^0.12.55", + "phpstan/phpstan-phpunit": "^0.12.16", + "symfony/phpunit-bridge": "^4.2 || ^5", + "symfony/process": "^2.3" + }, + "type": "composer-plugin", + "extra": { + "class": "Composer\\Installers\\Plugin", + "branch-alias": { + "dev-main": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\Installers\\": "src/Composer/Installers" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Kyle Robinson Young", + "email": "kyle@dontkry.com", + "homepage": "https://github.com/shama" + } + ], + "description": "A multi-framework Composer library installer", + "homepage": "https://composer.github.io/installers/", + "keywords": [ + "Craft", + "Dolibarr", + "Eliasis", + "Hurad", + "ImageCMS", + "Kanboard", + "Lan Management System", + "MODX Evo", + "MantisBT", + "Mautic", + "Maya", + "OXID", + "Plentymarkets", + "Porto", + "RadPHP", + "SMF", + "Starbug", + "Thelia", + "Whmcs", + "WolfCMS", + "agl", + "aimeos", + "annotatecms", + "attogram", + "bitrix", + "cakephp", + "chef", + "cockpit", + "codeigniter", + "concrete5", + "croogo", + "dokuwiki", + "drupal", + "eZ Platform", + "elgg", + "expressionengine", + "fuelphp", + "grav", + "installer", + "itop", + "joomla", + "known", + "kohana", + "laravel", + "lavalite", + "lithium", + "magento", + "majima", + "mako", + "mediawiki", + "miaoxing", + "modulework", + "modx", + "moodle", + "osclass", + "phpbb", + "piwik", + "ppi", + "processwire", + "puppet", + "pxcms", + "reindex", + "roundcube", + "shopware", + "silverstripe", + "sydes", + "sylius", + "symfony", + "tastyigniter", + "typo3", + "wordpress", + "yawik", + "zend", + "zikula" + ], + "support": { + "issues": "https://github.com/composer/installers/issues", + "source": "https://github.com/composer/installers/tree/v1.11.0" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2021-04-28T06:42:17+00:00" + } + ], + "packages-dev": [], + "aliases": [], + "minimum-stability": "stable", + "stability-flags": [], + "prefer-stable": false, + "prefer-lowest": false, + "platform": { + "php": ">=7.1" + }, + "platform-dev": [], + "plugin-api-version": "2.1.0" +} diff --git a/includes/admin/thickbox.php b/includes/admin/thickbox.php index 57213e8..3d7f3ce 100644 --- a/includes/admin/thickbox.php +++ b/includes/admin/thickbox.php @@ -245,7 +245,7 @@ function novelistBookGrid() {
- html->series_dropdown( array( + html->series_dropdown( array( 'id' => 'novelist_series_filter', 'name' => 'novelist_series_filter' ) ); ?> @@ -256,7 +256,7 @@ function novelistBookGrid() {
- html->genre_dropdown( array( + html->genre_dropdown( array( 'id' => 'novelist_genre_filter', 'name' => 'novelist_genre_filter' ) ); ?> @@ -312,7 +312,7 @@ function novelistBookGrid() {
- html->select( array( + html->select( array( 'id' => 'novelist_orderby', 'selected' => 'menu_order', 'options' => array( @@ -331,7 +331,7 @@ function novelistBookGrid() {
- html->select( array( + html->select( array( 'id' => 'novelist_order', 'selected' => 'ASC', 'options' => array( @@ -346,7 +346,7 @@ function novelistBookGrid() {
- html->select( array( + html->select( array( 'id' => 'novelist_pagination', 'selected' => 'true', 'options' => array( @@ -361,7 +361,7 @@ function novelistBookGrid() {
- html->text( array( + html->text( array( 'id' => 'novelist_number_results', 'value' => '12', 'type' => 'number' @@ -378,4 +378,4 @@ function novelistBookGrid() { setup_constants(); - - add_action( 'plugins_loaded', array( self::$instance, 'load_textdomain' ) ); - - self::$instance->includes(); - self::$instance->roles = new Novelist_Roles; - self::$instance->html = new Novelist_HTML; - } - - return self::$instance; - - } - - /** - * Throw error on object clone. - * - * The whole idea of the singleton design pattern is that there is a single - * object therefore, we don't want the object to be cloned. - * - * @access protected - * @since 1.0.0 - * @return void - */ - public function __clone() { - // Cloning instances of the class is forbidden. - _doing_it_wrong( __FUNCTION__, __( 'Cheatin’ huh?', 'novelist' ), '1.0.0' ); - } - - /** - * Disable unserializing of the class. - * - * @access protected - * @since 1.0.0 - * @return void - */ - public function __wakeup() { - // Unserializing instances of the class is forbidden. - _doing_it_wrong( __FUNCTION__, __( 'Cheatin’ huh?', 'novelist' ), '1.0.0' ); - } - - /** - * Setup plugin constants. - * - * @access private - * @since 1.0.0 - * @return void - */ - private function setup_constants() { - - // Plugin version. - if ( ! defined( 'NOVELIST_VERSION' ) ) { - define( 'NOVELIST_VERSION', '1.1.11' ); - } - - // Plugin Folder Path. - if ( ! defined( 'NOVELIST_PLUGIN_DIR' ) ) { - define( 'NOVELIST_PLUGIN_DIR', plugin_dir_path( __FILE__ ) ); - } - - // Plugin Folder URL. - if ( ! defined( 'NOVELIST_PLUGIN_URL' ) ) { - define( 'NOVELIST_PLUGIN_URL', plugin_dir_url( __FILE__ ) ); - } - - // Plugin Root File. - if ( ! defined( 'NOVELIST_PLUGIN_FILE' ) ) { - define( 'NOVELIST_PLUGIN_FILE', __FILE__ ); - } - - } - - /** - * Include Required Files - * - * @access private - * @since 1.0.0 - * @return void - */ - private function includes() { - - global $novelist_options; - - // Settings. - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/settings/register-settings.php'; - if ( empty( $novelist_options ) ) { - $novelist_options = novelist_get_settings(); - } - - require_once NOVELIST_PLUGIN_DIR . 'includes/class-novelist-html.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/class-novelist-roles.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/post-types.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/class-novelist-book.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/class-novelist-shortcodes.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/book-functions.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/book-filters.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/load-assets.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/misc-functions.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/template-functions.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/widgets/widget-book.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/widgets/widget-books-by-series.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/widgets/widget-word-count.php'; - - if ( is_admin() ) { - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/admin-actions.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/extensions.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/thickbox.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/tools.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/admin-pages.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/class-novelist-notices.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/class-welcome.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/settings/display-settings.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/books/meta-box.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/books/sanitize-meta-fields.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/books/dashboard-columns.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/books/demo-book.php'; - require_once NOVELIST_PLUGIN_DIR . 'includes/admin/upgrades/upgrade-functions.php'; - } - - require_once NOVELIST_PLUGIN_DIR . 'includes/install.php'; - - } - - /** - * Loads the plugin language files. - * - * @access public - * @since 1.0.0 - * @return void - */ - public function load_textdomain() { - - $lang_dir = dirname( plugin_basename( NOVELIST_PLUGIN_FILE ) ) . '/languages/'; - $lang_dir = apply_filters( 'novelist/languages-directory', $lang_dir ); - load_plugin_textdomain( 'novelist', false, $lang_dir ); - - } - - } +require __DIR__.'/vendor/autoload.php'; + +if (! class_exists('Novelist')) : + + class Novelist + { + /** @var \Novelist\Container\Container */ + private $container; + + /** + * Service providers to boot. + * + * @see Novelist::boot() + * @see Novelist::loadServiceProviders() + * + * @var string[] + */ + private $serviceProviders = []; + + /** @var bool */ + private $serviceProvidersLoaded = false; + + /** + * Novelist_Roles object + * + * @var Novelist_Roles + * @since 1.0.0 + */ + public $roles; + + /** + * HTML elements helper class. + * + * @var Novelist_HTML + * @since 1.1.0 + */ + public $html; + + public function __construct() + { + $this->container = new \Novelist\Container\Container(); + } + + /** + * Initializes the plugin. + * + * @since 2.0 + */ + public function boot() + { + if (version_compare(phpversion(), '7.1', '<')) { + return; + } + + $this->setup_constants(); + $this->loadServiceProviders(); + + add_action('plugins_loaded', [$this, 'load_textdomain']); + + $this->includes(); + $this->roles = new Novelist_Roles(); + $this->html = new Novelist_HTML(); + } + + /** + * Novelist instance. + * + * Insures that only one instance of Novelist exists at any one time. + * + * @deprecated 2.0 + * + * @uses Novelist::setup_constants() Set up the plugin constants. + * @uses Novelist::includes() Include any required files. + * @uses Novelist::load_textdomain() Load the language files. + * + * @access public + * @since 1.0.0 + * @return Novelist Instance of Novelist class + */ + public static function instance() + { + return novelist(); + } + + /** + * Properties are loaded from the service container. + * + * @since 2.0 + * + * @param string $property + * + * @return mixed|object + * @throws Exception + */ + public function __get($property) + { + return $this->container->get($property); + } + + /** + * Magic methods are passed to the service container. + * + * @param $name + * @param $arguments + * + * @return mixed + */ + public function __call($name, $arguments) + { + return call_user_func_array([$this->container, $name], $arguments); + } + + /** + * Throw error on object clone. + * + * The whole idea of the singleton design pattern is that there is a single + * object therefore, we don't want the object to be cloned. + * + * @access protected + * @since 1.0.0 + * @return void + */ + public function __clone() + { + // Cloning instances of the class is forbidden. + _doing_it_wrong(__FUNCTION__, __('Cheatin’ huh?', 'novelist'), '1.0.0'); + } + + /** + * Disable unserializing of the class. + * + * @access protected + * @since 1.0.0 + * @return void + */ + public function __wakeup() + { + // Unserializing instances of the class is forbidden. + _doing_it_wrong(__FUNCTION__, __('Cheatin’ huh?', 'novelist'), '1.0.0'); + } + + /** + * Setup plugin constants. + * + * @access private + * @since 1.0.0 + * @return void + */ + private function setup_constants() + { + // Plugin version. + if (! defined('NOVELIST_VERSION')) { + define('NOVELIST_VERSION', '1.1.11'); + } + + // Plugin Folder Path. + if (! defined('NOVELIST_PLUGIN_DIR')) { + define('NOVELIST_PLUGIN_DIR', plugin_dir_path(__FILE__)); + } + + // Plugin Folder URL. + if (! defined('NOVELIST_PLUGIN_URL')) { + define('NOVELIST_PLUGIN_URL', plugin_dir_url(__FILE__)); + } + + // Plugin Root File. + if (! defined('NOVELIST_PLUGIN_FILE')) { + define('NOVELIST_PLUGIN_FILE', __FILE__); + } + } + + /** + * Registers and boots all service providers. + * + * @since 2.0 + */ + private function loadServiceProviders() + { + if ($this->serviceProvidersLoaded) { + return; + } + + $providers = []; + foreach ($this->serviceProviders as $serviceProvider) { + if (! is_subclass_of($serviceProvider, \Novelist\ServiceProviders\ServiceProvider::class)) { + throw new \InvalidArgumentException(sprintf( + '%s class must implement the ServiceProvider interface.', + $serviceProvider + )); + } + + /** @var \Novelist\ServiceProviders\ServiceProvider $serviceProvider */ + $serviceProvider = new $serviceProvider(); + $serviceProvider->register(); + $providers[] = $serviceProvider; + } + + foreach ($providers as $serviceProvider) { + $serviceProvider->boot(); + } + + $this->serviceProvidersLoaded = true; + } + + /** + * Include Required Files + * + * @access private + * @since 1.0.0 + * @return void + */ + private function includes() + { + + global $novelist_options; + + // Settings. + require_once NOVELIST_PLUGIN_DIR.'includes/admin/settings/register-settings.php'; + if (empty($novelist_options)) { + $novelist_options = novelist_get_settings(); + } + + require_once NOVELIST_PLUGIN_DIR.'includes/class-novelist-html.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/class-novelist-roles.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/post-types.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/class-novelist-book.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/class-novelist-shortcodes.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/book-functions.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/book-filters.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/load-assets.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/misc-functions.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/template-functions.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/widgets/widget-book.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/widgets/widget-books-by-series.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/widgets/widget-word-count.php'; + + if (is_admin()) { + require_once NOVELIST_PLUGIN_DIR.'includes/admin/admin-actions.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/extensions.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/thickbox.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/tools.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/admin-pages.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/class-novelist-notices.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/class-welcome.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/settings/display-settings.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/books/meta-box.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/books/sanitize-meta-fields.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/books/dashboard-columns.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/books/demo-book.php'; + require_once NOVELIST_PLUGIN_DIR.'includes/admin/upgrades/upgrade-functions.php'; + } + + require_once NOVELIST_PLUGIN_DIR.'includes/install.php'; + + } + + /** + * Loads the plugin language files. + * + * @access public + * @since 1.0.0 + * @return void + */ + public function load_textdomain() + { + $lang_dir = dirname(plugin_basename(NOVELIST_PLUGIN_FILE)).'/languages/'; + $lang_dir = apply_filters('novelist/languages-directory', $lang_dir); + load_plugin_textdomain('novelist', false, $lang_dir); + } + + } endif; // End class exists check. @@ -230,10 +320,21 @@ public function load_textdomain() { * This function returns an instance of the Novelist class. * * @since 1.0.0 - * @return Novelist + * @return Novelist|object */ -function Novelist() { - return Novelist::instance(); +function novelist($abstract = null) +{ + static $instance = null; + + if ($instance === null) { + $instance = new Novelist(); + } + + if ($abstract !== null) { + return $instance->make($abstract); + } + + return $instance; } -Novelist(); +novelist()->boot(); diff --git a/readme.txt b/readme.txt index d62d8f5..44dce04 100644 --- a/readme.txt +++ b/readme.txt @@ -2,9 +2,9 @@ Contributors: NoseGraze Donate link: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=L2TL7ZBVUMG9C Tags: books, authors, goodreads, writing, publishing, writer -Requires at least: 4.0 -Tested up to: 5.7 -Requires PHP: 5.4 +Requires at least: 5.0 +Tested up to: 5.8 +Requires PHP: 7.1 Stable tag: trunk License: GPLv2 or later License URI: http://www.gnu.org/licenses/gpl-2.0.html diff --git a/src/Container/Container.php b/src/Container/Container.php new file mode 100644 index 0000000..0251d3e --- /dev/null +++ b/src/Container/Container.php @@ -0,0 +1,1340 @@ +getAlias($c); + } + + return new ContextualBindingBuilder($this, $aliases); + } + + /** + * Determine if the given abstract type has been bound. + * + * @param string $abstract + * + * @return bool + */ + public function bound($abstract) + { + return isset($this->bindings[$abstract]) || + isset($this->instances[$abstract]) || + $this->isAlias($abstract); + } + + /** + * Returns true if the container can return an entry for the given identifier. + * Returns false otherwise. + * + * `has($id)` returning true does not mean that `get($id)` will not throw an exception. + * It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`. + * + * @param string $id Identifier of the entry to look for. + * + * @return bool + */ + public function has($id) + { + return $this->bound($id); + } + + /** + * Determine if the given abstract type has been resolved. + * + * @param string $abstract + * + * @return bool + */ + public function resolved($abstract) + { + if ($this->isAlias($abstract)) { + $abstract = $this->getAlias($abstract); + } + + return isset($this->resolved[$abstract]) || + isset($this->instances[$abstract]); + } + + /** + * Determine if a given type is shared. + * + * @param string $abstract + * + * @return bool + */ + public function isShared($abstract) + { + return isset($this->instances[$abstract]) || + (isset($this->bindings[$abstract]['shared']) && + $this->bindings[$abstract]['shared'] === true); + } + + /** + * Determine if a given string is an alias. + * + * @param string $name + * + * @return bool + */ + public function isAlias($name) + { + return isset($this->aliases[$name]); + } + + /** + * Register a binding with the container. + * + * @param string $abstract + * @param Closure|string|null $concrete + * @param bool $shared + * + * @return void + */ + public function bind($abstract, $concrete = null, $shared = false) + { + $this->dropStaleInstances($abstract); + + // If no concrete type was given, we will simply set the concrete type to the + // abstract type. After that, the concrete type to be registered as shared + // without being forced to state their classes in both of the parameters. + if (is_null($concrete)) { + $concrete = $abstract; + } + + // If the factory is not a Closure, it means it is just a class name which is + // bound into this container to the abstract type and we will just wrap it + // up inside its own Closure to give us more convenience when extending. + if (! $concrete instanceof Closure) { + $concrete = $this->getClosure($abstract, $concrete); + } + + $this->bindings[$abstract] = compact('concrete', 'shared'); + + // If the abstract type was already resolved in this container we'll fire the + // rebound listener so that any objects which have already gotten resolved + // can have their copy of the object updated via the listener callbacks. + if ($this->resolved($abstract)) { + $this->rebound($abstract); + } + } + + /** + * Get the Closure to be used when building a type. + * + * @param string $abstract + * @param string $concrete + * + * @return Closure + */ + protected function getClosure($abstract, $concrete) + { + return function ($container, $parameters = []) use ($abstract, $concrete) { + if ($abstract == $concrete) { + return $container->build($concrete); + } + + return $container->resolve( + $concrete, + $parameters, + $raiseEvents = false + ); + }; + } + + /** + * Determine if the container has a method binding. + * + * @param string $method + * + * @return bool + */ + public function hasMethodBinding($method) + { + return isset($this->methodBindings[$method]); + } + + /** + * Bind a callback to resolve with Container::call. + * + * @param array|string $method + * @param Closure $callback + * + * @return void + */ + public function bindMethod($method, $callback) + { + $this->methodBindings[$this->parseBindMethod($method)] = $callback; + } + + /** + * Get the method to be bound in class@method format. + * + * @param array|string $method + * + * @return string + */ + protected function parseBindMethod($method) + { + if (is_array($method)) { + return $method[0].'@'.$method[1]; + } + + return $method; + } + + /** + * Get the method binding for the given method. + * + * @param string $method + * @param mixed $instance + * + * @return mixed + */ + public function callMethodBinding($method, $instance) + { + return call_user_func($this->methodBindings[$method], $instance, $this); + } + + /** + * Add a contextual binding to the container. + * + * @param string $concrete + * @param string $abstract + * @param \Closure|string $implementation + * + * @return void + */ + public function addContextualBinding($concrete, $abstract, $implementation) + { + $this->contextual[$concrete][$this->getAlias($abstract)] = $implementation; + } + + /** + * Register a binding if it hasn't already been registered. + * + * @param string $abstract + * @param Closure|string|null $concrete + * @param bool $shared + * + * @return void + */ + public function bindIf($abstract, $concrete = null, $shared = false) + { + if (! $this->bound($abstract)) { + $this->bind($abstract, $concrete, $shared); + } + } + + /** + * Register a shared binding in the container. + * + * @param string $abstract + * @param Closure|string|null $concrete + * + * @return void + */ + public function singleton($abstract, $concrete = null) + { + $this->bind($abstract, $concrete, true); + } + + /** + * Register a shared binding if it hasn't already been registered. + * + * @param string $abstract + * @param Closure|string|null $concrete + * + * @return void + */ + public function singletonIf($abstract, $concrete = null) + { + if (! $this->bound($abstract)) { + $this->singleton($abstract, $concrete); + } + } + + /** + * "Extend" an abstract type in the container. + * + * @param string $abstract + * @param Closure $closure + * + * @return void + * + * @throws \InvalidArgumentException + */ + public function extend($abstract, Closure $closure) + { + $abstract = $this->getAlias($abstract); + + if (isset($this->instances[$abstract])) { + $this->instances[$abstract] = $closure($this->instances[$abstract], $this); + + $this->rebound($abstract); + } else { + $this->extenders[$abstract][] = $closure; + + if ($this->resolved($abstract)) { + $this->rebound($abstract); + } + } + } + + /** + * Register an existing instance as shared in the container. + * + * @param string $abstract + * @param mixed $instance + * + * @return mixed + */ + public function instance($abstract, $instance) + { + $this->removeAbstractAlias($abstract); + + $isBound = $this->bound($abstract); + + unset($this->aliases[$abstract]); + + // We'll check to determine if this type has been bound before, and if it has + // we will fire the rebound callbacks registered with the container and it + // can be updated with consuming classes that have gotten resolved here. + $this->instances[$abstract] = $instance; + + if ($isBound) { + $this->rebound($abstract); + } + + return $instance; + } + + /** + * Remove an alias from the contextual binding alias cache. + * + * @param string $searched + * + * @return void + */ + protected function removeAbstractAlias($searched) + { + if (! isset($this->aliases[$searched])) { + return; + } + + foreach ($this->abstractAliases as $abstract => $aliases) { + foreach ($aliases as $index => $alias) { + if ($alias == $searched) { + unset($this->abstractAliases[$abstract][$index]); + } + } + } + } + + /** + * Assign a set of tags to a given binding. + * + * @param array|string $abstracts + * @param array|mixed ...$tags + * + * @return void + */ + public function tag($abstracts, $tags) + { + $tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1); + + foreach ($tags as $tag) { + if (! isset($this->tags[$tag])) { + $this->tags[$tag] = []; + } + + foreach ((array) $abstracts as $abstract) { + $this->tags[$tag][] = $abstract; + } + } + } + + /** + * Alias a type to a different name. + * + * @param string $abstract + * @param string $alias + * + * @return void + * + * @throws LogicException + */ + public function alias($abstract, $alias) + { + if ($alias === $abstract) { + throw new LogicException("[{$abstract}] is aliased to itself."); + } + + $this->aliases[$alias] = $abstract; + + $this->abstractAliases[$abstract][] = $alias; + } + + /** + * Bind a new callback to an abstract's rebind event. + * + * @param string $abstract + * @param Closure $callback + * + * @return mixed + */ + public function rebinding($abstract, Closure $callback) + { + $this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback; + + if ($this->bound($abstract)) { + return $this->make($abstract); + } + + return null; + } + + /** + * Refresh an instance on the given target and method. + * + * @param string $abstract + * @param mixed $target + * @param string $method + * + * @return mixed + */ + public function refresh($abstract, $target, $method) + { + return $this->rebinding( + $abstract, + function ($app, $instance) use ($target, $method) { + $target->{$method}($instance); + } + ); + } + + /** + * Fire the "rebound" callbacks for the given abstract type. + * + * @param string $abstract + * + * @return void + */ + protected function rebound($abstract) + { + $instance = $this->make($abstract); + + foreach ($this->getReboundCallbacks($abstract) as $callback) { + $callback($this, $instance); + } + } + + /** + * Get the rebound callbacks for a given type. + * + * @param string $abstract + * + * @return array + */ + protected function getReboundCallbacks($abstract) + { + return isset($this->reboundCallbacks[$abstract]) ? $this->reboundCallbacks[$abstract] : []; + } + + /** + * Get a closure to resolve the given type from the container. + * + * @param string $abstract + * + * @return Closure + */ + public function factory($abstract) + { + return function () use ($abstract) { + return $this->make($abstract); + }; + } + + /** + * Resolve the given type from the container. + * + * @param string $abstract + * @param array $parameters + * + * @return mixed + */ + public function make($abstract, array $parameters = []) + { + return $this->resolve($abstract, $parameters); + } + + /** + * Finds an entry of the container by its identifier and returns it. + * + * @param string $id Identifier of the entry to look for. + * + * @return mixed Entry. + * @throws Exception + */ + public function get($id) + { + try { + return $this->resolve($id); + } catch (Exception $e) { + if ($this->has($id)) { + throw $e; + } + + throw new InvalidArgumentException($id, $e->getCode(), $e); + } + } + + /** + * Resolve the given type from the container. + * + * @param string $abstract + * @param array $parameters + * @param bool $raiseEvents + * + * @return mixed + * @throws BindingResolutionException + */ + protected function resolve($abstract, $parameters = [], $raiseEvents = true) + { + $abstract = $this->getAlias($abstract); + + $concrete = $this->getContextualConcrete($abstract); + + $needsContextualBuild = ! empty($parameters) || ! is_null($concrete); + + // If an instance of the type is currently being managed as a singleton we'll + // just return an existing instance instead of instantiating new instances + // so the developer can keep using the same objects instance every time. + if (isset($this->instances[$abstract]) && ! $needsContextualBuild) { + return $this->instances[$abstract]; + } + + $this->with[] = $parameters; + + if (is_null($concrete)) { + $concrete = $this->getConcrete($abstract); + } + + // We're ready to instantiate an instance of the concrete type registered for + // the binding. This will instantiate the types, as well as resolve any of + // its "nested" dependencies recursively until all have gotten resolved. + if ($this->isBuildable($concrete, $abstract)) { + $object = $this->build($concrete); + } else { + $object = $this->make($concrete); + } + + // If we defined any extenders for this type, we'll need to spin through them + // and apply them to the object being built. This allows for the extension + // of services, such as changing configuration or decorating the object. + foreach ($this->getExtenders($abstract) as $extender) { + $object = $extender($object, $this); + } + + // If the requested type is registered as a singleton we'll want to cache off + // the instances in "memory" so we can return it later without creating an + // entirely new instance of an object on each subsequent request for it. + if ($this->isShared($abstract) && ! $needsContextualBuild) { + $this->instances[$abstract] = $object; + } + + if ($raiseEvents) { + $this->fireResolvingCallbacks($abstract, $object); + } + + // Before returning, we will also set the resolved flag to "true" and pop off + // the parameter overrides for this build. After those two things are done + // we will be ready to return back the fully constructed class instance. + $this->resolved[$abstract] = true; + + array_pop($this->with); + + return $object; + } + + /** + * Get the concrete type for a given abstract. + * + * @param string $abstract + * + * @return mixed + */ + protected function getConcrete($abstract) + { + // If we don't have a registered resolver or concrete for the type, we'll just + // assume each type is a concrete name and will attempt to resolve it as is + // since the container should be able to resolve concretes automatically. + if (isset($this->bindings[$abstract])) { + return $this->bindings[$abstract]['concrete']; + } + + return $abstract; + } + + /** + * Get the contextual concrete binding for the given abstract. + * + * @param string|callable $abstract + * + * @return \Closure|string|array|null + */ + protected function getContextualConcrete($abstract) + { + if (! is_null($binding = $this->findInContextualBindings($abstract))) { + return $binding; + } + + // Next we need to see if a contextual binding might be bound under an alias of the + // given abstract type. So, we will need to check if any aliases exist with this + // type and then spin through them and check for contextual bindings on these. + if (empty($this->abstractAliases[$abstract])) { + return; + } + + foreach ($this->abstractAliases[$abstract] as $alias) { + if (! is_null($binding = $this->findInContextualBindings($alias))) { + return $binding; + } + } + } + + /** + * Find the concrete binding for the given abstract in the contextual binding array. + * + * @param string|callable $abstract + * + * @return \Closure|string|null + */ + protected function findInContextualBindings($abstract) + { + return $this->contextual[end($this->buildStack)][$abstract] ?? null; + } + + + /** + * Determine if the given concrete is buildable. + * + * @param mixed $concrete + * @param string $abstract + * + * @return bool + */ + protected function isBuildable($concrete, $abstract) + { + return $concrete === $abstract || $concrete instanceof Closure; + } + + /** + * Instantiate a concrete instance of the given type. + * + * @param Closure|string $concrete + * + * @return mixed + * @throws BindingResolutionException + * @throws ReflectionException + */ + public function build($concrete) + { + // If the concrete type is actually a Closure, we will just execute it and + // hand back the results of the functions, which allows functions to be + // used as resolvers for more fine-tuned resolution of these objects. + if ($concrete instanceof Closure) { + return $concrete($this, $this->getLastParameterOverride()); + } + + try { + $reflector = new ReflectionClass($concrete); + } catch (ReflectionException $e) { + throw new InvalidArgumentException("Target class [$concrete] does not exist.", 0, $e); + } + + // If the type is not instantiable, the developer is attempting to resolve + // an abstract type such as an Interface or Abstract Class and there is + // no binding registered for the abstractions so we need to bail out. + if (! $reflector->isInstantiable()) { + $this->notInstantiable($concrete); + } + + $this->buildStack[] = $concrete; + + $constructor = $reflector->getConstructor(); + + // If there are no constructors, that means there are no dependencies then + // we can just resolve the instances of the objects right away, without + // resolving any other types or dependencies out of these containers. + if (is_null($constructor)) { + array_pop($this->buildStack); + + return new $concrete; + } + + $dependencies = $constructor->getParameters(); + + // Once we have all the constructor's parameters we can create each of the + // dependency instances and then use the reflection instances to make a + // new instance of this class, injecting the created dependencies in. + try { + $instances = $this->resolveDependencies($dependencies); + } catch (BindingResolutionException $e) { + array_pop($this->buildStack); + + throw $e; + } + + array_pop($this->buildStack); + + return $reflector->newInstanceArgs($instances); + } + + /** + * Resolve all of the dependencies from the ReflectionParameters. + * + * @param array $dependencies + * + * @return array + * @throws BindingResolutionException + * @throws ReflectionException + */ + protected function resolveDependencies(array $dependencies) + { + $results = []; + + foreach ($dependencies as $dependency) { + // If this dependency has a override for this particular build we will use + // that instead as the value. Otherwise, we will continue with this run + // of resolutions and let reflection attempt to determine the result. + if ($this->hasParameterOverride($dependency)) { + $results[] = $this->getParameterOverride($dependency); + + continue; + } + + // If the class is null, it means the dependency is a string or some other + // primitive type which we can not resolve since it is not a class and + // we will just bomb out with an error since we have no-where to go. + $result = is_null(Util::getParameterClassName($dependency)) + ? $this->resolvePrimitive($dependency) + : $this->resolveClass($dependency); + + if ($dependency->isVariadic()) { + $results = array_merge($results, $result); + } else { + $results[] = $result; + } + } + + return $results; + } + + /** + * Determine if the given dependency has a parameter override. + * + * @param ReflectionParameter $dependency + * + * @return bool + */ + protected function hasParameterOverride($dependency) + { + return array_key_exists( + $dependency->name, + $this->getLastParameterOverride() + ); + } + + /** + * Get a parameter override for a dependency. + * + * @param ReflectionParameter $dependency + * + * @return mixed + */ + protected function getParameterOverride($dependency) + { + return $this->getLastParameterOverride()[$dependency->name]; + } + + /** + * Get the last parameter override. + * + * @return array + */ + protected function getLastParameterOverride() + { + return count($this->with) ? end($this->with) : []; + } + + /** + * Resolve a non-class hinted primitive dependency. + * + * @param ReflectionParameter $parameter + * + * @return mixed + * @throws ReflectionException + */ + protected function resolvePrimitive(ReflectionParameter $parameter) + { + if ($parameter->isDefaultValueAvailable()) { + return $parameter->getDefaultValue(); + } + + $this->unresolvablePrimitive($parameter); + + return null; + } + + /** + * Resolve a class based dependency from the container. + * + * @param ReflectionParameter $parameter + * + * @return mixed + * @throws BindingResolutionException + * @throws ReflectionException + */ + protected function resolveClass(ReflectionParameter $parameter) + { + try { + return $parameter->isVariadic() + ? $this->resolveVariadicClass($parameter) + : $this->make(Util::getParameterClassName($parameter)); + } + + // If we can not resolve the class instance, we will check to see if the value + // is optional, and if it is we will return the optional parameter value as + // the value of the dependency, similarly to how we do this with scalars. + catch (BindingResolutionException $e) { + if ($parameter->isDefaultValueAvailable()) { + return $parameter->getDefaultValue(); + } + + if ($parameter->isVariadic()) { + return []; + } + + throw $e; + } + } + + /** + * Resolve a class based variadic dependency from the container. + * + * @param \ReflectionParameter $parameter + * + * @return mixed + * @throws BindingResolutionException + */ + protected function resolveVariadicClass(ReflectionParameter $parameter) + { + $className = Util::getParameterClassName($parameter); + + $abstract = $this->getAlias($className); + + if (! is_array($concrete = $this->getContextualConcrete($abstract))) { + return $this->make($className); + } + + return array_map(function ($abstract) { + return $this->resolve($abstract); + }, $concrete); + } + + /** + * Throw an exception that the concrete is not instantiable. + * + * @param string $concrete + * + * @return void + * @throws BindingResolutionException + */ + protected function notInstantiable($concrete) + { + if (! empty($this->buildStack)) { + $previous = implode(', ', $this->buildStack); + + $message = "Target [$concrete] is not instantiable while building [$previous]."; + } else { + $message = "Target [$concrete] is not instantiable."; + } + + throw new BindingResolutionException($message); + } + + /** + * Throw an exception for an unresolvable primitive. + * + * @param ReflectionParameter $parameter + * + * @return void + * @throws BindingResolutionException + */ + protected function unresolvablePrimitive(ReflectionParameter $parameter) + { + $message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}"; + + throw new BindingResolutionException($message); + } + + /** + * Register a new resolving callback. + * + * @param Closure|string $abstract + * @param Closure|null $callback + * + * @return void + */ + public function resolving($abstract, Closure $callback = null) + { + if (is_string($abstract)) { + $abstract = $this->getAlias($abstract); + } + + if (is_null($callback) && $abstract instanceof Closure) { + $this->globalResolvingCallbacks[] = $abstract; + } else { + $this->resolvingCallbacks[$abstract][] = $callback; + } + } + + /** + * Register a new after resolving callback for all types. + * + * @param Closure|string $abstract + * @param Closure|null $callback + * + * @return void + */ + public function afterResolving($abstract, Closure $callback = null) + { + if (is_string($abstract)) { + $abstract = $this->getAlias($abstract); + } + + if ($abstract instanceof Closure && is_null($callback)) { + $this->globalAfterResolvingCallbacks[] = $abstract; + } else { + $this->afterResolvingCallbacks[$abstract][] = $callback; + } + } + + /** + * Fire all of the resolving callbacks. + * + * @param string $abstract + * @param mixed $object + * + * @return void + */ + protected function fireResolvingCallbacks($abstract, $object) + { + $this->fireCallbackArray($object, $this->globalResolvingCallbacks); + + $this->fireCallbackArray( + $object, + $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks) + ); + + $this->fireAfterResolvingCallbacks($abstract, $object); + } + + /** + * Fire all of the after resolving callbacks. + * + * @param string $abstract + * @param mixed $object + * + * @return void + */ + protected function fireAfterResolvingCallbacks($abstract, $object) + { + $this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks); + + $this->fireCallbackArray( + $object, + $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks) + ); + } + + /** + * Get all callbacks for a given type. + * + * @param string $abstract + * @param object $object + * @param array $callbacksPerType + * + * @return array + */ + protected function getCallbacksForType($abstract, $object, array $callbacksPerType) + { + $results = []; + + foreach ($callbacksPerType as $type => $callbacks) { + if ($type === $abstract || $object instanceof $type) { + array_push($results, ...$callbacks); + } + } + + return $results; + } + + /** + * Fire an array of callbacks with an object. + * + * @param mixed $object + * @param array $callbacks + * + * @return void + */ + protected function fireCallbackArray($object, array $callbacks) + { + foreach ($callbacks as $callback) { + $callback($object, $this); + } + } + + /** + * Get the container's bindings. + * + * @return array + */ + public function getBindings() + { + return $this->bindings; + } + + /** + * Get the alias for an abstract if available. + * + * @param string $abstract + * + * @return string + */ + public function getAlias($abstract) + { + if (! isset($this->aliases[$abstract])) { + return $abstract; + } + + return $this->getAlias($this->aliases[$abstract]); + } + + /** + * Get the extender callbacks for a given type. + * + * @param string $abstract + * + * @return array + */ + protected function getExtenders($abstract) + { + $abstract = $this->getAlias($abstract); + + return isset($this->extenders[$abstract]) ? $this->extenders[$abstract] : []; + } + + /** + * Remove all of the extender callbacks for a given type. + * + * @param string $abstract + * + * @return void + */ + public function forgetExtenders($abstract) + { + unset($this->extenders[$this->getAlias($abstract)]); + } + + /** + * Drop all of the stale instances and aliases. + * + * @param string $abstract + * + * @return void + */ + protected function dropStaleInstances($abstract) + { + unset($this->instances[$abstract], $this->aliases[$abstract]); + } + + /** + * Remove a resolved instance from the instance cache. + * + * @param string $abstract + * + * @return void + */ + public function forgetInstance($abstract) + { + unset($this->instances[$abstract]); + } + + /** + * Clear all of the instances from the container. + * + * @return void + */ + public function forgetInstances() + { + $this->instances = []; + } + + /** + * Flush the container of all bindings and resolved instances. + * + * @return void + */ + public function flush() + { + $this->aliases = []; + $this->resolved = []; + $this->bindings = []; + $this->instances = []; + $this->abstractAliases = []; + } + + /** + * Determine if a given offset exists. + * + * @param string $key + * + * @return bool + */ + public function offsetExists($key) + { + return $this->bound($key); + } + + /** + * Get the value at a given offset. + * + * @param string $key + * + * @return mixed + */ + public function offsetGet($key) + { + return $this->make($key); + } + + /** + * Set the value at a given offset. + * + * @param string $key + * @param mixed $value + * + * @return void + */ + public function offsetSet($key, $value) + { + $this->bind( + $key, + $value instanceof Closure ? $value : function () use ($value) { + return $value; + } + ); + } + + /** + * Unset the value at a given offset. + * + * @param string $key + * + * @return void + */ + public function offsetUnset($key) + { + unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]); + } + + /** + * Dynamically access container services. + * + * @param string $key + * + * @return mixed + */ + public function __get($key) + { + return $this[$key]; + } + + /** + * Dynamically set container services. + * + * @param string $key + * @param mixed $value + * + * @return void + */ + public function __set($key, $value) + { + $this[$key] = $value; + } + + /** + * Checks to see if the key exists. + * + * @param $key + * + * @return bool + */ + public function __isset($key) + { + return isset($this[$key]); + } + +} diff --git a/src/Container/ContextualBindingBuilder.php b/src/Container/ContextualBindingBuilder.php new file mode 100644 index 0000000..857484f --- /dev/null +++ b/src/Container/ContextualBindingBuilder.php @@ -0,0 +1,80 @@ +container = $container; + $this->concrete = is_array($concrete) ? $concrete : [$concrete]; + } + + /** + * Define the abstract target that depends on the context. + * + * @param string $abstract + * + * @return $this + */ + public function needs($abstract) + { + $this->needs = $abstract; + + return $this; + } + + /** + * Define the implementation for the contextual binding. + * + * @param \Closure|string|array $implementation + * + * @return void + */ + public function give($implementation) + { + foreach ($this->concrete as $concrete) { + $this->container->addContextualBinding($concrete, $this->needs, $implementation); + } + } + +} diff --git a/src/Container/Exceptions/BindingResolutionException.php b/src/Container/Exceptions/BindingResolutionException.php new file mode 100644 index 0000000..5b1822a --- /dev/null +++ b/src/Container/Exceptions/BindingResolutionException.php @@ -0,0 +1,15 @@ +getType(); + + if (! $type instanceof ReflectionNamedType || $type->isBuiltin()) { + return; + } + + $name = $type->getName(); + + if (! is_null($class = $parameter->getDeclaringClass())) { + if ($name === 'self') { + return $class->getName(); + } + + if ($name === 'parent' && $parent = $class->getParentClass()) { + return $parent->getName(); + } + } + + return $name; + } + +} diff --git a/src/ServiceProviders/ServiceProvider.php b/src/ServiceProviders/ServiceProvider.php new file mode 100644 index 0000000..8032e0f --- /dev/null +++ b/src/ServiceProviders/ServiceProvider.php @@ -0,0 +1,32 @@ +roles->remove_caps(); +novelist()->roles->remove_caps(); $novelist_roles = array( 'book_manager' ); foreach ( $novelist_roles as $role ) { remove_role( $role ); @@ -88,4 +88,4 @@ * Delete transients. */ $wpdb->query( "DELETE FROM $wpdb->options WHERE option_name LIKE '_transient_novelist_%'" ); -$wpdb->query( "DELETE FROM $wpdb->options WHERE option_name LIKE '_transient_timeout_novelist_%'" ); \ No newline at end of file +$wpdb->query( "DELETE FROM $wpdb->options WHERE option_name LIKE '_transient_timeout_novelist_%'" );