danger-additional-logging 0.0.1

data/lib/danger/request_sources/bitbucket_cloud.rb

@@ -0,0 +1,169 @@
+require "danger/helpers/comments_helper"
+require "danger/request_sources/bitbucket_cloud_api"
+require "danger/danger_core/message_group"
+
+module Danger
+  module RequestSources
+    class BitbucketCloud < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :pr_json
+
+      def self.env_vars
+        [
+          "DANGER_BITBUCKETCLOUD_USERNAME",
+          "DANGER_BITBUCKETCLOUD_UUID",
+          "DANGER_BITBUCKETCLOUD_PASSWORD"
+        ]
+      end
+
+      def self.optional_env_vars
+        ["DANGER_BITBUCKETCLOUD_OAUTH_KEY", "DANGER_BITBUCKETCLOUD_OAUTH_SECRET"]
+      end
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+
+        @api = BitbucketCloudAPI.new(ci_source.repo_slug, ci_source.pull_request_id, nil, environment)
+      end
+
+      def validates_as_ci?
+        # TODO: ???
+        true
+      end
+
+      def validates_as_api_source?
+        @api.credentials_given?
+      end
+
+      def scm
+        @scm ||= GitRepo.new
+      end
+
+      def host
+        @host ||= @api.host
+      end
+
+      def fetch_details
+        self.pr_json = @api.fetch_pr_json
+      end
+
+      def setup_danger_branches
+        base_branch = self.pr_json[:destination][:branch][:name]
+        base_commit = self.pr_json[:destination][:commit][:hash]
+        head_branch = self.pr_json[:source][:branch][:name]
+        head_commit = self.pr_json[:source][:commit][:hash]
+
+        # Next, we want to ensure that we have a version of the current branch at a known location
+        scm.ensure_commitish_exists_on_branch! base_branch, base_commit
+        self.scm.exec "branch #{EnvironmentManager.danger_base_branch} #{base_commit}"
+
+        # OK, so we want to ensure that we have a known head branch, this will always represent
+        # the head of the PR ( e.g. the most recent commit that will be merged. )
+        scm.ensure_commitish_exists_on_branch! head_branch, head_commit
+        self.scm.exec "branch #{EnvironmentManager.danger_head_branch} #{head_commit}"
+      end
+
+      def organisation
+        nil
+      end
+
+      def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [], danger_id: "danger", new_comment: false, remove_previous_comments: false)
+        delete_old_comments(danger_id: danger_id) if !new_comment || remove_previous_comments
+
+        warnings = update_inline_comments_for_kind!(:warnings, warnings, danger_id: danger_id)
+        errors = update_inline_comments_for_kind!(:errors, errors, danger_id: danger_id)
+        messages = update_inline_comments_for_kind!(:messages, messages, danger_id: danger_id)
+        markdowns = update_inline_comments_for_kind!(:markdowns, markdowns, danger_id: danger_id)
+
+        has_comments = (warnings.count.positive? || errors.count.positive? || messages.count.positive? || markdowns.count.positive?)
+        if has_comments
+          comment = generate_description(warnings: warnings, errors: errors, template: "bitbucket_server")
+          comment += "\n\n"
+          comment += generate_comment(warnings: warnings,
+                                      errors: errors,
+                                      messages: messages,
+                                      markdowns: markdowns,
+                                      previous_violations: {},
+                                      danger_id: danger_id,
+                                      template: "bitbucket_server")
+          @api.post_comment(comment)
+        end
+      end
+
+      def update_pr_by_line!(message_groups:,
+                             danger_id: "danger",
+                             new_comment: false,
+                             remove_previous_comments: false)
+        if !new_comment || remove_previous_comments
+          delete_old_comments(danger_id: danger_id)
+        end
+
+        summary_body = generate_description(warnings: message_groups.fake_warnings_array,
+                                            errors: message_groups.fake_errors_array,
+                                            template: "bitbucket_server")
+        summary_body += "\n\n"
+
+        # this isn't the most elegant thing in the world, but we need the group
+        # with file: nil, line: nil so we can combine its info in with the
+        # summary_body
+        summary_group = message_groups.first
+        if summary_group && summary_group.file.nil? && summary_group.line.nil?
+          # remove summary_group from message_groups so it doesn't get a
+          # duplicate comment posted in the message_groups loop below
+          message_groups.shift
+        else
+          summary_group = MessageGroup.new(file: nil, line: nil)
+        end
+
+        summary_body += generate_message_group_comment(
+          message_group: summary_group,
+          danger_id: danger_id,
+          template: "bitbucket_server_message_group"
+        )
+
+        @api.post_comment(summary_body)
+
+        message_groups.each do |message_group|
+          body = generate_message_group_comment(message_group: message_group,
+                                                danger_id: danger_id,
+                                                template: "bitbucket_server_message_group")
+          @api.post_comment(body,
+                            file: message_group.file,
+                            line: message_group.line)
+        end
+      end
+
+      def update_inline_comments_for_kind!(kind, messages, danger_id: "danger")
+        emoji = { warnings: "warning", errors: "no_entry_sign", messages: "book" }[kind]
+
+        messages.reject do |message|
+          next false unless message.file && message.line
+
+          body = ""
+
+          if kind == :markdown
+            body = generate_inline_markdown_body(message,
+                                                 danger_id: danger_id,
+                                                 template: "bitbucket_server")
+          else
+            body = generate_inline_comment_body(emoji, message,
+                                                danger_id: danger_id,
+                                                template: "bitbucket_server")
+          end
+
+          @api.post_comment(body, file: message.file, line: message.line)
+
+          true
+        end
+      end
+
+      def delete_old_comments(danger_id: "danger")
+        @api.fetch_comments.each do |c|
+          next if c[:user][:uuid] != @api.my_uuid
+
+          @api.delete_comment(c[:id]) if c[:content][:raw] =~ /generated_by_#{danger_id}/
+        end
+      end
+    end
+  end
+end

data/lib/danger/request_sources/bitbucket_cloud_api.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "danger/helpers/comments_helper"
+
+module Danger
+  module RequestSources
+    class BitbucketCloudAPI
+      attr_accessor :host, :project, :slug, :access_token, :pull_request_id
+      attr_reader :my_uuid
+
+      def initialize(repo_slug, pull_request_id, branch_name, environment)
+        initialize_my_uuid(environment["DANGER_BITBUCKETCLOUD_UUID"])
+        @username = environment["DANGER_BITBUCKETCLOUD_USERNAME"]
+        @password = environment["DANGER_BITBUCKETCLOUD_PASSWORD"]
+        self.project, self.slug = repo_slug.split("/")
+        self.access_token = fetch_access_token(environment)
+        self.pull_request_id = pull_request_id || fetch_pr_from_branch(branch_name)
+        self.host = "https://bitbucket.org/"
+      end
+
+      def initialize_my_uuid(uuid)
+        return if uuid.nil?
+        return @my_uuid = uuid if uuid.empty?
+
+        if uuid.start_with?("{") && uuid.end_with?("}")
+          @my_uuid = uuid
+        else
+          @my_uuid = "{#{uuid}}"
+        end
+      end
+
+      def inspect
+        inspected = super
+
+        inspected.gsub!(@password, "********") if @password
+        inspected.gsub!(@access_token, "********") if @access_token
+
+        inspected
+      end
+
+      def credentials_given?
+        @my_uuid && !@my_uuid.empty? &&
+          @username && !@username.empty? &&
+          @password && !@password.empty?
+      end
+
+      def pull_request(*)
+        fetch_pr_json
+      end
+
+      def fetch_pr_json
+        uri = URI(pr_api_endpoint)
+        fetch_json(uri)
+      end
+
+      def fetch_comments
+        values = []
+        # TODO: use a url parts encoder to encode the query
+        corrected_uuid = @my_uuid[1...-1] unless @my_uuid.nil? # Endpoint doesnt support curly brackets for this, so remove them for this
+        uri = "#{pr_api_endpoint}/comments?pagelen=100&q=deleted+%7E+false+AND+user.uuid+%7E+%22#{corrected_uuid}%22"
+
+        while uri
+          json = fetch_json(URI(uri))
+          values += json[:values]
+          uri = json[:next]
+        end
+        values
+      end
+
+      def delete_comment(id)
+        uri = URI("#{pr_api_endpoint}/comments/#{id}")
+        delete(uri)
+      end
+
+      def post_comment(text, file: nil, line: nil)
+        uri = URI("#{pr_api_endpoint}/comments")
+        body = {
+          content: {
+            raw: text
+          }
+        }
+        body.merge!(inline: { path: file, to: line }) if file && line
+
+        post(uri, body.to_json)
+      end
+
+      private
+
+      def base_url(version)
+        "https://api.bitbucket.org/#{version}.0/repositories/#{project}/#{slug}/pullrequests"
+      end
+
+      def pr_api_endpoint
+        "#{base_url(2)}/#{pull_request_id}"
+      end
+
+      def prs_api_url(branch_name)
+        encoded_branch_name = URI.encode_www_form_component(branch_name)
+        "#{base_url(2)}?q=source.branch.name=\"#{encoded_branch_name}\""
+      end
+
+      def fetch_pr_from_branch(branch_name)
+        uri = URI(prs_api_url(branch_name))
+        fetch_json(uri)[:values][0][:id]
+      end
+
+      def fetch_access_token(environment)
+        oauth_key = environment["DANGER_BITBUCKETCLOUD_OAUTH_KEY"]
+        oauth_secret = environment["DANGER_BITBUCKETCLOUD_OAUTH_SECRET"]
+        return nil if oauth_key.nil?
+        return nil if oauth_secret.nil?
+
+        uri = URI.parse("https://bitbucket.org/site/oauth2/access_token")
+        req = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth oauth_key, oauth_secret
+        req.set_form_data({ "grant_type" => "client_credentials" })
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+
+        JSON.parse(res.body, symbolize_names: true)[:access_token]
+      end
+
+      def fetch_json(uri)
+        raise credentials_not_available unless credentials_given?
+
+        req = Net::HTTP::Get.new(uri.request_uri, { "Content-Type" => "application/json" })
+        if access_token.nil?
+          req.basic_auth @username, @password
+        else
+          req["Authorization"] = "Bearer #{access_token}"
+        end
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+        raise error_fetching_json(uri.to_s, res.code) unless res.code == "200"
+
+        JSON.parse(res.body, symbolize_names: true)
+      end
+
+      def post(uri, body)
+        raise credentials_not_available unless credentials_given?
+
+        req = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
+        if access_token.nil?
+          req.basic_auth @username, @password
+        else
+          req["Authorization"] = "Bearer #{access_token}"
+        end
+        req.body = body
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+      end
+
+      def delete(uri)
+        raise credentials_not_available unless credentials_given?
+
+        req = Net::HTTP::Delete.new(uri.request_uri, { "Content-Type" => "application/json" })
+        if access_token.nil?
+          req.basic_auth @username, @password
+        else
+          req["Authorization"] = "Bearer #{access_token}"
+        end
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+      end
+
+      def credentials_not_available
+        "Credentials not available. Provide DANGER_BITBUCKETCLOUD_USERNAME, " \
+        "DANGER_BITBUCKETCLOUD_UUID, and DANGER_BITBUCKETCLOUD_PASSWORD " \
+        "as environment variables."
+      end
+
+      def error_fetching_json(url, status_code)
+        "Error fetching json for: #{url}, status code: #{status_code}"
+      end
+    end
+  end
+end

data/lib/danger/request_sources/bitbucket_server.rb

@@ -0,0 +1,210 @@
+require "danger/helpers/comments_helper"
+require "danger/request_sources/bitbucket_server_api"
+require "danger/request_sources/code_insights_api"
+require_relative "request_source"
+
+module Danger
+  module RequestSources
+    class BitbucketServer < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :pr_json, :dismiss_out_of_range_messages
+
+      def self.env_vars
+        [
+          "DANGER_BITBUCKETSERVER_USERNAME",
+          "DANGER_BITBUCKETSERVER_PASSWORD",
+          "DANGER_BITBUCKETSERVER_HOST"
+        ]
+      end
+
+      def self.optional_env_vars
+        [
+          "DANGER_BITBUCKETSERVER_CODE_INSIGHTS_REPORT_KEY",
+          "DANGER_BITBUCKETSERVER_CODE_INSIGHTS_REPORT_TITLE",
+          "DANGER_BITBUCKETSERVER_CODE_INSIGHTS_REPORT_DESCRIPTION",
+          "DANGER_BITBUCKETSERVER_CODE_INSIGHTS_REPORT_LOGO_URL",
+          "DANGER_BITBUCKETSERVER_VERIFY_SSL",
+          "DANGER_BITBUCKETSERVER_DISMISS_OUT_OF_RANGE_MESSAGES"
+        ]
+      end
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+        self.dismiss_out_of_range_messages = environment["DANGER_BITBUCKETSERVER_DISMISS_OUT_OF_RANGE_MESSAGES"] == "true"
+
+        project, slug = ci_source.repo_slug.split("/")
+        @api = BitbucketServerAPI.new(project, slug, ci_source.pull_request_id, environment)
+        @code_insights = CodeInsightsAPI.new(project, slug, environment)
+      end
+
+      def validates_as_ci?
+        # TODO: ???
+        true
+      end
+
+      def validates_as_api_source?
+        @api.credentials_given?
+      end
+
+      def scm
+        @scm ||= GitRepo.new
+      end
+
+      def host
+        @host ||= @api.host
+      end
+
+      def fetch_details
+        self.pr_json = @api.fetch_pr_json
+      end
+
+      def pr_diff
+        @pr_diff ||= @api.fetch_pr_diff
+      end
+
+      def setup_danger_branches
+        base_branch = self.pr_json[:toRef][:id].sub("refs/heads/", "")
+        base_commit = self.pr_json[:toRef][:latestCommit]
+        # Support for older versions of Bitbucket Server
+        base_commit = self.pr_json[:toRef][:latestChangeset] if self.pr_json[:fromRef].key? :latestChangeset
+        head_branch = self.pr_json[:fromRef][:id].sub("refs/heads/", "")
+        head_commit = self.pr_json[:fromRef][:latestCommit]
+        # Support for older versions of Bitbucket Server
+        head_commit = self.pr_json[:fromRef][:latestChangeset] if self.pr_json[:fromRef].key? :latestChangeset
+
+        # Next, we want to ensure that we have a version of the current branch at a known location
+        scm.ensure_commitish_exists_on_branch! base_branch, base_commit
+        self.scm.exec "branch #{EnvironmentManager.danger_base_branch} #{base_commit}"
+
+        # OK, so we want to ensure that we have a known head branch, this will always represent
+        # the head of the PR ( e.g. the most recent commit that will be merged. )
+        scm.ensure_commitish_exists_on_branch! head_branch, head_commit
+        self.scm.exec "branch #{EnvironmentManager.danger_head_branch} #{head_commit}"
+      end
+
+      def organisation
+        nil
+      end
+
+      def update_pull_request!(warnings: [], errors: [], messages: [], markdowns: [], danger_id: "danger", new_comment: false, remove_previous_comments: false)
+        delete_old_comments(danger_id: danger_id) if !new_comment || remove_previous_comments
+
+        # If configured, send a Code Insights API to provide the PR with a quality report
+        # which includes inline code violations found by Danger as Annotations.
+        # If no inline violations occurred, an empty, successful (green) report will be sent.
+        if @code_insights.ready?
+          inline_violations = inline_violations_group(warnings: warnings, errors: errors, messages: messages)
+          inline_warnings = inline_violations[:warnings] || []
+          inline_errors = inline_violations[:errors] || []
+          inline_messages = inline_violations[:messages] || []
+
+          head_commit = self.pr_json[:fromRef][:latestCommit]
+          @code_insights.send_report(head_commit,
+                                     inline_warnings,
+                                     inline_errors,
+                                     inline_messages)
+        end
+
+        # If we're sending inline comments separately via Code Insights,
+        # the main body comment should contain only generic, non-file specific messages.
+        if @code_insights.ready?
+          main_violations = main_violations_group(warnings: warnings, errors: errors, messages: messages)
+          warnings = main_violations[:warnings] || []
+          errors = main_violations[:errors] || []
+          messages = main_violations[:messages] || []
+          markdowns = main_violations[:markdowns] || []
+        end
+
+        has_comments = (warnings.count > 0 || errors.count > 0 || messages.count > 0 || markdowns.count > 0)
+        if has_comments
+          comment = generate_description(warnings: warnings,
+                                         errors: errors)
+          comment += "\n\n"
+          comment += generate_comment(warnings: warnings,
+                                      errors: errors,
+                                      messages: messages,
+                                      markdowns: markdowns,
+                                      previous_violations: {},
+                                      danger_id: danger_id,
+                                      template: "bitbucket_server")
+          @api.post_comment(comment)
+        end
+      end
+
+      def delete_old_comments(danger_id: "danger")
+        @api.fetch_last_comments.each do |c|
+          @api.delete_comment(c[:id], c[:version]) if c[:text] =~ /generated_by_#{danger_id}/
+        end
+      end
+
+      def main_violations_group(warnings: [], errors: [], messages: [], markdowns: [])
+        if dismiss_out_of_range_messages
+          {
+            warnings: warnings.reject(&:inline?),
+            errors: errors.reject(&:inline?),
+            messages: messages.reject(&:inline?),
+            markdowns: markdowns.reject(&:inline?)
+          }
+        else
+          in_diff = proc { |a| find_position_in_diff?(a.file, a.line) }
+          {
+            warnings: warnings.reject(&in_diff),
+            errors: errors.reject(&in_diff),
+            messages: messages.reject(&in_diff),
+            markdowns: markdowns.reject(&in_diff)
+          }
+        end
+      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 update_pr_build_status(status, build_job_link, description)
+        changeset = self.pr_json[:fromRef][:latestCommit]
+        # Support for older versions of Bitbucket Server
+        changeset = self.pr_json[:fromRef][:latestChangeset] if self.pr_json[:fromRef].key? :latestChangeset
+        puts "Changeset: " + changeset
+        puts self.pr_json.to_json
+        @api.update_pr_build_status(status, changeset, build_job_link, description)
+      end
+
+      def find_position_in_diff?(file, line)
+        return nil if file.nil? || line.nil?
+        return nil if file.empty?
+
+        added_lines(file).include?(line)
+      end
+
+      def file_diff(file)
+        self.pr_diff[:diffs].find { |diff| diff[:destination] && diff[:destination][:toString] == file } || { hunks: [] }
+      end
+
+      def added_lines(file)
+        @added_lines ||= {}
+        @added_lines[file] ||= file_diff(file)[:hunks].map do |hunk|
+          hunk[:segments].select { |segment| segment[:type] == "ADDED" }.map do |segment|
+            segment[:lines].map do |line|
+              line[:destination]
+            end
+          end
+        end.flatten
+      end
+    end
+  end
+end

data/lib/danger/request_sources/bitbucket_server_api.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "danger/helpers/comments_helper"
+
+module Danger
+  module RequestSources
+    class BitbucketServerAPI
+      attr_accessor :host, :verify_ssl, :pr_api_endpoint, :key, :project
+
+      def initialize(project, slug, pull_request_id, environment)
+        @username = environment["DANGER_BITBUCKETSERVER_USERNAME"]
+        @password = environment["DANGER_BITBUCKETSERVER_PASSWORD"]
+        self.host = environment["DANGER_BITBUCKETSERVER_HOST"]
+        self.verify_ssl = environment["DANGER_BITBUCKETSERVER_VERIFY_SSL"] != "false"
+        if self.host && !(self.host.include? "http://") && !(self.host.include? "https://")
+          self.host = "https://" + self.host
+        end
+        self.key = slug
+        self.project = project
+        self.pr_api_endpoint = "#{host}/rest/api/1.0/projects/#{project}/repos/#{slug}/pull-requests/#{pull_request_id}"
+      end
+
+      def inspect
+        inspected = super
+
+        inspected.gsub!(@password, "********") if @password
+
+        inspected
+      end
+
+      def credentials_given?
+        @username && !@username.empty? && @password && !@password.empty?
+      end
+
+      def pull_request(*)
+        fetch_pr_json
+      end
+
+      def fetch_pr_json
+        uri = URI(pr_api_endpoint)
+        fetch_json(uri)
+      end
+
+      def fetch_pr_diff
+        uri = URI("#{pr_api_endpoint}/diff?withComments=false")
+        fetch_json(uri)
+      end
+
+      def fetch_last_comments
+        uri = URI("#{pr_api_endpoint}/activities?limit=1000")
+        fetch_json(uri)[:values].select { |v| v[:action] == "COMMENTED" }.map { |v| v[:comment] }
+      end
+
+      def delete_comment(id, version)
+        uri = URI("#{pr_api_endpoint}/comments/#{id}?version=#{version}")
+        delete(uri)
+      end
+
+      def post_comment(text)
+        uri = URI("#{pr_api_endpoint}/comments")
+        body = { text: text }.to_json
+        post(uri, body)
+      end
+
+      def update_pr_build_status(status, changeset, build_job_link, description)
+        uri = URI("#{self.host}/rest/build-status/1.0/commits/#{changeset}")
+        body = build_status_body(status, build_job_link, description)
+        post(uri, body)
+      end
+
+      private
+
+      def use_ssl
+        return self.pr_api_endpoint.include? "https://"
+      end
+
+      def fetch_json(uri)
+        req = Net::HTTP::Get.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth @username, @password
+        res = http(uri).start do |http|
+          http.request(req)
+        end
+        JSON.parse(res.body, symbolize_names: true)
+      end
+
+      def post(uri, body)
+        req = Net::HTTP::Post.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth @username, @password
+        req.body = body
+
+        res = http(uri).start do |http|
+          http.request(req)
+        end
+
+        # show error to the user when Bitbucket Server returned an error
+        case res
+        when Net::HTTPClientError, Net::HTTPServerError
+          # HTTP 4xx - 5xx
+          abort "\nError posting comment to Bitbucket Server: #{res.code} (#{res.message}) - #{res.body}\n\n"
+        end
+      end
+
+      def delete(uri)
+        req = Net::HTTP::Delete.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth @username, @password
+        http(uri).start do |http|
+          http.request(req)
+        end
+      end
+
+      def http(uri)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        http.use_ssl = use_ssl
+        http.verify_mode = verify_ssl ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+
+      def build_status_body(status, build_job_link, description)
+        body = {}
+        body["state"] = status
+        body["key"] = self.key
+        body["url"] = build_job_link
+        body["description"] = description if description
+        return body.to_json
+      end
+    end
+  end
+end