Drupal 8 Updates and How to Help
Want help getting started in D8? Maybe you should check out Core contribution mentoring?
We are hard at work on the next version of Drupal. Some of the great things planned include better HTML5 and mobile support, improved multilingual features, and setting up Drupal 8 on a modern web development framework. But we can't do any of it without your help!
Planned timeline
The D8 team has been very hard at work to compile this information, and we have a googledoc that will be a bit more detailed than this image could provide. Keep an eye on Gabor's new website www.drupal8multilingual.org your one-stop-shop for info on D8MI.
VIEW DETAILED TIMELINE WITH LINKS TO ISSUES HERE!
More information on Drupal 8 dates.
Feature Freeze Extension Announcement
Core development structure
Drupal 8 is the first development cycle introducing so called Core initiatives. These are areas with named leads to improve Drupal core in certain areas. However, this does not limit core development to these main areas, there are many community initiatives as well. If you head a community initiative and want to get on this summary, contact Shannon Vettes.
Core initiatives status overview
| Initiative | Discovery | Design | Develop |
|---|---|---|---|
| Configuration Management |
|
|
|
| HTML5 |
|
|
|
| Layouts |
|
|
|
| Mobile |
|
|
|
| Multilingual |
|
|
|
Views in Core |
|
|
|
| Web Services |
|
|
|
D8 Plugin discovery
Plugin discovery is the process by which Drupal finds plugins of a given type. A discovery method must be set for every plugin type (explained in the plugin manager documentation).
The discovery component of plugins implements a DiscoveryInterface that defines the methods any discovery class must have.
<?php
/**
* @file
* Contains \Drupal\Component\Plugin\Discovery\DiscoveryInterface.
*/
namespace Drupal\Component\Plugin\Discovery;
/**
* Defines the plugin discovery interface.
*/
interface DiscoveryInterface {
/**
* Gets a specific plugin definition.
*
* @param string $plugin_id
* A plugin id.
*
* @return array
* A plugin definition.
*/
public function getPluginDefinition($plugin_id);
/**
* Gets the definition of all plugins for this type.
*
* @return array
* An array of configuration definitions.
*/
public function getPluginDefinitions();
}
?>There are three different core discovery types.
- StaticDiscovery
D8 Plugin types (plugin managers)
The plugin manager is the central controlling class that defines how the plugins of a particular type will be discovered and instantiated. This class is called directly in any module wishing to invoke a plugin type.
This documentation will require an understanding of PSR-0.
Defining the Plugin Manager
There are only two requirements for defining a new plugin manager:
- You must define a discovery method.
- You must define a factory.
Everything else within the plugin system is situational and based upon your use case. For this plugin type, we will use the hook discovery and the default factory.
<?php
namespace Drupal\components\Plugin\Manager;
use Drupal\Component\Plugin\PluginManagerBase;
use Drupal\Core\Plugin\Discovery\HookDiscovery;
use Drupal\Component\Plugin\Factory\DefaultFactory;
/**
* Defines the plugin manager for Components plugins.
*/
class ComponentsPluginManagerBase extends PluginManagerBase {
/**
* Constructs a new Components plugin manager object.
*/
public function __construct() {
$this->discovery = new HookDiscovery('component_info');
$this->factory = new DefaultFactory($this);
}
}
?>Plugin API in Drupal 8
Why plugins?
TBD [see comment]
Overview:
The D8 plugin system provides a set of guidelines and reusable code components to allow developers to expose pluggable components within their code and (as needed) support managing these components through the user interface. The plugin system has three base elements:
-
Plugin Types
The plugin type is the central controlling class that defines how the plugins of this type will be discovered and instantiated. The type will describe the central purpose of all plugins of that type; e.g. cache backends, image actions, blocks, etc.
-
Plugin Discovery
Plugin Discovery is the process of finding plugins within the available code base that qualify for use within this particular plugin type's use case.
-
Plugin Factory
The Factory is responsible for instantiating the specific plugin(s) chosen for a given use case.
