Example #1
0
 public function __construct(Nette\Loaders\RobotLoader $robotLoader)
 {
     $classes = $robotLoader->getIndexedClasses();
     foreach ($classes as $class => $file) {
         if (class_exists($class)) {
             $reflection = new \Nette\Reflection\ClassType($class);
             if ($reflection->implementsInterface('Tatami\\Modules\\IModule')) {
                 if (!($reflection->isAbstract() or $reflection->isInterface())) {
                     $this->modules[] = $this->parseModuleName($reflection->getShortName());
                 }
             }
             if ($reflection->isSubclassOf('Tatami\\Presenters\\BackendPresenter')) {
                 $moduleName = $this->parseModuleName($reflection->getNamespaceName());
                 $presenterName = $this->parsePresenterName($reflection->getShortName());
                 $this->presenters[$moduleName][] = $presenterName;
                 $methods = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);
                 foreach ($methods as $method) {
                     if (Strings::match($method->name, '/action/') or Strings::match($method->name, '/render/')) {
                         $this->actions[$presenterName][] = $this->parseActionName($method->name);
                     }
                 }
             }
             unset($reflection);
         }
     }
 }
Example #2
0
 private function getEntities()
 {
     $entities = array();
     foreach ($this->loadedClasses as $class => $file) {
         $reflection = new \Nette\Reflection\ClassType($class);
         $namespace = $reflection->getNamespaceName();
         if ($reflection->getNamespaceName() == 'Entity') {
             $entities[] = $class;
         }
     }
     return $entities;
 }
Example #3
0
 public function load($class)
 {
     $meta = array();
     $ref = new \Nette\Reflection\ClassType($class);
     do {
         foreach ($ref->getProperties() as $property) {
             $m = $this->processProperty($property);
             if ($m) {
                 $meta[$m->name] = $m;
             }
         }
         $ref = $ref->getParentClass();
     } while ($ref);
     return $meta;
 }
Example #4
0
 /**
  * Find test suits to run
  * 
  * @param string $folder Where to look
  * @return string[]
  */
 protected function findSuits($folder)
 {
     $suits = [];
     $robot = new \Nette\Loaders\RobotLoader();
     $robot->setCacheStorage(new \Nette\Caching\Storages\DevNullStorage());
     $robot->addDirectory($folder);
     $robot->acceptFiles = "*.phpt";
     $robot->rebuild();
     $robot->register();
     $classes = $robot->getIndexedClasses();
     foreach ($classes as $class => $file) {
         $rc = new \Nette\Reflection\ClassType($class);
         if (!$rc->isAbstract() and $rc->isSubclassOf(TestCase::class)) {
             $suits[] = [$rc->getName(), $file];
         }
     }
     return $suits;
 }
Example #5
0
 /**
  * Browse methods for autowire
  * @param ServiceDefinition $definition
  */
 protected function extendAutowire(ServiceDefinition $definition)
 {
     if (!$definition->autowired) {
         return;
     }
     if ($definition->class) {
         $reflection = new \Nette\Reflection\ClassType($definition->class);
     } elseif ($definition->factory) {
         try {
             $reflection = new \Nette\Reflection\ClassType($definition->factory->entity);
         } catch (\ReflectionException $e) {
             return;
         }
     } else {
         return;
     }
     if ($method = $reflection->getConstructor()) {
         $this->autowireParams($definition, $method);
     }
     return;
 }
Example #6
0
 /**
  * Creates method list
  * (may take a time..)
  *
  * @return array
  */
 public function createMethodList()
 {
     /** @var $robotLoader RobotLoader */
     $robotLoader = $this->context->getService('robotLoader');
     foreach ($robotLoader->getIndexedClasses() as $class => $file) {
         if (Strings::match($file, "~\\Nette~")) {
             continue;
         }
         $creflection = new Nette\Reflection\ClassType($class);
         foreach ($creflection->getMethods() as $method) {
             $mreflection = new Method($class, $method->getName());
             if ($mreflection->hasAnnotation('cron')) {
                 $m = new stdClass();
                 $m->name = $mreflection->getName();
                 $m->class = $mreflection->getDeclaringClass()->getName();
                 $m->annotations = $mreflection->getAnnotations();
                 $this->methods[] = $m;
             }
         }
     }
     return $this->methods;
 }
Example #7
0
 private function findModules()
 {
     if ($this->cache->offsetExists('modules')) {
         $modules = $this->cache->offsetGet('modules');
     } else {
         $classes = $this->robotLoader->getIndexedClasses();
         $modules = array();
         foreach ($classes as $class => $file) {
             if (class_exists($class)) {
                 $reflection = new \Nette\Reflection\ClassType($class);
                 if ($reflection->implementsInterface('Tatami\\Modules\\IModule')) {
                     if (!($reflection->isAbstract() or $reflection->isInterface())) {
                         $module = new $class();
                         $modules[$module->getName()] = $module;
                     }
                 }
                 unset($reflection);
             }
         }
         $this->cache->offsetSet('modules', $modules);
     }
     return $modules;
 }
Example #8
0
	/**
	 * Adding method to class
	 *
	 * @param string  method name
	 * @param mixed   callback or closure
	 * @return mixed
	 */
	public static function extensionMethod($name, $callback = NULL)
	{
		if (strpos($name, '::') === FALSE) {
			$class = get_called_class();
		} else {
			list($class, $name) = explode('::', $name);
		}
		$class = new \Nette\Reflection\ClassType($class);
		if ($callback === NULL) {
			return $class->getExtensionMethod($name);
		} else {
			$class->setExtensionMethod($name, $callback);
		}
	}
Example #9
0
 /**
  * Get name of current test suit
  * 
  * @return string
  */
 protected function getSuitName()
 {
     $suitName = get_class($this);
     $r = new \Nette\Reflection\ClassType($suitName);
     if ($r->hasAnnotation("testSuit")) {
         $suitName = (string) $r->getAnnotation("testSuit");
     }
     return $suitName;
 }
Example #10
0
 /**
  * @param  string   destination in format "[[module:]presenter:]action" or "signal!" or "this"
  * @param  array|mixed
  * @return bool
  */
 public function isAuthorized($destination)
 {
     if ($destination == 'this') {
         $class = get_class($this);
         $action = $this->action;
     } elseif (substr($destination, -1, 1) == '!') {
         $class = get_class($this);
         $action = $this->action;
         $do = substr($destination, 0, -1);
     } elseif (ctype_lower(substr($destination, 0, 1))) {
         $class = get_class($this);
         $action = $destination;
     } else {
         if (substr($destination, 0, 1) === ':') {
             $link = substr($destination, 1);
             $link = substr($link, 0, strrpos($link, ':'));
             $action = substr($destination, strrpos($destination, ':') + 1);
         } else {
             $link = substr($this->name, 0, strrpos($this->name, ':'));
             $link = $link . ($link ? ':' : '') . substr($destination, 0, strrpos($destination, ':'));
             $action = substr($destination, strrpos($destination, ':') + 1);
         }
         $action = $action ?: 'default';
         $presenterFactory = $this->getApplication()->getPresenterFactory();
         $class = $presenterFactory->getPresenterClass($link);
     }
     $schema = $this->controlVerifier->getControlVerifierReader()->getSchema($class);
     if (isset($schema['action' . ucfirst($action)])) {
         $classReflection = new \Nette\Reflection\ClassType($class);
         $method = $classReflection->getMethod('action' . ucfirst($action));
         try {
             $this->controlVerifier->checkRequirements($method);
         } catch (ForbiddenRequestException $e) {
             return FALSE;
         }
     }
     if (isset($do) && isset($schema['handle' . ucfirst($do)])) {
         $classReflection = new \Nette\Reflection\ClassType($class);
         $method = $classReflection->getMethod('handle' . ucfirst($do));
         try {
             $this->controlVerifier->checkRequirements($method);
         } catch (ForbiddenRequestException $e) {
             return FALSE;
         }
     }
     return TRUE;
 }
Example #11
0
 public function createComponent($name)
 {
     //$templates = array();
     $chunks = explode('/', $this->pageManagerService->getCurrentModule());
     array_walk($chunks, function ($val, $key) use(&$chunks) {
         $chunks[$key] .= 'Module';
     });
     $nsPrefixes = array();
     for ($i = count($chunks); $i > 0; $i--) {
         $t = array_slice($chunks, 0, $i);
         $nsPrefixes[] = implode("\\", $t);
     }
     if (preg_match('([a-zA-Z0-9]+Form)', $name)) {
         $classname = $this->_getExistingClass($nsPrefixes, "\\Forms\\" . ucfirst($name));
         if (class_exists($classname)) {
             $control = new $classname($this, $name);
             return $control;
         }
     } else {
         if (preg_match('([a-zA-Z0-9]+Menu)', $name)) {
             //dump($nsPrefixes);
             $classname = $this->_getExistingClass($nsPrefixes, "\\Components\\PageMenus\\" . ucfirst($name));
             //dump($classname);
             if (class_exists($classname)) {
                 $control = new $classname($this, $name, $this->lang ?: $this->langManagerService->getDefaultLanguage());
                 return $control;
             }
         } else {
             if (preg_match('([a-zA-Z0-9]+Tabs)', $name)) {
                 //$classname = $nsPrefix."\\Components\\PageTabs\\" . ucfirst($name);
                 $classname = $this->_getExistingClass($nsPrefixes, "\\Components\\PageTabs\\" . ucfirst($name));
                 if (class_exists($classname)) {
                     $control = new $classname($this, $name, $this->lang ?: $this->langManagerService->getDefaultLanguage());
                     return $control;
                 }
             } else {
                 if (preg_match('([a-zA-Z0-9]+Gallery)', $name)) {
                     //$classname = $nsPrefix."\\Components\\Galleries\\" . ucfirst($name);
                     $classname = $this->_getExistingClass($nsPrefixes, "\\Components\\Galleries\\" . ucfirst($name));
                     if (class_exists($classname)) {
                         $control = new $classname();
                         return $control;
                     }
                     $classname = "FrontModule\\Components\\Galleries\\" . ucfirst($name);
                     if (class_exists($classname)) {
                         $control = new $classname();
                         return $control;
                     }
                 } else {
                     // generic facotry for components with default constructor
                     // public function __construct($parent, $name)
                     $classname = $this->_getExistingClass($nsPrefixes, "\\Components\\" . ucfirst($name));
                     //            dump($classname);
                     //            die();
                     if ($classname !== NULL) {
                         $class = new \Nette\Reflection\ClassType($classname);
                         $constructor = $class->getConstructor();
                         $constructorParams = $constructor->getParameters();
                         if (count($constructorParams) == 2 && $constructorParams[0]->name == 'parent' && $constructorParams[1]->name == 'name') {
                             $control = new $classname($this, $name);
                             return $control;
                         }
                     }
                 }
             }
         }
     }
     return parent::createComponent($name);
 }
Example #12
0
    private function renderTestResult($testClass, $test_results)
    {
        $outputsNumber = 0;
        // vykreslení tabulky s testy
        ob_start();
        $results = array('Total' => 0, 'Pass' => 0, 'Fail' => 0, 'Error' => 0, 'NRY' => 0, 'Skip' => 0);
        $classAnnotation = new \Nette\Reflection\ClassType($testClass);
        ?>
		<table cellspacing="0" class="test_results" border=1>
		  <thead>
			 <tr><th>Result</th><th>Name</th><th title="count of assertions">Asserts<br>Count</th><th title="msec">Time<br>in ms</th><th>Output</th></tr>
		  </thead>
		  <tbody>

		  <?php 
        foreach ($test_results as $test_result) {
            if (!is_array($test_result) || !isset($test_result['result'])) {
                continue;
            }
            $result = $test_result['result'];
            if (!isset($results[$result])) {
                echo "Unknown result type \"{$result}\", please modify MyTestRunner.php";
                $results[$result] = 0;
            }
            $results[$result]++;
            $results['Total']++;
            ?>

		  <tr>
				<?php 
            if ($test_result['result'] === 'Fail') {
                ?>
					<td class="result test_fail"/><?php 
                echo strtoupper($test_result['result']);
                ?>
</td>
				<?php 
            } elseif ($test_result['result'] == 'Pass') {
                ?>
					<td class="result test_pass"/><?php 
                echo strtoupper($test_result['result']);
                ?>
</td>
				<?php 
            } else {
                ?>
					<td class="result test_other"/><?php 
                echo strtoupper($test_result['result']);
                ?>
</td>
				<?php 
            }
            ?>
				<td style="text-align:left;"><?php 
            $cmethod = $methodName = $test_result['name'];
            if (strpos($methodName, ' ')) {
                $cmethod = substr($methodName, 0, strpos($methodName, ' '));
            }
            $method = $classAnnotation->getMethod($cmethod);
            $editLink = $this->createEditLink($method->fileName, $method->startLine);
            echo "<a title=\"{$method}\" href=\"{$editLink}\">" . $this->translateTestName($methodName) . "</a>";
            ?>
				<?php 
            if ($test_result['message']) {
                $message = trim($test_result['message']);
                $message = $this->enhanceMessageWithLinks($message);
                $this->displayPreMessage($message);
            }
            ?>
				</td>
				<td>
					<?php 
            echo $test_result['assertions'];
            ?>
				</td>
				<td>
					<?php 
            echo round(1000 * $test_result['time'], 1);
            ?>
				</td>
				<?php 
            if (isset($test_result['output'])) {
                $output = $test_result['output'];
                if (!empty($output)) {
                    $outputsNumber++;
                }
            } else {
                $output = '';
            }
            ?>
				<td class="output"><?php 
            $this->displayPreMessage($output);
            ?>
</td>
		  </tr>
		  <?php 
        }
        ?>
		  </tbody>
		</table>

		<?php 
        $table = ob_get_clean();
        //vykreslení hlavičky testu
        $fileName = $classAnnotation->fileName;
        $editLink = $this->createEditLink($fileName);
        if ($results['Total'] !== $results['Pass'] + $results['NRY'] + $results['Skip']) {
            $errtxt = $results['Fail'] === 0 ? 'ERRORS' : 'FAILED';
            $cssClass = "fail";
            $cssStyle = "color:red;font-weight:bold;";
            $display = "block";
        } else {
            $errtxt = "PASSED";
            $cssClass = "passed";
            $cssStyle = "color:green;font-weight:bold;";
            $display = "none";
        }
        $detail = "{$results['Total']}<span style=\"color:green\"> / {$results['Pass']}<span> / <span style=\"color:red\">{$results['Fail']}</span>";
        $detail .= "<span style=\"color:black\">";
        if ($results['Skip'] > 0) {
            $detail .= " Skipped: {$results['Skip']}";
        }
        if ($results['NRY'] > 0) {
            $detail .= " / {$results['NRY']}";
        }
        $detail .= "</span>";
        $htmlClass = str_replace('\\', '-', $testClass);
        echo "<div class=\"{$cssClass}\">";
        //class links
        $this->renderClassHeader($classAnnotation);
        //result numbers
        echo "<span style=\"{$cssStyle}\">&nbsp&nbsp;&nbsp;{$errtxt}&nbsp;</span> {$detail} ";
        if ($outputsNumber > 0) {
            echo "<span class=\"outputs\">tests with output: <span style=\"color:yellow;\">{$outputsNumber}</span></span>";
            //$display =' block';
        }
        //collapsing
        echo "<a href=\"#\" onClick=\"javascript:return toggle('{$htmlClass}');\">&#x25ba;</a>";
        echo "</div>";
        echo "<div style=\"display:{$display}\"id=\"{$htmlClass}\">{$table}</div>";
        return $results;
    }
Example #13
0
 /**
  * Get path to child plugin class
  *
  * @return string
  */
 private static function getPluginDir()
 {
     $reflection = new \Nette\Reflection\ClassType(get_called_class());
     return dirname($reflection->getFilename());
 }