Add shorthand support to gitlab markdown references

23 files changed, 894 insertions, 153 deletions

diff --git a/spec/features/issues/move_spec.rb b/spec/features/issues/move_spec.rb
index c9bec05a9da..f89b4db9e62 100644
--- a/spec/features/issues/move_spec.rb
+++ b/spec/features/issues/move_spec.rb
@@ -28,7 +28,7 @@ feature 'issue move to another project' do
     let(:new_project) { create(:project) }
     let(:new_project_search) { create(:project) }
     let(:text) { "Text with #{mr.to_reference}" }
-    let(:cross_reference) { old_project.to_reference }
+    let(:cross_reference) { old_project.to_reference(new_project) }
 
     background do
       old_project.team << [user, :reporter]
diff --git a/spec/features/merge_requests/create_new_mr_spec.rb b/spec/features/merge_requests/create_new_mr_spec.rb
index 702869b6e8b..f1b68a39343 100644
--- a/spec/features/merge_requests/create_new_mr_spec.rb
+++ b/spec/features/merge_requests/create_new_mr_spec.rb
@@ -40,7 +40,7 @@ feature 'Create New Merge Request', feature: true, js: true do
 
       visit new_namespace_project_merge_request_path(project.namespace, project, merge_request: { target_project_id: private_project.id })
 
-      expect(page).not_to have_content private_project.to_reference
+      expect(page).not_to have_content private_project.path_with_namespace
     end
   end
 
diff --git a/spec/helpers/labels_helper_spec.rb b/spec/helpers/labels_helper_spec.rb
index d30daf47543..7cf535fadae 100644
--- a/spec/helpers/labels_helper_spec.rb
+++ b/spec/helpers/labels_helper_spec.rb
@@ -7,7 +7,7 @@ describe LabelsHelper do
 
     context 'without subject' do
       it "uses the label's project" do
-        expect(link_to_label(label)).to match %r{<a href="/#{label.project.to_reference}/issues\?label_name%5B%5D=#{label.name}">.*</a>}
+        expect(link_to_label(label)).to match %r{<a href="/#{label.project.path_with_namespace}/issues\?label_name%5B%5D=#{label.name}">.*</a>}
       end
     end
 
@@ -32,7 +32,7 @@ describe LabelsHelper do
       ['issue', :issue, 'merge_request', :merge_request].each do |type|
         context "set to #{type}" do
           it 'links to correct page' do
-            expect(link_to_label(label, type: type)).to match %r{<a href="/#{label.project.to_reference}/#{type.to_s.pluralize}\?label_name%5B%5D=#{label.name}">.*</a>}
+            expect(link_to_label(label, type: type)).to match %r{<a href="/#{label.project.path_with_namespace}/#{type.to_s.pluralize}\?label_name%5B%5D=#{label.name}">.*</a>}
           end
         end
       end
diff --git a/spec/lib/banzai/filter/abstract_link_filter_spec.rb b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
index 1ee31a603e4..70a87fbc01e 100644
--- a/spec/lib/banzai/filter/abstract_link_filter_spec.rb
+++ b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
@@ -5,7 +5,7 @@ describe Banzai::Filter::AbstractReferenceFilter do
 
   describe '#references_per_project' do
     it 'returns a Hash containing references grouped per project paths' do
-      doc = Nokogiri::HTML.fragment("#1 #{project.to_reference}#2")
+      doc = Nokogiri::HTML.fragment("#1 #{project.path_with_namespace}#2")
       filter = described_class.new(doc, project: project)
 
       expect(filter).to receive(:object_class).exactly(4).times.and_return(Issue)
@@ -14,7 +14,7 @@ describe Banzai::Filter::AbstractReferenceFilter do
       refs = filter.references_per_project
 
       expect(refs).to be_an_instance_of(Hash)
-      expect(refs[project.to_reference]).to eq(Set.new(%w[1 2]))
+      expect(refs[project.path_with_namespace]).to eq(Set.new(%w[1 2]))
     end
   end
 
diff --git a/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb b/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
index e6c90ad87ee..9703e2315b8 100644
--- a/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/commit_range_reference_filter_spec.rb
@@ -59,9 +59,7 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
     it 'ignores invalid commit IDs' do
       exp = act = "See #{commit1.id.reverse}...#{commit2.id}"
 
-      expect(project).to receive(:valid_repo?).and_return(true)
-      expect(project.repository).to receive(:commit).with(commit1.id.reverse)
-      expect(project.repository).to receive(:commit).with(commit2.id)
+      allow(project.repository).to receive(:commit).with(commit1.id.reverse)
       expect(reference_filter(act).to_html).to eq exp
     end
 
@@ -100,14 +98,44 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
-    let(:project2)  { create(:project, :public, namespace: namespace) }
-    let(:reference) { range.to_reference(project) }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:project2)  { create(:project, :public) }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit1.id}...#{commit2.id}" }
 
-    before do
-      range.project = project2
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path_with_namespace}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path_with_namespace}@#{commit1.short_id}...#{commit2.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Fixed #{project2.path_with_namespace}@#{commit1.id.reverse}...#{commit2.id}"
+      expect(reference_filter(act).to_html).to eq exp
+
+      exp = act = "Fixed #{project2.path_with_namespace}@#{commit1.id}...#{commit2.id.reverse}"
+      expect(reference_filter(act).to_html).to eq exp
     end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace)         { create(:namespace) }
+    let(:project)           { create(:project, :public, namespace: namespace) }
+    let(:project2)          { create(:project, :public, path: "same-namespace", namespace: namespace) }
+    let(:reference)         { "#{project2.path}@#{commit1.id}...#{commit2.id}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
@@ -116,24 +144,65 @@ describe Banzai::Filter::CommitRangeReferenceFilter, lib: true do
         to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Fixed (#{reference}.)")
 
-      exp = Regexp.escape("#{project2.to_reference}@#{range.reference_link_text}")
-      expect(doc.to_html).to match(/\(<a.+>#{exp}<\/a>\.\)/)
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path}@#{commit1.short_id}...#{commit2.short_id}.)")
     end
 
     it 'ignores invalid commit IDs on the referenced project' do
-      exp = act = "Fixed #{project2.to_reference}@#{commit1.id.reverse}...#{commit2.id}"
+      exp = act = "Fixed #{project2.path}@#{commit1.id.reverse}...#{commit2.id}"
       expect(reference_filter(act).to_html).to eq exp
 
-      exp = act = "Fixed #{project2.to_reference}@#{commit1.id}...#{commit2.id.reverse}"
+      exp = act = "Fixed #{project2.path}@#{commit1.id}...#{commit2.id.reverse}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace)         { create(:namespace) }
+    let(:project)           { create(:project, :public, namespace: namespace) }
+    let(:project2)          { create(:project, :public, path: "same-namespace", namespace: namespace) }
+    let(:reference)         { "#{project2.path}@#{commit1.id}...#{commit2.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_compare_url(project2.namespace, project2, range.to_param)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eql("#{project2.path}@#{commit1.short_id}...#{commit2.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eql("Fixed (#{project2.path}@#{commit1.short_id}...#{commit2.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Fixed #{project2.path}@#{commit1.id.reverse}...#{commit2.id}"
+      expect(reference_filter(act).to_html).to eq exp
+
+      exp = act = "Fixed #{project2.path}@#{commit1.id}...#{commit2.id.reverse}"
       expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   context 'cross-project URL reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:range)  { CommitRange.new("#{commit1.id}...master", project) }
     let(:reference) { urls.namespace_project_compare_url(project2.namespace, project2, from: commit1.id, to: 'master') }
diff --git a/spec/lib/banzai/filter/commit_reference_filter_spec.rb b/spec/lib/banzai/filter/commit_reference_filter_spec.rb
index e0f08282551..2e6dcc3a434 100644
--- a/spec/lib/banzai/filter/commit_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/commit_reference_filter_spec.rb
@@ -41,6 +41,7 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
 
     it 'links with adjacent text' do
       doc = reference_filter("See (#{reference}.)")
+
       expect(doc.to_html).to match(/\(<a.+>#{commit.short_id}<\/a>\.\)/)
     end
 
@@ -48,8 +49,6 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
       invalid = invalidate_reference(reference)
       exp = act = "See #{invalid}"
 
-      expect(project).to receive(:valid_repo?).and_return(true)
-      expect(project.repository).to receive(:commit).with(invalid)
       expect(reference_filter(act).to_html).to eq exp
     end
 
@@ -95,34 +94,85 @@ describe Banzai::Filter::CommitReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:commit)    { project2.commit }
-    let(:reference) { commit.to_reference(project) }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
 
-    it 'links to a valid reference' do
-      doc = reference_filter("See #{reference}")
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
 
-      expect(doc.css('a').first.attr('href')).
-        to eq urls.namespace_project_commit_url(project2.namespace, project2, commit.id)
+      expect(doc.css('a').first.text).to eql("#{project2.path_with_namespace}@#{commit.short_id}")
     end
 
-    it 'links with adjacent text' do
-      doc = reference_filter("Fixed (#{reference}.)")
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path_with_namespace}@#{commit.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Committed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:project, :public, namespace: namespace) }
+    let(:commit)    { project2.commit }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
 
-      exp = Regexp.escape(project2.to_reference)
-      expect(doc.to_html).to match(/\(<a.+>#{exp}@#{commit.short_id}<\/a>\.\)/)
+      expect(doc.css('a').first.text).to eql("#{project2.path}@#{commit.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}@#{commit.short_id}.)")
     end
 
     it 'ignores invalid commit IDs on the referenced project' do
       exp = act = "Committed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:project, :public, namespace: namespace) }
+    let(:commit)    { project2.commit }
+    let(:reference) { "#{project2.path_with_namespace}@#{commit.short_id}" }
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}@#{commit.short_id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}@#{commit.short_id}.)")
+    end
+
+    it 'ignores invalid commit IDs on the referenced project' do
+      exp = act = "Committed #{invalidate_reference(reference)}"
+
       expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   context 'cross-project URL reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:project, :public, namespace: namespace) }
     let(:commit)    { project2.commit }
     let(:reference) { urls.namespace_project_commit_url(project2.namespace, project2, commit.id) }
diff --git a/spec/lib/banzai/filter/issue_reference_filter_spec.rb b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
index 8f0b2db3e8e..456dbac0698 100644
--- a/spec/lib/banzai/filter/issue_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
@@ -8,7 +8,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
   end
 
   let(:project) { create(:empty_project, :public) }
-  let(:issue)   { create(:issue, project: project) }
+  let(:issue)  { create(:issue, project: project) }
 
   it 'requires project context' do
     expect { described_class.call('') }.to raise_error(ArgumentError, /:project/)
@@ -24,7 +24,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
   context 'internal reference' do
     it_behaves_like 'a reference containing an element node'
 
-    let(:reference) { issue.to_reference }
+    let(:reference) { "##{issue.iid}" }
 
     it 'ignores valid references when using non-default tracker' do
       allow(project).to receive(:default_issues_tracker?).and_return(false)
@@ -42,7 +42,7 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
 
     it 'links with adjacent text' do
       doc = reference_filter("Fixed (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+      expect(doc.text).to eql("Fixed (#{reference}.)")
     end
 
     it 'ignores invalid issue IDs' do
@@ -116,13 +116,56 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
+  context 'cross-project / cross-namespace complete reference' do
     it_behaves_like 'a reference containing an element node'
 
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+    let(:project2)  { create(:empty_project, :public) }
+    let(:issue)     { create(:issue, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}##{issue.iid}" }
+
+    it 'ignores valid references when cross-reference project uses external tracker' do
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project2, issue.iid).
+        and_return(nil)
+
+      exp = act = "Issue #{reference}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq helper.url_for_issue(issue.iid, project2)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path_with_namespace}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path_with_namespace}##{issue.iid}.)")
+    end
+
+    it 'ignores invalid issue IDs on the referenced project' do
+      exp = act = "Fixed #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    it_behaves_like 'a reference containing an element node'
+
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
     let(:project2)  { create(:empty_project, :public, namespace: namespace) }
     let(:issue)     { create(:issue, project: project2) }
-    let(:reference) { issue.to_reference(project) }
+    let(:reference) { "#{project2.path_with_namespace}##{issue.iid}" }
 
     it 'ignores valid references when cross-reference project uses external tracker' do
       expect_any_instance_of(described_class).to receive(:find_object).
@@ -140,9 +183,16 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
         to eq helper.url_for_issue(issue.iid, project2)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Fixed (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path}##{issue.iid}.)")
     end
 
     it 'ignores invalid issue IDs on the referenced project' do
@@ -150,9 +200,47 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
 
       expect(reference_filter(act).to_html).to eq exp
     end
+  end
+
+  context 'cross-project shorthand reference' do
+    it_behaves_like 'a reference containing an element node'
 
-    it 'ignores out-of-bounds issue IDs on the referenced project' do
-      exp = act = "Fixed ##{Gitlab::Database::MAX_INT_VALUE + 1}"
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let(:issue)     { create(:issue, project: project2) }
+    let(:reference) { "#{project2.path}##{issue.iid}" }
+
+    it 'ignores valid references when cross-reference project uses external tracker' do
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project2, issue.iid).
+        and_return(nil)
+
+      exp = act = "Issue #{reference}"
+      expect(reference_filter(act).to_html).to eq exp
+    end
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq helper.url_for_issue(issue.iid, project2)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}##{issue.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Fixed (#{reference}.)")
+
+      expect(doc.text).to eq("Fixed (#{project2.path}##{issue.iid}.)")
+    end
+
+    it 'ignores invalid issue IDs on the referenced project' do
+      exp = act = "Fixed #{invalidate_reference(reference)}"
 
       expect(reference_filter(act).to_html).to eq exp
     end
diff --git a/spec/lib/banzai/filter/label_reference_filter_spec.rb b/spec/lib/banzai/filter/label_reference_filter_spec.rb
index 9c09f00ae8a..284641fb20a 100644
--- a/spec/lib/banzai/filter/label_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/label_reference_filter_spec.rb
@@ -4,7 +4,7 @@ require 'html/pipeline'
 describe Banzai::Filter::LabelReferenceFilter, lib: true do
   include FilterSpecHelper
 
-  let(:project)   { create(:empty_project, :public) }
+  let(:project)   { create(:empty_project, :public, name: 'sample-project') }
   let(:label)     { create(:label, project: project) }
   let(:reference) { label.to_reference }
 
@@ -48,6 +48,14 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     expect(link).to eq urls.namespace_project_issues_path(project.namespace, project, label_name: label.name)
   end
 
+  context 'project that does not exist referenced' do
+    let(:result) { reference_filter('aaa/bbb~ccc') }
+
+    it 'does not link reference' do
+      expect(result.to_html).to eq 'aaa/bbb~ccc'
+    end
+  end
+
   describe 'label span element' do
     it 'includes default classes' do
       doc = reference_filter("Label #{reference}")
@@ -334,14 +342,14 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     end
 
     context 'with project reference' do
-      let(:reference) { project.to_reference + group_label.to_reference(format: :name) }
+      let(:reference) { "#{project.to_reference}#{group_label.to_reference(format: :name)}" }
 
       it 'links to a valid reference' do
         doc = reference_filter("See #{reference}", project: project)
 
         expect(doc.css('a').first.attr('href')).to eq urls.
           namespace_project_issues_url(project.namespace, project, label_name: group_label.name)
-        expect(doc.text).to eq 'See gfm references'
+        expect(doc.text).to eq "See gfm references"
       end
 
       it 'links with adjacent text' do
@@ -357,68 +365,247 @@ describe Banzai::Filter::LabelReferenceFilter, lib: true do
     end
   end
 
-  describe 'cross project label references' do
-    context 'valid project referenced' do
-      let(:another_project)  { create(:empty_project, :public) }
-      let(:project_name) { another_project.name_with_namespace }
-      let(:label) { create(:label, project: another_project, color: '#00ff00') }
-      let(:reference) { label.to_reference(project) }
+  describe 'cross-project / cross-namespace complete reference' do
+    let(:project2)  { create(:empty_project) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path_with_namespace}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
 
-      let!(:result) { reference_filter("See #{reference}") }
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
 
-      it 'points to referenced project issues page' do
-        expect(result.css('a').first.attr('href'))
-          .to eq urls.namespace_project_issues_url(another_project.namespace,
-                                                   another_project,
-                                                   label_name: label.name)
-      end
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).to match /background-color: #00ff00/
+    end
 
-      it 'has valid color' do
-        expect(result.css('a span').first.attr('style'))
-          .to match /background-color: #00ff00/
-      end
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name_with_namespace}"
+    end
 
-      it 'contains cross project content' do
-        expect(result.css('a').first.text).to eq "#{label.name} in #{project_name}"
-      end
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name_with_namespace}"
     end
 
-    context 'project that does not exist referenced' do
-      let(:result) { reference_filter('aaa/bbb~ccc') }
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
 
-      it 'does not link reference' do
-        expect(result.to_html).to eq 'aaa/bbb~ccc'
-      end
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:empty_project, namespace: namespace) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path_with_namespace}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
+
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, namespace: namespace) }
+    let(:project2)  { create(:empty_project, namespace: namespace) }
+    let(:label)     { create(:label, project: project2, color: '#00ff00') }
+    let(:reference) { "#{project2.path}~#{label.name}" }
+    let!(:result)   { reference_filter("See #{reference}") }
+
+    it 'links to a valid reference' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project2.namespace,
+                                                 project2,
+                                                 label_name: label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq "#{label.name} in #{project2.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{label.name} in #{project2.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
     end
   end
 
   describe 'cross group label references' do
-    context 'valid project referenced' do
-      let(:group) { create(:group) }
-      let(:project) { create(:empty_project, :public, namespace: group) }
-      let(:another_group) { create(:group) }
-      let(:another_project)  { create(:empty_project, :public, namespace: another_group) }
-      let(:project_name) { another_project.name_with_namespace }
-      let(:group_label) { create(:group_label, group: another_group, color: '#00ff00') }
-      let(:reference) { another_project.to_reference + group_label.to_reference }
-
-      let!(:result) { reference_filter("See #{reference}", project: project) }
-
-      it 'points to referenced project issues page' do
-        expect(result.css('a').first.attr('href'))
-          .to eq urls.namespace_project_issues_url(another_project.namespace,
-                                                   another_project,
-                                                   label_name: group_label.name)
-      end
+    let(:group)            { create(:group) }
+    let(:project)          { create(:empty_project, :public, namespace: group) }
+    let(:another_group)    { create(:group) }
+    let(:another_project)  { create(:empty_project, :public, namespace: another_group) }
+    let(:group_label)      { create(:group_label, group: another_group, color: '#00ff00') }
+    let(:reference)        { "#{another_project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)          { reference_filter("See #{reference}", project: project) }
 
-      it 'has valid color' do
-        expect(result.css('a span').first.attr('style'))
-          .to match /background-color: #00ff00/
-      end
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(another_project.namespace,
+                                                 another_project,
+                                                 label_name: group_label.name)
+    end
 
-      it 'contains cross project content' do
-        expect(result.css('a').first.text).to eq "#{group_label.name} in #{project_name}"
-      end
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).
+        to eq "#{group_label.name} in #{another_project.name_with_namespace}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).
+        to eq "See #{group_label.name} in #{another_project.name_with_namespace}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'cross-project / same-group_label complete reference' do
+    let(:group)            { create(:group) }
+    let(:project)          { create(:empty_project, :public, namespace: group) }
+    let(:another_project)  { create(:empty_project, :public, namespace: group) }
+    let(:group_label)      { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)        { "#{another_project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)          { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href')).
+        to eq urls.namespace_project_issues_url(another_project.namespace,
+                                                 another_project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).
+        to eq "#{group_label.name} in #{another_project.name}"
+    end
+
+    it 'has valid text' do
+      expect(result.text).
+        to eq "See #{group_label.name} in #{another_project.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'same project / same group_label complete reference' do
+    let(:group)       { create(:group) }
+    let(:project)     { create(:empty_project, :public, namespace: group) }
+    let(:group_label) { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)   { "#{project.path_with_namespace}~#{group_label.name}" }
+    let!(:result)     { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project.namespace,
+                                                 project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style'))
+        .to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq group_label.name
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{group_label.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  describe 'same project / same group_label shorthand reference' do
+    let(:group)       { create(:group) }
+    let(:project)     { create(:empty_project, :public, namespace: group) }
+    let(:group_label) { create(:group_label, group: group, color: '#00ff00') }
+    let(:reference)   { "#{project.path}~#{group_label.name}" }
+    let!(:result)     { reference_filter("See #{reference}", project: project) }
+
+    it 'points to referenced project issues page' do
+      expect(result.css('a').first.attr('href'))
+        .to eq urls.namespace_project_issues_url(project.namespace,
+                                                 project,
+                                                 label_name: group_label.name)
+    end
+
+    it 'has valid color' do
+      expect(result.css('a span').first.attr('style')).
+        to match /background-color: #00ff00/
+    end
+
+    it 'has valid link text' do
+      expect(result.css('a').first.text).to eq group_label.name
+    end
+
+    it 'has valid text' do
+      expect(result.text).to eq "See #{group_label.name}"
+    end
+
+    it 'ignores invalid IDs on the referenced label' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
     end
   end
 end
diff --git a/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb b/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
index 274258a045c..275010c1a2c 100644
--- a/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/merge_request_reference_filter_spec.rb
@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Banzai::Filter::MergeRequestReferenceFilter, lib: true do
   include FilterSpecHelper
 
-  let(:project) { create(:project, :public) }
+  let(:project) { create(:empty_project, :public) }
   let(:merge)   { create(:merge_request, source_project: project) }
 
   it 'requires project context' do
@@ -86,23 +86,97 @@ describe Banzai::Filter::MergeRequestReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
-    let(:project2)  { create(:project, :public, namespace: namespace) }
-    let(:merge)     { create(:merge_request, source_project: project2) }
-    let(:reference) { merge.to_reference(project) }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:project2)          { create(:empty_project, :public) }
+    let(:merge)             { create(:merge_request, source_project: project2) }
+    let(:reference)         { "#{project2.path_with_namespace}!#{merge.iid}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
 
       expect(doc.css('a').first.attr('href')).
         to eq urls.namespace_project_merge_request_url(project2.namespace,
-                                                      project, merge)
+                                                       project2, merge)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("Merge (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eq(reference)
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{reference}.)")
+    end
+
+    it 'ignores invalid merge IDs on the referenced project' do
+      exp = act = "Merge #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:merge)    { create(:merge_request, source_project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}!#{merge.iid}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_merge_request_url(project2.namespace,
+                                                      project2, merge)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eq("#{project2.path}!#{merge.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{project2.path}!#{merge.iid}.)")
+    end
+
+    it 'ignores invalid merge IDs on the referenced project' do
+      exp = act = "Merge #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:merge)    { create(:merge_request, source_project: project2) }
+    let(:reference) { "#{project2.path}!#{merge.iid}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_merge_request_url(project2.namespace,
+                                                      project2, merge)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.css('a').first.text).to eq("#{project2.path}!#{merge.iid}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("Merge (#{reference}.)")
+
+      expect(doc.text).to eq("Merge (#{project2.path}!#{merge.iid}.)")
     end
 
     it 'ignores invalid merge IDs on the referenced project' do
diff --git a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
index 7419863d848..73b5edb99b3 100644
--- a/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/milestone_reference_filter_spec.rb
@@ -148,13 +148,51 @@ describe Banzai::Filter::MilestoneReferenceFilter, lib: true do
     end
   end
 
-  describe 'cross project milestone references' do
-    let(:another_project)  { create(:empty_project, :public) }
-    let(:project_path) { another_project.path_with_namespace }
-    let(:milestone) { create(:milestone, project: another_project) }
-    let(:reference) { milestone.to_reference(project) }
+  describe 'cross-project / cross-namespace complete reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path_with_namespace}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
 
-    let!(:result) { reference_filter("See #{reference}") }
+    it 'points to referenced project milestone page' do
+      expect(result.css('a').first.attr('href')).to eq urls.
+        namespace_project_milestone_url(another_project.namespace,
+                                        another_project,
+                                        milestone)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path_with_namespace}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path_with_namespace}.)")
+    end
+
+    it 'escapes the name attribute' do
+      allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path_with_namespace}"
+    end
+  end
+
+  describe 'cross-project / same-namespace complete reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:project)         { create(:empty_project, :public, namespace: namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path_with_namespace}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
 
     it 'points to referenced project milestone page' do
       expect(result.css('a').first.attr('href')).to eq urls.
@@ -163,14 +201,66 @@ describe Banzai::Filter::MilestoneReferenceFilter, lib: true do
                                         milestone)
     end
 
-    it 'contains cross project content' do
-      expect(result.css('a').first.text).to eq "#{milestone.name} in #{project_path}"
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path}.)")
     end
 
     it 'escapes the name attribute' do
       allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path}"
+    end
+  end
+
+  describe 'cross project shorthand reference' do
+    let(:namespace)       { create(:namespace) }
+    let(:project)         { create(:empty_project, :public, namespace: namespace) }
+    let(:another_project) { create(:empty_project, :public, namespace: namespace) }
+    let(:milestone)       { create(:milestone, project: another_project) }
+    let(:reference)       { "#{another_project.path}%#{milestone.iid}" }
+    let!(:result)         { reference_filter("See #{reference}") }
+
+    it 'points to referenced project milestone page' do
+      expect(result.css('a').first.attr('href')).to eq urls.
+        namespace_project_milestone_url(another_project.namespace,
+                                        another_project,
+                                        milestone)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.css('a').first.text).
+        to eq("#{milestone.name} in #{another_project.path}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).
+        to eq("See (#{milestone.name} in #{another_project.path}.)")
+    end
+
+    it 'escapes the name attribute' do
+      allow_any_instance_of(Milestone).to receive(:title).and_return(%{"></a>whatever<a title="})
+
       doc = reference_filter("See #{reference}")
-      expect(doc.css('a').first.text).to eq "#{milestone.name} in #{project_path}"
+
+      expect(doc.css('a').first.text).
+        to eq "#{milestone.name} in #{another_project.path}"
     end
   end
 end
diff --git a/spec/lib/banzai/filter/snippet_reference_filter_spec.rb b/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
index 9b92d1a3926..e036514d283 100644
--- a/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/snippet_reference_filter_spec.rb
@@ -79,11 +79,11 @@ describe Banzai::Filter::SnippetReferenceFilter, lib: true do
     end
   end
 
-  context 'cross-project reference' do
-    let(:namespace) { create(:namespace, name: 'cross-reference') }
+  context 'cross-project / cross-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
     let(:project2)  { create(:empty_project, :public, namespace: namespace) }
-    let(:snippet)   { create(:project_snippet, project: project2) }
-    let(:reference) { snippet.to_reference(project) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}$#{snippet.id}" }
 
     it 'links to a valid reference' do
       doc = reference_filter("See #{reference}")
@@ -92,9 +92,82 @@ describe Banzai::Filter::SnippetReferenceFilter, lib: true do
         to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
     end
 
-    it 'links with adjacent text' do
+    it 'link has valid text' do
       doc = reference_filter("See (#{reference}.)")
-      expect(doc.to_html).to match(/\(<a.+>#{Regexp.escape(reference)}<\/a>\.\)/)
+
+      expect(doc.css('a').first.text).to eql(reference)
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{reference}.)")
+
+      expect(doc.text).to eql("See (#{reference}.)")
+    end
+
+    it 'ignores invalid snippet IDs on the referenced project' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project / same-namespace complete reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path_with_namespace}$#{snippet.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}$#{snippet.id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}$#{snippet.id}.)")
+    end
+
+    it 'ignores invalid snippet IDs on the referenced project' do
+      exp = act = "See #{invalidate_reference(reference)}"
+
+      expect(reference_filter(act).to_html).to eq exp
+    end
+  end
+
+  context 'cross-project shorthand reference' do
+    let(:namespace) { create(:namespace) }
+    let(:project)   { create(:empty_project, :public, namespace: namespace) }
+    let(:project2)  { create(:empty_project, :public, namespace: namespace) }
+    let!(:snippet)  { create(:project_snippet, project: project2) }
+    let(:reference) { "#{project2.path}$#{snippet.id}" }
+
+    it 'links to a valid reference' do
+      doc = reference_filter("See #{reference}")
+
+      expect(doc.css('a').first.attr('href')).
+        to eq urls.namespace_project_snippet_url(project2.namespace, project2, snippet)
+    end
+
+    it 'link has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.css('a').first.text).to eql("#{project2.path}$#{snippet.id}")
+    end
+
+    it 'has valid text' do
+      doc = reference_filter("See (#{project2.path}$#{snippet.id}.)")
+
+      expect(doc.text).to eql("See (#{project2.path}$#{snippet.id}.)")
     end
 
     it 'ignores invalid snippet IDs on the referenced project' do
diff --git a/spec/lib/gitlab/gfm/reference_rewriter_spec.rb b/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
index 6b3dfebd85d..d619e401897 100644
--- a/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
+++ b/spec/lib/gitlab/gfm/reference_rewriter_spec.rb
@@ -64,7 +64,7 @@ describe Gitlab::Gfm::ReferenceRewriter do
 
         context 'description with project labels' do
           let!(:label) { create(:label, id: 123, name: 'test', project: old_project) }
-          let(:project_ref) { old_project.to_reference }
+          let(:project_ref) { old_project.to_reference(new_project) }
 
           context 'label referenced by id' do
             let(:text) { '#1 and ~123' }
@@ -80,7 +80,7 @@ describe Gitlab::Gfm::ReferenceRewriter do
         context 'description with group labels' do
           let(:old_group) { create(:group) }
           let!(:group_label) { create(:group_label, id: 321, name: 'group label', group: old_group) }
-          let(:project_ref) { old_project.to_reference }
+          let(:project_ref) { old_project.to_reference(new_project) }
 
           before do
             old_project.update(namespace: old_group)
diff --git a/spec/models/commit_range_spec.rb b/spec/models/commit_range_spec.rb
index c41359b55a3..d89d4342dea 100644
--- a/spec/models/commit_range_spec.rb
+++ b/spec/models/commit_range_spec.rb
@@ -45,7 +45,7 @@ describe CommitRange, models: true do
   end
 
   describe '#to_reference' do
-    let(:cross) { create(:project) }
+    let(:cross) { create(:empty_project, namespace: project.namespace) }
 
     it 'returns a String reference to the object' do
       expect(range.to_reference).to eq "#{full_sha_from}...#{full_sha_to}"
@@ -56,12 +56,12 @@ describe CommitRange, models: true do
     end
 
     it 'supports a cross-project reference' do
-      expect(range.to_reference(cross)).to eq "#{project.to_reference}@#{full_sha_from}...#{full_sha_to}"
+      expect(range.to_reference(cross)).to eq "#{project.path}@#{full_sha_from}...#{full_sha_to}"
     end
   end
 
   describe '#reference_link_text' do
-    let(:cross) { create(:project) }
+    let(:cross) { create(:empty_project, namespace: project.namespace) }
 
     it 'returns a String reference to the object' do
       expect(range.reference_link_text).to eq "#{sha_from}...#{sha_to}"
@@ -72,7 +72,7 @@ describe CommitRange, models: true do
     end
 
     it 'supports a cross-project reference' do
-      expect(range.reference_link_text(cross)).to eq "#{project.to_reference}@#{sha_from}...#{sha_to}"
+      expect(range.reference_link_text(cross)).to eq "#{project.path}@#{sha_from}...#{sha_to}"
     end
   end
 
diff --git a/spec/models/commit_spec.rb b/spec/models/commit_spec.rb
index 7194c20d3bf..eb482c7f913 100644
--- a/spec/models/commit_spec.rb
+++ b/spec/models/commit_spec.rb
@@ -34,24 +34,30 @@ describe Commit, models: true do
   end
 
   describe '#to_reference' do
+    let(:project) { create(:project, path: 'sample-project') }
+    let(:commit)  { project.commit }
+
     it 'returns a String reference to the object' do
       expect(commit.to_reference).to eq commit.id
     end
 
     it 'supports a cross-project reference' do
-      cross = double('project')
-      expect(commit.to_reference(cross)).to eq "#{project.to_reference}@#{commit.id}"
+      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      expect(commit.to_reference(another_project)).to eq "sample-project@#{commit.id}"
     end
   end
 
   describe '#reference_link_text' do
+    let(:project) { create(:project, path: 'sample-project') }
+    let(:commit)  { project.commit }
+
     it 'returns a String reference to the object' do
       expect(commit.reference_link_text).to eq commit.short_id
     end
 
     it 'supports a cross-project reference' do
-      cross = double('project')
-      expect(commit.reference_link_text(cross)).to eq "#{project.to_reference}@#{commit.short_id}"
+      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      expect(commit.reference_link_text(another_project)).to eq "sample-project@#{commit.short_id}"
     end
   end
 
diff --git a/spec/models/group_label_spec.rb b/spec/models/group_label_spec.rb
index 2369658bf78..668aa6fb357 100644
--- a/spec/models/group_label_spec.rb
+++ b/spec/models/group_label_spec.rb
@@ -37,6 +37,16 @@ describe GroupLabel, models: true do
       end
     end
 
+    context 'cross-project' do
+      let(:namespace) { build_stubbed(:namespace) }
+      let(:source_project) { build_stubbed(:empty_project, name: 'project-1', namespace: namespace) }
+      let(:target_project) { build_stubbed(:empty_project, name: 'project-2', namespace: namespace) }
+
+      it 'returns a String reference to the object' do
+        expect(label.to_reference(source_project, target_project)).to eq %(project-1~#{label.id})
+      end
+    end
+
     context 'using invalid format' do
       it 'raises error' do
         expect { label.to_reference(format: :invalid) }
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 89e93dce8c5..24e216329a9 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -43,14 +43,16 @@ describe Issue, models: true do
   end
 
   describe '#to_reference' do
+    let(:project) { build(:empty_project, name: 'sample-project') }
+    let(:issue) { build(:issue, iid: 1, project: project) }
+
     it 'returns a String reference to the object' do
-      expect(subject.to_reference).to eq "##{subject.iid}"
+      expect(issue.to_reference).to eq "#1"
     end
 
     it 'supports a cross-project reference' do
-      cross = double('project')
-      expect(subject.to_reference(cross)).
-        to eq "#{subject.project.to_reference}##{subject.iid}"
+      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      expect(issue.to_reference(another_project)).to eq "sample-project#1"
     end
   end
 
diff --git a/spec/models/merge_request_spec.rb b/spec/models/merge_request_spec.rb
index ec22ef93465..b9deb04da3a 100644
--- a/spec/models/merge_request_spec.rb
+++ b/spec/models/merge_request_spec.rb
@@ -142,13 +142,16 @@ describe MergeRequest, models: true do
   end
 
   describe '#to_reference' do
+    let(:project) { build(:empty_project, name: 'sample-project') }
+    let(:merge_request) { build(:merge_request, target_project: project, iid: 1) }
+
     it 'returns a String reference to the object' do
-      expect(subject.to_reference).to eq "!#{subject.iid}"
+      expect(merge_request.to_reference).to eq "!1"
     end
 
     it 'supports a cross-project reference' do
-      cross = double('project')
-      expect(subject.to_reference(cross)).to eq "#{subject.source_project.to_reference}!#{subject.iid}"
+      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      expect(merge_request.to_reference(another_project)).to eq "sample-project!1"
     end
   end
 
diff --git a/spec/models/milestone_spec.rb b/spec/models/milestone_spec.rb
index a4bfe851dfb..0cc2efae5f9 100644
--- a/spec/models/milestone_spec.rb
+++ b/spec/models/milestone_spec.rb
@@ -246,4 +246,18 @@ describe Milestone, models: true do
       end
     end
   end
+
+  describe '#to_reference' do
+    let(:project) { build(:empty_project, name: 'sample-project') }
+    let(:milestone) { build(:milestone, iid: 1, project: project) }
+
+    it 'returns a String reference to the object' do
+      expect(milestone.to_reference).to eq "%1"
+    end
+
+    it 'supports a cross-project reference' do
+      another_project = build(:project, name: 'another-project', namespace: project.namespace)
+      expect(milestone.to_reference(another_project)).to eq "sample-project%1"
+    end
+  end
 end
diff --git a/spec/models/project_label_spec.rb b/spec/models/project_label_spec.rb
index 18c9d449ee5..4d538cac007 100644
--- a/spec/models/project_label_spec.rb
+++ b/spec/models/project_label_spec.rb
@@ -105,14 +105,14 @@ describe ProjectLabel, models: true do
       context 'using name' do
         it 'returns cross reference with label name' do
           expect(label.to_reference(project, format: :name))
-            .to eq %Q(#{label.project.to_reference}~"#{label.name}")
+            .to eq %Q(#{label.project.path_with_namespace}~"#{label.name}")
         end
       end
 
       context 'using id' do
         it 'returns cross reference with label id' do
           expect(label.to_reference(project, format: :id))
-            .to eq %Q(#{label.project.to_reference}~#{label.id})
+            .to eq %Q(#{label.project.path_with_namespace}~#{label.id})
         end
       end
     end
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index 8abcce42ce0..587ca1936a3 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -258,10 +258,70 @@ describe Project, models: true do
   end
 
   describe '#to_reference' do
-    let(:project) { create(:empty_project) }
+    let(:owner) { create(:user, name: 'Gitlab') }
+    let(:namespace) { create(:namespace, path: 'sample-namespace', owner: owner) }
+    let(:project) { create(:empty_project, path: 'sample-project', namespace: namespace) }
+
+    context 'when nil argument' do
+      it 'returns nil' do
+        expect(project.to_reference).to be_nil
+      end
+    end
+
+    context 'when same project argument' do
+      it 'returns nil' do
+        expect(project.to_reference(project)).to be_nil
+      end
+    end
 
-    it 'returns a String reference to the object' do
-      expect(project.to_reference).to eq project.path_with_namespace
+    context 'when cross namespace project argument' do
+      let(:another_namespace_project) { create(:empty_project, name: 'another-project') }
+
+      it 'returns complete path to the project' do
+        expect(project.to_reference(another_namespace_project)).to eq 'sample-namespace/sample-project'
+      end
+    end
+
+    context 'when same namespace / cross-project argument' do
+      let(:another_project) { create(:empty_project, namespace: namespace) }
+
+      it 'returns complete path to the project' do
+        expect(project.to_reference(another_project)).to eq 'sample-project'
+      end
+    end
+  end
+
+  describe '#to_human_reference' do
+    let(:owner) { create(:user, name: 'Gitlab') }
+    let(:namespace) { create(:namespace, name: 'Sample namespace', owner: owner) }
+    let(:project) { create(:empty_project, name: 'Sample project', namespace: namespace) }
+
+    context 'when nil argument' do
+      it 'returns nil' do
+        expect(project.to_human_reference).to be_nil
+      end
+    end
+
+    context 'when same project argument' do
+      it 'returns nil' do
+        expect(project.to_human_reference(project)).to be_nil
+      end
+    end
+
+    context 'when cross namespace project argument' do
+      let(:another_namespace_project) { create(:empty_project, name: 'another-project') }
+
+      it 'returns complete name with namespace of the project' do
+        expect(project.to_human_reference(another_namespace_project)).to eq 'Gitlab / Sample project'
+      end
+    end
+
+    context 'when same namespace / cross-project argument' do
+      let(:another_project) { create(:empty_project, namespace: namespace) }
+
+      it 'returns name of the project' do
+        expect(project.to_human_reference(another_project)).to eq 'Sample project'
+      end
     end
   end
 
diff --git a/spec/models/snippet_spec.rb b/spec/models/snippet_spec.rb
index f62f6bacbaa..79d2843e122 100644
--- a/spec/models/snippet_spec.rb
+++ b/spec/models/snippet_spec.rb
@@ -33,16 +33,31 @@ describe Snippet, models: true do
   end
 
   describe '#to_reference' do
-    let(:project) { create(:empty_project) }
-    let(:snippet) { create(:snippet, project: project) }
+    context 'when snippet belongs to a project' do
+      let(:project) { build(:empty_project, name: 'sample-project') }
+      let(:snippet) { build(:snippet, id: 1, project: project) }
+
+      it 'returns a String reference to the object' do
+        expect(snippet.to_reference).to eq "$1"
+      end
 
-    it 'returns a String reference to the object' do
-      expect(snippet.to_reference).to eq "$#{snippet.id}"
+      it 'supports a cross-project reference' do
+        another_project = build(:project, name: 'another-project', namespace: project.namespace)
+        expect(snippet.to_reference(another_project)).to eq "sample-project$1"
+      end
     end
 
-    it 'supports a cross-project reference' do
-      cross = double('project')
-      expect(snippet.to_reference(cross)).to eq "#{project.to_reference}$#{snippet.id}"
+    context 'when snippet does not belong to a project' do
+      let(:snippet) { build(:snippet, id: 1, project: nil) }
+
+      it 'returns a String reference to the object' do
+        expect(snippet.to_reference).to eq "$1"
+      end
+
+      it 'still returns shortest reference when project arg present' do
+        another_project = build(:project, name: 'another-project')
+        expect(snippet.to_reference(another_project)).to eq "$1"
+      end
     end
   end
 
diff --git a/spec/services/issues/move_service_spec.rb b/spec/services/issues/move_service_spec.rb
index c7de0d0c534..db196ed5751 100644
--- a/spec/services/issues/move_service_spec.rb
+++ b/spec/services/issues/move_service_spec.rb
@@ -189,7 +189,7 @@ describe Issues::MoveService, services: true do
 
           it 'rewrites references using a cross reference to old project' do
             expect(new_note.note)
-              .to eq "Note with reference to merge request #{old_project.to_reference}!1"
+              .to eq "Note with reference to merge request #{old_project.to_reference(new_project)}!1"
           end
         end
 
@@ -217,7 +217,7 @@ describe Issues::MoveService, services: true do
 
           it 'rewrites referenced issues creating cross project reference' do
             expect(new_issue.description)
-              .to eq "Some description #{old_project.to_reference}#{another_issue.to_reference}"
+              .to eq "Some description #{another_issue.to_reference(new_project)}"
           end
         end
 
diff --git a/spec/services/system_note_service_spec.rb b/spec/services/system_note_service_spec.rb
index 4a8f6c321aa..835d7467bd9 100644
--- a/spec/services/system_note_service_spec.rb
+++ b/spec/services/system_note_service_spec.rb
@@ -530,7 +530,7 @@ describe SystemNoteService, services: true do
       end
 
       it 'mentions referenced project' do
-        expect(subject.note).to include new_project.to_reference
+        expect(subject.note).to include new_project.path_with_namespace
       end
     end