Question

Would this be considered dependency injection?

<?php
class BASE_Model extends CI_Model 
{  
    /**
     * inject_class - load class using dependency injection
     *
     * @access public
     * @param  string $path
     * @param  string $class
     * @param  string $func
     * @param  string $method
     **/
    public function inject_class($path, $class, $func, $method)
    {
        // load_class is a function located in system/core/common.php on line 123
        $obj = load_class($class, $path, NULL);
        return $obj->$func();
    }
}

// lets say this is instantiated by a user controller when a new user is made
class User_model extends BASE_Model
{
    public function create()
    {
        echo 'create a new user';
        $request = $this->inject_class('path/to/models', 'Logger_model', 'log');
        echo $request;
    }
}

class Logger_model extends BASE_Model
{
    public function log()
    {
        return 'Logged';
    }
}

Answer 1

No. That’s just another way of how the object loads dependencies itself. The point of dependency injection is that every method/object/function takes its dependencies as arguments and does not load them itself in any way. User_model::create is injecting loading another class by itself, which is not accepting the dependency as an argument.

The point of dependency injection is to reduce coupling. The User_model is now coupled to the Logger_model class, since it hardcodes the name and path to that specific class inside itself. If you wanted to use or test the User_model by itself in isolation, without it logging stuff you don’t want, you cannot do so anymore. Real DI would be this:

public function create(Logger_model $log) {
    // here be dragons
    $log->log();
}

This way you can inject a mocked dummy logging class when you want to test the method without breaking anything or use alternative types of loggers when needed without needing to change any code.