예제 #1
0
 public function folder($folder, $filename = null)
 {
     if (!preg_match('/^[0-9]+x[0-9]+$/', $folder)) {
         // Zijn er geen afmetingen meegegeven?
         return $this->onFolderNotFound();
     }
     if (!$filename) {
         // Komt de afbeelding uit een subfolder($recursive)?
         $url = Url::getCurrentURL();
         $path = array('folders' => $url->getFolders(), 'filename' => $url->getFilename());
         $subfolders = array_slice($path['folders'], $this->depth + 1);
         $filename = implode('/', $subfolders) . '/' . $path['filename'];
     }
     $source = $this->imagesFolder . $filename;
     if (!file_exists($source)) {
         return new HttpError(404, array('warning' => 'Image "' . $filename . '" not found in "' . $this->imagesFolder . '"'));
     }
     $target = $this->targetFolder . $folder . '/' . $filename;
     if (!file_exists($target) || filemtime($source) > filemtime($target)) {
         $dimensions = explode('x', $folder);
         \Sledgehammer\mkdirs(dirname($target));
         $image = new Image($source);
         $image->saveThumbnail($target, $dimensions[0], $dimensions[1]);
     }
     return new File($target);
 }
예제 #2
0
 public function test_startup()
 {
     \Sledgehammer\mkdirs(\Sledgehammer\TMP_DIR . 'Cache');
     $cache = Cache::rootNode();
     $this->assertInstanceOf(Cache::class, $cache);
     $this->apcSupported = function_exists('apc_fetch');
     if ($this->apcSupported === false) {
         $this->markTestSkipped('Skipping tests for "apc" backend, the php-extension "apc" is not installed.');
     }
 }
예제 #3
0
 /**
  * Register all models from the backend.
  * Aslo validates and corrects the model configurations.
  *
  * @param RepositoryBackend $backend
  */
 public function registerBackend($backend)
 {
     if ($backend->identifier === null) {
         throw new Exception('RepositoryBackend->identifier is required');
     }
     if (count($backend->configs) === 0) {
         notice(get_class($backend) . ': "' . $backend->identifier . '" doesn\'t have any ModelConfigs');
         return;
     }
     if (isset($this->backends[$backend->identifier])) {
         throw new Exception('RepositoryBackend "' . $backend->identifier . '" already registered');
     }
     $this->backends[$backend->identifier] = $backend;
     // Pass 1: Register configs
     foreach ($backend->configs as $config) {
         if ($config->backend === null) {
             $config->backend = $backend->identifier;
         }
         $this->registerModel($config);
     }
     // Pass 2: Register junctions
     foreach ($backend->junctions as $junction) {
         if ($junction->backend === null) {
             $junction->backend = $backend->identifier;
         }
         if (isset($this->junctions[$junction->name])) {
             notice('overwriting junction ' . $junction->name);
         }
         $this->junctions[$junction->name] = $junction;
     }
     // Pass 3: Auto detect id's
     foreach ($backend->configs as $backendConfig) {
         $config = $this->configs[$backendConfig->name];
         if (count($config->id) === 0) {
             if (isset($config->properties['id'])) {
                 // No id set, but the column 'id' exists?
                 $config->id = array('id');
             } else {
                 warning('Invalid config: ' . $config->name . '->id is not configured and could not detect an "id" element');
             }
         }
     }
     // Pass 4: Validate and correct configs
     foreach ($backend->configs as $backendConfig) {
         $config = $this->configs[$backendConfig->name];
         if (count($config->properties) === 0) {
             warning('Invalid config: ' . $config->name . '->properties array is not configured');
         }
         foreach ($config->id as $idIndex => $idColumn) {
             if (isset($config->properties[$idColumn])) {
                 $idProperty = $config->properties[$idColumn];
             } else {
                 warning('Invalid config: ' . $config->name . '->id[' . $idIndex . ']: "' . $idColumn . '" isn\'t mapped as a property');
             }
         }
         foreach ($config->belongsTo as $property => $belongsTo) {
             $validationError = false;
             if (is_array($belongsTo) === false) {
                 $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '] should be an array';
             }
             if (empty($belongsTo['model'])) {
                 $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '][model] not set';
             } elseif (empty($belongsTo['reference']) && empty($belongsTo['convert'])) {
                 $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '] is missing a [reference] or [convert] element';
             } elseif (isset($belongsTo['convert']) && isset($belongsTo['reference'])) {
                 $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '] can\'t contain both a [reference] and a [convert] element';
             }
             if (isset($belongsTo['reference'])) {
                 if (empty($belongsTo['id'])) {
                     // id not set, but (target)model is configured?
                     if (empty($this->configs[$belongsTo['model']])) {
                         $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '][id] couldn\'t be inferred, because model "' . $belongsTo['model'] . '" isn\'t registered';
                     } else {
                         $belongsToConfig = $this->_getConfig($belongsTo['model']);
                         // Infer/Assume that the id is the ID from the model
                         if (count($belongsToConfig->id) == 1) {
                             $belongsTo['id'] = current($belongsToConfig->id);
                             $config->belongsTo[$property]['id'] = $belongsTo['id'];
                             // Update config
                         } else {
                             $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '][id] not set and can\'t be inferred (for a complex key)';
                         }
                     }
                 }
                 if (isset($belongsTo['reference']) && isset($belongsTo['useIndex']) == false) {
                     if (empty($this->configs[$belongsTo['model']])) {
                         $validationError = 'Invalid config: ' . $config->name . '->belongsTo[' . $property . '][useIndex] couldn\'t be inferred, because model "' . $belongsTo['model'] . '" isn\'t registered';
                     } else {
                         $belongsToConfig = $this->_getConfig($belongsTo['model']);
                         // Is the foreign key is linked to the model id
                         $belongsTo['useIndex'] = count($belongsToConfig->id) == 1 && $belongsTo['id'] == current($belongsToConfig->id);
                         $config->belongsTo[$property]['useIndex'] = $belongsTo['useIndex'];
                         // Update config
                     }
                 }
                 if (isset($belongsTo['id'])) {
                     // Add foreign key to the collection mapping
                     $this->collectionMappings[$config->name][$property . '->' . $belongsToConfig->properties[$belongsTo['id']]] = $belongsTo['reference'];
                     $this->collectionMappings[$config->name][$property . '.' . $belongsToConfig->properties[$belongsTo['id']]] = $belongsTo['reference'];
                 }
             }
             // @todo Add collectionMapping for "convert" relations?
             if (empty($this->configs[$belongsTo['model']])) {
                 //					$validationError = 'Invalid config: '.$config->name.'->belongsTo['.$property.'][model] "'.$belongsTo['model'].'" isn\'t registered';
             }
             // Remove invalid relations
             if ($validationError) {
                 warning($validationError);
                 unset($config->belongsTo[$property]);
             }
         }
         foreach ($config->hasMany as $property => $hasMany) {
             $validationError = false;
             if (empty($hasMany['model'])) {
                 $validationError = 'Invalid config: ' . $config->name . '->hasMany[' . $property . '][model] not set';
             } elseif (isset($hasMany['convert'])) {
                 // no additional fields are needed.
             } elseif (empty($hasMany['reference'])) {
                 // @todo Infer property (lookup belongsTo)
                 $validationError = 'Invalid hasMany: ' . $config->name . '->hasMany[' . $property . '][reference] not set';
             } elseif (isset($hasMany['reference']) && empty($hasMany['belongsTo'])) {
                 $referencePath = PropertyPath::parse($hasMany['reference']);
                 if (count($referencePath) == 1) {
                     // The foreign key is linked directly
                 } elseif (empty($this->configs[$hasMany['model']])) {
                     $validationError = 'Invalid config: ' . $config->name . '->hasMany[' . $property . '][belongsTo] couldn\'t be inferred, because model "' . $hasMany['model'] . '" isn\'t registered';
                 } else {
                     // Infer the belongsTo path based on the model and reference path.
                     $hasManyConfig = $this->configs[$hasMany['model']];
                     $idProperty = array(array_value(array_pop($referencePath), 1));
                     if ($idProperty == $hasManyConfig->id) {
                         $hasMany['belongsTo'] = PropertyPath::assemble($referencePath);
                         $config->hasMany[$property]['belongsTo'] = $hasMany['belongsTo'];
                         // update config
                     }
                 }
             }
             if (isset($hasMany['through'])) {
                 if (array_key_exists('fields', $hasMany) === false) {
                     $config->hasMany[$property]['fields'] = [];
                 } elseif (array_key_exists('junctionClass', $hasMany) === false) {
                     $config->hasMany[$property]['junctionClass'] = Junction::class;
                 }
                 $junctionConfig = @$this->junctions[$hasMany['through']];
                 if (array_key_exists('idPath', $hasMany) === false && $junctionConfig) {
                     //                        dump($junctionConfig);
                 }
             }
             // Remove invalid relations
             if ($validationError) {
                 warning($validationError);
                 unset($config->hasMany[$property]);
             }
         }
         // Validate read & write filters
         foreach ($config->readFilters as $column => $filter) {
             if (empty($config->properties[$column])) {
                 notice('Invalid config: ' . $config->name . '->readFilters[' . $column . '] isn\'t mapped as property', $filter);
             }
         }
         foreach ($config->writeFilters as $column => $filter) {
             if (empty($config->properties[$column])) {
                 notice('Invalid config: ' . $config->name . '->writeFilters[' . $column . '] isn\'t mapped as property', $filter);
             }
         }
     }
     // Pass 5: Generate classes based on properties when no class is detected/found.
     foreach ($backend->configs as $config) {
         if (substr($config->class, 0, 11) !== '\\Generated\\') {
             $this->validated[$config->name] = false;
         } else {
             $this->validated[$config->name] = true;
             // Generated classes are valid by design.
             if (class_exists($config->class, false)) {
                 notice('Skipped generating class: "' . $config->class . '", a class with the same name exists');
                 continue;
             }
             $parts = explode('\\', $config->class);
             array_pop($parts);
             // remove class part.
             $namespace = implode('\\', array_slice($parts, 1));
             // Generate class
             $use = '';
             $aliases = [];
             $alias = $this->buildAlias(Object::class, $aliases, $use);
             $php = "\nclass " . $config->name . " extends " . $alias . "\n{\n";
             $properties = [];
             foreach ($config->properties as $path) {
                 $parsedPath = PropertyPath::parse($path);
                 $property = $parsedPath[0][1];
                 if (!in_array($property, $properties)) {
                     $php .= "    public \$" . $property . ";\n";
                     $properties[] = $property;
                 }
             }
             foreach ($config->belongsTo as $path => $belongsTo) {
                 $parsedPath = PropertyPath::parse($path);
                 $belongsToConfig = $this->_getConfig($belongsTo['model']);
                 $alias = $this->buildAlias($belongsToConfig->class, $aliases, $use);
                 $property = $parsedPath[0][1];
                 $php .= "\n";
                 $php .= "    /**\n";
                 $php .= "     * @var " . $alias . ' The associated ' . $belongsToConfig->name . "\n";
                 $php .= "     */\n";
                 $php .= "    public \$" . $property . ";\n";
             }
             foreach ($config->hasMany as $path => $hasMany) {
                 $parsedPath = PropertyPath::parse($path);
                 $hasManyConfig = $this->_getConfig($hasMany['model']);
                 $property = $parsedPath[0][1];
                 $aliasC = $this->buildAlias(Collection::class, $aliases, $use);
                 $alias = $this->buildAlias($hasManyConfig->class, $aliases, $use);
                 $php .= "\n";
                 $php .= "    /**\n";
                 $php .= "     * @var " . $aliasC . "|" . $alias . "[] A collection with the associated " . $hasManyConfig->plural . "\n";
                 $php .= "     */\n";
                 $php .= "    public \$" . $property . ";\n";
             }
             $php .= '}';
             $php = "namespace " . $namespace . ";\n\n" . $use . $php;
             if (\Sledgehammer\ENVIRONMENT === 'development' && $namespace === 'Generated') {
                 // Write autoComplete helper
                 // @todo Only write file when needed, aka validate $this->autoComplete
                 \Sledgehammer\mkdirs(\Sledgehammer\TMP_DIR . 'AutoComplete');
                 file_put_contents(\Sledgehammer\TMP_DIR . 'AutoComplete/' . $config->name . '.php', "<?php\n\n" . $php . "\n");
             }
             eval($php);
         }
     }
     // Pass 6: Generate or update the AutoComplete Helper for the default repository?
     if (\Sledgehammer\ENVIRONMENT == 'development' && isset(self::$instances['default']) && self::$instances['default'] === $this) {
         $autoCompleteFile = \Sledgehammer\TMP_DIR . 'AutoComplete/repository.ini';
         if ($this->autoComplete === null) {
             if (file_exists($autoCompleteFile)) {
                 $this->autoComplete = parse_ini_file($autoCompleteFile, true);
             } else {
                 $this->autoComplete = [];
             }
         }
         // Validate AutoCompleteHelper
         foreach ($backend->configs as $config) {
             $autoComplete = array('class' => $config->class, 'properties' => implode(', ', $config->properties));
             if (empty($this->autoComplete[$config->name]) || $this->autoComplete[$config->name] != $autoComplete) {
                 $this->autoComplete[$config->name] = $autoComplete;
                 \Sledgehammer\mkdirs(\Sledgehammer\TMP_DIR . 'AutoComplete');
                 \Sledgehammer\write_ini_file($autoCompleteFile, $this->autoComplete, 'Repository AutoComplete config');
                 $this->writeAutoCompleteHelper(\Sledgehammer\TMP_DIR . 'AutoComplete/DefaultRepository.php', 'DefaultRepository', 'Generated');
             }
         }
     }
 }
예제 #4
0
 /**
  * Download and install a PEAR package.
  *
  * @throws Exceptions on failure
  *
  * @param string $package
  * @param string $version
  * @param array  $options array(
  *                        'version' = Install a specific version
  *                        'target' => alternative target directory
  *                        'channel' => specifiy the channel
  *                        )
  */
 public function install($package, $options = [])
 {
     $version = \Sledgehammer\array_value($options, 'version') ?: 'stable';
     if (isset($options['channel'])) {
         $channel = $options['channel'];
         $this->addChannel($channel);
         if (empty($this->channels[$channel]['packages'][$package])) {
             if (isset($this->channels[$channel]['packages'])) {
                 foreach ($this->channels[$channel]['packages'] as $name => $info) {
                     if (strcasecmp($name, $package) === 0) {
                         return $this->install($name, $options);
                     }
                 }
             }
             throw new InfoException('Package "' . $package . '" not found in channel: ' . $channel, \Sledgehammer\quoted_human_implode(' and ', array_keys($this->channels[$channel]['packages'])));
         }
         $packageLocation =& $this->channels[$channel]['packages'][$package];
     } else {
         if (count($this->channels) === 0) {
             $this->addChannel('pear.php.net');
         }
         if (empty($this->packages[$package])) {
             foreach ($this->packages as $name => $channel) {
                 if (strcasecmp($name, $package) === 0) {
                     return $this->install($name, $options);
                 }
             }
             throw new InfoException('Package "' . $package . '" not found in channels: ' . \Sledgehammer\quoted_human_implode(' and ', array_keys($this->channels)), 'Available packages: ' . \Sledgehammer\quoted_human_implode(' and ', array_keys($this->packages)));
         }
         $packageLocation =& $this->channels[$this->packages[$package]]['packages'][$package];
     }
     $release = $this->findRelease($packageLocation, $version);
     if (\Sledgehammer\array_value($packageLocation, 'installed') === $version) {
         return;
     }
     $this->trigger('installing', $this, $package, $version);
     $tmpFolder = \Sledgehammer\TMP_DIR . 'PearInstaller/';
     $folderName = $package . '-' . $version;
     $tarFile = $tmpFolder . $folderName . '/package.tar';
     \Sledgehammer\mkdirs(dirname($tarFile));
     if (file_exists($tarFile) === false) {
         // Is this package already in the tmp folder
         Curl::download($release->g . '.tar', $tarFile);
     }
     chdir(dirname($tarFile));
     system('tar xf ' . escapeshellarg($tarFile), $exit);
     if ($exit !== 0) {
         throw new Exception('Unable to untar "' . $tarFile . '"');
     }
     if (file_exists(dirname($tarFile) . '/package2.xml')) {
         $info = simplexml_load_file(dirname($tarFile) . '/package2.xml');
     } else {
         $info = simplexml_load_file(dirname($tarFile) . '/package.xml');
     }
     // Install dependencies first
     foreach ($info->dependencies->required->package as $dependancy) {
         if ($dependancy->conflicts) {
             //				\Sledgehammer\notice('Dependancy "'.$dependancy->name.'" for "'.$package.'" <conflicts />');
             continue;
         }
         $this->install((string) $dependancy->name, array('channel' => (string) $dependancy->channel));
     }
     $renames = [];
     foreach ($info->phprelease as $release) {
         if ($release->count() > 0) {
             foreach ($release->filelist->install as $move) {
                 $renames[(string) $move['name']] = (string) $move['as'];
             }
         }
     }
     $files = $this->extractFiles($info->contents->dir, '', '/', $renames);
     foreach ($files as $file) {
         if (isset($this->targets[$file['role']])) {
             $dir = $this->targets[$file['role']];
             if (in_array($file['role'], array('doc', 'www'))) {
                 if (\Sledgehammer\text($file['to'])->startsWith($package) == false) {
                     $dir = $this->makePath($dir, $package);
                 }
             }
             $target = $this->makePath($dir, $file['to']);
             if (\Sledgehammer\mkdirs(dirname($target)) == false || is_writable(dirname($target)) == false) {
                 throw new Exception('Target "' . $target . '" is not writable');
             }
             $source = $this->makePath($tmpFolder . $folderName . '/' . $folderName, $file['from']);
             if (isset($file['tasks'])) {
                 $contents = file_get_contents($source);
                 foreach ($file['tasks'] as $task) {
                     $value = null;
                     if ($task['type'] === 'package-info') {
                         if ($task['to'] == 'version') {
                             $value = $version;
                         } elseif ($task['to'] == 'state') {
                             $value = (string) $info->stability->release;
                         }
                     } elseif ($task['type'] == 'pear-config') {
                         if (substr($task['to'], -4) === '_dir') {
                             $role = substr($task['to'], 0, -4);
                             if (isset($this->targets[$role])) {
                                 $value = $this->targets[$role];
                                 // @todo calculate relative paths
                                 \Sledgehammer\notice('Harcoding path "' . $value . '" into "' . $file['to'] . '"', $file);
                             }
                         } elseif ($task['to'] == 'php_bin') {
                             $value = trim(`which php`);
                             \Sledgehammer\notice('Harcoding path "' . $value . '" into "' . $file['to'] . '"', $file);
                         }
                     }
                     if ($task['task'] === 'replace') {
                         if ($value != '') {
                             $contents = str_replace($task['from'], $value, $contents);
                         } else {
                             \Sledgehammer\notice($task['type'] . ' "' . $task['to'] . '" not yet supported');
                         }
                     } else {
                         \Sledgehammer\notice('task "' . $task['task'] . '" not implemented');
                     }
                 }
                 file_put_contents($target, $contents);
             } else {
                 copy($source, $target);
             }
         }
     }
     \Sledgehammer\rmdir_recursive($tmpFolder . $folderName . '/' . $folderName);
     $packageLocation['installed'] = $version;
     $this->trigger('installed', $this, $package, $version);
 }
예제 #5
0
    echo "  \n";
    return false;
}
$modules = Framework::getModules();
$folders = [];
foreach ($modules as $folder => $info) {
    $modulePath = $info['path'];
    if (is_dir($modulePath . 'public')) {
        if (\Sledgehammer\array_value($info, 'app')) {
            $folders[$modulePath . 'public'] = '';
        } else {
            $folders[$modulePath . 'public'] = '/' . $folder;
        }
    }
}
foreach ($targetFolders as $targetFolder) {
    $fileCount = 0;
    echo "\nPopulating /" . $targetFolder . " ...\n";
    foreach ($folders as $folder => $targetSuffix) {
        $targetPath = \Sledgehammer\PATH . $targetFolder . $targetSuffix;
        \Sledgehammer\mkdirs($targetPath);
        $fileCount += copydir($folder, $targetPath, array('.svn'));
    }
    echo '  ' . $fileCount . " files copied\n";
}
if (isset($modules['minify'])) {
    include $modules['minify']['path'] . 'utils/minify_DocumentRoot.php';
} else {
    echo "  done.\n";
}
return true;
예제 #6
0
    }
    define('Sledgehammer\\TMP_DIR', $__TMP_DIR);
    unset($__TMP_DIR);
}
// Case insensitive "natural order" sorting method for natcasesort() in Collection->orderBy()
define('Sledgehammer\\SORT_NATURAL_CI', -2);
// Regex for supported operators for the compare() function
define('Sledgehammer\\COMPARE_OPERATORS', '==|!=|<|<=|>|>=|IN|NOT IN|LIKE|NOT LIKE');
/**
 * 2. Declare public functions.
 */
require_once __DIR__ . '/functions.php';
// Namespaced functions
require_once __DIR__ . '/helpers.php';
// Global functions (but not guaranteed)
\Sledgehammer\mkdirs(\Sledgehammer\TMP_DIR);
/*
 * 3. Configure and register the AutoLoader
 */
require_once __DIR__ . '/Object.php';
require_once __DIR__ . '/Debug/Autoloader.php';
spl_autoload_register('Sledgehammer\\Core\\Debug\\AutoLoader::lazyRegister');
/*
 * 4. Set DebugR statusbar header.
 */
if (headers_sent() === false) {
    DebugR::send('sledgehammer-statusbar', 'no statusbar data.', true);
}
/*
 * Timestamp (in microseconds) for when the Sledgehammer Framework was initialized.
 */
예제 #7
0
파일: Cache.php 프로젝트: sledgehammer/core
 /**
  * Return the rootnode for the app.
  *
  * @return Cache
  */
 public static function rootNode()
 {
     if (self::$instance !== null) {
         return self::$instance;
     }
     $backend = function_exists('apc_fetch') ? 'apc' : 'file';
     $backend = 'file';
     self::$instance = new self('', $backend);
     if ($backend === 'file') {
         \Sledgehammer\mkdirs(\Sledgehammer\TMP_DIR . 'Cache');
         if (rand(1, 25) === 1) {
             // Run gc only once in every X requests.
             self::file_gc();
         }
     }
     return self::$instance;
 }
예제 #8
0
 /**
  * Import definitions inside a folder.
  * Checks "autoloader.ini" for additional settings.
  *
  * @param string $path
  * @param array  $settings
  */
 public function importFolder($path, $settings = [])
 {
     $composer = false;
     if (file_exists($path . '/composer.json')) {
         if (substr($path, -1) !== '/') {
             $path .= '/';
         }
         $composer = json_decode(file_get_contents($path . 'composer.json'), true);
     }
     if ($composer && isset($composer['sledgehammer'])) {
         $settings += ['matching_filename' => true, 'mandatory_definition' => true, 'mandatory_superclass' => true, 'one_definition_per_file' => true, 'detect_accidental_output' => true, 'notice_ambiguous' => true];
     }
     $settings = $this->loadSettings($path, $settings);
     if ($composer) {
         $locations = [];
         $trace = [];
         $preventDefault = true;
         if (isset($composer['autoload']['classmap'])) {
             foreach ($composer['autoload']['classmap'] as $entry) {
                 $paths = is_array($entry) ? $entry : array($entry);
                 foreach ($paths as $entryPath) {
                     if (empty($entryPath) || $entry === '.') {
                         \Sledgehammer\notice('Empty autoload.classmap in "composer.json" isn\'t supported');
                         $preventDefault = false;
                         break;
                     } elseif (is_dir($path . $entryPath)) {
                         $locations[] = $entryPath;
                         $trace[] = 'classmap';
                     }
                 }
             }
         }
         $namespaces = [];
         if (isset($composer['autoload']['psr-0'])) {
             $namespaces += $composer['autoload']['psr-0'];
         }
         if (isset($composer['autoload']['psr-4'])) {
             $namespaces += $composer['autoload']['psr-4'];
         }
         if (isset($composer['autoload-dev']['psr-0'])) {
             $namespaces += $composer['autoload-dev']['psr-0'];
         }
         if (isset($composer['autoload-dev']['psr-4'])) {
             $namespaces += $composer['autoload-dev']['psr-4'];
         }
         foreach ($namespaces as $namespace => $entry) {
             $paths = is_array($entry) ? $entry : array($entry);
             foreach ($paths as $entryPath) {
                 if (in_array($entryPath, array('', '/', '.'))) {
                     $preventDefault = false;
                     break 2;
                 }
                 $locations[] = $entryPath;
                 $trace[] = 'psr-0 (' . $namespace . ')';
             }
         }
         if ($preventDefault) {
             foreach ($locations as $i => $entry) {
                 if (is_dir($path . $entry)) {
                     if (in_array($entry, $settings['ignore_folders'])) {
                         continue;
                     }
                     $this->importFolder($path . $entry, $settings);
                 } elseif (is_file($path . $entry)) {
                     if (in_array($entry, $settings['ignore_files'])) {
                         continue;
                     }
                     $this->importFile($path . $entry, $settings);
                 } else {
                     // Allow invalid composer.json configurations, not Sledgehammers problem.
                     // \Sledgehammer\notice('Invalid "composer.json" entry: '.$trace[$i].': "'.$entry.'"', 'file or directory: "'.$path.$entry.'" not found');
                 }
             }
             return;
         }
     }
     $useCache = $this->enableCache && $settings['cache_level'] > 0;
     if ($useCache) {
         --$settings['cache_level'];
         $scanCount = false;
         $folder = basename($path);
         if ($folder == 'classes') {
             $folder = basename(dirname($path));
         }
         $cacheFile = \Sledgehammer\TMP_DIR . 'AutoLoader/' . $folder . '_' . md5($path) . '.php';
         if (!\Sledgehammer\mkdirs(dirname($cacheFile))) {
             $this->enableCache = false;
             $useCache = false;
         } elseif (file_exists($cacheFile)) {
             $mtimeCache = filemtime($cacheFile);
             $revalidateCache = $mtimeCache < time() - $settings['revalidate_cache_delay'];
             // Is er een delay ingesteld en is deze nog niet verstreken?;
             $mtimeFolder = $revalidateCache ? \Sledgehammer\mtime_folders($path, array('php'), $scanCount) : 0;
             if ($mtimeFolder !== false && $mtimeCache > $mtimeFolder) {
                 // Is het cache bestand niet verouderd?
                 if ($this->loadDatabase($cacheFile, true, $scanCount)) {
                     if ($settings['revalidate_cache_delay'] && $revalidateCache) {
                         // is het cache bestand opnieuw gevalideerd?
                         touch($cacheFile);
                         // de mtime van het cache-bestand aanpassen, (voor het bepalen of de delay is vertreken)
                     }
                     return;
                 }
             }
         }
     }
     // Import files & subfolders
     try {
         $dir = new DirectoryIterator($path);
     } catch (Exception $e) {
         \Sledgehammer\notice($e->getMessage());
         return;
     }
     foreach ($dir as $entry) {
         if ($entry->isDot()) {
             continue;
         }
         if ($entry->isDir()) {
             if (in_array($entry->getPathname(), $settings['ignore_folders'])) {
                 continue;
             }
             $this->importFolder($entry->getPathname(), $settings);
         }
         if (\Sledgehammer\file_extension($entry->getFilename()) == 'php') {
             if (in_array($entry->getPathname(), $settings['ignore_files']) == false) {
                 $this->importFile($entry->getPathname(), $settings);
             }
         }
     }
     if ($useCache) {
         $this->saveDatabase($cacheFile, $this->relativePath($path), $scanCount);
     }
 }