/** * @return \Twig_Function|\Twig_SimpleFunction */ public function getNativeInstance() { if (Inspect::useClass('\\Twig_Function')->isAbstract()) { return new \Twig_SimpleFunction($this->name, $this->callable, $this->options->toArray()); } return new \Twig_Function($this->name, $this->callable, $this->options->toArray()); }
/** * @param string $data */ public function unserialize($data) { $properties = (array) Serializer::create(Serializer::TYPE_IGBINARY)->unserialize($data); foreach ($properties as $name => $value) { Inspect::this($this)->getProperty($name)->setValue($this, $value); } }
/** * @param mixed $style */ public function __construct($style) { $this->style = $style; $this->input = $style->getInput(); $this->output = $style->getOutput(); $this->inspect = Inspect::thisInstance($style); }
/** * @param string $method * @param string $class * * @return bool|\Closure */ private static function isValidMethod($method, $class) { $inspect = Inspect::thisClass($class); if ($inspect->hasMethod($method) && $inspect->getMethod($method)->visibilityPublic()) { return true; } return function () use($method, $class) { Context::get()->getOutput()->writeln(sprintf('[WARNING] Request task "%s::%s" could not be found.', $class, $method)); }; }
public function testSetAndGetAndClearFilters() { $callable = function () { return 'test-callable'; }; $extension = new TwigExtension(); $extension->addFilter('test', $callable); if (Inspect::useClass('\\Twig_Filter')->isAbstract()) { $this->assertInstanceOf('\\Twig_SimpleFilter', $extension->getFilters()[0]); } else { $this->assertInstanceOf('\\Twig_Filter', $extension->getFilters()[0]); } $extension->clearFilters(); $this->assertCount(0, $extension->getFilters()); }
public function testLongWordsBlockWrapping() { $word = 'Lopadotemachoselachogaleokranioleipsanodrimhypotrimmatosilphioparaomelitokatakechymenokichlepikossyphophattoperisteralektryonoptekephalliokigklopeleiolagoiosiraiobaphetraganopterygon'; $wordLength = strlen($word); $style = $this->getStyle(); $inspect = Inspect::this($style); $property = $inspect->getProperty('lineLengthMax'); $maxLineLength = $property->value($style) - 3; $this->command->setCode(function (InputInterface $input, OutputInterface $output) use($word) { $sfStyle = new StyleWithForcedLineLength($input, $output); $sfStyle->block($word, 'CUSTOM', 'fg=white;bg=blue', ' § ', false); }); $this->tester->execute(array(), array('interactive' => false, 'decorated' => false)); $expectedCount = (int) ceil($wordLength / $maxLineLength) + (int) ($wordLength > $maxLineLength - 5); $this->assertSame($expectedCount, substr_count($this->tester->getDisplay(true), ' § ')); }
public function testInitializeMethods() { $className = 'SR\\Doctrine\\ORM\\Mapping\\Tests\\Fixture\\IdEntity'; $instance = new $className(false); $this->assertNull($instance->getAString()); $this->assertNull($instance->getAnInt()); $this->assertNull($instance->getAnArray()); $instance->__construct(true); $this->assertNotNull($instance->getAString()); $this->assertSame('aString', $instance->getAString()); $this->assertNotNull($instance->getAnInt()); $this->assertNotNull($instance->getAnArray()); $aStringProperty = Inspect::thisInstance($instance)->matchOneProperty('aString', 'nameUnQualified'); $aStringProperty->setValue($instance, 'aStringValueSetViaReflection'); $instance->__construct(); $this->assertSame('aStringValueSetViaReflection', $instance->getAString()); }
/** * @param Entity $compareTo * * @return bool */ public final function isEqualTo(Entity $compareTo) { $propertiesSelfNorm = []; $propertiesCompNorm = []; $propertiesSelf = Inspect::thisInstance($this)->properties(); $propertiesComp = Inspect::thisInstance($compareTo)->properties(); $visitor = function (array $properties, array &$normalized, $bind) { foreach ($properties as $property) { $normalized[$property->name()] = $property->value($bind); } }; $visitor($propertiesSelf, $propertiesSelfNorm, $this); $visitor($propertiesComp, $propertiesCompNorm, $compareTo); ksort($propertiesSelfNorm); ksort($propertiesCompNorm); return $propertiesSelfNorm === $propertiesCompNorm; }
/** * @return \SR\Reflection\Inspector\ConstantInspector[] */ private function getLogLevelConstants() { return Inspect::useInstance($this)->constants(); }
/** * @param string $search * @param null|Entity $entity * * @return null|PropertyIntrospection */ protected final function findProperty($search, Entity $entity = null) { $_ = function (PropertyIntrospection $p, $index) use($search) { return $p->nameUnQualified() === $search; }; return Inspect::thisInstance($entity ?: $this)->filterOneProperty($_, null); }
public function testBindTo() { $object = FixtureClassOne::class; $method = Inspect::useClass($object, $fixture = new FixtureClassOne()); $result = $method->visitConstants(function (ConstantInspector $const) use($object) { return $this->protectedOne0($const->value()) . '---' . $const->name(); }); $this->assertGreaterThan(3, $result); foreach ($result as $r) { $this->assertNotFalse(strpos($r, 'propProtectedOne0') !== false); $this->assertNotFalse(strpos($r, 'ONE_') !== false || strpos($r, 'NULL_') !== false); } }
/** * Validate the requested object instance or class name exists. * * @param string|object $object The object instance or class name * @param bool $static Whether this is a static call or not * * @internal * * @throws BadFunctionCallException * * @return string|object */ private static function validateClass($object, $static) { try { $class = Inspect::using($object)->nameQualified(); } catch (\Exception $e) { throw BadFunctionCallException::create()->setMessage('Could not validate call class (got "%s" with message "%s").', var_export($object, true), $e->getMessage()); } return $static ? $class : $object; }
public function testFindPropertySet() { $class = 'SR\\Doctrine\\ORM\\Mapping\\Tests\\Fixture\\EntityA'; $instance = new $class(); $findPropertySetMethod = Inspect::thisInstance($instance)->getMethod('findPropertySet'); $properties = $findPropertySetMethod->invoke($instance, '{^property}', true); $this->assertCount(3, $properties); }
/** * @param \PHPUnit_Framework_MockObject_MockObject $entity * @param string $initializeMethod */ private function initializerCall(\PHPUnit_Framework_MockObject_MockObject $entity, $initializeMethod) { $inspector = Inspect::thisInstance($entity); try { $method = $inspector->getMethod($initializeMethod); } catch (InvalidArgumentException $e) { $initializeMethod = $initializeMethod; $method = $inspector->getMethod($initializeMethod); } $method->invoke($entity); }
/** * The attendants are designated their "type" using the class names of the respective object. Although * fully-qualified names can be (and are) used, this implementation does take the assuption that the * base names of the implementations does not overlap. * * @param bool $qualified * * @return string */ public function getType($qualified = false) { return Inspect::useInstance($this)->name($qualified); }
/** * @param bool $qualified * @param null|object $instance * * @return string */ public final function getParentName($qualified = false, $instance = null) { return Inspect::this(get_parent_class($instance))->name($qualified); }