Port OG-Context module as OgContext provider

config/install/og.settings.yml

@@ -4,3 +4,7 @@ node_access_strict: true
 delete_orphans: false
 delete_orphans_plugin_id: simple
 deny_subscribe_without_approval: true
+group_resolvers:
+  - route_group
+  - route_group_content
+  - request_query_argument

config/schema/og.schema.yml

@@ -65,6 +65,12 @@ og.settings:
     deny_subscribe_without_approval:
       type: boolean
       label: 'When enabled, a user that ask to join to a private group their membership status will be pending regardless of the group permissions'
+    group_resolvers:
+      type: sequence
+      label: 'List of OgGroupResolver plugins that are used to discover the group context, in order of priority.'
+      sequence:
+        type: string
+        label: 'OgGroupResolver plugin ID.'
 
 og.settings.group.*:
   type: sequence

og.services.yml

@@ -12,6 +12,11 @@ services:
   og.access:
     class: Drupal\og\OgAccess
     arguments: ['@config.factory', '@current_user', '@module_handler', '@og.group_type_manager', '@og.permission_manager', '@og.membership_manager', '@og.group_audience_helper']
+  og.context:
+    class: Drupal\og\ContextProvider\OgContext
+    arguments: ['@plugin.manager.og.group_resolver', '@config.factory']
+    tags:
+      - { name: 'context_provider' }
   og.membership_manager:
     class: Drupal\og\MembershipManager
     arguments: ['@entity_type.manager', '@og.group_audience_helper']
@@ -29,18 +34,20 @@ services:
   og.permission_manager:
     class: Drupal\og\PermissionManager
     arguments: ['@event_dispatcher']
+  og.role_manager:
+    class: Drupal\og\OgRoleManager
+    arguments: ['@entity_type.manager', '@event_dispatcher', '@og.permission_manager']
   og.route_subscriber:
     class: Drupal\og\Routing\RouteSubscriber
     arguments: ['@entity_type.manager', '@router.route_provider', '@event_dispatcher']
     tags:
       - { name: event_subscriber }
-  og.role_manager:
-    class: Drupal\og\OgRoleManager
-    arguments: ['@entity_type.manager', '@event_dispatcher', '@og.permission_manager']
   plugin.manager.og.delete_orphans:
     class: Drupal\og\OgDeleteOrphansPluginManager
     parent: default_plugin_manager
   plugin.manager.og.fields:
     class: Drupal\og\OgFieldsPluginManager
     parent: default_plugin_manager
-
+  plugin.manager.og.group_resolver:
+    class: Drupal\og\OgGroupResolverPluginManager
+    parent: default_plugin_manager

src/Annotation/OgGroupResolver.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Drupal\og\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * Defines the OgGroupResolver annotation object.
+ *
+ * @see \Drupal\og\OgGroupResolverPluginManager
+ * @see plugin_api
+ *
+ * @Annotation
+ */
+class OgGroupResolver extends Plugin {
+
+  /**
+   * The plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The label of the plugin.
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   *
+   * @ingroup plugin_translatable
+   */
+  public $label;
+
+}

src/ContextProvider/OgContext.php

@@ -0,0 +1,209 @@
+<?php
+
+namespace Drupal\og\ContextProvider;
+
+use Drupal\Component\Plugin\PluginManagerInterface;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Config\ConfigFactoryInterface;
+use Drupal\Core\Plugin\Context\Context;
+use Drupal\Core\Plugin\Context\ContextDefinition;
+use Drupal\Core\Plugin\Context\ContextProviderInterface;
+use Drupal\Core\StringTranslation\StringTranslationTrait;
+use Drupal\og\OgResolvedGroupCollection;
+
+/**
+ * Provides the group that best matches the current context.
+ */
+class OgContext implements ContextProviderInterface {
+
+  use StringTranslationTrait;
+
+  /**
+   * The OgGroupResolver plugin manager.
+   *
+   * @var \Drupal\Component\Plugin\PluginManagerInterface
+   */
+  protected $pluginManager;
+
+  /**
+   * The config factory.
+   *
+   * @var \Drupal\Core\Config\ConfigFactoryInterface
+   */
+  protected $configFactory;
+
+  /**
+   * IDs of cache contexts that are relevant for the current group context.
+   *
+   * @var string[]
+   */
+  protected $cacheContextIds = [];
+
+  /**
+   * Constructs a new OgContext.
+   *
+   * @param \Drupal\Component\Plugin\PluginManagerInterface $plugin_manager
+   *   The OgGroupResolver plugin manager.
+   * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
+   *   The config factory.
+   */
+  public function __construct(PluginManagerInterface $plugin_manager, ConfigFactoryInterface $config_factory) {
+    $this->pluginManager = $plugin_manager;
+    $this->configFactory = $config_factory;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getRuntimeContexts(array $unqualified_context_ids) {
+    // Don't bother to resolve the group context if it is not requested.
+    if (!in_array('og', $unqualified_context_ids)) {
+      return [];
+    }
+
+    return ['og' => $this->getOgContext()];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getAvailableContexts() {
+    $context = new Context(new ContextDefinition('entity', $this->t('Active group')));
+    return ['og' => $context];
+  }
+
+  /**
+   * Returns the context object containing the relevant group.
+   *
+   * @return \Drupal\Core\Plugin\Context\Context
+   *   A context object containing the group which is relevant in the current
+   *   context as a value. If there is no relevant group in the current context
+   *   then the value will be empty.
+   */
+  protected function getOgContext() {
+    $context_definition = new ContextDefinition('entity', $this->t('Active group'), FALSE);
+    $context = new Context($context_definition, $this->getBestCandidate());
+
+    $cacheability = new CacheableMetadata();
+    $cacheability->setCacheContexts($this->cacheContextIds);
+
+    $context->addCacheableDependency($cacheability);
+
+    return $context;
+  }
+
+  /**
+   * Returns the group which best matches the current context.
+   *
+   * There might be several groups that are relevant in the current context, and
+   * this method tries to determine which is the best possible candidate.
+   *
+   * For example, if we are on a page that displays a group content entity that
+   * belongs to two groups, then both groups are relevant in the current
+   * context. We might then decide which group is the better candidate by
+   * looking at a URL query argument or inspecting the user's browsing history
+   * to see if they are coming from a group page.
+   *
+   * This discovery of groups is handled by OgGroupResolver plugins. Each plugin
+   * is responsible for discovering groups in a specific domain (e.g. find all
+   * groups belonging to the current route). The plugins that will be used for
+   * the discovery are configurable; they are listed under the 'group_resolvers'
+   * key in the 'og.settings' config. The plugins are ordered by priority,
+   * meaning that if two groups are relevant to the current context, then the
+   * plugin with the highest priority will decide which group is going to 'win'.
+   *
+   * Developers can customize the group context result by providing their own
+   * plugins and by activating, disabling or reordering the default ones.
+   *
+   * @return \Drupal\Core\Entity\EntityInterface|null
+   *   The group entity which is most relevant in the current context, or NULL
+   *   if no relevant group was found.
+   *
+   * @see \Drupal\og\OgGroupResolverInterface
+   */
+  protected function getBestCandidate() {
+    $collection = new OgResolvedGroupCollection();
+    $plugins = [];
+
+    // Retrieve the list of group resolvers. These are stored in config, and are
+    // ordered by priority.
+    $group_resolvers = $this->configFactory->get('og.settings')->get('group_resolvers');
+    $priority = 0;
+    foreach ($group_resolvers as $plugin_id) {
+      /** @var \Drupal\og\OgGroupResolverInterface $plugin */
+      if ($plugin = $this->pluginManager->createInstance($plugin_id)) {
+        $plugins[$plugin_id] = $plugin;
+
+        // Set the default vote weight according to the plugin's priority.
+        $collection->setVoteWeight($priority);
+
+        // Let the plugin do its magic.
+        $plugin->resolve($collection);
+
+        // If the plugin is certain that the candidate belongs to the current
+        // context, it can declare the search to be over.
+        if ($plugin->isPropagationStopped()) {
+          break;
+        }
+
+        // The next plugin we try will have a lower priority.
+        $priority--;
+      }
+    }
+
+    // @todo This should be moved to a plugin.
+    // Filter out inappropriate results.
+    array_filter($collection, function (array $candidate) {
+      // Filter out results that are not accessible by the current user.
+      return $candidate['entity']->access('view');
+    });
+
+    // @todo This should be handled in the collection.
+    // Since we have filtered the results by the current user, we need to add
+    // the user as a cache context.
+    $this->addCacheContextIds(['user']);
+
+    // @todo Move this in the collection? Seems to make sense, since the
+    //   collection has knowledge about the groups and votes.
+    // Find the best matching group by iterating over the candidates and return
+    // the one that has the most "votes". If there are multiple candidates with
+    // the same number of votes then the candidate that was resolved by the
+    // plugin(s) with the highest priority will be returned.
+    uasort($collection, function ($a, $b) {
+      if (count($a['votes']) == count($b['votes'])) {
+        return array_sum($a['votes']) < array_sum($b['votes']) ? -1 : 1;
+      }
+      return count($a['votes']) < count($b['votes']) ? -1 : 1;
+    });
+
+    // We found the best candidate.
+    $candidate = reset($collection);
+
+    if (empty($candidate)) {
+      return NULL;
+    }
+
+    // Compile the cache contexts that were used by the plugins that voted for
+    // our chosen candidate.
+    foreach (array_keys($candidate['votes']) as $plugin_id) {
+      $this->addCacheContextIds($plugins[$plugin_id]->getCacheContextIds());
+    };
+
+    return $candidate['entity'];
+  }
+
+  /**
+   * Adds a list of cache context IDs to be included in the context object.
+   *
+   * @param string[] $contexts
+   *   An array of cache context IDs.
+   */
+  protected function addCacheContextIds($contexts) {
+    foreach ($contexts as $context) {
+      if (!in_array($context, $this->cacheContextIds)) {
+        $this->cacheContextIds[] = $context;
+      }
+    }
+  }
+
+}

src/OgGroupResolverBase.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Drupal\og;
+
+use Drupal\Core\Plugin\PluginBase;
+
+/**
+ * Base class for OgGroupResolver plugins.
+ */
+abstract class OgGroupResolverBase extends PluginBase implements OgGroupResolverInterface {
+
+  /**
+   * Whether the group resolving process can be stopped.
+   *
+   * @var bool
+   */
+  protected $propagationStopped = FALSE;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function stopPropagation() {
+    $this->propagationStopped = TRUE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isPropagationStopped() {
+    return $this->propagationStopped;
+  }
+
+}