Download the PHP package jhuddle/framework without Composer

framework

Requires PHP 8.1.0 or later

Ultra-minimal PHP, erm, framework.

Oh no, not another one...

Fair point - but this one is really small and super useful, promise.

How small?

Just under 10 kB. You'll hardly know it's there.

Go on then. How do I get started?

Let's start at the very beginning; a very good place to start. From your project root folder:

• Install it with Composer:

• Then, by way of example, create the following files:

  templates/layout.php

  templates/partials/list.php

  public/index.php

  app/app.php

• Start a web server that points at public/index.php:

  • For development, the easiest option is to run the built-in server:

  • For production environments, you'll probably want to set up nginx or Apache.

• Then, from your base URL (e.g. http://localhost:8000), try out some routes in your browser of choice:

  Or with curl:

Note that in each case, the route handling methods get() and post() - or put(), patch(), delete(), whatever you need - take two arguments:

• The route pattern, which may contain parameters in angle brackets: these can be made optional with ?, and/or provided with the name of a PHP scalar type as a syntax hint (though type coercion/URL decoding is not performed automatically, for security reasons)
• The callback function, with named parameters that correspond to those in the route pattern, where the app's input property may be used to inspect the HTTP request body

Hopefully you might already have an idea how this works by now...

Yeah, looks simple enough - what's this 'view' => dir('../templates') all about though?

This tells your App instance where to find the PHP templates for generating your site's HTML; the framework isn't expecting any particular folder structure, so you need to tell it which base folder to look in. In fact, the array key doesn't even have to be named view: you could call it template instead, or html, or whatever you prefer! And you can even have multiple array keys, each referring to a different base folder.

Whichever names you choose will be used to create new callable Resource properties on the app instance: when invoked with a file path (relative to the base folder), these create anonymous class objects which include the file whenever used as a string, and which extract an optional array of variable names and values for use within that file's context, e.g.:

But that's not all! Besides base folders wrapped in dir(), you can add/overwrite anything you like to your App instance, at any time, either during instantiation or by calling the use() method:

Cute. What else can it do?

It not only handles requests, it can also make them:

Behind the scenes, the request objects were loaded into the app in just the same way as we've seen above - so it's possible to override them in the constructor or with use(), if you want to use a different implementation.

Same goes for db - if the right environment variables are available in the execution context, the framework will establish a PDO connection based on the value of DBMS, using DB_HOST, DB_PORT, DB_NAME, DB_USER and DB_PASS for credentials. The included implementation comes with a couple of common helper methods for prepared statements and transactions, but you can override db with another if you like:

And there's also session, a very simple wrapper for the built-in PHP session management functions - by default, the framework starts a session unless false is passed as the second argument to the App constructor.

OK, sounds good - is that everything?

Yes and no! We've now touched each of the six small classes that make up this framework, but there's a lot more you can do with them...

• The objects you create via dir() can be stored in variables and extended with the use() method, just like the app itself:

  templates/mantra.php

  app/app.php

• These objects are also callable! You can use this fact to simplify your route callbacks:

  templates/hills.php

  app/app.php

• Templates can also create and call these objects:

  templates/layout.php

  templates/partials/header.php

  templates/partials/footer.php

  app/app.php

• Route methods can be chained together and/or prefixed:

And there's probably a bunch of other possible patterns for a bunch of other use cases that I didn't think of yet... the goal of this project is to write the smallest, least-opinionated, most extensible and most useful PHP framework possible, so it's over to you and your imagination from here!

Awesome, thank you! How can I contribute?

The best contribution you can make to this framework is simply to use it, and report any issues... and if you build something cool with it, please let me know by adding a link to your GitHub repo/project website in a pull request to the Projects file! It'd be great to see what you come up with. 🙂