php monty

Monty

Framework de type Sinatra, axé sur la réponse et la fiabilité rapide.

Exemple de configuration

 $ composer require troublete/monty

 <?php
require_once ' path/to/vendor/autoload.php ' ;

$ application = new  Monty  Application ();

$ application -> get (
    ' /request[/{someId}] ' ,
    function (  Monty  Request $ req ,  Monty  Response $ res , $ someId ) {
        
        // do some awesome stuff
        
        return new  Symfony  Component  HttpFoundation  JsonResponse ([]);
    }
);

Routage

L'analyse de route est basée sur le package FastRoute créé Be @nikic, donc pour la plupart, il devrait être possible de définir des itinéraires comme spécifié par FastRoute. La correspondance d'itinéraire se fait via PCRE avec Delimiter Set sur @ , alors sachez lors de la définition du paramètre Regex défini par l'utilisateur avec @ . Les définitions d'itinéraire permettent des pièces variables à la fin d'une définition marquée de [] . Étant donné que cela est possible, la correspondance essaiera plusieurs expressions régulières par ordre de complexité descendant et reviendra sur la première correspondance de modèle.

Routage valide

 /search/{searchId} => routing with parameter
/search/{searchId:d+} => routing with parameter with defined regex
/search[/{searchId}] => routing with optional parameter
/search/index[es] => routing with optional part

Routage non valide

 /search/index[es]/{searchId} => optional chunk in the middle

Gestion des demandes

Le traitement des définitions sera traité par ordre d'enregistrement dès que l'on correspond à la demande reçue qu'elle expédiera, renverra et fera donc fermer le processus.

De plus, Monty est conçu pour être centré sur la demande et la réponse, après le dogme, une demande à une demande sera traitée une fois afin que tout ce nécessaire pendant le cycle de vie soit inclus (ou devrait être annexé) dans l'objet de demande ou de réponse.

Les gestionnaires sur une définition sont un tableau de callable et seront exécutés de manière synchrone dans l'ordre sur la correspondance de définition. Middlewares enregistré à exécuter avant ou après est intégré dans cette "pile d'appels".

Si un objet de réponse est renvoyé dans un gestionnaire, il est interprété comme la réponse du processus et ne peut pas être réinitialisé (mais modifié).

Application

L'application est le composant principal de Monty. Il gérera l'enregistrement des gestionnaires d'itinéraire, de Middlewares et une configuration supplémentaire de la demande et de la réponse. Il contient généralement quatre cas d'utilisation différents. Accéder à l'objet de demande ou de réponse du processus de demande actuel, enregistrer les gestionnaires d'itinéraire et l'enregistrement de Middlewares qui sera exécuté pendant le cycle de vie.

En plus des méthodes d'utilisation, il contient également une interface de méthodes d'alias pour rendre le code que vous écrivez beaucoup plus compréhensible et élégant.

Méthodes

$ app-> manche ($ méthodes, $ itiné

Cette méthode enregistre les nouveaux gestionnaires de demande pour un itinéraire spécifique en ce qui concerne une collection de méthodes de demande sur lesquelles devrait être envoyée.

Arguments

Argument	Taper	Description
$ méthodes	chaîne[]	Collecte de méthodes de demande en majuscules.
$ itinéraire	chaîne	L'itinéraire vers lequel les gestionnaires sont enregistrés.
... $ Handlers	callable []	Collection de gestionnaires qui seront exécutés.

Exemple

 // ...
$ app -> handle (
    [ ' GET ' ], 
    ' /index ' , 
    function ( $ req , $ res ) { /*...*/ }, 
    function ( $ req , $ res ) { /*...*/ }, 
    function ( $ req , $ res ) { /*...*/ }
    // ...
);
// ... 

Alias

Méthode	Description
Tous ($ Route, ... $ Handlers)	Méthode d'alias qui réagira à toutes les méthodes de demande
Get ($ Route, ... $ Handlers)	Méthode d'alias qui réagira pour obtenir des demandes
Post ($ Route, ... $ Handlers)	Méthode d'alias qui réagira aux demandes de poste
Tête ($ Route, ... $ Handlers)	Méthode d'alias qui réagira aux demandes de tête
Options ($ Route, ... $ Handlers)	Méthode d'alias qui réagira aux demandes d'options
Patch ($ Route, ... $ Handlers)	Méthode d'alias qui réagira aux demandes de patch
put ($ Route, ... $ Handlers)	Méthode d'alias qui réagira aux demandes de pose
Supprimer ($ Route, ... $ Handlers)	Méthode d'alias qui réagira pour supprimer les demandes

$ app-> middleware ($ Placement, ... $ Handlers): Monty Application

Cette méthode enregistre des gestionnaires supplémentaires qui seront exécutés sans égard à la méthode de demande.

Arguments

Argument	Taper	Description
$ Placement	entier	La demande de cycle de vie de demande (application :: prend - avant, application :: ajouter - après) lorsque les gestionnaires doivent être exécutés.
... $ Handlers	callable []	Collection de gestionnaires qui seront exécutés.

Exemple

 // ...
$ app -> middleware (
     Monty Application:: PREPEND ,
    function ( $ req , $ res ) { /*...*/ },
    function ( $ req , $ res ) { /*...*/ },
    function ( $ req , $ res ) { /*...*/ }
    // ...
);
// ... 

Alias

Méthode	Description
Avant (... $ Handlers)	Méthode d'alias qui ajoutera les gestionnaires de demande exécutés avant le traitement réel de la demande
Après (... $ Handlers)	Méthode d'alias qui ajoutera des gestionnaires de demande exécutés après le traitement réel de la demande

$ app-> getRequest (): Monty request

Cette méthode récupère l'objet de demande actuel.

$ app-> getResponse () :: Monty Response

Cette méthode récupère l'objet de réponse actuel.

Demande

L'objet de demande est la pièce centrale du processus. Il contient la possibilité d'ajouter les propriétés et les services nécessaires pendant la demande. Avec cette gestion, l'objet de demande reste petit et seules les dépendances nécessaires sont enregistrées en cas de besoin.

Méthodes

$ req-> clientrip (): chaîne

Méthode pour récupérer la demande IP.

$ req-> contentType (): chaîne

Méthode pour récupérer la valeur d'en-tête de type contenu demandé.

$ req-> files (): symfony composant httpfoundation filebag

Méthode pour récupérer les paramètres $ _files.

$ req-> get (... $ paramètres)

Cette méthode peut être utilisée pour récupérer un ensemble de propriétés ou de services sur la demande.

Arguments

Argument	Taper	Description
... $ paramètres	mixte	La collection de paramètres a passé beaucoup à la méthode du secteur.

Exemple

 // ...
$ request -> get ( ' logger ' , new SomeDefault ());
$ request -> get ( ' property ' , ' some default value ' );
// ... 

$ req-> getrawrequest (): symfony composant httpfoundation request

Méthode pour récupérer la demande brute intégrée dans l'objet Monty Request.

$ req-> httphost (): chaîne

Méthode pour récupérer l'hôte HTTP, y compris le protocole.

$ req-> ismethod ($ méthode): booléen

Méthode pour vérifier si la méthode de demande est une valeur spécifique.

Arguments

Argument	Taper	Description
$ méthode	chaîne	Méthode de demande de vérification.

$ req-> issesecure (): booléen

Méthode pour vérifier si la demande envoyée est sécurisée (HTTPS / SSL).

$ req-> path (): chaîne

Méthode pour récupérer le chemin de demande.

$ req-> précédente (): mixte

Méthode pour récupérer la valeur de retour du gestionnaire précédent dans la pile.

$ req-> query (): symfony composant httpfoundation paramètrebag

Méthode pour récupérer les paramètres $ _get.

$ req-> requestMethod (): chaîne

Méthode pour récupérer la méthode de demande.

$ req-> request (): symfony composant httpfoundation paramètrebag

Méthode pour récupérer les paramètres $ _post.

$ req-> routeParameters (): symfony composant httpfoundation paramètrebag

Méthode pour récupérer les valeurs de paramètres d'itinéraire correspond à l'instance de gestionnaire de route.

$ req-> set (... $ Paramètres): Monty request

Cette méthode peut être utilisée pour ajouter une instance de classe ou une propriété à la demande accessible le long de la pile d'appels. Habituellement, la méthode prend au moins deux paramètres, d'abord l'ID de la propriété / service en tant que chaîne et deuxièmement une valeur scalaire ou objet.

Les tableaux ne sont pas autorisés à être définis en tant que propriétés de demande pour éviter le code de code et le gonflement des ressources.

Arguments

Argument	Taper	Description
... $ paramètres	mixte	La collection de paramètres a passé beaucoup à la méthode du secteur.

Exemple

 // ...
$ request -> set ( ' logger ' , new SomeLogger ()); // valid
$ request -> set ( ' property ' , ' some value ' ); // valid

$ request -> set ( ' not_possible ' , []); // invalid
// ... 

$ req-> SetPreviousReturn ($ Value): Monty Request

Méthode pour définir le rendement du gestionnaire précédent.

Arguments

Argument	Taper	Description
$ valeur	mixte	Valeur de retour du gestionnaire précédent.

$ req-> updaterateParams ($ params): Monty request

Méthode pour mettre à jour les paramètres de route définis sur la demande.

Arguments

Argument	Taper	Description
$ params	tableau	Paramètres d'itinéraire à définir.

Réponse

L'objet de réponse est généralement supposé se résoudre lui-même - ce qui signifie que cela devrait gérer la façon dont la réponse définie doit être rendue dans la réponse de l'application. Vous pouvez utiliser simplement l'objet de réponse du composant Symfony HTTP ou définir les propres, qui doivent implémenter le Monty ResponseInterface.

Maître

Un gestionnaire est défini comme un callable qui est enregistré dans une définition de gestionnaire d'itinéraire ou un middleware.

Le gestionnaire peut être, de simples fonctions lambda, des objets de fermeture, des classes, ... pratiquement tout ce qui est possible à invoquer. Aucune limitation ici.

---

© 2017 Willi Eßer