corcel
vel 10
Une collection de classes Model qui vous permet d'obtenir des données directement à partir d'une base de données WordPress.
Corcel est une collection de classes PHP construites sur Eloquent ORM (du framework Laravel), qui fournit une interface fluide pour se connecter et obtenir des données directement à partir d'une base de données WordPress.
Vous pouvez utiliser WordPress comme backend (panneau d'administration) ou CMS, pour insérer des publications, des types personnalisés, etc., et toute autre application PHP de l'autre côté interrogeant ces données (en tant que couche de modèle). Il est plus facile d'utiliser Corcel avec Laravel, mais vous êtes libre de l'utiliser avec n'importe quel projet PHP utilisant Composer.
Achetez-moi un café | Suivez Corcel sur Twitter
| Laravel | Corcel |
|---|---|
| 5.1.x | ~2.1.0 |
| 5.2.x | ~2.2.0 |
| 5.3.x | ~2.3.0 |
| 5.4.x | ~2.4.0 |
| 5.5.x | ~2.5.0 |
| 5.6.x | ~2.6.0 |
| 5.7.x | ~2.7.0 |
| 5.8.x | ~2.8.0 |
| 6.0.x | ^3.0.0 |
| 7.0.x | ^4.0.0 |
| 8.0.x | ^5.0.0 |
| 9.0.x | ^6.0.0 |
| 10.0.x | ^7.0.0 |
| 11.0.x | ^8.0.0 |
Vous devez utiliser Composer pour installer Corcel dans votre projet :
composer require jgrossi/corcel
Corcel s'enregistrera à l'aide de la découverte automatique de Laravel.
Vous devrez inclure CorcelServiceProvider dans votre config/app.php :
' providers ' => [
/*
* Package Service Providers...
*/
Corcel Laravel CorcelServiceProvider::class,
]Configurez maintenant notre fichier de configuration pour vous assurer que votre base de données est correctement configurée et pour vous permettre d'enregistrer des types de publication et des codes courts personnalisés de manière très simple :
Exécutez la commande Artisan suivante dans votre terminal :
php artisan vendor:publish --provider="CorcelLaravelCorcelServiceProvider"
Vous disposez maintenant d'un fichier de configuration config/corcel.php , dans lequel vous pouvez définir la connexion à la base de données avec les tables WordPress et bien plus encore.
Définissez simplement la connection à la base de données que vous souhaitez utiliser par Corcel dans config/corcel.php .
Supposons que vous ayez les connexions de base de données suivantes dans votre fichier config/database.php :
// File: /config/database.php
' connections ' => [
' mysql ' => [ // for Laravel database
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' database ' => ' mydatabase ' ,
' username ' => ' admin '
'password' => 'secret',
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => '' ,
' strict ' => false ,
' engine ' => null ,
],
' wordpress ' => [ // for WordPress database (used by Corcel)
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' database ' => ' mydatabase ' ,
' username ' => ' admin ' ,
' password ' => ' secret ' ,
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => ' wp_ ' ,
' strict ' => false ,
' engine ' => null ,
],
], Dans ce cas, vous devriez utiliser la connexion wordpress pour Corcel, alors définissez-la simplement dans le fichier de configuration Corcel config/corcel.php :
' connection ' => ' wordpress ' , Ici, vous devez configurer la base de données pour répondre aux exigences de Corcel. Tout d’abord, vous devez inclure le fichier autoload de Composer s’il n’est pas déjà chargé :
require __DIR__ . ' /vendor/autoload.php ' ;Vous devez maintenant définir les paramètres de votre base de données WordPress :
$ params = [
' database ' => ' database_name ' ,
' username ' => ' username ' ,
' password ' => ' pa$$word ' ,
' prefix ' => ' wp_ ' // default prefix is 'wp_', you can change to your own prefix
];
Corcel Database:: connect ( $ params );Vous pouvez spécifier tous les paramètres Eloquent, mais certains sont par défaut (mais vous pouvez les remplacer).
' driver ' => ' mysql ' ,
' host ' => ' localhost ' ,
' charset ' => ' utf8 ' ,
' collation ' => ' utf8_unicode_ci ' ,
' prefix ' => ' wp_ ' , // Specify the prefix for WordPress tables, default prefix is 'wp_'Chaque fois que vous voyez
Post::method(), si vous utilisez votre propre classe Post (où vous définissez le nom de la connexion), commeAppPostvous devez utiliserAppPost::method()et nonPost::method(). Tous les exemples supposent que vous connaissez déjà cette différence.
Dans les exemples, chaque fois que vous voyez
Post::method()supposezCorcelModelPost::method().
// All published posts
$ posts = Post:: published ()-> get ();
$ posts = Post:: status ( ' publish ' )-> get ();
// A specific post
$ post = Post:: find ( 31 );
echo $ post -> post_title ; En option, vous pouvez créer votre propre modèle Post (ou Page, ou autre) qui étend CorcelPost . Définissez ensuite le nom de connexion (si vous souhaitez remplacer celui par défaut de Corcel) que vous utilisez, dans ce cas foo-bar :
L'extension de la classe
CorcelModelPostpeut ajouter de la flexibilité à votre projet, une fois que vous pouvez ajouter des méthodes et une logique personnalisées, en fonction de ce que vous devez utiliser à partir de votre base de données WordPress.
<?php // File: app/Post.php
namespace App ;
use Corcel Model Post as Corcel ;
class Post extends Corcel
{
protected $ connection = ' foo-bar ' ;
public function customMethod () {
//
}
}Ainsi, vous pouvez maintenant récupérer les données de la base de données WP en utilisant votre propre classe :
$ posts = App Post:: all (); // using the 'foo-bar' connectionN'oubliez pas que vous n'avez pas besoin d'étendre notre classe
Post, vous pouvez utiliserCorcelModelPostet tous les autres modèles sans aucun problème.
REMARQUE : Dans Corcel v1, vous pouvez enregistrer les métadonnées à l'aide de la méthode
Post::save(). Ce n'est plus autorisé. Utilisez les méthodessaveMeta()oucreateMeta()(voir ci-dessous) pour enregistrer la méta de publication.
Vous pouvez également récupérer les métadonnées des publications.
// Get a custom meta value (like 'link' or whatever) from a post (any type)
$ post = Post:: find ( 31 );
echo $ post -> meta -> link ; // OR
echo $ post -> fields -> link ;
echo $ post -> link ; // OR Pour créer ou mettre à jour des métadonnées d'un utilisateur, utilisez simplement les méthodes saveMeta() ou saveField() . Ils renvoient bool comme la méthode Eloquent save() .
$ post = Post:: find ( 1 );
$ post -> saveMeta ( ' username ' , ' jgrossi ' );Vous pouvez également enregistrer plusieurs métadonnées en même temps :
$ post = Post:: find ( 1 );
$ post -> saveMeta ([
' username ' => ' jgrossi ' ,
' url ' => ' http://jgrossi.com ' ,
]); Vous disposez également des méthodes createMeta() et createField() , qui fonctionnent comme les méthodes saveX() , mais elles sont utilisées uniquement pour la création et renvoient l'instance créée par PostMeta , au lieu de bool .
$ post = Post:: find ( 1 );
$ postMeta = $ post -> createMeta ( ' foo ' , ' bar ' ); // instance of PostMeta class
$ trueOrFalse = $ post -> saveMeta ( ' foo ' , ' baz ' ); // boolean Il existe de multiples possibilités d'interroger les publications par leurs champs personnalisés (méta) en utilisant des étendues sur une classe Post (ou un autre modèle qui utilise le trait HasMetaFields ) :
Pour vérifier si une clé méta existe, utilisez la portée hasMeta() :
// Finds a published post with a meta flag.
$post = Post::published()->hasMeta('featured_article')->first();
Si vous souhaitez faire correspondre précisément un méta-champ, vous pouvez utiliser la portée hasMeta() avec une valeur.
// Find a published post which matches both meta_key and meta_value.
$ post = Post:: published ()-> hasMeta ( ' username ' , ' jgrossi ' )-> first (); Si vous devez faire correspondre plusieurs méta-champs, vous pouvez également utiliser la portée hasMeta() en passant un tableau en paramètre :
$ post = Post:: hasMeta ([ ' username ' => ' jgrossi ' ])-> first ();
$ post = Post:: hasMeta ([ ' username ' => ' jgrossi ' , ' url ' => ' jgrossi.com ' ])-> first ();
// Or just passing the keys
$ post = Post:: hasMeta ([ ' username ' , ' url ' ])-> first (); Si vous devez faire correspondre une chaîne insensible à la casse ou faire correspondre des caractères génériques, vous pouvez utiliser la portée hasMetaLike() avec une valeur. Cela utilise un opérateur SQL LIKE , utilisez donc '%' comme opérateur générique.
// Will match: 'J Grossi', 'J GROSSI', and 'j grossi'.
$ post = Post:: published ()-> hasMetaLike ( ' author ' , ' J GROSSI ' )-> first ();
// Using % as a wildcard will match: 'J Grossi', 'J GROSSI', 'j grossi', 'Junior Grossi' etc.
$ post = Post:: published ()-> hasMetaLike ( ' author ' , ' J%GROSSI ' )-> first (); La classe Post prend en charge les "alias", donc si vous vérifiez la classe Post vous devez noter certains alias définis dans le tableau statique $aliases , comme title pour post_title et content pour post_content .
$ post = Post:: find ( 1 );
$ post -> title === $ post -> post_title ; // true Si vous étendez la classe Post pour créer votre propre classe, vous pouvez également utiliser $aliases . Ajoutez simplement de nouveaux alias à cette propriété statique dans votre propre classe et elle héritera automatiquement de tous les alias de la classe Post parent :
class A extends Corcel Post
{
protected static $ aliases = [
' foo ' => ' post_foo ' ,
];
}
$ a = A:: find ( 1 );
echo $ a -> foo ;
echo $ a -> title ; // from Post class Pour commander des publications, vous pouvez utiliser les scopes newest() et oldest() , pour les classes Post et User :
$ newest = Post:: newest ()-> first ();
$ oldest = Post:: oldest ()-> first (); Pour commander des articles, utilisez simplement la méthode Eloquent paginate() :
$ posts = Post:: published ()-> paginate ( 5 );
foreach ( $ posts as $ post ) {
// ...
} Pour afficher les liens de pagination, appelez simplement la méthode links() :
{{ $ posts -> links () }} Si vous souhaitez récupérer un champ personnalisé créé par le plugin Advanced Custom Fields (ACF), vous devez installer le plugin corcel/acf - cliquez ici pour plus d'informations - et appeler le champ personnalisé comme ceci :
$ post = Post:: find ( 123 );
echo $ post -> acf -> some_radio_field ;
$ repeaterFields = $ post -> acf -> my_repeater_name ;Pour éviter les requêtes SQL inutiles, définissez simplement le type de champ que vous demandez. Habituellement, deux requêtes SQL sont nécessaires pour obtenir le type de champ, donc si vous souhaitez le spécifier, vous ignorez ces requêtes supplémentaires :
$ post = Post:: find ( 123 );
echo $ post -> acf -> text ( ' text_field_name ' );
echo $ post -> acf -> boolean ( ' boolean_field_name ' ); Vous pouvez également travailler avec des types de publication personnalisés. Vous pouvez utiliser la méthode type(string) ou créer votre propre classe.
// using type() method
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();
// using your own class
class Video extends Corcel Post
{
protected $ postType = ' video ' ;
}
$ videos = Video:: status ( ' publish ' )-> get (); L'utilisation de la méthode type() obligera Corcel à renvoyer tous les objets sous la forme CorcelPost . En utilisant votre classe personnalisée, vous avez l'avantage de personnaliser les classes, y compris les méthodes et propriétés personnalisées, en renvoyant tous les objets sous forme Video , par exemple.
Types de publications personnalisés et métadonnées :
// Get 3 posts with custom post type (store) and show its address
$ stores = Post:: type ( ' store ' )-> status ( ' publish ' )-> take ( 3 )-> get ();
foreach ( $ stores as $ store ) {
$ storeAddress = $ store -> address ; // option 1
$ storeAddress = $ store -> meta -> address ; // option 2
$ storeAddress = $ store -> fields -> address ; // option 3
} Chaque fois que vous appelez quelque chose comme Post::type('video)->first() ou Video::first() vous recevez une instance CorcelModelPost .
Si vous choisissez de créer une nouvelle classe pour votre type de publication personnalisé, vous pouvez renvoyer cette classe pour toutes les instances de ce type de publication.
Au lieu d'appeler la méthode Post::registerPostType() pour tous les types de publication personnalisés que vous souhaitez enregistrer, utilisez simplement le fichier de configuration de Corcel et mappez toutes les publications personnalisées et leurs classes. Ils seront enregistrés automatiquement pour vous :
' post_types ' => [
' video ' => App Video::class,
' foo ' => App Foo::class,
]Ainsi, chaque fois que vous interrogez un type de publication personnalisé, l'instance mappée sera renvoyée.
Ceci est particulièrement utile lorsque vous avez l'intention d'obtenir une collection de publications de différents types (par exemple lors de la récupération des publications définies dans un menu).
//all objects in the $videos Collection will be instances of Post
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();
// register the video custom post type and its particular class
Post:: registerPostType ( ' video ' , ' AppVideo ' )
//now all objects in the $videos Collection will be instances of Video
$ videos = Post:: type ( ' video ' )-> status ( ' publish ' )-> get ();Vous pouvez également le faire pour les classes intégrées, telles que Page ou Post. Enregistrez simplement la classe Page ou Post avec la chaîne de type de publication associée, et cet objet sera renvoyé à la place de celui par défaut.
Vous pouvez mapper tous les shortcodes de votre choix dans le fichier config/corcel.php , sous la clé 'shortcodes' . Dans ce cas, vous devez créer votre propre classe qui implements l'interface CorcelShortcode , qui nécessite une méthode render() :
' shortcodes ' => [
' foo ' => App Shortcodes FooShortcode::class,
' bar ' => App Shortcodes BarShortcode::class,
],Voici un exemple de classe de shortcode :
class FakeShortcode implements Corcel Shortcode
{
/**
* @param ShortcodeInterface $shortcode
* @return string
*/
public function render ( ShortcodeInterface $ shortcode )
{
return sprintf (
' html-for-shortcode-%s-%s ' ,
$ shortcode -> getName (),
$ shortcode -> getParameter ( ' one ' )
);
}
} Vous pouvez ajouter des shortcodes en appelant la méthode addShortcode sur le modèle Post :
// [gallery id="1"]
Post:: addShortcode ( ' gallery ' , function ( $ shortcode ) {
return $ shortcode -> getName () . ' . ' . $ shortcode -> getParameter ( ' id ' );
});
$ post = Post:: find ( 1 );
echo $ post -> content ;Laravel 5.5 utilise la découverte automatique des packages, vous n'avez donc pas besoin d'ajouter manuellement le ServiceProvider
Si vous utilisez Laravel, nous vous suggérons d'ajouter vos gestionnaires de shortcodes dans AppProvidersAppServiceProvider , dans la méthode boot .
Les codes courts sont analysés avec la bibliothèque Thunderer/shortcode .
Plusieurs analyseurs différents sont fournis. RegularParser est le plus correct techniquement et est fourni par défaut. Cela convient dans la plupart des cas. Cependant, si vous rencontrez des irrégularités dans l'analyse de votre shortcode, vous devrez peut-être configurer Corcel pour qu'il utilise WordpressParser , qui correspond plus fidèlement à l'expression régulière du shortcode de WordPress. Pour ce faire, si vous utilisez Laravel, éditez le fichier config/corcel.php et décommentez votre analyseur préféré. Alternativement, vous pouvez le remplacer par votre propre analyseur.
' shortcode_parser ' => Thunder Shortcode Parser RegularParser::class,
// 'shortcode_parser' => ThunderShortcodeParserWordpressParser::class, Si vous n'utilisez pas Laravel, vous pouvez le faire au moment de l'exécution, en appelant la méthode setShortcodeParser() à partir de n'importe quelle classe qui utilise le trait Shortcodes , comme Post , par exemple.
$ post -> setShortcodeParser ( new WordpressParser ());
echo $ post -> content ; // content parsed with "WordpressParser" classPour plus d’informations sur le package shortcode, cliquez ici.
Vous pouvez obtenir des taxonomies pour un article spécifique comme :
$ post = Post:: find ( 1 );
$ taxonomy = $ post -> taxonomies ()-> first ();
echo $ taxonomy -> taxonomy ;Ou vous pouvez rechercher des articles en utilisant ses taxonomies :
$ post = Post:: taxonomy ( ' category ' , ' php ' )-> first (); Vous pouvez également obtenir le format de la publication, comme la fonction WordPress get_post_format() :
echo $ post -> getFormat (); // should return something like 'video', etc Les pages sont comme des types de publication personnalisés. Vous pouvez utiliser Post::type('page') ou la classe CorcelModelPage .
use Corcel Model Page ;
// Find a page by slug
$ page = Page:: slug ( ' about ' )-> first (); // OR
$ page = Post:: type ( ' page ' )-> slug ( ' about ' )-> first ();
echo $ page -> post_title ;Obtenez une catégorie ou une taxonomie ou chargez des publications d’une certaine catégorie. Il existe plusieurs façons d’y parvenir.
// all categories
$ cat = Taxonomy:: category ()-> slug ( ' uncategorized ' )-> posts -> first ();
echo " <pre> " ; print_r ( $ cat -> name ); echo " </pre> " ;
// only all categories and posts connected with it
$ cat = Taxonomy:: where ( ' taxonomy ' , ' category ' )-> with ( ' posts ' )-> get ();
$ cat -> each ( function ( $ category ) {
echo $ category -> name ;
});
// clean and simple all posts from a category
$ cat = Category:: slug ( ' uncategorized ' )-> posts -> first ();
$ cat -> posts -> each ( function ( $ post ) {
echo $ post -> post_title ;
}); Obtenir la pièce jointe et/ou la révision à partir d’un Post ou Page .
$ page = Page:: slug ( ' about ' )-> with ( ' attachment ' )-> first ();
// get feature image from page or post
print_r ( $ page -> attachment );
$ post = Post:: slug ( ' test ' )-> with ( ' revision ' )-> first ();
// get all revisions from a post or page
print_r ( $ post -> revision ); Obtenir la vignette d'un Post ou Page .
$ post = Post:: find ( 1 );
// Retrieve an instance of CorcelModelMetaThumbnailMeta.
print_r ( $ post -> thumbnail );
// For convenience you may also echo the thumbnail instance to get the URL of the original image.
echo $ post -> thumbnail ; Pour récupérer une taille de vignette particulière, vous pouvez appeler la méthode ->size() sur l'objet vignette et transmettre un paramètre de chaîne de taille de vignette (par exemple thumbnail ou medium ). Si la vignette a été générée, cette méthode renvoie un tableau de métadonnées d'image, sinon l'URL de l'image d'origine sera renvoyée comme solution de secours.
if ( $ post -> thumbnail !== null ) {
/**
* [
* 'file' => 'filename-300x300.jpg',
* 'width' => 300,
* 'height' => 300,
* 'mime-type' => 'image/jpeg',
* 'url' => 'http://localhost/wp-content/uploads/filename-300x300.jpg',
* ]
*/
print_r ( $ post -> thumbnail -> size ( Corcel Model Meta ThumbnailMeta:: SIZE_THUMBNAIL ));
// http://localhost/wp-content/uploads/filename.jpg
print_r ( $ post -> thumbnail -> size ( ' invalid_size ' ));
}Dans les versions précédentes de Corcel, cette classe s'appelait
Optionsau lieu deOption(singulier). Prenez donc soin d'utiliser toujours cette classe au singulier à partir dev2.0.0.
La méthode
Option::getAll()a été supprimée dans Corcel 2+, au profit deOption::asArray($keys []).
Vous pouvez utiliser la classe Option pour obtenir des données de la table wp_options :
$ siteUrl = Option:: get ( ' siteurl ' );Vous pouvez également ajouter de nouvelles options :
Option:: add ( ' foo ' , ' bar ' ); // stored as string
Option:: add ( ' baz ' , [ ' one ' => ' two ' ]); // this will be serialized and savedVous pouvez obtenir toutes les options dans un tableau simple :
$ options = Option:: asArray ();
echo $ options [ ' siteurl ' ];Ou vous pouvez spécifier uniquement les clés que vous souhaitez obtenir :
$ options = Option:: asArray ([ ' siteurl ' , ' home ' , ' blogname ' ]);
echo $ options [ ' home ' ]; Pour obtenir un menu par son slug, utilisez la syntaxe ci-dessous. Les éléments de menu seront chargés dans la variable items (c'est une collection d'objets CorcelModelMenuItem ).
Les éléments de menu actuellement pris en charge sont : Pages, Publications, Liens personnalisés et Catégories.
Une fois que vous aurez des instances de la classe MenuItem , si vous souhaitez utiliser l'instance d'origine (comme la page ou le terme d'origine, par exemple), appelez simplement la méthode MenuItem::instance() . L'objet MenuItem est juste une publication avec post_type égal à nav_menu_item :
$ menu = Menu:: slug ( ' primary ' )-> first ();
foreach ( $ menu -> items as $ item ) {
echo $ item -> instance ()-> title ; // if it's a Post
echo $ item -> instance ()-> name ; // if it's a Term
echo $ item -> instance ()-> link_text ; // if it's a custom link
} La méthode instance() renverra l'objet correspondant :
Post pour l'élément de menu post ;Page pour l'élément de menu page ;CustomLink pour l’élément de menu custom ;Term pour l’élément de menu category .Pour gérer des menus à plusieurs niveaux, parcourez tous les éléments de menu pour les placer aux bons niveaux, par exemple.
Vous pouvez utiliser la méthode MenuItem::parent() pour récupérer l'instance parent de cet élément de menu :
$ items = Menu:: slug ( ' foo ' )-> first ()-> items ;
$ parent = $ items -> first ()-> parent (); // Post, Page, CustomLink or Term (category) Pour regrouper les éléments de menu en fonction de leurs parents, vous pouvez utiliser la méthode ->groupBy() dans la collection $menu->items , en regroupant les éléments de menu par leur $item->parent()->ID .
Pour en savoir plus sur la méthode groupBy() jetez un œil à la documentation de Laravel.
Vous pouvez manipuler les utilisateurs de la même manière que vous travaillez avec des publications :
// All users
$ users = User:: get ();
// A specific user
$ user = User:: find ( 1 );
echo $ user -> user_login ; Si vous utilisez Laravel 5.4 ou une version antérieure, assurez-vous que le fournisseur CorcelServiceProvider est enregistré.
Et puis, définissez le fournisseur d'utilisateurs dans config/auth.php pour permettre à Laravel de se connecter avec les utilisateurs WordPress :
' providers ' => [
' users ' => [
' driver ' => ' corcel ' ,
' model ' => Corcel Model User::class,
],
], Vous pouvez désormais utiliser la façade Auth pour authentifier les utilisateurs :
Auth:: validate ([
' email ' => ' [email protected] ' , // or using 'username' too
' password ' => ' secret ' ,
]); Pour que la réinitialisation de mot de passe de Laravel fonctionne avec Corcel, nous devons remplacer la façon dont les mots de passe sont stockés dans la base de données. Pour ce faire, vous devez modifier Auth/PasswordController.php de :
use App Http Controllers Controller ;
use Illuminate Foundation Auth ResetsPasswords ;
class PasswordController extends Controller
{
use ResetsPasswords;à
use App Http Controllers Controller ;
use Illuminate Foundation Auth ResetsPasswords ;
use Corcel Laravel Auth ResetsPasswords as CorcelResetsPasswords ;
class PasswordController extends Controller
{
use ResetsPasswords, CorcelResetsPasswords {
CorcelResetsPasswords::resetPassword insteadof ResetsPasswords;
} Vous pouvez utiliser la classe AuthUserProvider pour authentifier manuellement un utilisateur :
$ userProvider = new Corcel Laravel Auth AuthUserProvider ;
$ user = $ userProvider -> retrieveByCredentials ([ ' username ' => ' admin ' ]);
if (! is_null ( $ user ) && $ userProvider -> validateCredentials ( $ user , [ ' password ' => ' admin ' ])) {
// successfully login
}N'oubliez pas que vous pouvez utiliser à la fois
usernameet
Pour exécuter les tests phpunit, exécutez la commande suivante :
./vendor/bin/phpunit
Si la commande globale phpunit est installée, vous pouvez simplement taper :
phpunit
Tous les tests ont été écrits en utilisant SQLite avec la base de données :memory , ils s'exécutent donc dans votre mémoire. Tous les tests utilisent factories et migrations . Jetez un œil aux répertoires tests/database/factories et tests/database/migrations pour plus d’informations.
Toutes les contributions sont les bienvenues pour aider à améliorer Corcel.
Avant de soumettre votre Pull Request (PR), tenez compte des directives suivantes :
Fork https://github.com/corcel/corcel dans Github ;
Clonez votre référentiel forké (pas celui de Corcel) localement et créez votre propre branche en fonction de la version que vous souhaitez corriger ( 2.1 , 2.2 , 2.3 , 2.4 ou 2.5 ) : git checkout -b my-fix-branch 2.5 ;
Apportez toutes les modifications au code. N'oubliez pas ici d'écrire au moins un scénario de test pour toute fonctionnalité que vous ajoutez ou toute correction de bug (si elle n'a pas encore été testée). Notre objectif est que 100% du code soit couvert par les tests, alors aidez-nous à écrire un meilleur code ;-) Si vous n'avez pas d'expérience avec les tests, c'est une bonne opportunité d'apprendre. Jetez simplement un œil à nos cas de tests et vous verrez à quel point ils sont simples.
Exécutez les tests unitaires localement pour vous assurer que vos modifications n'ont cassé aucun autre morceau de code ;
Poussez votre nouvelle branche vers votre référentiel forké, généralement git push origin HEAD devrait fonctionner ;
Dans GitHub à nouveau, créez une Pull Request (PR) depuis votre branche my-fix-branch personnalisée (de votre référentiel forké) vers la branche associée ( corcel:2.5 , par exemple, pas corcel:master , s'il vous plaît ;
Attendez l'approbation :-)
Licence MIT © Junior Grossi
