Zec Data Parsing
v1.0.0
La bibliothèque Zec Data Parsing est conçue pour apporter des capacités de définition et de validation de schéma aux applications PHP.
composer require mohamed-amine-sayagh/zecVoici un exemple d'utilisation de la bibliothèque Zec pour définir et valider un schéma de profil utilisateur :
use function Zec Utils z ;
// Define the user profile schema
$ userProfileParser = z ()-> options ([
' name ' => z ()-> string ()-> min ( 3 )-> max ( 50 ), // Name must be a string between 3 and 50 characters
' age ' => z ()-> number ()-> min ( 18 ), // Age must be a number and at least 18
' email ' => z ()-> email (), // Email must be a valid email address
' address ' => z ()-> options ([
' street ' => z ()-> string (),
' city ' => z ()-> string ()
]),
' hobbies ' => z ()-> each ( z ()-> string ()), // Hobbies must be an array of strings
' metadata ' => z ()-> optional ()-> each ( z ()-> options ([ // Metadata is optional and must be an array of objects
' key ' => z ()-> string (), // Each object must have a key as a string
' value ' => z ()-> string () // Each object must have a value as a string
]))
]); // Parse and validate user data
$ userData = [
' name ' => ' Jane Doe ' ,
' age ' => 1 , // 1 is not a valid age
' email ' => ' jane.doe@examplecom ' , // missing dot
' address ' => [
' street ' => ' 123 Elm St ' ,
' city ' => 3 // city is not a string
],
' hobbies ' => [ ' photography ' , ' traveling ' , ' reading ' , 5 ], // 5 is not a string
' metadata ' => [
[ ' key ' => ' memberSince ' , ' value ' => ' 2019 ' ],
[ ' key ' => ' newsletter ' , ' value ' => ' true ' ]
]
];
try {
$ userProfileParser -> parseOrThrow ( $ userData ); // Throws an error
echo " User data is valid n" ;
} catch ( Zec ZecError $ e ) {
echo " User data is invalid: " ;
$ e -> log (); // Log the error
} User data is invalid: [
{
"parser": "min",
"value": 1,
"min": 18,
"message": "Invalid value",
"path": [
"age"
]
},
{
"parser": "email",
"value": "jane.doe@examplecom",
"message": "Invalid email address",
"path": [
"email"
]
},
{
"parser": "string",
"value": 5,
"message": "Invalid string value",
"path": [
"hobbies",
"3"
]
}
]
Version actuelle : v1.0.0, Date de sortie : 2024-10-01, Auteur : Mohamed Amine SAYAGH, Notes de version : Version initiale de la bibliothèque d'analyse de données Zec PHP., Lien de version : [Zec 1.0.0](
Remarque : Cette bibliothèque est actuellement en développement. La documentation officielle et d'autres ressources seront bientôt disponibles.
Informations sur l'auteur :
Nous sommes entièrement ouverts à la collaboration ! Si vous souhaitez contribuer à la bibliothèque d'analyse de données PHP, nous serions ravis de vous entendre. Qu'il s'agisse de contributions au code, d'améliorations de la documentation ou de suggestions de fonctionnalités, votre contribution est la bienvenue.
Pour plus de détails, consultez nos directives de contribution (lien vers les directives de contribution détaillées si disponibles).
Nous sommes impatients de créer un puissant outil d'analyse de données avec une communauté dynamique de contributeurs !
Définissez et validez les types de données à l'aide de définitions de schéma simples :
use function Zec Utils z ;
$ my_schema = z ()-> string ();
$ response_valid = $ my_schema -> parse ( " Hello, World! " ); // Returns Zec data object
$ value = $ response_valid -> value ; // Returns "Hello, World!"
$ response_invalid = $ my_schema -> parse ( 123 ); // Returns Zec data object
$ errors = $ response_invalid -> errors ; // Returns an array of ZecError object an exception extends classValidez rapidement les données après l'analyse :
$ is_valid = $ my_schema -> parse ( " Hello, World! " )-> isValid (); // Returns true
$ is_invalid = $ my_schema -> parse ( 123 )-> isValid (); // Returns falseGérez les exceptions à l'aide de parse_or_throw pour la validation des données critiques :
try {
$ response = $ my_schema -> parseOrThrow ( 123 ); // Throws ZecError
} catch ( ZecError $ error ) {
$ error_message = $ error -> message ; // Returns "Invalid type: expected string, received integer"
$ error -> log (); // Logs the error
}Vous pouvez améliorer la définition du schéma en incorporant des options de validation supplémentaires. Cela permet un contrôle plus détaillé de la conformité des données en fonction d'exigences spécifiques.
use function Zec z ;
$ user_schema = z ()-> options ([
' name ' => z ()-> string ()-> min ( 3 )-> max ( 50 ),
' email ' => z ()-> email (),
' age ' => z ()-> number ()-> min ( 18 ),
' isActive ' => z ()-> boolean (),
' registrationDate ' => z ()-> date ()
]);
// Parsing a valid user object
$ valid_user = $ user_schema -> parse ([
' name ' => ' John Doe ' ,
' email ' => ' [email protected] ' ,
' age ' => 30 ,
' isActive ' => true ,
' registrationDate ' => ' 2021-01-01 '
]);
// Parsing an invalid user object
$ invalid_user = $ user_schema -> parse ([
' name ' => ' JD ' , // Too short
' email ' => ' john.doe@ ' , // Invalid email format
' age ' => 17 , // Below minimum age requirement
' isActive ' => ' yes ' , // Incorrect type (should be boolean)
' registrationDate ' => ' 01-01-2021 ' // Wrong date format
]);
// Handling validation results
if ( $ valid_user -> isValid ()) {
echo ' User is valid. ' ;
} else {
echo ' User is invalid. Errors: ' ;
var_dump ( $ valid_user -> errors ());
}
if ( $ invalid_user -> isValid ()) {
echo ' User is valid. ' ;
} else {
echo ' User is invalid. Errors: ' ;
var_dump ( $ invalid_user -> errors ());
}La bibliothèque offre une configurabilité étendue pour la validation des données, permettant aux utilisateurs de définir des règles de validation complexes avec des messages et des conditions personnalisés. Vous trouverez ci-dessous un exemple de configuration d'un schéma détaillé pour un champ de courrier électronique avec des règles de validation spécifiques :
use function Zec z ;
// Define a configurable email schema
$ my_configurable_email_schema = z ()-> string ([
' message ' => ' Invalid string data '
])-> min ([
' min ' => 3 ,
' message ' => ' String data must be at least 3 characters long ' // Custom message
])-> max ([
' max ' => 10 ,
' message ' => ' String {{value}} must be at most ((max)) characters long ' // Custom message with value interpolation
]). email ([
' message ' => ' Invalid email ' ,
' domain ' => [ ' gmail.com ' , ' yahoo.com ' ] // Custom domain validation rules
]);
// Define a user schema using the configurable email schema
$ my_user = z ()-> options ([
' email ' => $ my_configurable_email_schema -> required ()
]);Cet exemple montre la validation d'une structure de données utilisateur qui comprend des tableaux imbriqués, des champs facultatifs et des types d'union, démontrant la capacité de la bibliothèque à gérer des modèles de données complexes et réalistes.
use function Zec z ;
// Define a user schema with various data validation rules
$ user_parser = z ()-> options ([
' name ' => z ()-> required ()-> string ()-> min ( 3 )-> max ( 50 ),
' email ' => z ()-> url ([
' message ' => ' Invalid email address ' ,
' domain ' => [ ' gmail.com ' ]
]),
' age ' => z ()-> number (),
' friends ' => z ()-> each (
function ( $ user ) {
return $ user -> nullable ();
} // Each friend is a user object (nullable)
),
' password ' => z ()-> optional ()-> options ([
' password ' => z ()-> string (), // Path: 'password.password'
' confirm_password ' => z ()-> string (),
' created_at ' => z ()-> date (),
]),
' created_at ' => z ()-> date (),
' updated_at ' => z ()-> date (),
' document ' => z ()-> union ([
z ()-> options ([
' type ' => z ()-> enum ([ ' student ' ]),
' content ' => z ()-> options ([
' school ' => z ()-> string (),
' grade ' => z ()-> number (),
]),
]),
z ()-> options ([
' type ' => z ()-> enum ([ ' teacher ' ]),
' content ' => z ()-> options ([
' school ' => z ()-> string (),
' subject ' => z ()-> string (),
]),
]),
]) // Union type for document, can be student or teacher document
]);
// Parse a valid user object
$ user = $ user_parser -> parse ([
' name ' => ' John Doe ' ,
' email ' => ' [email protected] ' ,
' age ' => 25 ,
' friends ' => [
[
' name ' => ' Jane Doe ' ,
' email ' => ' [email protected] ' ,
' age ' => 30 ,
],
],
' password ' => [
' password ' => ' password ' ,
' confirm_password ' => ' password ' ,
' created_at ' => ' 2021-10-10 '
],
' created_at ' => ' 2021-10-10 ' ,
' updated_at ' => ' 2021-10-10 ' ,
' document ' => [
' type ' => ' student ' ,
' content ' => [
' school ' => ' School ' ,
' grade ' => 10 ,
]
]
]); // Returns a Zec object
// Validate the parsed data
if ( $ user -> isValid ()) {
echo ' User is valid. ' ;
var_dump ( $ user -> getValue ()); // Outputs the validated data
} else {
echo ' User is invalid. ' ;
var_dump ( $ user -> errors ()); // Outputs validation errors
} Pour améliorer la flexibilité et répondre aux besoins de validation spécifiques, notre bibliothèque permet aux utilisateurs de définir des méthodes d'analyse personnalisées. Cette section montre comment créer une méthode d'analyseur size , qui valide que la taille d'un tableau, la longueur d'une chaîne ou la valeur d'un nombre répond à une exigence spécifique.
La méthode size vérifie si :
Voici comment implémenter cet analyseur personnalisé :
use function Zec z ;
use function Zec bundler ;
use Zec FIELD as FK ;
$ custom_size_parser = parser_build ()
-> name ( ' size ' )
-> prioritize ( ' string ' , ' number ' , ' array ' ) // Prioritize the parser for string, number, and array types
-> argument ( ' message ' , ' Invalid size ' , function ( Zec Zec $ z ) {
return $ z -> required ()-> string ();
}) // argument for custom message, default is 'Invalid size'
-> argument ( ' size ' , 0 , function ( Zec Zec $ z ) {
return $ z -> required ()-> number ();
}) // argument for size, default is 0
-> function ( function ( array $ args ): string | bool {
$ value = $ args [ ' value ' ];
$ expected_size = $ args [ ' size ' ];
$ message = $ args [ ' message ' ];
if ( is_array ( $ value )) {
$ actual_size = count ( $ value );
} elseif ( is_string ( $ value )) {
$ actual_size = strlen ( $ value );
} elseif ( is_numeric ( $ value )) {
$ actual_size = $ value ;
} else {
return $ message ?? ' Invalid data type ' ;
}
if ( $ actual_size === $ expected_size ) {
return true ;
}
return $ message ?? ' Invalid size ' ;
})-> priority ( 4 ); // priority of the parser, the default priority of parser is 10, parser with 5 as priority will override before parser with 10 as priority if they have the same parser name
-> build (); // Build the parser
bundler-> addParser ( $ custom_size_parser ); Vous pouvez désormais utiliser la méthode d'analyseur size personnalisée dans vos définitions de schéma :
$ my_schema = z ()-> options ([
' username ' => z ()-> string ()-> size ( 5 ), // Username must be a string of length 5
' favorite_numbers ' => z ()-> array ()-> size ( 5 ), // Favorite numbers must be an array of length 5
' lucky_number ' => z ()-> number ()-> size ( 5 ), // Lucky number must be 5
]);
$ user_data = [
' username ' => ' admin ' ,
' favorite_numbers ' => [ 1 , 2 , 3 , 4 , 5 ],
' lucky_number ' => 5
]; // Valid data
$ parsed_data = $ my_schema -> parse ( $ user_data ); // Returns a Zec object
// Validate the parsed data
if ( $ parsed_data -> isValid ()) { // Returns true if data is valid
echo ' All data is valid. ' ;
} else {
echo ' Data validation failed. Errors: ' ;
var_dump ( $ parsed_data -> errors ()); // Outputs validation errors
}Ce projet est sous licence MIT - voir le fichier LICENSE.md pour plus de détails.
Copyright (c) 2024 Mohamed Amine SAYAGH
Tous droits réservés.
L'autorisation est accordée par la présente, gratuitement, à toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le « Logiciel »), d'utiliser le Logiciel sans restriction, y compris, sans limitation, les droits d'utilisation, de copie, de modification, de fusion. , publier, distribuer, accorder des sous-licences et/ou vendre des copies du Logiciel, et permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :
L'avis de droit d'auteur ci-dessus et cet avis d'autorisation doivent être inclus dans toutes les copies ou parties substantielles du logiciel.
LE LOGICIEL EST FOURNI « EN L'ÉTAT », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS MAIS SANS LIMITATION LES GARANTIES DE QUALITÉ MARCHANDE, D'ADAPTATION À UN USAGE PARTICULIER ET DE NON-VIOLATION. EN AUCUN CAS LES AUTEURS OU LES TITULAIRES DES DROITS D'AUTEUR NE SERONT RESPONSABLES DE TOUTE RÉCLAMATION, DOMMAGES OU AUTRE RESPONSABILITÉ, QUE CE SOIT DANS UNE ACTION CONTRACTUELLE, DÉLIT OU AUTRE, DÉCOULANT DE, DE OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES TRANSACTIONS DANS LE LOGICIEL.
