Modular Extensions - Version 4.3

[eluser]Avatar[/eluser]

Code:

class Module
{        
    var $_modules;
    
    function Module()
    {
        static $mods = array();
        $this->_modules =& $mods;
        
        $ci =& get_instance();
        
        $this->load =& new Loader($this);
        $this->load->_assign_libraries($this, $ci);
        $this->load->_ci_assign_to_models();
        
        log_message('debug', ucfirst(get_class($this))." module initialised");
    }
    
    function index()
    {
        log_message('error', ucfirst(get_class($this))." module: No index() method defined");
    }
    
    function _error($method)
    {
        log_message('error', ucfirst(get_class($this))." module: No ".$method."() method defined");
    }
}

class Loader extends CI_Loader
{    
    function Loader(&$module)
    {
        parent::CI_Loader();
        
        $this->module  =& $this;    /* reserved for future use */
        $this->_module =& $module;
        $this->_path   = get_class($module);
    }

    function _assign_libraries(&$_object, &$_parent)
    {
        $_this = ucfirst(get_class($_object));
        
        $obj_vars = array_keys(get_object_vars($_parent));
        foreach ($obj_vars as $key)
        {
            if (!isset($_object->$key) AND $key != $_this)
            {
                $_object->$key =& $_parent->$key;
            }
        }
    }
    
    function _assign_to_models()
    {
        if (count($this->_ci_models) == 0)
        {
            return;
        }
    
        foreach ($this->_ci_models as $model)
        {            
            $this->_module->$model->_assign_libraries($this->_module->$model, $this->_module);
        }
    }
    
    function module()
    {
        /* reserved for future use */
    }
    
    function config($file = '', $use_sections = FALSE)
    {            
        list($path, $file) = modules::path_to($file, $this->_path, 'config/');
        
        $file = ($file == '') ? 'config' : $file;
        
        if (in_array($file, $this->_module->config->is_loaded, TRUE))
        {
            return;
        }

        if ($config = modules::_load_config($file, $path))
        {            
            if ($use_sections == TRUE)
            {
                if (isset($this->_module->config->config[$file]))
                {
                    $this->_module->config->config[$file] = array_merge($this->_module->config->config[$file], $config);
                }
                else
                    $this->_module->config->config[$file] = $config;
            }
            else
                $this->_module->config->config = array_merge($this->_module->config->config, $config);
            
            $this->_module->config->is_loaded[] = $file;
        }
    }
    
    function helper($helper)
    {
        if (is_file(BASEPATH.'helpers/'.$helper.EXT))
        {
            echo '<br />BLAH:'.BASEPATH.'helpers/'.$helper.EXT.'<br />';
            load_class($helper, FALSE);
        }
        list($path, $helper) = modules::path_to($helper, $this->_path, 'helpers/','_helper');
        
        if (isset($this->_ci_helpers[$helper]))
        {
            return;
        }
        
        if(modules::_load_file($helper, $path))
        {
            $this->_ci_helpers[$helper] = TRUE;
        }                
    }

    function helpers($helpers = array())
    {
        if (!is_array($helpers))
        {
            $helpers = array($helpers);
        }
            
        foreach ($helpers as $helper)
        {
            $this->helper($helper);
        }
    }
    
    function library($library, $params = NULL)
    {
        if ($library == 'database') return parent::database();
        
        if (is_file(BASEPATH.'libraries/'.$library.EXT))
        {
            load_class($library, FALSE);
        }

        list($path, $library) = modules::path_to($library, $this->_path, 'libraries/');
        
        if (isset($this->_module->$library))
        {
           return;
         }
        
        
        
        if(modules::_load_file($library, $path))
        {        
            $_library = strtolower($library);
            if ($path != FALSE) $library = 'CI_'.$library;        
            $this->_module->$_library =& new $library($params);
            $this->_assign_to_models();
        }
    }
    
    function model($model, $alias = FALSE, $connect = TRUE)
    {
        list($path, $model) = modules::path_to($model, $this->_path, 'models/');
        
        $_alias = ($alias == FALSE) ? strtolower($model) : strtolower($alias);
        
        if (isset($this->_module->$_alias))
        {
            return;
        }
        
        if(!class_exists('Model'))
        {
            load_class('Model', FALSE);
        }
        
        if(modules::_load_file($model, $path))
        {
            if ($connect) parent::database();
            
            $this->_module->$_alias =& new $model();
            
            $this->_assign_libraries($this->_module->$_alias, $this->_module);
        }
    }
    
    function plugin($plugin)
    {
        list($path, $plugin) = modules::path_to($plugin, $this->_path, 'plugins/','_pi');
        
        if (isset($this->_ci_plugins[$plugin]))
        {
            return;
        }
        
        if(modules::_load_file($plugin, $path))
        {
            $this->_ci_plugins[$plugin] = TRUE;
        }
    }

    function plugins($plugins = array())
    {
        if (!is_array($plugins))
        {
            $plugins = array($plugins);
        }
            
        foreach ($plugins as $plugin)
        {
            $this->plugin($plugin);
        }
    }

    function view($view, $data = array(), $return = TRUE)
    {
        list($path, $view) = modules::path_to($view, $this->_path, 'views/');
        
        $this->_ci_view_path = $path;
        return parent::view($view, $data, $return);
      }
}