pryley / site-reviews

plugin/Modules/Schema/BaseType.php

Indentation +221 added lines, -221 removed lines

@@ -12,248 +12,248 @@
 
 abstract class BaseType implements ArrayAccess, JsonSerializable, Type
 {
-    /**
-     * @var array
-     */
-    public $allowed = [];
+	/**
+	 * @var array
+	 */
+	public $allowed = [];
 
-    /**
-     * @var array
-     */
-    public $parents = [];
+	/**
+	 * @var array
+	 */
+	public $parents = [];
 
-    /**
-     * @var array
-     */
-    protected $properties = [];
+	/**
+	 * @var array
+	 */
+	protected $properties = [];
 
-    /**
-     * @var string
-     */
-    protected $type;
+	/**
+	 * @var string
+	 */
+	protected $type;
 
-    /**
-     * @param string $method
-     * @return static
-     */
-    public function __call($method, array $arguments)
-    {
-        return $this->setProperty($method, glsr_get($arguments, 0));
-    }
+	/**
+	 * @param string $method
+	 * @return static
+	 */
+	public function __call($method, array $arguments)
+	{
+		return $this->setProperty($method, glsr_get($arguments, 0));
+	}
 
-    /**
-     * @param string $type
-     */
-    public function __construct($type = null)
-    {
-        $this->type = !is_string($type)
-            ? (new ReflectionClass($this))->getShortName()
-            : $type;
-        $this->setAllowedProperties();
-    }
+	/**
+	 * @param string $type
+	 */
+	public function __construct($type = null)
+	{
+		$this->type = !is_string($type)
+			? (new ReflectionClass($this))->getShortName()
+			: $type;
+		$this->setAllowedProperties();
+	}
 
-    /**
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->toScript();
-    }
+	/**
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->toScript();
+	}
 
-    /**
-     * @return static
-     */
-    public function addProperties(array $properties)
-    {
-        foreach ($properties as $property => $value) {
-            $this->setProperty($property, $value);
-        }
-        return $this;
-    }
+	/**
+	 * @return static
+	 */
+	public function addProperties(array $properties)
+	{
+		foreach ($properties as $property => $value) {
+			$this->setProperty($property, $value);
+		}
+		return $this;
+	}
 
-    /**
-     * @return string
-     */
-    public function getContext()
-    {
-        return 'https://schema.org';
-    }
+	/**
+	 * @return string
+	 */
+	public function getContext()
+	{
+		return 'https://schema.org';
+	}
 
-    /**
-     * @return array
-     */
-    public function getProperties()
-    {
-        return $this->properties;
-    }
+	/**
+	 * @return array
+	 */
+	public function getProperties()
+	{
+		return $this->properties;
+	}
 
-    /**
-     * @param string $property
-     * @param mixed $default
-     * @return mixed
-     */
-    public function getProperty($property, $default = null)
-    {
-        return glsr_get($this->properties, $property, $default);
-    }
+	/**
+	 * @param string $property
+	 * @param mixed $default
+	 * @return mixed
+	 */
+	public function getProperty($property, $default = null)
+	{
+		return glsr_get($this->properties, $property, $default);
+	}
 
-    /**
-     * @return string
-     */
-    public function getType()
-    {
-        return $this->type;
-    }
+	/**
+	 * @return string
+	 */
+	public function getType()
+	{
+		return $this->type;
+	}
 
-    /**
-     * @param bool $condition
-     * @param mixed $callback
-     * @return static
-     */
-    public function doIf($condition, $callback)
-    {
-        if ($condition) {
-            $callback($this);
-        }
-        return $this;
-    }
+	/**
+	 * @param bool $condition
+	 * @param mixed $callback
+	 * @return static
+	 */
+	public function doIf($condition, $callback)
+	{
+		if ($condition) {
+			$callback($this);
+		}
+		return $this;
+	}
 
-    /**
-     * @return array
-     */
-    public function jsonSerialize()
-    {
-        return $this->toArray();
-    }
+	/**
+	 * @return array
+	 */
+	public function jsonSerialize()
+	{
+		return $this->toArray();
+	}
 
-    /**
-     * @param mixed $offset
-     * @return bool
-     */
-    public function offsetExists($offset)
-    {
-        return array_key_exists($offset, $this->properties);
-    }
+	/**
+	 * @param mixed $offset
+	 * @return bool
+	 */
+	public function offsetExists($offset)
+	{
+		return array_key_exists($offset, $this->properties);
+	}
 
-    /**
-     * @param string $offset
-     * @return mixed
-     */
-    public function offsetGet($offset)
-    {
-        return $this->getProperty($offset);
-    }
+	/**
+	 * @param string $offset
+	 * @return mixed
+	 */
+	public function offsetGet($offset)
+	{
+		return $this->getProperty($offset);
+	}
 
-    /**
-     * @param string $offset
-     * @param mixed $value
-     * @return void
-     */
-    public function offsetSet($offset, $value)
-    {
-        $this->setProperty($offset, $value);
-    }
+	/**
+	 * @param string $offset
+	 * @param mixed $value
+	 * @return void
+	 */
+	public function offsetSet($offset, $value)
+	{
+		$this->setProperty($offset, $value);
+	}
 
-    /**
-     * @param string $offset
-     * @return void
-     */
-    public function offsetUnset($offset)
-    {
-        unset($this->properties[$offset]);
-    }
+	/**
+	 * @param string $offset
+	 * @return void
+	 */
+	public function offsetUnset($offset)
+	{
+		unset($this->properties[$offset]);
+	}
 
-    /**
-     * @param string $property
-     * @param mixed $value
-     * @return static
-     */
-    public function setProperty($property, $value)
-    {
-        if (!in_array($property, $this->allowed)
-            && 'UnknownType' != (new ReflectionClass($this))->getShortName()) {
-            glsr_log()->warning($this->getType().' does not allow the "'.$property.'" property');
-            return $this;
-        }
-        $this->properties[$property] = $value;
-        return $this;
-    }
+	/**
+	 * @param string $property
+	 * @param mixed $value
+	 * @return static
+	 */
+	public function setProperty($property, $value)
+	{
+		if (!in_array($property, $this->allowed)
+			&& 'UnknownType' != (new ReflectionClass($this))->getShortName()) {
+			glsr_log()->warning($this->getType().' does not allow the "'.$property.'" property');
+			return $this;
+		}
+		$this->properties[$property] = $value;
+		return $this;
+	}
 
-    /**
-     * @return array
-     */
-    public function toArray()
-    {
-        return [
-            '@context' => $this->getContext(),
-            '@type' => $this->getType(),
-        ] + $this->serializeProperty($this->getProperties());
-    }
+	/**
+	 * @return array
+	 */
+	public function toArray()
+	{
+		return [
+			'@context' => $this->getContext(),
+			'@type' => $this->getType(),
+		] + $this->serializeProperty($this->getProperties());
+	}
 
-    /**
-     * @return string
-     */
-    public function toScript()
-    {
-        return sprintf('<script type="application/ld+json">%s</script>',
-            json_encode($this->toArray(), JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
-        );
-    }
+	/**
+	 * @return string
+	 */
+	public function toScript()
+	{
+		return sprintf('<script type="application/ld+json">%s</script>',
+			json_encode($this->toArray(), JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES)
+		);
+	}
 
-    /**
-     * @param array|null $parents
-     * @return array
-     */
-    protected function getParents($parents = null)
-    {
-        if (!isset($parents)) {
-            $parents = $this->parents;
-        }
-        $newParents = $parents;
-        foreach ($parents as $parent) {
-            $parentClass = glsr(Helper::class)->buildClassName($parent, __NAMESPACE__);
-            if (!class_exists($parentClass)) {
-                continue;
-            }
-            $newParents = array_merge($newParents, $this->getParents((new $parentClass())->parents));
-        }
-        return array_values(array_unique($newParents));
-    }
+	/**
+	 * @param array|null $parents
+	 * @return array
+	 */
+	protected function getParents($parents = null)
+	{
+		if (!isset($parents)) {
+			$parents = $this->parents;
+		}
+		$newParents = $parents;
+		foreach ($parents as $parent) {
+			$parentClass = glsr(Helper::class)->buildClassName($parent, __NAMESPACE__);
+			if (!class_exists($parentClass)) {
+				continue;
+			}
+			$newParents = array_merge($newParents, $this->getParents((new $parentClass())->parents));
+		}
+		return array_values(array_unique($newParents));
+	}
 
-    /**
-     * @return void
-     */
-    protected function setAllowedProperties()
-    {
-        $parents = $this->getParents();
-        foreach ($parents as $parent) {
-            $parentClass = glsr(Helper::class)->buildClassName($parent, __NAMESPACE__);
-            if (!class_exists($parentClass)) {
-                continue;
-            }
-            $this->allowed = array_values(array_unique(array_merge((new $parentClass())->allowed, $this->allowed)));
-        }
-    }
+	/**
+	 * @return void
+	 */
+	protected function setAllowedProperties()
+	{
+		$parents = $this->getParents();
+		foreach ($parents as $parent) {
+			$parentClass = glsr(Helper::class)->buildClassName($parent, __NAMESPACE__);
+			if (!class_exists($parentClass)) {
+				continue;
+			}
+			$this->allowed = array_values(array_unique(array_merge((new $parentClass())->allowed, $this->allowed)));
+		}
+	}
 
-    /**
-     * @param mixed $property
-     * @return array|string
-     */
-    protected function serializeProperty($property)
-    {
-        if (is_array($property)) {
-            return array_map([$this, 'serializeProperty'], $property);
-        }
-        if ($property instanceof Type) {
-            $property = $property->toArray();
-            unset($property['@context']);
-        }
-        if ($property instanceof DateTimeInterface) {
-            $property = $property->format(DateTime::ATOM);
-        }
-        if (is_object($property)) {
-            throw new InvalidProperty();
-        }
-        return $property;
-    }
+	/**
+	 * @param mixed $property
+	 * @return array|string
+	 */
+	protected function serializeProperty($property)
+	{
+		if (is_array($property)) {
+			return array_map([$this, 'serializeProperty'], $property);
+		}
+		if ($property instanceof Type) {
+			$property = $property->toArray();
+			unset($property['@context']);
+		}
+		if ($property instanceof DateTimeInterface) {
+			$property = $property->format(DateTime::ATOM);
+		}
+		if (is_object($property)) {
+			throw new InvalidProperty();
+		}
+		return $property;
+	}
 }

plugin/Modules/Schema/Rating.php

Indentation +14 added lines, -14 removed lines

@@ -12,19 +12,19 @@
  */
 class Rating extends BaseType
 {
-    /**
-     * @var array
-     * @see http://schema.org/{property_name}
-     */
-    public $allowed = [
-        'author', 'bestRating', 'ratingValue', 'worstRating',
-    ];
+	/**
+	 * @var array
+	 * @see http://schema.org/{property_name}
+	 */
+	public $allowed = [
+		'author', 'bestRating', 'ratingValue', 'worstRating',
+	];
 
-    /**
-     * @var array
-     * @see http://schema.org/{property_name}
-     */
-    public $parents = [
-        'Intangible',
-    ];
+	/**
+	 * @var array
+	 * @see http://schema.org/{property_name}
+	 */
+	public $parents = [
+		'Intangible',
+	];
 }

plugin/Modules/Validator.php

Indentation +274 added lines, -274 removed lines

@@ -12,302 +12,302 @@
  */
 class Validator
 {
-    use ValidationRules;
+	use ValidationRules;
 
-    /**
-     * @var array
-     */
-    public $errors = [];
+	/**
+	 * @var array
+	 */
+	public $errors = [];
 
-    /**
-     * The data under validation.
-     * @var array
-     */
-    protected $data = [];
+	/**
+	 * The data under validation.
+	 * @var array
+	 */
+	protected $data = [];
 
-    /**
-     * The failed validation rules.
-     * @var array
-     */
-    protected $failedRules = [];
+	/**
+	 * The failed validation rules.
+	 * @var array
+	 */
+	protected $failedRules = [];
 
-    /**
-     * The rules to be applied to the data.
-     * @var array
-     */
-    protected $rules = [];
+	/**
+	 * The rules to be applied to the data.
+	 * @var array
+	 */
+	protected $rules = [];
 
-    /**
-     * The size related validation rules.
-     * @var array
-     */
-    protected $sizeRules = [
-        'Between', 'Max', 'Min',
-    ];
+	/**
+	 * The size related validation rules.
+	 * @var array
+	 */
+	protected $sizeRules = [
+		'Between', 'Max', 'Min',
+	];
 
-    /**
-     * The validation rules that imply the field is required.
-     * @var array
-     */
-    protected $implicitRules = [
-        'Required',
-    ];
+	/**
+	 * The validation rules that imply the field is required.
+	 * @var array
+	 */
+	protected $implicitRules = [
+		'Required',
+	];
 
-    /**
-     * The numeric related validation rules.
-     * @var array
-     */
-    protected $numericRules = [
-        'Number',
-    ];
+	/**
+	 * The numeric related validation rules.
+	 * @var array
+	 */
+	protected $numericRules = [
+		'Number',
+	];
 
-    /**
-     * Run the validator's rules against its data.
-     * @param mixed $data
-     * @return array
-     */
-    public function validate($data, array $rules = [])
-    {
-        $this->normalizeData($data);
-        $this->setRules($rules);
-        foreach ($this->rules as $attribute => $rules) {
-            foreach ($rules as $rule) {
-                $this->validateAttribute($attribute, $rule);
-                if ($this->shouldStopValidating($attribute)) {
-                    break;
-                }
-            }
-        }
-        return $this->errors;
-    }
+	/**
+	 * Run the validator's rules against its data.
+	 * @param mixed $data
+	 * @return array
+	 */
+	public function validate($data, array $rules = [])
+	{
+		$this->normalizeData($data);
+		$this->setRules($rules);
+		foreach ($this->rules as $attribute => $rules) {
+			foreach ($rules as $rule) {
+				$this->validateAttribute($attribute, $rule);
+				if ($this->shouldStopValidating($attribute)) {
+					break;
+				}
+			}
+		}
+		return $this->errors;
+	}
 
-    /**
-     * Validate a given attribute against a rule.
-     * @param string $attribute
-     * @param string $rule
-     * @return void
-     * @throws BadMethodCallException
-     */
-    public function validateAttribute($attribute, $rule)
-    {
-        list($rule, $parameters) = $this->parseRule($rule);
-        if ('' == $rule) {
-            return;
-        }
-        $value = $this->getValue($attribute);
-        if (!method_exists($this, $method = 'validate'.$rule)) {
-            throw new BadMethodCallException("Method [$method] does not exist.");
-        }
-        if (!$this->$method($value, $attribute, $parameters)) {
-            $this->addFailure($attribute, $rule, $parameters);
-        }
-    }
+	/**
+	 * Validate a given attribute against a rule.
+	 * @param string $attribute
+	 * @param string $rule
+	 * @return void
+	 * @throws BadMethodCallException
+	 */
+	public function validateAttribute($attribute, $rule)
+	{
+		list($rule, $parameters) = $this->parseRule($rule);
+		if ('' == $rule) {
+			return;
+		}
+		$value = $this->getValue($attribute);
+		if (!method_exists($this, $method = 'validate'.$rule)) {
+			throw new BadMethodCallException("Method [$method] does not exist.");
+		}
+		if (!$this->$method($value, $attribute, $parameters)) {
+			$this->addFailure($attribute, $rule, $parameters);
+		}
+	}
 
-    /**
-     * Add an error message to the validator's collection of errors.
-     * @param string $attribute
-     * @param string $rule
-     * @return void
-     */
-    protected function addError($attribute, $rule, array $parameters)
-    {
-        $message = $this->getMessage($attribute, $rule, $parameters);
-        $this->errors[$attribute][] = $message;
-    }
+	/**
+	 * Add an error message to the validator's collection of errors.
+	 * @param string $attribute
+	 * @param string $rule
+	 * @return void
+	 */
+	protected function addError($attribute, $rule, array $parameters)
+	{
+		$message = $this->getMessage($attribute, $rule, $parameters);
+		$this->errors[$attribute][] = $message;
+	}
 
-    /**
-     * Add a failed rule and error message to the collection.
-     * @param string $attribute
-     * @param string $rule
-     * @return void
-     */
-    protected function addFailure($attribute, $rule, array $parameters)
-    {
-        $this->addError($attribute, $rule, $parameters);
-        $this->failedRules[$attribute][$rule] = $parameters;
-    }
+	/**
+	 * Add a failed rule and error message to the collection.
+	 * @param string $attribute
+	 * @param string $rule
+	 * @return void
+	 */
+	protected function addFailure($attribute, $rule, array $parameters)
+	{
+		$this->addError($attribute, $rule, $parameters);
+		$this->failedRules[$attribute][$rule] = $parameters;
+	}
 
-    /**
-     * Get the data type of the given attribute.
-     * @param string $attribute
-     * @return string
-     */
-    protected function getAttributeType($attribute)
-    {
-        return !$this->hasRule($attribute, $this->numericRules)
-            ? 'length'
-            : '';
-    }
+	/**
+	 * Get the data type of the given attribute.
+	 * @param string $attribute
+	 * @return string
+	 */
+	protected function getAttributeType($attribute)
+	{
+		return !$this->hasRule($attribute, $this->numericRules)
+			? 'length'
+			: '';
+	}
 
-    /**
-     * Get the validation message for an attribute and rule.
-     * @param string $attribute
-     * @param string $rule
-     * @return string|null
-     */
-    protected function getMessage($attribute, $rule, array $parameters)
-    {
-        if (in_array($rule, $this->sizeRules)) {
-            return $this->getSizeMessage($attribute, $rule, $parameters);
-        }
-        $lowerRule = glsr(Helper::class)->snakeCase($rule);
-        return $this->translator($lowerRule, $parameters);
-    }
+	/**
+	 * Get the validation message for an attribute and rule.
+	 * @param string $attribute
+	 * @param string $rule
+	 * @return string|null
+	 */
+	protected function getMessage($attribute, $rule, array $parameters)
+	{
+		if (in_array($rule, $this->sizeRules)) {
+			return $this->getSizeMessage($attribute, $rule, $parameters);
+		}
+		$lowerRule = glsr(Helper::class)->snakeCase($rule);
+		return $this->translator($lowerRule, $parameters);
+	}
 
-    /**
-     * Get a rule and its parameters for a given attribute.
-     * @param string $attribute
-     * @param string|array $rules
-     * @return array|null
-     */
-    protected function getRule($attribute, $rules)
-    {
-        if (!array_key_exists($attribute, $this->rules)) {
-            return;
-        }
-        $rules = (array) $rules;
-        foreach ($this->rules[$attribute] as $rule) {
-            list($rule, $parameters) = $this->parseRule($rule);
-            if (in_array($rule, $rules)) {
-                return [$rule, $parameters];
-            }
-        }
-    }
+	/**
+	 * Get a rule and its parameters for a given attribute.
+	 * @param string $attribute
+	 * @param string|array $rules
+	 * @return array|null
+	 */
+	protected function getRule($attribute, $rules)
+	{
+		if (!array_key_exists($attribute, $this->rules)) {
+			return;
+		}
+		$rules = (array) $rules;
+		foreach ($this->rules[$attribute] as $rule) {
+			list($rule, $parameters) = $this->parseRule($rule);
+			if (in_array($rule, $rules)) {
+				return [$rule, $parameters];
+			}
+		}
+	}
 
-    /**
-     * Get the size of an attribute.
-     * @param string $attribute
-     * @param mixed $value
-     * @return mixed
-     */
-    protected function getSize($attribute, $value)
-    {
-        $hasNumeric = $this->hasRule($attribute, $this->numericRules);
-        if (is_numeric($value) && $hasNumeric) {
-            return $value;
-        } elseif (is_array($value)) {
-            return count($value);
-        }
-        return function_exists('mb_strlen')
-            ? mb_strlen($value)
-            : strlen($value);
-    }
+	/**
+	 * Get the size of an attribute.
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return mixed
+	 */
+	protected function getSize($attribute, $value)
+	{
+		$hasNumeric = $this->hasRule($attribute, $this->numericRules);
+		if (is_numeric($value) && $hasNumeric) {
+			return $value;
+		} elseif (is_array($value)) {
+			return count($value);
+		}
+		return function_exists('mb_strlen')
+			? mb_strlen($value)
+			: strlen($value);
+	}
 
-    /**
-     * Get the proper error message for an attribute and size rule.
-     * @param string $attribute
-     * @param string $rule
-     * @return string|null
-     */
-    protected function getSizeMessage($attribute, $rule, array $parameters)
-    {
-        $type = $this->getAttributeType($attribute);
-        $lowerRule = glsr(Helper::class)->snakeCase($rule.$type);
-        return $this->translator($lowerRule, $parameters);
-    }
+	/**
+	 * Get the proper error message for an attribute and size rule.
+	 * @param string $attribute
+	 * @param string $rule
+	 * @return string|null
+	 */
+	protected function getSizeMessage($attribute, $rule, array $parameters)
+	{
+		$type = $this->getAttributeType($attribute);
+		$lowerRule = glsr(Helper::class)->snakeCase($rule.$type);
+		return $this->translator($lowerRule, $parameters);
+	}
 
-    /**
-     * Get the value of a given attribute.
-     * @param string $attribute
-     * @return mixed
-     */
-    protected function getValue($attribute)
-    {
-        if (isset($this->data[$attribute])) {
-            return $this->data[$attribute];
-        }
-    }
+	/**
+	 * Get the value of a given attribute.
+	 * @param string $attribute
+	 * @return mixed
+	 */
+	protected function getValue($attribute)
+	{
+		if (isset($this->data[$attribute])) {
+			return $this->data[$attribute];
+		}
+	}
 
-    /**
-     * Determine if the given attribute has a rule in the given set.
-     * @param string $attribute
-     * @param string|array $rules
-     * @return bool
-     */
-    protected function hasRule($attribute, $rules)
-    {
-        return !is_null($this->getRule($attribute, $rules));
-    }
+	/**
+	 * Determine if the given attribute has a rule in the given set.
+	 * @param string $attribute
+	 * @param string|array $rules
+	 * @return bool
+	 */
+	protected function hasRule($attribute, $rules)
+	{
+		return !is_null($this->getRule($attribute, $rules));
+	}
 
-    /**
-     * Normalize the provided data to an array.
-     * @param mixed $data
-     * @return void
-     */
-    protected function normalizeData($data)
-    {
-        $this->data = is_object($data)
-            ? get_object_vars($data)
-            : $data;
-    }
+	/**
+	 * Normalize the provided data to an array.
+	 * @param mixed $data
+	 * @return void
+	 */
+	protected function normalizeData($data)
+	{
+		$this->data = is_object($data)
+			? get_object_vars($data)
+			: $data;
+	}
 
-    /**
-     * Parse a parameter list.
-     * @param string $rule
-     * @param string $parameter
-     * @return array
-     */
-    protected function parseParameters($rule, $parameter)
-    {
-        return 'regex' == strtolower($rule)
-            ? [$parameter]
-            : str_getcsv($parameter);
-    }
+	/**
+	 * Parse a parameter list.
+	 * @param string $rule
+	 * @param string $parameter
+	 * @return array
+	 */
+	protected function parseParameters($rule, $parameter)
+	{
+		return 'regex' == strtolower($rule)
+			? [$parameter]
+			: str_getcsv($parameter);
+	}
 
-    /**
-     * Extract the rule name and parameters from a rule.
-     * @param string $rule
-     * @return array
-     */
-    protected function parseRule($rule)
-    {
-        $parameters = [];
-        if (false !== strpos($rule, ':')) {
-            list($rule, $parameter) = explode(':', $rule, 2);
-            $parameters = $this->parseParameters($rule, $parameter);
-        }
-        $rule = glsr(Helper::class)->camelCase($rule);
-        return [$rule, $parameters];
-    }
+	/**
+	 * Extract the rule name and parameters from a rule.
+	 * @param string $rule
+	 * @return array
+	 */
+	protected function parseRule($rule)
+	{
+		$parameters = [];
+		if (false !== strpos($rule, ':')) {
+			list($rule, $parameter) = explode(':', $rule, 2);
+			$parameters = $this->parseParameters($rule, $parameter);
+		}
+		$rule = glsr(Helper::class)->camelCase($rule);
+		return [$rule, $parameters];
+	}
 
-    /**
-     * Set the validation rules.
-     * @return void
-     */
-    protected function setRules(array $rules)
-    {
-        foreach ($rules as $key => $rule) {
-            $rules[$key] = is_string($rule)
-                ? explode('|', $rule)
-                : $rule;
-        }
-        $this->rules = $rules;
-    }
+	/**
+	 * Set the validation rules.
+	 * @return void
+	 */
+	protected function setRules(array $rules)
+	{
+		foreach ($rules as $key => $rule) {
+			$rules[$key] = is_string($rule)
+				? explode('|', $rule)
+				: $rule;
+		}
+		$this->rules = $rules;
+	}
 
-    /**
-     * Check if we should stop further validations on a given attribute.
-     * @param string $attribute
-     * @return bool
-     */
-    protected function shouldStopValidating($attribute)
-    {
-        return $this->hasRule($attribute, $this->implicitRules)
-            && isset($this->failedRules[$attribute])
-            && array_intersect(array_keys($this->failedRules[$attribute]), $this->implicitRules);
-    }
+	/**
+	 * Check if we should stop further validations on a given attribute.
+	 * @param string $attribute
+	 * @return bool
+	 */
+	protected function shouldStopValidating($attribute)
+	{
+		return $this->hasRule($attribute, $this->implicitRules)
+			&& isset($this->failedRules[$attribute])
+			&& array_intersect(array_keys($this->failedRules[$attribute]), $this->implicitRules);
+	}
 
-    /**
-     * Returns a translated message for the attribute.
-     * @param string $key
-     * @param string $attribute
-     * @return void|string
-     */
-    protected function translator($key, array $parameters)
-    {
-        $strings = glsr(ValidationStringsDefaults::class)->defaults();
-        if (isset($strings[$key])) {
-            return $this->replace($strings[$key], $parameters);
-        }
-        return 'error';
-    }
+	/**
+	 * Returns a translated message for the attribute.
+	 * @param string $key
+	 * @param string $attribute
+	 * @return void|string
+	 */
+	protected function translator($key, array $parameters)
+	{
+		$strings = glsr(ValidationStringsDefaults::class)->defaults();
+		if (isset($strings[$key])) {
+			return $this->replace($strings[$key], $parameters);
+		}
+		return 'error';
+	}
 }

plugin/Modules/Validator/ValidationRules.php

Indentation +113 added lines, -113 removed lines

@@ -9,126 +9,126 @@
  */
 trait ValidationRules
 {
-    /**
-     * Get the size of an attribute.
-     * @param string $attribute
-     * @param mixed $value
-     * @return mixed
-     */
-    abstract protected function getSize($attribute, $value);
+	/**
+	 * Get the size of an attribute.
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return mixed
+	 */
+	abstract protected function getSize($attribute, $value);
 
-    /**
-     * Replace all placeholders.
-     * @param string $message
-     * @return string
-     */
-    protected function replace($message, array $parameters)
-    {
-        if (false === strpos($message, '%s')) {
-            return $message;
-        }
-        return preg_replace_callback('/(%s)/', function () use (&$parameters) {
-            foreach ($parameters as $key => $value) {
-                return array_shift($parameters);
-            }
-        }, $message);
-    }
+	/**
+	 * Replace all placeholders.
+	 * @param string $message
+	 * @return string
+	 */
+	protected function replace($message, array $parameters)
+	{
+		if (false === strpos($message, '%s')) {
+			return $message;
+		}
+		return preg_replace_callback('/(%s)/', function () use (&$parameters) {
+			foreach ($parameters as $key => $value) {
+				return array_shift($parameters);
+			}
+		}, $message);
+	}
 
-    /**
-     * Validate that an attribute was "accepted".
-     * This validation rule implies the attribute is "required".
-     * @param string $attribute
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateAccepted($value)
-    {
-        $acceptable = ['yes', 'on', '1', 1, true, 'true'];
-        return $this->validateRequired($value) && in_array($value, $acceptable, true);
-    }
+	/**
+	 * Validate that an attribute was "accepted".
+	 * This validation rule implies the attribute is "required".
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateAccepted($value)
+	{
+		$acceptable = ['yes', 'on', '1', 1, true, 'true'];
+		return $this->validateRequired($value) && in_array($value, $acceptable, true);
+	}
 
-    /**
-     * Validate the size of an attribute is between a set of values.
-     * @param string $attribute
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateBetween($value, $attribute, array $parameters)
-    {
-        $this->requireParameterCount(2, $parameters, 'between');
-        $size = $this->getSize($attribute, $value);
-        return $size >= $parameters[0] && $size <= $parameters[1];
-    }
+	/**
+	 * Validate the size of an attribute is between a set of values.
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateBetween($value, $attribute, array $parameters)
+	{
+		$this->requireParameterCount(2, $parameters, 'between');
+		$size = $this->getSize($attribute, $value);
+		return $size >= $parameters[0] && $size <= $parameters[1];
+	}
 
-    /**
-     * Validate that an attribute is a valid e-mail address.
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateEmail($value)
-    {
-        return false !== filter_var($value, FILTER_VALIDATE_EMAIL);
-    }
+	/**
+	 * Validate that an attribute is a valid e-mail address.
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateEmail($value)
+	{
+		return false !== filter_var($value, FILTER_VALIDATE_EMAIL);
+	}
 
-    /**
-     * Validate the size of an attribute is less than a maximum value.
-     * @param string $attribute
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateMax($value, $attribute, array $parameters)
-    {
-        $this->requireParameterCount(1, $parameters, 'max');
-        return $this->getSize($attribute, $value) <= $parameters[0];
-    }
+	/**
+	 * Validate the size of an attribute is less than a maximum value.
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateMax($value, $attribute, array $parameters)
+	{
+		$this->requireParameterCount(1, $parameters, 'max');
+		return $this->getSize($attribute, $value) <= $parameters[0];
+	}
 
-    /**
-     * Validate the size of an attribute is greater than a minimum value.
-     * @param string $attribute
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateMin($value, $attribute, array $parameters)
-    {
-        $this->requireParameterCount(1, $parameters, 'min');
-        return $this->getSize($attribute, $value) >= $parameters[0];
-    }
+	/**
+	 * Validate the size of an attribute is greater than a minimum value.
+	 * @param string $attribute
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateMin($value, $attribute, array $parameters)
+	{
+		$this->requireParameterCount(1, $parameters, 'min');
+		return $this->getSize($attribute, $value) >= $parameters[0];
+	}
 
-    /**
-     * Validate that an attribute is numeric.
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateNumber($value)
-    {
-        return is_numeric($value);
-    }
+	/**
+	 * Validate that an attribute is numeric.
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateNumber($value)
+	{
+		return is_numeric($value);
+	}
 
-    /**
-     * Validate that a required attribute exists.
-     * @param mixed $value
-     * @return bool
-     */
-    public function validateRequired($value)
-    {
-        return is_null($value)
-            || (is_string($value) && '' === trim($value))
-            || (is_array($value) && count($value) < 1)
-            ? false
-            : true;
-    }
+	/**
+	 * Validate that a required attribute exists.
+	 * @param mixed $value
+	 * @return bool
+	 */
+	public function validateRequired($value)
+	{
+		return is_null($value)
+			|| (is_string($value) && '' === trim($value))
+			|| (is_array($value) && count($value) < 1)
+			? false
+			: true;
+	}
 
-    /**
-     * Require a certain number of parameters to be present.
-     * @param int $count
-     * @param string $rule
-     * @return void
-     * @throws InvalidArgumentException
-     */
-    protected function requireParameterCount($count, array $parameters, $rule)
-    {
-        if (count($parameters) < $count) {
-            throw new InvalidArgumentException("Validation rule $rule requires at least $count parameters.");
-        }
-    }
+	/**
+	 * Require a certain number of parameters to be present.
+	 * @param int $count
+	 * @param string $rule
+	 * @return void
+	 * @throws InvalidArgumentException
+	 */
+	protected function requireParameterCount($count, array $parameters, $rule)
+	{
+		if (count($parameters) < $count) {
+			throw new InvalidArgumentException("Validation rule $rule requires at least $count parameters.");
+		}
+	}
 }

plugin/Modules/Rating.php

Indentation +190 added lines, -190 removed lines

@@ -4,206 +4,206 @@
 
 class Rating
 {
-    /**
-     * The more sure we are of the confidence interval (the higher the confidence level), the less
-     * precise the estimation will be as the margin for error will be higher.
-     * @see http://homepages.math.uic.edu/~bpower6/stat101/Confidence%20Intervals.pdf
-     * @see https://www.thecalculator.co/math/Confidence-Interval-Calculator-210.html
-     * @see https://www.youtube.com/watch?v=grodoLzThy4
-     * @see https://en.wikipedia.org/wiki/Standard_score
-     * @var array
-     */
-    const CONFIDENCE_LEVEL_Z_SCORES = [
-        50 => 0.67449,
-        70 => 1.04,
-        75 => 1.15035,
-        80 => 1.282,
-        85 => 1.44,
-        90 => 1.64485,
-        92 => 1.75,
-        95 => 1.95996,
-        96 => 2.05,
-        97 => 2.17009,
-        98 => 2.326,
-        99 => 2.57583,
-        '99.5' => 2.81,
-        '99.8' => 3.08,
-        '99.9' => 3.29053,
-    ];
+	/**
+	 * The more sure we are of the confidence interval (the higher the confidence level), the less
+	 * precise the estimation will be as the margin for error will be higher.
+	 * @see http://homepages.math.uic.edu/~bpower6/stat101/Confidence%20Intervals.pdf
+	 * @see https://www.thecalculator.co/math/Confidence-Interval-Calculator-210.html
+	 * @see https://www.youtube.com/watch?v=grodoLzThy4
+	 * @see https://en.wikipedia.org/wiki/Standard_score
+	 * @var array
+	 */
+	const CONFIDENCE_LEVEL_Z_SCORES = [
+		50 => 0.67449,
+		70 => 1.04,
+		75 => 1.15035,
+		80 => 1.282,
+		85 => 1.44,
+		90 => 1.64485,
+		92 => 1.75,
+		95 => 1.95996,
+		96 => 2.05,
+		97 => 2.17009,
+		98 => 2.326,
+		99 => 2.57583,
+		'99.5' => 2.81,
+		'99.8' => 3.08,
+		'99.9' => 3.29053,
+	];
 
-    /**
-     * @var int
-     */
-    const MAX_RATING = 5;
+	/**
+	 * @var int
+	 */
+	const MAX_RATING = 5;
 
-    /**
-     * @var int
-     */
-    const MIN_RATING = 1;
+	/**
+	 * @var int
+	 */
+	const MIN_RATING = 1;
 
-    /**
-     * @param int $roundBy
-     * @return float
-     */
-    public function getAverage(array $ratingCounts, $roundBy = 1)
-    {
-        $average = array_sum($ratingCounts);
-        if ($average > 0) {
-            $average = round($this->getTotalSum($ratingCounts) / $average, intval($roundBy));
-        }
-        return floatval(apply_filters('site-reviews/rating/average', $average, $ratingCounts));
-    }
+	/**
+	 * @param int $roundBy
+	 * @return float
+	 */
+	public function getAverage(array $ratingCounts, $roundBy = 1)
+	{
+		$average = array_sum($ratingCounts);
+		if ($average > 0) {
+			$average = round($this->getTotalSum($ratingCounts) / $average, intval($roundBy));
+		}
+		return floatval(apply_filters('site-reviews/rating/average', $average, $ratingCounts));
+	}
 
-    /**
-     * Get the lower bound for up/down ratings
-     * Method receives an up/down ratings array: [1, -1, -1, 1, 1, -1].
-     * @see http://www.evanmiller.org/how-not-to-sort-by-average-rating.html
-     * @see https://news.ycombinator.com/item?id=10481507
-     * @see https://dataorigami.net/blogs/napkin-folding/79030467-an-algorithm-to-sort-top-comments
-     * @see http://julesjacobs.github.io/2015/08/17/bayesian-scoring-of-ratings.html
-     * @param int $confidencePercentage
-     * @return int|float
-     */
-    public function getLowerBound(array $upDownCounts = [0, 0], $confidencePercentage = 95)
-    {
-        $numRatings = array_sum($upDownCounts);
-        if ($numRatings < 1) {
-            return 0;
-        }
-        $z = static::CONFIDENCE_LEVEL_Z_SCORES[$confidencePercentage];
-        $phat = 1 * $upDownCounts[1] / $numRatings;
-        return ($phat + $z * $z / (2 * $numRatings) - $z * sqrt(($phat * (1 - $phat) + $z * $z / (4 * $numRatings)) / $numRatings)) / (1 + $z * $z / $numRatings);
-    }
+	/**
+	 * Get the lower bound for up/down ratings
+	 * Method receives an up/down ratings array: [1, -1, -1, 1, 1, -1].
+	 * @see http://www.evanmiller.org/how-not-to-sort-by-average-rating.html
+	 * @see https://news.ycombinator.com/item?id=10481507
+	 * @see https://dataorigami.net/blogs/napkin-folding/79030467-an-algorithm-to-sort-top-comments
+	 * @see http://julesjacobs.github.io/2015/08/17/bayesian-scoring-of-ratings.html
+	 * @param int $confidencePercentage
+	 * @return int|float
+	 */
+	public function getLowerBound(array $upDownCounts = [0, 0], $confidencePercentage = 95)
+	{
+		$numRatings = array_sum($upDownCounts);
+		if ($numRatings < 1) {
+			return 0;
+		}
+		$z = static::CONFIDENCE_LEVEL_Z_SCORES[$confidencePercentage];
+		$phat = 1 * $upDownCounts[1] / $numRatings;
+		return ($phat + $z * $z / (2 * $numRatings) - $z * sqrt(($phat * (1 - $phat) + $z * $z / (4 * $numRatings)) / $numRatings)) / (1 + $z * $z / $numRatings);
+	}
 
-    /**
-     * @return int|float
-     */
-    public function getOverallPercentage(array $ratingCounts)
-    {
-        return round($this->getAverage($ratingCounts) * 100 / glsr()->constant('MAX_RATING'), 2);
-    }
+	/**
+	 * @return int|float
+	 */
+	public function getOverallPercentage(array $ratingCounts)
+	{
+		return round($this->getAverage($ratingCounts) * 100 / glsr()->constant('MAX_RATING'), 2);
+	}
 
-    /**
-     * @return array
-     */
-    public function getPercentages(array $ratingCounts)
-    {
-        $total = array_sum($ratingCounts);
-        foreach ($ratingCounts as $index => $count) {
-            if (empty($count)) {
-                continue;
-            }
-            $ratingCounts[$index] = $count / $total * 100;
-        }
-        return $this->getRoundedPercentages($ratingCounts);
-    }
+	/**
+	 * @return array
+	 */
+	public function getPercentages(array $ratingCounts)
+	{
+		$total = array_sum($ratingCounts);
+		foreach ($ratingCounts as $index => $count) {
+			if (empty($count)) {
+				continue;
+			}
+			$ratingCounts[$index] = $count / $total * 100;
+		}
+		return $this->getRoundedPercentages($ratingCounts);
+	}
 
-    /**
-     * @return float
-     */
-    public function getRanking(array $ratingCounts)
-    {
-        return floatval(apply_filters('site-reviews/rating/ranking',
-            $this->getRankingUsingImdb($ratingCounts),
-            $ratingCounts,
-            $this
-        ));
-    }
+	/**
+	 * @return float
+	 */
+	public function getRanking(array $ratingCounts)
+	{
+		return floatval(apply_filters('site-reviews/rating/ranking',
+			$this->getRankingUsingImdb($ratingCounts),
+			$ratingCounts,
+			$this
+		));
+	}
 
-    /**
-     * Get the bayesian ranking for an array of reviews
-     * This formula is the same one used by IMDB to rank their top 250 films.
-     * @see https://www.xkcd.com/937/
-     * @see https://districtdatalabs.silvrback.com/computing-a-bayesian-estimate-of-star-rating-means
-     * @see http://fulmicoton.com/posts/bayesian_rating/
-     * @see https://stats.stackexchange.com/questions/93974/is-there-an-equivalent-to-lower-bound-of-wilson-score-confidence-interval-for-va
-     * @param int $confidencePercentage
-     * @return int|float
-     */
-    public function getRankingUsingImdb(array $ratingCounts, $confidencePercentage = 70)
-    {
-        $avgRating = $this->getAverage($ratingCounts);
-        // Represents a prior (your prior opinion without data) for the average star rating. A higher prior also means a higher margin for error.
-        // This could also be the average score of all items instead of a fixed value.
-        $bayesMean = ($confidencePercentage / 100) * glsr()->constant('MAX_RATING'); // prior, 70% = 3.5
-        // Represents the number of ratings expected to begin observing a pattern that would put confidence in the prior.
-        $bayesMinimal = 10; // confidence
-        $numOfReviews = array_sum($ratingCounts);
-        return $avgRating > 0
-            ? (($bayesMinimal * $bayesMean) + ($avgRating * $numOfReviews)) / ($bayesMinimal + $numOfReviews)
-            : 0;
-    }
+	/**
+	 * Get the bayesian ranking for an array of reviews
+	 * This formula is the same one used by IMDB to rank their top 250 films.
+	 * @see https://www.xkcd.com/937/
+	 * @see https://districtdatalabs.silvrback.com/computing-a-bayesian-estimate-of-star-rating-means
+	 * @see http://fulmicoton.com/posts/bayesian_rating/
+	 * @see https://stats.stackexchange.com/questions/93974/is-there-an-equivalent-to-lower-bound-of-wilson-score-confidence-interval-for-va
+	 * @param int $confidencePercentage
+	 * @return int|float
+	 */
+	public function getRankingUsingImdb(array $ratingCounts, $confidencePercentage = 70)
+	{
+		$avgRating = $this->getAverage($ratingCounts);
+		// Represents a prior (your prior opinion without data) for the average star rating. A higher prior also means a higher margin for error.
+		// This could also be the average score of all items instead of a fixed value.
+		$bayesMean = ($confidencePercentage / 100) * glsr()->constant('MAX_RATING'); // prior, 70% = 3.5
+		// Represents the number of ratings expected to begin observing a pattern that would put confidence in the prior.
+		$bayesMinimal = 10; // confidence
+		$numOfReviews = array_sum($ratingCounts);
+		return $avgRating > 0
+			? (($bayesMinimal * $bayesMean) + ($avgRating * $numOfReviews)) / ($bayesMinimal + $numOfReviews)
+			: 0;
+	}
 
-    /**
-     * The quality of a 5 star rating depends not only on the average number of stars but also on
-     * the number of reviews. This method calculates the bayesian ranking of a page by its number
-     * of reviews and their rating.
-     * @see http://www.evanmiller.org/ranking-items-with-star-ratings.html
-     * @see https://stackoverflow.com/questions/1411199/what-is-a-better-way-to-sort-by-a-5-star-rating/1411268
-     * @see http://julesjacobs.github.io/2015/08/17/bayesian-scoring-of-ratings.html
-     * @param int $confidencePercentage
-     * @return float
-     */
-    public function getRankingUsingZScores(array $ratingCounts, $confidencePercentage = 90)
-    {
-        $ratingCountsSum = array_sum($ratingCounts) + glsr()->constant('MAX_RATING');
-        $weight = $this->getWeight($ratingCounts, $ratingCountsSum);
-        $weightPow2 = $this->getWeight($ratingCounts, $ratingCountsSum, true);
-        $zScore = static::CONFIDENCE_LEVEL_Z_SCORES[$confidencePercentage];
-        return $weight - $zScore * sqrt(($weightPow2 - pow($weight, 2)) / ($ratingCountsSum + 1));
-    }
+	/**
+	 * The quality of a 5 star rating depends not only on the average number of stars but also on
+	 * the number of reviews. This method calculates the bayesian ranking of a page by its number
+	 * of reviews and their rating.
+	 * @see http://www.evanmiller.org/ranking-items-with-star-ratings.html
+	 * @see https://stackoverflow.com/questions/1411199/what-is-a-better-way-to-sort-by-a-5-star-rating/1411268
+	 * @see http://julesjacobs.github.io/2015/08/17/bayesian-scoring-of-ratings.html
+	 * @param int $confidencePercentage
+	 * @return float
+	 */
+	public function getRankingUsingZScores(array $ratingCounts, $confidencePercentage = 90)
+	{
+		$ratingCountsSum = array_sum($ratingCounts) + glsr()->constant('MAX_RATING');
+		$weight = $this->getWeight($ratingCounts, $ratingCountsSum);
+		$weightPow2 = $this->getWeight($ratingCounts, $ratingCountsSum, true);
+		$zScore = static::CONFIDENCE_LEVEL_Z_SCORES[$confidencePercentage];
+		return $weight - $zScore * sqrt(($weightPow2 - pow($weight, 2)) / ($ratingCountsSum + 1));
+	}
 
-    /**
-     * @param int $target
-     * @return array
-     */
-    protected function getRoundedPercentages(array $percentages, $totalPercent = 100)
-    {
-        array_walk($percentages, function (&$percent, $index) {
-            $percent = [
-                'index' => $index,
-                'percent' => floor($percent),
-                'remainder' => fmod($percent, 1),
-            ];
-        });
-        $indexes = glsr_array_column($percentages, 'index');
-        $remainders = glsr_array_column($percentages, 'remainder');
-        array_multisort($remainders, SORT_DESC, SORT_STRING, $indexes, SORT_DESC, $percentages);
-        $i = 0;
-        if (array_sum(glsr_array_column($percentages, 'percent')) > 0) {
-            while (array_sum(glsr_array_column($percentages, 'percent')) < $totalPercent) {
-                ++$percentages[$i]['percent'];
-                ++$i;
-            }
-        }
-        array_multisort($indexes, SORT_DESC, $percentages);
-        return array_combine($indexes, glsr_array_column($percentages, 'percent'));
-    }
+	/**
+	 * @param int $target
+	 * @return array
+	 */
+	protected function getRoundedPercentages(array $percentages, $totalPercent = 100)
+	{
+		array_walk($percentages, function (&$percent, $index) {
+			$percent = [
+				'index' => $index,
+				'percent' => floor($percent),
+				'remainder' => fmod($percent, 1),
+			];
+		});
+		$indexes = glsr_array_column($percentages, 'index');
+		$remainders = glsr_array_column($percentages, 'remainder');
+		array_multisort($remainders, SORT_DESC, SORT_STRING, $indexes, SORT_DESC, $percentages);
+		$i = 0;
+		if (array_sum(glsr_array_column($percentages, 'percent')) > 0) {
+			while (array_sum(glsr_array_column($percentages, 'percent')) < $totalPercent) {
+				++$percentages[$i]['percent'];
+				++$i;
+			}
+		}
+		array_multisort($indexes, SORT_DESC, $percentages);
+		return array_combine($indexes, glsr_array_column($percentages, 'percent'));
+	}
 
-    /**
-     * @return int
-     */
-    protected function getTotalSum(array $ratingCounts)
-    {
-        return array_reduce(array_keys($ratingCounts), function ($carry, $index) use ($ratingCounts) {
-            return $carry + ($index * $ratingCounts[$index]);
-        });
-    }
+	/**
+	 * @return int
+	 */
+	protected function getTotalSum(array $ratingCounts)
+	{
+		return array_reduce(array_keys($ratingCounts), function ($carry, $index) use ($ratingCounts) {
+			return $carry + ($index * $ratingCounts[$index]);
+		});
+	}
 
-    /**
-     * @param int|float $ratingCountsSum
-     * @param bool $powerOf2
-     * @return float
-     */
-    protected function getWeight(array $ratingCounts, $ratingCountsSum, $powerOf2 = false)
-    {
-        return array_reduce(array_keys($ratingCounts),
-            function ($count, $rating) use ($ratingCounts, $ratingCountsSum, $powerOf2) {
-                $ratingLevel = $powerOf2
-                    ? pow($rating, 2)
-                    : $rating;
-                return $count + ($ratingLevel * ($ratingCounts[$rating] + 1)) / $ratingCountsSum;
-            }
-        );
-    }
+	/**
+	 * @param int|float $ratingCountsSum
+	 * @param bool $powerOf2
+	 * @return float
+	 */
+	protected function getWeight(array $ratingCounts, $ratingCountsSum, $powerOf2 = false)
+	{
+		return array_reduce(array_keys($ratingCounts),
+			function ($count, $rating) use ($ratingCounts, $ratingCountsSum, $powerOf2) {
+				$ratingLevel = $powerOf2
+					? pow($rating, 2)
+					: $rating;
+				return $count + ($ratingLevel * ($ratingCounts[$rating] + 1)) / $ratingCountsSum;
+			}
+		);
+	}
 }

plugin/Contracts/ShortcodeContract.php

Indentation +5 added lines, -5 removed lines

@@ -4,9 +4,9 @@
 
 interface ShortcodeContract
 {
-    /**
-     * @params string|array $atts
-     * @return string
-     */
-    public function buildShortcode($atts = []);
+	/**
+	 * @params string|array $atts
+	 * @return string
+	 */
+	public function buildShortcode($atts = []);
 }

plugin/Contracts/HooksContract.php

Indentation +4 added lines, -4 removed lines

@@ -4,8 +4,8 @@
 
 interface HooksContract
 {
-    /**
-     * @return void
-     */
-    public function run();
+	/**
+	 * @return void
+	 */
+	public function run();
 }

plugin/Contracts/PartialContract.php

Indentation +4 added lines, -4 removed lines

@@ -4,8 +4,8 @@
 
 interface PartialContract
 {
-    /**
-     * @return void|string
-     */
-    public function build(array $args = []);
+	/**
+	 * @return void|string
+	 */
+	public function build(array $args = []);
 }

plugin/Contracts/ProviderContract.php

Indentation +4 added lines, -4 removed lines

@@ -6,8 +6,8 @@
 
 interface ProviderContract
 {
-    /**
-     * @return void
-     */
-    public function register(Application $app);
+	/**
+	 * @return void
+	 */
+	public function register(Application $app);
 }