/**
* @inheritdoc
*/
public function process(ParserInterface $parser, string $file, array $data) : array
{
if (false === array_key_exists('include', $data)) {
throw InvalidArgumentExceptionFactory::createForNoIncludeStatementInData($file);
}
$include = $data['include'];
unset($data['include']);
if (null === $include) {
return $data;
}
if (false === is_array($include)) {
throw TypeErrorFactory::createForInvalidIncludeStatementInData($include, $file);
}
foreach ($include as $includeFile) {
if (false === is_string($includeFile)) {
throw TypeErrorFactory::createForInvalidIncludedFilesInData($includeFile, $file);
}
if (0 === strlen($includeFile)) {
throw InvalidArgumentExceptionFactory::createForEmptyIncludedFileInData($file);
}
$filePathToInclude = $this->fileLocator->locate($includeFile, dirname($file));
$fileToIncludeData = $parser->parse($filePathToInclude);
if (array_key_exists('include', $fileToIncludeData)) {
$fileToIncludeData = $this->process($parser, $file, $fileToIncludeData);
}
$data = $this->dataMerger->mergeInclude($data, $fileToIncludeData);
}
return $data;
}
/**
* @param string|ValueInterface $parameterKey e.g. 'dummy_param'
*/
public function __construct($parameterKey)
{
if (false === is_string($parameterKey) && false === $parameterKey instanceof ValueInterface) {
throw TypeErrorFactory::createForInvalidParameterKey($parameterKey);
}
$this->parameterKey = $parameterKey;
}
/**
* @param string $reference
* @param object $instance
*/
public function __construct(string $reference, $instance)
{
if (false === is_object($instance)) {
throw TypeErrorFactory::createForObjectArgument($instance);
}
$this->reference = $reference;
$this->instance = $instance;
}
/**
* {@inheritdoc}
*
* @param array $data Full set of parsed data, will look for the parameter subset itself.
*/
public function denormalize(array $data) : ParameterBag
{
if (false === array_key_exists('parameters', $data) || null === ($fixturesParameters = $data['parameters'])) {
return new ParameterBag();
}
if (false === is_array($fixturesParameters)) {
throw TypeErrorFactory::createForInvalidFixtureBagParameters($fixturesParameters);
}
return new ParameterBag($fixturesParameters);
}
/**
* {@inheritDoc}
*
* @param string $file Local PHP file
*/
public function parse(string $file) : array
{
if (false === file_exists($file)) {
throw InvalidArgumentExceptionFactory::createForFileCouldNotBeFound($file);
}
$data = (include $file);
if (false === is_array($data)) {
throw TypeErrorFactory::createForInvalidFixtureFileReturnedData($file);
}
return $data;
}
/**
* @param ChainableParameterResolverInterface[] $resolvers
*/
public function __construct(array $resolvers)
{
foreach ($resolvers as $index => $resolver) {
if (false === $resolver instanceof ChainableParameterResolverInterface) {
throw TypeErrorFactory::createForInvalidChainableParameterResolver($resolver);
}
if ($resolver instanceof ParameterResolverAwareInterface) {
$resolvers[$index] = $resolver->withResolver($this);
}
}
$this->resolvers = $resolvers;
}
/**
* @param int|ValueInterface $quantifier
* @param string|ValueInterface $element
*/
public function __construct($quantifier, $element)
{
if ($quantifier instanceof ValueInterface) {
$quantifier = clone $quantifier;
} elseif (false === is_int($quantifier)) {
throw TypeErrorFactory::createForDynamicArrayQuantifier($quantifier);
}
if (false === is_string($element) && false === is_array($element) && false === $element instanceof ValueInterface) {
throw TypeErrorFactory::createForDynamicArrayElement($element);
}
$this->quantifier = $quantifier;
$this->element = deep_clone($element);
}
/**
* @param FlagParserInterface $flagParser
* @param ChainableFixtureDenormalizerInterface[] $denormalizers
*/
public function __construct(FlagParserInterface $flagParser, array $denormalizers)
{
foreach ($denormalizers as $index => $denormalizer) {
if (false === $denormalizer instanceof ChainableFixtureDenormalizerInterface) {
throw TypeErrorFactory::createForInvalidDenormalizerType($index, $denormalizer);
}
if ($denormalizer instanceof FixtureDenormalizerAwareInterface) {
$denormalizer = $denormalizer->withFixtureDenormalizer($this);
}
if ($denormalizer instanceof FlagParserAwareInterface) {
$denormalizer = $denormalizer->withFlagParser($flagParser);
}
$this->denormalizers[] = $denormalizer;
}
}
/**
* @param int|ValueInterface $quantifier
* @param string|ValueInterface $firstMember
* @param string|ValueInterface|null $secondMember
*/
public function __construct($quantifier, $firstMember, $secondMember = null)
{
if ($quantifier instanceof ValueInterface) {
$quantifier = clone $quantifier;
} elseif (is_scalar($quantifier)) {
$quantifier = (int) $quantifier;
} else {
throw TypeErrorFactory::createForOptionalValueQuantifier($quantifier);
}
if (false === is_string($firstMember) && false === $firstMember instanceof ValueInterface) {
throw TypeErrorFactory::createForOptionalValueFirstMember($firstMember);
}
if (null !== $secondMember && false === is_string($secondMember) && false === $secondMember instanceof ValueInterface) {
throw TypeErrorFactory::createForOptionalValueSecondMember($secondMember);
}
$this->quantifier = $quantifier;
$this->firstMember = $firstMember;
$this->secondMember = $secondMember;
}
private function denormalizeCallMethod(CallsDenormalizerInterface $callsDenormalizer, $methodCall, FixtureInterface $scope, FlagParserInterface $parser) : MethodCallInterface
{
if (false === is_array($methodCall)) {
throw TypeErrorFactory::createForInvalidSpecificationBagMethodCall($methodCall);
}
$unparsedMethod = key($methodCall);
if (false === is_string($unparsedMethod)) {
throw TypeErrorFactory::createForInvalidSpecificationBagMethodCallName($unparsedMethod);
}
return $callsDenormalizer->denormalize($scope, $parser, $unparsedMethod, $methodCall[$unparsedMethod]);
}
