/**
  * @param RuntimeConfiguration $configuration
  *
  * @return NewOperator
  */
 public function generate(RuntimeConfiguration $configuration)
 {
     $this->typeCheck->generate(func_get_args());
     $validatorNamespaceCall = new Call(new StaticMember(QualifiedIdentifier::fromString('\\Eloquent\\Cosmos\\ClassName'), new Constant(new Identifier('fromString'))));
     $validatorNamespaceCall->add(new Literal($configuration->validatorNamespace()->string()));
     $newConfigurationCall = new Call(QualifiedIdentifier::fromString('\\Eloquent\\Typhoon\\Configuration\\RuntimeConfiguration'));
     $newConfigurationCall->add($validatorNamespaceCall);
     $newConfigurationCall->add(new Literal($configuration->useNativeCallable()));
     return new NewOperator($newConfigurationCall);
 }
Ejemplo n.º 2
0
 /**
  * @param RuntimeConfiguration $configuration
  * @param null                 &$className
  *
  * @return SyntaxTree
  */
 public function generateSyntaxTree(RuntimeConfiguration $configuration, &$className = null)
 {
     $this->typeCheck->generateSyntaxTree(func_get_args());
     $className = $configuration->validatorNamespace()->joinAtoms('DummyValidator');
     $classDefinition = new ClassDefinition(new Identifier($className->shortName()->string()));
     $classDefinition->setParentName(QualifiedIdentifier::fromString('AbstractValidator'));
     $classDefinition->add($this->generateCallMethod());
     $primaryBlock = new PhpBlock();
     $primaryBlock->add(new NamespaceStatement(QualifiedIdentifier::fromString($className->parent()->toRelative()->string())));
     $primaryBlock->add($classDefinition);
     $syntaxTree = new SyntaxTree();
     $syntaxTree->add($primaryBlock);
     return $syntaxTree;
 }
 /**
  * @param RuntimeConfiguration $configuration
  * @param null                 &$className
  *
  * @return SyntaxTree
  */
 public function generateSyntaxTree(RuntimeConfiguration $configuration, &$className = null)
 {
     $this->typeCheck->generateSyntaxTree(func_get_args());
     $className = $configuration->validatorNamespace()->joinAtoms('Exception', 'UnexpectedInputException');
     $classDefinition = new ClassDefinition(new Identifier($className->shortName()->string()), ClassModifier::ABSTRACT_());
     $classDefinition->setParentName(QualifiedIdentifier::fromString('\\InvalidArgumentException'));
     $classDefinition->add($this->generateConstructor());
     $primaryBlock = new PhpBlock();
     $primaryBlock->add(new NamespaceStatement(QualifiedIdentifier::fromString($className->parent()->toRelative()->string())));
     $primaryBlock->add($classDefinition);
     $syntaxTree = new SyntaxTree();
     $syntaxTree->add($primaryBlock);
     return $syntaxTree;
 }
Ejemplo n.º 4
0
 /**
  * @param string        $outputPath
  * @param array<string> $sourcePaths
  */
 public function __construct($outputPath, array $sourcePaths)
 {
     $this->typeCheck = TypeCheck::get(__CLASS__, func_get_args());
     parent::__construct();
     $this->setOutputPath($outputPath);
     $this->setSourcePaths($sourcePaths);
     $this->loaderPaths = array('vendor/autoload.php');
 }
 /**
  * @param RuntimeConfiguration $configuration
  * @param null                 &$className
  *
  * @return SyntaxTree
  */
 public function generateSyntaxTree(RuntimeConfiguration $configuration, &$className = null)
 {
     $this->typeCheck->generateSyntaxTree(func_get_args());
     $className = $configuration->validatorNamespace()->joinAtoms('Exception', 'MissingArgumentException');
     $classDefinition = new ClassDefinition(new Identifier($className->shortName()->string()), ClassModifier::FINAL_());
     $classDefinition->setParentName(QualifiedIdentifier::fromString('UnexpectedInputException'));
     $classDefinition->add($this->generateConstructor());
     $classDefinition->add($this->generateParameterNameMethod());
     $classDefinition->add($this->generateIndexMethod());
     $classDefinition->add($this->generateExpectedTypeMethod());
     $classDefinition->add(new Property(new Identifier('parameterName'), AccessModifier::PRIVATE_()));
     $classDefinition->add(new Property(new Identifier('index'), AccessModifier::PRIVATE_()));
     $classDefinition->add(new Property(new Identifier('expectedType'), AccessModifier::PRIVATE_()));
     $primaryBlock = new PhpBlock();
     $primaryBlock->add(new NamespaceStatement(QualifiedIdentifier::fromString($className->parent()->toRelative()->string())));
     $primaryBlock->add($classDefinition);
     $syntaxTree = new SyntaxTree();
     $syntaxTree->add($primaryBlock);
     return $syntaxTree;
 }
Ejemplo n.º 6
0
 /**
  * @param RuntimeConfiguration $configuration
  * @param null                 &$className
  *
  * @return SyntaxTree
  */
 public function generateSyntaxTree(RuntimeConfiguration $configuration, &$className = null)
 {
     $this->typeCheck->generateSyntaxTree(func_get_args());
     $className = $configuration->validatorNamespace()->joinAtoms('TypeInspector');
     $classDefinition = new ClassDefinition(new Identifier($className->shortName()->string()));
     $classDefinition->add($this->generateTypeMethod());
     $classDefinition->add($this->generateArrayTypeMethod());
     $classDefinition->add($this->generateObjectTypeMethod());
     $classDefinition->add($this->generateTraversableSubTypesMethod());
     $classDefinition->add($this->generateResourceTypeMethod());
     $classDefinition->add($this->generateStreamTypeMethod());
     $primaryBlock = new PhpBlock();
     $primaryBlock->add(new NamespaceStatement(QualifiedIdentifier::fromString($className->parent()->toRelative()->string())));
     $primaryBlock->add($classDefinition);
     $syntaxTree = new SyntaxTree();
     $syntaxTree->add($primaryBlock);
     return $syntaxTree;
 }
Ejemplo n.º 7
0
 /**
  * @param RuntimeConfiguration $configuration
  *
  * @return boolean
  */
 public function useNativeCallable(RuntimeConfiguration $configuration)
 {
     $this->typeCheck->useNativeCallable(func_get_args());
     return $configuration->useNativeCallable() && $this->nativeCallableAvailable();
 }
Ejemplo n.º 8
0
 /**
  * @param RuntimeConfiguration $configuration
  *
  * @return ConcreteMethod
  */
 protected function generateCreateValidatorMethod(RuntimeConfiguration $configuration)
 {
     $this->typeCheck->generateCreateValidatorMethod(func_get_args());
     $classNameIdentifier = new Identifier('className');
     $classNameVariable = new Variable($classNameIdentifier);
     $validatorClassNameVariable = new Variable(new Identifier('validatorClassName'));
     $method = new ConcreteMethod(new Identifier('createValidator'), AccessModifier::PROTECTED_(), true);
     $method->addParameter(new Parameter($classNameIdentifier));
     $validatorClassNameConcatenation = new Concat(new Literal(sprintf('%s\\', $configuration->validatorNamespace()->joinAtoms('Validator')->string())), $classNameVariable);
     $validatorClassNameConcatenation->add(new Literal('TypeCheck'));
     $method->statementBlock()->add(new ExpressionStatement(new Assign($validatorClassNameVariable, $validatorClassNameConcatenation)));
     $staticConstant = new Constant(new Identifier('static'));
     $runtimeGenerationCall = new Call(new StaticMember($staticConstant, new Constant(new Identifier('runtimeGeneration'))));
     $classExistsCall = new Call(QualifiedIdentifier::fromString('\\class_exists'));
     $classExistsCall->add($validatorClassNameVariable);
     $runtimeGenerationIf = new IfStatement(new LogicalAnd($runtimeGenerationCall, new LogicalNot($classExistsCall)));
     $staticDummyModeVariable = new StaticMember($staticConstant, new Variable(new Identifier('dummyMode')));
     $runtimeGenerationIf->trueBranch()->add(new ExpressionStatement(new Assign($staticDummyModeVariable, new Literal(true))));
     $defineValidatorCall = new Call(new StaticMember($staticConstant, new Constant(new Identifier('defineValidator'))));
     $defineValidatorCall->add($classNameVariable);
     $runtimeGenerationIf->trueBranch()->add(new ExpressionStatement($defineValidatorCall));
     $runtimeGenerationIf->trueBranch()->add(new ExpressionStatement(new Assign($staticDummyModeVariable, new Literal(false))));
     $method->statementBlock()->add($runtimeGenerationIf);
     $method->statementBlock()->add(new ReturnStatement(new NewOperator($validatorClassNameVariable)));
     return $method;
 }
 /**
  * @param RuntimeConfiguration $configuration
  *
  * @return ConcreteMethod
  */
 protected function generateConstructor(RuntimeConfiguration $configuration)
 {
     $this->typeCheck->generateConstructor(func_get_args());
     $indexIdentifier = new Identifier('index');
     $indexVariable = new Variable($indexIdentifier);
     $valueIdentifier = new Identifier('value');
     $valueVariable = new Variable($valueIdentifier);
     $previousIdentifier = new Identifier('previous');
     $previousVariable = new Variable($previousIdentifier);
     $typeInspectorIdentifier = new Identifier('typeInspector');
     $typeInspectorVariable = new Variable($typeInspectorIdentifier);
     $thisVariable = new Variable(new Identifier('this'));
     $thisIndexMember = new Member($thisVariable, new Constant($indexIdentifier));
     $thisValueMember = new Member($thisVariable, new Constant($valueIdentifier));
     $thisTypeInspectorMember = new Member($thisVariable, new Constant($typeInspectorIdentifier));
     $thisUnexpectedTypeMember = new Member($thisVariable, new Constant(new Identifier('unexpectedType')));
     $typeInspectorClassName = QualifiedIdentifier::fromString($configuration->validatorNamespace()->joinAtoms('TypeInspector')->string());
     $method = new ConcreteMethod(new Identifier('__construct'), AccessModifier::PUBLIC_());
     $method->addParameter(new Parameter($indexIdentifier));
     $method->addParameter(new Parameter($valueIdentifier));
     $previousParameter = new Parameter($previousIdentifier, new ObjectTypeHint(QualifiedIdentifier::fromString('\\Exception')));
     $previousParameter->setDefaultValue(new Literal(null));
     $method->addParameter($previousParameter);
     $typeInspectorParameter = new Parameter($typeInspectorIdentifier, new ObjectTypeHint($typeInspectorClassName));
     $typeInspectorParameter->setDefaultValue(new Literal(null));
     $method->addParameter($typeInspectorParameter);
     $nullTypeInspectorIf = new IfStatement(new StrictEquals(new Literal(null), $typeInspectorVariable));
     $nullTypeInspectorIf->trueBranch()->add(new ExpressionStatement(new Assign($typeInspectorVariable, new NewOperator(new Call($typeInspectorClassName)))));
     $method->statementBlock()->add($nullTypeInspectorIf);
     $method->statementBlock()->add(new ExpressionStatement(new Assign($thisIndexMember, $indexVariable)));
     $method->statementBlock()->add(new ExpressionStatement(new Assign($thisValueMember, $valueVariable)));
     $method->statementBlock()->add(new ExpressionStatement(new Assign($thisTypeInspectorMember, $typeInspectorVariable)));
     $typeInspectorTypeCall = new Call(new Member($typeInspectorVariable, new Constant(new Identifier('type'))));
     $typeInspectorTypeCall->add($thisValueMember);
     $method->statementBlock()->add(new ExpressionStatement(new Assign($thisUnexpectedTypeMember, $typeInspectorTypeCall)));
     $sprintfCall = new Call(QualifiedIdentifier::fromString('\\sprintf'));
     $sprintfCall->add(new Literal("Unexpected argument of type '%s' at index %d."));
     $sprintfCall->add($thisUnexpectedTypeMember);
     $sprintfCall->add($indexVariable);
     $parentConstructCall = new Call(new StaticMember(new Constant(new Identifier('parent')), new Constant(new Identifier('__construct'))));
     $parentConstructCall->add($sprintfCall);
     $parentConstructCall->add(new Variable($previousIdentifier));
     $method->statementBlock()->add(new ExpressionStatement($parentConstructCall));
     return $method;
 }
Ejemplo n.º 10
0
 /**
  * @param RuntimeConfiguration $configuration
  * @param ClassDefinition      $classDefinition
  *
  * @return ClassName
  */
 protected function validatorClassName(RuntimeConfiguration $configuration, ClassDefinition $classDefinition)
 {
     $this->typeCheck->validatorClassName(func_get_args());
     $classNameAtoms = $configuration->validatorNamespace()->atoms();
     $classNameAtoms[] = 'Validator';
     if ($classDefinition->className()->hasParent()) {
         $classNameAtoms = array_merge($classNameAtoms, $classDefinition->className()->parent()->atoms());
     }
     $classNameAtoms[] = sprintf('%sTypeCheck', $classDefinition->className()->shortName()->string());
     return ClassName::fromAtoms($classNameAtoms, true);
 }