From 818ad5b34962f043da3d12d464b4329337acdab9 Mon Sep 17 00:00:00 2001 From: cbeauvoi Date: Fri, 8 Feb 2019 16:41:47 +0100 Subject: [PATCH] first commit --- LICENSE | 21 ++ composer.json | 21 ++ composer.lock | 19 ++ src/Validator.php | 443 +++++++++++++++++++++++++++++++ src/YourClass.php | 29 +++ vendor/autoload.php | 7 + vendor/composer/ClassLoader.php | 445 ++++++++++++++++++++++++++++++++ vendor/composer/LICENSE | 21 ++ vendor/composer/autoload_classmap.php | 9 + vendor/composer/autoload_namespaces.php | 9 + vendor/composer/autoload_psr4.php | 10 + vendor/composer/autoload_real.php | 52 ++++ vendor/composer/autoload_static.php | 31 +++ vendor/composer/installed.json | 1 + 14 files changed, 1118 insertions(+) create mode 100644 LICENSE create mode 100644 composer.json create mode 100644 composer.lock create mode 100644 src/Validator.php create mode 100644 src/YourClass.php create mode 100644 vendor/autoload.php create mode 100644 vendor/composer/ClassLoader.php create mode 100644 vendor/composer/LICENSE create mode 100644 vendor/composer/autoload_classmap.php create mode 100644 vendor/composer/autoload_namespaces.php create mode 100644 vendor/composer/autoload_psr4.php create mode 100644 vendor/composer/autoload_real.php create mode 100644 vendor/composer/autoload_static.php create mode 100644 vendor/composer/installed.json diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..192b1c3 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +DON'T BE A DICK PUBLIC LICENSE + +Version 1, December 2009 + +Copyright (C) 2009 Philip Sturgeon email@philsturgeon.co.uk + +Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed. + +DON'T BE A DICK PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + +Do whatever you like with the original work, just don't be a dick. + +Being a dick includes - but is not limited to - the following instances: + +1a. Outright copyright infringement - Don't just copy this and change the name. +1b. Selling the unmodified original with no work done what-so-ever, that's REALLY being a dick. +1c. Modifying the original work to contain hidden harmful content. That would make you a PROPER dick. + +If you become rich through modifications, related works/services, or supporting the original work, share the love. Only a dick would make loads off this work and not buy the original works creator(s) a pint. + +Code is provided with no warranty. Using somebody else's code and bitching when it goes wrong makes you a DONKEY dick. Fix the problem yourself. A non-dick would submit the fix back. \ No newline at end of file diff --git a/composer.json b/composer.json new file mode 100644 index 0000000..a887f32 --- /dev/null +++ b/composer.json @@ -0,0 +1,21 @@ +{ + "name": "bluesquare/validator", + "description": "Valitor create by Bluesquare Computing", + "keywords": ["template", "composer", "package"], + "license": "proprietary", + "authors": [ + { + "name": "RENOU Maxime", + "email": "maxime@bluesquare.io" + } + ], + "type": "project", + "require": { + "php": ">=7.1" + }, + "autoload": { + "psr-4": { + "Bluesquare\\Validator\\": "src/" + } + } +} diff --git a/composer.lock b/composer.lock new file mode 100644 index 0000000..4b1b846 --- /dev/null +++ b/composer.lock @@ -0,0 +1,19 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "2b969204dfdd0a26825f219258fb390c", + "packages": [], + "packages-dev": [], + "aliases": [], + "minimum-stability": "stable", + "stability-flags": [], + "prefer-stable": false, + "prefer-lowest": false, + "platform": { + "php": ">=7.1" + }, + "platform-dev": [] +} diff --git a/src/Validator.php b/src/Validator.php new file mode 100644 index 0000000..49e7623 --- /dev/null +++ b/src/Validator.php @@ -0,0 +1,443 @@ +values = []; + $this->errors = []; + $this->rules = []; + $this->validated = false; + + $this->translator = $translator; + $this->request = $requestStack->getCurrentRequest(); + + $session = $this->request->getSession()->getFlashBag()->get("Bluesquare:Validator"); + + if(is_array($session) && isset($session[0])) { + if(isset($session[0]['context'])) $this->context = $session[0]['context']; + if(isset($session[0]['errors']) && is_array($session[0]['errors'])) $this->errors = $session[0]['errors']; + if(isset($session[0]['values']) && is_array($session[0]['values'])) $this->values = $session[0]['values']; + $this->validated = true; + } + + if ($this->post()) + { + $values = []; + foreach (array_merge($_GET, $_POST) as $field => $value) $values[$field] = $value; + $json = @json_decode(file_get_contents('php://input'), true); + if (is_array($json)) $values = array_merge($values, $json); + $this->values = array_merge($this->values, $values); + } + } + + // + + public function context($context) + { + $this->context = $context; + return $this; + } + + public function entity($entity) + { + $this->entity = $entity; + return $this; + } + + public function set($key, $value) + { + $this->values[$key] = $value; + return $this; + } + + public function error($field, $error) + { + if (!isset($this->errors[$field])) + $this->errors[$field] = []; + + $this->errors[$field][] = $error; + + return $this; + } + + // + + public function json($code = 400, $data = []) + { + $data = array_merge([ + 'message' => 'Please check your input', + 'error' => 'validator.form-error', + 'errors' => array_map(function ($errors) { + return "validator.".$errors[0].(!is_null($this->context) ? ':'.$this->context : ''); + }, $this->errors) + ], $data); + + return new JsonResponse($data, $code); + } + + public function keep() + { + $data = [ + 'errors' => $this->errors, + 'values' => $this->values, + 'context' => $this->context + ]; + $this->request->getSession()->getFlashBag()->add('Bluesquare:Validator', $data); + return $this; + } + + public function validated() + { + return $this->validated; + } + + public function failed() + { + return (count($this->errors) > 0); + } + + public function errors() + { + $translator = $this->translator; + $context = $this->context; + + return array_map(function ($errors) use ($translator, $context) { + $error = $errors[0]; + $message = null; + if (!is_null($context)) { + $message = $translator->trans("$context.$error", [], "validator"); + } + if (is_null($message) || $message == "$context.$error") { + $message = $translator->trans("$error", [], "validator"); + } + return $message; + }, $this->errors); + } + + public function message() + { + $result = $this->failed() ? 'form-error' : 'form-success'; + $message = null; + if (!is_null($this->context)) { + $message = $this->translator->trans("$this->context.$result", [], "validator"); + } + if (is_null($message) || $message == "$this->context.$result") { + $message = $this->translator->trans("$result", [], "validator"); + } + return $message; + } + + public function has($field) + { + return !is_null($this->get($field)); + } + + public function value($field, $default = null) + { + $value = isset($this->values[$field]) ? trim($this->values[$field]) : $default; + if (empty($value)) $value = $default; + + if (is_null($value) && !is_null($this->entity)) { + $method = "get".$this->camelize($field); + if (method_exists($this->entity, $method)) + $value = $this->entity->$method(); + } + + return $value; + } + + public function get($field, $default = null) + { + $value = isset($this->values[$field]) ? trim($this->values[$field]) : $default; + if (empty($value)) $value = $default; + return $value; + } + + public function checked($field) + { + return !is_null($this->get($field)) || $this->get($field) != '0' || $this->get($field) != 0; + } + + public function getFile($name) + { + return $this->request->files->get($name); + } + + public function hasFile($name) + { + $file = $this->getFile($name); + return !is_null($file) && !(is_array($file) || $file instanceof Traversable); + } + + public function hasFiles($name) + { + $files = $this->getFile($name); + return !is_null($files) && (is_array($files) || $files instanceof Traversable); + } + + public function inject() + { + $args = func_get_args(); + if (count($args) === 0) return false; + if (is_object($args[0])) $entity = array_shift($args); + else $entity = $this->entity; + if (is_null($entity)) return false; + + foreach ($args as $field) { + $method = "set".$this->camelize($field); + if (method_exists($entity, $method)) $entity->$method($this->value($field)); + } + + return true; + } + + // + + public function post() + { + return in_array(strtolower($this->request->getMethod()), ['delete', 'put', 'post', 'patch']); + } + + public function check() + { + return $this->validate(); + } + + // + + protected function validate() + { + foreach ($this->rules as $field => $rules) + { + foreach ($rules as $rule) $this->test($field, $rule); + } + + $this->validated = true; + + return (count($this->errors) == 0); + } + + public function test($field, $rule) + { + $name = $rule['rule']; + $data = $rule['data']; + $value = $this->get($field); + $success = true; + + switch ($name) + { + case 'required-file': + $success = $this->hasFile($field); + break; + case 'required-files': + $success = $this->hasFiles($field); + break; + case 'required': + $success = !(is_null($value)); + break; + case 'integer': + $success = (filter_var($value, FILTER_VALIDATE_INT) ? true : false); + break; + case 'float': + $success = (filter_var($value, FILTER_VALIDATE_FLOAT) ? true : false); + break; + case 'boolean': + $success = (filter_var($value, FILTER_VALIDATE_BOOLEAN) ? true : false); + break; + case 'email': + $success = (filter_var($value, FILTER_VALIDATE_EMAIL) ? true : false); + break; + case 'phone': + $_pattern = "/^\+?\d{7,15}$/"; + $success = (!(strlen($value) == 10 && ctype_digit($value)) && !preg_match($_pattern, $value)) ? false : true; + break; + case 'zipcode': + $success = (!(strlen($value) == 5 && ctype_digit($value))) ? false : true; + break; + case 'alphanumeric': + $success = ctype_alnum($value); + break; + case 'date': + $success = preg_match('/^([0-9]{2}\/[0-9]{2}\/[0-9]{4})|([0-9]{4}-[0-9]{2}-[0-9]{2})$/', $value); + break; + case 'datetime': + $_pattern = "[0-9]{4}\-[0-9]{2}\-[0-9]{2}\ [0-9]{1,2}\:[0-9]{1,2}\:[0-9]{1,2}"; + $success = (preg_matchs($_pattern, $value)) ? true : false; + break; + case 'url': + $_pattern = "%^((?:(?:https?|ftp)://))?(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\x{00a1}-\x{ffff}0-9]-*)*[a-z\x{00a1}-\x{ffff}0-9]+)(?:\.(?:[a-z\x{00a1}-\x{ffff}0-9]-*)*[a-z\x{00a1}-\x{ffff}0-9]+)*(?:\.(?:[a-z\x{00a1}-\x{ffff}]{2,}))\.?)(?::\d{2,5})?(?:[/?#]\S*)?$%iuS"; + $success = preg_match($_pattern, $value); + break; + case 'inArray': + $success = in_array($value, $data['values']); + break; + case 'min': + $success = min($value, $data['length']) == $value ? true : false; + break; + case 'max': + $success = max($value, $data['length']) == $value ? true : false; + break; + case 'minLength': + $success = strlen($value) < $data['min-length'] ? true : false; + break; + case 'maxLength': + $success = strlen($value) > $data['min-length'] ? true : false; + break; + // (éwé c'est un switch) + } + + if (!$success) { + $this->error($field, $name); + } + + return $success; + } + + public function rule($field, $rule, $data = []) + { + if (!isset($this->rules[$field])) + $this->rules[$field] = []; + + $this->rules[$field][] = ['rule' => $rule, 'data' => $data]; + + return $this; + } + + // Rules: multiple + + public function required() + { + foreach (func_get_args() as $field) $this->rule($field, 'required'); + return $this; + } + + public function integer() + { + foreach (func_get_args() as $field) $this->rule($field, 'integer'); + return $this; + } + + public function float() + { + foreach (func_get_args() as $field) $this->rule($field, 'float'); + return $this; + } + + public function boolean() + { + foreach (func_get_args() as $field) $this->rule($field, 'boolean'); + return $this; + } + + public function email() + { + foreach (func_get_args() as $field) $this->rule($field, 'email'); + return $this; + } + + public function phone() + { + foreach (func_get_args() as $field) $this->rule($field, 'phone'); + return $this; + } + + public function zipcode() + { + foreach (func_get_args() as $field) $this->rule($field, 'zipcode'); + return $this; + } + + public function alphanumeric() + { + foreach (func_get_args() as $field) $this->rule($field, 'alphanumeric'); + return $this; + } + + public function date() + { + foreach (func_get_args() as $field) $this->rule($field, 'date'); + return $this; + } + + public function datetime() + { + foreach (func_get_args() as $field) $this->rule($field, 'datetime'); + return $this; + } + + public function url() + { + foreach (func_get_args() as $field) $this->rule($field, 'url'); + return $this; + } + + // Rules: single + + public function requiredFile($name) + { + $this->rule($name, 'required-file'); + return $this; + } + + public function requiredFiles($name) + { + $this->rule($name, 'required-files'); + return $this; + } + + public function min($field, $length) + { + $this->rule($field, 'min', ['length' => $length]); + return $this; + } + + public function max($field, $length) + { + $this->rule($field, 'max', ['length' => $length]); + return $this; + } + + public function minLength($field, $length) + { + $this->rule($field, 'min-length', ['length' => $length]); + return $this; + } + + public function maxLength($field, $length) + { + $this->rule($field, 'max-length', ['length' => $length]); + return $this; + } + + public function inArray($field, $values) + { + $this->rule($field, 'inArray', ['values' => $values]); + return $this; + } + + // Helpers + + protected function camelize($string) + { + $string = implode('_', explode('-', $string)); + $words = array_map('ucfirst', explode('_', $string)); + return implode('', $words); + } +} diff --git a/src/YourClass.php b/src/YourClass.php new file mode 100644 index 0000000..0be6b6d --- /dev/null +++ b/src/YourClass.php @@ -0,0 +1,29 @@ + + * Jordi Boggiano + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +namespace Composer\Autoload; + +/** + * ClassLoader implements a PSR-0, PSR-4 and classmap class loader. + * + * $loader = new \Composer\Autoload\ClassLoader(); + * + * // register classes with namespaces + * $loader->add('Symfony\Component', __DIR__.'/component'); + * $loader->add('Symfony', __DIR__.'/framework'); + * + * // activate the autoloader + * $loader->register(); + * + * // to enable searching the include path (eg. for PEAR packages) + * $loader->setUseIncludePath(true); + * + * In this example, if you try to use a class in the Symfony\Component + * namespace or one of its children (Symfony\Component\Console for instance), + * the autoloader will first look for the class under the component/ + * directory, and it will then fallback to the framework/ directory if not + * found before giving up. + * + * This class is loosely based on the Symfony UniversalClassLoader. + * + * @author Fabien Potencier + * @author Jordi Boggiano + * @see http://www.php-fig.org/psr/psr-0/ + * @see http://www.php-fig.org/psr/psr-4/ + */ +class ClassLoader +{ + // PSR-4 + private $prefixLengthsPsr4 = array(); + private $prefixDirsPsr4 = array(); + private $fallbackDirsPsr4 = array(); + + // PSR-0 + private $prefixesPsr0 = array(); + private $fallbackDirsPsr0 = array(); + + private $useIncludePath = false; + private $classMap = array(); + private $classMapAuthoritative = false; + private $missingClasses = array(); + private $apcuPrefix; + + public function getPrefixes() + { + if (!empty($this->prefixesPsr0)) { + return call_user_func_array('array_merge', $this->prefixesPsr0); + } + + return array(); + } + + public function getPrefixesPsr4() + { + return $this->prefixDirsPsr4; + } + + public function getFallbackDirs() + { + return $this->fallbackDirsPsr0; + } + + public function getFallbackDirsPsr4() + { + return $this->fallbackDirsPsr4; + } + + public function getClassMap() + { + return $this->classMap; + } + + /** + * @param array $classMap Class to filename map + */ + public function addClassMap(array $classMap) + { + if ($this->classMap) { + $this->classMap = array_merge($this->classMap, $classMap); + } else { + $this->classMap = $classMap; + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, either + * appending or prepending to the ones previously set for this prefix. + * + * @param string $prefix The prefix + * @param array|string $paths The PSR-0 root directories + * @param bool $prepend Whether to prepend the directories + */ + public function add($prefix, $paths, $prepend = false) + { + if (!$prefix) { + if ($prepend) { + $this->fallbackDirsPsr0 = array_merge( + (array) $paths, + $this->fallbackDirsPsr0 + ); + } else { + $this->fallbackDirsPsr0 = array_merge( + $this->fallbackDirsPsr0, + (array) $paths + ); + } + + return; + } + + $first = $prefix[0]; + if (!isset($this->prefixesPsr0[$first][$prefix])) { + $this->prefixesPsr0[$first][$prefix] = (array) $paths; + + return; + } + if ($prepend) { + $this->prefixesPsr0[$first][$prefix] = array_merge( + (array) $paths, + $this->prefixesPsr0[$first][$prefix] + ); + } else { + $this->prefixesPsr0[$first][$prefix] = array_merge( + $this->prefixesPsr0[$first][$prefix], + (array) $paths + ); + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, either + * appending or prepending to the ones previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param array|string $paths The PSR-4 base directories + * @param bool $prepend Whether to prepend the directories + * + * @throws \InvalidArgumentException + */ + public function addPsr4($prefix, $paths, $prepend = false) + { + if (!$prefix) { + // Register directories for the root namespace. + if ($prepend) { + $this->fallbackDirsPsr4 = array_merge( + (array) $paths, + $this->fallbackDirsPsr4 + ); + } else { + $this->fallbackDirsPsr4 = array_merge( + $this->fallbackDirsPsr4, + (array) $paths + ); + } + } elseif (!isset($this->prefixDirsPsr4[$prefix])) { + // Register directories for a new namespace. + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = (array) $paths; + } elseif ($prepend) { + // Prepend directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + (array) $paths, + $this->prefixDirsPsr4[$prefix] + ); + } else { + // Append directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + $this->prefixDirsPsr4[$prefix], + (array) $paths + ); + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, + * replacing any others previously set for this prefix. + * + * @param string $prefix The prefix + * @param array|string $paths The PSR-0 base directories + */ + public function set($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr0 = (array) $paths; + } else { + $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths; + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, + * replacing any others previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param array|string $paths The PSR-4 base directories + * + * @throws \InvalidArgumentException + */ + public function setPsr4($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr4 = (array) $paths; + } else { + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = (array) $paths; + } + } + + /** + * Turns on searching the include path for class files. + * + * @param bool $useIncludePath + */ + public function setUseIncludePath($useIncludePath) + { + $this->useIncludePath = $useIncludePath; + } + + /** + * Can be used to check if the autoloader uses the include path to check + * for classes. + * + * @return bool + */ + public function getUseIncludePath() + { + return $this->useIncludePath; + } + + /** + * Turns off searching the prefix and fallback directories for classes + * that have not been registered with the class map. + * + * @param bool $classMapAuthoritative + */ + public function setClassMapAuthoritative($classMapAuthoritative) + { + $this->classMapAuthoritative = $classMapAuthoritative; + } + + /** + * Should class lookup fail if not found in the current class map? + * + * @return bool + */ + public function isClassMapAuthoritative() + { + return $this->classMapAuthoritative; + } + + /** + * APCu prefix to use to cache found/not-found classes, if the extension is enabled. + * + * @param string|null $apcuPrefix + */ + public function setApcuPrefix($apcuPrefix) + { + $this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null; + } + + /** + * The APCu prefix in use, or null if APCu caching is not enabled. + * + * @return string|null + */ + public function getApcuPrefix() + { + return $this->apcuPrefix; + } + + /** + * Registers this instance as an autoloader. + * + * @param bool $prepend Whether to prepend the autoloader or not + */ + public function register($prepend = false) + { + spl_autoload_register(array($this, 'loadClass'), true, $prepend); + } + + /** + * Unregisters this instance as an autoloader. + */ + public function unregister() + { + spl_autoload_unregister(array($this, 'loadClass')); + } + + /** + * Loads the given class or interface. + * + * @param string $class The name of the class + * @return bool|null True if loaded, null otherwise + */ + public function loadClass($class) + { + if ($file = $this->findFile($class)) { + includeFile($file); + + return true; + } + } + + /** + * Finds the path to the file where the class is defined. + * + * @param string $class The name of the class + * + * @return string|false The path if found, false otherwise + */ + public function findFile($class) + { + // class map lookup + if (isset($this->classMap[$class])) { + return $this->classMap[$class]; + } + if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) { + return false; + } + if (null !== $this->apcuPrefix) { + $file = apcu_fetch($this->apcuPrefix.$class, $hit); + if ($hit) { + return $file; + } + } + + $file = $this->findFileWithExtension($class, '.php'); + + // Search for Hack files if we are running on HHVM + if (false === $file && defined('HHVM_VERSION')) { + $file = $this->findFileWithExtension($class, '.hh'); + } + + if (null !== $this->apcuPrefix) { + apcu_add($this->apcuPrefix.$class, $file); + } + + if (false === $file) { + // Remember that this class does not exist. + $this->missingClasses[$class] = true; + } + + return $file; + } + + private function findFileWithExtension($class, $ext) + { + // PSR-4 lookup + $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext; + + $first = $class[0]; + if (isset($this->prefixLengthsPsr4[$first])) { + $subPath = $class; + while (false !== $lastPos = strrpos($subPath, '\\')) { + $subPath = substr($subPath, 0, $lastPos); + $search = $subPath . '\\'; + if (isset($this->prefixDirsPsr4[$search])) { + $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1); + foreach ($this->prefixDirsPsr4[$search] as $dir) { + if (file_exists($file = $dir . $pathEnd)) { + return $file; + } + } + } + } + } + + // PSR-4 fallback dirs + foreach ($this->fallbackDirsPsr4 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) { + return $file; + } + } + + // PSR-0 lookup + if (false !== $pos = strrpos($class, '\\')) { + // namespaced class name + $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1) + . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR); + } else { + // PEAR-like class name + $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext; + } + + if (isset($this->prefixesPsr0[$first])) { + foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) { + if (0 === strpos($class, $prefix)) { + foreach ($dirs as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + } + } + } + + // PSR-0 fallback dirs + foreach ($this->fallbackDirsPsr0 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + + // PSR-0 include paths. + if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) { + return $file; + } + + return false; + } +} + +/** + * Scope isolated include. + * + * Prevents access to $this/self from included files. + */ +function includeFile($file) +{ + include $file; +} diff --git a/vendor/composer/LICENSE b/vendor/composer/LICENSE new file mode 100644 index 0000000..f27399a --- /dev/null +++ b/vendor/composer/LICENSE @@ -0,0 +1,21 @@ + +Copyright (c) Nils Adermann, Jordi Boggiano + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php new file mode 100644 index 0000000..7a91153 --- /dev/null +++ b/vendor/composer/autoload_classmap.php @@ -0,0 +1,9 @@ + array($baseDir . '/src'), +); diff --git a/vendor/composer/autoload_real.php b/vendor/composer/autoload_real.php new file mode 100644 index 0000000..31ed418 --- /dev/null +++ b/vendor/composer/autoload_real.php @@ -0,0 +1,52 @@ += 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded()); + if ($useStaticLoader) { + require_once __DIR__ . '/autoload_static.php'; + + call_user_func(\Composer\Autoload\ComposerStaticInit6706b1de9dd094294798ed047d274019::getInitializer($loader)); + } else { + $map = require __DIR__ . '/autoload_namespaces.php'; + foreach ($map as $namespace => $path) { + $loader->set($namespace, $path); + } + + $map = require __DIR__ . '/autoload_psr4.php'; + foreach ($map as $namespace => $path) { + $loader->setPsr4($namespace, $path); + } + + $classMap = require __DIR__ . '/autoload_classmap.php'; + if ($classMap) { + $loader->addClassMap($classMap); + } + } + + $loader->register(true); + + return $loader; + } +} diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php new file mode 100644 index 0000000..adfce18 --- /dev/null +++ b/vendor/composer/autoload_static.php @@ -0,0 +1,31 @@ + + array ( + 'Bluesquare\\Validator\\' => 21, + ), + ); + + public static $prefixDirsPsr4 = array ( + 'Bluesquare\\Validator\\' => + array ( + 0 => __DIR__ . '/../..' . '/src', + ), + ); + + public static function getInitializer(ClassLoader $loader) + { + return \Closure::bind(function () use ($loader) { + $loader->prefixLengthsPsr4 = ComposerStaticInit6706b1de9dd094294798ed047d274019::$prefixLengthsPsr4; + $loader->prefixDirsPsr4 = ComposerStaticInit6706b1de9dd094294798ed047d274019::$prefixDirsPsr4; + + }, null, ClassLoader::class); + } +} diff --git a/vendor/composer/installed.json b/vendor/composer/installed.json new file mode 100644 index 0000000..fe51488 --- /dev/null +++ b/vendor/composer/installed.json @@ -0,0 +1 @@ +[]