Vars é um carregador de configuração simples de usar, leve e facilmente extensível com carregadores integrados para tipos de arquivo ENV, INI, JSON, PHP, Toml, XML e YAML. Ele também vem com suporte integrado para Silex com mais frameworks (Symfony, Laravel etc) em breve.
Às vezes você é forçado a usar formatos diferentes para arquivos de configuração e um dos objetivos Vars é tornar isso mais simples para você, suportando os formatos de configuração mais comuns, para que você não precise trocar de biblioteca para lidar com os diferentes formatos.
Outro objetivo é oferecer suporte a estruturas diferentes, para que você não precise trocar de biblioteca ao lidar com estruturas diferentes. Atualmente suportando Silex apenas usando um provedor de serviços, suporte para Laravel e Symfony em breve.
Com uma API simples e opções de carregamento intuitivas, Vars tenta tornar o carregamento e o fornecimento de configurações o mais fácil possível para você.
Vars requer PHP versão 5.3+
.
Se você quiser usar YAML, precisará da biblioteca symfony/yaml
e, da mesma forma, precisará yosymfony/toml
para usar arquivos Toml e m1/env
para usar arquivos Env.
Através do 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 ' ,
));
Isso pode ser feito de várias maneiras, você pode tratar a variável $ Vars
como um array normal ou pode usá-la de maneira orientada a objetos
// All return the same thing
$ Vars -> get ( ' db.password ' )
$ Vars [ ' db.password ' ];
$ Vars [ ' db ' ][ ' password ' ]
Você também pode definir valores da mesma maneira
// All do the same thing
$ Vars -> set ( ' db.password ' , ' test ' )
$ Vars [ ' db.password ' ] = ' test ' ;
$ Vars [ ' db ' ][ ' password ' ] = ' test ' ;
Você também pode obter as variáveis de getenv()
// All do the same thing
$ Vars -> toEnv ();
getenv ( ' db.password ' );
Para mais informações sobre isso, verifique a seção Variáveis de Ambiente
Você pode facilmente importar configurações de forma relativa e absoluta para outras configurações, elas diferem de acordo com o tipo de arquivo de configuração, então verifique a pasta /tests/mocks/ para obter exemplos
# example_1.yml
test_key_1 : test_value_1
imports : example_2.yml
# example_2.yml
test_key_2 : test_value_2
Voltaria:
[
" test_key_1 " => " test_value_1 " ,
" test_key_2 " => " test_value_2 "
]
As importações são importadas em relação à chave por padrão, por exemplo:
test_key_1 :
imports : example_2.yml
Voltaria:
[
" test_key_1 " => [
" test_key_2 " => " test_value_2 "
]
]
No entanto, você pode alterar isso de várias maneiras:
# example 1
test_key_1 :
imports :
- {resource: example.yml, relative: false}
# example 2
test_key_2 :
imports :
resource : example.yml
relative : false
Se estiver importando vários arquivos e quiser definir a relatividade de todos os arquivos, você pode fazer o seguinte:
test_key_1 :
imports :
relative : false
resource :
- example_2.yml
- example_3.yml
Tudo isso faz com que as variáveis example_2.yml
e example_3.yml
se tornem absolutas para o arquivo de configuração:
[
" test_key_1 " => []
" test_key_2 " => " test_value_2 " // from example_2.yml
"test_key_3" => "test_value_3" // from example_3.yml
]
Você também pode importar diretórios usando toda a sintaxe acima:
test_key_1 :
imports : sub/
A importação de diretórios não é recursiva por padrão e não pesquisará pastas dentro de pastas. Você pode alterar isso adicionando uma alternância recursiva:
test_key_1 :
imports :
resource : sub/
recursive : true
ou adicionando um sinalizador recursivo:
test_key_1 :
imports :
resource : sub/*
Tal como acontece com os arquivos de carregamento, você pode importar diretórios em massa com uma alternância recursiva:
test_key_1 :
imports :
recursive : false
resource :
- sub/
- sub1/
A importação de diretórios depende de carregadores e extensões suportadas pelos carregadores. Consulte a seção do carregador para obter mais detalhes.
Você pode usar vários sinalizadores ao importar.
O sinalizador if else ?:
faz com que se o primeiro arquivo existir, use-o - caso contrário, use o outro arquivo definido, por exemplo:
imports : " example_1.yml ?: example_2.yml "
Nota: Você precisa colocar a string entre aspas para que o sinalizador if else funcione
O sinalizador de supressão de exceções @
- suprime exceções de arquivos não encontrados. por exemplo:
imports : @file_does_not_exist.yml
O sinalizador recursivo faz com que os diretórios dentro dos diretórios sejam pesquisados em busca de arquivos. por exemplo:
imports :
resource : sub/*
Você também pode combinar os sinalizadores acima, portanto, se a opção else file não existir, ela não lançará uma exceção, por exemplo:
imports : " example_1.yml ?: @example_2.yml "
Você pode obter arquivos ou recursos individuais:
// All return the same thing
$ Vars -> getResource ( ' example_2.yml ' )-> get ( ' test_key_2 ' );
$ Vars -> getResource ( ' example_2.yml ' )[ ' test_key_2 ' ];
Existem várias opções 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 '
]
]);
O path
é como $filename
em $ Vars ->getResource($filename)
é calculado. Por exemplo:
Se você definir o path
para __DIR__.'/config'
e importou __DIR__.'/app/test_1.yml'
:
# example_1.yml
imports : example_2.yml
Então, example_1.yml
e example_2.yml
$filename
seriam ../app/test_1.yml
e ../app/test_1.yml
respectivamente.
Se nenhum path
for definido, o primeiro caminho do recurso de arquivo será usado como path
, por exemplo:
// example 1
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
// example 2
$ Vars = new Vars ([
__DIR__ . ' /config/config.yml ' ,
__DIR__ . ' /sub/config.yml ' ,
]);
Ambos usarão __DIR__.'/config'
como path
Você pode usar 3 tipos de variáveis em Vars
: Replacements
, In-file
e Environment
, a sintaxe é:
Tipo de variável | Sintaxe |
---|---|
Substituições | %VARIABLE% |
No arquivo | %$VARIABLE% |
Ambiente | %^VARIABLE% |
Para melhor legibilidade, você também pode colocar espaços entre o nome da variável e os prefixos/sufixos da seguinte forma:
replacement_variable : % VARIABLE %
infile_variable : %$ VARIABLE %
env_variable : %^ VARIABLE %
Variáveis de substituição são carregadas de fora Vars
, por isso são frequentemente usadas para funções/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 '
],
]);
Saídas:
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/barfoo/foobar/ "
]
Suas substituições devem ser prefixadas e sufixadas com %
Você também pode carregar variáveis de arquivos:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' replacements ' => __DIR__ . ' /config/variables.yml '
]);
Você também pode usar variáveis de suas chaves já definidas nos arquivos, como:
test_key_1 : hello
test_key_2 : /bar/%$test_key_1%/bar
Saídas:
[
" test_key_1 " => " bar " ,
" test_key_2 " => " /bar/hello/foobar/ "
]
Suas substituições devem ter o prefixo %$
e o sufixo %
.
Tanto para in-file
quanto replacements
, você pode usar a sintaxe de notação de ponto para obter matrizes, por exemplo:
test_key_1 :
test_key_2 : hello
test_key_3 : /bar/%$test_key_1.test_key_2%/bar
Saídas:
[
" test_key_1 " => array (
" test_key_2 " => " hello "
),
" test_key_2 " => " /bar/hello/foobar/ "
]
Você também pode usar variáveis de ambiente para fazer substituições:
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;
}
Saídas:
[
" test_key_1 " => " test_username " ,
" test_key_2 " => " test_password "
]
Suas variáveis de ambiente devem ter o prefixo %^
e o sufixo %
Você também pode fazer com que seu array de configuração esteja disponível para getenv()
:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' );
$ Vars -> toEnv ();
Nota: Sua configuração será reduzida a uma notação de ponto para isso, por exemplo:
test_key_1 :
test_key_2 : value
Será acessado por:
getenv ( ' test_key_1.test_key_2 ' ); // value
Globals
em Vars
referem-se a variáveis definidas como tal:
_globals :
test_key_1 : test_value_1
Basicamente, eles são apenas encapsulados em um array _globals
- o uso deles é para que você possa acessá-los em getGlobals()
de Vars
A ação padrão é mesclá-los com o conteúdo de outro arquivo, para que:
_globals :
test_key_1 : test_value_1
test_key_2 : test_value_2
Torna-se:
[
' test_key_1 ' => ' test_value_1 ' ,
' test_key_2 ' => ' test_value_2 ' ,
]
Mas você pode substituir isso alterando merge_globals
para false
através das opções.
Se isso não fizer sentido, então você provavelmente não precisará usar globais, mas eles são úteis para trabalhar com frameworks que encapsulam tudo em $app
e você deseja poder acessar alguns valores-chave => como então: $app['test_key_1']
. Consulte a seção do provedor Silex para obter mais exemplos.
Vars armazena automaticamente os recursos em cache por 5 minutos. Você pode desativar isso definindo a opção cache
como false
.
O cache_path
se não estiver definido, será definido como o path
está definido. O cache_path
deve ser gravável.
Para invalidar o cache, basta remover a pasta dentro do seu cache_path
chamada Vars
, por exemplo: rm -rf /var/www/application/app/cache/ Vars
O arquivo de cache é um arquivo .php devido à aceleração extra do opcache.
Se você estiver usando o provedor Silex, o cache não será usado e definido se você estiver no modo de depuração.
Os carregadores são o que permitem Vars leia os diferentes tipos de arquivos (os padrões são Ini, Json, Php, Toml, Xml e Yaml).
Você pode ativar e desativar carregadores através das opções:
O padrão carrega todos os carregadores padrão:
$ 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 criar seu próprio carregador personalizado, você deve estender M1 Vars LoaderAbstractLoader
, ter as extensões suportadas no array public static $supported
e ter uma public function load()
que carrega o conteúdo do arquivo.
Aqui está um exemplo primitivo que carrega arquivos .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 ;
}
}
Então, para usar este carregador, você simplesmente usaria:
$ Vars = new Vars ( __DIR__ . ' /config/config.yml ' , [
' loaders ' => [
' M1FooBarLoaderTextLoader ' ,
]
]);
Nota: não use este carregador de verdade, é apenas para fins de apresentação
É muito simples usar esta biblioteca com Silex, basta registrá-la quando registrar outros provedores de serviço:
$ 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 ' ,
]]);
Então você pode acessar sua configuração em $app[' Vars ']
Nota: Se você $app['debug'] = true
então o cache não será usado.
Você também pode acessar os valores de configuração de $app usando a notação de ponto, por exemplo:
test_key_1 :
test_key_2 : value
test_key_3 : value
Você pode obter o acima usando a notação de ponto da seguinte forma:
$ app [ ' Vars ' ][ ' test_key_1.test_key_2 ' ]; // value
$ app [ ' Vars ' ][ ' test_key_3 ' ]; // value
Você também pode mesclar globais em $app
assim:
# 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 ' ]();
Observe o $app[' Vars .merge']()
- Isso substitui os padrões do provedor de serviços, portanto, neste exemplo, monolog
usará o arquivo de log definido na configuração Vars .
Você deve chamar Vars .merge
depois de ligar para os provedores de serviços para os quais você fornece valores de configuração em sua configuração.
Você também pode acessar test_key_1
via $app[' Vars .test_key_1']
e da mesma forma, se quiser, você pode acessar globais como $app['monolog.logfile']
.
Vars ($resource, $options = array())
O construtor para criar uma nova configuração 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()
Retorna o conteúdo analisado de todas as configurações.
getResource($resource)
Obtenha um recurso especificado, retorne um recurso de arquivo ou falso se o recurso não existir.
O nome $resource
é baseado no caminho definido no caminho base e no nome do arquivo.
# 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()
Retorna todos os recursos importados, eles serão objetos FileResource
.
toEnv()
Faz com que a configuração esteja disponível via getenv()
:
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> toEnv ();
getenv ( ' test_1 ' ); // value
toDots()
Faz com que a configuração seja achatada em uma matriz de notação de ponto
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()
Obtém os valores definidos em _globals
set($key, $value)
Defina uma chave de configuração:
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> set ( ' test_key_1 ' , ' value_2 ' );
get($key)
Obtém uma chave de configuração:
$ Vars = new Vars ( ' example.yml ' );
$ Vars -> get ( ' test_key_1 ' ); // value
getRawContent()
Obtenha o conteúdo bruto e não analisado do arquivo
# 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()
Veja getContent()
get($key)
Veja obter()
Consulte CHANGELOG para obter mais informações sobre o que mudou recentemente.
$ composer test
Consulte CONTRIBUINDO para obter detalhes.
Se você descobrir algum problema relacionado à segurança, envie um e-mail para [email protected] em vez de usar o rastreador de problemas.
A licença MIT (MIT). Consulte Arquivo de licença para obter mais informações.