spiral / framework

src/DataGrid/src/Specification/Value/SubsetValue.php

Spacing +2 added lines, -2 removed lines

@@ -35,11 +35,11 @@
     {
         $values = (array)$value;
 
-        if (count($values) === 1) {
+        if (count($values) === 1){
             return $this->enum->accepts(array_values($values)[0]);
         }
 
-        if (empty($values)) {
+        if (empty($values)){
             return false;
         }
 

src/DataGrid/src/Specification/Value/IntersectValue.php

Spacing +5 added lines, -5 removed lines

@@ -35,12 +35,12 @@ 
     {
         $values = (array)$value;
 
-        if (count($values) === 1) {
+        if (count($values) === 1){
             return $this->enum->accepts(array_values($values)[0]);
         }
 
-        foreach ($values as $v) {
-            if ($this->enum->accepts($v)) {
+        foreach ($values as $v){
+            if ($this->enum->accepts($v)){
                 return true;
             }
         }
@@ -55,8 +55,8 @@ 
     public function convert($value): array
     {
         $result = [];
-        foreach ((array)$value as $v) {
-            if ($this->enum->accepts($v)) {
+        foreach ((array)$value as $v){
+            if ($this->enum->accepts($v)){
                 $result[] = $this->enum->convert($v);
             }
         }

src/Validation/src/Checker/StringChecker.php

Spacing +1 added lines, -1 removed lines

@@ -88,7 +88,7 @@
      */
     public function range($value, int $min, int $max): bool
     {
-        if (!is_string($value)) {
+        if (!is_string($value)){
             return false;
         }
 

src/Core/src/Container.php

Spacing +69 added lines, -69 removed lines

@@ -98,7 +98,7 @@ 
     {
         $arguments = [];
 
-        foreach ($reflection->getParameters() as $parameter) {
+        foreach ($reflection->getParameters() as $parameter){
             $type = $parameter->getType();
             $name = $parameter->getName();
             $class = null;
@@ -107,17 +107,17 @@ 
              * Container do not currently support union types. In the future, we
              * can provide the possibility of autowiring based on priorities (TBD).
              */
-            if ($type instanceof \ReflectionUnionType) {
+            if ($type instanceof \ReflectionUnionType){
                 $error = 'Parameter $%s in %s contains a union type hint that cannot be inferred unambiguously';
                 $error = \sprintf($error, $reflection->getName(), $this->getLocationString($reflection));
 
                 throw new ContainerException($error);
             }
 
-            if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()) {
-                try {
+            if ($type instanceof \ReflectionNamedType && !$type->isBuiltin()){
+                try{
                     $class = new \ReflectionClass($type->getName());
-                } catch (\ReflectionException $e) {
+                }catch (\ReflectionException $e){
                     $location = $this->getLocationString($reflection);
 
                     $error = 'Unable to resolve `\$%s` parameter in %s: %s';
@@ -127,11 +127,11 @@ 
                 }
             }
 
-            if (isset($parameters[$name]) && is_object($parameters[$name])) {
-                if ($parameters[$name] instanceof Autowire) {
+            if (isset($parameters[$name]) && is_object($parameters[$name])){
+                if ($parameters[$name] instanceof Autowire){
                     // Supplied by user as late dependency
                     $arguments[] = $parameters[$name]->resolve($this);
-                } else {
+                }else{
                     // Supplied by user as object
                     $arguments[] = $parameters[$name];
                 }
@@ -139,16 +139,16 @@ 
             }
 
             // no declared type or scalar type or array
-            if (!isset($class)) {
+            if (!isset($class)){
                 // Provided from outside
-                if (\array_key_exists($name, $parameters)) {
+                if (\array_key_exists($name, $parameters)){
                     // Make sure it's properly typed
                     $this->assertType($parameter, $reflection, $parameters[$name]);
                     $arguments[] = $parameters[$name];
                     continue;
                 }
 
-                if ($parameter->isDefaultValueAvailable()) {
+                if ($parameter->isDefaultValueAvailable()){
                     //Default value
                     $arguments[] = $parameter->getDefaultValue();
                     continue;
@@ -158,12 +158,12 @@ 
                 throw new ArgumentException($parameter, $reflection);
             }
 
-            try {
+            try{
                 //Requesting for contextual dependency
                 $arguments[] = $this->get($class->getName(), $name);
                 continue;
-            } catch (AutowireException $e) {
-                if ($parameter->isOptional()) {
+            }catch (AutowireException $e){
+                if ($parameter->isOptional()){
                     //This is optional dependency, skip
                     $arguments[] = null;
                     continue;
@@ -193,7 +193,7 @@ 
      */
     public function get($id, string $context = null)
     {
-        if ($id instanceof Autowire) {
+        if ($id instanceof Autowire){
             return $id->resolve($this);
         }
 
@@ -209,34 +209,34 @@ 
      */
     public function make(string $alias, array $parameters = [], string $context = null)
     {
-        if (!isset($this->bindings[$alias])) {
+        if (!isset($this->bindings[$alias])){
             //No direct instructions how to construct class, make is automatically
             return $this->autowire($alias, $parameters, $context);
         }
 
         $binding = $this->bindings[$alias];
-        if (\is_object($binding)) {
+        if (\is_object($binding)){
             //When binding is instance, assuming singleton
             return $binding;
         }
 
-        if (\is_string($binding)) {
+        if (\is_string($binding)){
             //Binding is pointing to something else
             return $this->make($binding, $parameters, $context);
         }
 
         unset($this->bindings[$alias]);
-        try {
-            if ($binding[0] === $alias) {
+        try{
+            if ($binding[0] === $alias){
                 $instance = $this->autowire($alias, $parameters, $context);
-            } else {
+            }else{
                 $instance = $this->evaluateBinding($alias, $binding[0], $parameters, $context);
             }
-        } finally {
+        }finally{
             $this->bindings[$alias] = $binding;
         }
 
-        if ($binding[1]) {
+        if ($binding[1]){
             //Indicates singleton
             $this->bindings[$alias] = $instance;
         }
@@ -250,28 +250,28 @@ 
     public function runScope(array $bindings, callable $scope)
     {
         $cleanup = $previous = [];
-        foreach ($bindings as $alias => $resolver) {
-            if (isset($this->bindings[$alias])) {
+        foreach ($bindings as $alias => $resolver){
+            if (isset($this->bindings[$alias])){
                 $previous[$alias] = $this->bindings[$alias];
-            } else {
+            }else{
                 $cleanup[] = $alias;
             }
 
             $this->bind($alias, $resolver);
         }
 
-        try {
-            if (ContainerScope::getContainer() !== $this) {
+        try{
+            if (ContainerScope::getContainer() !== $this){
                 return ContainerScope::runScope($this, $scope);
             }
 
             return $scope();
-        } finally {
-            foreach (\array_reverse($previous) as $alias => $resolver) {
+        }finally{
+            foreach (\array_reverse($previous) as $alias => $resolver){
                 $this->bindings[$alias] = $resolver;
             }
 
-            foreach ($cleanup as $alias) {
+            foreach ($cleanup as $alias){
                 unset($this->bindings[$alias]);
             }
         }
@@ -287,7 +287,7 @@ 
      */
     public function bind(string $alias, $resolver): void
     {
-        if (\is_array($resolver) || $resolver instanceof \Closure || $resolver instanceof Autowire) {
+        if (\is_array($resolver) || $resolver instanceof \Closure || $resolver instanceof Autowire){
             // array means = execute me, false = not singleton
             $this->bindings[$alias] = [$resolver, false];
 
@@ -306,7 +306,7 @@ 
      */
     public function bindSingleton(string $alias, $resolver): void
     {
-        if (\is_object($resolver) && !$resolver instanceof \Closure && !$resolver instanceof Autowire) {
+        if (\is_object($resolver) && !$resolver instanceof \Closure && !$resolver instanceof Autowire){
             // direct binding to an instance
             $this->bindings[$alias] = $resolver;
 
@@ -324,11 +324,11 @@ 
      */
     public function hasInstance(string $alias): bool
     {
-        if (!$this->has($alias)) {
+        if (!$this->has($alias)){
             return false;
         }
 
-        while (isset($this->bindings[$alias]) && \is_string($this->bindings[$alias])) {
+        while (isset($this->bindings[$alias]) && \is_string($this->bindings[$alias])){
             //Checking alias tree
             $alias = $this->bindings[$alias];
         }
@@ -410,7 +410,7 @@ 
      */
     protected function autowire(string $class, array $parameters, string $context = null)
     {
-        if (!\class_exists($class)) {
+        if (!\class_exists($class)){
             throw new NotFoundException(\sprintf("Undefined class or binding '%s'", $class));
         }
 
@@ -429,7 +429,7 @@ 
     {
         $location = $reflection->getName();
 
-        if ($reflection instanceof \ReflectionMethod) {
+        if ($reflection instanceof \ReflectionMethod){
             return "{$reflection->getDeclaringClass()->getName()}::{$location}()";
         }
 
@@ -448,11 +448,11 @@ 
      */
     private function assertType(\ReflectionParameter $parameter, ContextFunction $context, $value): void
     {
-        if ($value === null) {
+        if ($value === null){
             if (
                 !$parameter->isOptional() &&
                 !($parameter->isDefaultValueAvailable() && $parameter->getDefaultValue() === null)
-            ) {
+            ){
                 throw new ArgumentException($parameter, $context);
             }
 
@@ -460,20 +460,20 @@ 
         }
 
         $type = $parameter->getType();
-        if ($type === null) {
+        if ($type === null){
             return;
         }
 
         $typeName = $type->getName();
-        if ($typeName === 'array' && !\is_array($value)) {
+        if ($typeName === 'array' && !\is_array($value)){
             throw new ArgumentException($parameter, $context);
         }
 
-        if (($typeName === 'int' || $typeName === 'float') && !\is_numeric($value)) {
+        if (($typeName === 'int' || $typeName === 'float') && !\is_numeric($value)){
             throw new ArgumentException($parameter, $context);
         }
 
-        if ($typeName === 'bool' && !\is_bool($value) && !\is_numeric($value)) {
+        if ($typeName === 'bool' && !\is_bool($value) && !\is_numeric($value)){
             throw new ArgumentException($parameter, $context);
         }
     }
@@ -491,22 +491,22 @@ 
      */
     private function createInstance(string $class, array $parameters, string $context = null)
     {
-        try {
+        try{
             $reflection = new \ReflectionClass($class);
-        } catch (\ReflectionException $e) {
+        }catch (\ReflectionException $e){
             throw new ContainerException($e->getMessage(), $e->getCode(), $e);
         }
 
         //We have to construct class using external injector when we know exact context
-        if ($parameters === [] && $this->checkInjector($reflection)) {
+        if ($parameters === [] && $this->checkInjector($reflection)){
             $injector = $this->injectors[$reflection->getName()];
 
             $instance = null;
-            try {
+            try{
                 /** @var InjectorInterface $injectorInstance */
                 $injectorInstance = $this->get($injector);
 
-                if (!$injectorInstance instanceof InjectorInterface) {
+                if (!$injectorInstance instanceof InjectorInterface){
                     throw new InjectionException(
                         \sprintf(
                             "Class '%s' must be an instance of InjectorInterface for '%s'",
@@ -517,7 +517,7 @@ 
                 }
 
                 $instance = $injectorInstance->createInjection($reflection, $context);
-                if (!$reflection->isInstance($instance)) {
+                if (!$reflection->isInstance($instance)){
                     throw new InjectionException(
                         \sprintf(
                             "Invalid injection response for '%s'",
@@ -525,23 +525,23 @@ 
                         )
                     );
                 }
-            } finally {
+            }finally{
                 $this->injectors[$reflection->getName()] = $injector;
             }
 
             return $instance;
         }
 
-        if (!$reflection->isInstantiable()) {
+        if (!$reflection->isInstantiable()){
             throw new ContainerException(\sprintf("Class '%s' can not be constructed", $class));
         }
 
         $constructor = $reflection->getConstructor();
 
-        if ($constructor !== null) {
+        if ($constructor !== null){
             // Using constructor with resolved arguments
             $instance = $reflection->newInstanceArgs($this->resolveArguments($constructor, $parameters));
-        } else {
+        }else{
             // No constructor specified
             $instance = $reflection->newInstance();
         }
@@ -558,28 +558,28 @@ 
     private function checkInjector(\ReflectionClass $reflection): bool
     {
         $class = $reflection->getName();
-        if (\array_key_exists($class, $this->injectors)) {
+        if (\array_key_exists($class, $this->injectors)){
             return $this->injectors[$class] !== null;
         }
 
         if (
             $reflection->implementsInterface(InjectableInterface::class)
             && $reflection->hasConstant('INJECTOR')
-        ) {
+        ){
             $this->injectors[$class] = $reflection->getConstant('INJECTOR');
 
             return true;
         }
 
-        if (!isset($this->injectorsCache[$class])) {
+        if (!isset($this->injectorsCache[$class])){
             $this->injectorsCache[$class] = null;
 
             // check interfaces
-            foreach ($this->injectors as $target => $injector) {
+            foreach ($this->injectors as $target => $injector){
                 if (
                     \class_exists($target, true)
                     && $reflection->isSubclassOf($target)
-                ) {
+                ){
                     $this->injectors[$class] = $injector;
 
                     return true;
@@ -588,7 +588,7 @@ 
                 if (
                     \interface_exists($target, true)
                     && $reflection->implementsInterface($target)
-                ) {
+                ){
                     $this->injectors[$class] = $injector;
 
                     return true;
@@ -610,9 +610,9 @@ 
     private function registerInstance($instance, array $parameters)
     {
         //Declarative singletons (only when class received via direct get)
-        if ($parameters === [] && $instance instanceof SingletonInterface) {
+        if ($parameters === [] && $instance instanceof SingletonInterface){
             $alias = \get_class($instance);
-            if (!isset($this->bindings[$alias])) {
+            if (!isset($this->bindings[$alias])){
                 $this->bindings[$alias] = $instance;
             }
         }
@@ -633,19 +633,19 @@ 
      */
     private function evaluateBinding(string $alias, $target, array $parameters, string $context = null)
     {
-        if (\is_string($target)) {
+        if (\is_string($target)){
             // Reference
             return $this->make($target, $parameters, $context);
         }
 
-        if ($target instanceof Autowire) {
+        if ($target instanceof Autowire){
             return $target->resolve($this, $parameters);
         }
 
-        if ($target instanceof \Closure) {
-            try {
+        if ($target instanceof \Closure){
+            try{
                 $reflection = new \ReflectionFunction($target);
-            } catch (\ReflectionException $e) {
+            }catch (\ReflectionException $e){
                 throw new ContainerException($e->getMessage(), $e->getCode(), $e);
             }
 
@@ -655,16 +655,16 @@ 
             );
         }
 
-        if (is_array($target) && isset($target[1])) {
+        if (is_array($target) && isset($target[1])){
             // In a form of resolver and method
             [$resolver, $method] = $target;
 
             // Resolver instance (i.e. [ClassName::class, 'method'])
             $resolver = $this->get($resolver);
 
-            try {
+            try{
                 $method = new \ReflectionMethod($resolver, $method);
-            } catch (\ReflectionException $e) {
+            }catch (\ReflectionException $e){
                 throw new ContainerException($e->getMessage(), $e->getCode(), $e);
             }
 

src/Models/src/DataEntity.php

Spacing +3 added lines, -3 removed lines

@@ -72,11 +72,11 @@ 
      */
     protected function isFillable(string $field): bool
     {
-        if (!empty(static::FILLABLE)) {
+        if (!empty(static::FILLABLE)){
             return in_array($field, static::FILLABLE);
         }
 
-        if (static::SECURED === '*') {
+        if (static::SECURED === '*'){
             return false;
         }
 
@@ -95,7 +95,7 @@ 
     protected function getMutator(string $field, string $type)
     {
         $target = [];
-        switch ($type) {
+        switch ($type){
             case ModelSchema::MUTATOR_ACCESSOR:
                 $target = static::ACCESSORS;
                 break;

src/Models/src/SchematicEntity.php

Spacing +3 added lines, -3 removed lines

@@ -34,15 +34,15 @@
      */
     protected function isFillable(string $field): bool
     {
-        if (!empty($this->schema[ModelSchema::FILLABLE]) && $this->schema[ModelSchema::FILLABLE] === '*') {
+        if (!empty($this->schema[ModelSchema::FILLABLE]) && $this->schema[ModelSchema::FILLABLE] === '*'){
             return true;
         }
 
-        if (!empty($this->schema[ModelSchema::FILLABLE])) {
+        if (!empty($this->schema[ModelSchema::FILLABLE])){
             return in_array($field, $this->schema[ModelSchema::FILLABLE], true);
         }
 
-        if (!empty($this->schema[ModelSchema::SECURED]) && $this->schema[ModelSchema::SECURED] === '*') {
+        if (!empty($this->schema[ModelSchema::SECURED]) && $this->schema[ModelSchema::SECURED] === '*'){
             return false;
         }
 

src/Prototype/src/ClassNode/ConstructorParam.php

Spacing +2 added lines, -2 removed lines

@@ -55,14 +55,14 @@
         $stmt = new self();
         $stmt->name = $parameter->getName();
 
-        if ($parameter->hasType()) {
+        if ($parameter->hasType()){
             $type = $parameter->getType();
             $stmt->type = Type::create($type->getName());
             $stmt->builtIn = $type->isBuiltin();
             $stmt->nullable = $type->allowsNull();
         }
 
-        if ($parameter->isDefaultValueAvailable()) {
+        if ($parameter->isDefaultValueAvailable()){
             $stmt->hasDefault = true;
             $stmt->default = $parameter->getDefaultValue();
         }

src/Translator/src/Catalogue.php

Spacing +6 added lines, -6 removed lines

@@ -57,7 +57,7 @@ 
      */
     public function has(string $domain, string $id): bool
     {
-        if (!isset($this->data[$domain])) {
+        if (!isset($this->data[$domain])){
             return false;
         }
 
@@ -69,7 +69,7 @@ 
      */
     public function get(string $domain, string $id): string
     {
-        if (!$this->has($domain, $id)) {
+        if (!$this->has($domain, $id)){
             throw new CatalogueException("Undefined string in domain '{$domain}'");
         }
 
@@ -99,15 +99,15 @@ 
      */
     public function mergeFrom(MessageCatalogue $catalogue, bool $follow = true): void
     {
-        foreach ($catalogue->all() as $domain => $messages) {
-            if (!isset($this->data[$domain])) {
+        foreach ($catalogue->all() as $domain => $messages){
+            if (!isset($this->data[$domain])){
                 $this->data[$domain] = [];
             }
 
-            if ($follow) {
+            if ($follow){
                 //MessageCatalogue string has higher priority that string stored in memory
                 $this->data[$domain] = array_merge($messages, $this->data[$domain]);
-            } else {
+            }else{
                 $this->data[$domain] = array_merge($this->data[$domain], $messages);
             }
         }