Vars
1.1.2
Vars es un cargador de configuración fácil de usar, liviano y fácilmente ampliable con cargadores integrados para tipos de archivos ENV, INI, JSON, PHP, Toml, XML y YAML. También viene con soporte integrado para Silex y próximamente habrá más frameworks (Symfony, Laravel, etc.).
A veces te ves obligado a usar diferentes formatos para los archivos de configuración y uno de los objetivos Vars es simplificarlo admitiendo los formatos de configuración más comunes para que no tengas que cambiar de biblioteca para lidiar con los diferentes formatos.
Otro objetivo es admitir diferentes marcos, por lo que nuevamente no es necesario cambiar de biblioteca cuando se trata de diferentes marcos. Actualmente solo se admite Silex mediante un proveedor de servicios; en breve se ofrecerá soporte para Laravel y Symfony.
Con una API simple y opciones de carga intuitivas, Vars intenta hacer que la carga y el suministro de configuraciones sean lo más fáciles posible para usted.
Vars requiere PHP versión 5.3+ .
Si desea utilizar YAML, necesitará la biblioteca symfony/yaml y, de manera similar, necesitará yosymfony/toml para usar archivos Toml y m1/env para usar archivos Env.
Vía compositor
$ 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 ' ,
)); Esto se puede hacer de varias maneras, puede tratar la variable $ Vars como una matriz normal o puede usarla de forma orientada a objetos.
// All return the same thing
$ Vars -> get ( ' db.password ' )
$ Vars [ ' db.password ' ];
$ Vars [ ' db ' ][ ' password ' ]También puede establecer valores de la misma manera.
// All do the same thing
$ Vars -> set ( ' db.password ' , ' test ' )
$ Vars [ ' db.password ' ] = ' test ' ;
$ Vars [ ' db ' ][ ' password ' ] = ' test ' ; También puedes obtener las variables de getenv()
// All do the same thing
$ Vars -> toEnv ();
getenv ( ' db.password ' );Para obtener más información sobre esto, consulte la sección Variables de entorno.
Puede importar fácilmente configuraciones de manera relativa y absoluta a otras configuraciones; estas difieren según el tipo de archivo de configuración, así que consulte la carpeta /tests/mocks/ para ver ejemplos.
# example_1.yml
test_key_1 : test_value_1
imports : example_2.yml
# example_2.yml
test_key_2 : test_value_2Volvería:
[
" test_key_1 " => " test_value_1 " ,
" test_key_2 " => " test_value_2 "
]Las importaciones se importan en relación con la clave de forma predeterminada, por ejemplo:
test_key_1 :
imports : example_2.ymlVolvería:
[
" test_key_1 " => [
" test_key_2 " => " test_value_2 "
]
]Sin embargo, puedes cambiar esto de varias maneras:
# example 1
test_key_1 :
imports :
- {resource: example.yml, relative: false}
# example 2
test_key_2 :
imports :
resource : example.yml
relative : falseSi importa varios archivos y desea establecer la relatividad de todos los archivos, puede hacer lo siguiente:
test_key_1 :
imports :
relative : false
resource :
- example_2.yml
- example_3.yml Todo lo anterior hace que las variables example_2.yml y example_3.yml se vuelvan absolutas para el archivo de configuración:
[
" test_key_1 " => []
" test_key_2 " => " test_value_2 " // from example_2.yml
"test_key_3" => "test_value_3" // from example_3.yml
]También puedes importar directorios usando toda la sintaxis anterior:
test_key_1 :
imports : sub/La importación de directorios no es recursiva de forma predeterminada y no buscará carpetas dentro de carpetas; puede cambiar esto agregando una opción recursiva:
test_key_1 :
imports :
resource : sub/
recursive : trueo agregando una bandera recursiva:
test_key_1 :
imports :
resource : sub/*Al igual que con la carga de archivos, puede importar directorios de forma masiva con un interruptor recursivo:
test_key_1 :
imports :
recursive : false
resource :
- sub/
- sub1/La importación de directorios depende de los cargadores y las extensiones admitidas por los cargadores. Consulte la sección del cargador para obtener más detalles.
Puede utilizar varias banderas al importar.
El indicador if else ?: hace que si el primer archivo existe, úselo; de lo contrario, use el otro archivo definido, por ejemplo:
imports : " example_1.yml ?: example_2.yml "Nota: Debe colocar la cadena entre comillas para que funcione el indicador if else.
El indicador de supresión de excepciones @ : suprime las excepciones de archivos no encontrados. p.ej:
imports : @file_does_not_exist.ymlEl indicador recursivo hace que se busquen archivos en directorios dentro de directorios. p.ej:
imports :
resource : sub/*También puede combinar los indicadores anteriores, de modo que si la opción de archivo else no existe, no generará una excepción, por ejemplo:
imports : " example_1.yml ?: @example_2.yml "Puede obtener archivos o recursos individuales:
// All return the same thing
$ Vars -> getResource ( ' example_2.yml ' )-> get ( ' test_key_2 ' );
$ Vars -> getResource ( ' example_2.yml ' )[ ' test_key_2 ' ];Hay varias opciones para 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 '
]
]); La path es cómo se calcula $filename en $ Vars ->getResource($filename) . Por ejemplo:
Si establece la path en __DIR__.'/config' e importó __DIR__.'/app/test_1.yml' :
# example_1.yml
imports : example_2.yml Entonces, tanto example_1.yml como example_2.yml $filename serían ../app/test_1.yml y ../app/test_1.yml respectivamente.
Si no se establece ninguna path , se utilizará como path la primera ruta del recurso de archivo, por ejemplo:
// example 1
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
// example 2
$ Vars = new Vars ([
__DIR__ . ' /config/config.yml ' ,
__DIR__ . ' /sub/config.yml ' ,
]); Ambos usarán __DIR__.'/config' como path
Puedes usar 3 tipos de variables en Vars : Replacements , In-file y Environment , la sintaxis es:
| Tipo de variable | Sintaxis |
|---|---|
| Reemplazos | %VARIABLE% |
| En archivo | %$VARIABLE% |
| Ambiente | %^VARIABLE% |
Para una mejor legibilidad, también puede colocar espacios entre el nombre de la variable y el prefijo/sufijos, así:
replacement_variable : % VARIABLE %
infile_variable : %$ VARIABLE %
env_variable : %^ VARIABLE % Las variables de reemplazo se cargan desde fuera Vars , por lo que a menudo se usan para funciones/lógica PHP , como __dir__ :
test_key_1 : %foo%
test_key_2 : /bar/%foobar%/bar $ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' replacements ' => [
' foo ' => ' bar ' ,
' foobar ' => ' barfoo '
],
]);Salidas:
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/barfoo/foobar/ "
] Sus reemplazos deben tener el prefijo y el sufijo %
También puedes cargar variables desde archivos:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' replacements ' => __DIR__ . ' /config/variables.yml '
]);También puede utilizar variables de sus claves ya definidas en los archivos, como por ejemplo:
test_key_1 : hello
test_key_2 : /bar/%$test_key_1%/barSalidas:
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/hello/foobar/ "
] Sus reemplazos deben tener el prefijo %$ y el sufijo % .
Tanto para in-file como replacements , puede utilizar la sintaxis de notación de puntos para obtener matrices, por ejemplo:
test_key_1 :
test_key_2 : hello
test_key_3 : /bar/%$test_key_1.test_key_2%/barSalidas:
[
" test_key_1 " => array (
" test_key_2 " => " hello "
),
" test_key_2 " => " /bar/hello/foobar/ "
]También puedes usar variables de entorno para realizar reemplazos:
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;
}Salidas:
[
" test_key_1 " => " test_username " ,
" test_key_2 " => " test_password "
] Sus variables de entorno deben tener el prefijo %^ y el sufijo %
También puedes hacerlo para que tu matriz de configuración esté disponible para getenv() :
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
$ Vars -> toEnv ();Nota: Su configuración se aplanará a una notación de puntos para esto, por ejemplo:
test_key_1 :
test_key_2 : valueSe accederá por:
getenv ( ' test_key_1.test_key_2 ' ); // value Globals en Vars se refieren a variables definidas como tales:
_globals :
test_key_1 : test_value_1 Básicamente, simplemente están encapsulados en una matriz _globals ; el uso de estos es para que puedas acceder a ellos desde getGlobals() desde Vars
La acción predeterminada es fusionarlos con el resto del contenido del archivo, de modo que:
_globals :
test_key_1 : test_value_1
test_key_2 : test_value_2Se convierte en:
[
' test_key_1 ' => ' test_value_1 ' ,
' test_key_2 ' => ' test_value_2 ' ,
] Pero puedes anular esto cambiando merge_globals a false mediante las opciones.
Si esto no tiene sentido, entonces probablemente no necesitará usar globales en absoluto, pero son útiles para trabajar con marcos que encapsulan todo en, por ejemplo, $app y desea poder acceder a algunos valores clave => como entonces: $app['test_key_1'] . Consulte la sección Proveedor de Silex para obtener más ejemplos.
Vars almacena automáticamente en caché los recursos durante 5 minutos; puede desactivarlo configurando la opción cache en false .
La cache_path si no está configurada, se establece en el valor establecido para la path . La cache_path debe poder escribirse.
Para invalidar el caché, simplemente elimine la carpeta dentro de su cache_path llamada Vars , por ejemplo: rm -rf /var/www/application/app/cache/ Vars
El archivo de caché es un archivo .php debido a la aceleración adicional de opcache.
Si está utilizando el proveedor Silex, el caché no se utilizará ni se configurará si está en modo de depuración.
Los cargadores son los que permiten Vars leer los diferentes tipos de archivos (los valores predeterminados son Ini, Json, Php, Toml, Xml y Yaml).
Puede habilitar y deshabilitar cargadores a través de las opciones:
Por defecto carga todos los cargadores predeterminados:
$ 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 '
]
]); Para crear su propio cargador personalizado, debe extender M1 Vars LoaderAbstractLoader , tener las extensiones admitidas en la matriz public static $supported y tener una public function load() que cargue el contenido del archivo.
Aquí hay un ejemplo primitivo que carga archivos .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 ;
}
}Luego, para usar este cargador, simplemente usarías:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => [
' M1FooBarLoaderTextLoader ' ,
]
]);Nota: no utilice este cargador de verdad, es únicamente para fines de presentación.
Es bastante sencillo utilizar esta biblioteca con Silex, simplemente regístrela cuando registre otros proveedores de servicios:
$ 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 ' ,
]]); Luego puedes acceder a tu configuración desde $app[' Vars ']
Nota: Si $app['debug'] = true entonces no se utilizará el caché.
También puede acceder a los valores de configuración desde $app utilizando la notación de puntos, por ejemplo:
test_key_1 :
test_key_2 : value
test_key_3 : valuePuedes obtener lo anterior usando la notación de puntos de esta manera:
$ app [ ' Vars ' ][ ' test_key_1.test_key_2 ' ]; // value
$ app [ ' Vars ' ][ ' test_key_3 ' ]; // value También puedes fusionar globales en $app de esta manera:
# 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 ' ](); Tenga en cuenta $app[' Vars .merge']() : esto anula los valores predeterminados del proveedor de servicios, por lo que en este ejemplo monolog utilizará el archivo de registro definido en la configuración Vars .
Debe llamar Vars .merge después de haber llamado a los proveedores de servicios para los que proporciona valores de configuración en su configuración.
También puede acceder test_key_1 a través de $app[' Vars .test_key_1'] y, de manera similar, si lo desea, puede acceder a globales como $app['monolog.logfile'] .
Vars ($resource, $options = array())El constructor para crear una nueva configuración 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()Devuelve el contenido analizado de todas las configuraciones.
getResource($resource)Obtiene un recurso específico, devuelve un recurso de archivo o es falso si el recurso no existe.
El nombre $resource se basa en la ruta definida en la ruta base y el nombre del archivo.
# 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() Devuelve todos los recursos importados, serán objetos FileResource .
toEnv() Hace que la configuración esté disponible a través de getenv() :
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> toEnv ();
getenv ( ' test_1 ' ); // value toDots()Hace que la configuración se aplane en una matriz de notación de puntos
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() Obtiene los valores definidos en _globals
set($key, $value)Establezca una clave de configuración:
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> set ( ' test_key_1 ' , ' value_2 ' );get($key)Obtiene una clave de configuración:
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> get ( ' test_key_1 ' ); // valuegetRawContent()Obtenga el contenido sin procesar y sin analizar del archivo
# 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()Ver getContent()
get($key)Ver obtener()
Consulte CHANGELOG para obtener más información sobre los cambios recientes.
$ composer test Consulte CONTRIBUCIÓN para obtener más detalles.
Si descubre algún problema relacionado con la seguridad, envíe un correo electrónico a [email protected] en lugar de utilizar el rastreador de problemas.
La Licencia MIT (MIT). Consulte el archivo de licencia para obtener más información.
