danger 8.0.4

data/lib/danger/plugin_support/templates/readme_table.html.erb

@@ -0,0 +1,26 @@
+<% json.each do |plugin| %>
+
+### <%= plugin["instance_name"] %>
+
+<%= plugin["body_md"] %>
+<%- plugin["example_code"].each do |example| %>
+<blockquote><%= example["title"] %>
+  <pre><%= example["text"] %></pre>
+</blockquote>
+<%- end %>
+
+<%- unless plugin["attributes"].empty? %>
+#### Attributes
+<%- plugin["attributes"].each do |attribute| %>
+`<%= attribute.keys.first %>` - <%= attribute.values.first["write"]["body_md"] %>
+<%- end %>
+<%- end %>
+
+<%- unless plugin["methods"].empty? %>
+#### Methods
+<%- plugin["methods"].each do |method| %>
+`<%= method["name"] %>` - <%= method["body_md"] %>
+<%- end %>
+<%- end %>
+
+<% end %>

data/lib/danger/request_sources/bitbucket_cloud.rb

@@ -0,0 +1,171 @@
+# coding: utf-8
+
+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
+        self.environment = environment
+
+        @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
+
+        comment = generate_description(warnings: warnings, errors: errors, template: "bitbucket_server")
+        comment += "\n\n"
+
+        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)
+
+        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
+
+      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 @@
+# coding: utf-8
+
+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
+
+        if @password
+          inspected = inspected.sub! @password, "********".freeze
+        end
+
+        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
+        uri = "#{pr_api_endpoint}/comments?pagelen=100&q=deleted+%7E+false+AND+user.username+%7E+%22#{@username}%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_endpoint(branch_name)
+        "#{base_url(2)}?q=source.branch.name=\"#{branch_name}\""
+      end
+
+      def fetch_pr_from_branch(branch_name)
+        uri = URI(URI.escape(prs_api_endpoint(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,105 @@
+# coding: utf-8
+
+require "danger/helpers/comments_helper"
+require "danger/request_sources/bitbucket_server_api"
+
+module Danger
+  module RequestSources
+    class BitbucketServer < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :pr_json
+
+      def self.env_vars
+        [
+          "DANGER_BITBUCKETSERVER_USERNAME",
+          "DANGER_BITBUCKETSERVER_PASSWORD",
+          "DANGER_BITBUCKETSERVER_HOST"
+        ]
+      end
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+        self.environment = environment
+
+        project, slug = ci_source.repo_slug.split("/")
+        @api = BitbucketServerAPI.new(project, slug, ci_source.pull_request_id, 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[: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
+
+        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
+
+      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 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
+    end
+  end
+end