A working implementation of a project reference filter which links project references to project profile.

7 files changed, 338 insertions, 0 deletions

diff --git a/app/models/project.rb b/app/models/project.rb
index d91d7dcfe9a..7a8e3f8a7ec 100644
--- a/app/models/project.rb
+++ b/app/models/project.rb
@@ -456,6 +456,20 @@ class Project < ActiveRecord::Base
       }x
     end
 
+    def reference_postfix
+      '>'
+    end
+
+    # Pattern used to extract `project>` project references from text
+    # (?!\w) matches any non-word character
+    def markdown_reference_pattern
+      %r{
+        #{reference_pattern}
+        (#{reference_postfix}|#{CGI.escapeHTML(reference_postfix)})
+        (?!\w)
+      }x
+    end
+
     def trending
       joins('INNER JOIN trending_projects ON projects.id = trending_projects.project_id')
         .reorder('trending_projects.id ASC')
@@ -884,6 +898,10 @@ class Project < ActiveRecord::Base
     end
   end
 
+  def to_reference_with_postfix
+    "#{to_reference(full: true)}#{self.class.reference_postfix}"
+  end
+
   # `from` argument can be a Namespace or Project.
   def to_reference(from = nil, full: false)
     if full || cross_namespace_reference?(from)
diff --git a/lib/banzai/filter/project_reference_filter.rb b/lib/banzai/filter/project_reference_filter.rb
new file mode 100644
index 00000000000..ed69f7eae92
--- /dev/null
+++ b/lib/banzai/filter/project_reference_filter.rb
@@ -0,0 +1,114 @@
+module Banzai
+  module Filter
+    # HTML filter that replaces project references with links.
+    class ProjectReferenceFilter < ReferenceFilter
+      self.reference_type = :project
+
+      # Public: Find `project>` project references in text
+      #
+      #   ProjectReferenceFilter.references_in(text) do |match, project|
+      #     "<a href=...>#{project}></a>"
+      #   end
+      #
+      # text - String text to search.
+      #
+      # Yields the String match, and the String project name.
+      #
+      # Returns a String replaced with the return of the block.
+      def self.references_in(text)
+        text.gsub(Project.markdown_reference_pattern) do |match|
+          yield match, "#{$~[:namespace]}/#{$~[:project]}"
+        end
+      end
+
+      def call
+        ref_pattern = Project.markdown_reference_pattern
+        ref_pattern_start = /\A#{ref_pattern}\z/
+
+        nodes.each do |node|
+          if text_node?(node)
+            replace_text_when_pattern_matches(node, ref_pattern) do |content|
+              project_link_filter(content)
+            end
+          elsif element_node?(node)
+            yield_valid_link(node) do |link, inner_html|
+              if link =~ ref_pattern_start
+                replace_link_node_with_href(node, link) do
+                  project_link_filter(link, link_content: inner_html)
+                end
+              end
+            end
+          end
+        end
+
+        doc
+      end
+
+      # Replace `project>` project references in text with links to the referenced
+      # project page.
+      #
+      # text - String text to replace references in.
+      # link_content - Original content of the link being replaced.
+      #
+      # Returns a String with `project>` references replaced with links. All links
+      # have `gfm` and `gfm-project` class names attached for styling.
+      def project_link_filter(text, link_content: nil)
+        self.class.references_in(text) do |match, project_name|
+          cached_call(:banzai_url_for_object, match, path: [Project, project_name.downcase]) do
+            if project = projects_hash[project_name.downcase]
+              link_to_project(project, link_content: link_content) || match
+            else
+              match
+            end
+          end
+        end
+      end
+
+      # Returns a Hash containing all Namespace objects for the project
+      # references in the current document.
+      #
+      # The keys of this Hash are the namespace paths, the values the
+      # corresponding Namespace objects.
+      def projects_hash
+        @projects ||= Project.where_full_path_in(projects)
+                             .index_by(&:full_path)
+                             .transform_keys(&:downcase)
+      end
+
+      # Returns all projects referenced in the current document.
+      def projects
+        refs = Set.new
+
+        nodes.each do |node|
+          node.to_html.scan(Project.markdown_reference_pattern) do
+            refs << "#{$~[:namespace]}/#{$~[:project]}"
+          end
+        end
+
+        refs.to_a
+      end
+
+      private
+
+      def urls
+        Gitlab::Routing.url_helpers
+      end
+
+      def link_class
+        reference_class(:project)
+      end
+
+      def link_to_project(project, link_content: nil)
+        url = urls.project_url(project, only_path: context[:only_path])
+        data = data_attribute(project: project.id)
+        content = link_content || project.full_path + Project.reference_postfix
+
+        link_tag(url, data, content, project.name)
+      end
+
+      def link_tag(url, data, link_content, title)
+        %(<a href="#{url}" #{data} class="#{link_class}" title="#{escape_once(title)}">#{link_content}</a>)
+      end
+    end
+  end
+end
diff --git a/lib/banzai/pipeline/gfm_pipeline.rb b/lib/banzai/pipeline/gfm_pipeline.rb
index 0d9b874ef85..9295ca9efcc 100644
--- a/lib/banzai/pipeline/gfm_pipeline.rb
+++ b/lib/banzai/pipeline/gfm_pipeline.rb
@@ -25,6 +25,7 @@ module Banzai
           Filter::ExternalLinkFilter,
 
           Filter::UserReferenceFilter,
+          Filter::ProjectReferenceFilter,
           Filter::IssueReferenceFilter,
           Filter::ExternalIssueReferenceFilter,
           Filter::MergeRequestReferenceFilter,
diff --git a/lib/banzai/reference_parser/project_parser.rb b/lib/banzai/reference_parser/project_parser.rb
new file mode 100644
index 00000000000..54fd3c38a85
--- /dev/null
+++ b/lib/banzai/reference_parser/project_parser.rb
@@ -0,0 +1,17 @@
+module Banzai
+  module ReferenceParser
+    class ProjectParser < BaseParser
+      self.reference_type = :project
+
+      def references_relation
+        Project
+      end
+
+      private
+
+      def can_read_reference?(user, ref_project, node)
+        can?(user, :read_project, ref_project)
+      end
+    end
+  end
+end
diff --git a/spec/lib/banzai/filter/project_reference_filter_spec.rb b/spec/lib/banzai/filter/project_reference_filter_spec.rb
new file mode 100644
index 00000000000..2ace8496b08
--- /dev/null
+++ b/spec/lib/banzai/filter/project_reference_filter_spec.rb
@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Banzai::Filter::ProjectReferenceFilter do
+  include FilterSpecHelper
+
+  def invalidate_reference(reference)
+    "#{reference.reverse}"
+  end
+
+  def get_reference(project)
+    project.to_reference_with_postfix
+  end
+
+  let(:project)   { create(:project, :public) }
+  let(:reference) { get_reference(project) }
+
+  it 'ignores invalid projects' do
+    exp = act = "Hey #{invalidate_reference(reference)}"
+
+    expect(reference_filter(act).to_html).to eq(CGI.escapeHTML(exp))
+  end
+
+  it 'ignores references with text after the > sign' do
+    exp = act = "Hey #{reference}foo"
+    expect(reference_filter(act).to_html).to eq CGI.escapeHTML(exp)
+  end
+
+  %w(pre code a style).each do |elem|
+    it "ignores valid references contained inside '#{elem}' element" do
+      exp = act = "<#{elem}>Hey #{CGI.escapeHTML(reference)}</#{elem}>"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'mentioning a project' do
+    it_behaves_like 'a reference containing an element node'
+
+    it 'links to a Project' do
+      doc = reference_filter("Hey #{reference}")
+      expect(doc.css('a').first.attr('href')).to eq urls.project_url(project)
+    end
+
+    it 'links to a Project with a period' do
+      project = create(:project, name: 'alphA.Beta')
+
+      doc = reference_filter("Hey #{get_reference(project)}")
+      expect(doc.css('a').length).to eq 1
+    end
+
+    it 'links to a Project with an underscore' do
+      project = create(:project, name: 'ping_pong_king')
+
+      doc = reference_filter("Hey #{get_reference(project)}")
+      expect(doc.css('a').length).to eq 1
+    end
+
+    it 'links to a Project with different case-sensitivity' do
+      project = create(:project, name: 'RescueRanger')
+      reference = get_reference(project)
+
+      doc = reference_filter("Hey #{reference.upcase}")
+      expect(doc.css('a').length).to eq 1
+      expect(doc.css('a').text).to eq(reference)
+    end
+
+    it 'includes a data-project attribute' do
+      doc = reference_filter("Hey #{reference}")
+      link = doc.css('a').first
+
+      expect(link).to have_attribute('data-project')
+      expect(link.attr('data-project')).to eq project.namespace.owner_id.to_s
+    end
+  end
+
+  it 'includes default classes' do
+    doc = reference_filter("Hey #{reference}")
+    expect(doc.css('a').first.attr('class')).to eq 'gfm gfm-project has-tooltip'
+  end
+
+  it 'supports an :only_path context' do
+    doc = reference_filter("Hey #{reference}", only_path: true)
+    link = doc.css('a').first.attr('href')
+
+    expect(link).not_to match %r(https?://)
+    expect(link).to eq urls.project_path(project)
+  end
+
+  context 'referencing a project in a link href' do
+    let(:reference) { %Q{<a href="#{get_reference(project)}">Project</a>} }
+
+    it 'links to a Project' do
+      doc = reference_filter("Hey #{reference}")
+      expect(doc.css('a').first.attr('href')).to eq urls.project_url(project)
+    end
+
+    it 'links with adjacent text' do
+      doc = reference_filter("Mention me (#{reference}.)")
+      expect(doc.to_html).to match(%r{\(<a.+>Project</a>\.\)})
+    end
+
+    it 'includes a data-project attribute' do
+      doc = reference_filter("Hey #{reference}")
+      link = doc.css('a').first
+
+      expect(link).to have_attribute('data-project')
+      expect(link.attr('data-project')).to eq project.id.to_s
+    end
+  end
+
+  context 'in group context' do
+    let(:group) { create(:group) }
+    let(:project) { create(:project, group: group) }
+
+    let(:nested_group) { create(:group, :nested) }
+    let(:nested_project) { create(:project, group: nested_group) }
+
+    it 'supports mentioning a project' do
+      reference = get_reference(project)
+      doc = reference_filter("Hey #{reference}")
+
+      expect(doc.css('a').first.attr('href')).to eq urls.project_url(project)
+    end
+
+    it 'supports mentioning a project in a nested group' do
+      reference = get_reference(nested_project)
+      doc = reference_filter("Hey #{reference}")
+
+      expect(doc.css('a').first.attr('href')).to eq urls.project_url(nested_project)
+    end
+  end
+
+  describe '#projects_hash' do
+    it 'returns a Hash containing all Projects' do
+      document = Nokogiri::HTML.fragment("<p>#{get_reference(project)}</p>")
+      filter = described_class.new(document, project: project)
+
+      expect(filter.projects_hash).to eq({ project.full_path => project })
+    end
+  end
+
+  describe '#projects' do
+    it 'returns the projects mentioned in a document' do
+      document = Nokogiri::HTML.fragment("<p>#{get_reference(project)}</p>")
+      filter = described_class.new(document, project: project)
+
+      expect(filter.projects).to eq([project.full_path])
+    end
+  end
+end
diff --git a/spec/lib/banzai/reference_parser/project_parser_spec.rb b/spec/lib/banzai/reference_parser/project_parser_spec.rb
new file mode 100644
index 00000000000..4a6c2294fbd
--- /dev/null
+++ b/spec/lib/banzai/reference_parser/project_parser_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Banzai::ReferenceParser::ProjectParser do
+  include ReferenceParserHelpers
+
+  let(:project) { create(:project, :public) }
+  let(:user) { create(:user) }
+  subject { described_class.new(Banzai::RenderContext.new(project, user)) }
+  let(:link) { empty_html_link }
+
+  describe '#referenced_by' do
+    describe 'when the link has a data-project attribute' do
+      context 'using an existing project ID' do
+        it 'returns an Array of projects' do
+          link['data-project'] = project.id.to_s
+
+          expect(subject.referenced_by([link])).to eq([project])
+        end
+      end
+
+      context 'using a non-existing project ID' do
+        it 'returns an empty Array' do
+          link['data-project'] = ''
+
+          expect(subject.referenced_by([link])).to eq([])
+        end
+      end
+    end
+  end
+end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index abdc65336ca..acc7821a21e 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -344,6 +344,15 @@ describe Project do
     it { is_expected.to delegate_method(:name).to(:owner).with_prefix(true).with_arguments(allow_nil: true) }
   end
 
+  describe '#to_reference_with_postfix' do
+    it 'returns the full path with reference_postfix' do
+      namespace = create(:namespace, path: 'sample-namespace')
+      project = create(:project, path: 'sample-project', namespace: namespace)
+
+      expect(project.to_reference_with_postfix).to eq 'sample-namespace/sample-project>'
+    end
+  end
+
   describe '#to_reference' do
     let(:owner)     { create(:user, name: 'Gitlab') }
     let(:namespace) { create(:namespace, path: 'sample-namespace', owner: owner) }