Unduh gimli php - Unduh Kode Sumber gimli php

Gimliduck ⚔️?

Kerangka kerja PHP mikro yang dapat disesuaikan yang mencoba untuk menghindari jalan Anda.

Sangat banyak pekerjaan yang sedang berlangsung, gunakan dengan risiko Anda sendiri ...

Kepastian kematian. Peluang kecil untuk sukses. Apa yang kita tunggu?

Instalasi

composer require danc0/gimliduck-php

Buat Proyek Kerangka Dengan: composer create-project danc0/gimli-skeleton

Tambahkan devtools dengan composer require --dev danc0/gimliduck-devtools

Buat file .htaccess yang terlihat seperti ini untuk menunjukkan permintaan ke file index.php Anda

 RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [L]

Penggunaan

Membuat aplikasi Gimliduck sederhana:

 declare (strict_types= 1 );
require_once __DIR__ . ' /vendor/autoload.php ' ;

use Gimli  Application ;
use Gimli  Router  Route ;

Application:: create ( __DIR__ , $ _SERVER );

Route:: get ( ' / ' , function (){
	echo " Hello World " ;
});

Application:: start ();

Hanya itu yang Anda butuhkan untuk memulai. Anda dapat menambahkan lebih banyak seperti mesin templat, file konfigurasi, dll, tetapi Anda tidak perlu melakukannya.

Contoh yang lebih kompleks

 <?php
declare (strict_types= 1 );
require_once __DIR__ . ' /vendor/autoload.php ' ;

use Gimli  Application ;
use App  Core  Config ;
use App  Core  Cache ;

define ( ' APP_ROOT ' , __DIR__ );

$ App = Application:: create ( APP_ROOT , $ _SERVER );

// set up your config and add it to the Application
$ config_file = parse_ini_file ( APP_ROOT . ' /App/Core/config.ini ' , true );
$ App -> Config = $ App -> Injector -> resolveFresh (Config::class, [ ' config ' => $ config_file ]);

// Register a cache class with the Injector
$ App -> Injector -> register (Cache::class, Cache:: getCache ( $ App -> Config -> admin_cache ));

// Run Application
$ App -> run ();

Kelas Application juga mendaftarkan kelas pawang dan sesi dasar saat dibuat. Selain itu, jika konfigurasi Anda termasuk enable_latte , mesin template latte akan ditambahkan ke instance aplikasi menggunakan nilai konfigurasi untuk template_base_dir sebagai direktori template.

Mendeklarasikan rute

Secara default Gimli akan memerlukan file apa pun di direktori App/Routes . Anda dapat menonaktifkan ini dengan mengatur autoload_routes ke false di file konfigurasi Anda. Anda dapat mengubah direktori dengan mengatur nilai route_directory di file konfigurasi Anda. Anda juga dapat memuat file rute tambahan dengan metode berikut:

 // Load routes from a file(s)
$ App -> loadRouteFiles ([
	' App/routes/web.php ' ,
]);

Ada beberapa hal yang dapat Anda lakukan dengan callback rute Anda ... lewati string, dapat dipanggil, atau array.

Route::get( ' / ' , function (){
	echo " Hello World "
});

// Single action controller, must use __invoke method
Route:: get ( ' / ' , Home_Controller::class);
// cli routes are single action Job classes
Route:: cli ( ' build-cache ' , Cache_Job::class);

Route:: get ( ' / ' , Home_Controller::class . ' @homePage ' );

Route:: get ( ' / ' , [Home_Controller::class, ' homePage ' ]);

Salah satu dari itu, terserah Anda bagaimana Anda melakukannya.

Anda dapat menambahkan middleware jika Anda membutuhkan pertahanan tambahan

Route:: get ( ' / ' , [Home_Controller::class, ' homePage ' ])-> addMiddleware (Logged_In_Middleware::class);

Itu harus menjadi kelas yang mengimplementasikan GimliMiddlewareMiddleware_Interface yang membutuhkan metode process yang mengembalikan GimliMiddlewareMiddleware_Response . Middleware memang memiliki akses ke instance aplikasi termasuk injektor dan apa pun yang Anda putuskan untuk mengaturnya.

Anda juga dapat menambahkan grup, menentukan file rute default yang harus dimuat, dan memuat file rute tambahan untuk membantu mengatur rute Anda.

Rute Anda juga dapat berisi argumen variabel yang memenuhi pola berikut:

 protected array $ patterns = [
	' :all ' => " ([^/]+) " ,
	' :alpha ' => " ([A-Za-z_-]+) " ,
	' :alphanumeric ' => " ([w-]+) " ,
	' :integer ' => " ([0-9_-]+) " ,
	' :numeric ' => " ([0-9_-.]+) " ,
	' :id ' => " ([0-9_-]+) " ,
	' :slug ' => " ([A-Za-z0-9_-]+) " ,
];

Anda perlu menambahkan nama variabel mereka menggunakan simbol # dalam definisi rute.

Route:: get ( ' /user/:integer#id ' , [User_Controller::class, ' getUser ' ]);

Nama variabel ini diteruskan ke router dan ditetapkan sebagai ketergantungan untuk metode pengontrol Anda. Anda harus menggunakan nama variabel yang ditentukan sebagai argumen dalam metode pengontrol Anda. Nilai akan menjadi tipeCast berdasarkan jenis yang tersedia untuk settype , jenis yang mungkin:

 integer or int
float or double
string
array
object
boolean or bool

Contoh metode pengontrol:

 public function getUser ( Response $ Response , int $ id ): Response {
	// do something with $id
}

Pengontrol harus mengembalikan objek GimliHttpResponse . Ada metode pembantu yang mengembalikan objek Response yang diformat untuk membantu membatasi beberapa logika bersyarat:

response respons dasar
redirect Redirect Response
redirect_on_success redirect jika responsnya berhasil
redirect_on_failure redirect jika responsnya tidak berhasil
json_response JSON Respons

File kerja juga diberikan argumen berikut subcommand , options , dan flags . Argumen options adalah array array yang berisi nama dan nilai. Argumen flags adalah array dengan bendera yang diberikan. Argumen subcommand hanyalah sebuah string jika sub -perintah diberikan.

Injeksi ketergantungan

Anda dapat menggunakan injektor bawaan untuk mengikat atau mendaftarkan dependensi. Anda juga dapat menyelesaikan dependensi dari injektor. Anda dapat menambahkan apa pun yang Anda butuhkan ke injektor dan mengaksesnya di seluruh aplikasi Anda melalui instance Application .

Kelas injektor yang dibangun akan autowire dan menyelesaikan ketergantungan sesuai kebutuhan. Anda juga dapat mengikat kelas ke penutupan jika Anda perlu melakukan beberapa pengaturan sebelum mengembalikan kelas atau mendaftarkan objek yang sudah dibuat. Contoh di bawah ini menunjukkan pengontrol aksi tunggal yang akan diselesaikan dari kelas router. Parameter metode __construct diselesaikan dari injektor.

 <?php
declare (strict_types= 1 );
namespace App  Controllers ;

use App  Logic  Dashboard_Logic ;
use Gimli  Http  Response ;
use Gimli  Application ;
use Gimli  View  Latte_Engine ;

class Dashboard_Landing_Controller {

	/**
	 * Constructor
	 *
	 * @param Application $Application
	 */
	public function __construct (
		public Application $ Application ,
		protected Dashboard_Logic $ Dashboard_Logic ,
		protected Latte_Engine $ View
	){
		//
	}

	/**
	 * Single action controller call
	 *
	 * @return Response
	 */
	public function __invoke ( Response $ Response ): Response {		
		$ template_data = $ this -> Dashboard_Logic -> getTemplateData ();
		return $ Response -> setResponse ( $ this -> View -> render ( ' dashboard/dashboard.latte ' , $ template_data ));
	}
}

Parameter metode juga diselesaikan oleh injektor ketika rute mengirimkan metode.

Ada juga metode pembantu injektor yang mengurangi kode inline. Biasanya jika Anda ingin menyuntikkan kelas sebaris, Anda dapat melakukannya dengan $this->Application->Injector->resolve(Some_Class::class) atau Application::get()->Injector->resolve(Some_Class::class) . Metode resolve dan resolve_fresh tersedia untuk dipotong pada kode inline itu.

Database

Ada Database pembungkus PDO dasar serta kelas Pdo_Manager yang dapat Anda gunakan untuk mengelola kueri basis data. Kelas Pdo_Manager kembali dan contoh PDO dan dapat digunakan untuk menjalankan kueri secara langsung. Kelas Database adalah pembungkus di sekitar kelas Pdo_Manager dan menyediakan beberapa metode kueri dasar. Ada juga kelas dasar Model yang sangat mendasar dan metode penolong tambahan untuk Database , seperti di tempat lain metode ini menangani injeksi ketergantungan dan memanggil metode pada kelas Database yang disuntikkan. Pembantu adalah:

fetch_column
fetch_row
fetch_all
row_exists

Model seeders

Ada kelas seeder dasar yang dapat digunakan untuk menyemai basis data Anda. Ini bergantung pada atribut yang ditempatkan di kelas model untuk menginstruksikan Seeder cara membuat data.

 <?php
declare (strict_types= 1 );

namespace Gimli  Database ;

use Gimli  Database  Model ;
use Gimli  Database  Seed ;


class User_Model extends Model {
	
	/**
	 * @var string $table_name
	 */
	protected string $ table_name = ' users ' ;

	
	/**
	 * ID
	 * 
	 * @var int $id 
	 */
	public $ id ;

	/**
	 * Unique_Id
	 * 
	 * @var string $unique_id 
	 */
	#[Seed(type: ' unique_id ' , args: [ ' length ' => 12 ])]
	public $ unique_id ;

	/**
	 * Username
	 * 
	 * @var string $username 
	 */
	#[Seed(type: ' username ' )]
	public $ username ;

	/**
	 * Email
	 * 
	 * @var string $email 
	 */
	#[Seed(type: ' email ' )]
	public $ email ;

	/**
	 * Password
	 * 
	 * @var string $password 
	 */
	#[Seed(type: ' password ' )]
	public $ password ;

	/**
	 * Is_Active
	 * 
	 * @var int $is_active 
	 */
	#[Seed(type: ' tiny_int ' )]
	public $ is_active ;

	/**
	 * First Name
	 * 
	 * @var string $first_name 
	 */
	#[Seed(type: ' first_name ' )]
	public $ first_name ;

	/**
	 * Last Name
	 * 
	 * @var string $last_name 
	 */
	#[Seed(type: ' last_name ' )]
	public $ last_name ;

	/**
	 * Status
	 * 
	 * @var int $status 
	 */
	#[Seed(type: ' one_of ' , args: [ 0 , 1 ])]
	public $ status ;

	/**
	 * Created_At
	 * 
	 * @var string $created_at 
	 */
	#[Seed(type: ' date ' , args: [ ' format ' => ' Y-m-d H:i:s ' , ' min ' => ' 2021-01-01 ' , ' max ' => ' 2021-04-01 00:00:00 ' ])]
	public $ created_at ;

	/**
	 * Updated_At
	 * 
	 * @var string $updated_at 
	 */
	#[Seed(type: ' date ' , args: [ ' format ' => ' Y-m-d H:i:s ' , ' min ' => ' 2021-04-01 00:02:00 ' ])]
	public $ updated_at ;

	/**
	 * bio
	 * 
	 * @var string $about 
	 */
	#[Seed(type: ' paragraph ' , args: [ ' count ' => 1 ])]
	public $ about ;
}

Anda kemudian dapat menyemai database dengan kode berikut:

Seeder:: make (User_Model::class)
	-> seed ( 123 )
	-> count ( 1 )
	-> create ();

Alih -alih membuat, Anda dapat memanggil getSeededData untuk mendapatkan data yang akan dimasukkan ke dalam database. Ini berguna untuk menguji atau memuat model secara manual tanpa menyimpannya. Anda juga dapat melewati metode panggilan balik yang akan diberikan data model awal. Ini membantu untuk menyemai data terkait. Callback harus mengembalikan serangkaian instance Seeder .

Seeder:: make (User_Model::class)
	-> seed ( 123 )
	-> count ( 1 )
	-> callback ( function ( $ data ) {
		return [
			Seeder:: make (User_Hobby_Model::class)-> with ([ ' user_id ' => $ data [ ' id ' ]]),
			Seeder:: make (User_Group_Model::class)-> with ([ ' user_id ' => $ data [ ' id ' ]]),
		]
	})
	-> create ();

Benih yang diteruskan memastikan data tetap sama setiap kali seeder dijalankan, menghasilkan kumpulan data yang dapat direproduksi. Kelas Seeder memiliki metode getRandomSeed yang akan mengembalikan nilai benih acak. Ini berguna untuk membuat data acak yang tidak perlu Anda dapat direproduksi, atau untuk menghasilkan benih acak yang dapat Anda salin dan gunakan.