[COMPONENT][Collection][Feed][Attachment][Feed][Language][Tag] Refactor and consolidate Search and Feed query mechanisms into Collection. Remame 'onSearch' events to 'onCollectionQuery'

components/Attachment/Attachment.php

@@ -68,7 +68,7 @@ class Attachment extends Component
         return Event::next;
     }
 
-    public function onSearchQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
+    public function onCollectionQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
     {
         $note_qb->leftJoin(E\AttachmentToNote::class, 'attachment_to_note', Expr\Join::WITH, 'note.id = attachment_to_note.note_id');
         return Event::next;
@@ -77,7 +77,7 @@ class Attachment extends Component
     /**
      * Populate $note_expr with the criteria for looking for notes with attachments
      */
-    public function onSearchCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr): bool
+    public function onCollectionQueryCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr): bool
     {
         $include_term = str_contains($term, ':') ? explode(':', $term)[1] : $term;
         if (Formatting::startsWith($term, ['note-types:', 'notes-incude:', 'note-filter:'])) {

components/Collection/Collection.php

@@ -4,8 +4,142 @@ declare(strict_types = 1);
 
 namespace Component\Collection;
 
+use App\Core\DB\DB;
+use App\Core\Event;
 use App\Core\Modules\Component;
+use App\Entity\Actor;
+use App\Util\Formatting;
+use Component\Collection\Util\Parser;
+use Component\Subscription\Entity\ActorSubscription;
+use Doctrine\Common\Collections\ExpressionBuilder;
+use Doctrine\ORM\Query\Expr;
+use Doctrine\ORM\QueryBuilder;
 
 class Collection extends Component
 {
+    /**
+     * Perform a high level query on notes or actors
+     *
+     * Supports a variety of query terms and is used both in feeds and
+     * in search. Uses query builders to allow for extension
+     */
+    public static function query(string $query, int $page, ?string $language = null, ?Actor $actor = null): array
+    {
+        $note_criteria  = null;
+        $actor_criteria = null;
+        if (!empty($query = trim($query))) {
+            [$note_criteria, $actor_criteria] = Parser::parse($query, $language, $actor);
+        }
+        $note_qb  = DB::createQueryBuilder();
+        $actor_qb = DB::createQueryBuilder();
+        $note_qb->select('note')->from('App\Entity\Note', 'note')->orderBy('note.created', 'DESC')->addOrderBy('note.id', 'DESC');
+        $actor_qb->select('actor')->from('App\Entity\Actor', 'actor')->orderBy('actor.created', 'DESC')->addOrderBy('actor.id', 'DESC');
+        Event::handle('CollectionQueryAddJoins', [&$note_qb, &$actor_qb, $note_criteria, $actor_criteria]);
+
+        $notes  = [];
+        $actors = [];
+        if (!\is_null($note_criteria)) {
+            $note_qb->addCriteria($note_criteria);
+        }
+        $notes = $note_qb->getQuery()->execute();
+
+        if (!\is_null($actor_criteria)) {
+            $actor_qb->addCriteria($actor_criteria);
+        }
+        $actors = $actor_qb->getQuery()->execute();
+
+        // N.B.: Scope is only enforced at FeedController level
+        return ['notes' => $notes ?? null, 'actors' => $actors ?? null];
+    }
+
+    public function onCollectionQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
+    {
+        $note_qb->leftJoin(ActorSubscription::class, 'subscription', Expr\Join::WITH, 'note.actor_id = subscription.subscribed_id')
+            ->leftJoin(Actor::class, 'note_actor', Expr\Join::WITH, 'note.actor_id = note_actor.id');
+        return Event::next;
+    }
+
+    /**
+     * Convert $term to $note_expr and $actor_expr, search criteria. Handles searching for text
+     * notes, for different types of actors and for the content of text notes
+     */
+    public function onCollectionQueryCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr)
+    {
+        if (str_contains($term, ':')) {
+            $term = explode(':', $term);
+            if (Formatting::startsWith($term[0], 'note-')) {
+                switch ($term[0]) {
+                case 'note-local':
+                    $note_expr = $eb->eq('note.is_local', filter_var($term[1], \FILTER_VALIDATE_BOOLEAN));
+                    break;
+                case 'note-types':
+                case 'notes-include':
+                case 'note-filter':
+                    if (\is_null($note_expr)) {
+                        $note_expr = [];
+                    }
+                    if (array_intersect(explode(',', $term[1]), ['text', 'words']) !== []) {
+                        $note_expr[] = $eb->neq('note.content', null);
+                    } else {
+                        $note_expr[] = $eb->eq('note.content', null);
+                    }
+                    break;
+                case 'note-conversation':
+                    $note_expr = $eb->eq('note.conversation_id', (int) trim($term[1]));
+                    break;
+                case 'note-from':
+                case 'notes-from':
+                    $subscribed_expr = $eb->eq('subscription.subscriber_id', $actor->getId());
+                    $type_consts     = [];
+                    if ($term[1] === 'subscribed') {
+                        $type_consts = null;
+                    }
+                    foreach (explode(',', $term[1]) as $from) {
+                        if (str_starts_with($from, 'subscribed-')) {
+                            [, $type] = explode('-', $from);
+                            if (\in_array($type, ['actor', 'actors'])) {
+                                $type_consts = null;
+                            } else {
+                                $type_consts[] = \constant(Actor::class . '::' . mb_strtoupper($type));
+                            }
+                        }
+                    }
+                    if (\is_null($type_consts)) {
+                        $note_expr = $subscribed_expr;
+                    } elseif (!empty($type_consts)) {
+                        $note_expr = $eb->andX($subscribed_expr, $eb->in('note_actor.type', $type_consts));
+                    }
+                    break;
+                }
+            } elseif (Formatting::startsWith($term, 'actor-')) {
+                switch ($term[0]) {
+                    case 'actor-types':
+                    case 'actors-include':
+                    case 'actor-filter':
+                    case 'actor-local':
+                        if (\is_null($actor_expr)) {
+                            $actor_expr = [];
+                        }
+                        foreach (
+                            [
+                                Actor::PERSON => ['person', 'people'],
+                                Actor::GROUP => ['group', 'groups'],
+                                Actor::ORGANIZATION => ['org', 'orgs', 'organization', 'organizations', 'organisation', 'organisations'],
+                                Actor::BUSINESS => ['business', 'businesses'],
+                                Actor::BOT => ['bot', 'bots'],
+                            ] as $type => $match) {
+                            if (array_intersect(explode(',', $term[1]), $match) !== []) {
+                                $actor_expr[] = $eb->eq('actor.type', $type);
+                            } else {
+                                $actor_expr[] = $eb->neq('actor.type', $type);
+                            }
+                        }
+                        break;
+                }
+            }
+        } else {
+            $note_expr = $eb->contains('note.content', $term);
+        }
+        return Event::next;
+    }
 }

components/Collection/Util/Controller/Collection.php

@@ -7,7 +7,7 @@ namespace Component\Collection\Util\Controller;
 use App\Core\Controller;
 use App\Entity\Actor;
 use App\Util\Common;
-use Component\Feed\Feed;
+use Component\Collection\Collection as CollectionModule;
 
 class Collection extends Controller
 {
@@ -15,6 +15,6 @@ class Collection extends Controller
     {
         $actor  ??= Common::actor();
         $locale ??= $actor?->getTopLanguage()?->getLocale();
-        return Feed::query($query, $this->int('page') ?? 1, $locale, $actor);
+        return CollectionModule::query($query, $this->int('page') ?? 1, $locale, $actor);
     }
 }

components/Collection/Util/Parser.php

@@ -21,7 +21,7 @@ declare(strict_types = 1);
 
 // }}}
 
-namespace Component\Search\Util;
+namespace Component\Collection\Util;
 
 use App\Core\Event;
 use App\Entity\Actor;
@@ -78,7 +78,7 @@ abstract class Parser
                     $term      = mb_substr($input, $left, $end ? null : $right - $left);
                     $note_res  = null;
                     $actor_res = null;
-                    Event::handle('SearchCreateExpression', [$eb, $term, $language, $actor, &$note_res, &$actor_res]);
+                    Event::handle('CollectionQueryCreateExpression', [$eb, $term, $language, $actor, &$note_res, &$actor_res]);
                     if (\is_null($note_res) && \is_null($actor_res)) { // @phpstan-ignore-line
                         throw new ServerException("No one claimed responsibility for a match term: {$term}");
                     }

components/Feed/Feed.php

@@ -23,18 +23,10 @@ declare(strict_types = 1);
 
 namespace Component\Feed;
 
-use App\Core\DB\DB;
 use App\Core\Event;
 use App\Core\Modules\Component;
 use App\Core\Router\RouteLoader;
-use App\Entity\Actor;
-use App\Util\Formatting;
 use Component\Feed\Controller as C;
-use Component\Search\Util\Parser;
-use Component\Subscription\Entity\ActorSubscription;
-use Doctrine\Common\Collections\ExpressionBuilder;
-use Doctrine\ORM\Query\Expr;
-use Doctrine\ORM\QueryBuilder;
 
 class Feed extends Component
 {
@@ -44,130 +36,4 @@ class Feed extends Component
         $r->connect('feed_home', '/feed/home', [C\Feeds::class, 'home']);
         return Event::next;
     }
-
-    /**
-     * Perform a high level query on notes or actors
-     *
-     * Supports a variety of query terms and is used both in feeds and
-     * in search. Uses query builders to allow for extension
-     */
-    public static function query(string $query, int $page, ?string $language = null, ?Actor $actor = null): array
-    {
-        $note_criteria  = null;
-        $actor_criteria = null;
-        if (!empty($query = trim($query))) {
-            [$note_criteria, $actor_criteria] = Parser::parse($query, $language, $actor);
-        }
-        $note_qb  = DB::createQueryBuilder();
-        $actor_qb = DB::createQueryBuilder();
-        $note_qb->select('note')->from('App\Entity\Note', 'note')->orderBy('note.created', 'DESC')->addOrderBy('note.id', 'DESC');
-        $actor_qb->select('actor')->from('App\Entity\Actor', 'actor')->orderBy('actor.created', 'DESC')->addOrderBy('actor.id', 'DESC');
-        Event::handle('SearchQueryAddJoins', [&$note_qb, &$actor_qb, $note_criteria, $actor_criteria]);
-
-        $notes  = [];
-        $actors = [];
-        if (!\is_null($note_criteria)) {
-            $note_qb->addCriteria($note_criteria);
-        }
-        $notes = $note_qb->getQuery()->execute();
-
-        if (!\is_null($actor_criteria)) {
-            $actor_qb->addCriteria($actor_criteria);
-        }
-        $actors = $actor_qb->getQuery()->execute();
-
-        // N.B.: Scope is only enforced at FeedController level
-        return ['notes' => $notes ?? null, 'actors' => $actors ?? null];
-    }
-
-    public function onSearchQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
-    {
-        $note_qb->leftJoin(ActorSubscription::class, 'subscription', Expr\Join::WITH, 'note.actor_id = subscription.subscribed_id')
-            ->leftJoin(Actor::class, 'note_actor', Expr\Join::WITH, 'note.actor_id = note_actor.id');
-        return Event::next;
-    }
-
-    /**
-     * Convert $term to $note_expr and $actor_expr, search criteria. Handles searching for text
-     * notes, for different types of actors and for the content of text notes
-     */
-    public function onSearchCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr)
-    {
-        if (str_contains($term, ':')) {
-            $term = explode(':', $term);
-            if (Formatting::startsWith($term[0], 'note-')) {
-                switch ($term[0]) {
-                case 'note-local':
-                    $note_expr = $eb->eq('note.is_local', filter_var($term[1], \FILTER_VALIDATE_BOOLEAN));
-                    break;
-                case 'note-types':
-                case 'notes-include':
-                case 'note-filter':
-                    if (\is_null($note_expr)) {
-                        $note_expr = [];
-                    }
-                    if (array_intersect(explode(',', $term[1]), ['text', 'words']) !== []) {
-                        $note_expr[] = $eb->neq('note.content', null);
-                    } else {
-                        $note_expr[] = $eb->eq('note.content', null);
-                    }
-                    break;
-                case 'note-conversation':
-                    $note_expr = $eb->eq('note.conversation_id', (int) trim($term[1]));
-                    break;
-                case 'note-from':
-                case 'notes-from':
-                    $subscribed_expr = $eb->eq('subscription.subscriber_id', $actor->getId());
-                    $type_consts     = [];
-                    if ($term[1] === 'subscribed') {
-                        $type_consts = null;
-                    }
-                    foreach (explode(',', $term[1]) as $from) {
-                        if (str_starts_with($from, 'subscribed-')) {
-                            [, $type] = explode('-', $from);
-                            if (\in_array($type, ['actor', 'actors'])) {
-                                $type_consts = null;
-                            } else {
-                                $type_consts[] = \constant(Actor::class . '::' . mb_strtoupper($type));
-                            }
-                        }
-                    }
-                    if (\is_null($type_consts)) {
-                        $note_expr = $subscribed_expr;
-                    } elseif (!empty($type_consts)) {
-                        $note_expr = $eb->andX($subscribed_expr, $eb->in('note_actor.type', $type_consts));
-                    }
-                    break;
-                }
-            } elseif (Formatting::startsWith($term, 'actor-')) {
-                switch ($term[0]) {
-                    case 'actor-types':
-                    case 'actors-include':
-                    case 'actor-filter':
-                    case 'actor-local':
-                        if (\is_null($actor_expr)) {
-                            $actor_expr = [];
-                        }
-                        foreach (
-                            [
-                                Actor::PERSON => ['person', 'people'],
-                                Actor::GROUP => ['group', 'groups'],
-                                Actor::ORGANIZATION => ['org', 'orgs', 'organization', 'organizations', 'organisation', 'organisations'],
-                                Actor::BUSINESS => ['business', 'businesses'],
-                                Actor::BOT => ['bot', 'bots'],
-                            ] as $type => $match) {
-                            if (array_intersect(explode(',', $term[1]), $match) !== []) {
-                                $actor_expr[] = $eb->eq('actor.type', $type);
-                            } else {
-                                $actor_expr[] = $eb->neq('actor.type', $type);
-                            }
-                        }
-                        break;
-                }
-            }
-        } else {
-            $note_expr = $eb->contains('note.content', $term);
-        }
-        return Event::next;
-    }
 }

components/Language/Language.php

@@ -60,7 +60,7 @@ class Language extends Component
     /**
      * Populate $note_expr or $actor_expr with an expression to match a language
      */
-    public function onSearchCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr): bool
+    public function onCollectionQueryCreateExpression(ExpressionBuilder $eb, string $term, ?string $language, ?Actor $actor, &$note_expr, &$actor_expr): bool
     {
         $search_term = str_contains($term, ':') ? explode(':', $term)[1] : $term;
 
@@ -103,7 +103,7 @@ class Language extends Component
         return Event::next;
     }
 
-    public function onSearchQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
+    public function onCollectionQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
     {
         $note_qb->leftJoin('Component\Language\Entity\Language', 'note_language', Expr\Join::WITH, 'note.language_id = note_language.id')
             ->leftJoin('Component\Language\Entity\ActorLanguage', 'actor_language', Expr\Join::WITH, 'note.actor_id = actor_language.actor_id')

components/Tag/Tag.php

@@ -179,7 +179,7 @@ class Tag extends Component
      *
      * $term /^(note|tag|people|actor)/ means we want to match only either a note or an actor
      */
-    public function onSearchCreateExpression(ExpressionBuilder $eb, string $term, ?string $locale, ?Actor $actor, &$note_expr, &$actor_expr): bool
+    public function onCollectionQueryCreateExpression(ExpressionBuilder $eb, string $term, ?string $locale, ?Actor $actor, &$note_expr, &$actor_expr): bool
     {
         if (!str_contains($term, ':')) {
             return Event::next;
@@ -217,7 +217,7 @@ class Tag extends Component
         return Event::stop;
     }
 
-    public function onSearchQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
+    public function onCollectionQueryAddJoins(QueryBuilder &$note_qb, QueryBuilder &$actor_qb): bool
     {
         $note_qb->leftJoin(NoteTag::class, 'note_tag', Expr\Join::WITH, 'note_tag.note_id = note.id');
         $actor_qb->leftJoin(ActorTag::class, 'actor_tag', Expr\Join::WITH, 'actor_tag.tagger = actor.id');