예제 #1
0
 /**
  * Add a path to the path pool
  * 
  * Use Identifier to override the built in identity engine
  * Otherwise to get the identifier you'll have to pass the path
  * back into the class.
  * 
  * @param string $path The actual path to add
  * @param string|int The desired path identifier
  * 
  */
 public function addPath($path, $identifier = '')
 {
     if ($path instanceof File\Path) {
         if (!$identifier) {
             $identifier = $path->getIdentifier();
         }
         if (!array_key_exists($identifier, $this->paths->getList())) {
             $this->paths[$identifier] = $path;
         }
         if ($this->conf->fileextension != 'php') {
             $this->paths[$identifier]->removeExtension('php');
             $this->paths[$identifier]->addExtension($this->conf->fileextension);
         }
         return $identifier;
     } else {
         if (!in_array($path, $this->getPaths())) {
             $addition = new File\Path($path, $identifier);
             $identifier = $addition->getIdentifier();
             $this->paths[$identifier] = $addition;
             return $identifier;
         } else {
             return $this->getIdentifier($path);
         }
     }
     return false;
 }
예제 #2
0
 /**
  * Autoload a Class
  * 
  * This is the meat of the whole operation.  Everything up until now
  * (AbstractLoader, GenericInterface, Module, Path, etc.) has been
  * constructed for this function to occur.
  * 
  * This function first establishes a base path either from a predefined
  * constant (presumably from the bootstrap), the default path set in the
  * autoloader (this is obviously overwritten by the constant), or, in the
  * case that these are not specified, two folders up ( /library/ ).
  * 
  * Then it parses the class string with the appropriate delimiters.
  * 
  * It moves on to parse through the modules, constructing a path,
  * by concatenating relative paths and replacing with absolute paths.
  * 
  * If path remnants are left over, it constructs a NEW path (losing
  * extensions but not prefixes).  This is important, if you want
  * extensions the path object must be in the terminating module.
  * 
  * It then checks file existence with prefixes, and then it processes
  * through independent paths (like an include path string)
  * 
  * NOTE: This function uses require_once
  * 
  * @param string $class The fully qualified class name to load
  * 
  */
 public function autoload($class)
 {
     $realBasePath = '';
     if (defined('FALCRAFT_APPLICATION_PATH')) {
         $realBasePath = FALCRAFT_APPLICATION_PATH;
     } else {
         if ($this->default) {
             // default from abstract
             $realBasePath = $this->getPath($this->default);
         } else {
             $realBasePath = realpath(__DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR);
         }
     }
     // http://stackoverflow.com/questions/2860238/exploding-by-array-of-delimiters
     $udelim = $this->delimiters[0];
     $step = str_replace($this->delimiters, $udelim, $class);
     $keys = explode($udelim, $step);
     $classToLoad = array_pop($keys);
     if (!$keys) {
         // This is a built in non namespaced class (or should be)
         return;
     }
     $prefixes = array();
     $basePath = $realBasePath;
     if ($this->default) {
         $path = $this->getPathObject($this->default);
     } else {
         $path = new File\Path($this->libraries->getPath());
     }
     if ($this->isLibrary($keys[0])) {
         $module = $this->getLibrary($keys[0]);
         while ($keys) {
             if ($this->isIdentifier($module->getPath())) {
                 $path = $this->getPathObject($module->getPath());
                 if (!$path->isRelative()) {
                     $basePath = $path->getPath() . DIRECTORY_SEPARATOR;
                 } else {
                     $basePath .= DIRECTORY_SEPARATOR . $path->getPath() . DIRECTORY_SEPARATOR;
                 }
                 if ($this->hasPrefix($module->getPath())) {
                     $prefixes = $this->prefixes[$module->getPath()];
                 }
             }
             array_shift($keys);
             if ($keys) {
                 if ($module->isModule($keys[0])) {
                     $module = $module->getModule($keys[0]);
                 } else {
                     break;
                 }
             }
         }
     }
     if (count($keys)) {
         $path = implode(DIRECTORY_SEPARATOR, $keys);
         $path = new File\Path($path);
     }
     $unprefixedClassToLoad = '';
     if ($prefixes) {
         foreach ($prefixes as $prefix) {
             if (strpos($classToLoad, $prefix) === 0) {
                 $unprefixedClassToLoad = substr($classToLoad, strlen($prefix));
                 /* ?? - $unprefixedClassToLoad =
                    substr( $classToLoad, count( $prefix ) ); */
             }
         }
     }
     if ($unprefixedClassToLoad && ($retPath = $path->isFilename($unprefixedClassToLoad, '', $basePath))) {
         require_once $retPath;
         return;
     } else {
         if ($retPath = $path->isFilename($classToLoad, '', $basePath)) {
             require_once $retPath;
             return;
         }
     }
     foreach ($this->getIndependentPathObjects() as $ipath) {
         $base = $realBasePath;
         if (!$ipath->isRelative()) {
             $base = '';
         }
         $relativeClassToLoad = $path->getPath() . DIRECTORY_SEPARATOR . $classToLoad;
         if ($unprefixedClassToLoad) {
             $relativeUnprefixedClassToLoad = $path->getPath . DIRECTORY_SEPARATOR . $unprefixedClassToLoad;
         } else {
             $relativeUnprefixedClassToLoad = '';
         }
         if ($unprefixedClassToLoad && ($retPath = $ipath->isFilename($unprefixedClassToLoad, '', $base))) {
             require_once $retPath;
             return;
         } else {
             if ($retPath = $ipath->isFilename($classToLoad, '', $base)) {
                 require_once $retPath;
                 return;
             } else {
                 if ($relativeUnprefixedClassToLoad && ($retPath = $ipath->isFilename($relativeUnprefixedClassToLoad, '', $base))) {
                     require_once $retPath;
                     return;
                 } else {
                     if ($retPath = $ipath->isFilename($relativeClassToLoad, '', $basePath)) {
                         require_once $retPath;
                         return;
                     }
                 }
             }
         }
     }
     return;
 }