From 139c240860df515f5ce19d8d3bb75ff6e82cc491 Mon Sep 17 00:00:00 2001
From: Ashley Gibson <ashley@nosegraze.com>
Date: Wed, 1 Sep 2021 13:05:41 +0100
Subject: [PATCH 1/2] Add Laravel Container & service provider logic #23

---
 .gitattributes                                |    5 +
 .gitignore                                    |    1 +
 .phpstorm.meta.php                            |   12 +
 composer.json                                 |   16 +
 composer.lock                                 |  171 +++
 includes/admin/thickbox.php                   |   14 +-
 novelist.php                                  |  479 ++++---
 readme.txt                                    |    6 +-
 src/Container/Container.php                   | 1276 +++++++++++++++++
 src/Container/ContextualBindingBuilder.php    |   77 +
 .../Exceptions/BindingResolutionException.php |   15 +
 src/Container/Util.php                        |   46 +
 src/ServiceProviders/ServiceProvider.php      |   32 +
 uninstall.php                                 |    4 +-
 14 files changed, 1953 insertions(+), 201 deletions(-)
 create mode 100644 .gitattributes
 create mode 100644 .phpstorm.meta.php
 create mode 100644 composer.json
 create mode 100644 composer.lock
 create mode 100644 src/Container/Container.php
 create mode 100644 src/Container/ContextualBindingBuilder.php
 create mode 100644 src/Container/Exceptions/BindingResolutionException.php
 create mode 100644 src/Container/Util.php
 create mode 100644 src/ServiceProviders/ServiceProvider.php

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 @@
+<?php
+
+namespace PHPSTORM_META {
+    // Allow PhpStorm IDE to resolve return types when calling novelist( Object_Type::class ) or novelist( `Object_Type` ).
+    override(
+        \novelist( 0 ),
+        map( [
+            '' => '@',
+            '' => '@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() {
 			<div class="novelist-box-row">
 				<label for="novelist_series_filter"><?php _e( 'Filter by Series', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->series_dropdown( array(
+					<?php novelist()->html->series_dropdown( array(
 						'id'   => 'novelist_series_filter',
 						'name' => 'novelist_series_filter'
 					) ); ?>
@@ -256,7 +256,7 @@ function novelistBookGrid() {
 			<div class="novelist-box-row">
 				<label for="novelist_genre_filter"><?php _e( 'Filter by Genre', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->genre_dropdown( array(
+					<?php novelist()->html->genre_dropdown( array(
 						'id'   => 'novelist_genre_filter',
 						'name' => 'novelist_genre_filter'
 					) ); ?>
@@ -312,7 +312,7 @@ function novelistBookGrid() {
 			<div class="novelist-box-row">
 				<label for="novelist_orderby"><?php _e( 'Order By', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->select( array(
+					<?php novelist()->html->select( array(
 						'id'       => 'novelist_orderby',
 						'selected' => 'menu_order',
 						'options'  => array(
@@ -331,7 +331,7 @@ function novelistBookGrid() {
 			<div class="novelist-box-row">
 				<label for="novelist_order"><?php _e( 'Order', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->select( array(
+					<?php novelist()->html->select( array(
 						'id'       => 'novelist_order',
 						'selected' => 'ASC',
 						'options'  => array(
@@ -346,7 +346,7 @@ function novelistBookGrid() {
 			<div class="novelist-box-row">
 				<label for="novelist_pagination"><?php _e( 'Split Results into Multiple Pages?', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->select( array(
+					<?php novelist()->html->select( array(
 						'id'       => 'novelist_pagination',
 						'selected' => 'true',
 						'options'  => array(
@@ -361,7 +361,7 @@ function novelistBookGrid() {
 			<div class="novelist-box-row">
 				<label for="novelist_number_results"><?php _e( 'Number of Results', 'novelist' ); ?></label>
 				<div>
-					<?php Novelist()->html->text( array(
+					<?php novelist()->html->text( array(
 						'id'    => 'novelist_number_results',
 						'value' => '12',
 						'type'  => 'number'
@@ -378,4 +378,4 @@ function novelistBookGrid() {
 	<?php
 }
 
-add_action( 'admin_footer', 'novelist_admin_footer_for_thickbox' );
\ No newline at end of file
+add_action( 'admin_footer', 'novelist_admin_footer_for_thickbox' );
diff --git a/novelist.php b/novelist.php
index 0c7b453..d76293e 100644
--- a/novelist.php
+++ b/novelist.php
@@ -9,6 +9,8 @@
  * License: GPL2
  * Text Domain: novelist
  * Domain Path: languages
+ * Requires at least: 5.0
+ * Requires PHP: 7.1
  *
  * Novelist is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,193 +36,281 @@
  */
 
 // Exit if accessed directly
-if ( ! defined( 'ABSPATH' ) ) {
-	exit;
+if (! defined('ABSPATH')) {
+    exit;
 }
 
-if ( ! class_exists( 'Novelist' ) ) :
-
-	class Novelist {
-
-		/**
-		 * Novelist object
-		 *
-		 * @var Novelist Instance of the Novelist class.
-		 * @since 1.0.0
-		 */
-		private static $instance;
-
-		/**
-		 * Novelist_Roles object
-		 *
-		 * @var object Instance of Novelist_Roles class.
-		 * @since 1.0.0
-		 */
-		public $roles;
-
-		/**
-		 * HTML elements helper class.
-		 *
-		 * @var Novelist_HTML
-		 * @since 1.1.0
-		 */
-		public $html;
-
-		/**
-		 * Novelist instance.
-		 *
-		 * Insures that only one instance of Novelist exists at any one time.
-		 *
-		 * @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() {
-
-			if ( ! isset( self::$instance ) && ! self::$instance instanceof Novelist ) {
-				self::$instance = new Novelist;
-				self::$instance->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&#8217; 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&#8217; 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&#8217; 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&#8217; 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..c8fb51c
--- /dev/null
+++ b/src/Container/Container.php
@@ -0,0 +1,1276 @@
+<?php
+/**
+ * Container.php
+ *
+ * Taken from Laravel
+ *
+ * @link      https://github.com/laravel/framework/blob/8.x/src/Illuminate/Container/Container.php
+ *
+ * @package   novelist
+ * @copyright Copyright (c) 2021, Ashley Gibson
+ * @license   GPL2+
+ */
+
+namespace Novelist\Container;
+
+use ArrayAccess;
+use Closure;
+use InvalidArgumentException;
+use LogicException;
+use ReflectionClass;
+use ReflectionException;
+use ReflectionParameter;
+use Exception;
+
+class Container implements ArrayAccess
+{
+
+    /**
+     * An array of the types that have been resolved.
+     *
+     * @var bool[]
+     */
+    protected $resolved = [];
+
+    /**
+     * The container's bindings.
+     *
+     * @var array[]
+     */
+    protected $bindings = [];
+
+    /**
+     * The container's method bindings.
+     *
+     * @var Closure[]
+     */
+    protected $methodBindings = [];
+
+    /**
+     * The container's shared instances.
+     *
+     * @var object[]
+     */
+    protected $instances = [];
+
+    /**
+     * The registered type aliases.
+     *
+     * @var string[]
+     */
+    protected $aliases = [];
+
+    /**
+     * The registered aliases keyed by the abstract name.
+     *
+     * @var array[]
+     */
+    protected $abstractAliases = [];
+
+    /**
+     * The extension closures for services.
+     *
+     * @var array[]
+     */
+    protected $extenders = [];
+
+    /**
+     * All of the registered tags.
+     *
+     * @var array[]
+     */
+    protected $tags = [];
+
+    /**
+     * The stack of concretions currently being built.
+     *
+     * @var array[]
+     */
+    protected $buildStack = [];
+
+    /**
+     * The parameter override stack.
+     *
+     * @var array[]
+     */
+    protected $with = [];
+
+    /**
+     * The contextual binding map.
+     *
+     * @var array[]
+     */
+    public $contextual = [];
+
+    /**
+     * All of the registered rebound callbacks.
+     *
+     * @var array[]
+     */
+    protected $reboundCallbacks = [];
+
+    /**
+     * All of the global resolving callbacks.
+     *
+     * @var Closure[]
+     */
+    protected $globalResolvingCallbacks = [];
+
+    /**
+     * All of the global after resolving callbacks.
+     *
+     * @var Closure[]
+     */
+    protected $globalAfterResolvingCallbacks = [];
+
+    /**
+     * All of the resolving callbacks by class type.
+     *
+     * @var array[]
+     */
+    protected $resolvingCallbacks = [];
+
+    /**
+     * All of the after resolving callbacks by class type.
+     *
+     * @var array[]
+     */
+    protected $afterResolvingCallbacks = [];
+
+    /**
+     * Define a contextual binding.
+     *
+     * @param array|string $concrete
+     *
+     * @return ContextualBindingBuilder
+     */
+    public function when( $concrete ) {
+        $aliases = [];
+
+        if ( ! is_array( $concrete ) ) {
+            $concrete = [ $concrete ];
+        }
+
+        foreach ( $concrete as $c ) {
+            $aliases[] = $this->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..8675b95
--- /dev/null
+++ b/src/Container/ContextualBindingBuilder.php
@@ -0,0 +1,77 @@
+<?php
+/**
+ * ContextualBindingBuilder.php
+ *
+ * Taken from Laravel.
+ *
+ * @link      https://github.com/laravel/framework/blob/3bde8d5e3cf412c1e885eb310522b51d0053f736/src/Illuminate/Container/ContextualBindingBuilder.php
+ *
+ * @package   novelist
+ * @copyright Copyright (c) 2021, Ashley Gibson
+ * @license   GPL2+
+ */
+
+namespace Novelist\Container;
+
+class ContextualBindingBuilder
+{
+
+    /**
+     * The underlying container instance.
+     *
+     * @var Container
+     */
+    protected $container;
+
+    /**
+     * The concrete instance.
+     *
+     * @var array
+     */
+    protected $concrete;
+
+    /**
+     * The abstract target.
+     *
+     * @var string
+     */
+    protected $needs;
+
+    /**
+     * ContextualBindingBuilder constructor.
+     *
+     * @param Container    $container
+     * @param array|string $concrete
+     */
+    public function __construct( Container $container, $concrete ) {
+        $this->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 @@
+<?php
+/**
+ * BindingResolutionException.php
+ *
+ * @package   novelist
+ * @copyright Copyright (c) 2021, Ashley Gibson
+ * @license   GPL2+
+ */
+
+namespace Novelist\Container\Exceptions;
+
+class BindingResolutionException extends \Exception
+{
+
+}
diff --git a/src/Container/Util.php b/src/Container/Util.php
new file mode 100644
index 0000000..02b2042
--- /dev/null
+++ b/src/Container/Util.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * Util.php
+ *
+ * @package   novelist
+ * @copyright Copyright (c) 2021, Ashley Gibson
+ * @license   GPL2+
+ */
+
+namespace Novelist\Container;
+
+use ReflectionNamedType;
+
+class Util
+{
+
+    /**
+     * Get the class name of the given parameter's type, if possible.
+     *
+     * @param \ReflectionParameter $parameter
+     *
+     * @return string|null
+     */
+    public static function getParameterClassName( $parameter ) {
+        $type = $parameter->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 @@
+<?php
+/**
+ * ServiceProvider.php
+ *
+ * @package   novelist
+ * @copyright Copyright (c) 2021, Ashley Gibson
+ * @license   GPL2+
+ */
+
+namespace Novelist\ServiceProviders;
+
+interface ServiceProvider
+{
+    /**
+     * Registers the service provider within the application.
+     *
+     * @since 2.0
+     *
+     * @return void
+     */
+    public function register();
+
+    /**
+     * Bootstraps the service after all of the services have been registered.
+     * All dependencies will be available at this point.
+     *
+     * @since 2.0
+     *
+     * @return void
+     */
+    public function boot();
+}
diff --git a/uninstall.php b/uninstall.php
index 414b598..94afc83 100644
--- a/uninstall.php
+++ b/uninstall.php
@@ -78,7 +78,7 @@
 /*
  * Delete capabilities and roles.
  */
-Novelist()->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_%'" );

From c49741596f827cbd4b30af9d511aa10950e8f626 Mon Sep 17 00:00:00 2001
From: Ashley Gibson <ashley@nosegraze.com>
Date: Wed, 1 Sep 2021 13:07:40 +0100
Subject: [PATCH 2/2] Formatting #23

---
 src/Container/Container.php                | 734 +++++++++++----------
 src/Container/ContextualBindingBuilder.php |  23 +-
 src/Container/Util.php                     |  13 +-
 3 files changed, 419 insertions(+), 351 deletions(-)

diff --git a/src/Container/Container.php b/src/Container/Container.php
index c8fb51c..0251d3e 100644
--- a/src/Container/Container.php
+++ b/src/Container/Container.php
@@ -140,35 +140,37 @@ class Container implements ArrayAccess
     /**
      * Define a contextual binding.
      *
-     * @param array|string $concrete
+     * @param  array|string  $concrete
      *
      * @return ContextualBindingBuilder
      */
-    public function when( $concrete ) {
+    public function when($concrete)
+    {
         $aliases = [];
 
-        if ( ! is_array( $concrete ) ) {
-            $concrete = [ $concrete ];
+        if (! is_array($concrete)) {
+            $concrete = [$concrete];
         }
 
-        foreach ( $concrete as $c ) {
-            $aliases[] = $this->getAlias( $c );
+        foreach ($concrete as $c) {
+            $aliases[] = $this->getAlias($c);
         }
 
-        return new ContextualBindingBuilder( $this, $aliases );
+        return new ContextualBindingBuilder($this, $aliases);
     }
 
     /**
      * Determine if the given abstract type has been bound.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return bool
      */
-    public function bound( $abstract ) {
-        return isset( $this->bindings[ $abstract ] ) ||
-            isset( $this->instances[ $abstract ] ) ||
-            $this->isAlias( $abstract );
+    public function bound($abstract)
+    {
+        return isset($this->bindings[$abstract]) ||
+            isset($this->instances[$abstract]) ||
+            $this->isAlias($abstract);
     }
 
     /**
@@ -178,102 +180,108 @@ public function bound( $abstract ) {
      * `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.
+     * @param  string  $id  Identifier of the entry to look for.
      *
      * @return bool
      */
-    public function has( $id ) {
-        return $this->bound( $id );
+    public function has($id)
+    {
+        return $this->bound($id);
     }
 
     /**
      * Determine if the given abstract type has been resolved.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return bool
      */
-    public function resolved( $abstract ) {
-        if ( $this->isAlias( $abstract ) ) {
-            $abstract = $this->getAlias( $abstract );
+    public function resolved($abstract)
+    {
+        if ($this->isAlias($abstract)) {
+            $abstract = $this->getAlias($abstract);
         }
 
-        return isset( $this->resolved[ $abstract ] ) ||
-            isset( $this->instances[ $abstract ] );
+        return isset($this->resolved[$abstract]) ||
+            isset($this->instances[$abstract]);
     }
 
     /**
      * Determine if a given type is shared.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return bool
      */
-    public function isShared( $abstract ) {
-        return isset( $this->instances[ $abstract ] ) ||
-            ( isset( $this->bindings[ $abstract ]['shared'] ) &&
-                $this->bindings[ $abstract ]['shared'] === true );
+    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
+     * @param  string  $name
      *
      * @return bool
      */
-    public function isAlias( $name ) {
-        return isset( $this->aliases[ $name ] );
+    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
+     * @param  string  $abstract
+     * @param  Closure|string|null  $concrete
+     * @param  bool  $shared
      *
      * @return void
      */
-    public function bind( $abstract, $concrete = null, $shared = false ) {
-        $this->dropStaleInstances( $abstract );
+    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 ) ) {
+        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 );
+        if (! $concrete instanceof Closure) {
+            $concrete = $this->getClosure($abstract, $concrete);
         }
 
-        $this->bindings[ $abstract ] = compact( 'concrete', 'shared' );
+        $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 );
+        if ($this->resolved($abstract)) {
+            $this->rebound($abstract);
         }
     }
 
     /**
      * Get the Closure to be used when building a type.
      *
-     * @param string $abstract
-     * @param string $concrete
+     * @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 );
+    protected function getClosure($abstract, $concrete)
+    {
+        return function ($container, $parameters = []) use ($abstract, $concrete) {
+            if ($abstract == $concrete) {
+                return $container->build($concrete);
             }
 
             return $container->resolve(
@@ -287,36 +295,39 @@ protected function getClosure( $abstract, $concrete ) {
     /**
      * Determine if the container has a method binding.
      *
-     * @param string $method
+     * @param  string  $method
      *
      * @return bool
      */
-    public function hasMethodBinding( $method ) {
-        return isset( $this->methodBindings[ $method ] );
+    public function hasMethodBinding($method)
+    {
+        return isset($this->methodBindings[$method]);
     }
 
     /**
      * Bind a callback to resolve with Container::call.
      *
-     * @param array|string $method
-     * @param Closure      $callback
+     * @param  array|string  $method
+     * @param  Closure  $callback
      *
      * @return void
      */
-    public function bindMethod( $method, $callback ) {
-        $this->methodBindings[ $this->parseBindMethod( $method ) ] = $callback;
+    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
+     * @param  array|string  $method
      *
      * @return string
      */
-    protected function parseBindMethod( $method ) {
-        if ( is_array( $method ) ) {
-            return $method[0] . '@' . $method[1];
+    protected function parseBindMethod($method)
+    {
+        if (is_array($method)) {
+            return $method[0].'@'.$method[1];
         }
 
         return $method;
@@ -325,91 +336,97 @@ protected function parseBindMethod( $method ) {
     /**
      * Get the method binding for the given method.
      *
-     * @param string $method
-     * @param mixed  $instance
+     * @param  string  $method
+     * @param  mixed  $instance
      *
      * @return mixed
      */
-    public function callMethodBinding( $method, $instance ) {
-        return call_user_func( $this->methodBindings[ $method ], $instance, $this );
+    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
+     * @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;
+    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
+     * @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 );
+    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
+     * @param  string  $abstract
+     * @param  Closure|string|null  $concrete
      *
      * @return void
      */
-    public function singleton( $abstract, $concrete = null ) {
-        $this->bind( $abstract, $concrete, true );
+    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
+     * @param  string  $abstract
+     * @param  Closure|string|null  $concrete
      *
      * @return void
      */
-    public function singletonIf( $abstract, $concrete = null ) {
-        if ( ! $this->bound( $abstract ) ) {
-            $this->singleton( $abstract, $concrete );
+    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
+     * @param  string  $abstract
+     * @param  Closure  $closure
      *
      * @return void
      *
      * @throws \InvalidArgumentException
      */
-    public function extend( $abstract, Closure $closure ) {
-        $abstract = $this->getAlias( $abstract );
+    public function extend($abstract, Closure $closure)
+    {
+        $abstract = $this->getAlias($abstract);
 
-        if ( isset( $this->instances[ $abstract ] ) ) {
-            $this->instances[ $abstract ] = $closure( $this->instances[ $abstract ], $this );
+        if (isset($this->instances[$abstract])) {
+            $this->instances[$abstract] = $closure($this->instances[$abstract], $this);
 
-            $this->rebound( $abstract );
+            $this->rebound($abstract);
         } else {
-            $this->extenders[ $abstract ][] = $closure;
+            $this->extenders[$abstract][] = $closure;
 
-            if ( $this->resolved( $abstract ) ) {
-                $this->rebound( $abstract );
+            if ($this->resolved($abstract)) {
+                $this->rebound($abstract);
             }
         }
     }
@@ -417,25 +434,26 @@ public function extend( $abstract, Closure $closure ) {
     /**
      * Register an existing instance as shared in the container.
      *
-     * @param string $abstract
-     * @param mixed  $instance
+     * @param  string  $abstract
+     * @param  mixed  $instance
      *
      * @return mixed
      */
-    public function instance( $abstract, $instance ) {
-        $this->removeAbstractAlias( $abstract );
+    public function instance($abstract, $instance)
+    {
+        $this->removeAbstractAlias($abstract);
 
-        $isBound = $this->bound( $abstract );
+        $isBound = $this->bound($abstract);
 
-        unset( $this->aliases[ $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;
+        $this->instances[$abstract] = $instance;
 
-        if ( $isBound ) {
-            $this->rebound( $abstract );
+        if ($isBound) {
+            $this->rebound($abstract);
         }
 
         return $instance;
@@ -444,19 +462,20 @@ public function instance( $abstract, $instance ) {
     /**
      * Remove an alias from the contextual binding alias cache.
      *
-     * @param string $searched
+     * @param  string  $searched
      *
      * @return void
      */
-    protected function removeAbstractAlias( $searched ) {
-        if ( ! isset( $this->aliases[ $searched ] ) ) {
+    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 ] );
+        foreach ($this->abstractAliases as $abstract => $aliases) {
+            foreach ($aliases as $index => $alias) {
+                if ($alias == $searched) {
+                    unset($this->abstractAliases[$abstract][$index]);
                 }
             }
         }
@@ -465,21 +484,22 @@ protected function removeAbstractAlias( $searched ) {
     /**
      * Assign a set of tags to a given binding.
      *
-     * @param array|string $abstracts
-     * @param array|mixed  ...$tags
+     * @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 );
+    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 ($tags as $tag) {
+            if (! isset($this->tags[$tag])) {
+                $this->tags[$tag] = [];
             }
 
-            foreach ( (array) $abstracts as $abstract ) {
-                $this->tags[ $tag ][] = $abstract;
+            foreach ((array) $abstracts as $abstract) {
+                $this->tags[$tag][] = $abstract;
             }
         }
     }
@@ -487,36 +507,38 @@ public function tag( $abstracts, $tags ) {
     /**
      * Alias a type to a different name.
      *
-     * @param string $abstract
-     * @param string $alias
+     * @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." );
+    public function alias($abstract, $alias)
+    {
+        if ($alias === $abstract) {
+            throw new LogicException("[{$abstract}] is aliased to itself.");
         }
 
-        $this->aliases[ $alias ] = $abstract;
+        $this->aliases[$alias] = $abstract;
 
-        $this->abstractAliases[ $abstract ][] = $alias;
+        $this->abstractAliases[$abstract][] = $alias;
     }
 
     /**
      * Bind a new callback to an abstract's rebind event.
      *
-     * @param string  $abstract
-     * @param Closure $callback
+     * @param  string  $abstract
+     * @param  Closure  $callback
      *
      * @return mixed
      */
-    public function rebinding( $abstract, Closure $callback ) {
-        $this->reboundCallbacks[ $abstract = $this->getAlias( $abstract ) ][] = $callback;
+    public function rebinding($abstract, Closure $callback)
+    {
+        $this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback;
 
-        if ( $this->bound( $abstract ) ) {
-            return $this->make( $abstract );
+        if ($this->bound($abstract)) {
+            return $this->make($abstract);
         }
 
         return null;
@@ -525,17 +547,18 @@ public function rebinding( $abstract, Closure $callback ) {
     /**
      * Refresh an instance on the given target and method.
      *
-     * @param string $abstract
-     * @param mixed  $target
-     * @param string $method
+     * @param  string  $abstract
+     * @param  mixed  $target
+     * @param  string  $method
      *
      * @return mixed
      */
-    public function refresh( $abstract, $target, $method ) {
+    public function refresh($abstract, $target, $method)
+    {
         return $this->rebinding(
             $abstract,
-            function ( $app, $instance ) use ( $target, $method ) {
-                $target->{$method}( $instance );
+            function ($app, $instance) use ($target, $method) {
+                $target->{$method}($instance);
             }
         );
     }
@@ -543,137 +566,143 @@ function ( $app, $instance ) use ( $target, $method ) {
     /**
      * Fire the "rebound" callbacks for the given abstract type.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return void
      */
-    protected function rebound( $abstract ) {
-        $instance = $this->make( $abstract );
+    protected function rebound($abstract)
+    {
+        $instance = $this->make($abstract);
 
-        foreach ( $this->getReboundCallbacks( $abstract ) as $callback ) {
-            $callback( $this, $instance );
+        foreach ($this->getReboundCallbacks($abstract) as $callback) {
+            $callback($this, $instance);
         }
     }
 
     /**
      * Get the rebound callbacks for a given type.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return array
      */
-    protected function getReboundCallbacks( $abstract ) {
-        return isset( $this->reboundCallbacks[ $abstract ] ) ? $this->reboundCallbacks[ $abstract ] : [];
+    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
+     * @param  string  $abstract
      *
      * @return Closure
      */
-    public function factory( $abstract ) {
-        return function () use ( $abstract ) {
-            return $this->make( $abstract );
+    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
+     * @param  string  $abstract
+     * @param  array  $parameters
      *
      * @return mixed
      */
-    public function make( $abstract, array $parameters = [] ) {
-        return $this->resolve( $abstract, $parameters );
+    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.
+     * @param  string  $id  Identifier of the entry to look for.
      *
      * @return mixed Entry.
      * @throws Exception
      */
-    public function get( $id ) {
+    public function get($id)
+    {
         try {
-            return $this->resolve( $id );
-        } catch ( Exception $e ) {
-            if ( $this->has( $id ) ) {
+            return $this->resolve($id);
+        } catch (Exception $e) {
+            if ($this->has($id)) {
                 throw $e;
             }
 
-            throw new InvalidArgumentException( $id, $e->getCode(), $e );
+            throw new InvalidArgumentException($id, $e->getCode(), $e);
         }
     }
 
     /**
      * Resolve the given type from the container.
      *
-     * @param string $abstract
-     * @param array  $parameters
-     * @param bool   $raiseEvents
+     * @param  string  $abstract
+     * @param  array  $parameters
+     * @param  bool  $raiseEvents
      *
      * @return mixed
      * @throws BindingResolutionException
      */
-    protected function resolve( $abstract, $parameters = [], $raiseEvents = true ) {
-        $abstract = $this->getAlias( $abstract );
+    protected function resolve($abstract, $parameters = [], $raiseEvents = true)
+    {
+        $abstract = $this->getAlias($abstract);
 
-        $concrete = $this->getContextualConcrete( $abstract );
+        $concrete = $this->getContextualConcrete($abstract);
 
-        $needsContextualBuild = ! empty( $parameters ) || ! is_null( $concrete );
+        $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 ];
+        if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
+            return $this->instances[$abstract];
         }
 
         $this->with[] = $parameters;
 
-        if ( is_null( $concrete ) ) {
-            $concrete = $this->getConcrete( $abstract );
+        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 );
+        if ($this->isBuildable($concrete, $abstract)) {
+            $object = $this->build($concrete);
         } else {
-            $object = $this->make( $concrete );
+            $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 );
+        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 ($this->isShared($abstract) && ! $needsContextualBuild) {
+            $this->instances[$abstract] = $object;
         }
 
-        if ( $raiseEvents ) {
-            $this->fireResolvingCallbacks( $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;
+        $this->resolved[$abstract] = true;
 
-        array_pop( $this->with );
+        array_pop($this->with);
 
         return $object;
     }
@@ -681,16 +710,17 @@ protected function resolve( $abstract, $parameters = [], $raiseEvents = true ) {
     /**
      * Get the concrete type for a given abstract.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return mixed
      */
-    protected function getConcrete( $abstract ) {
+    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'];
+        if (isset($this->bindings[$abstract])) {
+            return $this->bindings[$abstract]['concrete'];
         }
 
         return $abstract;
@@ -699,24 +729,25 @@ protected function getConcrete( $abstract ) {
     /**
      * Get the contextual concrete binding for the given abstract.
      *
-     * @param string|callable $abstract
+     * @param  string|callable  $abstract
      *
      * @return \Closure|string|array|null
      */
-    protected function getContextualConcrete( $abstract ) {
-        if ( ! is_null( $binding = $this->findInContextualBindings( $abstract ) ) ) {
+    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 ] ) ) {
+        if (empty($this->abstractAliases[$abstract])) {
             return;
         }
 
-        foreach ( $this->abstractAliases[ $abstract ] as $alias ) {
-            if ( ! is_null( $binding = $this->findInContextualBindings( $alias ) ) ) {
+        foreach ($this->abstractAliases[$abstract] as $alias) {
+            if (! is_null($binding = $this->findInContextualBindings($alias))) {
                 return $binding;
             }
         }
@@ -725,55 +756,58 @@ protected function getContextualConcrete( $abstract ) {
     /**
      * Find the concrete binding for the given abstract in the contextual binding array.
      *
-     * @param string|callable $abstract
+     * @param  string|callable  $abstract
      *
      * @return \Closure|string|null
      */
-    protected function findInContextualBindings( $abstract ) {
-        return $this->contextual[ end( $this->buildStack ) ][ $abstract ] ?? 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
+     * @param  mixed  $concrete
+     * @param  string  $abstract
      *
      * @return bool
      */
-    protected function isBuildable( $concrete, $abstract ) {
+    protected function isBuildable($concrete, $abstract)
+    {
         return $concrete === $abstract || $concrete instanceof Closure;
     }
 
     /**
      * Instantiate a concrete instance of the given type.
      *
-     * @param Closure|string $concrete
+     * @param  Closure|string  $concrete
      *
      * @return mixed
      * @throws BindingResolutionException
      * @throws ReflectionException
      */
-    public function build( $concrete ) {
+    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() );
+        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 );
+            $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 );
+        if (! $reflector->isInstantiable()) {
+            $this->notInstantiable($concrete);
         }
 
         $this->buildStack[] = $concrete;
@@ -783,8 +817,8 @@ public function build( $concrete ) {
         // 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 );
+        if (is_null($constructor)) {
+            array_pop($this->buildStack);
 
             return new $concrete;
         }
@@ -795,36 +829,37 @@ public function build( $concrete ) {
         // 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 );
+            $instances = $this->resolveDependencies($dependencies);
+        } catch (BindingResolutionException $e) {
+            array_pop($this->buildStack);
 
             throw $e;
         }
 
-        array_pop( $this->buildStack );
+        array_pop($this->buildStack);
 
-        return $reflector->newInstanceArgs( $instances );
+        return $reflector->newInstanceArgs($instances);
     }
 
     /**
      * Resolve all of the dependencies from the ReflectionParameters.
      *
-     * @param array $dependencies
+     * @param  array  $dependencies
      *
      * @return array
      * @throws BindingResolutionException
      * @throws ReflectionException
      */
-    protected function resolveDependencies( array $dependencies ) {
+    protected function resolveDependencies(array $dependencies)
+    {
         $results = [];
 
-        foreach ( $dependencies as $dependency ) {
+        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 );
+            if ($this->hasParameterOverride($dependency)) {
+                $results[] = $this->getParameterOverride($dependency);
 
                 continue;
             }
@@ -832,12 +867,12 @@ protected function resolveDependencies( array $dependencies ) {
             // 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 );
+            $result = is_null(Util::getParameterClassName($dependency))
+                ? $this->resolvePrimitive($dependency)
+                : $this->resolveClass($dependency);
 
-            if ( $dependency->isVariadic() ) {
-                $results = array_merge( $results, $result );
+            if ($dependency->isVariadic()) {
+                $results = array_merge($results, $result);
             } else {
                 $results[] = $result;
             }
@@ -849,11 +884,12 @@ protected function resolveDependencies( array $dependencies ) {
     /**
      * Determine if the given dependency has a parameter override.
      *
-     * @param ReflectionParameter $dependency
+     * @param  ReflectionParameter  $dependency
      *
      * @return bool
      */
-    protected function hasParameterOverride( $dependency ) {
+    protected function hasParameterOverride($dependency)
+    {
         return array_key_exists(
             $dependency->name,
             $this->getLastParameterOverride()
@@ -863,12 +899,13 @@ protected function hasParameterOverride( $dependency ) {
     /**
      * Get a parameter override for a dependency.
      *
-     * @param ReflectionParameter $dependency
+     * @param  ReflectionParameter  $dependency
      *
      * @return mixed
      */
-    protected function getParameterOverride( $dependency ) {
-        return $this->getLastParameterOverride()[ $dependency->name ];
+    protected function getParameterOverride($dependency)
+    {
+        return $this->getLastParameterOverride()[$dependency->name];
     }
 
     /**
@@ -876,24 +913,26 @@ protected function getParameterOverride( $dependency ) {
      *
      * @return array
      */
-    protected function getLastParameterOverride() {
-        return count( $this->with ) ? end( $this->with ) : [];
+    protected function getLastParameterOverride()
+    {
+        return count($this->with) ? end($this->with) : [];
     }
 
     /**
      * Resolve a non-class hinted primitive dependency.
      *
-     * @param ReflectionParameter $parameter
+     * @param  ReflectionParameter  $parameter
      *
      * @return mixed
      * @throws ReflectionException
      */
-    protected function resolvePrimitive( ReflectionParameter $parameter ) {
-        if ( $parameter->isDefaultValueAvailable() ) {
+    protected function resolvePrimitive(ReflectionParameter $parameter)
+    {
+        if ($parameter->isDefaultValueAvailable()) {
             return $parameter->getDefaultValue();
         }
 
-        $this->unresolvablePrimitive( $parameter );
+        $this->unresolvablePrimitive($parameter);
 
         return null;
     }
@@ -901,28 +940,29 @@ protected function resolvePrimitive( ReflectionParameter $parameter ) {
     /**
      * Resolve a class based dependency from the container.
      *
-     * @param ReflectionParameter $parameter
+     * @param  ReflectionParameter  $parameter
      *
      * @return mixed
      * @throws BindingResolutionException
      * @throws ReflectionException
      */
-    protected function resolveClass( ReflectionParameter $parameter ) {
+    protected function resolveClass(ReflectionParameter $parameter)
+    {
         try {
             return $parameter->isVariadic()
-                ? $this->resolveVariadicClass( $parameter )
-                : $this->make( Util::getParameterClassName( $parameter ) );
+                ? $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() ) {
+        catch (BindingResolutionException $e) {
+            if ($parameter->isDefaultValueAvailable()) {
                 return $parameter->getDefaultValue();
             }
 
-            if ( $parameter->isVariadic() ) {
+            if ($parameter->isVariadic()) {
                 return [];
             }
 
@@ -933,150 +973,158 @@ protected function resolveClass( ReflectionParameter $parameter ) {
     /**
      * Resolve a class based variadic dependency from the container.
      *
-     * @param \ReflectionParameter $parameter
+     * @param  \ReflectionParameter  $parameter
      *
      * @return mixed
      * @throws BindingResolutionException
      */
-    protected function resolveVariadicClass( ReflectionParameter $parameter ) {
-        $className = Util::getParameterClassName( $parameter );
+    protected function resolveVariadicClass(ReflectionParameter $parameter)
+    {
+        $className = Util::getParameterClassName($parameter);
 
-        $abstract = $this->getAlias( $className );
+        $abstract = $this->getAlias($className);
 
-        if ( ! is_array( $concrete = $this->getContextualConcrete( $abstract ) ) ) {
-            return $this->make( $className );
+        if (! is_array($concrete = $this->getContextualConcrete($abstract))) {
+            return $this->make($className);
         }
 
-        return array_map( function ( $abstract ) {
-            return $this->resolve( $abstract );
-        }, $concrete );
+        return array_map(function ($abstract) {
+            return $this->resolve($abstract);
+        }, $concrete);
     }
 
     /**
      * Throw an exception that the concrete is not instantiable.
      *
-     * @param string $concrete
+     * @param  string  $concrete
      *
      * @return void
      * @throws BindingResolutionException
      */
-    protected function notInstantiable( $concrete ) {
-        if ( ! empty( $this->buildStack ) ) {
-            $previous = implode( ', ', $this->buildStack );
+    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 new BindingResolutionException($message);
     }
 
     /**
      * Throw an exception for an unresolvable primitive.
      *
-     * @param ReflectionParameter $parameter
+     * @param  ReflectionParameter  $parameter
      *
      * @return void
      * @throws BindingResolutionException
      */
-    protected function unresolvablePrimitive( ReflectionParameter $parameter ) {
+    protected function unresolvablePrimitive(ReflectionParameter $parameter)
+    {
         $message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}";
 
-        throw new BindingResolutionException( $message );
+        throw new BindingResolutionException($message);
     }
 
     /**
      * Register a new resolving callback.
      *
-     * @param Closure|string $abstract
-     * @param Closure|null   $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 );
+    public function resolving($abstract, Closure $callback = null)
+    {
+        if (is_string($abstract)) {
+            $abstract = $this->getAlias($abstract);
         }
 
-        if ( is_null( $callback ) && $abstract instanceof Closure ) {
+        if (is_null($callback) && $abstract instanceof Closure) {
             $this->globalResolvingCallbacks[] = $abstract;
         } else {
-            $this->resolvingCallbacks[ $abstract ][] = $callback;
+            $this->resolvingCallbacks[$abstract][] = $callback;
         }
     }
 
     /**
      * Register a new after resolving callback for all types.
      *
-     * @param Closure|string $abstract
-     * @param Closure|null   $callback
+     * @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 );
+    public function afterResolving($abstract, Closure $callback = null)
+    {
+        if (is_string($abstract)) {
+            $abstract = $this->getAlias($abstract);
         }
 
-        if ( $abstract instanceof Closure && is_null( $callback ) ) {
+        if ($abstract instanceof Closure && is_null($callback)) {
             $this->globalAfterResolvingCallbacks[] = $abstract;
         } else {
-            $this->afterResolvingCallbacks[ $abstract ][] = $callback;
+            $this->afterResolvingCallbacks[$abstract][] = $callback;
         }
     }
 
     /**
      * Fire all of the resolving callbacks.
      *
-     * @param string $abstract
-     * @param mixed  $object
+     * @param  string  $abstract
+     * @param  mixed  $object
      *
      * @return void
      */
-    protected function fireResolvingCallbacks( $abstract, $object ) {
-        $this->fireCallbackArray( $object, $this->globalResolvingCallbacks );
+    protected function fireResolvingCallbacks($abstract, $object)
+    {
+        $this->fireCallbackArray($object, $this->globalResolvingCallbacks);
 
         $this->fireCallbackArray(
             $object,
-            $this->getCallbacksForType( $abstract, $object, $this->resolvingCallbacks )
+            $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks)
         );
 
-        $this->fireAfterResolvingCallbacks( $abstract, $object );
+        $this->fireAfterResolvingCallbacks($abstract, $object);
     }
 
     /**
      * Fire all of the after resolving callbacks.
      *
-     * @param string $abstract
-     * @param mixed  $object
+     * @param  string  $abstract
+     * @param  mixed  $object
      *
      * @return void
      */
-    protected function fireAfterResolvingCallbacks( $abstract, $object ) {
-        $this->fireCallbackArray( $object, $this->globalAfterResolvingCallbacks );
+    protected function fireAfterResolvingCallbacks($abstract, $object)
+    {
+        $this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
 
         $this->fireCallbackArray(
             $object,
-            $this->getCallbacksForType( $abstract, $object, $this->afterResolvingCallbacks )
+            $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks)
         );
     }
 
     /**
      * Get all callbacks for a given type.
      *
-     * @param string $abstract
-     * @param object $object
-     * @param array  $callbacksPerType
+     * @param  string  $abstract
+     * @param  object  $object
+     * @param  array  $callbacksPerType
      *
      * @return array
      */
-    protected function getCallbacksForType( $abstract, $object, array $callbacksPerType ) {
+    protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
+    {
         $results = [];
 
-        foreach ( $callbacksPerType as $type => $callbacks ) {
-            if ( $type === $abstract || $object instanceof $type ) {
-                array_push( $results, ...$callbacks );
+        foreach ($callbacksPerType as $type => $callbacks) {
+            if ($type === $abstract || $object instanceof $type) {
+                array_push($results, ...$callbacks);
             }
         }
 
@@ -1086,14 +1134,15 @@ protected function getCallbacksForType( $abstract, $object, array $callbacksPerT
     /**
      * Fire an array of callbacks with an object.
      *
-     * @param mixed $object
-     * @param array $callbacks
+     * @param  mixed  $object
+     * @param  array  $callbacks
      *
      * @return void
      */
-    protected function fireCallbackArray( $object, array $callbacks ) {
-        foreach ( $callbacks as $callback ) {
-            $callback( $object, $this );
+    protected function fireCallbackArray($object, array $callbacks)
+    {
+        foreach ($callbacks as $callback) {
+            $callback($object, $this);
         }
     }
 
@@ -1102,69 +1151,75 @@ protected function fireCallbackArray( $object, array $callbacks ) {
      *
      * @return array
      */
-    public function getBindings() {
+    public function getBindings()
+    {
         return $this->bindings;
     }
 
     /**
      * Get the alias for an abstract if available.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return string
      */
-    public function getAlias( $abstract ) {
-        if ( ! isset( $this->aliases[ $abstract ] ) ) {
+    public function getAlias($abstract)
+    {
+        if (! isset($this->aliases[$abstract])) {
             return $abstract;
         }
 
-        return $this->getAlias( $this->aliases[ $abstract ] );
+        return $this->getAlias($this->aliases[$abstract]);
     }
 
     /**
      * Get the extender callbacks for a given type.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return array
      */
-    protected function getExtenders( $abstract ) {
-        $abstract = $this->getAlias( $abstract );
+    protected function getExtenders($abstract)
+    {
+        $abstract = $this->getAlias($abstract);
 
-        return isset( $this->extenders[ $abstract ] ) ? $this->extenders[ $abstract ] : [];
+        return isset($this->extenders[$abstract]) ? $this->extenders[$abstract] : [];
     }
 
     /**
      * Remove all of the extender callbacks for a given type.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return void
      */
-    public function forgetExtenders( $abstract ) {
-        unset( $this->extenders[ $this->getAlias( $abstract ) ] );
+    public function forgetExtenders($abstract)
+    {
+        unset($this->extenders[$this->getAlias($abstract)]);
     }
 
     /**
      * Drop all of the stale instances and aliases.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return void
      */
-    protected function dropStaleInstances( $abstract ) {
-        unset( $this->instances[ $abstract ], $this->aliases[ $abstract ] );
+    protected function dropStaleInstances($abstract)
+    {
+        unset($this->instances[$abstract], $this->aliases[$abstract]);
     }
 
     /**
      * Remove a resolved instance from the instance cache.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return void
      */
-    public function forgetInstance( $abstract ) {
-        unset( $this->instances[ $abstract ] );
+    public function forgetInstance($abstract)
+    {
+        unset($this->instances[$abstract]);
     }
 
     /**
@@ -1172,7 +1227,8 @@ public function forgetInstance( $abstract ) {
      *
      * @return void
      */
-    public function forgetInstances() {
+    public function forgetInstances()
+    {
         $this->instances = [];
     }
 
@@ -1181,7 +1237,8 @@ public function forgetInstances() {
      *
      * @return void
      */
-    public function flush() {
+    public function flush()
+    {
         $this->aliases         = [];
         $this->resolved        = [];
         $this->bindings        = [];
@@ -1192,37 +1249,40 @@ public function flush() {
     /**
      * Determine if a given offset exists.
      *
-     * @param string $key
+     * @param  string  $key
      *
      * @return bool
      */
-    public function offsetExists( $key ) {
-        return $this->bound( $key );
+    public function offsetExists($key)
+    {
+        return $this->bound($key);
     }
 
     /**
      * Get the value at a given offset.
      *
-     * @param string $key
+     * @param  string  $key
      *
      * @return mixed
      */
-    public function offsetGet( $key ) {
-        return $this->make( $key );
+    public function offsetGet($key)
+    {
+        return $this->make($key);
     }
 
     /**
      * Set the value at a given offset.
      *
-     * @param string $key
-     * @param mixed  $value
+     * @param  string  $key
+     * @param  mixed  $value
      *
      * @return void
      */
-    public function offsetSet( $key, $value ) {
+    public function offsetSet($key, $value)
+    {
         $this->bind(
             $key,
-            $value instanceof Closure ? $value : function () use ( $value ) {
+            $value instanceof Closure ? $value : function () use ($value) {
                 return $value;
             }
         );
@@ -1231,35 +1291,38 @@ public function offsetSet( $key, $value ) {
     /**
      * Unset the value at a given offset.
      *
-     * @param string $key
+     * @param  string  $key
      *
      * @return void
      */
-    public function offsetUnset( $key ) {
-        unset( $this->bindings[ $key ], $this->instances[ $key ], $this->resolved[ $key ] );
+    public function offsetUnset($key)
+    {
+        unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
     }
 
     /**
      * Dynamically access container services.
      *
-     * @param string $key
+     * @param  string  $key
      *
      * @return mixed
      */
-    public function __get( $key ) {
-        return $this[ $key ];
+    public function __get($key)
+    {
+        return $this[$key];
     }
 
     /**
      * Dynamically set container services.
      *
-     * @param string $key
-     * @param mixed  $value
+     * @param  string  $key
+     * @param  mixed  $value
      *
      * @return void
      */
-    public function __set( $key, $value ) {
-        $this[ $key ] = $value;
+    public function __set($key, $value)
+    {
+        $this[$key] = $value;
     }
 
     /**
@@ -1269,8 +1332,9 @@ public function __set( $key, $value ) {
      *
      * @return bool
      */
-    public function __isset( $key ) {
-        return isset( $this[ $key ] );
+    public function __isset($key)
+    {
+        return isset($this[$key]);
     }
 
 }
diff --git a/src/Container/ContextualBindingBuilder.php b/src/Container/ContextualBindingBuilder.php
index 8675b95..857484f 100644
--- a/src/Container/ContextualBindingBuilder.php
+++ b/src/Container/ContextualBindingBuilder.php
@@ -40,22 +40,24 @@ class ContextualBindingBuilder
     /**
      * ContextualBindingBuilder constructor.
      *
-     * @param Container    $container
-     * @param array|string $concrete
+     * @param  Container  $container
+     * @param  array|string  $concrete
      */
-    public function __construct( Container $container, $concrete ) {
+    public function __construct(Container $container, $concrete)
+    {
         $this->container = $container;
-        $this->concrete  = is_array( $concrete ) ? $concrete : [ $concrete ];
+        $this->concrete  = is_array($concrete) ? $concrete : [$concrete];
     }
 
     /**
      * Define the abstract target that depends on the context.
      *
-     * @param string $abstract
+     * @param  string  $abstract
      *
      * @return $this
      */
-    public function needs( $abstract ) {
+    public function needs($abstract)
+    {
         $this->needs = $abstract;
 
         return $this;
@@ -64,13 +66,14 @@ public function needs( $abstract ) {
     /**
      * Define the implementation for the contextual binding.
      *
-     * @param \Closure|string|array $implementation
+     * @param  \Closure|string|array  $implementation
      *
      * @return void
      */
-    public function give( $implementation ) {
-        foreach ( $this->concrete as $concrete ) {
-            $this->container->addContextualBinding( $concrete, $this->needs, $implementation );
+    public function give($implementation)
+    {
+        foreach ($this->concrete as $concrete) {
+            $this->container->addContextualBinding($concrete, $this->needs, $implementation);
         }
     }
 
diff --git a/src/Container/Util.php b/src/Container/Util.php
index 02b2042..ee9aeb7 100644
--- a/src/Container/Util.php
+++ b/src/Container/Util.php
@@ -17,25 +17,26 @@ class Util
     /**
      * Get the class name of the given parameter's type, if possible.
      *
-     * @param \ReflectionParameter $parameter
+     * @param  \ReflectionParameter  $parameter
      *
      * @return string|null
      */
-    public static function getParameterClassName( $parameter ) {
+    public static function getParameterClassName($parameter)
+    {
         $type = $parameter->getType();
 
-        if ( ! $type instanceof ReflectionNamedType || $type->isBuiltin() ) {
+        if (! $type instanceof ReflectionNamedType || $type->isBuiltin()) {
             return;
         }
 
         $name = $type->getName();
 
-        if ( ! is_null( $class = $parameter->getDeclaringClass() ) ) {
-            if ( $name === 'self' ) {
+        if (! is_null($class = $parameter->getDeclaringClass())) {
+            if ($name === 'self') {
                 return $class->getName();
             }
 
-            if ( $name === 'parent' && $parent = $class->getParentClass() ) {
+            if ($name === 'parent' && $parent = $class->getParentClass()) {
                 return $parent->getName();
             }
         }