public function addCest($file) { $name = $this->relativeName($file); $this->tests[$name] = $file; $loaded_classes = get_declared_classes(); require_once $file; $extra_loaded_classes = get_declared_classes(); $testClasses = array_diff($extra_loaded_classes, $loaded_classes); foreach ($testClasses as $testClass) { $unit = new $testClass(); $reflected = new \ReflectionClass($testClass); $methods = $reflected->getMethods(\ReflectionMethod::IS_PUBLIC); foreach ($methods as $method) { if ($method->isConstructor()) { continue; } if ($method->isDestructor()) { continue; } if (isset($unit->class)) { $target = $unit->class; $target .= $method->isStatic() ? '::' . $method->name : '.' . $method->name; } else { $target = get_class($unit) . '::' . $method->name; } $this->suite->addTest(new \Codeception\TestCase\Cest($this->dispatcher, array('name' => $name . ':' . $target, 'class' => $unit, 'method' => $method->name, 'static' => $method->isStatic(), 'signature' => $target, 'file' => $file, 'bootstrap' => $this->settings['bootstrap']))); } } }
/** * Autoload */ public function testAutoload() { $declared = get_declared_classes(); $declaredCount = count($declared); Autoloader::autoload('Foo'); $this->assertEquals($declaredCount, count(get_declared_classes()), 'PhpOffice\\PhpPowerpoint\\Autoloader::autoload() is trying to load ' . 'classes outside of the PhpOffice\\PhpPowerpoint namespace'); }
/** * {@inheritDoc} * @todo Same code exists in AnnotationDriver, should we re-use it somehow or not worry about it? */ public function getAllClassNames() { if ($this->classNames !== null) { return $this->classNames; } if (!$this->paths) { throw MongoDBException::pathRequired(); } $classes = array(); $includedFiles = array(); foreach ($this->paths as $path) { if (!is_dir($path)) { throw MongoDBException::fileMappingDriversRequireConfiguredDirectoryPath(); } $iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path), \RecursiveIteratorIterator::LEAVES_ONLY); foreach ($iterator as $file) { if (($fileName = $file->getBasename($this->fileExtension)) == $file->getBasename()) { continue; } $sourceFile = realpath($file->getPathName()); require_once $sourceFile; $includedFiles[] = $sourceFile; } } $declared = get_declared_classes(); foreach ($declared as $className) { $rc = new \ReflectionClass($className); $sourceFile = $rc->getFileName(); if (in_array($sourceFile, $includedFiles) && !$this->isTransient($className)) { $classes[] = $className; } } $this->classNames = $classes; return $classes; }
/** * Analyzes the file provided and gets a list of all valid tests * The analyzer includes the class, scans the declared class space * for new classes, inspects every included class, and then for each * class, inspects the methods to find any that match the test criteria. * The resulting array of file => classes => tests is then returned. * * @param $file the file to inspect * @return array **/ public function analyzeFile($file) { if (!file_exists($file)) { throw new Snap_File_UnitTestLoader_LoadException('The test file ' . $file . ' was not found.'); } // record the declated classes before include $classes = get_declared_classes(); // include, and then scan for new classes include_once $file; $classes = array_diff(get_declared_classes(), $classes); $output = array(); // loop through the tests and if it does not have a runTest method, continue // otherwise, add that class as a valid test $methods = array(); foreach ($classes as $class_name) { // skip classes that don't have a runTests method if (!method_exists($class_name, 'runTests')) { continue; } $methods = get_class_methods($class_name); // loop through the methods, adding the tests foreach ($methods as $method) { if (stripos($method, 'test') !== 0) { continue; } if (!isset($output[$class_name])) { $output[$class_name] = array(); } $output[$class_name][] = $method; } } return $output; }
/** * @return array * @throws \Exception */ public function getClassAnnotation() { $classAttributes = []; $this->getAllClasses(); $classes = get_declared_classes(); foreach ($classes as $class) { $reflection = new \ReflectionClass($class); $methods = $reflection->getMethods(); foreach ($methods as $method) { $annotations = $method->getDocComment(); preg_match_all('#@(.*?)\\s#', $annotations, $annotation); if ($annotation[1] != null) { if (empty($method->name)) { throw new \Exception('You have no method!'); } $action = $method->name; if (empty($annotation[1][0])) { $annotation[1][0] = 'GET'; } $type = $annotation[1][0]; if (empty($annotation[1][1])) { $annotation[1][1] = ''; } $route = $annotation[1][1]; if (empty($annotation[1][2])) { $annotation[1][2] = 'UNAUTHORIZE'; } $authorize = $annotation[1][2]; $classAttributes[] = ['method' => $action, 'type' => $type, 'route' => $route, 'authorize' => $authorize, 'class' => $class]; } } } return $classAttributes; }
/** * load() - called by the client initialize routine to load files * */ public function load() { $this->_retrievedFiles = $this->getRetrievedFiles(); $this->_loadedClasses = array(); $manifestRegistry = $this->_registry->getManifestRepository(); $providerRegistry = $this->_registry->getProviderRepository(); $loadedClasses = array(); // loop through files and find the classes declared by loading the file foreach ($this->_retrievedFiles as $file) { $classesLoadedBefore = get_declared_classes(); $oldLevel = error_reporting(E_ALL | ~E_STRICT); // remove strict so that other packages wont throw warnings // should we lint the files here? i think so include_once $file; error_reporting($oldLevel); // restore old error level $classesLoadedAfter = get_declared_classes(); $loadedClasses = array_merge($loadedClasses, array_diff($classesLoadedAfter, $classesLoadedBefore)); } // loop through the loaded classes and ensure that foreach ($loadedClasses as $loadedClass) { // reflect class to see if its something we want to load $reflectionClass = new ReflectionClass($loadedClass); if ($reflectionClass->implementsInterface('Zend_Tool_Framework_Manifest_Interface') && !$reflectionClass->isAbstract()) { $manifestRegistry->addManifest($reflectionClass->newInstance()); $this->_loadedClasses[] = $loadedClass; } if ($reflectionClass->implementsInterface('Zend_Tool_Framework_Provider_Interface') && !$reflectionClass->isAbstract() && !$providerRegistry->hasProvider($reflectionClass->getName(), false)) { $providerRegistry->addProvider($reflectionClass->newInstance()); $this->_loadedClasses[] = $loadedClass; } } return $this->_loadedClasses; }
/** * Constructor. */ public function __construct() { $date = $this->month . '-01'; $classes = get_declared_classes(); sort($classes); foreach ($classes as $className) { if (is_subclass_of($className, 'Fixture') && !is_subclass_of($className, __CLASS__) && $className != __CLASS__ && $className != "Piwik_Test_Fixture_SqlDump" && $className != "Piwik\\Tests\\Fixtures\\UpdaterTestFixture" && $className != "Piwik\\Tests\\Fixtures\\UITestFixture") { $klassReflect = new ReflectionClass($className); if (!strpos($klassReflect->getFilename(), "tests/PHPUnit/Fixtures") && $className != "CustomAlerts" && $className != "Piwik\\Plugins\\Insights\\tests\\Fixtures\\SomeVisitsDifferentPathsOnTwoDays") { continue; } $fixture = new $className(); if (!property_exists($fixture, 'dateTime')) { continue; } $fixture->dateTime = $this->adjustDateTime($fixture->dateTime, $date); $this->fixtures[$className] = $fixture; $date = Date::factory($date)->addDay(1)->toString(); } } $this->now = $this->fixtures['ManySitesImportedLogsWithXssAttempts']->now; // make sure ManySitesImportedLogsWithXssAttempts is the first fixture $fixture = $this->fixtures['Piwik\\Tests\\Fixtures\\ManySitesImportedLogsWithXssAttempts']; unset($this->fixtures['Piwik\\Tests\\Fixtures\\ManySitesImportedLogsWithXssAttempts']); $this->fixtures = array_merge(array('Piwik\\Tests\\Fixtures\\ManySitesImportedLogsWithXssAttempts' => $fixture), $this->fixtures); }
/** @param base base class to collect sub classes for * @param check_interfaces whether we deal with interfaces */ function __construct($base, $check_interfaces = false) { foreach (get_declared_classes() as $cname) { $parent = get_parent_class($cname); if (strcasecmp($parent, $base) == 0) { $this->offsetSet($cname, new SubClasses($cname)); } if ($check_interfaces) { if ($parent) { $parent_imp = class_implements($parent); } foreach (class_implements($cname) as $iname) { if (strcasecmp($iname, $base) == 0) { if (!$parent || !in_array($iname, $parent_imp)) { $this->offsetSet($cname, new SubClasses($cname)); } } } } } if ($check_interfaces) { foreach (get_declared_interfaces() as $cname) { foreach (class_implements($cname) as $iname) { if (strcasecmp($iname, $base) == 0) { $this->offsetSet($cname, new SubClasses($cname, true)); } } } } $this->uksort('strnatcasecmp'); }
/** * Same as loadView but loads relative to controllers name * * @param String $action * @param Boolean $toVar * * @return String */ public function loadRelativeView($action, $toVar = false) { //Searching if Views is loaded if (array_search('PhpBURN_Views', get_declared_classes()) == true) { return PhpBURN_Views::loadView(get_class($this) . DS . $action, $this->_viewData, $toVar); } }
public function __construct() { if ($this->_resources = Axis::cache()->load('axis_acl_resources')) { return; } foreach (Axis::app()->getModules() as $moduleName => $path) { if ('Axis_Admin' === $moduleName) { $path = $path . '/controllers'; } else { $path = $path . '/controllers/Admin'; } if (!is_dir($path)) { continue; } foreach ($this->_scanDirectory($path) as $file) { if (strstr($file, "Controller.php") == false) { continue; } include_once $file; } } $resource = 'admin'; $resources = array($resource); $camelCaseToDash = new Zend_Filter_Word_CamelCaseToDash(); foreach (get_declared_classes() as $class) { if (!is_subclass_of($class, 'Axis_Admin_Controller_Back')) { continue; } list($module, $controller) = explode('Admin_', $class, 2); $module = rtrim($module, '_'); if (empty($module)) { $module = 'Axis_Core'; } elseif ('Axis' === $module) { $module = 'Axis_Admin'; } $module = strtolower($camelCaseToDash->filter($module)); list($namespace, $module) = explode('_', $module, 2); $resource .= '/' . $namespace; $resources[$resource] = $resource; $resource .= '/' . $module; $resources[$resource] = $resource; $controller = substr($controller, 0, strpos($controller, "Controller")); $controller = strtolower($camelCaseToDash->filter($controller)); $resource .= '/' . $controller; $resources[$resource] = $resource; foreach (get_class_methods($class) as $action) { if (false == strstr($action, "Action")) { continue; } $action = substr($action, 0, strpos($action, 'Action')); $action = strtolower($camelCaseToDash->filter($action)); // $resources[$namespace][$module][$controller][] = $action; $resources[$resource . '/' . $action] = $resource . '/' . $action; } $resource = 'admin'; } asort($resources); Axis::cache()->save($resources, 'axis_acl_resources', array('modules')); $this->_resources = $resources; }
/** * @param string $name * @return mixed */ public function locateController($name) { // case $name is a real class name if (is_object($name) || class_exists($name)) { return $name; } // case $name is a short name $mask = FrontController::getInstance()->getOption('controller_name_finder'); $full_name = sprintf($mask, Helper::getPropertyName($name)); if (class_exists($full_name)) { return $full_name; } // a user defined locator $locator = FrontController::getInstance()->getOption('controller_locator'); if (!is_null($locator) && is_callable($locator)) { $result = call_user_func($locator, $name); if (!empty($result) && class_exists($result)) { return $result; } } // loop over all defined classes $n_length = strlen($name); $fn_length = strlen($full_name); foreach (get_declared_classes() as $classname) { if (substr($classname, -$n_length) == $name || substr($classname, -$fn_length) == $full_name) { return $classname; } } return null; }
/** * Get all the metadata class names known to this driver. * @throws DrestException * @return array $classes */ public function getAllClassNames() { if (empty($this->classNames)) { if (empty($this->paths)) { throw DrestException::pathToConfigFilesRequired(); } $classes = []; $included = []; foreach ($this->paths as $path) { $iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS), \RecursiveIteratorIterator::LEAVES_ONLY); foreach ($iterator as $file) { /* @var \SplFileInfo $file */ if (!in_array($file->getExtension(), $this->extensions)) { continue; } $path = $file->getRealPath(); if (!empty($path)) { require_once $path; } // Register the files we've included here $included[] = $path; } } foreach (get_declared_classes() as $className) { $reflClass = new \ReflectionClass($className); $sourceFile = $reflClass->getFileName(); if (in_array($sourceFile, $included) && $this->isDrestResource($className)) { $classes[] = $className; } } $this->classNames = $classes; } return $this->classNames; }
public function runInFolder($folder, $prefix = '', $suffix = '', $beforeEach = null, $afterEach = null) { if (!$folder) { trigger_error('No folder specified', E_USER_WARNING); return false; } $tests = array(); $classes_before = get_declared_classes(); if (!$this->includeFolder($folder, $prefix, $suffix)) { return false; } $classes_after = get_declared_classes(); $classes = array_diff($classes_after, $classes_before); if (!empty($classes)) { foreach ($classes as $class) { try { /** @var ClassTest $Test */ $Test = new $class(); } catch (\Exception $E) { continue; } if ($Test instanceof ClassTest && get_class($Test) !== 'Jamm\\Tester\\ClassTest') { if ($beforeEach && is_callable($beforeEach)) { $beforeEach($Test); } $Test->RunTests(); $tests = array_merge($tests, $Test->getTests()); if ($afterEach && is_callable($afterEach)) { $afterEach($Test); } } } } return $tests; }
public function parsePackage($pPath, $pPackage, $pOrigin = true) { $classes = array(); $excluded_ext = '/\\.(tpl|tpl\\.php|ttf)$/'; $r = Folder::read($pPath, false); foreach ($r as $name => $folder) { if (is_file($folder['path'])) { $file = $folder['path']; if (preg_match($excluded_ext, $file, $matches)) { continue; } include_once $file; continue; } $this->parsePackage($folder['path'], $pPackage . '\\' . $name, false); } if ($pOrigin) { $declared_classes = get_declared_classes(); foreach ($declared_classes as $classe) { if (preg_match('/^' . $pPackage . '/', $classe, $matches)) { $details = $this->parseClass($classe); $classes[$classe] = $details; } } } $this->packages = array_merge($this->packages, $classes); }
/** * Processes the request. * * @param object HTML_QuickForm_Page the current form-page * @param string Current action name, as one Action object can serve multiple actions * @since 2.1.0 * @access public */ function perform(&$page, $actionName) { $page->isFormBuilt() or $page->buildForm(); $page->handle('display'); $sess =& $page->controller->container(); $opt = $page->getSubmitValue('dumpOption'); switch ($opt) { case '1': // Progress2 dump info $arr = $page->controller->_progress->toArray(); varDump($arr); break; case '2': // Forms values container varDump($sess); break; case '3': // Included files $includes = get_included_files(); varDump($includes); break; case '4': // declared classes $classes = get_declared_classes(); varDump($classes); break; case '5': // declared actions $actions = $page->controller->_actions; varDump($actions); break; } }
/** @function load() loads the events into the system * @return void */ public function load() { global $Init; foreach ($Init->EventPaths as $subscriberDirectory) { if (file_exists($subscriberDirectory)) { $subscriberIterator = new DirectoryIterator($subscriberDirectory); foreach ($subscriberIterator as $fileInfo) { $file = !$fileInfo->isDot() && $fileInfo->isFile() && substr($fileInfo->getFilename(), -10) == '.event.php' ? file($fileInfo->getPathname()) : null; $PluginName = preg_match('#plugins#i', $subscriberDirectory) ? basename(substr($subscriberDirectory, 0, -7)) : null; if (in_array($PluginName, (array) $_SESSION['PluginsInstalled'])) { $className = substr($fileInfo->getFilename(), -10) == '.event.php' ? substr($fileInfo->getFilename(), 0, -10) : null; } else { if ($file && !preg_match('#plugins#', $fileInfo->getPathname())) { $key = '$active'; foreach ($file as $lineNumber => $line) { if (strpos($line, $key) !== false) { break; } } if (preg_match('#true#i', $file[$lineNumber])) { $className = substr($fileInfo->getFileName(), -10) == '.event.php' ? substr($fileInfo->getFilename(), 0, -10) : null; } } } if ($className && !in_array($className, get_declared_classes())) { $this->getClass($className); } } } } }
/** * generate docs */ public function docs() { $docs = []; foreach (get_declared_classes() as $task) { if (!preg_match('~Robo\\\\Task.*?Task$~', $task)) { continue; } $docs[basename((new ReflectionClass($task))->getFileName(), '.php')][] = $task; } ksort($docs); $taskGenerator = $this->taskGenDoc('docs/tasks.md')->filterClasses(function (\ReflectionClass $r) { return !$r->isAbstract() or $r->isTrait(); })->prepend("# Tasks"); foreach ($docs as $file => $classes) { $taskGenerator->docClass("Robo\\Task\\{$file}"); foreach ($classes as $task) { $taskGenerator->docClass($task); } } $taskGenerator->filterMethods(function (\ReflectionMethod $m) { if ($m->isConstructor() or $m->isDestructor() or $m->isStatic()) { return false; } return !in_array($m->name, ['run', '', '__call', 'getCommand']) and $m->isPublic(); // methods are not documented })->processClassSignature(function ($c) { return "## " . preg_replace('~Task$~', '', $c->getShortName()) . "\n"; })->processClassDocBlock(function ($c, $doc) { return preg_replace('~@method .*?\\wTask (.*?)\\)~', '* `$1)` ', $doc); })->processMethodSignature(function (\ReflectionMethod $m, $text) { return str_replace('#### *public* ', '* `', $text) . '`'; })->processMethodDocBlock(function (\ReflectionMethod $m, $text) { return $text ? ' ' . strtok($text, "\n") : ''; })->run(); }
protected function minifyYii($entryScript) { try { ob_start(); $this->runRequest($entryScript); $_SERVER['REQUEST_URI'] = '/index.php'; $this->runRequest($entryScript, array('r' => 'post')); ob_end_clean(); } catch (CException $e) { echo $e; die; } $classes = array_merge(get_declared_classes(), get_declared_interfaces()); $results = array(); foreach ($classes as $class) { $c = new ReflectionClass($class); if (strpos($c->getFileName(), YII_PATH) === 0 && strpos($c->getFileName(), YII_PATH . DIRECTORY_SEPARATOR . 'console') !== 0) { $results[$class] = $c->getFileName(); } } $results = $this->sortByInheritance($results); $content = ''; foreach ($results as $fileName => $class) { $content .= "\n" . file_get_contents($fileName); } return $content; }
function determine_classes($file) { $c = get_declared_classes(); require_once $file; $diff = array_diff(get_declared_classes(), $c); return $diff; }
/** * Shows a dialog for creating or editing a course wizard step. * @param string $id ID of step to edit, or null if new step */ public function edit_action($id = '') { if ($id) { $title = _('Schritt bearbeiten'); $this->step = CourseWizardStepRegistry::find($id); } else { $title = _('Schritt hinzufügen'); $this->step = new CourseWizardStepRegistry(); $this->step->name = ''; $this->step->classname = ''; $this->step->number = 0; $this->step->enabled = false; $this->availableClasses = array(); foreach (get_declared_classes() as $className) { if (is_a($className, "CourseWizardStep", true) && $className !== "CourseWizardStep") { $collection = new SimpleCollection(CourseWizardStepRegistry::findBySQL("1 ORDER BY `number`")); if (!in_array($className, $collection->pluck("classname"))) { $this->availableClasses[] = $className; } } } } if (Request::isXhr()) { $this->response->add_header('X-Title', $title); } }
/** * Analyzes code coverage results collected from XDebug, and performs coverage density analysis. * * @param object $report The report instance running this filter and aggregating results * @param array $classes A list of classes to analyze coverage on. By default, gets all * defined subclasses of lithium\test\Unit which are currently in memory. * @return array|void Returns an array indexed by file and line, showing the number of * instances each line was called. */ public static function analyze($report, array $classes = array()) { $data = static::collect($report->results['filters'][__CLASS__]); $classes = $classes ?: array_filter(get_declared_classes(), function ($class) use($data) { $unit = 'lithium\\test\\Unit'; return !is_subclass_of($class, $unit) || array_key_exists($class, $data); }); $classes = array_values(array_intersect((array) $classes, array_keys($data))); $densities = $result = array(); foreach ($classes as $class) { $classMap = array($class => Libraries::path($class)); $densities += static::_density($data[$class], $classMap); } $executableLines = array(); if (!empty($classes)) { $executableLines = array_combine($classes, array_map(function ($cls) { return Inspector::executable($cls, array('public' => false)); }, $classes)); } foreach ($densities as $class => $density) { $executable = $executableLines[$class]; $covered = array_intersect(array_keys($density), $executable); $uncovered = array_diff($executable, $covered); $percentage = round(count($covered) / (count($executable) ?: 1), 4) * 100; $result[$class] = compact('class', 'executable', 'covered', 'uncovered', 'percentage'); } $result = static::collectLines($result); return $result; }
/** * Add the events defined in filename * * @param string $filename */ public function addPreloadEvents($filename, $module = false) { if ($module) { $filepath = ICMS_ROOT_PATH . "/modules/{$module}/preload/{$filename}.php"; } else { $filepath = ICMS_PRELOAD_PATH . "/{$filename}.php"; } include_once $filepath; $classname = $this->getClassName($filename); if (in_array($classname, get_declared_classes())) { $preloadItem = new $classname(); $class_methods = get_class_methods($classname); foreach ($class_methods as $method) { if (strpos($method, 'event') === 0) { $preload_event = strtolower(str_replace('event', '', $method)); $callback = array($preloadItem, $method); icms_Event::attach('icms', $preload_event, $callback); /* $preload_event_weight_define_name = strtoupper($classname) . '_' . strtoupper($preload_event); if (defined($preload_event_weight_define_name)) { $preload_event_weight = constant($preload_event_weight_define_name); $this->_preloadEventsArray[$preload_event][$preload_event_weight] = $preload_event_array; } else { $this->_preloadEventsArray[$preload_event][] = $preload_event_array; }*/ } } } }
public function scan($namespace) { $namespace = trim($namespace, "\\") . "\\"; $paths = []; foreach (spl_autoload_functions() as $loader) { if (is_array($loader) && count($loader) === 2) { if ($loader[0] instanceof ComposerLoader) { foreach ($loader[0]->getPrefixes() as $prefix => $loaderPaths) { if (strpos($prefix . "\\", $namespace) === 0) { $paths = array_merge($paths, $loaderPaths); } else { if (strpos($namespace, $prefix . "\\") === 0) { $paths = array_merge($paths, array_map(function ($path) use($namespace, $prefix) { return $path . "/" . str_replace("\\", "/", $namespace); }, $loaderPaths)); } } } } } } array_map([$this->phpLoader, "load"], $paths); return array_filter(array_merge(get_declared_classes(), get_declared_interfaces()), function ($name) use($namespace) { return stripos($name, $namespace) === 0; }); }
/** * Find fixtures classes in a given directory and load them. * * @param string $dir Directory to find fixture classes in. * @return array $fixtures Array of loaded fixture object instances */ public function loadFromDirectory($dir) { if (!is_dir($dir)) { throw new \InvalidArgumentException(sprintf('"%s" does not exist', $dir)); } $fixtures = array(); $includedFiles = array(); $iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($dir), \RecursiveIteratorIterator::LEAVES_ONLY); foreach ($iterator as $file) { if (($fileName = $file->getBasename($this->fileExtension)) == $file->getBasename()) { continue; } $sourceFile = realpath($file->getPathName()); require_once $sourceFile; $includedFiles[] = $sourceFile; } $declared = get_declared_classes(); foreach ($declared as $className) { $reflClass = new \ReflectionClass($className); $sourceFile = $reflClass->getFileName(); if (in_array($sourceFile, $includedFiles) && !$this->isTransient($className)) { $fixture = new $className(); $fixtures[] = $fixture; $this->addFixture($fixture); } } return $fixtures; }
/** * Runs the thread code and the initialized function. * * @codeCoverageIgnore Only executed in thread. */ public function run() { /* First thing we need to do is re-initialize the class autoloader. If * we don't do this first, any object of a class that was loaded after * the thread started will just be garbage data and unserializable * values (like resources) will be lost. This happens even with * thread-safe objects. */ foreach (get_declared_classes() as $className) { if (strpos($className, 'ComposerAutoloaderInit') === 0) { // Calling getLoader() will register the class loader for us $className::getLoader(); break; } } Loop\loop($loop = Loop\create(false)); // Disable signals in thread. // At this point, the thread environment has been prepared so begin using the thread. try { $channel = new ChannelledStream(new DuplexPipe($this->socket, false)); } catch (\Throwable $exception) { return; // Parent has destroyed Thread object, so just exit. } $coroutine = new Coroutine($this->execute($channel)); $coroutine->done(); $timer = $loop->timer(self::KILL_CHECK_FREQUENCY, true, function () use($loop) { if ($this->killed) { $loop->stop(); } }); $timer->unreference(); $loop->run(); }
/** * Builds the container. * @param array $parameters */ public function build($parameters = array()) { // sort array by key to generate the container name ksort($parameters); // needed for new packages installed $composerClass = array_filter(get_declared_classes(), function ($item) { if (0 === strpos($item, 'ComposerAutoloaderInit')) { return true; } }); $composerClass = array_pop($composerClass); // generate hash $parametersHash = md5(serialize($parameters) . $composerClass); $containerClass = 'Container' . $parametersHash; $isDebug = true; $file = sprintf('%s/ladybug_cache/%s.php', sys_get_temp_dir(), $parametersHash); $containerConfigCache = new ConfigCache($file, $isDebug); if (!$containerConfigCache->isFresh()) { $this->initializeContainer(); $this->loadServices(); $this->loadThemes(); $this->loadPlugins(); $this->setParameters($parameters); $this->container->compile(); $dumper = new PhpDumper($this->container); $containerConfigCache->write($dumper->dump(array('class' => $containerClass)), $this->container->getResources()); } else { require_once $file; $this->container = new $containerClass(); } }
/** * Scans a given path for valid plugin files and load them if possible. * This method should be called after everything else in the application * has been properly initialized. * @param string $path */ public function Start($path) { if (!is_dir($path)) { return; } $path = rtrim($path, "/\\") . "/"; $elements = scandir($path); foreach ($elements as $file_name) { if (is_file($path . $file_name)) { $file_parts = explode(".", $file_name, 2); if (count($file_parts) < 2) { continue; } $class_name = $file_parts[0]; $class_name_ns = "Peg\\Lib\\Plugins\\{$class_name}"; $file_extension = $file_parts[1]; if ($file_extension == "php") { include $path . $file_name; if (in_array($class_name_ns, get_declared_classes())) { $this->plugins[$class_name] = new $class_name_ns(); $this->plugins[$class_name]->name = $class_name; $this->plugins[$class_name]->path = $path . $file_name; $this->plugins[$class_name]->OnInit(); } } } } }
public function testClassLoaderLoadsFlexihashClass() { // this test is fragile when run in a grouptest/testsuite environment $this->assertFalse(in_array('Flexihash\\Exception', get_declared_classes()), 'Exception should not be declared yet'); $e = new Exception(); $this->assertTrue(in_array('Flexihash\\Exception', get_declared_classes()), 'Exception should be declared after autoload'); }
/** * {@inheritdoc} */ public function create() : ResourceNameCollection { $classes = []; $includedFiles = []; if ($this->decorated) { foreach ($this->decorated->create() as $resourceClass) { $classes[$resourceClass] = true; } } foreach ($this->paths as $path) { $iterator = new \RegexIterator(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS), \RecursiveIteratorIterator::LEAVES_ONLY), '/^.+\\.php$/i', \RecursiveRegexIterator::GET_MATCH); foreach ($iterator as $file) { $sourceFile = $file[0]; if (!preg_match('(^phar:)i', $sourceFile)) { $sourceFile = realpath($sourceFile); } require_once $sourceFile; $includedFiles[$sourceFile] = true; } } $declared = get_declared_classes(); foreach ($declared as $className) { $reflectionClass = new \ReflectionClass($className); $sourceFile = $reflectionClass->getFileName(); if (isset($includedFiles[$sourceFile]) && $this->reader->getClassAnnotation($reflectionClass, ApiResource::class)) { $classes[$className] = true; } } return new ResourceNameCollection(array_keys($classes)); }
/** * Gets the list of class names in the given directory. * * @param string $directory * * @return array */ private function getClasses($directory) { $classes = []; $directoryList = []; $includedFiles = []; $finder = new Finder(); try { $finder->in($directory)->files()->name('*.php'); } catch (\InvalidArgumentException $e) { return [[], []]; } foreach ($finder as $file) { $directoryList[$file->getPath()] = true; $sourceFile = $file->getRealpath(); if (!preg_match('(^phar:)i', $sourceFile)) { $sourceFile = realpath($sourceFile); } require_once $sourceFile; $includedFiles[$sourceFile] = true; } $declared = get_declared_classes(); foreach ($declared as $className) { $reflectionClass = new \ReflectionClass($className); $sourceFile = $reflectionClass->getFileName(); if ($reflectionClass->isAbstract()) { continue; } if (isset($includedFiles[$sourceFile])) { $classes[$className] = true; } } return [array_keys($classes), $directoryList]; }