danger 8.4.2 → 9.2.0

data/lib/danger/request_sources/gitlab.rb

@@ -1,4 +1,3 @@
-# coding: utf-8
 require "uri"
 require "danger/helpers/comments_helper"
 require "danger/helpers/comment"
@@ -8,7 +7,7 @@ module Danger
   module RequestSources
     class GitLab < RequestSource
       include Danger::Helpers::CommentsHelper
-      attr_accessor :mr_json, :commits_json, :dismiss_out_of_range_messages
+      attr_accessor :mr_json, :commits_json, :dismiss_out_of_range_messages, :endpoint, :host
 
       FIRST_GITLAB_GEM_WITH_VERSION_CHECK = Gem::Version.new("4.6.0")
       FIRST_VERSION_WITH_INLINE_COMMENTS = Gem::Version.new("10.8.0")
@@ -23,20 +22,19 @@ module Danger
 
       def initialize(ci_source, environment)
         self.ci_source = ci_source
-        self.environment = environment
         self.dismiss_out_of_range_messages = false
-
-        @token = @environment["DANGER_GITLAB_API_TOKEN"]
+        @endpoint = environment["DANGER_GITLAB_API_BASE_URL"] || environment.fetch("CI_API_V4_URL", "https://gitlab.com/api/v4")
+        @host = environment.fetch("DANGER_GITLAB_HOST", URI.parse(endpoint).host) || "gitlab.com"
+        @token = environment["DANGER_GITLAB_API_TOKEN"]
       end
 
       def client
-        token = @environment["DANGER_GITLAB_API_TOKEN"]
-        raise "No API token given, please provide one using `DANGER_GITLAB_API_TOKEN`" unless token
+        raise "No API token given, please provide one using `DANGER_GITLAB_API_TOKEN`" unless @token
 
         # The require happens inline so that it won't cause exceptions when just using the `danger` gem.
         require "gitlab"
 
-        @client ||= Gitlab.client(endpoint: endpoint, private_token: token)
+        @client ||= Gitlab.client(endpoint: endpoint, private_token: @token)
       rescue LoadError => e
         if e.path == "gitlab"
           puts "The GitLab gem was not installed, you will need to change your Gem from `danger` to `danger-gitlab`.".red
@@ -48,7 +46,7 @@ module Danger
       end
 
       def validates_as_ci?
-        includes_port = self.host.include? ":"
+        includes_port = host.include? ":"
         raise "Port number included in `DANGER_GITLAB_HOST`, this will fail with GitLab CI Runners" if includes_port
 
         # We don't call super because in some cases the Git remote doesn't match the GitLab instance host.
@@ -66,14 +64,6 @@ module Danger
         @scm ||= GitRepo.new
       end
 
-      def endpoint
-        @endpoint ||= @environment["DANGER_GITLAB_API_BASE_URL"] || @environment["CI_API_V4_URL"] || "https://gitlab.com/api/v4"
-      end
-
-      def host
-        @host ||= @environment["DANGER_GITLAB_HOST"] || URI.parse(endpoint).host || "gitlab.com"
-      end
-
       def base_commit
         @base_commit ||= self.mr_json.diff_refs.base_sha
       end
@@ -81,20 +71,18 @@ module Danger
       def mr_comments
         # @raw_comments contains what we got back from the server.
         # @comments contains Comment objects (that have less information)
-        @comments ||= begin
-          if supports_inline_comments
-            @raw_comments = mr_discussions
-              .auto_paginate
-              .flat_map { |discussion| discussion.notes.map { |note| note.to_h.merge({"discussion_id" => discussion.id}) } }
-            @raw_comments
-              .map { |comment| Comment.from_gitlab(comment) }
-          else
-            @raw_comments = client.merge_request_comments(ci_source.repo_slug, ci_source.pull_request_id, per_page: 100)
-              .auto_paginate
-            @raw_comments
-              .map { |comment| Comment.from_gitlab(comment) }
-          end
-        end
+        @comments ||= if supports_inline_comments
+                        @raw_comments = mr_discussions
+                          .auto_paginate
+                          .flat_map { |discussion| discussion.notes.map { |note| note.to_h.merge({ "discussion_id" => discussion.id }) } }
+                        @raw_comments
+                          .map { |comment| Comment.from_gitlab(comment) }
+                      else
+                        @raw_comments = client.merge_request_comments(ci_source.repo_slug, ci_source.pull_request_id, per_page: 100)
+                          .auto_paginate
+                        @raw_comments
+                          .map { |comment| Comment.from_gitlab(comment) }
+                      end
       end
 
       def mr_discussions
@@ -105,10 +93,10 @@ module Danger
         @mr_diff ||= begin
           diffs = mr_changes.changes.map do |change|
             diff = change["diff"]
-            if diff.start_with?('--- a/')
+            if diff.start_with?("--- a/")
               diff
             else
-              "--- a/#{change["old_path"]}\n+++ b/#{change["new_path"]}\n#{diff}"
+              "--- a/#{change['old_path']}\n+++ b/#{change['new_path']}\n#{diff}"
             end
           end
           diffs.join("\n")
@@ -116,24 +104,18 @@ module Danger
       end
 
       def mr_changed_paths
-        @mr_changed_paths ||= begin
-          mr_changes
-            .changes.map { |change| change["new_path"] }
-        end
+        @mr_changed_paths ||= mr_changes
+          .changes.map { |change| change["new_path"] }
 
         @mr_changed_paths
       end
 
       def mr_changes
-        @mr_changes ||= begin
-          client.merge_request_changes(ci_source.repo_slug, ci_source.pull_request_id)
-        end
+        @mr_changes ||= client.merge_request_changes(ci_source.repo_slug, ci_source.pull_request_id)
       end
 
       def mr_closes_issues
-        @mr_closes_issues ||= begin
-          client.merge_request_closes_issues(ci_source.repo_slug, ci_source.pull_request_id)
-        end
+        @mr_closes_issues ||= client.merge_request_closes_issues(ci_source.repo_slug, ci_source.pull_request_id)
       end
 
       def setup_danger_branches
@@ -163,16 +145,14 @@ module Danger
       end
 
       def supports_inline_comments
-        @supports_inline_comments ||= begin
-          # If we can't check GitLab's version, we assume we don't support inline comments
-          if Gem.loaded_specs["gitlab"].version < FIRST_GITLAB_GEM_WITH_VERSION_CHECK
-            false
-          else
-            current_version = Gem::Version.new(client.version.version)
+        # If we can't check GitLab's version, we assume we don't support inline comments
+        @supports_inline_comments ||= if Gem.loaded_specs["gitlab"].version < FIRST_GITLAB_GEM_WITH_VERSION_CHECK
+                                        false
+                                      else
+                                        current_version = Gem::Version.new(client.version.version)
 
-            current_version >= FIRST_VERSION_WITH_INLINE_COMMENTS
-          end
-        end
+                                        current_version >= FIRST_VERSION_WITH_INLINE_COMMENTS
+                                      end
       end
 
       def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [], danger_id: "danger", new_comment: false, remove_previous_comments: false)
@@ -262,11 +242,11 @@ module Danger
           delete_old_comments!(danger_id: danger_id)
         else
           body = generate_comment(warnings: warnings,
-                                    errors: errors,
+                                  errors: errors,
                                   messages: messages,
-                                 markdowns: markdowns,
-                       previous_violations: previous_violations,
-                                 danger_id: danger_id,
+                                  markdowns: markdowns,
+                                  previous_violations: previous_violations,
+                                  danger_id: danger_id,
                                   template: "gitlab")
 
           if editable_comments.empty? or should_create_new_comment
@@ -287,11 +267,10 @@ module Danger
 
       def delete_old_comments!(except: nil, danger_id: "danger")
         @raw_comments.each do |raw_comment|
-
           comment = Comment.from_gitlab(raw_comment)
           next unless comment.generated_by_danger?(danger_id)
           next if comment.id == except
-          next unless raw_comment.is_a?(Hash) && raw_comment["position"].nil?
+          next unless raw_comment.kind_of?(Hash) && raw_comment["position"].nil?
 
           begin
             client.delete_merge_request_comment(
@@ -299,7 +278,7 @@ module Danger
               ci_source.pull_request_id,
               comment.id
             )
-          rescue
+          rescue StandardError
           end
         end
       end
@@ -307,7 +286,7 @@ module Danger
       def markdown_link_to_message(message, _)
         "#{message.file}#L#{message.line}: "
       end
-      
+
       # @return [String] The organisation name, is nil if it can't be detected
       def organisation
         nil # TODO: Implement this
@@ -324,13 +303,12 @@ module Danger
       end
 
       # @return [String] A URL to the specific file, ready to be downloaded
-      def file_url(organisation: nil, repository: nil, branch: nil, path: nil)
-        branch ||= 'master'
-        token = @environment["DANGER_GITLAB_API_TOKEN"]
+      def file_url(organisation: nil, repository: nil, ref: nil, branch: nil, path: nil)
+        ref ||= (branch || "master")
         # According to GitLab Repositories API docs path and id(slug) should be encoded.
         path = URI.encode_www_form_component(path)
         repository = URI.encode_www_form_component(repository)
-        "#{endpoint}/projects/#{repository}/repository/files/#{path}/raw?ref=#{branch}&private_token=#{token}"
+        "#{endpoint}/projects/#{repository}/repository/files/#{path}/raw?ref=#{ref}&private_token=#{@token}"
       end
 
       def regular_violations_group(warnings: [], errors: [], messages: [], markdowns: [])
@@ -348,6 +326,7 @@ module Danger
           next 1 unless b.file && b.line
 
           next a.line <=> b.line if a.file == b.file
+
           next a.file <=> b.file
         end
 
@@ -369,7 +348,7 @@ module Danger
       def submit_inline_comments!(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: [], danger_id: "danger")
         comments = mr_discussions
           .auto_paginate
-          .flat_map { |discussion| discussion.notes.map { |note| note.to_h.merge({"discussion_id" => discussion.id}) } }
+          .flat_map { |discussion| discussion.notes.map { |note| note.to_h.merge({ "discussion_id" => discussion.id }) } }
           .select { |comment| Comment.from_gitlab(comment).inline? }
 
         danger_comments = comments.select { |comment| Comment.from_gitlab(comment).generated_by_danger?(danger_id) }
@@ -411,7 +390,7 @@ module Danger
         }
       end
 
-      def submit_inline_comments_for_kind!(kind, messages, diff_lines, danger_comments, previous_violations, danger_id: "danger")
+      def submit_inline_comments_for_kind!(kind, messages, _diff_lines, danger_comments, previous_violations, danger_id: "danger")
         previous_violations ||= []
         is_markdown_content = kind == :markdown
         emoji = { warning: "warning", error: "no_entry_sign", message: "book" }[kind]
@@ -450,7 +429,7 @@ module Danger
             params = {
               body: body,
               position: {
-                position_type: 'text',
+                position_type: "text",
                 new_path: m.file,
                 new_line: m.line,
                 old_path: old_position[:path],
@@ -560,20 +539,19 @@ module Danger
         line_number = 0
         diff.each_line do |line|
           if line.match range_header_regexp
-            line = line.split('+').last
-            line = line.split(' ').first
-            range_string = line.split(',')
+            line = line.split("+").last
+            line = line.split(" ").first
+            range_string = line.split(",")
             line_number = range_string[0].to_i - 1
-          elsif line.start_with?('+')
+          elsif line.start_with?("+")
             addition_lines.push(line_number)
-          elsif line.start_with?('-')
-            line_number=line_number-1
+          elsif line.start_with?("-")
+            line_number -= 1
           end
-          line_number=line_number+1
+          line_number += 1
         end
         addition_lines
       end
-
     end
   end
 end

data/lib/danger/request_sources/local_only.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require "danger/helpers/comments_helper"
 require "danger/helpers/comment"
 
@@ -13,9 +11,8 @@ module Danger
         ["DANGER_LOCAL_ONLY"]
       end
 
-      def initialize(ci_source, environment)
+      def initialize(ci_source, _environment)
         self.ci_source = ci_source
-        self.environment = environment
       end
 
       def validates_as_ci?

data/lib/danger/request_sources/request_source.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Danger
   module RequestSources
     class RequestSource
-      DANGER_REPO_NAME = "danger".freeze
+      DANGER_REPO_NAME = "danger"
 
-      attr_accessor :ci_source, :environment, :scm, :host, :ignored_violations
+      attr_accessor :ci_source, :scm, :host, :ignored_violations
 
       def self.env_vars
         raise "Subclass and overwrite self.env_vars"
@@ -23,12 +25,12 @@ module Danger
       end
 
       def self.source_name
-        to_s.sub("Danger::RequestSources::".freeze, "".freeze)
+        to_s.sub("Danger::RequestSources::", "")
       end
 
       def self.available_source_names_and_envs
         available_request_sources.map do |klass|
-          " - #{klass.source_name}: #{klass.env_vars.join(', '.freeze).yellow}"
+          " - #{klass.source_name}: #{klass.env_vars.join(', ').yellow}"
         end
       end
 
@@ -36,6 +38,16 @@ module Danger
         raise "Subclass and overwrite initialize"
       end
 
+      def inspect
+        inspected = super
+
+        inspected.gsub!(@token, "********") if @token
+        inspected.gsub!(@access_token, "********") if @access_token
+        inspected.gsub!(@bearer_token, "********") if @bearer_token
+
+        inspected
+      end
+
       # @return [Boolean] whether scm.origins is a valid git repository or not
       def validates_as_ci?
         !!self.scm.origins.match(%r{#{Regexp.escape self.host}(:|/)(.+/.+?)(?:\.git)?$})
@@ -73,12 +85,12 @@ module Danger
         raise "Subclass and overwrite organisation"
       end
 
-      def file_url(_organisation: nil, _repository: nil, _branch: "master", _path: nil)
+      def file_url(_organisation: nil, _repository: nil, _ref: nil, _branch: nil, _path: nil)
         raise "Subclass and overwrite file_url"
       end
-      
-      def update_build_status(status)
-          raise "Subclass and overwrite update_build_status"
+
+      def update_build_status(_status)
+        raise "Subclass and overwrite update_build_status"
       end
     end
   end

data/lib/danger/request_sources/support/get_ignored_violation.rb

@@ -1,5 +1,5 @@
 class GetIgnoredViolation
-  IGNORE_REGEXP = />*\s*danger\s*:\s*ignore\s*"(?<error>[^"]*)"/i
+  IGNORE_REGEXP = />*\s*danger\s*:\s*ignore\s*"(?<error>[^"]*)"/i.freeze
 
   def initialize(body)
     @body = body

data/lib/danger/request_sources/vsts.rb

@@ -1,5 +1,3 @@
-# coding: utf-8
-
 require "danger/helpers/comments_helper"
 require "danger/request_sources/vsts_api"
 
@@ -24,16 +22,14 @@ module Danger
 
       def initialize(ci_source, environment)
         self.ci_source = ci_source
-        self.environment = environment
 
-        @is_vsts_git = environment["BUILD_REPOSITORY_PROVIDER"] == "TfsGit"
+        @is_vsts_ci = environment.key? "DANGER_VSTS_HOST"
 
-        project, slug = ci_source.repo_slug.split("/")
-        @api = VSTSAPI.new(project, slug, ci_source.pull_request_id, environment)
+        @api = VSTSAPI.new(ci_source.repo_slug, ci_source.pull_request_id, environment)
       end
 
       def validates_as_ci?
-        @is_vsts_git
+        @is_vsts_ci
       end
 
       def validates_as_api_source?
@@ -44,6 +40,10 @@ module Danger
         @scm ||= GitRepo.new
       end
 
+      def client
+        @api
+      end
+
       def host
         @host ||= @api.host
       end
@@ -77,15 +77,36 @@ module Danger
           return
         end
 
-        comment = generate_description(warnings: warnings, errors: errors)
+        regular_violations = regular_violations_group(
+          warnings: warnings,
+          errors: errors,
+          messages: messages,
+          markdowns: markdowns
+        )
+
+        inline_violations = inline_violations_group(
+          warnings: warnings,
+          errors: errors,
+          messages: messages,
+          markdowns: markdowns
+        )
+
+        rest_inline_violations = submit_inline_comments!(**{
+          danger_id: danger_id,
+          previous_violations: {}
+        }.merge(inline_violations))
+
+        main_violations = merge_violations(
+          regular_violations, rest_inline_violations
+        )
+
+        comment = generate_description(warnings: main_violations[:warnings], errors: main_violations[:errors])
         comment += "\n\n"
-        comment += generate_comment(warnings: warnings,
-                                     errors: errors,
-                                   messages: messages,
-                                  markdowns: markdowns,
-                        previous_violations: {},
-                                  danger_id: danger_id,
-                                   template: "vsts")
+        comment += generate_comment(**{
+          previous_violations: {},
+          danger_id: danger_id,
+          template: "vsts"
+        }.merge(main_violations))
         if new_comment || remove_previous_comments
           post_new_comment(comment)
         else
@@ -106,6 +127,9 @@ module Danger
           comment_content = comment[:content].nil? ? "" : comment[:content]
           # Skip the comment if it wasn't posted by danger
           next unless comment_content.include?("generated_by_#{danger_id}")
+          # Skip the comment if it's an inline comment
+          next unless c[:threadContext].nil?
+
           # Updated the danger posted comment
           @api.update_comment(thread_id, comment_id, new_comment)
           comment_updated = true
@@ -113,6 +137,142 @@ module Danger
         # If no comment was updated, post a new one
         post_new_comment(new_comment) unless comment_updated
       end
+
+      def submit_inline_comments!(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: [], danger_id: "danger")
+        # Avoid doing any fetchs if there's no inline comments
+        return {} if (warnings + errors + messages + markdowns).select(&:inline?).empty?
+
+        pr_threads = @api.fetch_last_comments
+        danger_threads = pr_threads.select do |thread|
+          comment = thread[:comments].first
+          comment_content = comment[:content].nil? ? "" : comment[:content]
+
+          next comment_content.include?("generated_by_#{danger_id}")
+        end
+        non_danger_threads = pr_threads - danger_threads
+
+        warnings = submit_inline_comments_for_kind!(:warning, warnings, danger_threads, previous_violations["warning"], danger_id: danger_id)
+        errors = submit_inline_comments_for_kind!(:error, errors, danger_threads, previous_violations["error"], danger_id: danger_id)
+        messages = submit_inline_comments_for_kind!(:message, messages, danger_threads, previous_violations["message"], danger_id: danger_id)
+        markdowns = submit_inline_comments_for_kind!(:markdown, markdowns, danger_threads, [], danger_id: danger_id)
+
+        # submit removes from the array all comments that are still in force
+        # so we strike out all remaining ones
+        danger_threads.each do |thread|
+          violation = violations_from_table(thread[:comments].first[:content]).first
+          if !violation.nil? && violation.sticky
+            body = generate_inline_comment_body("white_check_mark", violation, danger_id: danger_id, resolved: true, template: "github")
+            @api.update_comment(thread[:id], thread[:comments].first[:id], body)
+          end
+        end
+
+        {
+          warnings: warnings,
+          errors: errors,
+          messages: messages,
+          markdowns: markdowns
+        }
+      end
+
+      def messages_are_equivalent(m1, m2)
+        blob_regexp = %r{blob/[0-9a-z]+/}
+        m1.file == m2.file && m1.line == m2.line &&
+          m1.message.sub(blob_regexp, "") == m2.message.sub(blob_regexp, "")
+      end
+
+      def submit_inline_comments_for_kind!(kind, messages, danger_threads, previous_violations, danger_id: "danger")
+        previous_violations ||= []
+        is_markdown_content = kind == :markdown
+        emoji = { warning: "warning", error: "no_entry_sign", message: "book" }[kind]
+
+        messages.reject do |m|
+          next false unless m.file && m.line
+
+          # Once we know we're gonna submit it, we format it
+          if is_markdown_content
+            body = generate_inline_markdown_body(m, danger_id: danger_id, template: "vsts")
+          else
+            # Hide the inline link behind a span
+            m.message = m.message.gsub("\n", "<br />")
+            m = process_markdown(m, true)
+            body = generate_inline_comment_body(emoji, m, danger_id: danger_id, template: "vsts")
+            # A comment might be in previous_violations because only now it's part of the unified diff
+            # We remove from the array since it won't have a place in the table anymore
+            previous_violations.reject! { |v| messages_are_equivalent(v, m) }
+          end
+
+          matching_threads = danger_threads.select do |comment_data|
+            if comment_data.key?(:threadContext) && !comment_data[:threadContext].nil? &&
+               comment_data[:threadContext][:filePath] == m.file &&
+               comment_data[:threadContext].key?(:rightFileStart) &&
+               comment_data[:threadContext][:rightFileStart][:line] == m.line
+              # Parse it to avoid problems with strikethrough
+              violation = violations_from_table(comment_data[:comments].first[:content]).first
+              if violation
+                messages_are_equivalent(violation, m)
+              else
+                blob_regexp = %r{blob/[0-9a-z]+/}
+                comment_data[:comments].first[:content].sub(blob_regexp, "") == body.sub(blob_regexp, "")
+              end
+            else
+              false
+            end
+          end
+
+          if matching_threads.empty?
+            @api.post_inline_comment(body, m.file, m.line)
+
+            # Not reject because this comment has not completed
+            next false
+          else
+            # Remove the surviving comment so we don't strike it out
+            danger_threads.reject! { |c| matching_threads.include? c }
+
+            # Update the comment to remove the strikethrough if present
+            thread = matching_threads.first
+            @api.update_comment(thread[:id], thread[:comments].first[:id], body)
+          end
+
+          # Remove this element from the array
+          next true
+        end
+      end
+
+      private
+
+      def regular_violations_group(warnings: [], errors: [], messages: [], markdowns: [])
+        {
+          warnings: warnings.reject(&:inline?),
+          errors: errors.reject(&:inline?),
+          messages: messages.reject(&:inline?),
+          markdowns: markdowns.reject(&:inline?)
+        }
+      end
+
+      def inline_violations_group(warnings: [], errors: [], messages: [], markdowns: [])
+        cmp = proc do |a, b|
+          next -1 unless a.file && a.line
+          next 1 unless b.file && b.line
+
+          next a.line <=> b.line if a.file == b.file
+
+          next a.file <=> b.file
+        end
+
+        # Sort to group inline comments by file
+        {
+          warnings: warnings.select(&:inline?).sort(&cmp),
+          errors: errors.select(&:inline?).sort(&cmp),
+          messages: messages.select(&:inline?).sort(&cmp),
+          markdowns: markdowns.select(&:inline?).sort(&cmp)
+        }
+      end
+
+      def merge_violations(*violation_groups)
+        violation_groups.inject({}) do |accumulator, group|
+          accumulator.merge(group) { |_, old, fresh| old + fresh }
+        end
+      end
     end
   end
 end