Today we are talking about The Needs Review Queue Initiative, What it is, and How it’s helping to improve Drupal with guest Stephen Mustgrave. We’ll also cover Translation Management Tool as our module of the week.

   

 

For show notes visit: www.talkingDrupal.com/426

Topics

• Can you give an overview of Needs Review Issue Queue Initiative
• Is the bug smash initiative related to the needs review issue queue
• Is this the same as the needs review bot
• How many issues were in the Needs Review status when you started
• How many issues today
• How long did it take until it was manageable
• How long do items stay on average
• Who else is helping
• Let’s talk through the pagination heading level issue
• What help can the community provide
• How does someone get involved
• Do you think this helps with burnout for core committers
• What’s the future of the initiative

Resources

• Needs Review Queue Bot
• Needs Review Issue Queue
• Pagination heading level issue

Guests

Stephen Mustgrave - smustgrave

Hosts

Nic Laflin - nLighteneddevelopment.com nicxvan John Picozzi - epam.com johnpicozzi Melissa Bent - linkedin.com/in/melissabent merauluka

MOTW Correspondent

Martin Anderson-Clutz - @mandclu Translation Management Tool (TMGMT)

• Brief description:
  • Have you ever wanted to automate the process of creating content translations on your Drupal site? There’s a module for that.
• Brief history
  • How old: created in Jan 2012
  • Versions available: 7.x-1.0-rc3 and 8.x-1.15, the latter of which works with Drupal 9 and 10
• Maintainership
  • Actively maintained
  • Test coverage
  • Documentation
  • Number of open issues: 595, 139 of which are bugs against the 8.x branch
• Usage stats:
  • 8,766 sites
• Maintainer(s):
  • Berdir, a very prolific maintainer in his own right, who also supports well known projects like Search API, Token, Paragraphs, and many more
• Module features and usage
  • Provides a tool set for automating the process of creating translations for your site content, as well as strings used within the site like menus, interface text, and so on
  • Works with more than 30 translation service providers, including many that leverage human translators, but also AI-based services like DeepL and OpenAI
  • Also has a plugin system to determine what text needs to be translated, so it can be easily adapted to very custom needs
  • With the module installed that Translate tab on your nodes changes to have buttons to request a translation in each language
  • Once a translation has been requested, it will run through states like unprocessed, active, and finished
  • Also provides an option for Continuous Translation, where new and updated content is automatically submitted for translation
  • Allows for professional translation at scale, using whatever kind of service works best for your site
  • The need for robust translation capabilities is what originally got me started using Drupal, so it’s great to see that there are enterprise-grade options for sites that need to manage translations at scale

The recent Drupal Core version 10.3.0 update brings a notable improvement for module developers, allowing the effortless integration of computed fields designated as bundle fields within Views. This enhancement streamlines the process of declaring and utilizing computed bundle fields, providing a more flexible approach to managing dynamic data in Drupal-based web development.

In this insightful interview segment, Grzegorz Pietrzak, the tech lead of Droopler, sheds light on how Droopler stands out in corporate website building. With a focus on the growing demand from enterprises, Pietrzak accentuates the distinctive features and integrations that position Droopler as the preferred choice. Exploring the nuanced balance between swift development and upholding Drupal's fundamental freedoms, he provides a sneak peek into Droopler's continuous evolution and hints at significant upcoming changes. For a more understanding, dive into the complete interview.

Allan Chappell

Senior Support Lead

Allan brings technological know-how and grounds it with some simple country living. His interests include DevOps, animal husbandry (raising rabbits and chickens), hiking, and automated testing.

January 1, 1970

At the time of this blog, we have done two major version upgrades of Drupal and have refined the process along the way. There has been a lot of work in the community, through the efforts of people like Matt Glaman to make this process easier.

As a Support Engineer, I see a lot of approaches for achieving the same results in many areas of my work. Here, I’d like to share with you three different ways to achieve an upgrade of a module or theme that isn’t ready for the next major Drupal version, each with pros and cons, but all absolutely acceptable.

Why do we have this problem?

All new Drupal developers have a hard time with the layers of code changes that happen in the Drupal community. We have custom package types, custom install locations, patches, and scaffolding. To make the challenges worse, we have two ways to identify a module’s dependencies — that being a .info.yml file and for some, a composer.json. This is because some Drupal modules may want to build upon an existing PHP library or project, in addition to other Drupal modules. To ease the pain of having to define some dependencies twice, both in the .info.yml file and composer.json file, Drupal.org built their packagist, a repository of Composer packages, to read the .info.yml files from the root of the project and create Composer version constraints from that. For example, if the .info file contained the following:

name: My Module type: module core_version_requirement: ^8.8 || ^9 dependencies: - ctools:ctools

Then Drupal.org’s packagist would create the following for the release that contained that .info.yml file, saving the contributed developer a lot of trouble.

{ "type": "drupal-module", "name": "drupal/my_module", "require": { "drupal/core": "^8.8 || ^9", "drupal/ctools": "*" } }

I hit on something there, though. It will create that for the release the .info.yml was in. When most code changes come in the form of patches, this poses a challenge. You apply your patch to the .info.yml after you download the release from Drupal.org’s packagist. Additionally, Drupal.org doesn’t create a new release entry for every patch file in the issue queue. So you are left with the question, “How do I install a module on Drupal 10 that requires Drupal 9 so that I can patch it to make it compatible for Drupal 10?”

Drupal Lenient

One of the easiest methods for those who don’t understand the ins and outs of Composer is to use the Drupal Lenient plugin. It takes a lot of the manual work out of defining new packages and works with any drupal-* typed library. Types are introduced to us through the use of the Composer Installer plugin and manipulated further with something like Composer Installers Extender. Composer plugins can be quite powerful, but they ultimately add a layer of complexity to any project over using core composer tactics.

Drupal Lenient works by taking any defined package pulled in by any means via Composer, and replaces the version constraints for drupal/core currently, at the time of this writing, with “^8 || ^9 || ^10“. So where the requirements might look like the example earlier “drupal/core“: “^8.8 || ^9“, they are replaced, making it now possible to install alongside Drupal 10, even though it might not‌ be compatible yet. This allows you to patch, test, or use the module as is, much like if you would have downloaded the zip and thrown it into your custom modules directory.

An example may look like this:

{ "name": "vendor/project", "repositories": [ { "type": "composer", "url": "https://packages.drupal.org/8" } ], "require": { "drupal/core": "^10.0.0", "drupal/my_module": "1.x-dev", "cweagans/composer-patches": "^1.7.3", "mglaman/composer-drupal-lenient": "^1.0.3" }" extra": { "composer-exit-on-patch-failure": true, "drupal-lenient": { "allowed-list": [ "drupal/my_module" ] }, "patches": { "drupal/my_module": { "3289029: Automated Drupal 10 compatibility fixes": "https://www.drupal.org/files/issues/2022-06-16/my_module.1.x-dev.rector.patch" } }, "patchLevel": { "drupal/core": "-p2" }, } }

Note the Drupal-Lenient allow list. Also note that you will need to make sure and install the plugin before trying to install the module that doesn’t support Drupal 10 in this case. If you want an excellent step-by-step, Matt put one together in the Readme.

The pros:

• Easy-peasy to install
• Feeds off the original packagist packages, so if there is an upgrade, you don’t have to do anything special to transition

The cons:

• Lenient has the control and may cause inexplicable errors when updating due to unsupported core versions
• PHP devs not familiar with Drupal Lenient won’t know to look for it
• Flaky experiences when switching in and out of branches that include this plugin. If you context switch a lot, be prepared to handle some errors due to Composer’s challenges maintaining state between branches.
• Patches to other dependencies inside composer.json still require you to run through some hoops

Custom package

If you want more control over what the module can and cannot do, while keeping the core of Composer functionality without adding yet another plugin, check out this method. What we will do here is find out what version the patch or merge request is being applied against. It should be stated in the issue queue and by best practices is a dev version.

If you are a perfectionist, you can use composer install -vvv to find the url or cache file that the module came from for packages.drupal.org. It is usually one of https://packages.drupal.org/files/packages/8/p2/drupal/my_module.json or https://packages.drupal.org/files/packages/8/p2/drupal/my_module~dev.json. You will note that the Composer cache system follows a very similar structure, swapping out certain characters with dashes.

With this information, you can grab the exact package as it’s defined in the Drupal packagist. Find the version you want, and then get it into your project’s composer.json.

Let’s use Context Active Trail as an example, because at the time of this writing, there is no Drupal 10 release available.

Looking through the issue queue, we see Automated Drupal 10 compatibility fixes, which has a patch on it at. I grab the Composer package info and paste the 2.0-dev info into my composer.json under the “repositories” section as a type “package.”

Which should make your project look something like this:

{ "name": "vendor/project", "repositories": [ { "type": "package", "package": { "keywords": [ "Drupal", "Context", "Active trail", "Breadcrumbs" ], "homepage": "https://www.drupal.org/project/context_active_trail", "version": "dev-2.x", "version_normalized": "dev-2.x", "license": "GPL-2.0+", "authors": [ { "name": "Jigar Mehta (jigarius)", "homepage": "https://jigarius.com/", "role": "Maintainer" }, { "name": "jigarius", "homepage": "https://www.drupal.org/user/2492730" }, { "name": "vasi", "homepage": "https://www.drupal.org/user/390545" } ], "support": { "source": "https://git.drupalcode.org/project/context_active_trail", "issues": "https://www.drupal.org/project/issues/context_active_trail" }, "source": { "type": "git", "url": "https://git.drupalcode.org/project/context_active_trail.git", "reference": "8dc46a4cf28e0569b187e88627a30161ee93384e" }, "type": "drupal-module", "uid": "context_active_trail-3192784", "name": "drupal/context_active_trail", "extra": { "branch-alias": { "dev-2.x": "2.x-dev" }, "drupal": { "version": "8.x-2.0-rc2+1-dev", "datestamp": "1630867980", "security-coverage": { "status": "not-covered", "message": "Project has not opted into security advisory coverage!" } } }, "description": "Set the active trail based on context.", "require": { "drupal/context": "^4.1", "drupal/core": "^8.8 || ^9" } } }, { "type": "composer", "url": "https://packages.drupal.org/8" } ], "require": { "drupal/core": "^10.0.0", "drupal/context_active_trail": "2.x-dev", "cweagans/composer-patches": "^1.7.3", "mglaman/composer-drupal-lenient": "^1.0.3" }" extra": { "composer-exit-on-patch-failure": true, }, "patches": { }, "patchLevel": { "drupal/core": "-p2" }, } }

Now let’s change our version criteria:

… "description": "Set the active trail based on context.", "require": { "drupal/context": "^4.1", "drupal/core": "^8.8 || ^9 || ^10" } …

And then add our patch:

… extra": { "composer-exit-on-patch-failure": true, }, "patches": { "drupal/context_active_trail": { "Automated Drupal 10 compatibility fixes": "https://www.drupal.org/files/issues/2023-09-29/context_d10comp_3286756.patch" } }, "patchLevel": { "drupal/core": "-p2" }, } …

Here, you will need to look to see if the patch is patching composer.json. If it is, you will need to modify your package information accordingly. For example, in this one, the fixer changes drupal/context from ^4.1 to ^5.0.0-rc1. That change looks like this:

… "description": "Set the active trail based on context.", "require": { "drupal/context": "^5.0.0-rc1", "drupal/core": "^8.8 || ^9 || ^10" } …

Lastly, sometimes you run into some complications with the order packages are picked up by Composer. You may need to add an exclude element to the Drupal packagist.

… { "type": "composer", "url": "https://packages.drupal.org/8", "exclude": [ "drupal/context_active_trail" ] }, …

Our final composer.json for our project could look something like this with all the edits:

{ "name": "vendor/project", "repositories": [ { "type": "package", "package": { "keywords": [ "Drupal", "Context", "Active trail", "Breadcrumbs" ], "homepage": "https://www.drupal.org/project/context_active_trail", "version": "dev-2.x", "version_normalized": "dev-2.x", "license": "GPL-2.0+", "authors": [ { "name": "Jigar Mehta (jigarius)", "homepage": "https://jigarius.com/", "role": "Maintainer" }, { "name": "jigarius", "homepage": "https://www.drupal.org/user/2492730" }, { "name": "vasi", "homepage": "https://www.drupal.org/user/390545" } ], "support": { "source": "https://git.drupalcode.org/project/context_active_trail", "issues": "https://www.drupal.org/project/issues/context_active_trail" }, "source": { "type": "git", "url": "https://git.drupalcode.org/project/context_active_trail.git", "reference": "8dc46a4cf28e0569b187e88627a30161ee93384e" }, "type": "drupal-module", "uid": "context_active_trail-3192784", "name": "drupal/context_active_trail", "extra": { "branch-alias": { "dev-2.x": "2.x-dev" }, "drupal": { "version": "8.x-2.0-rc2+1-dev", "datestamp": "1630867980", "security-coverage": { "status": "not-covered", "message": "Project has not opted into security advisory coverage!" } } }, "description": "Set the active trail based on context.", "require": { "drupal/context": "^5.0.0-rc1", "drupal/core": "^8.8 || ^9 || ^10" } } }, { "type": "composer", "url": "https://packages.drupal.org/8", "exclude": [ "drupal/context_active_trail" ] } ], "require": { "drupal/core": "^10.0.0", "drupal/context_active_trail": "2.x-dev", "cweagans/composer-patches": "^1.7.3", "mglaman/composer-drupal-lenient": "^1.0.3" }" extra": { "composer-exit-on-patch-failure": true, }, "patches": { "drupal/context_active_trail": { "Automated Drupal 10 compatibility fixes": "https://www.drupal.org/files/issues/2023-09-29/context_d10comp_3286756.patch" } }, "patchLevel": { "drupal/core": "-p2" }, } }

The pros:

• Uses more core Composer functionality
• A PHP developer will better understand ‌what’s going on here
• You are in complete control of how this module package and version are defined
• All the work is in one file

The cons:

• Requires some understanding of how composer.json, packagists, and the magic of Drupal’s packagist all work
• That’s a messy composer.json for the project
• If you have to use exclude, you have to leave it up to outside forces to let you know when that module does finally put out and actual D10-ready version, and then undo all of this work

Fork it

Standard PHP composer best practice says that if you make modifications to a package, fork it, maintain your modifications, and provide a pull request if it’s functionality you wish to contribute back. You can use this same approach with Drupal modules as well. Some may even say that’s what issue forks are for! That said, issue forks come with the downside that sometimes they go away, or are overridden with changes you don’t want. They are a moving dot.

For the sake of this example, let’s assume that we have forked the module on GitHub to https://github.com/fourkitchens/context_active_trail.git. If you don’t know how to make a fork, simply do the following:

• Clone the module to your local computer using the git instructions for the module in question
• Check out the branch you want to base your changes on
• Create a new repository on GitHub
• Add it as a remote git remote add github git@github.com:fourkitchens/context_active_trail.git
• Push it! git push github 8.x-2.x

You can do this with a version of the module that is in a merge request in Drupal.org’s issue queue, too. That way you won’t have to reapply all the changes. However, if your changes are in a patch file, consider adding them to the module at this time using your favorite patching method. Push all your changes to the github remote.

If the patch files don’t have changes to composer.json, or if the module doesn’t have one, you will likely want to provide at least a bare-bones one that contains something like the following and commit it:

{ "name": "drupal/context_active_trail", "type": "drupal-module", "require": { "drupal/context": "^5.0.0-rc1", "drupal/core": "^8.8 || ^9 || ^10" } }

This will tell Composer what it needs to know inside the project about dependencies. This project already had a composer.json, so I needed to add the changes from the patch to it.

Inside our Drupal project we are working on, we need to add a new entry to the repositories section. It will look something like this:

{ "type": "vcs", "url": "https://github.com/fourkitchens/context_active_trail.git" },

The VCS type repository entry tells Composer to look at the repository and poll for all its branches and tags. These will be your new version numbers.

Much like in the “Custom Package” example, you may need to add an exclude property to the Drupal packagist entry.

… { "type": "composer", "url": "https://packages.drupal.org/8", "exclude": [ "drupal/context_active_trail" ] }, …

Now, since Drupal packagist isn’t here to give Composer some version aliases, we have to use the old notation dev-BRANCHNAME for our version. Our require entry will look something like this:

"drupal/context_active_trail": "dev-8.x-2.x",

Since we already added our patches as a commit to the module, this is all you need. Your final composer.json for your project would look like this:

{ "name": "vendor/project", "repositories": [ { "type": "vcs", "url": "https://github.com/fourkitchens/context_active_trail.git" }, { "type": "composer", "url": "https://packages.drupal.org/8", "exclude": [ "drupal/context_active_trail" ] } ], "require": { "drupal/core": "^10.0.0", "drupal/context_active_trail": "dev-8.x-2.x", } }

It makes for a much cleaner project json, but now you’ve split the work into two locations, requiring some synchronization. However, if multiple sites of yours use this same module and need the same fixes, this absolutely has the least resistance and ability to get those changes out more quickly.

The pros:

• Reusability
• Two smaller, simpler chunks of work
• Any PHP developer should be able to debug this setup as it uses Composer best practices. This method will be used in any project with any framework in the PHP ecosystem.

The cons:

• Changes are in two separate places
• Which patches are applied isn’t obvious in the composer.json and require looking through the commit history on the forked repository
• Requires maintenance and synchronization when upgrades happen

Final thoughts

As with almost everything out there, there are multiple ways to achieve the same goal. I hope this brings awareness, and helps provide the flexibility you need when upgrading Drupal to a new major version. Obviously, each solution has strengths, and you may need to mix it up to get the results you want.

The post Using Composer for modules not ready for the next major version of Drupal appeared first on Four Kitchens.

Dear Readers,

"There's always room for a story that can transport people to another place."

—J.K. Rowling, Author of the Harry Potter Series.

Stories wield an irresistible charm, not merely as narratives to absorb but as potent wellsprings of inspiration. With their unique ability to engage, convey essential messages, and kindle our imagination, stories have been passed down through generations, nestled in books, or shared through diverse media. They possess the remarkable power to evoke emotions and offer insights that resonate across cultures.

Beyond mere entertainment, stories often carry valuable lessons, acting as a bridge to connect individuals and fostering a sense of wonder and empathy. Through the art of storytelling, individuals gain fresh perspectives, discover motivation, and shape their understanding of the world and their identities.

In the Drupal community, Dries Buytaert, the visionary founder of Drupal, extends a heartfelt invitation. He encourages members to share their personal stories, illustrating how Drupal has left an indelible mark on their lives and careers. This initiative underscores the power of stories in nurturing community, collaboration, and shared experiences within the Drupal ecosystem.

As J.K. Rowling aptly notes, there's always room for stories that transport us to new realms. Within the Drupal community, these stories serve as a bridge connecting individuals through the transformative impact of Drupal on their professional journeys.

So, what is your Drupal story? Share and become part of the collective narrative that defines the Drupal experience.

Let us look into last week's stories by The Drop Times.

Last week, The Drop Times published part one of the interview featuring Grzegorz Pietrzak, a seasoned Tech Lead at Droptica specializing in PHP, Drupal, and Symfony. Engaging in a profound discussion with Thomas Alias K, a former sub-editor at TDT, Pietrzak shared distinguished perspectives on various facets of Drupal, the dynamic role of Droopler in corporate website development, and his insights into constructing effective PHP teams.

The latest featured stories by our sub-editor, Alka Elizabeth, dive into notable happenings within the Drupal community. An insightful examination of challenges encountered in Drupal Distributions and Recipes Initiative takes center stage as contributor Jim Birch sheds light on a pertinent issue. This discovery catalyzes an ongoing initiative to address and overcome challenges associated with these essential elements of Drupal development.

Further contributing to Drupal's evolution, an adjustment was proposed by Alex Pott in response to issue #339889, which is set to bring about a significant change in the upcoming 10.2.x version of the Drupal core. This modification aims to streamline the configuration system, eliminating the need to list configuration in 'getEditableConfigNames()' when using '#config_target' in forms. The goal is to enhance the developer experience by simplifying processes and eliminating redundant configuration declarations.

Additionally, a substantial change in Drupal Core has been implemented in version 10.2.x. The widely recognized EntityReferenceTestTrait has undergone a renaming to EntityReferenceFieldCreationTrait. Behind this transformative modification is the dedicated effort of contributor Stephen Mustgrave, and it officially took effect on November 16, 2023.

DrupalCon Portland 2024 is currently seeking volunteers and summit contributors. Florida DrupalCamp 2024 is gearing up for its sixteenth annual event and searching for sponsors. The event will happen at the Florida Technical College in Orlando. If you're interested in sponsoring Florida DrupalCamp 2024 or would like to get more information about the event, including dates, available training sessions, and registration details, head nowhere else. Learn more about this weeks Drupal events here.

MidCamp, the Midwest Drupal Camp, has officially opened its call for session submissions for its 2024 event. Additionally, FOSDEM, the renowned free software event fostering collaboration and idea sharing within the open-source community, invites participation in presentations for its upcoming twenty-fourth edition scheduled for February 3rd and 4th, 2024.

Specbee published a blog exploring the significance of Drupal 10 Theming. Additionally, they are hosting a webinar titled "Getting Started with Drupal 10 Theming," scheduled for December 6, 2023.

The Acquia Engage conference ended discussions centered around experimentation and exploration. These emerging trends were featured in an article by Dom Nicastro. Discover the enhanced capabilities of the Drupal platform with the introduction of new features and improvements in Drupal 10.1. Dive deeper into these updates by reading the blog.

The digital landscape undergoes further evolution as PHP unveils its newest version, PHP 8.3. This latest iteration, packed with a myriad of enhancements and refinements, is poised to make a substantial impact on web development.

Lucio Waßill's demonstration on the Migrate Module provided valuable insights into establishing a demo-ready Drupal environment. The emphasis was on optimizing content creation processes by effectively utilizing the Migrate module.

Prepare for the imminent arrival of Drupal Gutenberg 3, as the beta version is now available for testing under Gutenberg 3.0.0-beta1. Users eager to integrate this update into Drupal 10 can seamlessly do so using Composer with the installation command. Revamp Drupal search boxes effortlessly with the Better Search Block: a user-friendly solution developed by 3C Web Services and maintained by Yogesh Pawar. This module stands out for its ability to enhance both the visual appeal and functionality of Drupal search boxes.

Dries Buytaert, the visionary behind Drupal, extends a heartfelt invitation to the Drupal community, encouraging individuals to share their personal narratives on Drupal's profound impact on their lives and careers.

Explore enhanced Drupal development efficiency by delving into the synergy between Visual Studio Code and DDEV in OSTraining's latest blog post. Gain practical insights into leveraging Visual Studio Code, a widely used and robust source-code editor, to streamline and optimize your Drupal development workflows. Droptica releases Drupal Website Maintenance Guide, a comprehensive e-book tailored for Drupal website owners seeking effective strategies for support, care, and maintenance.

So these are the highlights from TheDropTimes. Feel free to contact us with any suggestions, contributions, or feedback. Thank you for being a part of our community. Until the next edition, keep exploring, sharing, and embracing the power of knowledge! Follow us on LinkedIn, Twitter and Facebook.

Sincerely,

Elma John
Sub-editor, The DropTimes

Expert Help on Deck: The Importance of a Drupal Maintenance Service for Your Business kanapatrick Mon, 11/27/2023 - 11:11

In today's digital age, it is crucial for businesses to have a strong online presence. With the rise of content management systems like Drupal, companies are able to create and manage their websites with ease. However, as with any technology, regular maintenance is necessary to ensure the smooth functioning and security of your website. This is where a Drupal maintenance service comes in.

As health, wellness, and fitness organizations navigate the ever-evolving digital space, the need for a versatile content management system (CMS) has become increasingly important. Out of the many CMS, Drupal has emerged as a frontrunner for these organizations, offering an all-rounded suite of features that smoothly align with their specific requirements. 

In fact, did you know that some of the top health, wellness, and fitness giants like the American Heart Association, Mayo Clinic, National Cancer Institute, and YMCA rely on Drupal for healthcare solutions? 
 
In the preceding sections, let’s have a detailed look at some of the top reasons that make Drupal the best choice for health, wellness, and fitness organizations. 

We will also take a moment to highlight its ability to enhance online engagement, streamline content management, and cultivate a flourishing digital presence.

In the update effective from November 16, 2023, Drupal core has renamed EntityReferenceTestTrait to EntityReferenceFieldCreationTrait, enhancing code clarity and discoverability.

Drupal Recipes initiative, documented in issue #3390919, aims to enhance the user experience by introducing a mechanism that automatically reverts a site's configuration to its original state in case of validation errors during the application of distributions and recipes.

Building a Mobile App with Drupal as a Backend Editor Fri, 11/24/2023 - 10:00

Do you know that almost 90% of developers who use Drupal as a backend for their mobile apps have their stash, lucky coding socks? This is interesting because developers believe it allows them to work more efficiently.
We may have exaggerated about 90 percent, but building a mobile app development with Drupal as a backend is perfect. There are many reasons for this because Drupal as a tool has all the necessary features and capabilities to unleash the potential of the application fully and, of course, emphasize the skill of its creator. But how does it work?