Vars
1.1.2
Vars est un chargeur de configuration simple à utiliser, léger et facilement extensible avec des chargeurs intégrés pour les types de fichiers ENV, INI, JSON, PHP, Toml, XML et YAML. Il est également doté d'un support intégré pour Silex avec d'autres frameworks (Symfony, Laravel, etc.) à venir prochainement.
Parfois, vous êtes obligé d'utiliser différents formats pour les fichiers de configuration et l'un des objectifs Vars est de vous simplifier la tâche en prenant en charge les formats de configuration les plus courants afin que vous n'ayez pas à changer de bibliothèque pour gérer les différents formats.
Un autre objectif est de prendre en charge différents frameworks afin que, encore une fois, vous n'ayez pas à changer de bibliothèque lorsque vous utilisez différents frameworks. Actuellement, ne prend en charge que Silex en utilisant un fournisseur de services, le support de Laravel et Symfony suivra sous peu.
Avec une API simple et des options de chargement intuitives, Vars essaie de rendre le chargement et la fourniture de la configuration aussi simple que possible pour vous.
Vars nécessite PHP version 5.3+ .
Si vous souhaitez utiliser YAML, vous aurez besoin de la bibliothèque symfony/yaml et de même, vous aurez besoin yosymfony/toml pour utiliser les fichiers Toml et m1/env pour utiliser les fichiers Env.
Via Compositeur
$ composer require m1/ Vars // load single file
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
// load from dir
$ Vars = new Vars ( __DIR__ . ' /config ' );
// load from array
$ Vars = new Vars ( array (
__DIR__ . ' /config/config.yml ' ,
__DIR__ . ' /config/sub ' ,
)); Cela peut être fait de différentes manières, vous pouvez traiter la variable $ Vars comme un tableau normal ou vous pouvez l'utiliser de manière orientée objet.
// All return the same thing
$ Vars -> get ( ' db.password ' )
$ Vars [ ' db.password ' ];
$ Vars [ ' db ' ][ ' password ' ]Vous pouvez également définir des valeurs de la même manière
// All do the same thing
$ Vars -> set ( ' db.password ' , ' test ' )
$ Vars [ ' db.password ' ] = ' test ' ;
$ Vars [ ' db ' ][ ' password ' ] = ' test ' ; Vous pouvez également obtenir les variables depuis getenv()
// All do the same thing
$ Vars -> toEnv ();
getenv ( ' db.password ' );Pour plus d'informations à ce sujet, consultez la section Variables d'environnement
Vous pouvez facilement importer des configurations de manière relative et absolue dans d'autres configurations, celles-ci diffèrent selon le type de fichier de configuration, alors vérifiez le dossier /tests/mocks/ pour des exemples
# example_1.yml
test_key_1 : test_value_1
imports : example_2.yml
# example_2.yml
test_key_2 : test_value_2Je reviendrais :
[
" test_key_1 " => " test_value_1 " ,
" test_key_2 " => " test_value_2 "
]Les importations sont importées par défaut par rapport à la clé, par exemple :
test_key_1 :
imports : example_2.ymlJe reviendrais :
[
" test_key_1 " => [
" test_key_2 " => " test_value_2 "
]
]Cependant, vous pouvez modifier cela de différentes manières :
# example 1
test_key_1 :
imports :
- {resource: example.yml, relative: false}
# example 2
test_key_2 :
imports :
resource : example.yml
relative : falseSi vous importez plusieurs fichiers et que vous souhaitez définir la relativité de tous les fichiers, vous pouvez procéder comme suit :
test_key_1 :
imports :
relative : false
resource :
- example_2.yml
- example_3.yml Tout ce qui précède fait que les variables example_2.yml et example_3.yml deviennent absolues dans le fichier de configuration :
[
" test_key_1 " => []
" test_key_2 " => " test_value_2 " // from example_2.yml
"test_key_3" => "test_value_3" // from example_3.yml
]Vous pouvez également importer des répertoires en utilisant toute la syntaxe ci-dessus :
test_key_1 :
imports : sub/L'importation de répertoires n'est pas récursive par défaut et ne recherchera pas de dossiers dans les dossiers. Vous pouvez modifier cela en ajoutant une bascule récursive :
test_key_1 :
imports :
resource : sub/
recursive : trueou en ajoutant un indicateur récursif :
test_key_1 :
imports :
resource : sub/*Comme pour le chargement de fichiers, vous pouvez importer des répertoires en masse avec une seule bascule récursive :
test_key_1 :
imports :
recursive : false
resource :
- sub/
- sub1/L'importation de répertoires repose sur des chargeurs et les extensions supportées par les chargeurs. Voir la section chargeur pour plus de détails.
Vous pouvez utiliser différents indicateurs lors de l'importation.
L'indicateur if else ?: fait en sorte que si le premier fichier existe, utilisez-le -- else utilisez l'autre fichier défini, par exemple :
imports : " example_1.yml ?: example_2.yml "Remarque : Vous devez mettre la chaîne entre guillemets pour que l'indicateur if else fonctionne
L'indicateur de suppression des exceptions @ -- supprime les exceptions des fichiers introuvables. par exemple :
imports : @file_does_not_exist.ymlL'indicateur récursif permet de rechercher des fichiers dans les répertoires à l'intérieur des répertoires. par exemple :
imports :
resource : sub/*Vous pouvez également combiner les indicateurs ci-dessus, donc si l'option else file n'existe pas, elle ne lèvera pas d'exception, par exemple :
imports : " example_1.yml ?: @example_2.yml "Vous pouvez obtenir des fichiers ou des ressources individuels :
// All return the same thing
$ Vars -> getResource ( ' example_2.yml ' )-> get ( ' test_key_2 ' );
$ Vars -> getResource ( ' example_2.yml ' )[ ' test_key_2 ' ];Il existe différentes options pour Vars
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
// this will affect how you getResource() and will default to the path
// of the first resource you initiate
' path ' => __DIR__ . ' /config ' ,
// to cache or not -- defaults to true
' cache ' => true ,
// where the cache is stored -- If not set will default to the base path
' cache_path ' => __DIR__ . ' /config/ ' ,
// How long the cache lasts for -- Defaults to 300 seconds (5 minutes)
' cache_expire ' => 300 ,
// Replacement variables -- see variables section for more detail
' replacements ' => [
' foo ' => ' bar ' ,
' foobar ' => ' barfoo '
],
// Merge globals -- see globals section for more detail
' merge_globals ' => true ,
// The file loaders to load the configs -- see loader section for more detail
' loaders ' => [
' default '
]
]); Le path indique comment le $filename dans $ Vars ->getResource($filename) est calculé. Par exemple:
Si vous définissez le path sur __DIR__.'/config' et que vous avez importé __DIR__.'/app/test_1.yml' :
# example_1.yml
imports : example_2.yml Ensuite, example_1.yml et example_2.yml $filename seraient respectivement ../app/test_1.yml et ../app/test_1.yml .
Si aucun path n'est défini, le premier chemin de ressource de fichier sera utilisé comme path , par exemple :
// example 1
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
// example 2
$ Vars = new Vars ([
__DIR__ . ' /config/config.yml ' ,
__DIR__ . ' /sub/config.yml ' ,
]); Les deux utiliseront __DIR__.'/config' comme path
Vous pouvez utiliser 3 types de variables dans Vars : Replacements , In-file et Environment , la syntaxe est :
| Type de variable | Syntaxe |
|---|---|
| Remplaçants | %VARIABLE% |
| Dans le dossier | %$VARIABLE% |
| Environnement | %^VARIABLE% |
Pour une meilleure lisibilité, vous pouvez également mettre des espaces entre le nom de la variable et les préfixes/suffixes comme ceci :
replacement_variable : % VARIABLE %
infile_variable : %$ VARIABLE %
env_variable : %^ VARIABLE % Les variables de remplacement sont chargées depuis l'extérieur Vars , elles sont donc souvent utilisées pour les fonctions/logiques PHP , telles que __dir__ :
test_key_1 : %foo%
test_key_2 : /bar/%foobar%/bar $ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' replacements ' => [
' foo ' => ' bar ' ,
' foobar ' => ' barfoo '
],
]);Sorties :
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/barfoo/foobar/ "
] Vos remplacements doivent être préfixés et suffixés par %
Vous pouvez également charger des variables à partir de fichiers :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' replacements ' => __DIR__ . ' /config/variables.yml '
]);Vous pouvez également utiliser des variables de vos clés déjà définies dans les fichiers, telles que :
test_key_1 : hello
test_key_2 : /bar/%$test_key_1%/barSorties :
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/hello/foobar/ "
] Vos remplacements doivent être préfixés par %$ et suffixés par % .
Pour les fichiers in-file et replacements , vous pouvez utiliser la syntaxe de notation par points pour accéder aux tableaux, par exemple :
test_key_1 :
test_key_2 : hello
test_key_3 : /bar/%$test_key_1.test_key_2%/barSorties :
[
" test_key_1 " => array (
" test_key_2 " => " hello "
),
" test_key_2 " => " /bar/hello/foobar/ "
]Vous pouvez également utiliser des variables d'environnement pour effectuer des remplacements :
test_key_1 : %^DATABASE_USERNAME%
test_key_2 : %^DATABASE_PASSWORD% # nginx config example
location @site {
fastcgi_pass unix:/var/run/php5-fpm.sock;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root /index.php;
# env variables
fastcgi_param DATABASE_USERNAME test_username;
fastcgi_param DATABASE_PASSWORD test_password;
}Sorties :
[
" test_key_1 " => " test_username " ,
" test_key_2 " => " test_password "
] Vos variables d'environnement doivent être préfixées par %^ et suffixées par %
Vous pouvez également faire en sorte que votre tableau de configuration soit disponible pour getenv() :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
$ Vars -> toEnv ();Remarque : Votre configuration sera aplatie en notation par points pour cela, par exemple :
test_key_1 :
test_key_2 : valueSera accessible par :
getenv ( ' test_key_1.test_key_2 ' ); // value Globals dans Vars font référence à des variables définies comme telles :
_globals :
test_key_1 : test_value_1 Fondamentalement, ils sont simplement encapsulés dans un tableau _globals - leur utilisation permet de pouvoir y accéder depuis getGlobals() depuis Vars
L'action par défaut consiste à les fusionner avec les autres contenus du fichier, de sorte que :
_globals :
test_key_1 : test_value_1
test_key_2 : test_value_2Devient :
[
' test_key_1 ' => ' test_value_1 ' ,
' test_key_2 ' => ' test_value_2 ' ,
] Mais vous pouvez remplacer cela en changeant merge_globals en false via les options.
Si cela n'a pas de sens, vous n'aurez probablement pas besoin d'utiliser des variables globales, mais elles sont utiles pour travailler avec des frameworks qui encapsulent tout sous, par exemple, $app et vous souhaitez pouvoir accéder à certaines valeurs clés => comme donc : $app['test_key_1'] . Voir la section Fournisseur Silex pour plus d'exemples.
Vars met automatiquement en cache les ressources pendant 5 minutes, vous pouvez désactiver cette option en définissant l'option cache sur false .
Le cache_path s'il n'est pas défini est défini sur celui du path . Le cache_path doit être accessible en écriture.
Pour invalider le cache, supprimez simplement le dossier à l'intérieur de votre cache_path appelé Vars , par exemple : rm -rf /var/www/application/app/cache/ Vars
Le fichier cache est un fichier .php en raison de l'accélération supplémentaire d'opcache.
Si vous utilisez le fournisseur Silex, le cache ne sera pas utilisé et défini si vous êtes en mode débogage.
Les chargeurs permettent Vars de lire les différents types de fichiers (les valeurs par défaut sont Ini, Json, Php, Toml, Xml et Yaml).
Vous pouvez activer et désactiver les chargeurs via les options :
Default charge tous les chargeurs par défaut :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => ' default '
]);
// You can load individual loaders:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => [
' ini ' ,
' json '
[
]);
//You can also create and load custom loaders:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => [
' FooBarCustomFooBarLoader ' ,
' ini ' ,
' json '
]
]); Pour créer votre propre chargeur personnalisé, vous devez étendre M1 Vars LoaderAbstractLoader , disposer des extensions prises en charge dans le tableau public static $supported et disposer d'une public function load() qui charge le contenu du fichier.
Voici un exemple primitif qui charge des fichiers .txt :
namespace M1 Foo Bar Loader ;
use M1 Vars Loader AbstractLoader ;
class TextLoader extends AbstractLoader
{
public static $ supported = array ( ' txt ' );
public function load ()
{
$ content = [];
foreach ( file ( $ this -> entity ) as $ line ) {
list ( $ key , $ value ) = explode ( ' : ' , $ line , 2 );
$ content [ trim ( $ key )] = trim ( $ value );
}
$ this -> content = $ content ;
return $ this ;
}
}Ensuite, pour utiliser ce chargeur, vous utiliserez simplement :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => [
' M1FooBarLoaderTextLoader ' ,
]
]);Remarque : n'utilisez pas ce chargeur pour de vrai, c'est uniquement à des fins de présentation.
C'est assez simple d'utiliser cette bibliothèque avec Silex, il suffit de l'enregistrer lorsque vous inscrivez d'autres prestataires de services :
$ app -> register ( new M1 Vars Provider Silex Vars ServiceProvider ( ' example.yml ' ), [
' Vars .path ' => __DIR__ . ' /../../app/config/test/ ' ,
' Vars .options ' => [
' cache ' => true ,
' cache_path ' => __DIR__ . ' /../../app/config/cache/ ' ,
' cache_expire ' => 500 ,
' replacements ' => [
' test ' => ' test_replacement '
],
' loaders ' => [
' yml ' ,
' json '
],
' merge_globals ' => true ,
' replacements ' => __DIR__ . ' /../../app/config/replacements.json ' ,
]]); Ensuite, vous pouvez accéder à votre configuration depuis $app[' Vars ']
Remarque : Si vous $app['debug'] = true alors le cache ne sera pas utilisé.
Vous pouvez également accéder aux valeurs de configuration depuis $app en utilisant la notation par points, par exemple :
test_key_1 :
test_key_2 : value
test_key_3 : valueVous pouvez obtenir ce qui précède en utilisant la notation par points comme ceci :
$ app [ ' Vars ' ][ ' test_key_1.test_key_2 ' ]; // value
$ app [ ' Vars ' ][ ' test_key_3 ' ]; // value Vous pouvez également fusionner les globales dans $app comme ceci :
# example.yml
_globals :
monolog.logfile : log.log
test_key_1 : test_value_2 $ app -> register ( new M1 Vars Provider Silex Vars ServiceProvider ( ' example.yml ' ));
// register monolog here and other service providers
$ app [ ' Vars .merge ' ](); Notez le $app[' Vars .merge']() - Cela remplace les valeurs par défaut du fournisseur de services. Dans cet exemple, monolog utilisera donc le fichier journal défini dans la configuration Vars .
Vous devez appeler Vars .merge après avoir appelé les fournisseurs de services pour lesquels vous fournissez des valeurs de configuration dans votre configuration.
Vous pouvez également accéder test_key_1 via $app[' Vars .test_key_1'] et de la même manière si vous le souhaitez, vous pouvez accéder aux globales comme ceci $app['monolog.logfile'] .
Vars ($resource, $options = array())Le constructeur pour créer une nouvelle configuration Vars :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
// this will affect how you getResource() and will default to the path
// of the first resource you initiate
' path ' => __DIR__ . ' /config ' ,
// to cache or not -- defaults to true
' cache ' => true ,
// where the cache is stored -- If not set will default to the base path
' cache_path ' => __DIR__ . ' /config/ ' ,
// How long the cache lasts for -- Defaults to 300 seconds (5 minutes)
' cache_expire ' => 300 ,
// Replacement variables -- see variables section for more detail
' replacements ' => [
' foo ' => ' bar ' ,
' foobar ' => ' barfoo '
],
// The file loaders to load the configs -- see loader section for more detail
' loaders ' => [
' default '
]
]);getContent()Renvoie le contenu analysé de toutes les configurations.
getResource($resource)Récupère une ressource spécifiée, renvoie une ressource de fichier ou false si la ressource n'existe pas.
Le nom $resource est basé sur le chemin défini dans le chemin de base et le nom du fichier.
# example.yml
imports : example2.yml
test_1 : value
# example2.yml
test_2 : value $ Vars = new Vars ( ' example.yml ' );
$ Vars -> getResource ( ' example2.yml ' ); // FileResource
$ Vars -> getResource ( ' example2.yml ' )-> getContent ();
# output:
# [
# "test_2" => "value"
# ] getResources() Renvoie toutes les ressources importées, ce seront des objets FileResource .
toEnv() Cela fait en sorte que la configuration soit disponible via getenv() :
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> toEnv ();
getenv ( ' test_1 ' ); // value toDots()Fait en sorte que la configuration soit aplatie dans un tableau de notation par points
test_value_1 :
test_value_2 : value
test_value_3 : value $ Vars = new Vars ( ' example.yml ' );
$ Vars -> toDots ();
# output:
# [
# "test_value_1.test_value_2" => "value",
# "test_value_1.test_value_3" => "value
# ] getGlobals() Obtient les valeurs définies dans _globals
set($key, $value)Définissez une clé de configuration :
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> set ( ' test_key_1 ' , ' value_2 ' );get($key)Obtient une clé de configuration :
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> get ( ' test_key_1 ' ); // valuegetRawContent()Obtenez le contenu brut et non analysé du fichier
# example.yml
test_value_1 :
imports : example2.yml
test_value_2 : %root%/foo/%dir% $ Vars = new Vars ( ' example.yml ' );
$ Vars -> getResource ( ' example.yml ' )-> getRawContent ();
# output:
# [
# test_value_1:
# imports: example2.yml
# test_value_2: %root%/foo/%dir%
# ] getContent()Voir getContent()
get($key)Voir obtenir()
Veuillez consulter CHANGELOG pour plus d'informations sur ce qui a changé récemment.
$ composer test Veuillez consulter CONTRIBUER pour plus de détails.
Si vous découvrez des problèmes liés à la sécurité, veuillez envoyer un e-mail à [email protected] au lieu d'utiliser le suivi des problèmes.
La licence MIT (MIT). Veuillez consulter le fichier de licence pour plus d'informations.
