Planet Drupal

Subscribe to Planet Drupal feed - aggregated feeds in category Planet Drupal
Updated: 5 hours 13 min ago

Third & Grove: Benefit Cosmetics Drupal Case Study

25 January 2017 - 12:00am
Benefit Cosmetics Drupal Case Study antonella Wed, 01/25/2017 - 03:00
Categories: Drupal Redis, now for long-term keys and values

24 January 2017 - 5:00pm

Redis is a popular key-value database, well-regarded for its speed and simplicity. has offered a Redis service for quite some time, which is configured not to store data but to keep it only in memory. That makes it an excellent choice for a cache server, and we recommend that configuration for most projects.

Of course, Redis can do far more than caching. And we’re therefore happy to report we now offer a persistent configuration of Redis, too.

Categories: Drupal

Drupal Modules: The One Percent: Drupal Modules: The One Percent — Holmes (video tutorial)

24 January 2017 - 4:35pm
Drupal Modules: The One Percent — Holmes (video tutorial) NonProfit Tue, 01/24/2017 - 18:35 Episode 16

Here is where we bring awareness to Drupal modules running on less than 1% of reporting sites. Today we'll consider Holmes, a module which highlights potentially invalid, inaccessible or erroneous markup.

Categories: Drupal blog: What’s new on - December 2016

24 January 2017 - 4:04pm

Read our Roadmap to understand how this work falls into priorities set by the Drupal Association with direction and collaboration from the Board and community.

Our December update comes to you a bit later than our usual monthly posts, for all the usual practical reasons: holidays, vacations, and our staff retreat in early January. But also, because we've been reflecting on the past year, and planning for the year to come. You'll soon hear about our initiatives for 2017, but for now— let's dive into what we did in December. updates DrupalCon Baltimore

At the beginning of December we launched the full site for DrupalCon Baltimore, which is coming up April 24-28. For the first time, we launched the full event site including the call for papers, scholarship applications, and registration all on the same day.

Early bird pricing is available for a limited time, so we encourage you to register today.

Stable release of the Composer Façade's support for Composer has been in development since the beginning of last year. We released the public alpha of our composer endpoints at DrupalCon New Orleans, and then entered beta over the course of this past summer. After a period of feedback, bug fixes, and further refinement with the help of core and contrib developers we announced the stable release of's composer support on December 21st.

We'd like to thank the following community members for their help with this initiative: seldeak, webflo, timmillwood, dixon_, badjava, cweagans, tstoeckler, and mile23. We'd also like to thank Appnovation for sponsoring our initial Composer support work.

Improved messaging for new users

One of the innovations of's online community that we introduced about 2 years ago, is the process by which new users get confirmed by trusted users. As a user of, you know that when you see a new user with a 'confirm' button under their user icon, you can check their recent activity and help confirm for us that they're a real user (not a bot or spammer who managed to slip through).

However, we received some feedback from recently registered users, that this process was too opaque. New users did not have enough guidance to understand that they can only perform a sub-set of site activities until another user confirms them.

After hearing this feedback, we spent some time in December improving the messaging tonew users when they first sign up on— so they can better understand how to become confirmed.

DrupalCI refactored and updated to use composer

In December we also completed a refactor of DrupalCI and updated the testing system to use Composer when testing Drupal. This means we can now test projects with external composer dependencies on Other new features and bugfixes include: more available test artifacts; dependency changes can now be submitted in patches to composer json; the test runner produces a build file that can be downloaded and run locally to re-execute any test verbatim. There are more added features as well..

This work has continued into January, particularly around making more testing environments available, and adding new test types (such as code sniffer). Look for additional updates in the upcoming January report.

Special thanks to mile23 for collaborating with us on this work.

Jenkins upgraded to better manage our EC2 Instances

The cost of automated testing for the Drupal project is a significant expense for the Drupal Association. In December we updated Jenkins and several of the plugins that are used to orchestrate the creation and management of DrupalCI testbots, and now our enforcement of instance limits is much more reliable. In December this saved us nearly 50% on our testing bill, without a significant increase in testing wait times. In January we are projecting a similar savings.

The work of community member fabianX might also provide similar savings for the project, so we encourage contributors involved in core to help review: #2759197: [D7] Improve WebTestCase performance by 50% and #2747075: [meta] Improve WebTestCase / BrowserTestBase performance by 50%

HTTP/2 Support enabled

HTTP/2 is the next generation network protocol that decreases latency in page loads by using better data compression, pipelining, and server push. In December we enabled HTTP/2 support for, improving performance for all users with modern browsers that support the standard.

Community Initiatives Preparing for the Project Applications Revamp

In November the Drupal 8 User Guide went live, so in December we prepared for the next community initiative on our roadmap - the Project Application Revamp. Over the course of the last several months we've been doing pre-work around this initiative to ensure that the appropriate signals about security advisory coverage and recommended releases are provided on project pages. This pre-work will help ensure that Drupal users still have good signals to project quality, even as we open up the creation of full projects.

Initiatives need your help

Are you a power user who relies on Dreditor? Markcarver is currently leading the charge to port Dreditor features to, and invites anyone interested in contributing to join him in #dreditor on freenode IRC or the Dreditor GitHub.

Is the written word your domain? Consider putting your skills to use by becoming a maintainer of Drupal documentation. If you are a developer interested in contributing code to the new documentation system, please contact tvn.


As always, we’d like to say thanks to all the volunteers who work with us, and to the Drupal Association Supporters, who made it possible for us to work on these projects.

If you would like to support our work as an individual or an organization, consider becoming a member of the Drupal Association.

Follow us on Twitter for regular updates: @drupal_org, @drupal_infra

Categories: Drupal

Aten Design Group: User Personas: Drupal 8 Permissions Done Right

24 January 2017 - 1:54pm

Nearly a year ago, I wrote a blog called "Drupal Permissions Done Right". I received a lot of excellent feedback and at the end of it I promised to release a module which would make managing permissions in Drupal 8 more sane based on the principles the post outlined. Today, I'd like to announce that module and explain a little bit about it.

Where Drupal Permissions Fall Short

Before I explain the module, we should explain the problem it tries to solve. I think the Drupal community has been mis-configuring our permissions for years. We look at the site we're building and realize that we have a few core personas, like "journalist" or "editor" and we make Drupal roles that match those business titles. This means that we often need to duplicate permissions across roles and it quickly becomes difficult to tweak, debug, and extend these roles when business requirements change.

The original blog post I wrote encourages you to instead make many small, discrete roles which can be composed together into the business "roles" we have. Doing so removes the need to duplicate permissions and means that we no longer need to be concerned with every single permission for every single role type we have. I think Drupal core exacerbates the problem by exposing newcomers to the default "Content Editor" role, which does far more than just "edit content".

The strategy of making many small, composable roles works out of the box with Drupal—but it requires that we assign lots of roles to every user individually. To make site administration easier, we really would like to bundle permissions into high level names like "journalist" or "intern" when building a site. So, how do we reconcile the need for easy-to-understand roles with the efficiency of small, composable roles?

Drupal Permissions Simplified: User Personas

Enter the User Personas module. It's a simple module layered on top of Drupal's permissions and roles system.

Personas are a lot like Drupal's roles, they're just one level higher. They allow you to bundle roles together and then assign those bundles of roles to users as a set. Under the hood, the module just saves the appropriate roles to the user entity when the user is saved and so it works just fine with contrib and core. To all other code, nothing is different, they can continue to use permissions and roles as if personas don't exist at all (in fact, your code should too).

To give you a simple use case as an example: we have been working with the National Center for Women & Information Technology (NCWIT) to build an event planning and management platform called AspireIT. The application lets young women and girls host extracurricular events (called programs) to teach a new generation of girls about coding and technology. These young women from all over the country partner with adults in the tech industry to run their programs. When building the application, we imagined these users falling into two personas: Program Leader (the young woman creating the event), and Program Partner (the adult providing financial or practical support).

The process of creating and managing a program needed to be a collaborative effort between Program Leaders and Program Partners. This meant that many of their permissions would be the same, but they did differ in subtle ways. One major difference was that a Program Partner shouldn’t be able to create programs—they join the process after a Program Leader gets things started. However, they should be allowed to edit the program node along the way.

I used the User Personas module to create a persona for each of these user types: Program Leader and Program Partner. I then created two Drupal roles, a Program Creator role and a Program Editor role. I could assign the Program Editor role to both personas while assigning the Program Creator role to the Program Leader persona alone. This way I’ll rarely (if ever) need to duplicate permissions across roles, instead permissions are simply shared by sharing roles between User Personas.

I’ve used this module in a few projects so far, and the User Personas abstraction seems to hold across different use cases. I don't think I'll go back to doing permissions any other way.

The User Personas module is still in alpha and I'd love for you to download it and take it for a spin. If you do, please use the issue queue to make suggestions for where it can be improved (and maybe submit a patch! 😉) and, of course, report any bugs. There are still a couple of opportunities for improvement, for example, once you create many roles the performance of the global permissions page starts to degrade rapidly (the performance of the rest of the site is unaffected). Frankly, I'd like to rethink the need for the permissions table altogether, as it seems to discourage small, discrete roles. But before doing something so drastic, I'd like others' input. I wouldn't want users of the module to be frightened off because it appears to change the way core operates.

I hope that you find the module useful. So, please download it, install it, and let me know what you think!

Categories: Drupal Drupal Developer's blog: Form API #states: dependent fields

24 January 2017 - 1:49pm
Drupal provides a powerfull API for building different kind of forms. One of the most cool thing in this API, I think, it's a #states feature. It allows developers to create form elements that can change their state depending on some conditions. For instance you can create a text input which will be visible only if checkbox is checked. Or even make multiple conditions for an element.
Read more »
Categories: Drupal

Acquia Developer Center Blog: Drupal 8 Module of the Week: SEO Checklist

24 January 2017 - 12:51pm

This week: SEO Checklist // Drupal 8 has more and more features available practically every day. Alongside module migrations and new projects, the Drupal community’s latest major release also offers new ways of solving common problems. Some functionality has moved to Drupal core and new modules have taken up the torch along the way. In this series, the Acquia Developer Center is profiling useful solutions--modules, themes, distros, and more--available for Drupal 8.

Tags: acquia drupal planetseo
Categories: Drupal

LakeDrops Drupal Consulting, Development and Hosting: Avoid self-definition in taxonomy term description when using the Onomasticon module

24 January 2017 - 11:08am
Avoid self-definition in taxonomy term description when using the Onomasticon module Richard Papp Tue, 01/24/2017 - 20:08 The

The enterprise OpenSource content management system which is available for free at where you can find all the details and also references.

Drupal has a very active community with tens of thousands of developers all around the world and they also have a huge focus on standard compliance and on security.


What's known as plugin or addon in other platforms, is what we call a module in the Drupal universe. Drupal core itself is a a collection of modules as well and the community has added and maintains tens of thousands of individual modules on top of that.

Onomasticon automatically displays the definition of taxonomy terms everywhere a term is used. However, you may want to avoid self-definition on the term's own page as its description is already visible without it.
Categories: Drupal

Dries Buytaert: Acquia a leader in the 2017 Forrester Wave for Web Content Management Systems

24 January 2017 - 8:17am

Today Acquia was named a leader in the The Forrester Wave: Web Content Management Systems, Q1 2017. This report is especially exciting because for the first time ever Acquia was recognized as the leader for strategy and vision, ahead of every other vendor including Adobe and Sitecore.

I take great pride in Acquia's vision and strategy. As I wrote in my 2016 retrospective, I believe that the powerful combination of open source and cloud has finally crossed the chasm, and will continue to drive change in our industry.

Today, cloud is the starting point for any modern digital experience project, but this wasn't always the case. Acquia was one of the first organizations to explore Amazon Web Services in 2008 and to to launch a commercial cloud product in 2009. At the time that was a bold move, but we have always seen the cloud as the best way to provide our customers with the necessary tools to build, deploy and manage Drupal.

Since its founding, Acquia has helped set the standard for cloud-based delivery of web content management. This year's Forrester report shows that many of our competitors are only now introducing a cloud delivery platform. Acquia's eight year commitment to the cloud is one of the reasons why we were deemed the leading vendor for strategy.

Second, organizations can no longer afford to ignore open source software. Acquia is the only open source leader in both the Forrester Wave and the Gartner Magic Quadrant for Web Content Management. There are a lot of inherent benefits to open source software, including speed of innovation, cost, quality, security and more. But the thing that really sets open source apart is freedom. This extends to many different users: for developers freedom means there are no limitations on integrations; for designers that means creative freedom, and for organizations that means freedom from vendor lock-in.

In addition to our commitment to open source and cloud, Forrester also highlighted Acquia's focus on APIs. This includes our many contributions to Drupal 8's API-first initiative, but it also includes our APIs for Acquia Cloud, Acquia Cloud Site Factory and Acquia Lift. APIs are important because they enable organizations to build more ambitious digital experiences. With Open APIs, organizations can use our software in the way they choose and integrate with different technology solutions.

This is why Acquia's solution -- using open source, cloud, and open APIs -- is so powerful: it prepares organizations for the current and evolving demands of digital experience delivery by allowing them to innovate faster than traditional solutions.

Thank you to everyone who contributed to this result! It's another great milestone for Acquia and Drupal.

Categories: Drupal

Acquia Developer Center Blog: Drupal 8 Beginner Class Approaches One Million Views

24 January 2017 - 7:57am

Late in 2015, just before the release of Drupal 8, a company called OSTraining approached Acquia for help in funding a Kickstarter project.

The goal of the Kickstarter was to make sure that as many people as possible can use Drupal 8. Their method was to publish free, high-quality Drupal 8 training on YouTube.

Acquia decided to sponsor the The Drupal 8 Beginner Class, which consists of 60 video tutorials.

Tags: acquia drupal planet
Categories: Drupal

InternetDevels: The benefits of Drupal 8 for your business

24 January 2017 - 7:44am

As an experienced Drupal development company, we can estimate all Drupal’s features, basing on our experience. This CMS accommodates to the modern world’s needs and becomes more and more up-to-date. We are amused by its latest release, and want to share our amusement with you.

Read more
Categories: Drupal

Drupalize.Me: An Insider's Look at Proposing a Session for DrupalCon

24 January 2017 - 6:00am

The 2017 DrupalCon North America will take place in Baltimore, Maryland from April 24-28. The call for session proposals is quickly coming to a close with a deadline of February 1, 2017. Get some tips for submitting a session proposal and an insider's look at what it's like to be a session track chair from Drupalize.Me trainers Joe Shindelar and Amber Matz.

Categories: Drupal Blog: AGILEDROP: Global Drupal Sprint Weekend

24 January 2017 - 1:16am
Drupal Global Sprint Weekend will this year happen at the end of this week, on 28th and 29th January, almost all over the world. Small local sprints will be in a shape of sprint meetups, sprint camp sessions, mini-sprints, wind-sprints and all-day sprints. You can participate, so make sure you find the right location for yourself. We'll help you find it with this blog post. But if you live near Slovenia, sprint in our office in Ljubljana will be just what you need. In case you don't know what sprints are, let us refresh your memories. Code sprints are getting developers for a day or two for… READ MORE
Categories: Drupal

Web Omelette: Render custom entity form modes programatically in Drupal 8

24 January 2017 - 12:00am

Drupal 8 comes with a funky new feature that allows admins and editors to customize entity forms in more than one variant. That means they can have, for different purposes, different form modes that feature different fields, with different form display configuration, etc. Nice, right?

Although you can do this in Drupal 8, not much use has yet been made of these form modes. So if you create a form mode, you cannot easily render it. Even more so, Drupal core doesn't actually make use of them.

In this article we will, however, look at how we can programatically render entity forms which use a form mode that had been created by an admin in the UI. First though, how do we render a regular entity form in Drupal 8?

Regular entity forms $form = \Drupal::service('entity.form_builder')->getForm($entity);

$form is now a renderable array for the entity passed to the getForm() method of the EntityFormBuilder service. The entity itself can be an existing one (which will show you the edit form with values pre-filled) or a new one you just created programatically.

It's that simple.

The EntityFormBuilder::getForm() method takes a second parameter though, namely $operation. Apart from the variable name, this reminds me of how an entity itself is rendered, the second parameter to the build method being a view mode. So you'd expect in this case $operation to be a form mode, right? Well, wrong. Ish.

When an entity is defined, for example Node, under the handlers key of the annotation we have some form handlers defined. Those are what the $operation parameter expects. So for example, if we want the delete form of the Node entity, we pass delete and we get a different form. Otherwise, we fallback to the default one which is used for create/edit (although we can also specify edit but it maps to the same class anyway).

Custom form modes

Continuing with the Node example, the entity type defines three handlers (operations): default, delete, edit. That is not a lot. Other entity types can define more or less and can be differently named.

So if we create a form mode in the UI, whose machine name ends up being create_editors (for example), how do we go about rendering the entity form for nodes using that form mode? Passing that machine name as the second parameter by itself won't do the trick because the Node entity has not defined that handler, and more importantly, it doesn't map to an actual form class.

To fix this, we can alter the entity definition and add our own form handler named as our custom form mode, mapped to the default Form class of the Node entity. Here is a snippet of code, sprinkled with explanatory comments, that takes care of our Node entity for a custom form mode called create_editors:

/** * Implements hook_entity_type_alter(). */ function example_module_entity_type_alter(array &$entity_types) { // We get all form modes, for all entities, and loop through them. $form_modes = \Drupal::service('entity_display.repository')->getAllFormModes(); foreach ($form_modes as $entity_type => $display_modes) { if ($entity_type !== 'node') { // We are only interested in adding a handler to the Node entity. continue; } $node_type = $entity_types[$entity_type]; foreach ($display_modes as $machine_name => $form_display) { if ($machine_name !== 'editors_create') { // We are only interested in adding this form mode to the definition. continue; } // We get the default handler class. It will be enough for us. $default_handler_class = $node_type->getHandlerClasses()['form']['default']; // We set the form class, keyed by the machine name of our custom form mode. $node_type->setFormClass($machine_name, $default_handler_class); } } }

So basically, we are supplementing the Node form handlers with a new one called editors_create which maps to the default form class, in this case Drupal\node\NodeForm. The form class itself is not so important because after it is built, if there is a form mode with that name, it will be used to override the default form with all the configuration of that form mode. So building our node form with our custom form mode would now go like this:

$form = \Drupal::service('entity.form_builder')->getForm($entity, 'editors_create');

And that is pretty much it. Of course you can loop through all the entity types and add all form modes if you want. But I always like to inject my custom functionality only to the extent I need, touching as little as possible.

Let me know how this works for you.

Categories: Drupal

DrupalCon News: Anatomy of a DrupalCon Session

23 January 2017 - 1:59pm

The Front End, being the web’s sensory interface, I’d like to offer this anatomy lesson to encourage those who aspire to take the stage at DrupalCon Baltimore.

Categories: Drupal

Appnovation Technologies: Better Accessibility in Drupal 8 is Great News for All Users

23 January 2017 - 1:44pm

Accessibility should be a key requirement for any website project. Unfortunately, it is often regarded as an add-on with low priority for most businesses and developers. The biggest mistake is assuming that the proportion of people with accessibility requirements is low and insignificant, and that focus on accessibility will only help a 'tiny' subset of users. However, this is definitely not the case, and ignoring accessibility is missing an opportunity for all of your users.

Categories: Drupal

Drupal Modules: The One Percent: Drupal Modules: The One Percent — Node Class (video tutorial)

23 January 2017 - 10:50am
Drupal Modules: The One Percent — Node Class (video tutorial) NonProfit Mon, 01/23/2017 - 12:50 Episode 15

Here is where we bring awareness to Drupal modules running on less than 1% of reporting sites. Today we'll wonder where the .page-node-[nid] body class went in D8 and investigate Node Class, a module which allows you to add classes to your nodes through the UI.

Categories: Drupal Rerunning update hooks in D8

23 January 2017 - 9:48am

Note: there be dragons here... read all the way through before trying this.

When I'm writing an update_hook for a module I'm working on I often need to run it multiple times in order to get it working just right. In Drupal 7 I had a little trick where I would run my updates and then reset the schema version of my module  directly in the database and then run my updates again. I'd rinse and repeat until everything worked as desired.

Categories: Drupal

Palantir: New Years Resolution: Staying Fit and Healthy

23 January 2017 - 9:42am
New Years Resolution: Staying Fit and Healthy brandt Mon, 01/23/2017 - 11:42 Allison Manley Jan 23, 2017

In this five-part series, every Monday in January we’ll explore a New Year’s resolution and how it can apply to your web project.

We want to make your project a success.

Let's Chat.

Need to tone those arms? Or lose those pesky five pounds from all the holiday indulgences? Perhaps your website is suffering from a bit of bloat as well, and could use a bit of a tune up. We have some ideas on how to keep your website in top shape over the coming year.

Even a website needs a trip to the gym now and then to get back in shape. Next week’s resolution: enjoy life to the fullest.

Let Palantir help get your site in great shape.

Stay connected with the latest news on web strategy, design, and development.

Sign up for our newsletter.
Categories: Drupal

Acquia Developer Center Blog: Building Your Platform and Governance Plan for Acquia Site Factory

23 January 2017 - 9:16am

Acquia Cloud Site Factory (ACSF) makes creating, managing, and deploying hundreds of content-rich sites fast and hassle free. ACSF’s powerful toolset allows non-technical teams to easily create and manage new sites that form the moving pieces in an organization’s strategy.

Tags: acquia drupal planet
Categories: Drupal