+
-
+
-### During Instantiation
+- **Passing config during instantiation**
-To define settings upon instantiation, pass an associative array into the Leaf constructor.
+ To define settings upon instantiation, pass an associative array into the Leaf constructor. The array keys are the setting names and the array values are the setting values. This is the most performant way to define settings for Leaf, and we'll recommend this if you're using class mode.
-```php
-$app = new Leaf\App([
+ ```php
+ $app = new Leaf\App([
'debug' => true
-]);
-```
+ ]);
+ ```
-### Leaf Config
+- **Using the `config()` method**
-Leaf config allows you to quickly configure your leaf application from anywhere in your app.
+ This method is the most common way to apply config to your Leaf application. It's also the most flexible way to apply config. You can apply config at any point in your application, and you can apply multiple config at once. *Note that the config will only be applied to code that comes after the config method.*
-```php
-Leaf\Config::set([
- "views.path" => "views",
- "views.cachePath" => "views/cache"
-]);
-```
+ ```php
+ $app = new Leaf\App;
+ $app->config([
+ 'debug' => true,
+ 'views.path' => '../views'
+ ]);
+ ```
-The best part of this is that you don't need to pass these configurations to any file or methods. Leaf automatically picks up all the configurations made in this file whether the configuration is done before of after initializing leaf.
+
+
-You can also get configuration values using `get`
+- **Using the `config()` method**
-```php
-$appConfig = Leaf\Config::get("views.path");
-```
+ The `config()` method is the recommended way to apply config to your Leaf application. It allows you to set and get config values at any point in your application, and you can apply multiple config at once. *Note that the config will only be applied to code that comes after the config method.*
-You can also get all the settings your app is using by leaving the parameter on Leaf Config empty
+ ```php
+ app()->config([
+ 'debug' => true,
+ 'views.path' => '../views'
+ ]);
+ ```
-```php
-$appConfig = Leaf\Config::get();
-```
+
-### After Instantiation
+- **Using the `Leaf\Config` class**
-To define settings after instantiation, the majority can use the config application instance method; the first argument is the setting name and the second argument is the setting value.
+ The Config class is the central point for all of Leaf's config. It allows you to set and get config from anywhere in your app. However, it is best to set config before initializing Leaf.
-```php
-$app = new Leaf\App;
-$app->config('debug', false);
-```
+ ```php
+ Leaf\Config::set([
+ 'views.path' => 'views',
+ 'views.cachePath' => 'views/cache'
+ ]);
-You may also define multiple settings at once using an associative array:
+ // your leaf app after this
+ ```
+
+## Nested Config
+
+Leaf allows you to nest config into groups. This means that you can group config into arrays. This is especially useful when you're scoping features based on some configuration.
+
+For example, you can group all your server config into a `server` array:
+
+
```php
-$app->config([
- 'debug' => true,
- 'views.path' => '../views'
+$app = new Leaf\App([
+ 'server' => [
+ 'host' => 'localhost',
+ 'port' => 8080
+ ]
]);
```
-To retrieve the value of a setting, you also use the config application instance method; however, you only pass one argument - the name of the setting you wish to inspect. If the setting you request does not exist, null is returned.
+
+
```php
-$settingValue = $app->config('views.path'); // returns "../views"
+app()->config([
+ 'server' => [
+ 'host' => 'localhost',
+ 'port' => 8080
+ ]
+]);
```
-## Nested Config
+
-From v3 of leaf, config works a little bit differently under the hood. Leaf now allows you to set and get config under groups in an array form. Before, all config was saved in one flat array, and you namespacing commands eg: `app.down` would add a new entry in the flat array just as defined.
+You can then access the config using the `config()` method:
-Leaf Config in v3 now creates a sub array which allows you to group all the config related to an item in an array.
+
-::: tip Note
-This in no way affects the way Leaf config works, it simply creates new possibilities for use, especially externally with modules and functional mode.
-:::
+```php
+$app->config('server.host'); // localhost
+```
-Instead of your config looking like this:
+
+
```php
-['app.down' => false, ..., 'log.enabled' => false, 'log.file' => '1.txt', ...]
+app()->config('server.host'); // localhost
```
-You'll have this:
+
+
+
+You can also retrieve the entire config group by passing the group name:
+
+
```php
-['app' => ['down' => false, ...], 'log' => ['enabled' => false, ...], ...]
+$app->config('server'); // ['host' => 'localhost', 'port' => 8080]
```
-This means that you can simply grab a single group if you want to:
+
+
```php
-$appConfig = app()->config('app');
-$loggerConfig = app()->config('log');
+app()->config('server'); // ['host' => 'localhost', 'port' => 8080]
```
-You can also create your own group and config:
+
-```php
-app()->config(['home.key' => '2']);
+This isn't limited to only retrieving config. You can also set config using the same method:
-$homeConfig = app()->config('home');
-$homeKey = $homeConfig['key'];
+
-// or
+```php
+$app->config('server.host', '127.0.0.1');
+```
+
+
+
-$homeKey = app()->config('home.key');
+```php
+app()->config('server.host', '127.0.0.1');
```
+
+
diff --git a/src/docs/config/nsm.md b/src/docs/config/nsm.md
index a7402189..baa1e91f 100755
--- a/src/docs/config/nsm.md
+++ b/src/docs/config/nsm.md
@@ -1,90 +1,99 @@
-
-
-# Instance and Mode
-
-## Config app instance
+# Application Environment
-Once leaf is initialized, a config named app is populated with the app instance and container. You can use these from anywhere in your app.
+
-```php
-
+import VideoDocs from '/@theme/components/VideoDocs.vue'
+
-// ...
-$app = Leaf\Config::get("app")["instance"];
+When building an application, it is helpful to distinguish between what is "running locally" versus what is "running in production". For example, you may have a different database running locally than you do on your production server.
-$app->set404(Custom404::build());
-```
+To make this a breeze, Leaf provides robust support for environment based configuration, allowing you to conveniently handle configuration values for different environments.
-## Modes
+## Environment variables
-It is common practice to run web applications in a specific mode depending on the current state of the project. If you are developing the application, you will run the application in “development” mode; if you are testing the application, you will run the application in “test” mode; if you launch the application, you will run the application in “production” mode.
+In a sense of your applications, environment variables are dynamic values that affect the way your applications behave. They are part of the environment in which a process runs. For example, your app can use the value of the TEMP environment variable to discover a suitable location to store temporary files. Environment variables are easy to change between environments, such as development, staging, and production.
-Leaf supports the concept of modes in that you may define your own modes and prompt Leaf to prepare itself appropriately for the current mode. For example, you may want to enable debugging in “development” mode but not in “production” mode. The examples below demonstrate how to configure Leaf differently for a given mode.
+
-If no mode setting is found, Leaf will set the application mode to `development`.
-
-### How do I use an app mode?
-
-After you instantiate a Leaf application, you may configure the Leaf application for a specific mode with the Leaf application’s `script` method. This method accepts two arguments: the name of the target mode and a callable function to be immediately invoked if the first argument matches the current application mode.
+```php
+$app->config([
+ 'mode' => 'production'
+]);
+```
-Assume the current application mode is `production`. Only the callable associated with the `production` mode will be invoked. The callable associated with the `development` mode will be ignored until the application mode is changed to `development`.
+
+
```php
-config([
- 'mode' => 'production'
+ 'mode' => 'production'
]);
```
+
+
+### Using your application mode
+
+The Leaf instance provides a `script()` method that allows you to register a callable that will be invoked when the application mode matches the given mode. The `script()` method accepts two arguments: the mode and a callable.
+
+
+
```php
-// Only invoked if mode is "production"
-app()->script('production', function () use ($app) {
- app()->config([
- 'log.enable' => true,
- 'debug' => false
- ]);
+$app->script('production', function () use ($app) {
+ $app->config([
+ 'log.enable' => true,
+ 'debug' => false
+ ]);
});
+```
+
+
+
-// Only invoked if mode is "development"
-app()->script('development', function () use ($app) {
- app()->config([
- 'log.enable' => false,
- 'debug' => true
- ]);
+```php
+app()->script('production', function () {
+ app()->config([
+ 'log.enable' => true,
+ 'debug' => false
+ ]);
});
```
+
+
+
+The above example will enable logging and disable debugging when the application mode is set to `production`.
diff --git a/src/docs/config/settings.md b/src/docs/config/settings.md
index 406aaa7a..37bba912 100755
--- a/src/docs/config/settings.md
+++ b/src/docs/config/settings.md
@@ -1,128 +1,84 @@
# App Settings
-
-These are configurations leaf uses to seamlessly configure your applications.
+
-## app
+Leaf has lots of configurations which can be used to determine the way Leaf behaves in your application. You can check the [config page](/docs/config/) for more information on how to set and get configs. This page will show you all the configs available in Leaf. Note that we will only cover the user-facing configs, configs that are used internally by Leaf will not be covered here.
-This is a new configuration that allows you to get information about your Leaf app and it's instance. It is recommended to **set** anything on this config key as Leaf automatically sets up everything you might need.
+## app.down
-After initializing Leaf with `new Leaf\App`, Leaf saves that instance with an `instance` key and the instance container as `container` inside the app config.
+This configuration tells Leaf whether to place your app in a maintenance like state. By default, this is set to `false`, but you can set it to `true` to place your app in a maintenance like state.
```php
-$app = new Leaf\App;
-
-// somewhere else...
-
-$application = Leaf\Config::get("app");
-
-// get the $app instance defined above
-$leafApp = $application["instance"];
-
-// get $app container
-$container = $application["container"];
-
-// use container data
-$container->response->json("hello");
-
-// use the $app instance
-$leafApp->get("/", function () {
- echo "something";
-});
-
-// you can also get information about that instance
-echo $leafApp->routes();
+'app.down' => true
```
-::: tip Note ⚡️
-Although you can do all of these, there is actually no need to. This is because Leaf 3 comes with functional mode which allows you to use the app instance from anywhere in your app.
+When your app is in a maintenance like state, Leaf will automatically load the `down` screen. You can customize this screen using Leaf's `setDown` method.
```php
-$app = new Leaf\App;
-
-// somewhere else...
-
-app()->response()->json("hello");
+$app->setDown(function () {
+ echo 'Custom Down Handler!';
+});
```
-:::
+**You can read more about the down screen [here](/docs/routing/errors#application-down).**
-## app.down
+## debug
-A new `app.down` config was added to replace the `mode=down` which caused problems in earlier releases. You can set this to true to place your app in a maintainance like state.
+By default, Leaf will display all errors and warnings you encounter while developing your app. However, when you're ready to deploy your app, you should turn off debugging to prevent users from seeing errors. You can do this by setting the `debug` config to `false`.
```php
-$app = new \Leaf\App([
- 'app.down' => true
-]);
+'debug' => false
```
-To top it all, you no longer need `setDown` unless you want to define a custom maintainance screen as Leaf's default app down screen is now automatically loaded.
+Note that when you set `debug` to `false`, Leaf will automatically turn off error reporting and display a custom error page to users. You can customize this page using Leaf's `setError` method.
```php
-$app->setDown(function () {
- echo "Custom Down Handler!";
+$app->setError(function () {
+ echo "Custom Error Handler!";
});
```
-## debug
+## Logging
-If debugging is enabled, Leaf will use its built-in error handler to display diagnostic information for uncaught Exceptions. If debugging is disabled, Leaf will instead invoke your custom error handler, passing it the otherwise uncaught Exception as its first and only argument.
+Leaf has a built-in logger that can be used to log errors and other messages. You can check the [logging page](/docs/tooling/logging) for more information on how to use Leaf's logger. This page will show you all the configs available for Leaf's logger.
-```php
-$app = new \Leaf\App([
- 'debug' => true
-]);
-```
-
-## http.version
-
-By default, Leaf returns an HTTP/1.1 response to the client. Use this setting if you need to return an HTTP/1.0 response. This is useful if you use PHPFog or an nginx server configuration where you communicate with backend proxies rather than directly with the HTTP client.
+To get started, make sure you have the [logger module](/docs/tooling/logging) installed. Once installed, you should have access to a `logger()` method on the Leaf instance. You can use this method to access Leaf's logger if you want to manually log messages.
```php
-$app = new \Leaf\App([
- 'http.version' => '1.1'
-));
-
-// After instantiation
-$app->config('http.version', '1.1');
+$app->logger()->info('Hello World!');
```
-## log.dir
+Below are all the configs available for Leaf's logger:
-This tells leaf which directory to save and look for logs.
+### log.enabled
+
+This enables or disables Leaf’s logger. You need to set this to `true` to enable logging.
```php
-Leaf\Config::set("log.dir", __DIR__ . "/logs/");
+'log.enabled' => true
```
-## log.enabled
+Note that if `log.enabled` is set to `false`. Leaf will skip initializing anything related to logs, as such, you won't have access to `$app->logger()`, `$app->log` or `$app->logWriter`.
-This enables or disables Leaf’s logger. To change this setting after instantiation you need to access Leaf’s logger directly and use its `setEnabled()` method.
+### log.dir
-```php
-// During instantiation
-$app = new \Leaf\App([
- 'log.enabled' => true
-]);
+This tells leaf which directory to save and look for logs.
-// After instantiation
-$app->logger()->enabled(true);
+```php
+'log.dir' => __DIR__ . '/logs/'
```
-::: warning log.enabled
-Note that if `log.enabled` is set to `false`. Leaf will skip initializing anything related to logs, as such, you won't have access to `$app->logger()`, `$app->log` or `$app->logWriter`.
-:::
-
-## log.file
+### log.file
This setting tells leaf which file to write logs to.
```php
-Leaf\Config::set("log.file", "crashes.log");
+'log.file' => 'crashes.log'
```
-## log.level
+*By default, Leaf will write logs to a file named `log.txt`.*
+
+### log.level
Leaf has these log levels:
@@ -137,24 +93,11 @@ Leaf has these log levels:
The `log.level` application setting determines which logged messages will be honored and which will be ignored. For example, if the `log.level` setting is `\Leaf\Log::INFO`, debug messages will be ignored while info, warn, error, and fatal messages will be logged.
-To change this setting after instantiation you must access Leaf’s logger directly and use its `setLevel()` method.
-
-```php
-// During instantiation
-$app = new \Leaf\App([
- 'log.level' => \Leaf\Log::DEBUG
-]);
-
-// After instantiation
-$log = $app->getLog();
-$log->setLevel(\Leaf\Log::WARN);
-```
-
-## log.open
+### log.open
This option takes in a boolean and determines whether Leaf should create the specified log file if it doesn't exist.
-## log.writer
+### log.writer
Use a custom log writer to direct logged messages to the appropriate output destination. By default, Leaf’s logger will write logged messages to `STDERR`. If you use a custom log writer, it must implement this interface:
@@ -162,40 +105,10 @@ Use a custom log writer to direct logged messages to the appropriate output dest
public write(mixed $message, int $level);
```
-The `write()` method is responsible for sending the logged message (not necessarily a string) to the appropriate output destination (e.g. a text file, a database, or a remote web service).
-
-To specify a custom log writer after instantiation you must access Leaf’s logger directly and use its `setWriter()` method:
-
-```php
-// During instantiation
-$app = new \Leaf\App([
- 'log.writer' => new \My\LogWriter()
-]);
-
-// After instantiation
-$app->logger()->setWriter(new \My\LogWriter());
-```
-
-## mode
-
-This is an identifier for the application’s current mode of operation. The mode does not affect a Leaf application’s internal functionality. Instead, the mode is only for you to optionally invoke your own code for a given mode with the `script()` application method.
-
-The application mode is declared during instantiation, either as an environment variable or as an argument to the Leaf application constructor. It cannot be changed afterward. The mode may be anything you want — “development”, “test”, and “production” are typical, but you are free to use anything you want (e.g. “foo”).
+The `write()` method is responsible for sending the logged message (not necessarily a string) to the appropriate output destination (e.g. a text file, a database, or a remote web service). The `$level` argument is one of the log levels listed above.
```php
-$app = new \Leaf\App([
- 'mode' => 'development'
-]);
-```
-
-```php
-// Only invoked if mode is "development"
-app()->script('development', function () use ($app) {
- app()->config([
- 'log.enable' => false,
- 'debug' => true
- ]);
-});
+'log.writer' => new \My\LogWriter()
```
## views.path
@@ -203,11 +116,13 @@ app()->script('development', function () use ($app) {
The relative or absolute path to the filesystem directory that contains your Leaf application’s view files.
```php
-$app = new \Leaf\App([
- 'views.path' => './views'
-]);
+'views.path' => './views'
```
## views.cachePath
-This config tells leaf where to save cached and compiled views.
+When using a view engine, this config tells Leaf where to store cached views.
+
+```php
+'views.cachePath' => './views/cache'
+```
diff --git a/src/docs/introduction/docker.md b/src/docs/introduction/docker.md
index 859a257e..5440efc2 100644
--- a/src/docs/introduction/docker.md
+++ b/src/docs/introduction/docker.md
@@ -17,28 +17,23 @@ This guide will walk you through how to set up your Leaf application using Docke
## Using the Leaf CLI
-The Leaf CLI provides a simple way to create a new Leaf application using Docker. To create a new Leaf application using the Leaf CLI, run the following command:
+The Leaf CLI provides a simple way to get started with Docker in your Leaf applications. To create a new Dockerized Leaf app using the Leaf CLI, you need to add the `--docker` option to the `leaf create` command:
```bash
-leaf create my-app --v3 --docker
+leaf create my-app --docker
```
-This will setup a new Leaf application with Docker support. You can then run the following command to start your application:
+This will setup a new Leaf application with Docker support. Although your app is dockerized, Leaf CLI still allows you to use the `serve` command to start your application. This command will automatically start your application using Docker instead of the built-in server.
```bash
leaf serve
```
-As you can see, following this process is not any different from creating a new Leaf application without Docker. The only difference is that the Leaf CLI will create a Dockerfile and docker-compose.yml file for you. You can always customize these files to suit your specific needs. Also, running the `leaf serve` command will smartly start your application using Docker instead of the built-in server.
+### Docker Files
-::: warning Known Issues
-In some cases stopping the dev server doesn't stop your Docker containers. If this happens, you can stop the containers from the Docker Desktop application.
-:::
-
-Using this method will scaffold your application with the following files:
+You will notice a bunch of docker related files in your project. These are added by the Leaf CLI since you used the `--docker` option. You can always customize these files to suit your specific needs.
```bash
-.
├── docker
│ ├── 000-default.conf
│ ├── Dockerfile
@@ -51,17 +46,9 @@ Using this method will scaffold your application with the following files:
- `php.ini` is the PHP configuration file that will be used by the Docker container.
- `docker-compose.yml` is the Docker Compose file that will be used to start the Docker container.
-Leaf CLI only scaffolds them for you. You can always customize them to suit your specific needs.
-
-## Creating your Leaf application
-
-First, create a new Leaf application using the Leaf CLI or any of the methods on the [installation](/docs/introduction/installation) page.
-
-```bash
-leaf create my-app --v3 --basic --no-tests
-```
+## Adding to existing projects
-From there, we can manually add our Docker files into the project. For this, you can choose any method that you prefer. We have provided a sample Dockerfile and docker-compose.yml file below that you can use as a starting point.
+If you already have an existing Leaf application and you want to add Docker support to it, you will need to do so manually. We have provided a sample below that you can use as a reference.
**Dockerfile:**
@@ -129,3 +116,15 @@ services:
```
+
+After adding these files, you can start your application using Docker by running the following command:
+
+```bash
+leaf serve
+```
+
+Or with the docker compose command:
+
+```bash
+docker compose up
+```
diff --git a/src/docs/introduction/first-app.md b/src/docs/introduction/first-app.md
index 708b9f6d..6c48606f 100644
--- a/src/docs/introduction/first-app.md
+++ b/src/docs/introduction/first-app.md
@@ -17,7 +17,7 @@ We recommend using the [Leaf CLI](/docs/cli/) for creating and managing your Lea
To get started, we will need to generate a leaf application. We can do this simply with Leaf CLI:
```bash
-leaf create
-
-```php
-get('/', function () {
- echo 'Hello world';
-});
-
-$app->run();
-```
-
-
-
-
-
-```php
-get('/', function () {
- echo 'Hello world';
-});
-
-app()->run();
-```
+## Classes vs Functions
-
-
-We have already created our very first Leaf app! This is as simple as it gets.
-
-In addition, we can output data with Leaf response. This is a module that allows us to output data of various types without any hassle.
-
-
-
-```php
-get('/', function () use($app) {
- $app->response()->markup('Hello world');
-});
-
-$app->run();
-```
-
-Now you might be wondering why we need to go through all of this just to return some HTML when we can just use echo. The reason for this is simple. `Response` takes care of a lot of issues for us under the hood and renders exactly what we expect. Let's look at an example below.
-
-
-
-
-```php
-get('/', function () {
- response()->markup('Hello world');
-});
-
-app()->run();
-```
+Leaf supports two different ways of writing your code:
-We use `response` here instead of `echo` because it takes care of a lot of issues for us under the hood and renders exactly what we expect. Let's look at an example below.
+- Using functional mode which you saw above
+- Using class mode which is building your app using Leaf's classes
-
+### Class Mode
-
+If you are familiar with PHP frameworks, you've probably spent a lot of time writing code using classes. Leaf comes with a ton of powerful classes that you can use to build your app. Let's take a look at the code above in class mode.
```php
get('/', function () {
- // set content-type to json
- Leaf\Http\Headers::contentJSON();
-
- echo 'Hello world';
+$app->get('/', function () use ($app) {
+ $app->response()->json(['message' => 'Hello World!']);
});
$app->run();
```
-
-
-
-
-```php
-get('/', function () {
- // set content-type to json
- Leaf\Http\Headers::contentJSON();
-
- echo 'Hello world';
-});
-
-app()->run();
-```
-
-
-
-When we run this, we get "\Hello world\" instead of **Hello World**
-
-Unlike the confusion above between the content type and echo, Leaf response makes sure that whatever content we're trying to render is reflected in the content type. This is just one of the many things that response takes care of automatically.
-
-## Functional Mode
-
-We have mostly talked about general features that are the same even in Leaf 2, so let's talk about some spice in Leaf 3.
-
-::: tip
-This is just an introduction to functional mode. Read the [functional mode documentation](/docs/tooling/functions.html) for the full explanation.
-:::
-
-Basically, leaf 3 comes with global helper functions that take away the only pain anyone has ever had in using leaf, i.e., long namespaces and class initializers. Let's rewrite the first example in functional mode.
-
-```php
-get('/', function () {
- response()->markup('Hello world');
-});
-
-app()->run();
-```
-
-You'll notice that we've gotten rid of the lengthy `use Leaf\Http\Response;` and even the leaf initializer. Leaf 3 helps you focus on only what matters: your application. Everything is either done for you under the hood or made available to you in easy-to-use tools.
-
-### Handling User Input
-
-One very important part of building web apps/APIs is user input. Users may pass data into your leaf app through forms, http request bodies, URLs, ...
+### Functional Mode
-You must read this data and make sure it can't harm your system before performing any operations on it. This can be very clumsy when done raw with PHP, especially when the data comes in through multiple channels. Leaf has, however, prepared a simple handler for this: `Leaf\Http\Request`. Since we are using functional mode, we will use the `request` method instead of this lengthy class.
+Classes can become annoying and very repetitive, especially because of namespaces. You also sometimes need to worry about variable scoping and re-initializing classes.
-The user navigates to /?greeting=hello%20world
+For these and many more reasons, Leaf allows you to build your apps entirely using functions. Let's take a look at the code above in functional mode.
```php
get('/', function () {
- // we can get the GET request data from the URL like this
- $greeting = request()->get('greeting'); // hello world
-
- // output json encoded data
- response()->json([
- 'greeting' => $greeting
- ]);
+ response()->json(['message' => 'Hello World!']);
});
app()->run();
```
-The most beautiful thing about the request object is that all data passed into your app is automatically sanitized to prevent attacks like XSS. You have simple and safe code working for you.
-
-## Class mode vs Functional mode
-
-Leaf supports two different ways of writing your code:
-
-- Using functional mode which you saw above
-- Using class mode which is what has been used since Leaf v1
-
-### Class Mode
-
-This method is the default for most frameworks. Since leaf comes with classes, you can entirely build your aplication using those classes. like the `Leaf\Http\Response` class.
-
-```php
-get("/", function () {
- echo "Hello world";
-});
-
-$app->run();
-```
-
-### Functional Mode
-
-Classes become annoying to use and repeat, especially because of namespaces. You also sometimes need to put the instance of a class into a function's scope with `use`. Getting the particular instance of a class can be difficult which sometimes leads to reinitializing the class. For these reasons (and more), we created scopeless functions which allow you to quickly build your applications. These functions return instances of Leaf's classes so you don't need to use the classes yourself.
-
-```php
-get("/", function () {
- echo "Hello world";
-});
-
-app()->run();
-```
+Besides the benefits functional mode gives you on a surface level, it also does a lot of work behind the scenes to make your code more efficient and faster.
## Modes in the docs
-Just as leaf allows you to write your code in 2 ways, with functional mode or class mode, our docs come with examples prepared for both.
-
-You can click on this switch in the sidebar to toggle the mode of the examples on our documentation.
+The docs are written in both functional and class mode. You can switch between the two modes using the switcher at the top of the page.
-## Installing modules
-
-Modules are pieces of functionality that have been packaged and shipped separately from the Leaf core. Modules are used to extend Leaf's reach by performing operations not available on the core. Modules were introduced with Leaf 3, but some of them can be used with earlier versions of Leaf. Modules can also be used in external libraries and frameworks as well. To install a module, simply run its install script with composer or use the leaf CLI.
-
-To demonstrate this, we will expand the app above to output a template instead of the JSON data from earlier. For this, we will need a template module. Leaf has 3 template modules
+## Leaf modules
-- BareUI: Super lightweight, blazing fast templating engine with zero compilation
-- Blade: A port of the laravel blade templating engine
-- Leaf Veins: Lightweight but powerful templating
-
-For this demo, we will use BareUI. We can install BareUI with leaf CLI.
-
-```bash
-leaf install bareui
-```
-
-Or with composer:
-
-```bash
-composer require leafs/bareui
-```
-
-After this, Leaf **automatically** links the BareUI class for you and makes it available on the leaf object as `template`. So from there, we can create our template. I'll name this `index.view.php` (BareUI templates end in `.view.php`)
-
-```php
-
-
-
-
-
-
-
-
-```php
-template->config("path", "./");
-
-$app->get("/", function () use($app) {
- // we can get the GET request data from the URL like this
- $greeting = $app->request()->get("greeting"); // hello world
-
- // render our template
- echo $app->template->render("index", [
- "greeting" => $greeting,
- ]);
-});
-
-$app->run();
-```
-
-
-
-
-```php
-template->config("path", "./");
-
-app()->get("/", function () {
- // we can get the GET request data from the URL like this
- $greeting = request()->get("greeting"); // hello world
-
- // render our template
- echo app()->template->render("index", [
- "greeting" => $greeting,
- ]);
-});
-
-app()->run();
-```
-
-
+Modules are pieces of Leaf's functionality that are available as separate packages. These packages can be installed and used with Leaf to extend its functionality. Most modules are framework agnostic and can be used with other frameworks and libraries, but they are built to work best with Leaf.
-Just as you saw above, most Leaf modules require absolutely no configuration in order to work with the Leaf core. They just fit right in.
+You can check out the [modules page](/modules/) to see a list of all the modules available for Leaf.
## Ready for More?
@@ -383,7 +138,7 @@ We've briefly introduced the most basic features of Leaf 3 - the rest of this gu
## Next Steps
-If you skipped the [Introduction](/docs/introduction/), we strongly recommend reading it before moving on to the rest of the documentation.
+If you are new to Leaf, we strongly recommend reading this page before moving on to the rest of the documentation. It will provide you with a solid foundation on which to build your Leaf knowledge. If you are already familiar with Leaf, feel free to check out the rest of the documentation.
-You might want to check out [URL rewriting](/docs/introduction/url-rewriting.html).
+When hosting your application on a webserver, all requests coming into your app must be routed through Leaf. It is really simple to do, and all needed instructions can be found @ [URL rewriting](/docs/introduction/url-rewriting.html).
-## GitHub
+## MVC Setup
-
+Although Leaf allows you to select exactly what you want to install, some applications go beyond the basic setup. Leaf MVC is a full but ridiculously light-weight MVC framework that allows you to build complex applications with Leaf. It comes with a lot of features like authentication, database, http related functionality and a powerful CLI. To get started with Leaf's MVC setup, you can check out the [MVC docs](/docs/mvc/).
-You can also clone the leaf 3 branch.
+## Hello world example
-::: tip Setup
-You can directly download v3.x-dev here.
-
-
- Download Repo
-
-:::
+Below is a "hello world" example which takes you through the core of Leaf. Other parts of the docs cover deeper examples. You can also refer to our [codelab experiments](/codelabs/) for real world examples and use-cases.
-After downloading repo, you need to create an autoloader.
+A base Leaf app that outputs hello world in your browser looks like this:
-**Example autoloader: `autoloader.php`**
+
```php
get('/', function () {
+ echo 'Hello world';
});
-```
-The autoloader will allow you use leaf files without having to `require` or `include` them first. So straight up using `Leaf\App` will load `leaf\src\App.php`.
+$app->run();
+```
-**This is only required if you downloaded the repo.**
+
-Now, all you have to do is create your index.php file, install leaf's dependencies (core modules), and include your autoloader like this:
+
```php
get('/', function () {
+ echo 'Hello world';
+});
+
+app()->run();
```
-::: warning NOTE THAT
-functional mode is not automatically available if you go down this route, you will have to manually add the leaf functions file in your app or in the autoloader.
-:::
+
-```php{5}
-
-## Leaf skeleton
+```php
+ --skeleton --v3
+$app->get('/', function () use($app) {
+ $app->response()->markup('Hello world');
+});
+
+$app->run();
```
-:::
+
+
-The main installtion for skeleton is through composer.
+```php
+
+require __DIR__ . '/vendor/autoload.php';
+
+app()->get('/', function () {
+ response()->markup('Hello world');
+});
+
+app()->run();
```
+
+
diff --git a/src/docs/leafapi/index.md b/src/docs/leafapi/index.md
index 9801e456..28158c87 100644
--- a/src/docs/leafapi/index.md
+++ b/src/docs/leafapi/index.md
@@ -6,16 +6,12 @@ Leaf API is a minimal but powerful PHP MVC framework. It's designed to be simple
Leaf API is a setup that gives you a good starting point for building APIs using the MVC pattern. It's built on top of Leaf, and comes with additional tooling that make building with Leaf even faster.
-::: tip Leaf MVC vs Leaf API vs Skeleton
-Leaf offers three setups for you to choose from. You can find more information about these setups in the [MVC](/docs/mvc/#mvc-in-leaf) section.
-:::
-
## Installation
The easiest way to setup Leaf MVC is to use the [Leaf CLI](/docs/cli/):
```bash
-leaf create