Grav is a content management system (CMS) with a difference. Content management systems are commonplace in the modern web, with platforms like WordPress powering a large percentage of websites. They provide an easy-to-use graphical interface for non-technical users to add articles and content while the developers handle the code separately. The major drawbacks come when the CMS is bloated with unneeded features, or forces developers to work in a counter-productive manner. Even a basic CMS-built website that’s little more than a landing page relies on a database, which can make migration and management a larger task than it should be. Meet Grav, the CMS built with the purpose of being lightweight, flexible – and without a traditional database. Yet it still has an optional administration panel with a graphical interface, user management and the same features expected of a CMS.While Grav doesn’t have a traditional database running on MySQL or similar, it does have a type of database which is stored in folders and plain text files. These files store content with the Markdown syntax with configuration stored in YAML.

Why Grav?

The inspiration behind Grav’s development was to create a CMS that fills a gap between simple, static sites and complex multiuser blogs. When the project’s founder, Andy Miller, took a look at the flat-file solutions already out there, he found current options were either commercial, underpowered, or both.This isn’t for lack of technology. Twig tempting, YAML configuration, markdown content support, and other exceptionally user-friendly features were out there, but they hadn’t been assembled into a single CMS available for free.We felt it was important to make Grav not only free, but open source. This enables its community of developers to contribute code, have a definite say in the project’s development, and to easily create plugins and themes that take full advantage of Grav’s capabilities.

Grav – Lifecycle

Here, we will understand the lifecycle of Grav. Grav Lifecycle determines how Grav processes in order to extend the Grav via Plugins. The following diagram shows the flow of Grav lifecycle process.

The following four steps from the Grav lifecycle −

• PHP Version
• Loader class is initialized
• Obtain Grav Instance
• Call Grav Process

PHP Version

It checks the version of PHP to make sure that we are running the PHP version above 5.4.0.

Loader class is initialized

In the second step, the class loader gets initialized.

Obtain Grav Instance

• If no instance exists, then it calls the load() method and adds Grav.
• It initializes the debugger value and adds to the debugger.
• It registers the log and the error handler.
• It adds the uri, task, events, cache, session, plugins, themes, twig, taxonomy, language, pages, assets and base url.
• It registers the stream and the config handler.

Call Grav Process

• It initializes the configuration, Uri object, error handler, debugger and session.
• After initializing, it starts buffering the output.
• It initializes the timezone and the plugins and fires the onPluginsInitialized event.
• Next it initializes the theme and fires the onThemeInitialized and onTask[TASK] events.
• It initializes the assets and fires the onAssetsInitialized event.
• It initializes the twig with the following actions −
  • Based on the configuration, it sets the twig template paths.
  • Handles the available language templates.
  • Next it fires the onTwigTemplatePaths event.
  • Loader chain and twig configuration is loaded.
  • Fires onTwigInitialized event.
  • It loads the twig extensions and fires onTwigExtensions event.
  • It sets the standard twig variables.
• Next it initializes the pages.
  • It calls the buildPages() method.
  • If cache is good, then it loads pages from cache. If cache is not good then the recurse() method is called.
  • onBuildPagesInitialized event is fired in the recurse() method.
  • If a file is found as .md, the following actions are performed −
    • To load the file details, the init() method is called.
    • It sets the filePath, modified and id.
    • The header() method is called to initialize header variables.
    • The slug() method is called to set the URL slug.
    • The visible() method is called to set the visible state.
    • Based on the folder that starts with _(underscore), modularTwig() is set.
  • It later fires the onPageProcessed event.
  • recurse() the children if a folder is found.
  • It fires the onFolderProcessed event.
  • calls the buildRoutes() method.
  • For all pages the taxonomy is initialized
  • The route table is built for fast lookup.
• The events onPagesInitialized and onPageInitialized gets fired.
• Debugger CSS/JS is added to the assets.
• Using Twig’s processSite() method, we get the output.
  • The event onTwigSiteVariables is fired.
  • Gets the output of the page.
  • When page is not found or not routable then the event onPageNotFound is fired.
  • All Twig variables are set on twig object.
  • Template name is set depending upon the file/header/extension information.
  • render() method is called.
  • Returns the file format in HTML
• It fires the onOutputGenerated event.
• Set the HTTP headers.
• Displays the output
• The output buffer is flushed to the page.
• The event onOutputRendered will get fire.
• Closes the connection to client.
• Lastly, it fires the onShutDown event.

When the content() method is called on page, then the following lifecycle occurs.

• The event onPageContentRaw will get fire.
• According to the Markdown and Twig settings, it processes the page.
• It fires the onPageContentProcessed event.

Grav – Installation

Software Requirements for Grav

Let us now understand the software requirements for Grav.

Web Server

• WAMP (Windows)
• LAMP (Linux)
• XAMP (Multi-platform)
• MAMP (Macintosh)
• Nginx
• Microsoft IIS

Operating System − Cross-platform

Browser Support − IE (Internet Explorer 8+), Firefox, Google Chrome, Safari, Opera

PHP Compatibility − PHP 5.4 or higher

Text Editors

• Sublime Text (Mac / Windows/ Linux)
• Atom (Mac / Windows)
• Notepad ++ (Windows)
• Bluefish (Mac / Windows/ Linux)

Download Grav

Click on this link https://getgrav.org/downloads and follow the steps as shown in the screenshot given below to download Grav.

Unzip the downloaded Grav file into your web server.

Setup Wizard

Installation of Grav is a very simple process. Follow the steps given below for Grav setup.

• Download the zip file and extract it to your web server or local host. Rename the folder from its current name that you want to use to refer to your site.
• Open your browser and navigate to localhost/<your_folder_name>, you will be redirected to a screen which shows you have installed Grav successfully as in the following screenshot.

• Grav comes with a sample page that helps you get started. In the above screenshot, you can see the home link which has displayed a sample page.

How to Configure the General Settings of Grav

Once you install Grav, you will have to change the general options of your website. Elements like your site’s title or default Author can be changed from within the administration panel but first you will have to log into it.Navigate to the Configuration section from the main admin panel on the left.

name: Antimatter
version: 1.6.0
description: "Antimatter is the default theme included with **Grav**"
icon: empire
author:
   name: Team Grav
   email: devs@getgrav.org
   url: http://getgrav.org
homepage: https://github.com/getgrav/grav-theme-antimatter
demo: http://demo.getgrav.org/blog-skeleton
keywords: antimatter, theme, core, modern, fast, responsive, html5, css3
bugs: https://github.com/getgrav/grav-theme-antimatter/issues
license: MIT

form:
   validation: loose
   fields:
      dropdown.enabled:
         type: toggle
         label: Dropdown in navbar
         highlight: 1
         default: 1
         options:
            1: Enabled
            0: Disabled
         validate:
            type: bool

enable: true

<?php
namespace Grav\Theme;

use Grav\Common\Theme;

class MyTheme extends Theme {
   public static function getSubscribedEvents() {
      return [
         'onThemeInitialized' => ['onThemeInitialized', 0]
      ];
   }
   public function onThemeInitialized() {
      if ($this->isAdmin()) {
         $this->active = false;
         return;
      }
      
      $this->enable([
         'onTwigSiteVariables' => ['onTwigSiteVariables', 0]
      ]);
   }
   public function onTwigSiteVariables() {
      $this->grav['assets']
         ->addCss('plugin://css/mytheme-core.css')
         ->addCss('plugin://css/mytheme-custom.css');

      $this->grav['assets']
         ->add('jquery', 101)
         ->addJs('theme://js/jquery.myscript.min.js');
   }
}

$ ./scss.sh

$ scss --sourcemap --watch scss:css-compiled

How to Install Themes in Grav

Switching the appearance of your Grav website is easy and can be done in just a few simple clicks. There are themes officially made by Grav and 3^rd party themes on your disposal. In this tutorial we will show you how to find a new theme, add it to your website and activate it.As always the first thing you will need to do is to be logged in your admin dashboard. From there, please navigate to the Themes section.

Grav – Plugin

Grav Plugin can be uploaded to expand the functionality of the site. Plugins are used to make your work easier. The Dependency Injection Container helps access the key objects in Grav. In the entire life cycle with the help of Grav’s event hooks, we can manipulate Grav as per our need and can also access whatever the Grav knows. Dependency Injection is a software design pattern in which components are given their dependencies instead of hard coding them within the component.There are many free plugins available for Grav which are used for displaying blog archive, sitemap, search engine, form, light slider and many more. In the Plugin folder, you can store the plugins with a unique name; the name should be related to the function of the plugin and it should not contain any capital letter, underscore or space.

Powerful

Plugins are easy to write, flexible and powerful. There are 46 plugins, and have the features that include displaying a sitemap, provides breadcrumbs, display blog archives etc.

Essentials

When Grav is installed on your system, you can see there are two plugins inside the <your_folder_name>/user/plugins folder.

• Error plugin
• Problem plugin

Error Plugin − It is used to display the HTTP errors i.e. 404 Page Not Found when there is no request page available for the given URI.

Problem Plugin − It is used for detecting issues regarding the permissions, hosting setup and missing folders. It is useful when you install new Grav for identifying such issues.

How to Install Plugins in Grav

The Core version of Grav is accompanied by more than 45 plugin each of which provides viable new options for the CMS. The Softaculous installation comes with 6 of those plugin and you can install more at any time from the application itself.

-Grav is a Fast, Simple, and Flexible file-based Web-platform. Although Grav follows principles similar to other flat-file CMS platforms, it has a different design philosophy than most. The underlying architecture of Grav is built using well established and best-in-class technologies.

Login

Dashboard

Publishing

Installed Themes

Content

Grav is released under the MIT License.

Top 10 features of GRAV:

• Ready-to-run open source Grav package
• Uses Markdown for streamlined cross-platform content
• Support for Git (e.g. GitHub or GitLab) syncing and collaboration
• ‘Chromeless’ feature to display only page content (for embedding Hub pages)
• Blog-format homepage, with important reminders and unit preparations areas
• Ability to control which units are listed on homepage
• Additional Hub pages can be easily added/removed/changed
• Supports custom page types and modular content
• Markdown-based optional Sidebar, which can be easily customized
• Custom HTML, CSS, JavaScript and Twig is fully supported

-Major Features Of GRAV

• Fast : Performance is not just an afterthought, we baked it in from the start
• Extensible : Grav has a powerful API and sophisticated Package Manager to make it super flexible
• Enjoyable Content Creation : Use your favorite Markdown editor to create your content online or offline
• Stellar Performance : Grav intelligently caches content to deliver great performance, regardless of hosting
• Powerful Content Filtering : Create unlimited taxonomies such as tags, categories, and authors to filter and manage your content
• Dynamic Content Types : The flat-file nature of Grav lets you define custom fields for any of your pages, including modular content
• Simple Backups and Restores : Being file based means backing up and restoring your data is super easy, and changing hosts/servers is a breeze
• Image Media Processing : Dynamic image manipulation to resize, crop, resample, and effects all with automatic caching of images
• Easy Theme Customization : No need to start from scratch, use Theme Inheritance and then modify the bits you need, allowing for easier update