PSR Traduzidas

PSR-0: - autoload e namespace

A seguir, o manual com os requisitos obrigatrios que devem ser seguidos
para a interoperabilidade de autocarregamento (autoloading).
Obrigatrio
Uma namespace totalmente qualificada e as classes devem seguir a
seguinte estrutura \<Nome do Fabricante>\(<Namespace>\)*<Nome da Classe>
Cada namespace deve ter uma namespace de nvel superior ("Nome do
fabricante").
Cada namespace pode ter quantos sub-namespaces que quiser.
Cada separador de namespace deve ser convertido
para DIRECTORY_SEPARATOR durante o carregamento do sistema de arquivos.
Cada caractere _ no nome da classe convertido
para DIRECTORY_SEPARATOR. O caractere _no tem nenhum significado
especial na namespace.
A namespace totalmente qualificada e a classe sufixada com .php durante
o carregamento do sistema de arquivos.
Caracteres alfabticos em nomes de fabricante, em namespaces e em
classes podem ser qualquer combinao de letras maisculas e minsculas.
Exemplos
\Doctrine\Common\IsolatedClassLoader => /caminho/para/projeto/lib/vendor/Doctri
ne/Common/IsolatedClassLoader.php
\Symfony\Core\Request => /caminho/para/projeto/lib/vendor/Symfony/Core/Reques
t.php
\Zend\Acl => /caminho/para/projeto/lib/vendor/Zend/Acl.php
\Zend\Mail\Message => /caminho/para/projeto/lib/vendor/Zend/Mail/Message.php
Underlines em namespaces e em nomes
de classes
\namespace\package\Class_Name => /caminho/para/projeto/lib/vendor/namespace
/package/Class/Name.php
\namespace\package_name\Class_Name => /caminho/para/projeto/lib/vendor/nam
espace/package_name/Class/Name.php
Os padres que definimos aqui devem ser o menor denominador comum
para uma indolor interoperabilidade de autocarregamento. Voc pode testar
se est seguindo esses padres, utilizando esta amostra da implementao
da SplClassLoader que capaz de carregar classes do PHP 5.3.
Exemplo de implementao
Abaixo est um exemplo de funo para simplesmente demonstrar como os
padres propostos acima so autocarregados.
<?php

function autoload($className)
{
$className = ltrim($className, '\\');
$fileName = '';
$namespace = '';
if ($lastNsPos = strrpos($className, '\\')) {
$namespace = substr($className, 0, $lastNsPos);
$className = substr($className, $lastNsPos + 1);
 $fileName = str_replace('\\', DIRECTORY_SEPARATOR, $namespace) .
DIRECTORY_SEPARATOR;
}
$fileName .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';

require $fileName;
}
Implementao da SplClassLoader
O seguinte gist uma implementao da SplClassLoader que carrega suas
classes se voc seguir as propostas de interoperabilidade de
autocarregamento citadas acima. Atualmente, a forma recomendada para
carregar classes de PHP 5.3 que seguem estes padres.
http://gist.github.com/221634
PSR-1

Padro bsico de codificao

Esta seo do padro compreende o que deve ser considerado dos
elementos padres de codificao que so necessrios para um alto nvel de
interoperabilidade tcnica entre cdigo PHP compartilhado.
1. Viso geral
Arquivos devem usar apenas as tags <?php e <?=
Arquivos devem usar apenas UTF-8 sem BOM para cdigo PHP.
Arquvos devem declarar smbolos (classes, funes, contantes, etc.) ou
causar outros efeitos (ex: gerar output, alterar configuraes .ini, etc.), mas
no devem fazer as duas coisas.
Namespaces e classes devem seguir a PSR-0.
Nomes das classes devem ser declarados em StudlyCaps.
Constantes de classes devem ser declaradas em letra maiscula
separado por underlines.
Nomes de mtodos devem ser declarados em camelCase. Ex:
getCandidato

2. Arquivos
2.1. Tags PHP
Cdigo PHP deve usar as tags longas <?php ?> ou a short-tags para
echo <?= ?>; no deve se utilizar outras tags.
2.2. Codificao de caracteres
Cdigo PHP deve usar apenas UTF-8 sem BOM.
2.3. Efeitos secundrios
Ou o arquivo declara classes, funes, constantes, ou o arquivo
executa lgica e outros efeitos, mas nunca ambos.
Um arquivo deve declarar novos smbolos (classes, funes, contantes, etc.)
e no causar outros efeitos, ou ele deve executar lgica com outros efeitos,
mas no deve fazer ambos.
A expresso "efeitos secundrios" significa a execuo da lgica no
diretamente ligada com declarao de classes, funes, constantes, etc,
apenas de incluir o arquivo.
"Efeitos secundrios" incluem, mas no esto limitados a: A gerao do
output, uso explcito de require ou include, conexo a servios externos,
modificao de configuraes ini, emisso erros ou excees, modificao
das variveis globais ou estticas, ler ou escrever em um arquivo, e assim
por diante.

A seguir est um exemplo de um arquivo, com as declaraes e efeitos

secundrios; um exemplo de que deve ser evitado:
<?php
// efeito secundrio: mudana nas configuraes ini
ini_set('error_reporting', E_ALL);

// efeito secundrio: carregamento de arquivo

include "file.php";

// efeito secundrio: gerao de output

echo "<html>\n";

// declarao
function foo()
{
// corpo da funo
}
A seguir est um exemplo de um arquivo, com declaraes sem efeitos
secundrios; um exemplo do que deve ser feito:

<?php
// declarao
function foo()
{
// corpo da funo
}

// declarao condicional no um efeito secundrio

if (! function_exists('bar')) {
function bar()
{
// corpo da funo
}
}

3. Namespace e nomes de classes

Namespaces e classes devem seguir a PSR-0.
Isto significa que cada classe est em um arquivo, por si mesmo, e em um
espao de pelo menos um nvel: um nvel superior com o nome do
fornecedor.
Classes devem ser declaradas em StudlyCaps.
Cdigo escrito para PHP 5.3 ou superior deve utilizar namespaces reais.

Por exemplo:

<?php
// PHP 5.3 e superior:
namespace Vendor\Model;

class Foo
{
}
Cdigo escrito para PHP 5.2.x ou inferior deve utilizar a conveno pseudo-
namespace do Vendor_ prefixando nos nomes das classes.
<?php
// PHP 5.2.x e inferior:
class Vendor_Model_Foo
{
}

4. Constantes de classes, propriedades e

mtodos
O termo "classes" se refere a todas as classes, interfaces e traits.
4.1. Constantes
Constantes de classes devem ser declaradas em letra maiscula separado
por underlines. Por exemplo:

<?php
namespace Vendor\Model;

class Foo
{
const VERSION = '1.0';
const DATE_APPROVED = '2012-06-01';
}
4.2. Propriedades
Este guia intencionalmente evita qualquer recomendao sobre o uso
de $StudlyCaps, $camelCase, ou $under_score em nomes de propriedades.
Seja qual for conveno de nomenclatura usada, ela deve ser aplicada de
forma consistente dentro de um escopo razovel. Esse escopo pode ser a
nvel de fornecedor, pacote, classe ou mtodo.
4.3. Mtodos
Mtodos devem ser declarados em camelCase().
PSR-2
Guia de estilo de cdigo
Este guia estende e expande sobre a PSR-1, os padres bsicos de
codificao.

A inteno deste guia reduzir a frico cognitiva durante a

codificao de diferentes autores. Ele faz isso por enumerar um
conjunto compartilhado de regras e expectativas sobre como
formatar o cdigo PHP.

As regras de estilo daqui so derivadas de semelhanas entre

membros de vrios projetos. Quando vrios autores colaboram em
vrios projetos, ajuda a ter um conjunto de diretrizes para serem
usadas em todos os projetos. Assim, o benefcio deste guia no est
nas regras em si, mas sim no compartilhamento dessas regras.

1. Viso geral
Cdigo deve seguir a PSR-1.

Cdigo deve usar 4 espaos para identao ao invs de tabs.

No deve existir um limite rigoroso no comprimento das linhas;

o limite suave deve ser de 120 caracteres; linhas devem ser de
80 caracteres ou menos.

Deve ter uma linha em branco depois da declarao

de namespace e outra linha aps o bloco das declaraes de use.

A abertura de chaves para classes deve estar na prxima linha

e o fechamento na prxima linha aps o corpo.

A abertura de chaves para mtodos deve estar na prxima linha

e o fechamento na prxima linha aps o corpo.

Visibilidade deve ser declarada em todas as propriedades e

mtodos; abstract e final deve ser declarada antes da
visibilidade; static aps a visibilidade.

Palavras-chaves das estruturas de controle devem ter um

espao aps elas; chamadas de mtodos e funes no devem.
 A abertura de chaves para classes deve estar na mesma linha e
o fechamento na prxima linha aps o corpo.

A abertura de parnteses para estruturas de controle no

devem ter um espao aps ela e tambm no deve ter um
espaco antes do fechamento dos parnteses.

1.1. Exemplo
Este exemplo engloba algumas das regras abaixo como uma viso
geral:

<?php
namespace Vendor\Package;

use FooInterface;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class Foo extends Bar implements FooInterface

{
public function sampleFunction($a, $b = null)
{
if ($a === $b) {
bar();
} elseif ($a > $b) {
$foo->bar($arg1);
} else {
BazClass::bar($arg2, $arg3);
}
}

final public static function bar()

{
// corpo do mtodo
}
}
2. Geral
2.1 Padro bsico de codificao
Cdigo deve seguir todas as regras descritas na PSR-1.

2.2 Arquivos
Todos os arquivos PHP deve usar o fim da linha Unix LF (linefeed).

Todos os arquivos PHP devem terminar com uma nica linha em

branco.

A tag de fechamento ?> deve ser omitida em arquivos que s contm

cdigo PHP.
2.3. Linhas
No deve existir um limite rigoroso no comprimento das linhas.

O limite suave deve ser de 120 caracteres; verificadores de estilo

automatizados devem avisar mas no devem assinalar como erro no
limite suave.

Linhas no devem ser maiores do que 80 caracteres; linhas longas

devem ser quebradas em linhas com menos de 80 caracteres cada.

No deve ter linhas em branco no final de linhas no em branco.

Linhas em branco podem ser adcionadas para aumentar a legibilidade

e para indicar blocos relacionados de cdigo.

No deve ter mais de um comando por linha.

2.4. Indentao
Cdigo deve usar uma identao de 4 espacos, e no deve usar tabs
para identao.

Note bem: Usando apenas espaos, e no misturando espaos com

tabs, ajuda a evitaar problemas com diffs, patches, history e
annotations. O uso de espaos tambm torna mais fcil para inserir
sub-identao.

2.5. Palavras-chave e as constantes

True/False/Null
Palavras-chave do PHP devem estar em letra minscula.

As constantes do PHP true, false e null devem estar em letra minscula.

3. Namespace e declaraes de 'use'

Quando presente, deve haver uma linha em branco depois da
declarao da namespace.

Quando presente, todas as declaraes use devem vir depois da

declarao da namespace.

Deve haver uma palavra-chave use para cada declarao.

Deve haver uma linha em branco aps o bloco de declaraes use.

Por exemplo:

<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

// ... cdigo PHP adcional ...

4. Classes, propriedades e mtodos

O termo "classes" uma referncia para todas as classes, interfaces e
traits.

4.1. Extends e Implements

As palavras-chave extends e implements devem ser declaradas na
mesma linha do nome da classe.

A abertura de chaves para a classe deve vir na prxima linha; o

fechamento das chaves deve vir na linha seguinte do fechamento do
corpo.

<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class ClassName extends ParentClass implements \ArrayAccess, \Countable

{
// constantes, propriedades e mtodos
}

A lista de implements pode ser divida em mltiplas linhas, onde cada

linha subsequente identada uma vez. Quando fizer isto, o primeiro
item na lista deve estar na prxima linha e deve haver uma interface
por linha.

<?php
namespace Vendor\Package;

use FooClass;
use BarClass as Bar;
use OtherVendor\OtherPackage\BazClass;

class ClassName extends ParentClass implements

\ArrayAccess,
 \Countable,
\Serializable
{
// constantes, propriedades e mtodos
}

4.2. Propriedades
Visibilidade deve ser declarada em todas as propriedades.

A palavra-chave var no deve ser utilizada para declarar uma

propriedade.

No deve haver mais de uma propriedade declarada por instruo.

Nome das propriedades no devem ser prefixados com um nico

undeline para indicar a visibilidade protegida ou privada.

Uma declarao de propriedade se parece com o seguinte:

<?php
namespace Vendor\Package;

class ClassName
{
public $foo = null;
}

4.3. Mtodos
Visibilidade deve ser declarada em todos os mtodos.

Nome dos mtodos no devem ser prefixados com um nico undeline

para indicar a visibilidade protegida ou privada.

Nome dos mtodos no devem ser declarados com um espao aps

ao nome do mtodo. A abertura de chave deve vir na prxima linha e
o fechamento deve vir na linha seguinte do fechamento do corpo. No
deve haver um espao depois da abertura dos parnteses e nem um
espao antes do fechamento dos parnteses.

Uma declarao de mtodo se parece com o seguinte. Note a

colocao dos parnteses, vrgulas, espaos e chaves:

<?php
namespace Vendor\Package;

class ClassName
{
public function fooBarBaz($arg1, &$arg2, $arg3 = [])
{
// corpo do mtodo
 }
}

4.4. Argumentos dos mtodos

Na lista de argumentos, no deve haver um espao antes de cada
vrgula e deve haver um espao aps cada vrtgula.

Argumentos de mtodos com valores padro deve vir no final da lista

de argumentos.

<?php
namespace Vendor\Package;

class ClassName
{
public function foo($arg1, &$arg2, $arg3 = [])
{
// corpo do mtodo
}
}

Listas de argumentos podem ser dividas em mltiplas linhas, onde

cada linha subsequente identada uma vez. Quando fizer isto, o
primeiro item na lista deve estar na prxima linha e deve haver um
argumento por linha.

Quando a lista de argumento for dividida em mltiplas linhas, o

fechamento de parnteses e a abertura de chaves devem ser
colocadas na mesma linha com um espao entre eles.

<?php
namespace Vendor\Package;

class ClassName
{
public function umNomeDeMetodoMuitoLongo(
ClassTypeHint $arg1,
&$arg2,
array $arg3 = []
){
// corpo do mtodo
}
}

4.5. Palavras-chave abstract, final,

e static
Quando presentes, as declaraes abstract e final devem preceder a
declarao da visibilidade.
Quando presente, a declarao static deve vir depois da declarao da
visibilidade.

<?php
namespace Vendor\Package;

abstract class ClassName

{
protected static $foo;

abstract protected function zim();

final public static function bar()

{
// corpo do mtodo
}
}

4.6. Chamadas de mtodos e funes

Quando fazemos uma chamada de mtodo ou de funo, no deve
haver um espao entre o mtodo ou o nome da funo e a abertura
dos parnteses, no deve haver um espao depois da abertura de
parnteses e no deve haver um espao antes do fechamento de
parnteses. Na lista de argumentos no deve haver um espao antes
de cada vrgula e deve ter uma espao depois de cada vrgula.

<?php
bar();
$foo->bar($arg1);
Foo::bar($arg2, $arg3);

Listas de argumentos podem ser dividas em mltiplas linhas, onde

cada linha subsequente identada uma vez. Quando fizer isto, o
primeiro item na lista deve estar na prxima linha e deve haver um
argumento por linha.

<?php
$foo->bar(
$longArgument,
$longerArgument,
$muchLongerArgument
);

5. Estruturas de controle
As regras gerais de estilo para estruturas de controle so as
seguintes:

Deve haver um espao depois da palavra-chave da estrutura de

controle

No deve haver um espao depois da abertura de parnteses

 No deve haver um espao antes do fechamento de parnteses

Deve haver um espao entre o fechamento de parnteses e a

abertura de chaves

A estrutura do corpo deve ser identada uma vez

O fechamento das chaves devem vir na prxima linha aps o corpo

O corpo de cada estrutura deve ser delimitado por chaves. Isto

padroniza como as estruturas aparecem e reduz o risco de introduo
de erros como novas linhas sejam adcionadas ao corpo.

5.1. if, elseif, else

Uma estrutura if se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves; e que else e elseif so na mesma linha
do fechamento das chaves do corpo anterior.

<?php
if ($expr1) {
// if corpo
} elseif ($expr2) {
// elseif corpo
} else {
// else corpo;
}

A palavra-chave elseif deve ser usada ao invs de elseif de modo que

todas as estruturas de controle paream uma nica palavra.

5.2. switch, case

Uma estrutura switch se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves. A declarao case deve ser identada
uma vez do switch, e a palavra-chave break (ou outra palavra-chave de
finalizao) deve ser identada no mesmo nvel do corpo do case. Deve
haver um comentrio como // no break quando "continuar"
intencional e no for um case com corpo vazio.

<?php
switch ($expr) {
case 0:
echo 'Primeiro caso, com uma quebra';
break;
case 1:
echo 'Segundo caso, sem uma quebra, continuando para o(s) caso(s)
seguintes';
// no break
case 2:
 case 3:
case 4:
echo 'Quarto caso, return usado para fazer a quebra ao invs de break';
return;
default:
echo 'Caso padro';
break;
}

5.3. while, do while

Uma estrutura while se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves.

<?php
while ($expr) {
// estrutura
}

Igualmente, uma estrutura do while se parece com o seguinte. Note a

posio dos parnteses, espaos e chaves.

<?php
do {
// estrutura;
} while ($expr);

5.4. for
Uma estrutura for se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves.

<?php
for ($i = 0; $i < 10; $i++) {
// for corpo
}

5.5. foreach
Uma estrutura foreach se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves.

<?php
foreach ($iterable as $key => $value) {
// foreach corpo
}

5.6. try, catch

Um bloco try catch se parece com o seguinte. Note a posio dos
parnteses, espaos e chaves.

<?php
try {
// try corpo
} catch (FirstExceptionType $e) {
// catch corpo
} catch (OtherExceptionType $e) {
// catch corpo
}

6. Closures
Closures devem ser declaradas com um espao depois da palavra-
chave function e um espao antes e depois da palavra-chave use.

A abertura da chave deve vir na mesma linha e o fechamento da

chave deve vir na prxima linha aps o corpo.

No deve haver um espao aps a abertura de parnteses de uma

lista de argumentos ou uma lista de variveis, e no deve haver um
espao antes do fechamento dos parnteses da lista de argumentos
ou de variveis.

Na lista de argumentos e na lista de variveis, no deve haver um

espao antes de cada vrgula e deve haver um espao depois de cada
vrgula.

Argumentos de uma Closure com valores padro devem vir depois da

lista de argumentos.

Uma declarao de closure se parece com o seguinte. Note a posio

de parnteses, vrgulas, espaos e chaves:

<?php
$closureWithArgs = function ($arg1, $arg2) {
// corpo
};

$closureWithArgsAndVars = function ($arg1, $arg2) use ($var1, $var2) {

// corpo
};

Listas de argumentos e de variveis podem ser divididas em mltiplas

linhas, onde cada linha subsequente identada uma vez. Quando
fizer isto, o primeiro item na lista deve estar na prxima linha e deve
haver um argumento ou varivel por linha.

Quando a lista de argumento for dividida em mltiplas linhas, o

fechamento de parnteses e a abertura de chaves devem ser
colocadas na mesma linha com um espao entre eles.

Os seguintes so exemplos de closure com e sem listas de

argumentos e variveis divididas em mltiplas linhas.
<?php
$longArgs_noVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
){
// corpo
};

$noArgs_longVars = function () use (

$longVar1,
$longerVar2,
$muchLongerVar3
){
// corpo
};

$longArgs_longVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
) use (
$longVar1,
$longerVar2,
$muchLongerVar3
){
// corpo
};

$longArgs_shortVars = function (
$longArgument,
$longerArgument,
$muchLongerArgument
) use ($var1) {
// corpo
};

$shortArgs_longVars = function ($arg) use (

$longVar1,
$longerVar2,
$muchLongerVar3
){
// corpo
};

Note que as regras de formatao tambm se aplicam quando o

fechamento usado diretamente em uma chamada de funo ou
mtodo como um argumento.

<?php
$foo->bar(
$arg1,
function ($arg2) use ($var1) {
// corpo
},
$arg3
);
7. Concluso
H muitos elementos de estilo e prticas intencionalmente omitidos
por este guia. Estes incluem, mas no esto limitados para:

Declarao de variveis globais e constantes globais

Declarao de funes

Operadores e atribuio

Alinhamento entre linhas

Comentrios e blocos de documentao

Prefixos e sufixos de nomes de classes

Boas prticas

Futuras recomendaes podem ser revisadas e pode se estender este

guia para abordar outros elementos de estilo e prtica.

PSR-3: Logger
Interface
Este documento descrve uma interface comum para
bibliotecas de Logging.

O principal objetivo permitir que bibliotecas recebam um

objeto como:

Psr\Log\LoggerInterface e grave logs de uma maneira simples e

universal.
Frameworks and CMSs que tm necessidades personalizadas
PODEM estender a interface para o seu prprio propsito, mas
devem continuar a ser compatvel com este documento. Isso
garante que as bibliotecas de terceiros que um aplicativo usa,
podem gravar nas aplicaes os logs de forma centralizada.
(write to the centralized application logs.)

As palavras-chave MUST(DEVE), MUST NOT(NO DEVE),

REQUIRED(REQUERIDO), SHALL (DEVE), SHALL NOT
(NO DEVER), SHOULD (DEVERIA), SHOULD NOT (NO
DEVE), RECOMMENDED (RECOMENDADO), MAY (PODE), e
OPTIONAL (OPCIONAL) neste documento, devem ser
interpretadas como descrito na RFC 2119.

A palavra implementor neste documento deve ser interpretada

como algum implementando o LoggerInterface em uma
biblioteca ou framework relacionado ao log. Usurios
registrados so referidos como user .

Especificao
1.1 Basics

O LoggerInterface expe oito mtodos para gravar logs para os

oito RFC 5424 niveis (depurao, info, noticia, aviso, erro,
crtica, alerta, emergncia).

Um nono mtodo, log , aceita um nvel de log como o

primeiro argumento. Chamar esse mtodo com uma das
constantes de nvel de log DEVE ter o mesmo resultado
como chamar o mtodo de nvel especfico. Chamar este
mtodo com um nvel no definido por esta
especificao DEVE lanar um Psr\Log\InvalidArgumentException
se a implementao no sabe sobre o nvel. Os usurios
 NO DEVEM usar um nvel personalizado sem saber com
certeza que a implementao atual o suporta.

1.2 Message
Cada mtodo aceita uma string como mensagem, ou um
objeto com o mtodo __toString() .
Implementadores podem ter manipulao especial para os
objetos passados. Se esse no for o caso, os implementadores
devem mold-lo para uma string.
A mensagem pode conter placeholders que os
implementadores podem substituir com valores da array de
contexto.

Os nomes dos placeholders DEVEM corresponder as chaves na

array (matriz) de contexto.

Os nomes de placeholders DEVEM ser delimitados com uma

nica chave de abertura { e uma nica chave de fecho }. No
deve haver espao em branco entre os delimitadores e o
nome do placeholders (marcador de posio).
Os nomes de placeholders DEVERO ser compostos apenas
dos caracteres A-Z, a-z, 0-9, sublinhado _ e perodo.. O uso de
outros caracteres reservado para futuras modificaes da
especificao dos placeholders.

Os implementadores podem usar placeholders para

implementar vrias estratgias de escape e traduzir logs para
exibio. Os usurios NO devem pr-escapar valores de
placeholders se eles no souberem em qual contexto os
dados sero exibidos.

The following is an example implementation of placeholder

interpolation provided for reference purposes only:
O exemplo seguinte de uma implementao de interpolao
de placeholder fornecida apenas para fins de referncia:

/**
* Interpolates context values into the message placeholders.
*/
function interpolate($message, array $context = array())
{
// criar uma matriz de substituio com chaves em torno das chaves de
contexto

$replace = array();
foreach ($context as $key => $val) {

// Verificar se o valor pode ser moldado para string

if (!is_array($val) && (!is_object($val) || method_exists($val,

'__toString'))) {
$replace['{' . $key . '}'] = $val;
}
}

// Interpolar os valores de substituio para a mensagem e

Retornar:

return strtr($message, $replace);

}

// Uma mensagem com nomes de placeholder delimitado por chaves

$message = "User {username} created";

// Uma array de contexto de nomes de placeholders => valores de

substituio

$context = array('username' => 'bolivar');

// imprime "User bolivar created"

echo interpolate($message, $context);

1.3 Context
Cada mtodo aceita uma matriz como dados
de contexto. Isso para manter qualquer
informao estranha que no se encaixa bem
em uma string. A matriz pode conter qualquer
coisa. Os implementadores DEVEM assegurar
que tratam os dados de contexto com a maior
clareza possvel. Um dado valor no contexto
no deve lanar uma exceo nem levantar
qualquer php erro, noticia ou aviso.

Se um objeto Exception for passado nos dados de

contexto, ele DEVE estar na chave 'exception
'. Excees de logging um padro comum e
isso permite que os implementadores
extraiam um rastreamento de pilha (stack trace)
da exceo quando o backend de log o
suportar.
Os implementadores DEVEM ainda verificar
que a chave 'exception' realmente uma Exception
antes de a utilizar como tal, pois PODE conter
qualquer coisa.

1.4 Helper classes and interfaces

Classes auxiliares e interfaces

A classe Psr\Log\AbstractLogger permite implementar

facilmente o LoggerInterface implementando e extendendo o
mtodo de log genrico. Os outros oito mtodos vo seguir a
mensagem e o contexto para ele.
Da mesma forma, usando o Psr\Log\LoggerTrait s requer
que voc implemente o mtodo de log genrico. Observe que,
uma vez que traos (traits) no podem implementar
interfaces, neste caso voc ainda tem que implementar
LoggerInterface .

O Psr\Log\NullLogger fornecido em conjunto com a

interface. Ele PODE ser usado por usurios da interface para
fornecer uma implementao fall-back "buraco negro" (black
hole) se nenhum logger dado a eles. No entanto, o logging
condicional pode ser uma abordagem melhor se a criao de
dados de contexto difcil.

O Psr\Log\LoggerAwareInterface contm apenas um mtodo

setLogger(LoggerInterface $logger) e pode ser usado por frameworks
para linkar? (auto-wire) instncias arbitrrias com um logger.
A caracterstica Psr\Log\LoggerAwareTrait pode ser usada para
implementar a interface equivalente facilmente em qualquer
classe. Ele d acesso ao $this->logger .

A classe Psr\Log\LogLevel contm constantes para os oito nveis

de registo.

Package
As interfaces e classes descritas, bem como as classes de
exceo relevantes e um conjunto de testes para verificar sua
implementao so fornecidos como parte do pacote psr / log.

Psr\Log\LoggerInterface
<?php

namespace Psr\Log;.

* Descreve uma instncia de logger

*
* A mensagem deve ser uma string ou objeto implementando __toString
().
*
* A mensagem pode conter espaos reservados (placeholders) na forma:
{foo} where foo
* Ser substitudo pelos dados de contexto na chave "foo".
*
* A matriz de contexto pode conter dados arbitrrios, a nica suposio de
que pode ser feita pelos implementadores que se uma instncia de
exceo dada Para produzir um rastreamento de pilha, ele deve estar em
uma chave chamada "exceo".
*
 * Consulte https://github.com/php-fig/fig-
standards/blob/master/accepted/PSR-3-logger-interface.md
* Para a especificao de interface completa.
interface LoggerInterface
{
/**
* System is unusable.
*
* @param string $message
* @param array $context
* @return null
*/
public function emergency($message, array $context = array());

/**
* Action must be taken immediately.
*
* Example: Entire website down, database unavailable, etc. This should
* trigger the SMS alerts and wake you up.
*
* @param string $message
* @param array $context
* @return null
*/
public function alert($message, array $context = array());

/**
* Critical conditions.
*
* Example: Application component unavailable, unexpected exception.
*
* @param string $message
* @param array $context
* @return null
*/
public function critical($message, array $context = array());

/**
* Runtime errors that do not require immediate action but should
typically
* be logged and monitored.
*
* @param string $message
* @param array $context
* @return null
*/
public function error($message, array $context = array());

/**
* Exceptional occurrences that are not errors.
 *
* Example: Use of deprecated APIs, poor use of an API, undesirable things
* that are not necessarily wrong.
*
* @param string $message
* @param array $context
* @return null
*/
public function warning($message, array $context = array());

/**
* Normal but significant events.
*
* @param string $message
* @param array $context
* @return null
*/
public function notice($message, array $context = array());

/**
* Interesting events.
*
* Example: User logs in, SQL logs.
*
* @param string $message
* @param array $context
* @return null
*/
public function info($message, array $context = array());

/**
* Detailed debug information.
*
* @param string $message
* @param array $context
* @return null
*/
public function debug($message, array $context = array());

/**
* Logs with an arbitrary level.
*
* @param mixed $level
* @param string $message
* @param array $context
* @return null
*/
public function log($level, $message, array $context = array());
}
Psr\Log\LoggerAwareInterface
<?php

namespace Psr\Log;

/**
* Describes a logger-aware instance
*/
interface LoggerAwareInterface
{
/**
* Sets a logger instance on the object
*
* @param LoggerInterface $logger
* @return null
*/
public function setLogger(LoggerInterface $logger);
}

Psr\Log\LogLevel
<?php

namespace Psr\Log;

/**
* Describes log levels
*/
class LogLevel
{
const EMERGENCY = 'emergency';
const ALERT = 'alert';
const CRITICAL = 'critical';
const ERROR = 'error';
const WARNING = 'warning';
const NOTICE = 'notice';
const INFO = 'info';
const DEBUG = 'debug';
}