/** * The Constructor. * * @param mixed $reference An instance or a fully-namespaced class name. */ public function __construct($reference) { $reference = $this->_reference($reference); $isString = is_string($reference); if ($isString) { if (!class_exists($reference)) { throw new InvalidArgumentException("Can't Stub the unexisting class `{$reference}`."); } $reference = ltrim($reference, '\\'); $reflection = Inspector::inspect($reference); } else { $reflection = Inspector::inspect(get_class($reference)); } if (!$reflection->isInternal()) { $this->_reference = $reference; return; } if (!$isString) { throw new InvalidArgumentException("Can't Stub built-in PHP instances, create a test double using `Double::instance()`."); } $this->_needToBePatched = true; return $this->_reference = $reference; }
/** * Gets the parameters array of a class method. * * @param $class The class name. * @param $method The method name. * @param $data The default values. * @return array The parameters array. */ public static function parameters($class, $method, $data = null) { $params = []; $reflexion = Inspector::inspect($class); $parameters = $reflexion->getMethod($method)->getParameters(); if ($data === null) { return $parameters; } foreach ($data as $key => $value) { $name = $key; if ($parameters) { $parameter = array_shift($parameters); $name = $parameter->getName(); } $params[$name] = $value; } foreach ($parameters as $parameter) { if ($parameter->isDefaultValueAvailable()) { $params[$parameter->getName()] = $parameter->getDefaultValue(); } } return $params; }
<?php namespace kahlan\spec\suite\analysis; use kahlan\analysis\Inspector; describe("Inspector", function () { before(function () { $this->class = 'kahlan\\spec\\fixture\\analysis\\SampleClass'; }); describe('::inspect()', function () { it("gets the reflexion layer of a class", function () { $inspector = Inspector::inspect($this->class); expect($inspector)->toBeAnInstanceOf('ReflectionClass'); expect($inspector->name)->toBe($this->class); }); }); describe('::parameters()', function () { it("gets method's parameters details", function () { $inspector = Inspector::parameters($this->class, 'parametersExample'); expect($inspector)->toBeA('array'); $param2 = next($inspector); expect($param2)->toBeAnInstanceOf('ReflectionParameter'); expect($param2->getName())->toBe('b'); expect($param2->getDefaultValue())->toBe(100); $param3 = next($inspector); expect($param3)->toBeAnInstanceOf('ReflectionParameter'); expect($param3->getName())->toBe('c'); expect($param3->getDefaultValue())->toBe('abc'); $param4 = next($inspector); expect($param4)->toBeAnInstanceOf('ReflectionParameter'); expect($param4->getName())->toBe('d');
/** * Creates method definitions from an interface array. * * @param array $interfaces A array on interfaces. * @param integer $mask The method mask to filter. * @return string The generated methods. */ protected static function _generateInterfaceMethods($interfaces, $mask = 255) { if (!$interfaces) { return []; } $result = []; foreach ((array) $interfaces as $interface) { if (!interface_exists($interface)) { throw new MissingImplementationException("Unexisting interface `{$interface}`"); } $reflection = Inspector::inspect($interface); $methods = $reflection->getMethods($mask); foreach ($methods as $method) { $result[$method->getName()] = static::_generateMethod($method); } } return $result; }
/** * Check the actual value can receive messages. * * @param mixed $reference An instance or a fully-namespaced class name. */ protected function _check($reference) { $isString = is_string($reference); if ($isString) { if (!class_exists($reference)) { throw new InvalidArgumentException("Can't Spy the unexisting class `{$reference}`."); } $reflection = Inspector::inspect($reference); } else { $reflection = Inspector::inspect(get_class($reference)); } if (!$reflection->isInternal()) { return; } if (!$isString) { throw new InvalidArgumentException("Can't Spy built-in PHP instances, create a test double using `Double::instance()`."); } }