danger-additional-logging 0.0.1

data/lib/danger/request_sources/request_source.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Danger
+  module RequestSources
+    class RequestSource
+      DANGER_REPO_NAME = "danger"
+
+      attr_accessor :ci_source, :scm, :host, :ignored_violations
+
+      def self.env_vars
+        raise "Subclass and overwrite self.env_vars"
+      end
+
+      def self.optional_env_vars
+        []
+      end
+
+      def self.inherited(child_class)
+        available_request_sources.add child_class
+        super
+      end
+
+      def self.available_request_sources
+        @available_request_sources ||= Set.new
+      end
+
+      def self.source_name
+        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(', ').yellow}"
+        end
+      end
+
+      def initialize(_ci_source, _environment)
+        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)?$})
+      end
+
+      def validates_as_api_source?
+        raise "Subclass and overwrite validates_as_api_source?"
+      end
+
+      def scm
+        @scm ||= nil
+      end
+
+      def host
+        @host ||= nil
+      end
+
+      def ignored_violations
+        @ignored_violations ||= []
+      end
+
+      def update_pull_request!(_warnings: [], _errors: [], _messages: [], _markdowns: [])
+        raise "Subclass and overwrite update_pull_request!"
+      end
+
+      def setup_danger_branches
+        raise "Subclass and overwrite setup_danger_branches"
+      end
+
+      def fetch_details
+        raise "Subclass and overwrite initialize"
+      end
+
+      def organisation
+        raise "Subclass and overwrite organisation"
+      end
+
+      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"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+class GetIgnoredViolation
+  IGNORE_REGEXP = />*\s*danger\s*:\s*ignore\s*"(?<error>[^"]*)"/i.freeze
+
+  def initialize(body)
+    @body = body
+  end
+
+  def call
+    return [] unless body
+
+    body.chomp.scan(IGNORE_REGEXP).flatten
+  end
+
+  private
+
+  attr_reader :body
+end

data/lib/danger/request_sources/vsts.rb

@@ -0,0 +1,278 @@
+require "danger/helpers/comments_helper"
+require "danger/request_sources/vsts_api"
+
+module Danger
+  module RequestSources
+    class VSTS < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :pr_json
+
+      def self.env_vars
+        [
+          "DANGER_VSTS_API_TOKEN",
+          "DANGER_VSTS_HOST"
+        ]
+      end
+
+      def self.optional_env_vars
+        [
+          "DANGER_VSTS_API_VERSION"
+        ]
+      end
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+
+        @is_vsts_ci = environment.key? "DANGER_VSTS_HOST"
+
+        @api = VSTSAPI.new(ci_source.repo_slug, ci_source.pull_request_id, environment)
+      end
+
+      def validates_as_ci?
+        @is_vsts_ci
+      end
+
+      def validates_as_api_source?
+        @api.credentials_given?
+      end
+
+      def scm
+        @scm ||= GitRepo.new
+      end
+
+      def client
+        @api
+      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[:targetRefName].sub("refs/heads/", "")
+        base_commit = self.pr_json[:lastMergeTargetCommit][:commitId]
+        head_branch = self.pr_json[:sourceRefName].sub("refs/heads/", "")
+        head_commit = self.pr_json[:lastMergeSourceCommit][:commitId]
+
+        # 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)
+        unless @api.supports_comments?
+          return
+        end
+
+        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(**{
+          previous_violations: {},
+          danger_id: danger_id,
+          template: "vsts"
+        }.merge(main_violations))
+        if new_comment || remove_previous_comments
+          post_new_comment(comment)
+        else
+          update_old_comment(comment, danger_id: danger_id)
+        end
+      end
+
+      def post_new_comment(comment)
+        @api.post_comment(comment)
+      end
+
+      def update_old_comment(new_comment, danger_id: "danger")
+        comment_updated = false
+        @api.fetch_last_comments.each do |c|
+          thread_id = c[:id]
+          comment = c[:comments].first
+          comment_id = comment[:id]
+          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
+        end
+        # 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

data/lib/danger/request_sources/vsts_api.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "base64"
+require "danger/helpers/comments_helper"
+
+module Danger
+  module RequestSources
+    class VSTSAPI
+      attr_accessor :host, :pr_api_endpoint, :min_api_version_for_comments
+
+      def initialize(slug, pull_request_id, environment)
+        self.min_api_version_for_comments = "3.0"
+
+        user_name = ""
+        personal_access_token = environment["DANGER_VSTS_API_TOKEN"]
+
+        @token = Base64.strict_encode64("#{user_name}:#{personal_access_token}")
+        @api_version = environment["DANGER_VSTS_API_VERSION"] ||= self.min_api_version_for_comments
+
+        self.host = environment["DANGER_VSTS_HOST"]
+        if self.host && !(self.host.include? "http://") && !(self.host.include? "https://")
+          self.host = "https://" + self.host
+        end
+
+        self.pr_api_endpoint = "#{host}/_apis/git/repositories/#{slug}/pullRequests/#{pull_request_id}"
+      end
+
+      def supports_comments?
+        major_version = @api_version.split(".").first.to_i
+        minimum_version_for_comments = self.min_api_version_for_comments.split(".").first.to_i
+
+        major_version >= minimum_version_for_comments
+      end
+
+      def inspect
+        inspected = super
+
+        inspected.gsub!(@token, "********") if @token
+
+        inspected
+      end
+
+      def credentials_given?
+        @token && !@token.empty?
+      end
+
+      def pull_request(*)
+        fetch_pr_json
+      end
+
+      def fetch_pr_json
+        uri = URI("#{pr_api_endpoint}?api-version=#{@api_version}")
+        fetch_json(uri)
+      end
+
+      def fetch_last_comments
+        uri = URI("#{pr_api_endpoint}/threads?api-version=#{@api_version}")
+        fetch_json(uri)[:value]
+      end
+
+      def post_comment(text)
+        uri = URI("#{pr_api_endpoint}/threads?api-version=#{@api_version}")
+        body = {
+          "comments" => [
+            {
+              "parentCommentId" => 0,
+              "content" => text,
+              "commentType" => 1
+            }
+          ],
+          "properties" => {
+            "Microsoft.TeamFoundation.Discussion.SupportsMarkdown" => {
+              "type" => "System.Int32",
+              "value" => 1
+            }
+          },
+          "status" => 1
+        }.to_json
+        post(uri, body)
+      end
+
+      def post_inline_comment(text, file, line)
+        uri = URI("#{pr_api_endpoint}/threads?api-version=#{@api_version}")
+        body = {
+          "comments" => [
+            {
+              "parentCommentId" => 0,
+              "content" => text,
+              "commentType" => 1
+            }
+          ],
+          "properties" => {
+            "Microsoft.TeamFoundation.Discussion.SupportsMarkdown" => {
+              "type" => "System.Int32",
+              "value" => 1
+            }
+          },
+          "status" => 1,
+          "threadContext" => {
+            "filePath" => file,
+            "rightFileEnd" => {
+              "line" => line + 1,
+              "offset" => 1
+            },
+            "rightFileStart" => {
+              "line" => line,
+              "offset" => 1
+            }
+          }
+        }.to_json
+        post(uri, body)
+      end
+
+      def update_comment(thread, id, new_comment)
+        uri = URI("#{pr_api_endpoint}/threads/#{thread}/comments/#{id}?api-version=#{@api_version}")
+        body = {
+          "content" => new_comment
+        }.to_json
+        patch(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", "Authorization" => "Basic #{@token}" })
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: use_ssl) 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", "Authorization" => "Basic #{@token}" })
+        req.body = body
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: use_ssl) do |http|
+          http.request(req)
+        end
+
+        # show error to the user when VSTS returned an error
+        case res
+        when Net::HTTPClientError, Net::HTTPServerError
+          # HTTP 4xx - 5xx
+          abort "\nError posting comment to VSTS: #{res.code} (#{res.message})\n\n"
+        end
+      end
+
+      def patch(uri, body)
+        puts uri
+        puts body
+
+        req = Net::HTTP::Patch.new(uri.request_uri, { "Content-Type" => "application/json", "Authorization" => "Basic #{@token}" })
+        req.body = body
+
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: use_ssl) do |http|
+          http.request(req)
+        end
+
+        # show error to the user when VSTS returned an error
+        case res
+        when Net::HTTPClientError, Net::HTTPServerError
+          # HTTP 4xx - 5xx
+          abort "\nError updating comment on VSTS: #{res.code} (#{res.message})\n\n"
+        end
+      end
+    end
+  end
+end