gimli php

Gimliduck ⚔️?

Ein anpassungsfähiges Micro -PHP -Framework, das versucht, sich nicht in den Weg zu halten.

Sehr viel in Arbeit, nutzen Sie Ihr eigenes Risiko ...

Gewissheit des Todes. Kleine Erfolgschance. Worauf warten wir noch?

Installation

composer require danc0/gimliduck-php

Erstellen Sie ein Skelettprojekt mit: composer create-project danc0/gimli-skeleton

Fügen Sie die Devtools mit composer require --dev danc0/gimliduck-devtools

Erstellen Sie eine .htaccess -Datei, die so etwas aussieht, um Anforderungen auf Ihre index.php -Datei zu verweisen

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

Verwendung

Das Erstellen einer Gimliduck -Anwendung ist einfach:

 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 ();

Das ist wirklich alles, was Sie brauchen, um loszulegen. Sie können mehr wie eine Template -Engine, eine Konfigurationsdatei usw. hinzufügen, müssen aber nicht.

Ein komplexeres Beispiel

 <?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 ();

Die Application registriert auch den grundlegenden Ereignishandler und die Sitzungsklasse, wenn sie erstellt wird. Wenn Ihre Konfiguration außerdem enable_latte enthält, wird die Latte -Vorlagen -Engine der Anwendungsinstanz mit dem Konfigurationswert für template_base_dir als Vorlageverzeichnis hinzugefügt.

Routen deklarieren

Standardmäßig benötigt GIMLI alle Dateien im App/Routes -Verzeichnis. Sie können dies deaktivieren, indem Sie autoload_routes in Ihrer Konfigurationsdatei auf false einstellen. Sie können das Verzeichnis ändern, indem Sie den Wert von route_directory in Ihrer Konfigurationsdatei einstellen. Sie können auch zusätzliche Routendateien mit der folgenden Methode laden:

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

Es gibt ein paar Dinge, die Sie mit Ihren Route zurückrufen können ... eine Zeichenfolge, einen Callable oder ein Array übergeben.

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 ' ]);

Jede dieser Arbeiten, es liegt an Ihnen, wie Sie es machen.

Sie können Middleware hinzufügen, wenn Sie eine zusätzliche Verteidigung benötigen

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

Dies sollte eine Klasse sein, die GimliMiddlewareMiddleware_Interface implementiert, die eine process erfordert, die GimliMiddlewareMiddleware_Response zurückgibt. Middleware hat Zugriff auf die Anwendungsinstanz, einschließlich des Injektors und alles, was Sie sich sonst noch dafür entscheiden.

Sie können auch Gruppen hinzufügen, eine Standard -Routendatei definieren, die geladen werden sollte, und zusätzliche Routendateien laden, um Ihre Routen zu organisieren.

Ihre Routen können auch variable Argumente enthalten, die die folgenden Muster entsprechen:

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

Sie müssen ihren Variablennamen mit dem Symbol # in der Routendefinition hinzufügen.

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

Dieser variable Name wird an den Router übergeben und als Abhängigkeit für Ihre Controller -Methode festgelegt. Sie sollten den definierten Variablennamen als Argument in Ihrer Controller -Methode verwenden. Der Wert wird typecast basierend auf den verfügbaren Typen zu settype , möglichen Typen:

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

Beispiel Controller -Methode:

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

Controller sollten ein GimliHttpResponse Antwortobjekt zurückgeben. Es gibt Helfermethoden, die formatierte Response zurückgeben, um eine bedingte Logik einzuschränken:

• response Eine grundlegende Antwort
• redirect umleiten
• redirect_on_success leiten, wenn die Antwort erfolgreich ist
• redirect_on_failure leiten, wenn die Antwort nicht erfolgreich ist
• json_response JSON -Antwort

Jobdateien erhalten auch die folgenden subcommand , options und flags . Das Argument options ist ein Array von Arrays mit Namen und Wert. Das flags -Argument ist ein Array mit den angegebenen Flaggen. Das Argument subcommand ist nur eine Zeichenfolge, wenn ein Unterbefehl gegeben wurde.

Abhängigkeitsinjektion

Sie können den eingebauten Injektor verwenden, um Abhängigkeiten zu binden oder zu registrieren. Sie können auch Abhängigkeiten vom Injektor lösen. Sie können alles, was Sie benötigen, zum Injektor hinzufügen und während Ihrer Anwendung über die Application darauf zugreifen.

Der eingebaute Injektor wird nach Bedarf abhängig sein und Abhängigkeiten auflösen. Sie können eine Klasse auch an einen Schließ binden, wenn Sie vor der Rückgabe der Klasse ein Setup durchführen oder ein bereits erstellter Objekt registrieren müssen. Das folgende Beispiel zeigt einen einzelnen Aktionscontroller, der aus der Router -Klasse aufgelöst wird. Die __construct -Methodenparameter werden aus dem Injektor aufgelöst.

 <?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 ));
	}
}

Die Methodenparameter werden auch vom Injektor aufgelöst, wenn die Route die Methode versendet.

Es gibt auch Injektor -Helfer -Methoden, die einen Inline -Code verringern. Wenn Sie eine Klasseninline injizieren möchten, können Sie dies mit $this->Application->Injector->resolve(Some_Class::class) oder Application::get()->Injector->resolve(Some_Class::class) . Die Methoden resolve und resolve_fresh sind verfügbar, um diesen Inline -Code zu verkürzen.

Datenbank

Es gibt eine grundlegende PDO -Wrapper Database sowie eine Pdo_Manager -Klasse, mit der Sie Datenbankabfragen verwalten können. Die Pdo_Manager -Klasse kehrt und Instanz von PDO zurück und kann verwendet werden, um Abfragen direkt auszuführen. Die Database ist ein Wrapper um die Pdo_Manager -Klasse und bietet einige grundlegende Abfragemethoden. Es gibt auch eine sehr grundlegende Model und zusätzliche Helfermethoden für Database , wie an anderer Stelle diese Methoden verarbeiten die Abhängigkeitsinjektion und rufen die Methoden in der injizierten Database auf. Die Helfer sind:

• fetch_column
• fetch_row
• fetch_all
• row_exists

Model -Sämaschinen

Es gibt eine grundlegende Säatorklasse, mit der Ihre Datenbank gesenkt werden kann. Dies stützt sich auf Attribute, die in den Modellklassen aufgeführt sind, um den Seeder zu unterweisen, wie die Daten erstellt werden.

 <?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 ;
}

Sie können dann die Datenbank mit dem folgenden Code säen:

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

Anstelle von Create können Sie getSeededData aufrufen, um die Daten zu erhalten, die in die Datenbank eingefügt werden. Dies ist nützlich, um ein Modell zu testen oder manuell zu laden, ohne es zu speichern. Sie können auch eine Rückrufmethode übergeben, die die Daten des Anfangsmodells erhalten. Dies hilft, Daten zu säen. Der Rückruf sollte eine Reihe von Seeder zurückgeben.

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 ();

Der übergebene Saatgut stellt sicher, dass die Daten jedes Mal gleich bleiben, wenn der Sämaschine ausgeführt wird, was zu reproduzierbaren Datensätzen führt. Die Seeder hat eine getRandomSeed -Methode, die einen zufälligen Saatgutwert zurückgibt. Dies ist nützlich, um zufällige Daten zu erstellen, die Sie nicht reproduzierbar sein müssen, oder um einen zufälligen Saatgut zu generieren, den Sie kopieren und verwenden können.

Konfigurationshelfer

Es gibt auch einige Konfigurationshelfer:

• get_config , um das gesamte Konfigurationsarray zu erhalten
• get_config_value , um einen bestimmten Wert aus dem Konfigurationsarray zu erhalten
• config_has , um zu überprüfen, ob im Konfigurationsarray ein Schlüssel vorhanden ist