eco

Estrutura ecológica

Eco é uma estrutura PHP para Php 5.5+

Instale o exemplo:

 # wget shayanderson.com/eco.zip
# unzip ./eco.zip

Tópicos de documentação

• Roteamento
• Parâmetros de rota
• Visualizações
• Log
• Manuseio de erros
• Ganchos
• Configuração
• Métodos principais
• Classes principais (cache, banco de dados, formulário, http, modelo, tabela)
• Classes Helper (benchmark, farinha de pão, filtro, flash, formato, solicitação, resposta, serviço, sessão, soquete, validar)
• Funções auxiliares (núcleo, alias, fábrica, flash, solicitação, resposta, visualização)
• Estendendo -se Eco

Roteamento

As rotas básicas podem ser configuradas no app/com/route.php , por exemplo:

 // set routes
return [
	// class method
	' / ' => ' IndexController->home ' ,
	// namespace
	' login ' => ' AccountUserController->login ' ,
	// callable
	' logout ' => function () { /* do something */ },
	// more routes
];

A solicitação / ligaria para o método home na classe IndexController no arquivo app/mod/IndexController.php .

A solicitação /login chamaria o login do método na classe AccountUserController no arquivo app/mod/Account/UserController.php .

Métodos HTTP

Métodos HTTP específicos podem ser usados ​​para rotas:

eco:: route ( ' GET@api/user/:id ' , function ( $ id ) { /* GET method */ });
eco:: route ( ' DELETE@api/user/:id ' , function ( $ id ) { /* DELETE method */ });
eco:: route ( ' POST@api/user/:id? ' , function ( $ id = null ) { /* POST method */ });
// or handle multiple HTTP methods
eco:: route ( ' POST|PUT@api/user/:id? ' , function ( $ id = null ) { /* POST or PUT method */ });

Esses métodos HTTP são suportados: DELETE , GET , HEAD , PATCH , POST , PUT

Rota retornos de chamada

Os retornos de chamada de rota podem ser um nome chamável ou chamável (o primeiro elemento da matriz deve ser o controlador/ação):

 function auth () { /* do something */ }
eco:: route ( ' account/secure ' ,
	[ ' AccountController->secure ' , ' auth ' , function () { /* invoked */ }]);

Aviso: os retornos de chamada de rota não funcionam com a configuração dinâmica de rota

Configuração dinâmica de rota

Setters de rotas dinâmicas podem ser usadas para aplicativos maiores que possuem muitas rotas (rotas de carga preguiçosas), por exemplo:

eco:: route ( ' account* ' , ' AccountController::getRoutes() ' );

Agora, todas as solicitações que começam com /account carregarão as rotas usando o método:

 class AccountController
{
    public static function getRoutes ()
    {
        return [
            ' account/login ' => ' AccountController->login ' ,
            // do not have to use class name if in same class:
            ' account/logout ' => ' logout '
        ];
    }
}

A configuração dinâmica de rota (rotas de carga preguiçosa) também pode ser definida diretamente como uma matriz, exemplo:

eco:: route ( ' account* ' , [
    ' AccountController ' , // the class name must be first (index:0)
    ' account/login ' => ' login ' ,
    ' account/logout ' => ' logout '
]);

Roteamento da CLI

O roteamento da CLI é simples de usar, por exemplo:

eco: route ( ' bin/test/:id ' , function ( $ id ) {
    echo ' CLI test, id: ' . $ id ;
});

Agora um comando da CLI pode ser emitido:

 $ php index.php bin/test/5
Bin test: 5

A rota acima também funcionaria em um navegador da web. Para criar uma rota apenas da CLI (não funcionará no navegador da web), adicione um $ ao início da rota, por exemplo:

 // this route will only work as CLI command
// the request '/bin/test/5' in a Web browser would result in a 404 error
eco: route ( ' $bin/test/:id ' , function ( $ id ) {
    echo ' CLI test, id: ' . $ id ;
});

Parâmetros de rota

Nomeados parâmetros de rota:

eco:: route ( ' user/:id ' , ' UserController->view ' );

O valor :id será passado para o método chamável ou de classe:

 class UserController
{
    public function view ( $ id )
    {
        // do something
    }
}

Parâmetros opcionais

Parâmetros opcionais podem ser usados:

eco:: route ( ' page/:id/:title? ' , function ( $ id , $ title = null ) {});

Parâmetros curinga

Exemplo de parâmetros curinga:

eco:: route ( ' product/:info+ ' , function ( $ info ) {
    // if request is '/product/1/abc/x'
    // $info is an array: ['1', 'abc', 'x']
});

Rota os retornos de chamada dos parâmetros

Os retornos de chamada dos parâmetros de rota podem ser usados ​​de várias maneiras diferentes:

eco:: route ( ' page/:title:strtoupper ' , ' PageController->view ' );

Ou defina retornos de chamada de parâmetro na matriz (o primeiro elemento da matriz deve ser o método de classe / chamável):

eco:: route ( ' page/:title ' , [ ' PageController->view ' , [ ' title ' => ' strtoupper ' ]]);

Além disso, os retornos de chamada dos parâmetros de rota globais podem ser definidos, por exemplo:

 // globally set route param callback
// now every ':id' param will use this callback
// global param callbacks are overwritten by local ones
eco:: param ( ' id ' , function ( $ id ) { return strtoupper ( $ id ); });
// or use multiple param names:
eco:: param ([ ' x ' , ' y ' , ' z ' ], function ( $ val ) { });

Os retornos de chamada de rota também podem ser usados ​​com retornos de chamada de parâmetro de rota:

eco:: route ( ' page/:title ' , [
  ' PageController->view ' ,
  ' route_callback ' ,
  function () { /* route callback */ },
  // route param callback
  [ ' title ' => ' strtoupper ' ]
]);

Route Parâmetro Expressões regulares

Os parâmetros de rota podem ser usados, se a correspondência falhar, a rota não será invocada:

eco:: route ( ' user/:id@[0-9]+ ' , ...);

Rota Parâmetro Sintaxe

A ordem da sintaxe é importante ao usar diferentes tipos de parâmetros e/ou combinar retornos de chamada e expressões regulares, aqui está a sintaxe correta:

 // when using callback with regular expression
// the callback must come first:
eco:: route ( ' user/:id:strtoupper@[0-9]+ ' , ...);

// use optional param and callback:
eco:: route ( ' user/:id/:name?:strtoupper ' , ...);

// use optional param and regular expression:
eco:: route ( ' user/:id/:name?@[a-z]+ ' , ...);

// use optional param, callback and regular expression:
eco:: route ( ' user/:id/:name?:strtoupper@[a-z]+ ' , ...);

// use wildcard param and callback:
eco:: route ( ' user/:params+:strtoupper ' , ...);

// use wildcard param and regular expression:
eco:: route ( ' user/:params+@[a-z]+ ' , ...);

// use wildcard param, callback and regular expression:
eco:: route ( ' user/:params+:strtoupper@[a-z]+ ' , ...);

Visualizações

O objeto de visualização pode ser usado em ações de uma rota:

 class PageController
{
    public function get ( $ id )
    {
        $ page = PageModel:: get ( $ id );

        // set view param
        eco:: view ()-> set ( ' title ' , $ page -> title );

        // or use view() helper function
        // view()->set('title', $page->title);

        // or like this:
        view ()-> author = $ page -> author ;

        // load template file 'page/view'
        // and can also set view param 'content'
        view ( ' page/view ' , [
            ' content ' => $ page -> content
        ]);
    }
}

Os parâmetros de rota também podem ser acessados ​​usando métodos de classe Router .

Visualizar modelo

O exemplo do arquivo app/tpl/page/view.tpl :

 <?php include PATH_TEMPLATE_GLOBAL . ' header.tpl ' ; ?>
<h1> <?= $ title ?> </h1>
<p>Author: <?= $ author ?> </p>
<?= $ content ?>
<?php include PATH_TEMPLATE_GLOBAL . ' footer.tpl ' ; ?> 

Log

Exemplo de mensagens de registro:

eco:: log ()-> error ( ' Bad error / fatal ' );
eco:: log ()-> warning ( ' Warning conditions ' );
eco:: log ()-> notice ( ' Notice message ' );
eco:: log ()-> debug ( ' File has loaded ' );

As categorias podem ser usadas ao registrar uma mensagem:

 // category 'payment'
eco:: log ()-> error ( ' Failed to access payment gateway ' , ' payment ' );

Informações de depuração também podem ser adicionadas:

eco:: log ()-> warning ( ' Request failed ' , /* category optional */ null ,
    [ ' request ' => ' x ' , ' client ' => ' y ' ]);

Obtenha log inteiro:

 $ log = eco:: log ()-> get ();

Configurar exemplo de manipulador de log personalizado:

eco:: log ()-> setHandler ( function ( $ message , $ level , $ category , $ info ){
	// if sending message to database
    // do no send if database connection error, example:
    // if(substr($message, 0, 17) == 'SQLSTATE[HY000] [')
    // {
    // 	return false;
    // }

    // handle custom logging
    return true ; // handled
});

Se o manipulador de log personalizado chamável não retornar true o madeireiro interno continuará normalmente

Manuseio de erros

Trigger Exemplos de erros:

eco:: error ( ' Error message ' );
// or use helper function
error ( ' Something bad ' );
// custom error code
error ( ' Page not found ' , 404 );
// add log category
error ( ' Failed to load user ' , null , ' account ' );
// by default the HTTP error response code is sent
// to not send HTTP code use:
error ( ' Page not found ' , 404 , ' category ' false );

A última mensagem de erro (e categoria de erro) enviada para a função eco::error() pode ser acessada usando:

 $ error_message = eco:: errorGetLast ();
$ error_category = eco:: errorGetLastCategory ();

Um retorno de chamada 404 pode ser usado para lidar com o 404 antes que um erro seja chamado

Ganchos

Ganchos podem ser usados ​​para carregar arquivos ou usar retornos de chamada durante a execução, exemplos:

 // called before routing starts
eco:: hook (eco:: HOOK_BEFORE , function () { /* do something */ });

// called before the route callable or class method is called
// include a file example:
eco:: hook (eco:: HOOK_MIDDLE , PATH_LIB . ' hook/middle.php ' );

// called after dispatching
eco:: hook (eco:: HOOK_AFTER , function () { /* do something */ });

Configuração

As configurações de aplicativo e configuração ecológica são tratadas separadamente.

Configuração ecológica

O arquivo de configuração ecológico está localizado em app/com/conf/eco.conf.php e contém todas as configurações da estrutura. Toda a documentação para configurações ecológicas pode ser encontrada no arquivo.

Configuração do aplicativo

As configurações de aplicativos podem ser armazenadas pelo Eco, exemplo:

 // load config file(s) using path
eco:: conf ( PATH_CONF . ' app.conf.php ' );
eco:: conf ( PATH_CONF . ' api.conf.php ' );

// or load config settings using array
eco:: conf ([ ' local ' => [ ' path ' => ' x ' , ' filename ' => ' y ' ]]);

// use config settings
$ app_username = eco:: conf ()-> app -> username ;
$ local_path = eco:: conf ()-> local -> path ;

Os arquivos de configuração devem retornar uma matriz, app.conf.php Exemplo:

 return [
    ' app ' => [
        ' username ' => ' x ' ,
        ' password ' => ' y '
    ],
    ' core ' => [ /* more */ ]
];

As definições de configuração não podem ser substituídas ao usar vários arquivos; portanto, as teclas de matriz primária devem ser únicas, mesmo em arquivos diferentes. Nunca use a chave de matriz primária _eco , usada pelo ECO para configurações de estrutura interna.

As configurações de configuração também podem ser usadas separadamente do ECO, por exemplo:

 // do not store internally
$ conf = eco:: conf ( PATH_CONF . ' app.conf.php ' , false );
// use config settings
$ app_username = $ conf -> app -> username ;

Métodos principais

O ECO oferece os seguintes métodos:

• eco::autoload($paths) - Classe Autoloader
• eco::breadcrumb() - Acesse a classe Breadcrumb (Função do ajudante breadcrumb() disponível)
• eco::clear($key) - Clear Global Variable
• eco::conf($file_path, $store) - Registrar / carregar o arquivo de configuração do aplicativo FILE ( conf() função auxiliar disponível)
• eco::db($connection_id) - Access Database Class (função auxiliar db() disponível)
• eco::error($message, $code, $category, $http_response_code) - Trigger um erro ( error() função auxiliar disponível)
• eco::filter() - Acesso a classe de filtro de dados ( filter() função auxiliar disponível)
• eco::flash() - Acesso aula de flash de sessão ( flash() Função auxiliar disponível)
• eco::format() - Acesse a classe Format Data ( format() função auxiliar disponível)
• eco::get($key) - Obtenha uma variável global
• eco::has($key) - Verifique se existe uma variável global
• eco::hook($name, $callback) - Adicione um gancho
• eco::log() - ACCESS LOG CLASS (Função logger() Disponível disponível)
• eco::model() - Modelo Classe Loader ( model() Helper Função disponível)
• eco::param($id, $callback) - Map Route Parâmetro de chamada ( param() função auxiliar disponível)
• eco::request() - Acesso aula de solicitação (Função do auxiliar request() disponível)
• eco::response() - Acesso aula de resposta ( response() função auxiliar disponível)
• eco::route($route, $action) - Rota do mapa
• eco::router() - Acesso Classe Core do Router
• eco::run() - Execute o aplicativo
• eco::service() - Classe de serviço Carregador (função auxiliar de service() disponível)
• eco::session() - Acesso aula de sessão (Função do ajudante session() disponível)
• eco::set($key, $value) - Defina uma variável global
• eco::stop() - Pare graciosamente o aplicativo ( stop() função auxiliar disponível)
• eco::validate() - Acesso a classe Validate ( validate() função auxiliar disponível)
• eco::view($template, $view_params) - Carregar arquivo de modelo e acessar a classe View ( view() Helper Função disponível)

Classes principais

As classes principais podem ser usadas para simplificar tarefas de aplicativos comuns:

• EcoCache - Classe Core Cache do lado do servidor
• EcoDatabase - Classe Core do Database
• EcoForm - HTML FORM CORE CLASS
• EcoHttp - http solicita a classe Core
• EcoModel - Modelo de banco de dados CLET CORE
• EcoTable - HTML TABLE CORE CLASS

Classes Helper

Essas aulas de auxiliar estão disponíveis:

• EcoBenchmark - Benchmarking Helper
• EcoSystemBreadcrumb - Acesso com eco::breadcrumb() ou Função do Helper breadcrumb()
• EcoSystemFilter - Acesso com eco::filter() ou filter() função auxiliar
• EcoSystemSessionFlash - Acesso com eco::flash() ou flash() função auxiliar
• EcoSystemFormat - Acesso com eco::format() ou format() função auxiliar
• EcoSystemRequest - Acesso com eco::request() ou request() função auxiliar
• EcoSystemRegistryService - Acesso com eco::service() ou service() função Helper
• EcoSystemSession - Acesso com eco::session() ou session() função auxiliar
• EcoSocketClient e EcoSocketServer - Criando ajudantes de soquetes
• EcoSystemValidate - Accesso com eco::validate() ou validate() função auxiliar

Funções auxiliares

As funções auxiliares podem ser usadas para acessar rapidamente os métodos principais do Eco ou outra funcionalidade útil. Encontre documentação de funções auxiliares aqui.

Estendendo -se Eco

O ECO pode ser estendido estendendo a classe EcoSystem . Inicialmente, isso é configurado no arquivo app/com/bootstrap.php :

 // set Eco access class
class eco extends  Eco System {}

A classe estendida pode ser usada para adicionar métodos ou substituir métodos de excesso EcoSystem .

^ De volta ao topo