opdavies/drupalcampbristol
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Core and composer updates

Browse source
This commit is contained in:
Rob Davies 2017-07-03 16:47:07 +01:00
parent a82634bb98
commit 62cac30480
1118 changed files with 21770 additions and 6306 deletions
Download patch file Download diff file Expand all files Collapse all files

12
web/core/modules/outside_in/css/offcanvas.css → web/core/modules/outside_in/css/off-canvas.css
View file

@ -1,23 +1,23 @@
/**
* @file
* CSS for Offcanvas tray.
* CSS for off-canvas dialog.
*
* @todo Move CSS into core dialog library https://www.drupal.org/node/2784443.
*/
/* Position the dialog-offcanvas tray container outside the right of the viewport. */
.ui-dialog-offcanvas {
/* Position the off-canvas dialog container outside the right of the viewport. */
.ui-dialog-off-canvas {
box-sizing: border-box;
height: 100%;
overflow: visible;
}
/* Wrap the form that's inside the dialog-offcanvas tray. */
.ui-dialog-offcanvas .ui-dialog-content {
/* Wrap the form that's inside the off-canvas dialog. */
.ui-dialog-off-canvas .ui-dialog-content {
padding: 0 20px;
/* Prevent horizontal scrollbar. */
overflow-x: hidden;
overflow-y: auto;
}
[dir="rtl"] .ui-dialog-offcanvas .ui-dialog-content {
[dir="rtl"] .ui-dialog-off-canvas .ui-dialog-content {
text-align: right;
}

10
web/core/modules/outside_in/css/offcanvas.motion.css → web/core/modules/outside_in/css/off-canvas.motion.css
View file

@ -1,6 +1,6 @@
/**
* @file
* Motion effects for off-canvas tray dialog.
* Motion effects for off-canvas dialog.
*
* Motion effects are in a separate file so that they can be easily turned off
* to improve performance if desired.
@ -10,22 +10,22 @@
* file: https://www.drupal.org/node/2784443.
*/
/* Transition the dialog-offcanvas tray container, with 2s delay to match main canvas speed. */
.ui-dialog-offcanvas .ui-dialog-content {
/* Transition the off-canvas dialog container, with 2s delay to match main canvas speed. */
.ui-dialog-off-canvas .ui-dialog-content {
-webkit-transition: all .7s ease 2s;
-moz-transition: all .7s ease 2s;
transition: all .7s ease 2s;
}
@media (max-width: 700px) {
.ui-dialog-offcanvas .ui-dialog-content {
.ui-dialog-off-canvas .ui-dialog-content {
-webkit-transition: all .7s ease;
-moz-transition: all .7s ease;
transition: all .7s ease;
}
}
.dialog-offcanvas__main-canvas {
.dialog-off-canvas__main-canvas {
-webkit-transition: all .7s ease;
-moz-transition: all .7s ease;
transition: all .7s ease;

2
web/core/modules/outside_in/css/outside_in.module.css
View file

@ -27,7 +27,7 @@
* to expand dialog widths.
*/
@media all and (max-width: 48em) { /* 768px */
.ui-dialog.ui-dialog-offcanvas {
.ui-dialog.ui-dialog-off-canvas {
width: 100% !important;
}
/* When tray is at 100% width stop the body from scrolling */

6
web/core/modules/outside_in/css/outside_in.motion.css
View file

@ -19,9 +19,9 @@
}
/* Transition the editables on the page, their contextual links and their hover states. */
.dialog-offcanvas__main-canvas .contextual,
.dialog-offcanvas__main-canvas .js-outside-in-edit-mode .outside-in-editable,
.dialog-offcanvas__main-canvas.js-tray-open .js-outside-in-edit-mode .outside-in-editable {
.dialog-off-canvas__main-canvas .contextual,
.dialog-off-canvas__main-canvas .js-outside-in-edit-mode .outside-in-editable,
.dialog-off-canvas__main-canvas.js-tray-open .js-outside-in-edit-mode .outside-in-editable {
-webkit-transition: all .7s ease;
-moz-transition: all .7s ease;
transition: all .7s ease;

8
web/core/modules/outside_in/css/outside_in.theme.css
View file

@ -60,16 +60,16 @@
}
/* Style the editables while in edit mode. */
.dialog-offcanvas__main-canvas.js-outside-in-edit-mode .outside-in-editable {
.dialog-off-canvas__main-canvas.js-outside-in-edit-mode .outside-in-editable {
outline: 1px dashed rgba(0,0,0,0.5);
box-shadow: 0 0 0 1px rgba(255,255,255,0.7);
}
.dialog-offcanvas__main-canvas.js-outside-in-edit-mode .outside-in-editable:hover,
.dialog-offcanvas__main-canvas.js-outside-in-edit-mode .outside-in-editable.outside-in-active-editable {
.dialog-off-canvas__main-canvas.js-outside-in-edit-mode .outside-in-editable:hover,
.dialog-off-canvas__main-canvas.js-outside-in-edit-mode .outside-in-editable.outside-in-active-editable {
background-color: rgba(0,0,0,0.2);
}
/* Style the dialog-offcanvas container. */
/* Style the dialog-off-canvas container. */
.ui-dialog-outside-in {
background: #444;
border: 0 solid transparent;

34
web/core/modules/outside_in/js/offcanvas.js → web/core/modules/outside_in/js/off-canvas.js
View file

@ -22,7 +22,7 @@
*/
var edge = document.documentElement.dir === 'rtl' ? 'left' : 'right';
var $mainCanvasWrapper = $('[data-offcanvas-main-canvas]');
var $mainCanvasWrapper = $('[data-off-canvas-main-canvas]');
/**
* Resets the size of the dialog.
@ -51,7 +51,7 @@
$element
.dialog('option', adjustedOptions)
.trigger('dialogContentResize.offcanvas');
.trigger('dialogContentResize.off-canvas');
}
/**
@ -64,7 +64,7 @@
var $element = event.data.$element;
var $widget = $element.dialog('widget');
var $offsets = $widget.find('> :not(#drupal-offcanvas, .ui-resizable-handle)');
var $offsets = $widget.find('> :not(#drupal-off-canvas, .ui-resizable-handle)');
var offset = 0;
var modalHeight;
@ -112,25 +112,25 @@
attach: function () {
$(window).once('off-canvas').on({
'dialog:aftercreate': function (event, dialog, $element, settings) {
if ($element.is('#drupal-offcanvas')) {
if ($element.is('#drupal-off-canvas')) {
var eventData = {settings: settings, $element: $element};
$('.ui-dialog-offcanvas, .ui-dialog-offcanvas .ui-dialog-titlebar').toggleClass('ui-dialog-empty-title', !settings.title);
$('.ui-dialog-off-canvas, .ui-dialog-off-canvas .ui-dialog-titlebar').toggleClass('ui-dialog-empty-title', !settings.title);
$element
.on('dialogresize.offcanvas', eventData, debounce(bodyPadding, 100))
.on('dialogContentResize.offcanvas', eventData, handleDialogResize)
.on('dialogContentResize.offcanvas', eventData, debounce(bodyPadding, 100))
.trigger('dialogresize.offcanvas');
.on('dialogresize.off-canvas', eventData, debounce(bodyPadding, 100))
.on('dialogContentResize.off-canvas', eventData, handleDialogResize)
.on('dialogContentResize.off-canvas', eventData, debounce(bodyPadding, 100))
.trigger('dialogresize.off-canvas');
$element.dialog('widget').attr('data-offset-' + edge, '');
$(window)
.on('resize.offcanvas scroll.offcanvas', eventData, debounce(resetSize, 100))
.trigger('resize.offcanvas');
.on('resize.off-canvas scroll.off-canvas', eventData, debounce(resetSize, 100))
.trigger('resize.off-canvas');
}
},
'dialog:beforecreate': function (event, dialog, $element, settings) {
if ($element.is('#drupal-offcanvas')) {
if ($element.is('#drupal-off-canvas')) {
$('body').addClass('js-tray-open');
// @see http://api.jqueryui.com/position/
settings.position = {
@ -138,18 +138,18 @@
at: edge + ' top',
of: window
};
settings.dialogClass += ' ui-dialog-offcanvas';
settings.dialogClass += ' ui-dialog-off-canvas';
// Applies initial height to dialog based on window height.
// See http://api.jqueryui.com/dialog for all dialog options.
settings.height = $(window).height();
}
},
'dialog:beforeclose': function (event, dialog, $element) {
if ($element.is('#drupal-offcanvas')) {
if ($element.is('#drupal-off-canvas')) {
$('body').removeClass('js-tray-open');
// Remove all *.offcanvas events
$(document).off('.offcanvas');
$(window).off('.offcanvas');
// Remove all *.off-canvas events
$(document).off('.off-canvas');
$(window).off('.off-canvas');
$mainCanvasWrapper.css('padding-' + edge, 0);
}
}

33
web/core/modules/outside_in/js/outside_in.js
View file

@ -9,7 +9,7 @@
var blockConfigureSelector = '[data-outside-in-edit]';
var toggleEditSelector = '[data-drupal-outsidein="toggle"]';
var itemsToToggleSelector = '[data-offcanvas-main-canvas], #toolbar-bar, [data-drupal-outsidein="editable"] a, [data-drupal-outsidein="editable"] button';
var itemsToToggleSelector = '[data-off-canvas-main-canvas], #toolbar-bar, [data-drupal-outsidein="editable"] a, [data-drupal-outsidein="editable"] button';
var contextualItemsSelector = '[data-contextual-id] a, [data-contextual-id] button';
var quickEditItemSelector = '[data-quickedit-entity-id]';
@ -111,10 +111,10 @@
}
/**
* Closes/removes offcanvas.
* Closes/removes off-canvas.
*/
function closeOffCanvas() {
$('.ui-dialog-offcanvas .ui-dialog-titlebar-close').trigger('click');
$('.ui-dialog-off-canvas .ui-dialog-titlebar-close').trigger('click');
}
/**
@ -124,6 +124,9 @@
* True enable edit mode, false disable edit mode.
*/
function setEditModeState(editMode) {
if (!document.querySelector('[data-off-canvas-main-canvas]')) {
throw new Error('data-off-canvas-main-canvas is missing from outside-in-page-wrapper.html.twig');
}
editMode = !!editMode;
var $editButton = $(toggleEditSelector);
var $editables;
@ -135,7 +138,7 @@
$editables = $('[data-drupal-outsidein="editable"]').once('outsidein');
if ($editables.length) {
// Use event capture to prevent clicks on links.
document.querySelector('[data-offcanvas-main-canvas]').addEventListener('click', preventClick, true);
document.querySelector('[data-off-canvas-main-canvas]').addEventListener('click', preventClick, true);
// When a click occurs try and find the outside-in edit link
// and click it.
@ -152,7 +155,7 @@
$(quickEditItemSelector)
.not(contextualItemsSelector)
.on('click.outsidein', function (e) {
// For all non-contextual links or the contextual QuickEdit link close the off-canvas tray.
// For all non-contextual links or the contextual QuickEdit link close the off-canvas dialog.
if (!$(e.target).parent().hasClass('contextual') || $(e.target).parent().hasClass('quickedit')) {
closeOffCanvas();
}
@ -168,7 +171,7 @@
else {
$editables = $('[data-drupal-outsidein="editable"]').removeOnce('outsidein');
if ($editables.length) {
document.querySelector('[data-offcanvas-main-canvas]').removeEventListener('click', preventClick, true);
document.querySelector('[data-off-canvas-main-canvas]').removeEventListener('click', preventClick, true);
$editables.off('.outsidein');
$(quickEditItemSelector).off('.outsidein');
}
@ -212,19 +215,19 @@
$(toggleEditSelector).once('outsidein').on('click.outsidein', toggleEditMode);
var search = Drupal.ajax.WRAPPER_FORMAT + '=drupal_dialog';
var replace = Drupal.ajax.WRAPPER_FORMAT + '=drupal_dialog_offcanvas';
// Loop through all Ajax links and change the format to dialog-offcanvas when
var replace = Drupal.ajax.WRAPPER_FORMAT + '=drupal_dialog_off_canvas';
// Loop through all Ajax links and change the format to dialog-off-canvas when
// needed.
Drupal.ajax.instances
.filter(function (instance) {
var hasElement = instance && !!instance.element;
var rendererOffcanvas = false;
var wrapperOffcanvas = false;
var rendererOffCanvas = false;
var wrapperOffCanvas = false;
if (hasElement) {
rendererOffcanvas = $(instance.element).attr('data-dialog-renderer') === 'offcanvas';
wrapperOffcanvas = instance.options.url.indexOf('drupal_dialog_offcanvas') === -1;
rendererOffCanvas = $(instance.element).attr('data-dialog-renderer') === 'off_canvas';
wrapperOffCanvas = instance.options.url.indexOf('drupal_dialog_off_canvas') === -1;
}
return hasElement && rendererOffcanvas && wrapperOffcanvas;
return hasElement && rendererOffCanvas && wrapperOffCanvas;
})
.forEach(function (instance) {
// @todo Move logic for data-dialog-renderer attribute into ajax.js
@ -243,7 +246,7 @@
// Manage Active editable class on opening and closing of the dialog.
$(window).on({
'dialog:beforecreate': function (event, dialog, $element, settings) {
if ($element.is('#drupal-offcanvas')) {
if ($element.is('#drupal-off-canvas')) {
$('body .outside-in-active-editable').removeClass('outside-in-active-editable');
var $activeElement = $('#' + settings.outsideInActiveEditableId);
if ($activeElement.length) {
@ -253,7 +256,7 @@
}
},
'dialog:beforeclose': function (event, dialog, $element) {
if ($element.is('#drupal-offcanvas')) {
if ($element.is('#drupal-off-canvas')) {
$('body .outside-in-active-editable').removeClass('outside-in-active-editable');
}
}

2
web/core/modules/outside_in/outside_in.libraries.yml
View file

@ -23,7 +23,7 @@ drupal.outside_in:
drupal.off_canvas:
version: VERSION
js:
js/offcanvas.js: {}
js/off-canvas.js: {}
dependencies:
- core/jquery
- core/drupal

2
web/core/modules/outside_in/outside_in.links.contextual.yml
View file

@ -1,4 +1,4 @@
outside_in.block_configure:
title: 'Quick edit'
route_name: 'entity.block.offcanvas_form'
route_name: 'entity.block.off_canvas_form'
group: 'block'

21
web/core/modules/outside_in/outside_in.module
View file

@ -30,16 +30,25 @@ function outside_in_help($route_name, RouteMatchInterface $route_match) {
/**
* Implements hook_contextual_links_view_alter().
*
* Change Configure Blocks into offcanvas links.
* Change Configure Blocks into off_canvas links.
*/
function outside_in_contextual_links_view_alter(&$element, $items) {
if (isset($element['#links']['outside-inblock-configure'])) {
// Place outside_in link first.
$outside_in_link = $element['#links']['outside-inblock-configure'];
unset($element['#links']['outside-inblock-configure']);
$element['#links'] = ['outside-inblock-configure' => $outside_in_link] + $element['#links'];
$element['#links']['outside-inblock-configure']['attributes'] = [
'class' => ['use-ajax'],
'data-dialog-type' => 'dialog',
'data-dialog-renderer' => 'offcanvas',
'data-dialog-renderer' => 'off_canvas',
'data-outside-in-edit' => TRUE,
];
// If this is content block change title to avoid duplicate "Quick Edit".
if (isset($element['#links']['block-contentblock-edit'])) {
$element['#links']['outside-inblock-configure']['title'] = t('Quick edit settings');
}
$element['#attached']['library'][] = 'outside_in/drupal.off_canvas';
}
@ -83,8 +92,8 @@ function outside_in_theme() {
function outside_in_entity_type_build(array &$entity_types) {
/* @var $entity_types \Drupal\Core\Entity\EntityTypeInterface[] */
$entity_types['block']
->setFormClass('offcanvas', BlockEntityOffCanvasForm::class)
->setLinkTemplate('offcanvas-form', '/admin/structure/block/manage/{block}/offcanvas');
->setFormClass('off_canvas', BlockEntityOffCanvasForm::class)
->setLinkTemplate('off_canvas-form', '/admin/structure/block/manage/{block}/off-canvas');
}
/**
@ -130,14 +139,14 @@ function outside_in_toolbar_alter(&$items) {
*/
function outside_in_block_alter(&$definitions) {
if (!empty($definitions['system_branding_block'])) {
$definitions['system_branding_block']['forms']['offcanvas'] = SystemBrandingOffCanvasForm::class;
$definitions['system_branding_block']['forms']['off_canvas'] = SystemBrandingOffCanvasForm::class;
}
// Since menu blocks use derivatives, check the definition ID instead of
// relying on the plugin ID.
foreach ($definitions as &$definition) {
if ($definition['id'] === 'system_menu_block') {
$definition['forms']['offcanvas'] = SystemMenuOffCanvasForm::class;
$definition['forms']['off_canvas'] = SystemMenuOffCanvasForm::class;
}
}
}

6
web/core/modules/outside_in/outside_in.routing.yml
View file

@ -1,7 +1,7 @@
entity.block.offcanvas_form:
path: '/admin/structure/block/manage/{block}/offcanvas'
entity.block.off_canvas_form:
path: '/admin/structure/block/manage/{block}/off-canvas'
defaults:
_entity_form: 'block.offcanvas'
_entity_form: 'block.off_canvas'
_title_callback: '\Drupal\outside_in\Block\BlockEntityOffCanvasForm::title'
requirements:
_permission: 'administer blocks'

2
web/core/modules/outside_in/outside_in.services.yml
View file

@ -3,7 +3,7 @@ services:
class: Drupal\outside_in\Render\MainContent\OffCanvasRender
arguments: ['@title_resolver', '@renderer']
tags:
- { name: render.main_content_renderer, format: drupal_dialog_offcanvas }
- { name: render.main_content_renderer, format: drupal_dialog_off_canvas }
outside_in.manager:
class: Drupal\outside_in\OutsideInManager

6
web/core/modules/outside_in/src/Ajax/OpenOffCanvasDialogCommand.php
View file

@ -5,7 +5,7 @@ namespace Drupal\outside_in\Ajax;
use Drupal\Core\Ajax\OpenDialogCommand;
/**
* Defines an AJAX command to open content in a dialog in a off-canvas tray.
* Defines an AJAX command to open content in a dialog in a off-canvas dialog.
*
* @ingroup ajax
*/
@ -16,7 +16,7 @@ class OpenOffCanvasDialogCommand extends OpenDialogCommand {
*
* The off-canvas dialog differs from the normal modal provided by
* OpenDialogCommand in that a off-canvas has built in positioning and
* behaviours. Drupal provides a built-in off-canvas tray for this purpose,
* behaviours. Drupal provides a built-in off-canvas dialog for this purpose,
* so the selector is hard-coded in the call to the parent constructor.
*
* @param string $title
@ -33,7 +33,7 @@ class OpenOffCanvasDialogCommand extends OpenDialogCommand {
* populated automatically from the current request.
*/
public function __construct($title, $content, array $dialog_options = [], $settings = NULL) {
parent::__construct('#drupal-offcanvas', $title, $content, $dialog_options, $settings);
parent::__construct('#drupal-off-canvas', $title, $content, $dialog_options, $settings);
$this->dialogOptions['modal'] = FALSE;
$this->dialogOptions['autoResize'] = FALSE;
$this->dialogOptions['resizable'] = 'w';

4
web/core/modules/outside_in/src/Block/BlockEntityOffCanvasForm.php
View file

@ -9,7 +9,7 @@ use Drupal\Core\Form\FormStateInterface;
use Drupal\Core\Plugin\PluginWithFormsInterface;
/**
* Provides form for block instance forms when used in the off-canvas tray.
* Provides form for block instance forms when used in the off-canvas dialog.
*
* This form removes advanced sections of regular block form such as the
* visibility settings, machine ID and region.
@ -92,7 +92,7 @@ class BlockEntityOffCanvasForm extends BlockForm {
*/
protected function getPluginForm(BlockPluginInterface $block) {
if ($block instanceof PluginWithFormsInterface) {
return $this->pluginFormFactory->createInstance($block, 'offcanvas', 'configure');
return $this->pluginFormFactory->createInstance($block, 'off_canvas', 'configure');
}
return $block;
}

22
web/core/modules/outside_in/src/Form/SystemMenuOffCanvasForm.php
View file

@ -33,9 +33,11 @@ class SystemMenuOffCanvasForm extends PluginFormBase implements ContainerInjecti
protected $plugin;
/**
* The menu entity that the block uses and that will be edited in this form.
*
* @var \Drupal\system\MenuInterface
*/
protected $entity;
protected $menu;
/**
* @var \Drupal\Core\Entity\EntityStorageInterface
@ -81,10 +83,10 @@ class SystemMenuOffCanvasForm extends PluginFormBase implements ContainerInjecti
$form['entity_form'] = [
'#type' => 'details',
'#title' => $this->t('Edit menu %label', ['%label' => $this->entity->label()]),
'#title' => $this->t('Edit menu %label', ['%label' => $this->menu->label()]),
'#open' => TRUE,
];
$form['entity_form'] += $this->getEntityForm($this->entity)->buildForm([], $form_state);
$form['entity_form'] += $this->getEntityForm($this->menu)->buildForm([], $form_state);
// Print the menu link titles as text instead of a link.
if (!empty($form['entity_form']['links']['links'])) {
@ -111,7 +113,7 @@ class SystemMenuOffCanvasForm extends PluginFormBase implements ContainerInjecti
*/
public function validateConfigurationForm(array &$form, FormStateInterface $form_state) {
$this->plugin->validateConfigurationForm($form, $form_state);
$this->getEntityForm($this->entity)->validateForm($form, $form_state);
$this->getEntityForm($this->menu)->validateForm($form, $form_state);
}
/**
@ -119,22 +121,22 @@ class SystemMenuOffCanvasForm extends PluginFormBase implements ContainerInjecti
*/
public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
$this->plugin->submitConfigurationForm($form, $form_state);
$this->getEntityForm($this->entity)->submitForm($form, $form_state);
$this->entity->save();
$this->getEntityForm($this->menu)->submitForm($form, $form_state);
$this->menu->save();
}
/**
* Gets the entity form for this menu.
*
* @param \Drupal\system\MenuInterface $entity
* @param \Drupal\system\MenuInterface $menu
* The menu entity.
*
* @return \Drupal\Core\Entity\EntityFormInterface
* The entity form.
*/
protected function getEntityForm(MenuInterface $entity) {
protected function getEntityForm(MenuInterface $menu) {
$entity_form = $this->entityTypeManager->getFormObject('menu', 'edit');
$entity_form->setEntity($entity);
$entity_form->setEntity($menu);
return $entity_form;
}
@ -143,7 +145,7 @@ class SystemMenuOffCanvasForm extends PluginFormBase implements ContainerInjecti
*/
public function setPlugin(PluginInspectionInterface $plugin) {
$this->plugin = $plugin;
$this->entity = $this->menuStorage->load($this->plugin->getDerivativeId());
$this->menu = $this->menuStorage->load($this->plugin->getDerivativeId());
}
}

4
web/core/modules/outside_in/src/Render/MainContent/OffCanvasRender.php
View file

@ -11,7 +11,7 @@ use Drupal\outside_in\Ajax\OpenOffCanvasDialogCommand;
use Symfony\Component\HttpFoundation\Request;
/**
* Default main content renderer for offcanvas dialog requests.
* Default main content renderer for off-canvas dialog requests.
*/
class OffCanvasRender extends DialogRenderer {
@ -43,7 +43,6 @@ class OffCanvasRender extends DialogRenderer {
// First render the main content, because it might provide a title.
$content = $this->renderer->renderRoot($main_content);
// Attach the library necessary for using the OpenOffCanvasDialogCommand and
// set the attachments for this Ajax response.
$main_content['#attached']['library'][] = 'outside_in/drupal.off_canvas';
@ -55,7 +54,6 @@ class OffCanvasRender extends DialogRenderer {
// Determine the title: use the title provided by the main content if any,
// otherwise get it from the routing information.
$options = $request->request->get('dialogOptions', []);
$response->addCommand(new OpenOffCanvasDialogCommand($title, $content, $options));
return $response;
}

10
web/core/modules/outside_in/src/Tests/Ajax/OffCanvasDialogTest.php
View file

@ -21,7 +21,7 @@ class OffCanvasDialogTest extends AjaxTestBase {
public static $modules = ['outside_in'];
/**
* Test sending AJAX requests to open and manipulate offcanvas dialog.
* Test sending AJAX requests to open and manipulate off-canvas dialog.
*/
public function testDialog() {
$this->drupalLogin($this->drupalCreateUser(['administer contact forms']));
@ -32,9 +32,9 @@ class OffCanvasDialogTest extends AjaxTestBase {
$dialog_renderable = AjaxTestController::dialogContents();
$dialog_contents = \Drupal::service('renderer')->renderRoot($dialog_renderable);
$offcanvas_expected_response = [
$off_canvas_expected_response = [
'command' => 'openDialog',
'selector' => '#drupal-offcanvas',
'selector' => '#drupal-off-canvas',
'settings' => NULL,
'data' => $dialog_contents,
'dialogOptions' =>
@ -52,8 +52,8 @@ class OffCanvasDialogTest extends AjaxTestBase {
];
// Emulate going to the JS version of the page and check the JSON response.
$ajax_result = $this->drupalGetAjax('ajax-test/dialog-contents', ['query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_dialog_offcanvas']]);
$this->assertEqual($offcanvas_expected_response, $ajax_result[3], 'Off-canvas dialog JSON response matches.');
$ajax_result = $this->drupalGetAjax('ajax-test/dialog-contents', ['query' => [MainContentViewSubscriber::WRAPPER_FORMAT => 'drupal_dialog_off_canvas']]);
$this->assertEqual($off_canvas_expected_response, $ajax_result[3], 'off-canvas dialog JSON response matches.');
}
}

6
web/core/modules/outside_in/templates/outside-in-page-wrapper.html.twig
View file

@ -3,7 +3,9 @@
* @file
* Default theme implementation for a page wrapper.
*
* For consistent wrapping to {{ page }} render in all themes.
* For consistent wrapping to {{ page }} render in all themes. The
* "data-off-canvas-main-canvas" attribute is required by the off-canvas dialog.
* It cannot be removed without breaking the off-canvas dialog functionality.
*
* Available variables:
* - children: Contains the child elements of the page.
@ -12,7 +14,7 @@
*/
#}
{% if children %}
<div class="dialog-offcanvas__main-canvas" data-offcanvas-main-canvas >
<div class="dialog-off-canvas__main-canvas" data-off-canvas-main-canvas >
{{ children }}
</div>
{% endif %}

0
web/core/modules/outside_in/tests/modules/offcanvas_test/offcanvas_test.info.yml → web/core/modules/outside_in/tests/modules/off_canvas_test/off_canvas_test.info.yml
View file

29
web/core/modules/outside_in/tests/modules/off_canvas_test/off_canvas_test.routing.yml Normal file
View file

@ -0,0 +1,29 @@
off_canvas_test.links:
path: '/off-canvas-test-links'
defaults:
_controller: '\Drupal\off_canvas_test\Controller\TestController::linksDisplay'
_title: 'Links'
requirements:
_access: 'TRUE'
off_canvas_test.thing1:
path: '/off-canvas-thing1'
defaults:
_controller: '\Drupal\off_canvas_test\Controller\TestController::thing1'
_title: 'Thing 1'
requirements:
_access: 'TRUE'
off_canvas_test.thing2:
path: '/off-canvas-thing2'
defaults:
_controller: '\Drupal\off_canvas_test\Controller\TestController::thing2'
requirements:
_access: 'TRUE'
off_canvas_test.dialog_links:
path: '/off-canvas-dialog-links'
defaults:
_controller: '\Drupal\off_canvas_test\Controller\TestController::otherDialogLinks'
requirements:
_access: 'TRUE'

38
web/core/modules/outside_in/tests/modules/offcanvas_test/src/Controller/TestController.php → web/core/modules/outside_in/tests/modules/off_canvas_test/src/Controller/TestController.php
View file

@ -1,6 +1,6 @@
<?php
namespace Drupal\offcanvas_test\Controller;
namespace Drupal\off_canvas_test\Controller;
use Drupal\Component\Serialization\Json;
use Drupal\Core\Url;
@ -37,21 +37,21 @@ class TestController {
}
/**
* Displays test links that will open in offcanvas tray.
* Displays test links that will open in off-canvas dialog.
*
* @return array
* Render array with links.
*/
public function linksDisplay() {
return [
'offcanvas_link_1' => [
'off_canvas_link_1' => [
'#title' => 'Click Me 1!',
'#type' => 'link',
'#url' => Url::fromRoute('offcanvas_test.thing1'),
'#url' => Url::fromRoute('off_canvas_test.thing1'),
'#attributes' => [
'class' => ['use-ajax'],
'data-dialog-type' => 'dialog',
'data-dialog-renderer' => 'offcanvas',
'data-dialog-renderer' => 'off_canvas',
],
'#attached' => [
'library' => [
@ -59,14 +59,14 @@ class TestController {
],
],
],
'offcanvas_link_2' => [
'off_canvas_link_2' => [
'#title' => 'Click Me 2!',
'#type' => 'link',
'#url' => Url::fromRoute('offcanvas_test.thing2'),
'#url' => Url::fromRoute('off_canvas_test.thing2'),
'#attributes' => [
'class' => ['use-ajax'],
'data-dialog-type' => 'dialog',
'data-dialog-renderer' => 'offcanvas',
'data-dialog-renderer' => 'off_canvas',
'data-dialog-options' => Json::encode([
'width' => 555,
]),
@ -80,11 +80,11 @@ class TestController {
'other_dialog_links' => [
'#title' => 'Display more links!',
'#type' => 'link',
'#url' => Url::fromRoute('offcanvas_test.dialog_links'),
'#url' => Url::fromRoute('off_canvas_test.dialog_links'),
'#attributes' => [
'class' => ['use-ajax'],
'data-dialog-type' => 'dialog',
'data-dialog-renderer' => 'offcanvas',
'data-dialog-renderer' => 'off_canvas',
],
'#attached' => [
'library' => [
@ -96,12 +96,12 @@ class TestController {
}
/**
* Displays dialogs links to be displayed inside the offcanvas tray.
* Displays dialogs links to be displayed inside the off-canvas dialog.
*
* This links are used to test opening a modal and another offcanvas link from
* inside the offcanvas tray.
* This links are used to test opening a modal and another off_canvas link from
* inside the off-canvas dialog.
*
* @todo Update tests to check these links work in the offcanvas tray.
* @todo Update tests to check these links work in the off-canvas dialog.
* https://www.drupal.org/node/2790073
*
* @return array
@ -113,19 +113,19 @@ class TestController {
'#links' => [
'modal_link' => [
'title' => 'Open modal!',
'url' => Url::fromRoute('offcanvas_test.thing2'),
'url' => Url::fromRoute('off_canvas_test.thing2'),
'attributes' => [
'class' => ['use-ajax'],
'data-dialog-type' => 'modal',
],
],
'offcanvas_link' => [
'title' => 'Offcanvas link!',
'url' => Url::fromRoute('offcanvas_test.thing2'),
'off_canvas_link' => [
'title' => 'Off_canvas link!',
'url' => Url::fromRoute('off_canvas_test.thing2'),
'attributes' => [
'class' => ['use-ajax'],
'data-dialog-type' => 'dialog',
'data-dialog-renderer' => 'offcanvas',
'data-dialog-renderer' => 'off_canvas',
],
],
],

29
web/core/modules/outside_in/tests/modules/offcanvas_test/offcanvas_test.routing.yml
View file

@ -1,29 +0,0 @@
offcanvas_test.links:
path: '/offcanvas-test-links'
defaults:
_controller: '\Drupal\offcanvas_test\Controller\TestController::linksDisplay'
_title: 'Links'
requirements:
_access: 'TRUE'
offcanvas_test.thing1:
path: '/offcanvas-thing1'
defaults:
_controller: '\Drupal\offcanvas_test\Controller\TestController::thing1'
_title: 'Thing 1'
requirements:
_access: 'TRUE'
offcanvas_test.thing2:
path: '/offcanvas-thing2'
defaults:
_controller: '\Drupal\offcanvas_test\Controller\TestController::thing2'
requirements:
_access: 'TRUE'
offcanvas_test.dialog_links:
path: '/offcanvas-dialog-links'
defaults:
_controller: '\Drupal\offcanvas_test\Controller\TestController::otherDialogLinks'
requirements:
_access: 'TRUE'

57
web/core/modules/outside_in/tests/src/FunctionalJavascript/OffCanvasTest.php
View file

@ -3,7 +3,7 @@
namespace Drupal\Tests\outside_in\FunctionalJavascript;
/**
* Tests the off-canvas tray functionality.
* Tests the off-canvas dialog functionality.
*
* @group outside_in
*/
@ -12,23 +12,28 @@ class OffCanvasTest extends OutsideInJavascriptTestBase {
/**
* {@inheritdoc}
*/
public static $modules = ['block', 'system', 'toolbar', 'outside_in', 'offcanvas_test'];
public static $modules = [
'block',
'system',
'toolbar',
'outside_in',
'off_canvas_test',
];
/**
* Tests that regular non-contextual links will work with the off-canvas tray.
* Tests that non-contextual links will work with the off-canvas dialog.
*/
public function testOffCanvasLinks() {
$themes = ['bartik', 'stark'];
// Test the same functionality on multiple themes.
foreach ($themes as $theme) {
foreach ($this->getTestThemes() as $theme) {
$this->enableTheme($theme);
$this->drupalGet('/offcanvas-test-links');
$this->drupalGet('/off-canvas-test-links');
$page = $this->getSession()->getPage();
$web_assert = $this->assertSession();
// Make sure off-canvas tray is on page when first loaded.
$web_assert->elementNotExists('css', '#drupal-offcanvas');
// Make sure off-canvas dialog is on page when first loaded.
$web_assert->elementNotExists('css', '#drupal-off-canvas');
// Check opening and closing with two separate links.
// Make sure tray updates to new content.
@ -40,16 +45,16 @@ class OffCanvasTest extends OutsideInJavascriptTestBase {
$this->waitForOffCanvasToOpen();
// Check that the canvas is not on the page.
$web_assert->elementExists('css', '#drupal-offcanvas');
$web_assert->elementExists('css', '#drupal-off-canvas');
// Check that response text is on page.
$web_assert->pageTextContains("Thing $link_index says hello");
$offcanvas_tray = $this->getTray();
$off_canvas_tray = $this->getTray();
// Check that tray is visible.
$this->assertEquals(TRUE, $offcanvas_tray->isVisible());
$header_text = $offcanvas_tray->find('css', '.ui-dialog-title')->getText();
$this->assertEquals(TRUE, $off_canvas_tray->isVisible());
$header_text = $off_canvas_tray->find('css', '.ui-dialog-title')->getText();
$tray_text = $offcanvas_tray->findById('drupal-offcanvas')->getText();
$tray_text = $off_canvas_tray->findById('drupal-off-canvas')->getText();
$this->assertEquals("Thing $link_index says hello", $tray_text);
if ($link_index == '2') {
@ -57,7 +62,7 @@ class OffCanvasTest extends OutsideInJavascriptTestBase {
$web_assert->elementExists('css', '.ui-dialog-empty-title');
$this->assertEquals('', $header_text);
$style = $page->find('css', '.ui-dialog-offcanvas')->getAttribute('style');
$style = $page->find('css', '.ui-dialog-off-canvas')->getAttribute('style');
self::assertTrue(strstr($style, 'width: 555px;') !== FALSE, 'Dialog width respected.');
}
else {
@ -73,7 +78,6 @@ class OffCanvasTest extends OutsideInJavascriptTestBase {
* Tests the body displacement behaves differently at a narrow width.
*/
public function testNarrowWidth() {
$themes = ['stark', 'bartik'];
$narrow_width_breakpoint = 768;
$offset = 20;
$height = 800;
@ -81,26 +85,35 @@ class OffCanvasTest extends OutsideInJavascriptTestBase {
$web_assert = $this->assertSession();
// Test the same functionality on multiple themes.
foreach ($themes as $theme) {
foreach ($this->getTestThemes() as $theme) {
$this->enableTheme($theme);
// Testing at the wider width.
$this->getSession()->resizeWindow($narrow_width_breakpoint + $offset, $height);
$this->drupalGet('/offcanvas-test-links');
$this->assertFalse($page->find('css', '.dialog-offcanvas__main-canvas')->hasAttribute('style'), 'Body not padded on wide page load.');
$this->drupalGet('/off-canvas-test-links');
$this->assertFalse($page->find('css', '.dialog-off-canvas__main-canvas')->hasAttribute('style'), 'Body not padded on wide page load.');
$page->clickLink("Click Me 1!");
$this->waitForOffCanvasToOpen();
// Check that the main canvas is padded when page is not narrow width and
// tray is open.
$web_assert->elementAttributeContains('css', '.dialog-offcanvas__main-canvas', 'style', 'padding-right');
$web_assert->elementAttributeContains('css', '.dialog-off-canvas__main-canvas', 'style', 'padding-right');
// Testing at the narrower width.
$this->getSession()->resizeWindow($narrow_width_breakpoint - $offset, $height);
$this->drupalGet('/offcanvas-test-links');
$this->assertFalse($page->find('css', '.dialog-offcanvas__main-canvas')->hasAttribute('style'), 'Body not padded on narrow page load.');
$this->drupalGet('/off-canvas-test-links');
$this->assertFalse($page->find('css', '.dialog-off-canvas__main-canvas')->hasAttribute('style'), 'Body not padded on narrow page load.');
$page->clickLink("Click Me 1!");
$this->waitForOffCanvasToOpen();
$this->assertFalse($page->find('css', '.dialog-offcanvas__main-canvas')->hasAttribute('style'), 'Body not padded on narrow page with tray open.');
$this->assertFalse($page->find('css', '.dialog-off-canvas__main-canvas')->hasAttribute('style'), 'Body not padded on narrow page with tray open.');
}
}
/**
* {@inheritdoc}
*/
protected function getTestThemes() {
// Add 'seven' theme. Setting Tray "Edit Mode" will not work with 'seven'
// because it removes all contextual links the off-canvas dialog should.
return array_merge(parent::getTestThemes(), ['seven']);
}
}

425
web/core/modules/outside_in/tests/src/FunctionalJavascript/OutsideInBlockFormTest.php
View file

@ -2,10 +2,13 @@
namespace Drupal\Tests\outside_in\FunctionalJavascript;
use Drupal\block\Entity\Block;
use Drupal\block_content\Entity\BlockContent;
use Drupal\block_content\Entity\BlockContentType;
use Drupal\user\Entity\Role;
/**
* Testing opening and saving block forms in the off-canvas tray.
* Testing opening and saving block forms in the off-canvas dialog.
*
* @group outside_in
*/
@ -26,6 +29,7 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
'outside_in',
'quickedit',
'search',
'block_content',
// Add test module to override CSS pointer-events properties because they
// cause test failures.
'outside_in_test_css',
@ -36,9 +40,9 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
*/
protected function setUp() {
parent::setUp();
// @todo Ensure that this test class works against bartik and stark:
// https://www.drupal.org/node/2784881.
$this->enableTheme('bartik');
$this->createBlockContentType('basic', TRUE);
$block_content = $this->createBlockContent('Custom Block', 'basic', TRUE);
$user = $this->createUser([
'administer blocks',
'access contextual links',
@ -48,87 +52,91 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
'search content',
]);
$this->drupalLogin($user);
$this->placeBlock('system_powered_by_block', ['id' => 'powered']);
$this->placeBlock('system_branding_block', ['id' => 'branding']);
$this->placeBlock('search_form_block', ['id' => 'search']);
$this->placeBlock('block_content:' . $block_content->uuid(), ['id' => 'custom']);
}
/**
* Tests opening Offcanvas tray by click blocks and elements in the blocks.
* Tests opening off-canvas dialog by click blocks and elements in the blocks.
*
* @dataProvider providerTestBlocks
*/
public function testBlocks($block_id, $new_page_text, $element_selector, $label_selector, $button_text, $toolbar_item) {
public function testBlocks($block_plugin, $new_page_text, $element_selector, $label_selector, $button_text, $toolbar_item) {
$web_assert = $this->assertSession();
$page = $this->getSession()->getPage();
$block_selector = '#' . $block_id;
$this->drupalGet('user');
if (isset($toolbar_item)) {
// Check that you can open a toolbar tray and it will be closed after
// entering edit mode.
if ($element = $page->find('css', "#toolbar-administration a.is-active")) {
// If a tray was open from page load close it.
$element->click();
$this->waitForNoElement("#toolbar-administration a.is-active");
foreach ($this->getTestThemes() as $theme) {
$this->enableTheme($theme);
$block = $this->placeBlock($block_plugin);
$block_selector = str_replace('_', '-', $this->getBlockSelector($block));
$block_id = $block->id();
$this->drupalGet('user');
$link = $page->find('css', "$block_selector .contextual-links li a");
$this->assertEquals('Quick edit', $link->getText(), "'Quick edit' is the first contextual link for the block.");
$this->assertContains("/admin/structure/block/manage/$block_id/off-canvas?destination=user/2", $link->getAttribute('href'));
if (isset($toolbar_item)) {
// Check that you can open a toolbar tray and it will be closed after
// entering edit mode.
if ($element = $page->find('css', "#toolbar-administration a.is-active")) {
// If a tray was open from page load close it.
$element->click();
$this->waitForNoElement("#toolbar-administration a.is-active");
}
$page->find('css', $toolbar_item)->click();
$web_assert->waitForElementVisible('css', "{$toolbar_item}.is-active");
}
$page->find('css', $toolbar_item)->click();
$web_assert->waitForElementVisible('css', "{$toolbar_item}.is-active");
$this->enableEditMode();
if (isset($toolbar_item)) {
$this->waitForNoElement("{$toolbar_item}.is-active");
}
$this->openBlockForm($block_selector);
switch ($block_plugin) {
case 'system_powered_by_block':
// Fill out form, save the form.
$page->fillField('settings[label]', $new_page_text);
$page->checkField('settings[label_display]');
break;
case 'system_branding_block':
// Fill out form, save the form.
$page->fillField('settings[site_information][site_name]', $new_page_text);
break;
}
if (isset($new_page_text)) {
$page->pressButton($button_text);
// Make sure the changes are present.
// @todo Use a wait method that will take into account the form submitting
// and all JavaScript activity. https://www.drupal.org/node/2837676
// The use \Behat\Mink\WebAssert::pageTextContains to check text.
$this->assertJsCondition('jQuery("' . $block_selector . ' ' . $label_selector . '").html() == "' . $new_page_text . '"');
}
$this->openBlockForm($block_selector);
$this->disableEditMode();
// Canvas should close when editing module is closed.
$this->waitForOffCanvasToClose();
$this->enableEditMode();
// Open block form by clicking a element inside the block.
// This confirms that default action for links and form elements is
// suppressed.
$this->openBlockForm("$block_selector {$element_selector}");
$web_assert->elementTextContains('css', '.contextual-toolbar-tab button', 'Editing');
$web_assert->elementAttributeContains('css', '.dialog-off-canvas__main-canvas', 'class', 'js-outside-in-edit-mode');
// Simulate press the Escape key.
$this->getSession()->executeScript('jQuery("body").trigger(jQuery.Event("keyup", { keyCode: 27 }));');
$this->waitForOffCanvasToClose();
$this->getSession()->wait(100);
$this->assertEditModeDisabled();
$web_assert->elementTextContains('css', '#drupal-live-announce', 'Exited edit mode.');
$web_assert->elementTextNotContains('css', '.contextual-toolbar-tab button', 'Editing');
$web_assert->elementAttributeNotContains('css', '.dialog-off-canvas__main-canvas', 'class', 'js-outside-in-edit-mode');
// Delete the block that was placed for the current theme.
$block->delete();
}
$this->enableEditMode();
if (isset($toolbar_item)) {
$this->waitForNoElement("{$toolbar_item}.is-active");
}
$this->openBlockForm($block_selector);
switch ($block_id) {
case 'block-powered':
// Fill out form, save the form.
$page->fillField('settings[label]', $new_page_text);
$page->checkField('settings[label_display]');
break;
case 'block-branding':
// Fill out form, save the form.
$page->fillField('settings[site_information][site_name]', $new_page_text);
break;
}
if (isset($new_page_text)) {
$page->pressButton($button_text);
// Make sure the changes are present.
// @todo Use a wait method that will take into account the form submitting
// and all JavaScript activity. https://www.drupal.org/node/2837676
// The use \Behat\Mink\WebAssert::pageTextContains to check text.
$this->assertJsCondition('jQuery("' . $block_selector . ' ' . $label_selector . '").html() == "' . $new_page_text . '"');
}
$this->openBlockForm($block_selector);
$this->disableEditMode();
// Canvas should close when editing module is closed.
$this->waitForOffCanvasToClose();
$this->enableEditMode();
$element_selector = "$block_selector {$element_selector}";
// Open block form by clicking a element inside the block.
// This confirms that default action for links and form elements is
// suppressed.
$this->openBlockForm($element_selector);
// Exit edit mode using ESC.
$web_assert->elementTextContains('css', '.contextual-toolbar-tab button', 'Editing');
$web_assert->elementAttributeContains('css', '.dialog-offcanvas__main-canvas', 'class', 'js-outside-in-edit-mode');
// Simulate press the Escape key.
$this->getSession()->executeScript('jQuery("body").trigger(jQuery.Event("keyup", { keyCode: 27 }));');
$this->waitForOffCanvasToClose();
$this->getSession()->wait(100);
$this->assertEditModeDisabled();
$web_assert->elementTextContains('css', '#drupal-live-announce', 'Exited edit mode.');
$web_assert->elementTextNotContains('css', '.contextual-toolbar-tab button', 'Editing');
$web_assert->elementAttributeNotContains('css', '.dialog-offcanvas__main-canvas', 'class', 'js-outside-in-edit-mode');
}
/**
@ -137,23 +145,23 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
public function providerTestBlocks() {
$blocks = [
'block-powered' => [
'id' => 'block-powered',
'block_plugin' => 'system_powered_by_block',
'new_page_text' => 'Can you imagine anyone showing the label on this block?',
'element_selector' => '.content a',
'element_selector' => 'span a',
'label_selector' => 'h2',
'button_text' => 'Save Powered by Drupal',
'toolbar_item' => '#toolbar-item-user',
],
'block-branding' => [
'id' => 'block-branding',
'block_plugin' => 'system_branding_block',
'new_page_text' => 'The site that will live a very short life.',
'element_selector' => 'a[rel="home"]:nth-child(2)',
'label_selector' => '.site-branding__name a',
'element_selector' => "a[rel='home']:last-child",
'label_selector' => "a[rel='home']:last-child",
'button_text' => 'Save Site branding',
'toolbar_item' => '#toolbar-item-administration',
],
'block-search' => [
'id' => 'block-search',
'block_plugin' => 'search_form_block',
'new_page_text' => NULL,
'element_selector' => '#edit-submit',
'label_selector' => 'h2',
@ -169,6 +177,7 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
*/
protected function enableEditMode() {
$this->pressToolbarEditButton();
$this->waitForToolbarToLoad();
$this->assertEditModeEnabled();
}
@ -177,6 +186,7 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
*/
protected function disableEditMode() {
$this->pressToolbarEditButton();
$this->waitForToolbarToLoad();
$this->assertEditModeDisabled();
}
@ -200,6 +210,7 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
* A css selector selects the block or an element within it.
*/
protected function openBlockForm($block_selector) {
$this->waitForToolbarToLoad();
$this->click($block_selector);
$this->waitForOffCanvasToOpen();
$this->assertOffCanvasBlockFormIsValid();
@ -210,8 +221,8 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
*/
public function testQuickEditLinks() {
$quick_edit_selector = '#quickedit-entity-toolbar';
$body_selector = '.field--name-body p';
$block_selector = '#block-powered';
$node_selector = '[data-quickedit-entity-id="node/1"]';
$body_selector = '[data-quickedit-field-id="node/1/body/en/full"]';
$web_assert = $this->assertSession();
// Create a Content type and two test nodes.
$this->createContentType(['type' => 'page']);
@ -233,87 +244,99 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
]
);
$page = $this->getSession()->getPage();
// Load the same page twice.
foreach ([1, 2] as $page_load_times) {
$this->drupalGet('node/' . $node->id());
// Waiting for Toolbar module.
// @todo Remove the hack after https://www.drupal.org/node/2542050.
$web_assert->waitForElementVisible('css', '.toolbar-fixed');
// Waiting for Toolbar animation.
$web_assert->assertWaitOnAjaxRequest();
// The 2nd page load we should already be in edit mode.
if ($page_load_times == 1) {
$block_plugin = 'system_powered_by_block';
foreach ($this->getTestThemes() as $theme) {
$this->enableTheme($theme);
$block = $this->placeBlock($block_plugin);
$block_selector = str_replace('_', '-', $this->getBlockSelector($block));
// Load the same page twice.
foreach ([1, 2] as $page_load_times) {
$this->drupalGet('node/' . $node->id());
// Waiting for Toolbar module.
// @todo Remove the hack after https://www.drupal.org/node/2542050.
$web_assert->waitForElementVisible('css', '.toolbar-fixed');
// Waiting for Toolbar animation.
$web_assert->assertWaitOnAjaxRequest();
// The 2nd page load we should already be in edit mode.
if ($page_load_times == 1) {
$this->enableEditMode();
}
// In Edit mode clicking field should open QuickEdit toolbar.
$page->find('css', $body_selector)->click();
$web_assert->waitForElementVisible('css', $quick_edit_selector);
$this->disableEditMode();
// Exiting Edit mode should close QuickEdit toolbar.
$web_assert->elementNotExists('css', $quick_edit_selector);
// When not in Edit mode QuickEdit toolbar should not open.
$page->find('css', $body_selector)->click();
$web_assert->elementNotExists('css', $quick_edit_selector);
$this->enableEditMode();
$this->openBlockForm($block_selector);
$page->find('css', $body_selector)->click();
$web_assert->waitForElementVisible('css', $quick_edit_selector);
// Off-canvas dialog should be closed when opening QuickEdit toolbar.
$this->waitForOffCanvasToClose();
$this->openBlockForm($block_selector);
// QuickEdit toolbar should be closed when opening Off-canvas dialog.
$web_assert->elementNotExists('css', $quick_edit_selector);
}
// In Edit mode clicking field should open QuickEdit toolbar.
$page->find('css', $body_selector)->click();
$web_assert->waitForElementVisible('css', $quick_edit_selector);
// Check using contextual links to invoke QuickEdit and open the tray.
$this->drupalGet('node/' . $node->id());
$web_assert->assertWaitOnAjaxRequest();
$this->disableEditMode();
// Exiting Edit mode should close QuickEdit toolbar.
$web_assert->elementNotExists('css', $quick_edit_selector);
// When not in Edit mode QuickEdit toolbar should not open.
$page->find('css', $body_selector)->click();
$web_assert->elementNotExists('css', $quick_edit_selector);
$this->enableEditMode();
$this->openBlockForm($block_selector);
$page->find('css', $body_selector)->click();
// Open QuickEdit toolbar before going into Edit mode.
$this->clickContextualLink($node_selector, "Quick edit");
$web_assert->waitForElementVisible('css', $quick_edit_selector);
// Offcanvas should be closed when opening QuickEdit toolbar.
$this->waitForOffCanvasToClose();
$this->openBlockForm($block_selector);
// QuickEdit toolbar should be closed when opening Offcanvas.
// Open off-canvas and enter Edit mode via contextual link.
$this->clickContextualLink($block_selector, "Quick edit");
$this->waitForOffCanvasToOpen();
// QuickEdit toolbar should be closed when opening off-canvas dialog.
$web_assert->elementNotExists('css', $quick_edit_selector);
// Open QuickEdit toolbar via contextual link while in Edit mode.
$this->clickContextualLink($node_selector, "Quick edit", FALSE);
$this->waitForOffCanvasToClose();
$web_assert->waitForElementVisible('css', $quick_edit_selector);
$this->disableEditMode();
}
// Check using contextual links to invoke QuickEdit and open the tray.
$this->drupalGet('node/' . $node->id());
$web_assert->assertWaitOnAjaxRequest();
$this->disableEditMode();
// Open QuickEdit toolbar before going into Edit mode.
$this->clickContextualLink('.node', "Quick edit");
$web_assert->waitForElementVisible('css', $quick_edit_selector);
// Open off-canvas and enter Edit mode via contextual link.
$this->clickContextualLink($block_selector, "Quick edit");
$this->waitForOffCanvasToOpen();
// QuickEdit toolbar should be closed when opening Offcanvas.
$web_assert->elementNotExists('css', $quick_edit_selector);
// Open QuickEdit toolbar via contextual link while in Edit mode.
$this->clickContextualLink('.node', "Quick edit", FALSE);
$this->waitForOffCanvasToClose();
$web_assert->waitForElementVisible('css', $quick_edit_selector);
}
/**
* Tests enabling and disabling Edit Mode.
*/
public function testEditModeEnableDisable() {
foreach (['contextual_link', 'toolbar_link'] as $enable_option) {
$this->drupalGet('user');
$this->assertEditModeDisabled();
switch ($enable_option) {
// Enable Edit mode.
case 'contextual_link':
$this->clickContextualLink('#block-powered', "Quick edit");
$this->waitForOffCanvasToOpen();
$this->assertEditModeEnabled();
break;
foreach ($this->getTestThemes() as $theme) {
$this->enableTheme($theme);
$block = $this->placeBlock('system_powered_by_block');
foreach (['contextual_link', 'toolbar_link'] as $enable_option) {
$this->drupalGet('user');
$this->assertEditModeDisabled();
switch ($enable_option) {
// Enable Edit mode.
case 'contextual_link':
$this->clickContextualLink($this->getBlockSelector($block), "Quick edit");
$this->waitForOffCanvasToOpen();
$this->assertEditModeEnabled();
break;
case 'toolbar_link':
$this->enableEditMode();
break;
case 'toolbar_link':
$this->enableEditMode();
break;
}
$this->disableEditMode();
// Make another page request to ensure Edit mode is still disabled.
$this->drupalGet('user');
$this->assertEditModeDisabled();
// Make sure on this page request it also re-enables and disables
// correctly.
$this->enableEditMode();
$this->disableEditMode();
}
$this->disableEditMode();
// Make another page request to ensure Edit mode is still disabled.
$this->drupalGet('user');
$this->assertEditModeDisabled();
// Make sure on this page request it also re-enables and disables
// correctly.
$this->enableEditMode();
$this->disableEditMode();
}
}
@ -327,7 +350,7 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
// The toolbar edit button should read "Editing".
$web_assert->elementContains('css', static::TOOLBAR_EDIT_LINK_SELECTOR, 'Editing');
// The main canvas element should have the "js-outside-in-edit-mode" class.
$web_assert->elementExists('css', '.dialog-offcanvas__main-canvas.js-outside-in-edit-mode');
$web_assert->elementExists('css', '.dialog-off-canvas__main-canvas.js-outside-in-edit-mode');
}
/**
@ -343,25 +366,107 @@ class OutsideInBlockFormTest extends OutsideInJavascriptTestBase {
$web_assert->elementContains('css', static::TOOLBAR_EDIT_LINK_SELECTOR, 'Edit');
// The main canvas element should NOT have the "js-outside-in-edit-mode"
// class.
$web_assert->elementNotExists('css', '.dialog-offcanvas__main-canvas.js-outside-in-edit-mode');
$web_assert->elementNotExists('css', '.dialog-off-canvas__main-canvas.js-outside-in-edit-mode');
}
/**
* Press the toolbar Edit button provided by the contextual module.
*/
protected function pressToolbarEditButton() {
$this->assertSession()
->waitForElementVisible('css', 'div[data-contextual-id="block:block=powered:langcode=en|outside_in::langcode=en"] .contextual-links a', 10000);
// Waiting for QuickEdit icon animation.
$this->assertSession()->assertWaitOnAjaxRequest();
$this->assertSession()->waitForElement('css', '[data-contextual-id] .contextual-links a');
$edit_button = $this->getSession()
->getPage()
->find('css', static::TOOLBAR_EDIT_LINK_SELECTOR);
$edit_button->press();
// Waiting for Toolbar animation.
$this->assertSession()->assertWaitOnAjaxRequest();
}
/**
* Creates a custom block.
*
* @param bool|string $title
* (optional) Title of block. When no value is given uses a random name.
* Defaults to FALSE.
* @param string $bundle
* (optional) Bundle name. Defaults to 'basic'.
* @param bool $save
* (optional) Whether to save the block. Defaults to TRUE.
*
* @return \Drupal\block_content\Entity\BlockContent
* Created custom block.
*/
protected function createBlockContent($title = FALSE, $bundle = 'basic', $save = TRUE) {
$title = $title ?: $this->randomName();
$block_content = BlockContent::create([
'info' => $title,
'type' => $bundle,
'langcode' => 'en',
'body' => [
'value' => 'The name "llama" was adopted by European settlers from native Peruvians.',
'format' => 'plain_text',
],
]);
if ($block_content && $save === TRUE) {
$block_content->save();
}
return $block_content;
}
/**
* Creates a custom block type (bundle).
*
* @param string $label
* The block type label.
* @param bool $create_body
* Whether or not to create the body field.
*
* @return \Drupal\block_content\Entity\BlockContentType
* Created custom block type.
*/
protected function createBlockContentType($label, $create_body = FALSE) {
$bundle = BlockContentType::create([
'id' => $label,
'label' => $label,
'revision' => FALSE,
]);
$bundle->save();
if ($create_body) {
block_content_add_body_field($bundle->id());
}
return $bundle;
}
/**
* Tests that contextual links in custom blocks are changed.
*
* "Quick edit" is quickedit.module link.
* "Quick edit settings" is outside_in.module link.
*/
public function testCustomBlockLinks() {
$this->drupalGet('user');
$page = $this->getSession()->getPage();
$links = $page->findAll('css', "#block-custom .contextual-links li a");
$link_labels = [];
/** @var \Behat\Mink\Element\NodeElement $link */
foreach ($links as $link) {
$link_labels[$link->getAttribute('href')] = $link->getText();
}
$href = array_search('Quick edit', $link_labels);
$this->assertEquals('', $href);
$href = array_search('Quick edit settings', $link_labels);
$this->assertTrue(strstr($href, '/admin/structure/block/manage/custom/off-canvas?destination=user/2') !== FALSE);
}
/**
* Gets the block CSS selector.
*
* @param \Drupal\block\Entity\Block $block
* The block.
*
* @return string
* The CSS selector.
*/
public function getBlockSelector(Block $block) {
return '#block-' . $block->id();
}
}

34
web/core/modules/outside_in/tests/src/FunctionalJavascript/OutsideInJavascriptTestBase.php
View file

@ -37,28 +37,28 @@ abstract class OutsideInJavascriptTestBase extends JavascriptTestBase {
}
/**
* Waits for Off-canvas tray to open.
* Waits for off-canvas dialog to open.
*/
protected function waitForOffCanvasToOpen() {
$web_assert = $this->assertSession();
$web_assert->assertWaitOnAjaxRequest();
$web_assert->waitForElementVisible('css', '#drupal-offcanvas');
$web_assert->waitForElementVisible('css', '#drupal-off-canvas');
}
/**
* Waits for Off-canvas tray to close.
* Waits for off-canvas dialog to close.
*/
protected function waitForOffCanvasToClose() {
$this->waitForNoElement('#drupal-offcanvas');
$this->waitForNoElement('#drupal-off-canvas');
}
/**
* Gets the Off-Canvas tray element.
* Gets the off-canvas dialog element.
*
* @return \Behat\Mink\Element\NodeElement|null
*/
protected function getTray() {
$tray = $this->getSession()->getPage()->find('css', '.ui-dialog[aria-describedby="drupal-offcanvas"]');
$tray = $this->getSession()->getPage()->find('css', '.ui-dialog[aria-describedby="drupal-off-canvas"]');
$this->assertEquals(FALSE, empty($tray), 'The tray was found.');
return $tray;
}
@ -118,4 +118,26 @@ abstract class OutsideInJavascriptTestBase extends JavascriptTestBase {
$this->getSession()->executeScript("jQuery('{$selector} .contextual .trigger').toggleClass('visually-hidden');");
}
/**
* Waits for Toolbar to load.
*/
protected function waitForToolbarToLoad() {
$web_assert = $this->assertSession();
// Waiting for Toolbar module.
// @todo Remove the hack after https://www.drupal.org/node/2542050.
$web_assert->waitForElementVisible('css', '.toolbar-fixed');
// Waiting for Toolbar animation.
$web_assert->assertWaitOnAjaxRequest();
}
/**
* Get themes to test.
*
* @return string[]
* Theme names to test.
*/
protected function getTestThemes() {
return ['bartik', 'stark', 'classy', 'stable'];
}
}

2
web/core/modules/outside_in/tests/src/Unit/Ajax/OpenOffCanvasDialogCommandTest.php
View file

@ -19,7 +19,7 @@ class OpenOffCanvasDialogCommandTest extends UnitTestCase {
$expected = [
'command' => 'openDialog',
'selector' => '#drupal-offcanvas',
'selector' => '#drupal-off-canvas',
'settings' => NULL,
'data' => '<p>Text!</p>',
'dialogOptions' => [