From 181cd299f9e06223e8338e93b1c318c671ccb1aa Mon Sep 17 00:00:00 2001
From: Jacopo <beschi.jacopo@gmail.com>
Date: Tue, 14 Nov 2017 10:02:39 +0100
Subject: Adds Rubocop rule for line break after guard clause

Adds a rubocop rule (with autocorrect) to ensure line break after guard clauses.
---
 lib/banzai/object_renderer.rb              | 1 +
 lib/banzai/querying.rb                     | 2 ++
 lib/banzai/reference_parser/user_parser.rb | 1 +
 lib/banzai/renderer.rb                     | 2 ++
 4 files changed, 6 insertions(+)

(limited to 'lib/banzai')

diff --git a/lib/banzai/object_renderer.rb b/lib/banzai/object_renderer.rb
index 9bb8ed913d8..ecb3affbba5 100644
--- a/lib/banzai/object_renderer.rb
+++ b/lib/banzai/object_renderer.rb
@@ -86,6 +86,7 @@ module Banzai
 
     def save_options
       return {} unless base_context[:xhtml]
+
       { save_with: Nokogiri::XML::Node::SaveOptions::AS_XHTML }
     end
   end
diff --git a/lib/banzai/querying.rb b/lib/banzai/querying.rb
index fb2faae02bc..a19a05e8c0d 100644
--- a/lib/banzai/querying.rb
+++ b/lib/banzai/querying.rb
@@ -52,8 +52,10 @@ module Banzai
 
         children.each do |child|
           next if child.text.blank?
+
           node = nodes.shift
           break unless node == child
+
           filtered_nodes << node
         end
       end
diff --git a/lib/banzai/reference_parser/user_parser.rb b/lib/banzai/reference_parser/user_parser.rb
index 4d336068861..8932d4f2905 100644
--- a/lib/banzai/reference_parser/user_parser.rb
+++ b/lib/banzai/reference_parser/user_parser.rb
@@ -31,6 +31,7 @@ module Banzai
         nodes.each do |node|
           if node.has_attribute?(group_attr)
             next unless can_read_group_reference?(node, user, groups)
+
             visible << node
           elsif can_read_project_reference?(node)
             visible << node
diff --git a/lib/banzai/renderer.rb b/lib/banzai/renderer.rb
index 5cb9adf52b0..0050295eeda 100644
--- a/lib/banzai/renderer.rb
+++ b/lib/banzai/renderer.rb
@@ -149,6 +149,7 @@ module Banzai
 
     def self.full_cache_key(cache_key, pipeline_name)
       return unless cache_key
+
       ["banzai", *cache_key, pipeline_name || :full]
     end
 
@@ -157,6 +158,7 @@ module Banzai
     # method.
     def self.full_cache_multi_key(cache_key, pipeline_name)
       return unless cache_key
+
       Rails.cache.__send__(:expanded_key, full_cache_key(cache_key, pipeline_name)) # rubocop:disable GitlabSecurity/PublicSend
     end
   end
-- 
cgit v1.2.1


From 131e74d10dafbf2b781ab5d5517e42a18e20a587 Mon Sep 17 00:00:00 2001
From: "Vitaliy @blackst0ne Klachkov" <blackst0ne.ru@gmail.com>
Date: Wed, 22 Nov 2017 14:12:04 +1100
Subject: Add support of Mermaid

---
 lib/banzai/filter/mermaid_filter.rb          | 20 ++++++++++++++++
 lib/banzai/filter/syntax_highlight_filter.rb | 35 +++++++++++++++++-----------
 lib/banzai/pipeline/gfm_pipeline.rb          |  1 +
 3 files changed, 42 insertions(+), 14 deletions(-)
 create mode 100644 lib/banzai/filter/mermaid_filter.rb

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/mermaid_filter.rb b/lib/banzai/filter/mermaid_filter.rb
new file mode 100644
index 00000000000..b545b947a2c
--- /dev/null
+++ b/lib/banzai/filter/mermaid_filter.rb
@@ -0,0 +1,20 @@
+module Banzai
+  module Filter
+    class MermaidFilter < HTML::Pipeline::Filter
+      def call
+        doc.css('pre[lang="mermaid"]').add_class('mermaid')
+        doc.css('pre[lang="mermaid"]').add_class('js-render-mermaid')
+
+        # The `<code></code>` blocks are added in the lib/banzai/filter/syntax_highlight_filter.rb
+        # We want to keep context and consistency, so we the blocks are added for all filters.
+        # Details: https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/15107/diffs?diff_id=7962900#note_45495859
+        doc.css('pre[lang="mermaid"]').each do |pre|
+          document = pre.at('code')
+          document.replace(document.content)
+        end
+
+        doc
+      end
+    end
+  end
+end
diff --git a/lib/banzai/filter/syntax_highlight_filter.rb b/lib/banzai/filter/syntax_highlight_filter.rb
index 7da565043d1..a79a0154846 100644
--- a/lib/banzai/filter/syntax_highlight_filter.rb
+++ b/lib/banzai/filter/syntax_highlight_filter.rb
@@ -14,23 +14,26 @@ module Banzai
       end
 
       def highlight_node(node)
-        language = node.attr('lang')
         code = node.text
-        css_classes = "code highlight"
-        lexer = lexer_for(language)
-        lang = lexer.tag
-
-        begin
-          code = Rouge::Formatters::HTMLGitlab.format(lex(lexer, code), tag: lang)
-
-          css_classes << " js-syntax-highlight #{lang}"
-        rescue
-          lang = nil
-          # Gracefully handle syntax highlighter bugs/errors to ensure
-          # users can still access an issue/comment/etc.
+        css_classes = 'code highlight js-syntax-highlight'
+        language = node.attr('lang')
+
+        if use_rouge?(language)
+          lexer = lexer_for(language)
+          language = lexer.tag
+
+          begin
+            code = Rouge::Formatters::HTMLGitlab.format(lex(lexer, code), tag: language)
+            css_classes << " #{language}"
+          rescue
+            # Gracefully handle syntax highlighter bugs/errors to ensure
+            # users can still access an issue/comment/etc.
+
+            language = nil
+          end
         end
 
-        highlighted = %(<pre class="#{css_classes}" lang="#{lang}" v-pre="true"><code>#{code}</code></pre>)
+        highlighted = %(<pre class="#{css_classes}" lang="#{language}" v-pre="true"><code>#{code}</code></pre>)
 
         # Extracted to a method to measure it
         replace_parent_pre_element(node, highlighted)
@@ -51,6 +54,10 @@ module Banzai
         # Replace the parent `pre` element with the entire highlighted block
         node.parent.replace(highlighted)
       end
+
+      def use_rouge?(language)
+        %w(math mermaid plantuml).exclude?(language)
+      end
     end
   end
 end
diff --git a/lib/banzai/pipeline/gfm_pipeline.rb b/lib/banzai/pipeline/gfm_pipeline.rb
index 3208abfc538..55874ad50a3 100644
--- a/lib/banzai/pipeline/gfm_pipeline.rb
+++ b/lib/banzai/pipeline/gfm_pipeline.rb
@@ -14,6 +14,7 @@ module Banzai
           Filter::SyntaxHighlightFilter,
 
           Filter::MathFilter,
+          Filter::MermaidFilter,
           Filter::UploadLinkFilter,
           Filter::VideoLinkFilter,
           Filter::ImageLazyLoadFilter,
-- 
cgit v1.2.1


From e826c5d0917a7fe2225fb6ba0862bc56c1ef3fc2 Mon Sep 17 00:00:00 2001
From: Jarka Kadlecova <jarka@gitlab.com>
Date: Wed, 22 Nov 2017 14:20:35 +0100
Subject: Fix link text from group context

---
 lib/banzai/filter/abstract_reference_filter.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/abstract_reference_filter.rb b/lib/banzai/filter/abstract_reference_filter.rb
index 9fef386de16..8975395aff1 100644
--- a/lib/banzai/filter/abstract_reference_filter.rb
+++ b/lib/banzai/filter/abstract_reference_filter.rb
@@ -213,7 +213,8 @@ module Banzai
       end
 
       def object_link_text(object, matches)
-        text = object.reference_link_text(context[:project])
+        parent = context[:project] || context[:group]
+        text = object.reference_link_text(parent)
 
         extras = object_link_text_extras(object, matches)
         text += " (#{extras.join(", ")})" if extras.any?
-- 
cgit v1.2.1


From 0c2fdb1c342fa5eb64bb0ed02091af3c06b37c0e Mon Sep 17 00:00:00 2001
From: Jarka Kadlecova <jarka@gitlab.com>
Date: Fri, 1 Dec 2017 10:21:05 +0100
Subject: Refactor banzai to support referencing from group context

---
 lib/banzai/cross_project_reference.rb              |  2 +-
 lib/banzai/filter/abstract_reference_filter.rb     | 98 +++++++++++++---------
 lib/banzai/filter/epic_reference_filter.rb         | 12 +++
 lib/banzai/filter/issuable_reference_filter.rb     | 31 +++++++
 lib/banzai/filter/issue_reference_filter.rb        | 32 ++-----
 lib/banzai/filter/label_reference_filter.rb        |  4 +-
 .../filter/merge_request_reference_filter.rb       | 37 ++------
 lib/banzai/filter/milestone_reference_filter.rb    |  2 +-
 lib/banzai/issuable_extractor.rb                   |  4 +-
 lib/banzai/reference_parser/epic_parser.rb         | 12 +++
 lib/banzai/reference_parser/issuable_parser.rb     | 25 ++++++
 lib/banzai/reference_parser/issue_parser.rb        | 12 +--
 .../reference_parser/merge_request_parser.rb       | 24 +-----
 13 files changed, 163 insertions(+), 132 deletions(-)
 create mode 100644 lib/banzai/filter/epic_reference_filter.rb
 create mode 100644 lib/banzai/filter/issuable_reference_filter.rb
 create mode 100644 lib/banzai/reference_parser/epic_parser.rb
 create mode 100644 lib/banzai/reference_parser/issuable_parser.rb

(limited to 'lib/banzai')

diff --git a/lib/banzai/cross_project_reference.rb b/lib/banzai/cross_project_reference.rb
index e2b57adf611..d8fb7705b2a 100644
--- a/lib/banzai/cross_project_reference.rb
+++ b/lib/banzai/cross_project_reference.rb
@@ -11,7 +11,7 @@ module Banzai
     # ref - String reference.
     #
     # Returns a Project, or nil if the reference can't be found
-    def project_from_ref(ref)
+    def parent_from_ref(ref)
       return context[:project] unless ref
 
       Project.find_by_full_path(ref)
diff --git a/lib/banzai/filter/abstract_reference_filter.rb b/lib/banzai/filter/abstract_reference_filter.rb
index 8975395aff1..e7e6a90b5fd 100644
--- a/lib/banzai/filter/abstract_reference_filter.rb
+++ b/lib/banzai/filter/abstract_reference_filter.rb
@@ -82,9 +82,9 @@ module Banzai
         end
       end
 
-      def project_from_ref_cached(ref)
-        cached_call(:banzai_project_refs, ref) do
-          project_from_ref(ref)
+      def from_ref_cached(ref)
+        cached_call("banzai_#{parent_type}_refs".to_sym, ref) do
+          parent_from_ref(ref)
         end
       end
 
@@ -153,15 +153,20 @@ module Banzai
       # have `gfm` and `gfm-OBJECT_NAME` class names attached for styling.
       def object_link_filter(text, pattern, link_content: nil, link_reference: false)
         references_in(text, pattern) do |match, id, project_ref, namespace_ref, matches|
-          project_path = full_project_path(namespace_ref, project_ref)
-          project = project_from_ref_cached(project_path)
+          parent_path = if parent_type == :group
+                          full_group_path(namespace_ref)
+                        else
+                          full_project_path(namespace_ref, project_ref)
+                        end
 
-          if project
+          parent = from_ref_cached(parent_path)
+
+          if parent
             object =
               if link_reference
-                find_object_from_link_cached(project, id)
+                find_object_from_link_cached(parent, id)
               else
-                find_object_cached(project, id)
+                find_object_cached(parent, id)
               end
           end
 
@@ -169,13 +174,13 @@ module Banzai
             title = object_link_title(object)
             klass = reference_class(object_sym)
 
-            data = data_attributes_for(link_content || match, project, object, link: !!link_content)
+            data = data_attributes_for(link_content || match, parent, object, link: !!link_content)
 
             url =
               if matches.names.include?("url") && matches[:url]
                 matches[:url]
               else
-                url_for_object_cached(object, project)
+                url_for_object_cached(object, parent)
               end
 
             content = link_content || object_link_text(object, matches)
@@ -224,17 +229,24 @@ module Banzai
 
       # Returns a Hash containing all object references (e.g. issue IDs) per the
       # project they belong to.
-      def references_per_project
-        @references_per_project ||= begin
+      def references_per_parent
+        @references_per ||= {}
+
+        @references_per[parent_type] ||= begin
           refs = Hash.new { |hash, key| hash[key] = Set.new }
 
           regex = Regexp.union(object_class.reference_pattern, object_class.link_reference_pattern)
 
           nodes.each do |node|
             node.to_html.scan(regex) do
-              project_path = full_project_path($~[:namespace], $~[:project])
+              path = if parent_type == :project
+                       full_project_path($~[:namespace], $~[:project])
+                     else
+                       full_group_path($~[:group])
+                     end
+
               symbol = $~[object_sym]
-              refs[project_path] << symbol if object_class.reference_valid?(symbol)
+              refs[path] << symbol if object_class.reference_valid?(symbol)
             end
           end
 
@@ -244,35 +256,41 @@ module Banzai
 
       # Returns a Hash containing referenced projects grouped per their full
       # path.
-      def projects_per_reference
-        @projects_per_reference ||= begin
+      def parent_per_reference
+        @per_reference ||= {}
+
+        @per_reference[parent_type] ||= begin
           refs = Set.new
 
-          references_per_project.each do |project_ref, _|
-            refs << project_ref
+          references_per_parent.each do |ref, _|
+            refs << ref
           end
 
-          find_projects_for_paths(refs.to_a).index_by(&:full_path)
+          find_for_paths(refs.to_a).index_by(&:full_path)
         end
       end
 
-      def projects_relation_for_paths(paths)
-        Project.where_full_path_in(paths).includes(:namespace)
+      def relation_for_paths(paths)
+        klass = parent_type.to_s.camelize.constantize
+        result = klass.where_full_path_in(paths)
+        return result if parent_type == :group
+
+        result.includes(:namespace) if parent_type == :project
       end
 
       # Returns projects for the given paths.
-      def find_projects_for_paths(paths)
+      def find_for_paths(paths)
         if RequestStore.active?
-          cache = project_refs_cache
+          cache = refs_cache
           to_query = paths - cache.keys
 
           unless to_query.empty?
-            projects = projects_relation_for_paths(to_query)
+            records = relation_for_paths(to_query)
 
             found = []
-            projects.each do |project|
-              ref = project.full_path
-              get_or_set_cache(cache, ref) { project }
+            records.each do |record|
+              ref = record.full_path
+              get_or_set_cache(cache, ref) { record }
               found << ref
             end
 
@@ -284,33 +302,37 @@ module Banzai
 
           cache.slice(*paths).values.compact
         else
-          projects_relation_for_paths(paths)
+          relation_for_paths(paths)
         end
       end
 
-      def current_project_path
-        return unless project
-
-        @current_project_path ||= project.full_path
+      def current_parent_path
+        @current_parent_path ||= parent&.full_path
       end
 
       def current_project_namespace_path
-        return unless project
-
-        @current_project_namespace_path ||= project.namespace.full_path
+        @current_project_namespace_path ||= project&.namespace&.full_path
       end
 
       private
 
       def full_project_path(namespace, project_ref)
-        return current_project_path unless project_ref
+        return current_parent_path unless project_ref
 
         namespace_ref = namespace || current_project_namespace_path
         "#{namespace_ref}/#{project_ref}"
       end
 
-      def project_refs_cache
-        RequestStore[:banzai_project_refs] ||= {}
+      def refs_cache
+        RequestStore["banzai_#{parent_type}_refs".to_sym] ||= {}
+      end
+
+      def parent_type
+        :project
+      end
+
+      def parent
+        parent_type == :project ? project : group
       end
     end
   end
diff --git a/lib/banzai/filter/epic_reference_filter.rb b/lib/banzai/filter/epic_reference_filter.rb
new file mode 100644
index 00000000000..265924abe24
--- /dev/null
+++ b/lib/banzai/filter/epic_reference_filter.rb
@@ -0,0 +1,12 @@
+module Banzai
+  module Filter
+    # The actual filter is implemented in the EE mixin
+    class EpicReferenceFilter < IssuableReferenceFilter
+      self.reference_type = :epic
+
+      def self.object_class
+        Epic
+      end
+    end
+  end
+end
diff --git a/lib/banzai/filter/issuable_reference_filter.rb b/lib/banzai/filter/issuable_reference_filter.rb
new file mode 100644
index 00000000000..7addf09be73
--- /dev/null
+++ b/lib/banzai/filter/issuable_reference_filter.rb
@@ -0,0 +1,31 @@
+module Banzai
+  module Filter
+    class IssuableReferenceFilter < AbstractReferenceFilter
+      def records_per_parent
+        @records_per_project ||= {}
+
+        @records_per_project[object_class.to_s.underscore] ||= begin
+          hash = Hash.new { |h, k| h[k] = {} }
+
+          parent_per_reference.each do |path, parent|
+            record_ids = references_per_parent[path]
+
+            parent_records(parent, record_ids).each do |record|
+              hash[parent][record.iid.to_i] = record
+            end
+          end
+
+          hash
+        end
+      end
+
+      def find_object(parent, iid)
+        records_per_parent[parent][iid]
+      end
+
+      def parent_from_ref(ref)
+        parent_per_reference[ref || current_parent_path]
+      end
+    end
+  end
+end
diff --git a/lib/banzai/filter/issue_reference_filter.rb b/lib/banzai/filter/issue_reference_filter.rb
index ce1ab977d3b..6877cae8c55 100644
--- a/lib/banzai/filter/issue_reference_filter.rb
+++ b/lib/banzai/filter/issue_reference_filter.rb
@@ -8,46 +8,24 @@ module Banzai
     # When external issues tracker like Jira is activated we should not
     # use issue reference pattern, but we should still be able
     # to reference issues from other GitLab projects.
-    class IssueReferenceFilter < AbstractReferenceFilter
+    class IssueReferenceFilter < IssuableReferenceFilter
       self.reference_type = :issue
 
       def self.object_class
         Issue
       end
 
-      def find_object(project, iid)
-        issues_per_project[project][iid]
-      end
-
       def url_for_object(issue, project)
         IssuesHelper.url_for_issue(issue.iid, project, only_path: context[:only_path], internal: true)
       end
 
-      def project_from_ref(ref)
-        projects_per_reference[ref || current_project_path]
-      end
-
-      # Returns a Hash containing the issues per Project instance.
-      def issues_per_project
-        @issues_per_project ||= begin
-          hash = Hash.new { |h, k| h[k] = {} }
-
-          projects_per_reference.each do |path, project|
-            issue_ids = references_per_project[path]
-            issues = project.issues.where(iid: issue_ids.to_a)
-
-            issues.each do |issue|
-              hash[project][issue.iid.to_i] = issue
-            end
-          end
-
-          hash
-        end
-      end
-
       def projects_relation_for_paths(paths)
         super(paths).includes(:gitlab_issue_tracker_service)
       end
+
+      def parent_records(parent, ids)
+        parent.issues.where(iid: ids.to_a)
+      end
     end
   end
 end
diff --git a/lib/banzai/filter/label_reference_filter.rb b/lib/banzai/filter/label_reference_filter.rb
index 5364984c9d3..d5360ad8f68 100644
--- a/lib/banzai/filter/label_reference_filter.rb
+++ b/lib/banzai/filter/label_reference_filter.rb
@@ -33,7 +33,7 @@ module Banzai
       end
 
       def find_label(project_ref, label_id, label_name)
-        project = project_from_ref(project_ref)
+        project = parent_from_ref(project_ref)
         return unless project
 
         label_params = label_params(label_id, label_name)
@@ -66,7 +66,7 @@ module Banzai
 
       def object_link_text(object, matches)
         project_path     = full_project_path(matches[:namespace], matches[:project])
-        project_from_ref = project_from_ref_cached(project_path)
+        project_from_ref = from_ref_cached(project_path)
         reference        = project_from_ref.to_human_reference(project)
         label_suffix     = " <i>in #{reference}</i>" if reference.present?
 
diff --git a/lib/banzai/filter/merge_request_reference_filter.rb b/lib/banzai/filter/merge_request_reference_filter.rb
index 0eab865ac04..b3cfa97d0e0 100644
--- a/lib/banzai/filter/merge_request_reference_filter.rb
+++ b/lib/banzai/filter/merge_request_reference_filter.rb
@@ -4,48 +4,19 @@ module Banzai
     # to merge requests that do not exist are ignored.
     #
     # This filter supports cross-project references.
-    class MergeRequestReferenceFilter < AbstractReferenceFilter
+    class MergeRequestReferenceFilter < IssuableReferenceFilter
       self.reference_type = :merge_request
 
       def self.object_class
         MergeRequest
       end
 
-      def find_object(project, iid)
-        merge_requests_per_project[project][iid]
-      end
-
       def url_for_object(mr, project)
         h = Gitlab::Routing.url_helpers
         h.project_merge_request_url(project, mr,
                                             only_path: context[:only_path])
       end
 
-      def project_from_ref(ref)
-        projects_per_reference[ref || current_project_path]
-      end
-
-      # Returns a Hash containing the merge_requests per Project instance.
-      def merge_requests_per_project
-        @merge_requests_per_project ||= begin
-          hash = Hash.new { |h, k| h[k] = {} }
-
-          projects_per_reference.each do |path, project|
-            merge_request_ids = references_per_project[path]
-
-            merge_requests = project.merge_requests
-              .where(iid: merge_request_ids.to_a)
-              .includes(target_project: :namespace)
-
-            merge_requests.each do |merge_request|
-              hash[project][merge_request.iid.to_i] = merge_request
-            end
-          end
-
-          hash
-        end
-      end
-
       def object_link_text_extras(object, matches)
         extras = super
 
@@ -61,6 +32,12 @@ module Banzai
 
         extras
       end
+
+      def parent_records(parent, ids)
+        parent.merge_requests
+          .where(iid: ids.to_a)
+          .includes(target_project: :namespace)
+      end
     end
   end
 end
diff --git a/lib/banzai/filter/milestone_reference_filter.rb b/lib/banzai/filter/milestone_reference_filter.rb
index bb5da310e09..2a6b0964ac5 100644
--- a/lib/banzai/filter/milestone_reference_filter.rb
+++ b/lib/banzai/filter/milestone_reference_filter.rb
@@ -38,7 +38,7 @@ module Banzai
 
       def find_milestone(project_ref, namespace_ref, milestone_id, milestone_name)
         project_path = full_project_path(namespace_ref, project_ref)
-        project = project_from_ref(project_path)
+        project = parent_from_ref(project_path)
 
         return unless project
 
diff --git a/lib/banzai/issuable_extractor.rb b/lib/banzai/issuable_extractor.rb
index cbabf9156de..49603d0b363 100644
--- a/lib/banzai/issuable_extractor.rb
+++ b/lib/banzai/issuable_extractor.rb
@@ -28,8 +28,8 @@ module Banzai
       issue_parser = Banzai::ReferenceParser::IssueParser.new(project, user)
       merge_request_parser = Banzai::ReferenceParser::MergeRequestParser.new(project, user)
 
-      issuables_for_nodes = issue_parser.issues_for_nodes(nodes).merge(
-        merge_request_parser.merge_requests_for_nodes(nodes)
+      issuables_for_nodes = issue_parser.records_for_nodes(nodes).merge(
+        merge_request_parser.records_for_nodes(nodes)
       )
 
       # The project for the issue/MR might be pending for deletion!
diff --git a/lib/banzai/reference_parser/epic_parser.rb b/lib/banzai/reference_parser/epic_parser.rb
new file mode 100644
index 00000000000..08b8a4c9a0f
--- /dev/null
+++ b/lib/banzai/reference_parser/epic_parser.rb
@@ -0,0 +1,12 @@
+module Banzai
+  module ReferenceParser
+    # The actual parser is implemented in the EE mixin
+    class EpicParser < IssuableParser
+      self.reference_type = :epic
+
+      def records_for_nodes(_nodes)
+        {}
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/issuable_parser.rb b/lib/banzai/reference_parser/issuable_parser.rb
new file mode 100644
index 00000000000..3953867eb83
--- /dev/null
+++ b/lib/banzai/reference_parser/issuable_parser.rb
@@ -0,0 +1,25 @@
+module Banzai
+  module ReferenceParser
+    class IssuableParser < BaseParser
+      def nodes_visible_to_user(user, nodes)
+        records = records_for_nodes(nodes)
+
+        nodes.select do |node|
+          issuable = records[node]
+
+          issuable && can_read_reference?(user, issuable)
+        end
+      end
+
+      def referenced_by(nodes)
+        records = records_for_nodes(nodes)
+
+        nodes.map { |node| records[node] }.compact.uniq
+      end
+
+      def can_read_reference?(user, issuable)
+        can?(user, "read_#{issuable.class.to_s.underscore}".to_sym, issuable)
+      end
+    end
+  end
+end
diff --git a/lib/banzai/reference_parser/issue_parser.rb b/lib/banzai/reference_parser/issue_parser.rb
index e0a8ca653cb..38d4e3f3e44 100644
--- a/lib/banzai/reference_parser/issue_parser.rb
+++ b/lib/banzai/reference_parser/issue_parser.rb
@@ -1,10 +1,10 @@
 module Banzai
   module ReferenceParser
-    class IssueParser < BaseParser
+    class IssueParser < IssuableParser
       self.reference_type = :issue
 
       def nodes_visible_to_user(user, nodes)
-        issues = issues_for_nodes(nodes)
+        issues = records_for_nodes(nodes)
 
         readable_issues = Ability
           .issues_readable_by_user(issues.values, user).to_set
@@ -14,13 +14,7 @@ module Banzai
         end
       end
 
-      def referenced_by(nodes)
-        issues = issues_for_nodes(nodes)
-
-        nodes.map { |node| issues[node] }.compact.uniq
-      end
-
-      def issues_for_nodes(nodes)
+      def records_for_nodes(nodes)
         @issues_for_nodes ||= grouped_objects_for_nodes(
           nodes,
           Issue.all.includes(
diff --git a/lib/banzai/reference_parser/merge_request_parser.rb b/lib/banzai/reference_parser/merge_request_parser.rb
index 75cbc7fdac4..a370ff5b5b3 100644
--- a/lib/banzai/reference_parser/merge_request_parser.rb
+++ b/lib/banzai/reference_parser/merge_request_parser.rb
@@ -1,25 +1,9 @@
 module Banzai
   module ReferenceParser
-    class MergeRequestParser < BaseParser
+    class MergeRequestParser < IssuableParser
       self.reference_type = :merge_request
 
-      def nodes_visible_to_user(user, nodes)
-        merge_requests = merge_requests_for_nodes(nodes)
-
-        nodes.select do |node|
-          merge_request = merge_requests[node]
-
-          merge_request && can?(user, :read_merge_request, merge_request.project)
-        end
-      end
-
-      def referenced_by(nodes)
-        merge_requests = merge_requests_for_nodes(nodes)
-
-        nodes.map { |node| merge_requests[node] }.compact.uniq
-      end
-
-      def merge_requests_for_nodes(nodes)
+      def records_for_nodes(nodes)
         @merge_requests_for_nodes ||= grouped_objects_for_nodes(
           nodes,
           MergeRequest.includes(
@@ -40,10 +24,6 @@ module Banzai
           self.class.data_attribute
         )
       end
-
-      def can_read_reference?(user, ref_project, node)
-        can?(user, :read_merge_request, ref_project)
-      end
     end
   end
 end
-- 
cgit v1.2.1


From f7c18ca31469b199c1a898cef583c9aae99f1375 Mon Sep 17 00:00:00 2001
From: Jarka Kadlecova <jarka@gitlab.com>
Date: Wed, 6 Dec 2017 12:36:11 +0100
Subject: Support uploads for groups

---
 lib/banzai/filter/upload_link_filter.rb | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/upload_link_filter.rb b/lib/banzai/filter/upload_link_filter.rb
index 09844931be5..d64f9ac4eb6 100644
--- a/lib/banzai/filter/upload_link_filter.rb
+++ b/lib/banzai/filter/upload_link_filter.rb
@@ -8,7 +8,7 @@ module Banzai
     #
     class UploadLinkFilter < HTML::Pipeline::Filter
       def call
-        return doc unless project
+        return doc unless project || group
 
         doc.xpath('descendant-or-self::a[starts-with(@href, "/uploads/")]').each do |el|
           process_link_attr el.attribute('href')
@@ -28,13 +28,27 @@ module Banzai
       end
 
       def build_url(uri)
-        File.join(Gitlab.config.gitlab.url, project.full_path, uri)
+        base_path = Gitlab.config.gitlab.url
+
+        if group
+          urls = Gitlab::Routing.url_helpers
+          # we need to get last 2 parts of the uri which are secret and filename
+          uri_parts = uri.split(File::SEPARATOR)
+          file_path = urls.show_group_uploads_path(group, uri_parts[-2], uri_parts[-1])
+          File.join(base_path, file_path)
+        else
+          File.join(base_path, project.full_path, uri)
+        end
       end
 
       def project
         context[:project]
       end
 
+      def group
+        context[:group]
+      end
+
       # Ensure that a :project key exists in context
       #
       # Note that while the key might exist, its value could be nil!
-- 
cgit v1.2.1


From 3d8fbd12b8f234aa62f4b5ceed21076a7afbcd23 Mon Sep 17 00:00:00 2001
From: "micael.bergeron" <micaelbergeron@gmail.com>
Date: Mon, 20 Nov 2017 09:02:01 -0500
Subject: add support for commit (in mr) to reference filter

---
 lib/banzai/filter/commit_reference_filter.rb | 14 ++++++++++++--
 lib/banzai/object_renderer.rb                | 16 ++++++++--------
 2 files changed, 20 insertions(+), 10 deletions(-)

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/commit_reference_filter.rb b/lib/banzai/filter/commit_reference_filter.rb
index 714e0319025..f4e0c3111f5 100644
--- a/lib/banzai/filter/commit_reference_filter.rb
+++ b/lib/banzai/filter/commit_reference_filter.rb
@@ -24,8 +24,18 @@ module Banzai
 
       def url_for_object(commit, project)
         h = Gitlab::Routing.url_helpers
-        h.project_commit_url(project, commit,
-                                        only_path: context[:only_path])
+        noteable = context[:merge_request] || context[:noteable]
+
+        if noteable.is_a?(MergeRequest) &&
+           noteable.all_commit_shas.include?(commit.id)
+
+          # the internal shas are in the context?
+          # why not preload in the object?, just make sure we have the same ref
+          # in all the rendering
+          h.diffs_project_merge_request_url(project, noteable, commit_id: commit.id)
+        else
+          h.project_commit_url(project, commit, only_path: context[:only_path])
+        end
       end
 
       def object_link_text_extras(object, matches)
diff --git a/lib/banzai/object_renderer.rb b/lib/banzai/object_renderer.rb
index ecb3affbba5..29c4e60f70c 100644
--- a/lib/banzai/object_renderer.rb
+++ b/lib/banzai/object_renderer.rb
@@ -18,10 +18,10 @@ module Banzai
     # project - A Project to use for redacting Markdown.
     # user - The user viewing the Markdown/HTML documents, if any.
     # context - A Hash containing extra attributes to use during redaction
-    def initialize(project, user = nil, redaction_context = {})
+    def initialize(project, user = nil, context = {})
       @project = project
       @user = user
-      @redaction_context = redaction_context
+      @context = base_context.merge(context)
     end
 
     # Renders and redacts an Array of objects.
@@ -48,7 +48,8 @@ module Banzai
       pipeline = HTML::Pipeline.new([])
 
       objects.map do |object|
-        pipeline.to_document(Banzai.render_field(object, attribute))
+        context = context_for(object, attribute)
+        pipeline.to_document(Banzai.render_field(object, attribute, context))
       end
     end
 
@@ -73,20 +74,19 @@ module Banzai
 
     # Returns a Banzai context for the given object and attribute.
     def context_for(object, attribute)
-      base_context.merge(object.banzai_render_context(attribute))
+      @context.merge(object.banzai_render_context(attribute))
     end
 
     def base_context
-      @base_context ||= @redaction_context.merge(
+      {
         current_user: user,
         project: project,
         skip_redaction: true
-      )
+      }
     end
 
     def save_options
-      return {} unless base_context[:xhtml]
-
+      return {} unless @context[:xhtml]
       { save_with: Nokogiri::XML::Node::SaveOptions::AS_XHTML }
     end
   end
-- 
cgit v1.2.1


From cb6f51ec9b2006f1040cca94119135c92e9a4cd1 Mon Sep 17 00:00:00 2001
From: "micael.bergeron" <micaelbergeron@gmail.com>
Date: Wed, 22 Nov 2017 09:48:09 -0500
Subject: add support for the commit reference filter

---
 lib/banzai/filter/commit_reference_filter.rb | 38 +++++++++++++++++++++-------
 lib/banzai/object_renderer.rb                | 13 +++++-----
 2 files changed, 35 insertions(+), 16 deletions(-)

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/commit_reference_filter.rb b/lib/banzai/filter/commit_reference_filter.rb
index f4e0c3111f5..c202d71072e 100644
--- a/lib/banzai/filter/commit_reference_filter.rb
+++ b/lib/banzai/filter/commit_reference_filter.rb
@@ -22,19 +22,29 @@ module Banzai
         end
       end
 
+      def referenced_merge_request_commit_shas
+        return [] unless noteable.is_a?(MergeRequest)
+
+        @referenced_merge_request_commit_shas ||= begin
+          referenced_shas = references_per_project.values.reduce(:|).to_a
+          noteable.all_commit_shas.select do |sha|
+            referenced_shas.any? { |ref| Gitlab::Git.shas_eql?(sha, ref) }
+          end
+        end
+      end
+
       def url_for_object(commit, project)
         h = Gitlab::Routing.url_helpers
-        noteable = context[:merge_request] || context[:noteable]
-
-        if noteable.is_a?(MergeRequest) &&
-           noteable.all_commit_shas.include?(commit.id)
 
-          # the internal shas are in the context?
-          # why not preload in the object?, just make sure we have the same ref
-          # in all the rendering
-          h.diffs_project_merge_request_url(project, noteable, commit_id: commit.id)
+        if referenced_merge_request_commit_shas.include?(commit.id)
+          h.diffs_project_merge_request_url(project,
+                                            noteable,
+                                            commit_id: commit.id,
+                                            only_path: only_path?)
         else
-          h.project_commit_url(project, commit, only_path: context[:only_path])
+          h.project_commit_url(project,
+                               commit,
+                               only_path: only_path?)
         end
       end
 
@@ -48,6 +58,16 @@ module Banzai
 
         extras
       end
+
+      private
+
+      def noteable
+        context[:noteable]
+      end
+
+      def only_path?
+        context[:only_path]
+      end
     end
   end
 end
diff --git a/lib/banzai/object_renderer.rb b/lib/banzai/object_renderer.rb
index 29c4e60f70c..0bf9a8d66bc 100644
--- a/lib/banzai/object_renderer.rb
+++ b/lib/banzai/object_renderer.rb
@@ -17,11 +17,11 @@ module Banzai
 
     # project - A Project to use for redacting Markdown.
     # user - The user viewing the Markdown/HTML documents, if any.
-    # context - A Hash containing extra attributes to use during redaction
-    def initialize(project, user = nil, context = {})
+    # redaction_context - A Hash containing extra attributes to use during redaction
+    def initialize(project, user = nil, redaction_context = {})
       @project = project
       @user = user
-      @context = base_context.merge(context)
+      @redaction_context = base_context.merge(redaction_context)
     end
 
     # Renders and redacts an Array of objects.
@@ -48,8 +48,7 @@ module Banzai
       pipeline = HTML::Pipeline.new([])
 
       objects.map do |object|
-        context = context_for(object, attribute)
-        pipeline.to_document(Banzai.render_field(object, attribute, context))
+        pipeline.to_document(Banzai.render_field(object, attribute))
       end
     end
 
@@ -74,7 +73,7 @@ module Banzai
 
     # Returns a Banzai context for the given object and attribute.
     def context_for(object, attribute)
-      @context.merge(object.banzai_render_context(attribute))
+      @redaction_context.merge(object.banzai_render_context(attribute))
     end
 
     def base_context
@@ -86,7 +85,7 @@ module Banzai
     end
 
     def save_options
-      return {} unless @context[:xhtml]
+      return {} unless @redaction_context[:xhtml]
       { save_with: Nokogiri::XML::Node::SaveOptions::AS_XHTML }
     end
   end
-- 
cgit v1.2.1


From 360b94ceba146935a40b02f39ed3d833eaea134a Mon Sep 17 00:00:00 2001
From: "micael.bergeron" <micaelbergeron@gmail.com>
Date: Fri, 1 Dec 2017 14:08:30 -0500
Subject: adding view and feature specs

---
 lib/banzai/object_renderer.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'lib/banzai')

diff --git a/lib/banzai/object_renderer.rb b/lib/banzai/object_renderer.rb
index 0bf9a8d66bc..2691be81623 100644
--- a/lib/banzai/object_renderer.rb
+++ b/lib/banzai/object_renderer.rb
@@ -86,6 +86,7 @@ module Banzai
 
     def save_options
       return {} unless @redaction_context[:xhtml]
+
       { save_with: Nokogiri::XML::Node::SaveOptions::AS_XHTML }
     end
   end
-- 
cgit v1.2.1


From daf9357aa92283e6cdd0d1e0cade65c8e2294540 Mon Sep 17 00:00:00 2001
From: "micael.bergeron" <micaelbergeron@gmail.com>
Date: Thu, 7 Dec 2017 10:35:56 -0500
Subject: fix the missing reference to #references_per_project

---
 lib/banzai/filter/commit_reference_filter.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'lib/banzai')

diff --git a/lib/banzai/filter/commit_reference_filter.rb b/lib/banzai/filter/commit_reference_filter.rb
index c202d71072e..eedb95197aa 100644
--- a/lib/banzai/filter/commit_reference_filter.rb
+++ b/lib/banzai/filter/commit_reference_filter.rb
@@ -26,7 +26,7 @@ module Banzai
         return [] unless noteable.is_a?(MergeRequest)
 
         @referenced_merge_request_commit_shas ||= begin
-          referenced_shas = references_per_project.values.reduce(:|).to_a
+          referenced_shas = references_per_parent.values.reduce(:|).to_a
           noteable.all_commit_shas.select do |sha|
             referenced_shas.any? { |ref| Gitlab::Git.shas_eql?(sha, ref) }
           end
-- 
cgit v1.2.1