Download velox - Download de código fonte velox

Velox

A maneira mais rápida de criar sites simples usando PHP!

Índice

Instalação
SOBRE VELOX
Arquitetura
Config
Classes
Funções
Comandos
Temas
Estendendo a velox
MVC
Modelagem
Autenticação
Changelog
Documentação

^{Se você gosta deste projeto e gostaria de apoiar seu desenvolvimento, dando -o seria apreciado!}

Confira a demonstração ou brinque com o REPL .

Você sente vontade de ler? Confira a API completa no site de documentação em marwanalsoltany.github.io/velox .

Principais recursos

Zero dependências
Mínimo, intuitivo e fácil de se dar bem
Flexibilidade ilimitada quando se trata de personalizá -la para suas necessidades exatas

Instalação

Usando compositor:

composer create-project marwanalsoltany/velox my-velox-app

NOTA: Pode ser necessário adicionar o --stability=dev dependendo da versão/ramificação. Você também pode querer adicionar --no-dev sinalizador para não instalar dependências de desenvolvimento.

Usando o git:

git clone https://github.com/MarwanAlsoltany/velox.git my-velox-app

Fato: se você não quiser usar outros pacotes de terceiros. A instalação do Velox usando Git é suficiente.

Usando fonte:

Faça o download do Velox como um .zip ou .tar.gz e extrai -o no diretório raiz da web do servidor.

Conselho: Se você deseja testar o Velox rapidamente e não tiver nenhum servidor da Web disponível, use qualquer método de instalação e execute php bin/app-serve a partir do diretório Inside Velox. Este comando aumentará um servidor da Web de desenvolvimento no localhost:8000 (observe que você precisa ter pelo menos o PHP instalado no seu sistema).

SOBRE VELOX

O Velox é um micro-quadro leve que torna a criação de um site simples usando o PHP alegre. Ajuda a criar sites à prova de futuros mais rápidos e eficientemente. Ele fornece componentes que facilitam o processo de criação de um site usando o PHP. O Velox não possui nenhuma dependência, o pacote Velox e tudo o que ele precisa estão incluídos no próprio projeto. Tudo o que o Velox fornece é uma maneira de trabalhar com a configuração , passar dados , registrar rotas , interagir com o banco de dados , renderizar visualizações , manipular exceções , código automático e resolver ativos. Ele fornece a visualização e as partes do controlador de um padrão de design MVC . Olhando da v1.3.0 , o Velox também fornece a parte do modelo , tornando -a uma estrutura MVC totalmente em destaque e a partir da v1.4.0 , ele também é enviado com um sistema de autenticação simples. O Velox também pode ser usado como um gerador de sites estáticos se tudo o que você precisa são arquivos HTML no final.

Por que o Velox existe?

O Velox foi criado para resolver um problema específico, é uma maneira de criar um site entre dinâmico e estático, uma maneira de criar um site simples com poucas páginas sem ser forçado a usar uma estrutura ou um CMS que vem com uma tonelada de coisas que nunca serão usadas, é leve, mínimo e reto ao ponto.

Não é recomendável usar o Velox se você tiver um projeto intermediário, seria melhor usar uma estrutura bem estabelecida. O Velox não é uma iniciativa de reinventar a roda, você pode considerar o Velox como um kit de partida para pequenos projetos.

O Velox possui um site de uso muito especial, sites simples, e aqui se entende sites realmente simples. A vantagem é que você não tem coisas que não precisa. Comparando o Velox a Laravel ou Symfony é irrelevante, pois essas estruturas jogam em uma área totalmente diferente, também vale a pena mencionar que o Velox é muito mais simples que o lúmen ou o esbelto.

Arquitetura

Estrutura de diretório

Diretório	Descrição
`bootstrap`	É aqui que o Velox inicializa o aplicativo. Você normalmente não precisa mudar nada neste diretório, a menos que deseje estender a funcionalidade do Velox além das coisas básicas.
`bin`	É aqui que os executáveis do PHP são colocados. Você pode adicionar livremente o seu ou excluir o diretório inteiro.
`app`	É aqui que sua própria lógica de back -end será colocada. Você estará trabalhando principalmente aqui para a parte de back -end do seu aplicativo.
`classes`	É aqui que vivem os arquivos de origem do VeLox. Você não deveria estar tocando em nada aqui, a menos que queira fazer sua própria versão do Velox.
`functions`	É aqui que todas as funções carregadas no aplicativo ao vivo. Você pode adicionar livremente o seu ou excluir o diretório inteiro.
`includes`	É aqui que todos os arquivos que devem ser pré -carregados serão colocados. Você pode adicionar livremente o seu ou excluir o diretório inteiro.
`themes`	É aqui que todos os seus temas de front -end serão colocados. Você estará trabalhando principalmente aqui para a parte front -end do seu aplicativo.
`config`	É aqui que todos os arquivos de configuração vão viver. Todos os arquivos aqui estarão acessíveis usando a classe `Config` no tempo de execução.
`storage`	É aqui que o Velox escreverá caches e logs. Você também pode usar este diretório para armazenar ativos em toda a instalação.
`public`	É aqui que você deve colocar seu `index.php` com um link simbólico para ativos estáticos ( `assets/` diretórios de temas ativos, por exemplo) para obter a máxima segurança. Você pode excluir livremente este diretório, se quiser.
`vendor`	É aqui que as dependências do compositor serão colocadas. Você pode excluir livremente este diretório se não quiser usar o Composer.

Conselhos: A maioria dos arquivos listados nesses diretórios está documentada. Dê uma olhada neles para aprender mais sobre o Velox.

Entrada de aplicativo

O ponto de entrada para um aplicativo Velox é o index.php , aqui você precisa exigir o bootstrap/autoload.php , registrar algumas rotas com seus manipuladores usando a Router::class e inicie o roteador. Isso é tudo o que você precisa para ter um aplicativo Velox em funcionamento.

 <?php

require ' bootstrap/autoload.php ' ;


Router:: handle ( ' / ' , function () {
    return View:: render ( ' home ' , [ ' title ' => ' Home ' ]);
});

Router:: start ();

Além disso, você pode adicionar os Middlewares usando Router::middleware() e/ou configurar manipuladores para respostas 404 e 405 usando {global.errorPages.CODE} Valor de configuração.

Como alternativa, você pode extrair a "parte de registro de rotas" em seu próprio arquivo e informar o Velox sobre ele usando bootstrap/additional.php . A partir da v1.2.0 Velox, por padrão, o arquivo includes/routes/web.php é onde você deve registrar suas rotas. O roteador também começará automaticamente se não for iniciado explicitamente.

NOTA: Para que o Velox funcione de maneira correta e segura, você precisa redirecionar todas as solicitações para o ponto de entrada do aplicativo ( index.php ) e bloquear todas as solicitações para outros arquivos PHP no servidor (dê uma olhada no .htaccess.dist para começar com o Apache).

Config

A tabela a seguir lista todos os arquivos de configuração que são enviados com Velox.

Arquivo de configuração	Descrição
`global.php`	Este arquivo de configuração contém algumas variáveis globais usadas por quase todas as classes (configuração em todo o aplicativo).
`router.php`	Este arquivo de configuração pode ser usado para substituir os parâmetros padrão `Router::class` .
`session.php`	Este arquivo de configuração contém configuração de sessão, é usado pela `Session::class` .
`database.php`	Este arquivo de configuração contém credenciais de banco de dados, é usado pela `Database::class` .
`auth.php`	Este arquivo de configuração contém configuração de autenticação, é usado pela `Auth::class` .
`theme.php`	Este arquivo de configuração pode ser usado para editar/estender a configuração do tema.
`view.php`	Este arquivo de configuração pode ser usado para personalizar tudo sobre as visualizações. É usado pela `View::class` .
`data.php`	Este arquivo de configuração pode ser usado para fornecer dados arbitrários, que serão injetados na `Data::class` .
`cli.php`	Este arquivo de configuração pode ser usado para ativar/desativar os comandos ou alterar seus argumentos.

Fato: você também pode adicionar livremente seus próprios arquivos de configuração, tudo o que você precisa fazer é criar um novo arquivo em /config e adicionar sua configuração a ele. O Velox saberá sobre este arquivo e o carregará no aplicativo. Você pode acessar sua configuração via Config::get('filename.whateverKeyYouWrote') .

Classes

As classes Velox são divididas em quatro espaços para nome:

MAKSVelox
MAKSVeloxBackend
MAKSVeloxFrontend
MAKSVeloxHelper

A tabela a seguir lista todas as classes disponíveis com sua descrição:

Aula	Descrição
`VeloxApp`	Uma classe que serve como um contador de serviço básico para o Velox.

`BackendEvent`	Uma classe que oferece funcionalidade simples de manuseio de eventos (despacho e escuta).
`BackendConfig`	Uma classe que carrega tudo do diretório `/config` e o torna como uma matriz acessível via notação de pontos.
`BackendRouter`	Uma classe que serve como roteador e ponto de entrada para o aplicativo.
`BackendGlobals`	Uma classe que serve como abstração/invólucro para trabalhar com superglobais.
`BackendSession`	Uma classe que oferece uma interface simples para trabalhar com sessões.
`BackendController`	Uma classe abstrata que serve como um controlador base que pode ser estendido para fazer manipuladores para o roteador.
`BackendDatabase`	Uma classe que representa o banco de dados e lida com operações de banco de dados.
`BackendModel`	Uma classe abstrata que serve como um modelo básico que pode ser estendido para criar modelos personalizados.
`BackendAuth`	Uma classe que serve como um sistema de autenticação para os usuários.

`FrontendData`	Uma aula que serve como uma bolsa de dados abstratada/loja acessível via notação de pontos.
`FrontendView`	Uma classe que renderiza arquivos (layouts, páginas e parciais) com a capacidade de incluir arquivos adicionais, dividir o conteúdo da página em seções e vistas renderizadas em cache.
`FrontendHTML`	Uma classe que serve como uma interface fluente para escrever HTML no PHP. Também ajuda na criação de elementos HTML em tempo real.
`FrontendPath`	Uma classe que serve como resolvedor de caminho para diferentes caminhos/URLs do aplicativo.

`HelperDumper`	Uma classe que despeja variáveis e exceção em uma boa formatação.
`HelperMisc`	Uma classe que serve como titular para várias funções de utilidade diversas.

Nota: tudo isso é o que o pacote Velox fornece pronta para uso.

Fato: o App , Event , Config , Router , Globals , Session , Database , Auth , Data , View , HTML , classes Path são alias no espaço de nome da raiz para facilidade de uso.

Funções

As funções Velox são divididas nesses arquivos:

helpers.php : É aqui que o auxiliar funciona para as classes Velox, são funções principalmente que retornam uma instância de classe ou alias algum método nela.
html.php : É aqui que o HTML Helper Functions vive, essas não são nada além de aliases para as funções PHP mais usadas com HTML.

A tabela a seguir lista todas as funções disponíveis e a qual classe/grupo eles pertencem:

Classe/grupo	Função (s)
`App::class`	`app()` , `abort()` , `terminate()`
`Event::class`	`event()`
`Config::class`	`config()`
`Router::class`	`router()` , `handle()` , `redirect()` , `forward()`
`Database::class`	`database()`
`Globals::class`	`globals()`
`Session::class`	`session()` , `flash()` , `csrf()`
`Auth::class`	`auth()`
`View::class`	`view()` , `render()` , `render_layout()` , `render_page()` , `render_partial()` , `section_push()` , `section_reset()` , `section_start()` , `section_end()` , `section_yield()` , `include_file()`
`Data::class`	`data()` , `data_has()` , `data_get()` , `data_set()`
`HTML::class`	`html()`
`Path::class`	`path()` , `app_path_current()` , `app_url_current()` , `app_path()` , `app_url()` , `theme_path()` , `theme_url()` , `assets_path()` , `assets_url()`
`Dumper::class`	`dd()` , `dump()` , `dump_exception()`
HTML HELHEDERS	`he()` , `hd()` , `hse()` , `hsd()` , `st()` , `nb()`

Fato: você também pode adicionar livremente suas próprias funções, tudo o que você precisa fazer é criar um novo arquivo em /functions e adicionar suas funções a ele. O Velox saberá sobre este arquivo e o carregará no aplicativo.

Comandos

O Velox vem com alguns comandos úteis que você pode usar para realizar algumas tarefas repetitivas. Você pode executar esses comandos usando o php bin/{command-name} .

A tabela a seguir lista todos os comandos disponíveis com sua descrição.

Comando	Descrição
`app-serve`	Este comando inicia um servidor de desenvolvimento.
`app-mirror`	Este comando reflete o aplicativo no diretório `/public` .
`config-cache`	Este comando armazena em cache a configuração atual.
`config-dump`	Este comando despeja a configuração atual com o destaque da sintaxe.
`cache-clear`	Este comando limpa os caches.

Você pode personalizar esses comandos usando o arquivo config/cli.php . Aqui você pode habilitá -los/desativá -los ou fornecer argumentos diferentes para eles.

Se você deseja tornar todos esses comandos acessíveis através de uma única interface. Confira minha outra mistura de pacote, o que fará isso por você e ainda mais.

Temas

O Velox é construído em torno da idéia de temas , um tema é dividido em quatro diretórios:

O assets/ diretório é onde todos os seus ativos estáticos associados a este tema serão colocados.
Os layouts/ diretório é onde você define seus layouts. Um layout na terminologia do Velox é o enquadramento externo de uma página da web.
As pages/ diretório é onde você coloca o conteúdo específico para cada página, a página será envolvida com algum layout de sua escolha e finalmente será renderizada. Uma página em Terminologia Velox é o conteúdo real de uma página da web.
O partials/ diretório é onde você coloca todas as suas peças reutilizáveis do tema, que serão usadas em seus layouts, páginas ou outros parciais. Um bom exemplo para parciais pode ser: componentes , inclui e elementos de conteúdo .

Você pode personalizar o comportamento dos temas usando o arquivo config/theme.php . Aqui você pode definir o tema ativo com a chave active . Os temas podem herdar um do outro, definindo os pais com a tecla parent . Você também pode alterar a estrutura do diretório de temas se desejar usar a tecla paths . Outras configurações (armazenamento em cache, por exemplo) que valem a pena dar uma olhada na qual têm a ver com temas podem ser encontrados no arquivo config/view.php .

Conselho: Você pode dar uma olhada no tema velox fornecido para ver como todas as coisas funcionam juntas na prática.

Exemplos:

Layout: themes/velox/layouts/main.phtml
Página: themes/velox/pages/home.phtml
Parcial: themes/velox/partials/text-image.phtml

Estendendo a velox

Para adicionar suas próprias classes, use o app/ diretório, é aqui que você deve colocar sua própria lógica de negócios. Observe que você deve seguir o PSR-4 para que o Velox carregue suas classes. Consulte app/Controller/DefaultController.php , para obter uma ideia.

Aqui está uma lista de alguns arquivos importantes que você deve considerar ao trabalhar com Velox:

Arquivos de pré -carregamento/diretórios autoload/additional.php .
Fornecendo dados adicionais config/data.php .
O registro de rotas da Web includes/routes/web.php (a partir da v1.2.0 ).
Os manipuladores de eventos de registro includes/events/system.php (a partir da v1.2.0 ).

MVC

Criando um modelo:

 <?php

namespace App  Model ;

use MAKS  Velox  Backend  Model ;

class Person extends Model
{
    protected static ? string $ table = ' persons ' ;
    protected static ? array $ columns = [ ' id ' , ' first_name ' , ' last_name ' , ' age ' , ...];
    protected static ? string $ primaryKey = ' id ' ;

    public static function schema (): string
    {
        // return SQL to create the table
    }
}

Trabalhando com o modelo:

 <?php

use App  Model  Person ;

// creating/manipulating models
$ person = new Person (); // set attributes later via setters or public assignment.
$ person = new Person([ ' first_name ' => $ value , . . . ]); // set attributes in constructor
$ person -> get ( ' first_name ' ); // get an attribute
$ person -> set ( ' last_name ' , $ value ); // set an attribute
$ person -> getFirstName (); // case will be changed to 'snake_case' automatically.
$ person -> setLastName ( $ value ); // case will be changed to 'snake_case' automatically.
$ person -> firstName ; // case will be changed to 'snake_case' automatically.
$ person -> lastName = $ value ; // case will be changed to 'snake_case' automatically.
$ attributes = $ person -> getAttributes (); // returns all attributes.
$ person -> save (); // persists the model in the database.
$ person -> update ([ ' first_name ' => $ value ]); // updates the model and save changes in the database.
$ person -> delete (); // deletes the model from the database.
Person:: create ( $ attributes ); // creates a new model instance, call save() on the instance to save it in the database.
Person:: destroy ( $ id ); // destroys a model and deletes it from the database.

// fetching models
$ count   = Person:: count (); // returns the number of models in the database.
$ person  = Person:: first ();
$ person  = Person:: last ();
$ person  = Person:: one ([ ' first_name ' => ' John ' ]);
$ persons = Person:: all ([ ' last_name ' => ' Doe ' ], $ order , $ offset , $ limit );
$ person  = Person:: find ( $ id ); // $id is the primary key of the model.
$ persons = Person::find( ' first_name ' , ' John ' , ' last_name ' , ' Doe ' . . .); // or
$ persons = Person:: find ([ ' first_name ' => ' John ' , ' last_name ' => ' Doe ' ]);
$ persons = Person:: findByFirstName ( ' John ' ); // fetches using an attribute, case will be changed to 'snake_case' automatically.
$ persons = Person:: where ( ' first_name ' , ' = ' , $ value ); // fetches using a where clause condition.
$ persons = Person:: where ( ' last_name ' , ' LIKE ' , ' %Doe ' , [[ ' AND ' , ' age ' , ' > ' , 27 ], ...], ' age DESC ' , $ limit , $ offset );
$ persons = Person:: fetch ( ' SELECT * FROM @table WHERE `first_name` = ? ' , [ $ value ]); // fetch using raw SQL query.

Usando o modelo no controlador:

 <?php

namespace App  Controller ;

use MAKS  Velox  Backend  Controller ;
use App  Model  Person ;

class PersonsController extends Controller
{
    public function indexAction ()
    {
        $ persons = Person:: all ();

        return $ this -> view -> render ( ' persons/index ' , [
            ' title ' => ' Persons ' ,
            ' persons ' => $ persons
        ]);
    }

    // other CRUD actions ...

    /**
     * Persons search action.
     *
     * @route("/persons/search", {GET})
     */
    public function searchAction ()
    {
        // ...
    }

    /**
     * Persons middleware.
     *
     * @route("/persons/*", {GET, POST})
     */
    public function personsMiddleware ()
    {
        // ...
    }
}

Fato: as operações do CRUD (a saber: index , create , store , show , edit , update , destroy ) são registradas e configuradas por padrão. Para registrar suas próprias rotas automaticamente, use o @route("<path>", {<http-verb>, ...}) anotação. Consulte Controller::registerRoutes() docblock para saber mais.

Fato: Para disponibilizar o modelo como propriedade do controlador ( $this->model ), use Controller::associateModel() . Consulte Controller::associateModel() docblock para saber mais.

Conselho: Se no modo de produção, como um atalho, lançar uma exceção com um valor de configuração de correspondência de código {global.errorPages.CODE} renderizará a página de erro correspondente. Por exemplo, ao lançar new Exception('Not found', 404) forma o controlador, a página de erro 404 configurada será renderizada e será passada a mensagem de exceção. Se a página não estiver configurada, a página de erro 500 será renderizada como fallback.

O Velox não tem nenhuma maneira de validar dados. Confira meu outro pacote Mighty, o que fará isso por você e ainda mais.

Usando o modelo em uma visualização:

{# theme/pages/persons/index.phtml #}

{! @extends 'theme/pages/persons/base' !}

{! @block content !}
    {! @super !}

    < h1 > {{ $title } } </ h1 >

    {! @if ( isset ( $persons ) && count ( $persons ) ) !}
        < ul >
            {! @foreach ( $persons as $person ) !}
                < li > {{ $person -> firsName } } {{ $person -> lastName } } </ li >
            {! @endforeach !}
        </ ul >
    {! @endif !}
{! @endblock !}

Conselho: Confira o modelo Person e o PersonsController para ver um exemplo realista.

Modelagem

O Velox vem com seu próprio motor de modelos. Este motor de modelos é muito intuitivo e fácil de se conviver, se você tiver experiência com qualquer outro motor de modelos, aprender que seria uma questão de minutos. Observe que o uso deste mecanismo de modelos é opcional. Você pode simplesmente usar o PHP bruto em seus pontos de vista.

A tabela a seguir lista todas as tags disponíveis e o que elas fazem:

Marcação	Descrição
`{! @extends 'path/to/template' !}`	Estender um modelo, os blocos deste modelo serão herdados.
`{! @include 'path/to/file' !}`	Inclua um arquivo, isso será renderizado antes da inclusão (não é possível acessar variáveis de contexto).
`{! @embed 'path/to/file' !}`	Incorporar um arquivo, isso será incluído como está (pode acessar variáveis de contexto).
`{! @block name !}` `{! @endblock !}`	Crie um bloco para envolver algum código.
`{! @super !}`	Use -o dentro de um bloco em um modelo estendido para herdar o conteúdo do bloco pai.
`{! @block(name) !}`	Imprima um bloco. Precisa ser chamado pelo menos uma vez para renderizar um bloco.
`{! @foreach ($vars as $var) !}` `{! @endforeach !}`	Estruturas de controle (loops, se declarações, ...). Todas as estruturas de controle de PHP estão disponíveis ( `if` , `else` , `elseif` , `while` , `do` , `for` , `foreach` , `continue` , `switch` , `break` , `return` , `require` , `include` ) com a mesma sintaxe, mas simplesmente prefixado com um símbolo `@` se uma estrutura de controle for a primeira palavra na tag.
`{! $var = '' !}`	Atribuições variáveis. O conteúdo pode ser uma variável ou qualquer expressão válida de PHP.
`{{ $var }}`	Imprima uma variável. O conteúdo pode ser uma variável ou qualquer expressão de PHP que possa ser lançada em uma string.
`{{{ $var }}}`	Imprima uma variável sem escapar. O conteúdo pode ser uma variável ou qualquer expressão de PHP que possa ser lançada em uma string.
`{# This is a comment #}`	Comente algo. Este será um comentário PHP (não estará disponível no HTML final).

Conselho: Dê uma olhada nas visões de persons do PersonsController no tema Velox para um exemplo realista.

Autenticação

A partir da v1.4.0 o Velox vem enviado com um sistema de autenticação incorporado simples. Este sistema é muito simples e fácil de usar.

 <?php

use MAKS  Velox  Backend  Auth ;

// instantiate the Auth class
$ auth = new Auth (); // or Auth::instance();

// register a new user
$ status = $ auth -> register ( ' username ' , ' password ' );

// unregister a user
$ status = $ auth -> unregister ( ' username ' );

// log in a user
$ status = $ auth -> login ( ' username ' , ' password ' );

// log out a user
$ auth -> logout ();

// authenticate a user model
Auth:: authenticate ( $ user );

// check if there is a logged in user
$ status = Auth:: check ();

// retrieve the current authenticated user
$ user = Auth:: user ();

// add HTTP basic auth
Auth:: basic ([ ' username ' => ' password ' ]);

Conselho: Confira o UsersController para ver um exemplo realista.

Licença

Expandir