Merge branch 'separate-banzai-references' into 'master'

Separate reference gathering from rendering

This is a required step to allow batch processing when gathering references. This in turn would allow grabbing (for example) all mentioned users of an issue/merge request using a single query.

cc @rspeicher @DouweM 

See merge request !3969

27 files changed, 554 insertions, 265 deletions

diff --git a/lib/banzai/filter/abstract_reference_filter.rb b/lib/banzai/filter/abstract_reference_filter.rb
index 65283fe96a4..db95d7c908b 100644
--- a/lib/banzai/filter/abstract_reference_filter.rb
+++ b/lib/banzai/filter/abstract_reference_filter.rb
@@ -18,10 +18,6 @@ module Banzai
         @object_sym ||= object_name.to_sym
       end
 
-      def self.data_reference
-        @data_reference ||= "data-#{object_name.dasherize}"
-      end
-
       def self.object_class_title
         @object_title ||= object_class.name.titleize
       end
@@ -45,10 +41,6 @@ module Banzai
         end
       end
 
-      def self.referenced_by(node)
-        { object_sym => LazyReference.new(object_class, node.attr(data_reference)) }
-      end
-
       def object_class
         self.class.object_class
       end
diff --git a/lib/banzai/filter/commit_range_reference_filter.rb b/lib/banzai/filter/commit_range_reference_filter.rb
index b469ea0f626..bbb88c979cc 100644
--- a/lib/banzai/filter/commit_range_reference_filter.rb
+++ b/lib/banzai/filter/commit_range_reference_filter.rb
@@ -4,6 +4,8 @@ module Banzai
     #
     # This filter supports cross-project references.
     class CommitRangeReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :commit_range
+
       def self.object_class
         CommitRange
       end
@@ -14,34 +16,18 @@ module Banzai
         end
       end
 
-      def self.referenced_by(node)
-        project = Project.find(node.attr("data-project")) rescue nil
-        return unless project
-
-        id = node.attr("data-commit-range")
-        range = find_object(project, id)
-
-        return unless range
-
-        { commit_range: range }
-      end
-
       def initialize(*args)
         super
 
         @commit_map = {}
       end
 
-      def self.find_object(project, id)
+      def find_object(project, id)
         range = CommitRange.new(id, project)
 
         range.valid_commits? ? range : nil
       end
 
-      def find_object(*args)
-        self.class.find_object(*args)
-      end
-
       def url_for_object(range, project)
         h = Gitlab::Routing.url_helpers
         h.namespace_project_compare_url(project.namespace, project,
diff --git a/lib/banzai/filter/commit_reference_filter.rb b/lib/banzai/filter/commit_reference_filter.rb
index bd88207326c..2ce1816672b 100644
--- a/lib/banzai/filter/commit_reference_filter.rb
+++ b/lib/banzai/filter/commit_reference_filter.rb
@@ -4,6 +4,8 @@ module Banzai
     #
     # This filter supports cross-project references.
     class CommitReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :commit
+
       def self.object_class
         Commit
       end
@@ -14,28 +16,12 @@ module Banzai
         end
       end
 
-      def self.referenced_by(node)
-        project = Project.find(node.attr("data-project")) rescue nil
-        return unless project
-
-        id = node.attr("data-commit")
-        commit = find_object(project, id)
-
-        return unless commit
-
-        { commit: commit }
-      end
-
-      def self.find_object(project, id)
+      def find_object(project, id)
         if project && project.valid_repo?
           project.commit(id)
         end
       end
 
-      def find_object(*args)
-        self.class.find_object(*args)
-      end
-
       def url_for_object(commit, project)
         h = Gitlab::Routing.url_helpers
         h.namespace_project_commit_url(project.namespace, project, commit,
diff --git a/lib/banzai/filter/external_issue_reference_filter.rb b/lib/banzai/filter/external_issue_reference_filter.rb
index 37344b90576..eaa702952cc 100644
--- a/lib/banzai/filter/external_issue_reference_filter.rb
+++ b/lib/banzai/filter/external_issue_reference_filter.rb
@@ -4,6 +4,8 @@ module Banzai
     # References are ignored if the project doesn't use an external issue
     # tracker.
     class ExternalIssueReferenceFilter < ReferenceFilter
+      self.reference_type = :external_issue
+
       # Public: Find `JIRA-123` issue references in text
       #
       #   ExternalIssueReferenceFilter.references_in(text) do |match, issue|
@@ -21,18 +23,6 @@ module Banzai
         end
       end
 
-      def self.referenced_by(node)
-        project = Project.find(node.attr("data-project")) rescue nil
-        return unless project
-
-        id = node.attr("data-external-issue")
-        external_issue = ExternalIssue.new(id, project)
-
-        return unless external_issue
-
-        { external_issue: external_issue }
-      end
-
       def call
         # Early return if the project isn't using an external tracker
         return doc if project.nil? || default_issues_tracker?
diff --git a/lib/banzai/filter/issue_reference_filter.rb b/lib/banzai/filter/issue_reference_filter.rb
index 59c5e89c546..2496e704002 100644
--- a/lib/banzai/filter/issue_reference_filter.rb
+++ b/lib/banzai/filter/issue_reference_filter.rb
@@ -5,18 +5,12 @@ module Banzai
     #
     # This filter supports cross-project references.
     class IssueReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :issue
+
       def self.object_class
         Issue
       end
 
-      def self.user_can_see_reference?(user, node, context)
-        # It is not possible to check access rights for external issue trackers
-        return true if context[:project].try(:external_issue_tracker)
- 
-        issue = Issue.find(node.attr('data-issue')) rescue nil
-        Ability.abilities.allowed?(user, :read_issue, issue)
-      end
-
       def find_object(project, id)
         project.get_issue(id)
       end
diff --git a/lib/banzai/filter/label_reference_filter.rb b/lib/banzai/filter/label_reference_filter.rb
index 8488a493b55..e4d3f87d0aa 100644
--- a/lib/banzai/filter/label_reference_filter.rb
+++ b/lib/banzai/filter/label_reference_filter.rb
@@ -2,6 +2,8 @@ module Banzai
   module Filter
     # HTML filter that replaces label references with links.
     class LabelReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :label
+
       def self.object_class
         Label
       end
diff --git a/lib/banzai/filter/merge_request_reference_filter.rb b/lib/banzai/filter/merge_request_reference_filter.rb
index cad38a51851..ac5216d9cfb 100644
--- a/lib/banzai/filter/merge_request_reference_filter.rb
+++ b/lib/banzai/filter/merge_request_reference_filter.rb
@@ -5,6 +5,8 @@ module Banzai
     #
     # This filter supports cross-project references.
     class MergeRequestReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :merge_request
+
       def self.object_class
         MergeRequest
       end
diff --git a/lib/banzai/filter/milestone_reference_filter.rb b/lib/banzai/filter/milestone_reference_filter.rb
index dad0768f51b..ca686c87d97 100644
--- a/lib/banzai/filter/milestone_reference_filter.rb
+++ b/lib/banzai/filter/milestone_reference_filter.rb
@@ -2,6 +2,8 @@ module Banzai
   module Filter
     # HTML filter that replaces milestone references with links.
     class MilestoneReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :milestone
+
       def self.object_class
         Milestone
       end
diff --git a/lib/banzai/filter/redactor_filter.rb b/lib/banzai/filter/redactor_filter.rb
index e589b5df6ec..c753a84a20d 100644
--- a/lib/banzai/filter/redactor_filter.rb
+++ b/lib/banzai/filter/redactor_filter.rb
@@ -7,8 +7,11 @@ module Banzai
     #
     class RedactorFilter < HTML::Pipeline::Filter
       def call
-        Querying.css(doc, 'a.gfm').each do |node|
-          unless user_can_see_reference?(node)
+        nodes = Querying.css(doc, 'a.gfm[data-reference-type]')
+        visible = nodes_visible_to_user(nodes)
+
+        nodes.each do |node|
+          unless visible.include?(node)
             # The reference should be replaced by the original text,
             # which is not always the same as the rendered text.
             text = node.attr('data-original') || node.text
@@ -21,20 +24,30 @@ module Banzai
 
       private
 
-      def user_can_see_reference?(node)
-        if node.has_attribute?('data-reference-filter')
-          reference_type = node.attr('data-reference-filter')
-          reference_filter = Banzai::Filter.const_get(reference_type)
+      def nodes_visible_to_user(nodes)
+        per_type = Hash.new { |h, k| h[k] = [] }
+        visible = Set.new
+
+        nodes.each do |node|
+          per_type[node.attr('data-reference-type')] << node
+        end
+
+        per_type.each do |type, nodes|
+          parser = Banzai::ReferenceParser[type].new(project, current_user)
 
-          reference_filter.user_can_see_reference?(current_user, node, context)
-        else
-          true
+          visible.merge(parser.nodes_visible_to_user(current_user, nodes))
         end
+
+        visible
       end
 
       def current_user
         context[:current_user]
       end
+
+      def project
+        context[:project]
+      end
     end
   end
 end
diff --git a/lib/banzai/filter/reference_filter.rb b/lib/banzai/filter/reference_filter.rb
index 31386cf851c..41ae0e1f9cc 100644
--- a/lib/banzai/filter/reference_filter.rb
+++ b/lib/banzai/filter/reference_filter.rb
@@ -8,24 +8,8 @@ module Banzai
     #   :project (required) - Current project, ignored if reference is cross-project.
     #   :only_path          - Generate path-only links.
     class ReferenceFilter < HTML::Pipeline::Filter
-      def self.user_can_see_reference?(user, node, context)
-        if node.has_attribute?('data-project')
-          project_id = node.attr('data-project').to_i
-          return true if project_id == context[:project].try(:id)
-
-          project = Project.find(project_id) rescue nil
-          Ability.abilities.allowed?(user, :read_project, project)
-        else
-          true
-        end
-      end
-
-      def self.user_can_reference?(user, node, context)
-        true
-      end
-
-      def self.referenced_by(node)
-        raise NotImplementedError, "#{self} does not implement #{__method__}"
+      class << self
+        attr_accessor :reference_type
       end
 
       # Returns a data attribute String to attach to a reference link
@@ -43,7 +27,9 @@ module Banzai
       #
       # Returns a String
       def data_attribute(attributes = {})
-        attributes[:reference_filter] = self.class.name.demodulize
+        attributes = attributes.reject { |_, v| v.nil? }
+
+        attributes[:reference_type] = self.class.reference_type
         attributes.delete(:original) if context[:no_original_data]
         attributes.map { |key, value| %Q(data-#{key.to_s.dasherize}="#{escape_once(value)}") }.join(" ")
       end
diff --git a/lib/banzai/filter/reference_gatherer_filter.rb b/lib/banzai/filter/reference_gatherer_filter.rb
deleted file mode 100644
index 96fdb06304e..00000000000
--- a/lib/banzai/filter/reference_gatherer_filter.rb
+++ /dev/null
@@ -1,65 +0,0 @@
-module Banzai
-  module Filter
-    # HTML filter that gathers all referenced records that the current user has
-    # permission to view.
-    #
-    # Expected to be run in its own post-processing pipeline.
-    #
-    class ReferenceGathererFilter < HTML::Pipeline::Filter
-      def initialize(*)
-        super
-
-        result[:references] ||= Hash.new { |hash, type| hash[type] = [] }
-      end
-
-      def call
-        Querying.css(doc, 'a.gfm').each do |node|
-          gather_references(node)
-        end
-
-        load_lazy_references unless ReferenceExtractor.lazy?
-
-        doc
-      end
-
-      private
-
-      def gather_references(node)
-        return unless node.has_attribute?('data-reference-filter')
-
-        reference_type = node.attr('data-reference-filter')
-        reference_filter = Banzai::Filter.const_get(reference_type)
-
-        return if context[:reference_filter] && reference_filter != context[:reference_filter]
-
-        return if author && !reference_filter.user_can_reference?(author, node, context)
-
-        return unless reference_filter.user_can_see_reference?(current_user, node, context)
-
-        references = reference_filter.referenced_by(node)
-        return unless references
-
-        references.each do |type, values|
-          Array.wrap(values).each do |value|
-            result[:references][type] << value
-          end
-        end
-      end
-
-      def load_lazy_references
-        refs = result[:references]
-        refs.each do |type, values|
-          refs[type] = ReferenceExtractor.lazily(values)
-        end
-      end
-
-      def current_user
-        context[:current_user]
-      end
-
-      def author
-        context[:author]
-      end
-    end
-  end
-end
diff --git a/lib/banzai/filter/snippet_reference_filter.rb b/lib/banzai/filter/snippet_reference_filter.rb
index d507eb5ebe1..212a0bbf2a0 100644
--- a/lib/banzai/filter/snippet_reference_filter.rb
+++ b/lib/banzai/filter/snippet_reference_filter.rb
@@ -5,6 +5,8 @@ module Banzai
     #
     # This filter supports cross-project references.
     class SnippetReferenceFilter < AbstractReferenceFilter
+      self.reference_type = :snippet
+
       def self.object_class
         Snippet
       end
diff --git a/lib/banzai/filter/user_reference_filter.rb b/lib/banzai/filter/user_reference_filter.rb
index eea3af842b6..331d8007257 100644
--- a/lib/banzai/filter/user_reference_filter.rb
+++ b/lib/banzai/filter/user_reference_filter.rb
@@ -4,6 +4,8 @@ module Banzai
     #
     # A special `@all` reference is also supported.
     class UserReferenceFilter < ReferenceFilter
+      self.reference_type = :user
+
       # Public: Find `@user` user references in text
       #
       #   UserReferenceFilter.references_in(text) do |match, username|
@@ -21,43 +23,6 @@ module Banzai
         end
       end
 
-      def self.referenced_by(node)
-        if node.has_attribute?('data-group')
-          group = Group.find(node.attr('data-group')) rescue nil
-          return unless group
-
-          { user: group.users }
-        elsif node.has_attribute?('data-user')
-          { user: LazyReference.new(User, node.attr('data-user')) }
-        elsif node.has_attribute?('data-project')
-          project = Project.find(node.attr('data-project')) rescue nil
-          return unless project
-
-          { user: project.team.members.flatten }
-        end
-      end
-
-      def self.user_can_see_reference?(user, node, context)
-        if node.has_attribute?('data-group')
-          group = Group.find(node.attr('data-group')) rescue nil
-          Ability.abilities.allowed?(user, :read_group, group)
-        else
-          super
-        end
-      end
-
-      def self.user_can_reference?(user, node, context)
-        # Only team members can reference `@all`
-        if node.has_attribute?('data-project')
-          project = Project.find(node.attr('data-project')) rescue nil
-          return false unless project
-
-          user && project.team.member?(user)
-        else
-          super
-        end
-      end
-
       def call
         return doc if project.nil?
 
@@ -114,9 +79,12 @@ module Banzai
 
       def link_to_all(link_text: nil)
         project = context[:project]
+        author = context[:author]
+
         url = urls.namespace_project_url(project.namespace, project,
                                          only_path: context[:only_path])
-        data = data_attribute(project: project.id)
+
+        data = data_attribute(project: project.id, author: author.try(:id))
         text = link_text || User.reference_prefix + 'all'
 
         link_tag(url, data, text)
diff --git a/lib/banzai/lazy_reference.rb b/lib/banzai/lazy_reference.rb
deleted file mode 100644
index 1095b4debc7..00000000000
--- a/lib/banzai/lazy_reference.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-module Banzai
-  class LazyReference
-    def self.load(refs)
-      lazy_references, values = refs.partition { |ref| ref.is_a?(self) }
-
-      lazy_values = lazy_references.group_by(&:klass).flat_map do |klass, refs|
-        ids = refs.flat_map(&:ids)
-        klass.where(id: ids)
-      end
-
-      values + lazy_values
-    end
-
-    attr_reader :klass, :ids
-
-    def initialize(klass, ids)
-      @klass = klass
-      @ids = Array.wrap(ids).map(&:to_i)
-    end
-
-    def load
-      self.klass.where(id: self.ids)
-    end
-  end
-end
diff --git a/lib/banzai/pipeline/reference_extraction_pipeline.rb b/lib/banzai/pipeline/reference_extraction_pipeline.rb
deleted file mode 100644
index 919998380e4..00000000000
--- a/lib/banzai/pipeline/reference_extraction_pipeline.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-module Banzai
-  module Pipeline
-    class ReferenceExtractionPipeline < BasePipeline
-      def self.filters
-        FilterArray[
-          Filter::ReferenceGathererFilter
-        ]
-      end
-    end
-  end
-end
diff --git a/lib/banzai/reference_extractor.rb b/lib/banzai/reference_extractor.rb
index f4079538ec5..bf366962aef 100644
--- a/lib/banzai/reference_extractor.rb
+++ b/lib/banzai/reference_extractor.rb
@@ -1,28 +1,6 @@
 module Banzai
   # Extract possible GFM references from an arbitrary String for further processing.
   class ReferenceExtractor
-    class << self
-      LAZY_KEY = :banzai_reference_extractor_lazy
-
-      def lazy?
-        Thread.current[LAZY_KEY]
-      end
-
-      def lazily(values = nil, &block)
-        return (values || block.call).uniq if lazy?
-
-        begin
-          Thread.current[LAZY_KEY] = true
-
-          values ||= block.call
-
-          Banzai::LazyReference.load(values.uniq).uniq
-        ensure
-          Thread.current[LAZY_KEY] = false
-        end
-      end
-    end
-
     def initialize
       @texts = []
     end
@@ -31,23 +9,21 @@ module Banzai
       @texts << Renderer.render(text, context)
     end
 
-    def references(type, context = {})
-      filter = Banzai::Filter["#{type}_reference"]
+    def references(type, project, current_user = nil)
+      processor = Banzai::ReferenceParser[type].
+        new(project, current_user)
+
+      processor.process(html_documents)
+    end
 
-      context.merge!(
-        pipeline: :reference_extraction,
+    private
 
-        # ReferenceGathererFilter
-        reference_filter: filter
-      )
+    def html_documents
+      # This ensures that we don't memoize anything until we have a number of
+      # text blobs to parse.
+      return [] if @texts.empty?
 
-      self.class.lazily do
-        @texts.flat_map do |html|
-          text_context = context.dup
-          result = Renderer.render_result(html, text_context)
-          result[:references][type]
-        end.uniq
-      end
+      @html_documents ||= @texts.map { |html| Nokogiri::HTML.fragment(html) }
     end
   end
 end
diff --git a/lib/banzai/reference_parser.rb b/lib/banzai/reference_parser.rb
new file mode 100644
index 00000000000..557bec4316e
--- /dev/null
+++ b/lib/banzai/reference_parser.rb
@@ -0,0 +1,14 @@
+module Banzai
+  module ReferenceParser
+    # Returns the reference parser class for the given type
+    #
+    # Example:
+    #
+    #     Banzai::ReferenceParser['issue']
+    #
+    # This would return the `Banzai::ReferenceParser::IssueParser` class.
+    def self.[](name)
+      const_get("#{name.to_s.camelize}Parser")
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/base_parser.rb b/lib/banzai/reference_parser/base_parser.rb
new file mode 100644
index 00000000000..3d7b9c4a024
--- /dev/null
+++ b/lib/banzai/reference_parser/base_parser.rb
@@ -0,0 +1,204 @@
+module Banzai
+  module ReferenceParser
+    # Base class for reference parsing classes.
+    #
+    # Each parser should also specify its reference type by calling
+    # `self.reference_type = ...` in the body of the class. The value of this
+    # method should be a symbol such as `:issue` or `:merge_request`. For
+    # example:
+    #
+    #     class IssueParser < BaseParser
+    #       self.reference_type = :issue
+    #     end
+    #
+    # The reference type is used to determine what nodes to pass to the
+    # `referenced_by` method.
+    #
+    # Parser classes should either implement the instance method
+    # `references_relation` or overwrite `referenced_by`. The
+    # `references_relation` method is supposed to return an
+    # ActiveRecord::Relation used as a base relation for retrieving the objects
+    # referenced in a set of HTML nodes.
+    #
+    # Each class can implement two additional methods:
+    #
+    # * `nodes_user_can_reference`: returns an Array of nodes the given user can
+    #   refer to.
+    # * `nodes_visible_to_user`: returns an Array of nodes that are visible to
+    #   the given user.
+    #
+    # You only need to overwrite these methods if you want to tweak who can see
+    # which references. For example, the IssueParser class defines its own
+    # `nodes_visible_to_user` method so it can ensure users can only see issues
+    # they have access to.
+    class BaseParser
+      class << self
+        attr_accessor :reference_type
+      end
+
+      # Returns the attribute name containing the value for every object to be
+      # parsed by the current parser.
+      #
+      # For example, for a parser class that returns "Animal" objects this
+      # attribute would be "data-animal".
+      def self.data_attribute
+        @data_attribute ||= "data-#{reference_type.to_s.dasherize}"
+      end
+
+      def initialize(project = nil, current_user = nil)
+        @project = project
+        @current_user = current_user
+      end
+
+      # Returns all the nodes containing references that the user can refer to.
+      def nodes_user_can_reference(user, nodes)
+        nodes
+      end
+
+      # Returns all the nodes that are visible to the given user.
+      def nodes_visible_to_user(user, nodes)
+        projects = lazy { projects_for_nodes(nodes) }
+        project_attr = 'data-project'
+
+        nodes.select do |node|
+          if node.has_attribute?(project_attr)
+            node_id = node.attr(project_attr).to_i
+
+            if project && project.id == node_id
+              true
+            else
+              can?(user, :read_project, projects[node_id])
+            end
+          else
+            true
+          end
+        end
+      end
+
+      # Returns an Array of objects referenced by any of the given HTML nodes.
+      def referenced_by(nodes)
+        ids = unique_attribute_values(nodes, self.class.data_attribute)
+
+        references_relation.where(id: ids)
+      end
+
+      # Returns the ActiveRecord::Relation to use for querying references in the
+      # DB.
+      def references_relation
+        raise NotImplementedError,
+          "#{self.class} does not implement #{__method__}"
+      end
+
+      # Returns a Hash containing attribute values per project ID.
+      #
+      # The returned Hash uses the following format:
+      #
+      #     { project id => [value1, value2, ...] }
+      #
+      # nodes - An Array of HTML nodes to process.
+      # attribute - The name of the attribute (as a String) for which to gather
+      #             values.
+      #
+      # Returns a Hash.
+      def gather_attributes_per_project(nodes, attribute)
+        per_project = Hash.new { |hash, key| hash[key] = Set.new }
+
+        nodes.each do |node|
+          project_id = node.attr('data-project').to_i
+          id = node.attr(attribute)
+
+          per_project[project_id] << id if id
+        end
+
+        per_project
+      end
+
+      # Returns a Hash containing objects for an attribute grouped per their
+      # IDs.
+      #
+      # The returned Hash uses the following format:
+      #
+      #     { id value => row }
+      #
+      # nodes - An Array of HTML nodes to process.
+      #
+      # collection - The model or ActiveRecord relation to use for retrieving
+      #              rows from the database.
+      #
+      # attribute - The name of the attribute containing the primary key values
+      #             for every row.
+      #
+      # Returns a Hash.
+      def grouped_objects_for_nodes(nodes, collection, attribute)
+        return {} if nodes.empty?
+
+        ids = unique_attribute_values(nodes, attribute)
+
+        collection.where(id: ids).each_with_object({}) do |row, hash|
+          hash[row.id] = row
+        end
+      end
+
+      # Returns an Array containing all unique values of an attribute of the
+      # given nodes.
+      def unique_attribute_values(nodes, attribute)
+        values = Set.new
+
+        nodes.each do |node|
+          if node.has_attribute?(attribute)
+            values << node.attr(attribute)
+          end
+        end
+
+        values.to_a
+      end
+
+      # Processes the list of HTML documents and returns an Array containing all
+      # the references.
+      def process(documents)
+        type = self.class.reference_type
+
+        nodes = documents.flat_map do |document|
+          Querying.css(document, "a[data-reference-type='#{type}'].gfm").to_a
+        end
+
+        gather_references(nodes)
+      end
+
+      # Gathers the references for the given HTML nodes.
+      def gather_references(nodes)
+        nodes = nodes_user_can_reference(current_user, nodes)
+        nodes = nodes_visible_to_user(current_user, nodes)
+
+        referenced_by(nodes)
+      end
+
+      # Returns a Hash containing the projects for a given list of HTML nodes.
+      #
+      # The returned Hash uses the following format:
+      #
+      #     { project ID => project }
+      #
+      def projects_for_nodes(nodes)
+        @projects_for_nodes ||=
+          grouped_objects_for_nodes(nodes, Project, 'data-project')
+      end
+
+      def can?(user, permission, subject)
+        Ability.abilities.allowed?(user, permission, subject)
+      end
+
+      def find_projects_for_hash_keys(hash)
+        Project.where(id: hash.keys)
+      end
+
+      private
+
+      attr_reader :current_user, :project
+
+      def lazy(&block)
+        Gitlab::Lazy.new(&block)
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/commit_parser.rb b/lib/banzai/reference_parser/commit_parser.rb
new file mode 100644
index 00000000000..0fee9d267de
--- /dev/null
+++ b/lib/banzai/reference_parser/commit_parser.rb
@@ -0,0 +1,34 @@
+module Banzai
+  module ReferenceParser
+    class CommitParser < BaseParser
+      self.reference_type = :commit
+
+      def referenced_by(nodes)
+        commit_ids = commit_ids_per_project(nodes)
+        projects = find_projects_for_hash_keys(commit_ids)
+
+        projects.flat_map do |project|
+          find_commits(project, commit_ids[project.id])
+        end
+      end
+
+      def commit_ids_per_project(nodes)
+        gather_attributes_per_project(nodes, self.class.data_attribute)
+      end
+
+      def find_commits(project, ids)
+        commits = []
+
+        return commits unless project.valid_repo?
+
+        ids.each do |id|
+          commit = project.commit(id)
+
+          commits << commit if commit
+        end
+
+        commits
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/commit_range_parser.rb b/lib/banzai/reference_parser/commit_range_parser.rb
new file mode 100644
index 00000000000..69d01f8db15
--- /dev/null
+++ b/lib/banzai/reference_parser/commit_range_parser.rb
@@ -0,0 +1,38 @@
+module Banzai
+  module ReferenceParser
+    class CommitRangeParser < BaseParser
+      self.reference_type = :commit_range
+
+      def referenced_by(nodes)
+        range_ids = commit_range_ids_per_project(nodes)
+        projects = find_projects_for_hash_keys(range_ids)
+
+        projects.flat_map do |project|
+          find_ranges(project, range_ids[project.id])
+        end
+      end
+
+      def commit_range_ids_per_project(nodes)
+        gather_attributes_per_project(nodes, self.class.data_attribute)
+      end
+
+      def find_ranges(project, range_ids)
+        ranges = []
+
+        range_ids.each do |id|
+          range = find_object(project, id)
+
+          ranges << range if range
+        end
+
+        ranges
+      end
+
+      def find_object(project, id)
+        range = CommitRange.new(id, project)
+
+        range.valid_commits? ? range : nil
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/external_issue_parser.rb b/lib/banzai/reference_parser/external_issue_parser.rb
new file mode 100644
index 00000000000..a1264db2111
--- /dev/null
+++ b/lib/banzai/reference_parser/external_issue_parser.rb
@@ -0,0 +1,25 @@
+module Banzai
+  module ReferenceParser
+    class ExternalIssueParser < BaseParser
+      self.reference_type = :external_issue
+
+      def referenced_by(nodes)
+        issue_ids = issue_ids_per_project(nodes)
+        projects = find_projects_for_hash_keys(issue_ids)
+        issues = []
+
+        projects.each do |project|
+          issue_ids[project.id].each do |id|
+            issues << ExternalIssue.new(id, project)
+          end
+        end
+
+        issues
+      end
+
+      def issue_ids_per_project(nodes)
+        gather_attributes_per_project(nodes, self.class.data_attribute)
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/issue_parser.rb b/lib/banzai/reference_parser/issue_parser.rb
new file mode 100644
index 00000000000..24076e3d9ec
--- /dev/null
+++ b/lib/banzai/reference_parser/issue_parser.rb
@@ -0,0 +1,40 @@
+module Banzai
+  module ReferenceParser
+    class IssueParser < BaseParser
+      self.reference_type = :issue
+
+      def nodes_visible_to_user(user, nodes)
+        # It is not possible to check access rights for external issue trackers
+        return nodes if project && project.external_issue_tracker
+
+        issues = issues_for_nodes(nodes)
+
+        nodes.select do |node|
+          issue = issue_for_node(issues, node)
+
+          issue ? can?(user, :read_issue, issue) : false
+        end
+      end
+
+      def referenced_by(nodes)
+        issues = issues_for_nodes(nodes)
+
+        nodes.map { |node| issue_for_node(issues, node) }.uniq
+      end
+
+      def issues_for_nodes(nodes)
+        @issues_for_nodes ||= grouped_objects_for_nodes(
+          nodes,
+          Issue.all.includes(:author, :assignee, :project),
+          self.class.data_attribute
+        )
+      end
+
+      private
+
+      def issue_for_node(issues, node)
+        issues[node.attr(self.class.data_attribute).to_i]
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/label_parser.rb b/lib/banzai/reference_parser/label_parser.rb
new file mode 100644
index 00000000000..e5d1eb11d7f
--- /dev/null
+++ b/lib/banzai/reference_parser/label_parser.rb
@@ -0,0 +1,11 @@
+module Banzai
+  module ReferenceParser
+    class LabelParser < BaseParser
+      self.reference_type = :label
+
+      def references_relation
+        Label
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/merge_request_parser.rb b/lib/banzai/reference_parser/merge_request_parser.rb
new file mode 100644
index 00000000000..c9a9ca79c09
--- /dev/null
+++ b/lib/banzai/reference_parser/merge_request_parser.rb
@@ -0,0 +1,11 @@
+module Banzai
+  module ReferenceParser
+    class MergeRequestParser < BaseParser
+      self.reference_type = :merge_request
+
+      def references_relation
+        MergeRequest.includes(:author, :assignee, :target_project)
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/milestone_parser.rb b/lib/banzai/reference_parser/milestone_parser.rb
new file mode 100644
index 00000000000..a000ac61e5c
--- /dev/null
+++ b/lib/banzai/reference_parser/milestone_parser.rb
@@ -0,0 +1,11 @@
+module Banzai
+  module ReferenceParser
+    class MilestoneParser < BaseParser
+      self.reference_type = :milestone
+
+      def references_relation
+        Milestone
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/snippet_parser.rb b/lib/banzai/reference_parser/snippet_parser.rb
new file mode 100644
index 00000000000..fa71b3c952a
--- /dev/null
+++ b/lib/banzai/reference_parser/snippet_parser.rb
@@ -0,0 +1,11 @@
+module Banzai
+  module ReferenceParser
+    class SnippetParser < BaseParser
+      self.reference_type = :snippet
+
+      def references_relation
+        Snippet
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/user_parser.rb b/lib/banzai/reference_parser/user_parser.rb
new file mode 100644
index 00000000000..a12b0d19560
--- /dev/null
+++ b/lib/banzai/reference_parser/user_parser.rb
@@ -0,0 +1,92 @@
+module Banzai
+  module ReferenceParser
+    class UserParser < BaseParser
+      self.reference_type = :user
+
+      def referenced_by(nodes)
+        group_ids = []
+        user_ids = []
+        project_ids = []
+
+        nodes.each do |node|
+          if node.has_attribute?('data-group')
+            group_ids << node.attr('data-group').to_i
+          elsif node.has_attribute?(self.class.data_attribute)
+            user_ids << node.attr(self.class.data_attribute).to_i
+          elsif node.has_attribute?('data-project')
+            project_ids << node.attr('data-project').to_i
+          end
+        end
+
+        find_users_for_groups(group_ids) | find_users(user_ids) |
+          find_users_for_projects(project_ids)
+      end
+
+      def nodes_visible_to_user(user, nodes)
+        group_attr = 'data-group'
+        groups = lazy { grouped_objects_for_nodes(nodes, Group, group_attr) }
+        visible = []
+        remaining = []
+
+        nodes.each do |node|
+          if node.has_attribute?(group_attr)
+            node_group = groups[node.attr(group_attr).to_i]
+
+            if node_group &&
+              can?(user, :read_group, node_group)
+              visible << node
+            end
+          # Remaining nodes will be processed by the parent class'
+          # implementation of this method.
+          else
+            remaining << node
+          end
+        end
+
+        visible + super(current_user, remaining)
+      end
+
+      def nodes_user_can_reference(current_user, nodes)
+        project_attr = 'data-project'
+        author_attr = 'data-author'
+
+        projects = lazy { projects_for_nodes(nodes) }
+        users = lazy { grouped_objects_for_nodes(nodes, User, author_attr) }
+
+        nodes.select do |node|
+          project_id = node.attr(project_attr)
+          user_id = node.attr(author_attr)
+
+          if project && project_id && project.id == project_id.to_i
+            true
+          elsif project_id && user_id
+            project = projects[project_id.to_i]
+            user = users[user_id.to_i]
+
+            project && user ? project.team.member?(user) : false
+          else
+            true
+          end
+        end
+      end
+
+      def find_users(ids)
+        return [] if ids.empty?
+
+        User.where(id: ids).to_a
+      end
+
+      def find_users_for_groups(ids)
+        return [] if ids.empty?
+
+        User.joins(:group_members).where(members: { source_id: ids }).to_a
+      end
+
+      def find_users_for_projects(ids)
+        return [] if ids.empty?
+
+        Project.where(id: ids).flat_map { |p| p.team.members.to_a }
+      end
+    end
+  end
+end