danger 3.1.1 → 3.2.0

data/lib/danger/danger_core/plugins/dangerfile_messaging_plugin.rb

@@ -1,4 +1,5 @@
-require "danger/danger_core/violation"
+require "danger/danger_core/messages/violation"
+require "danger/danger_core/messages/markdown"
 require "danger/plugin_support/plugin"
 
 module Danger
@@ -38,6 +39,10 @@ module Danger
   #          message << "20 | No documentation | Error \n"
   #          markdown message
   #
+  # @example Adding an inline warning to a file
+  #
+  #          warn("You shouldn't use puts in your Dangerfile", file: "Dangerfile", line: 10)
+  #
   #
   # @see  danger/danger
   # @tags core, messaging
@@ -65,10 +70,14 @@ module Danger
     #
     # @param    [String] message
     #           The markdown based message to be printed below the table
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
     # @return   [void]
     #
-    def markdown(message)
-      @markdowns << message
+    def markdown(message, file: nil, line: nil)
+      @markdowns << Markdown.new(message, file, line)
     end
 
     # @!group Core
@@ -79,10 +88,14 @@ module Danger
     # @param    [Boolean] sticky
     #           Whether the message should be kept after it was fixed,
     #           defaults to `true`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
     # @return   [void]
     #
-    def message(message, sticky: true)
-      @messages << Violation.new(message, sticky)
+    def message(message, sticky: true, file: nil, line: nil)
+      @messages << Violation.new(message, sticky, file, line)
     end
 
     # @!group Core
@@ -93,11 +106,15 @@ module Danger
     # @param    [Boolean] sticky
     #           Whether the message should be kept after it was fixed,
     #           defaults to `true`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
     # @return   [void]
     #
-    def warn(message, sticky: true)
+    def warn(message, sticky: true, file: nil, line: nil)
       return if should_ignore_violation(message)
-      @warnings << Violation.new(message, sticky)
+      @warnings << Violation.new(message, sticky, file, line)
     end
 
     # @!group Core
@@ -108,11 +125,15 @@ module Danger
     # @param    [Boolean] sticky
     #           Whether the message should be kept after it was fixed,
     #           defaults to `true`.
+    # @param    [String] file
+    #           Optional. Path to the file that the message is for.
+    # @param    [String] line
+    #           Optional. The line in the file to present the message in.
     # @return   [void]
     #
-    def fail(message, sticky: true)
+    def fail(message, sticky: true, file: nil, line: nil)
       return if should_ignore_violation(message)
-      @errors << Violation.new(message, sticky)
+      @errors << Violation.new(message, sticky, file, line)
     end
 
     # @!group Reporting

data/lib/danger/danger_core/standard_error.rb

@@ -63,10 +63,13 @@ module Danger
     def message
       @message ||= begin
         trace_line, description = parse_line_number_from_description
+        latest_version = Danger.danger_outdated?
 
         m = "\n[!] "
         m << description
-        m << ". Updating the Danger gem might fix the issue.\n"
+        if latest_version
+          m << upgrade_message(latest_version)
+        end
         m = m.red if m.respond_to?(:red)
 
         return m unless backtrace && dsl_path && contents
@@ -103,5 +106,11 @@ module Danger
       end
       [trace_line, description]
     end
+
+    def upgrade_message(latest_version)
+      ". Updating the Danger gem might fix the issue. "\
+      "Your Danger version: #{Danger::VERSION}, "\
+      "latest Danger version: #{latest_version}\n"
+    end
   end
 end

data/lib/danger/helpers/comments_helper.rb

@@ -1,27 +1,57 @@
 require "kramdown"
+require "danger/helpers/comments_parsing_helper"
+
+# rubocop:disable Metrics/ModuleLength
 
 module Danger
   module Helpers
     module CommentsHelper
+      # This might be a bit weird, but table_kind_from_title is a shared dependency for
+      # parsing and generating. And rubocop was adamant about file size so...
+      include Danger::Helpers::CommentsParsingHelper
+
       def markdown_parser(text)
         Kramdown::Document.new(text, input: "GFM")
       end
 
-      def parse_tables_from_comment(comment)
-        comment.split("</table>")
+      # !@group Extension points
+      # Produces a markdown link to the file the message points to
+      #
+      # request_source implementations are invited to override this method with their
+      # vendor specific link.
+      #
+      # @param [Violation or Markdown] message
+      # @param [Bool] Should hide any generated link created
+      #
+      # @return [String] The Markdown compatible link
+      def markdown_link_to_message(message, _)
+        "#{messages.file}#L#{message.line}"
       end
 
-      def violations_from_table(table)
-        regex = %r{<td data-sticky="true">(?:<del>)?(.*?)(?:</del>)?\s*</td>}im
-        table.scan(regex).flatten.map(&:strip)
+      # !@group Extension points
+      # Determine whether two messages are equivalent
+      #
+      # request_source implementations are invited to override this method.
+      # This is mostly here to enable sources to detect when inlines change only in their
+      # commit hash and not in content per-se. since the link is implementation dependant
+      # so should be the comparision.
+      #
+      # @param [Violation or Markdown] m1
+      # @param [Violation or Markdown] m2
+      #
+      # @return [Boolean] whether they represent the same message
+      def messages_are_equivalent(m1, m2)
+        m1 == m2
       end
 
-      def process_markdown(violation)
-        html = markdown_parser(violation.message).to_html
+      def process_markdown(violation, hide_link = false)
+        message = violation.message
+        message = "#{markdown_link_to_message(violation, hide_link)}#{message}" if violation.file && violation.line
+
+        html = markdown_parser(message).to_html
         # Remove the outer `<p>`, the -5 represents a newline + `</p>`
         html = html[3...-5] if html.start_with? "<p>"
-
-        Violation.new(html, violation.sticky)
+        Violation.new(html, violation.sticky, violation.file, violation.line)
       end
 
       def parse_comment(comment)
@@ -41,50 +71,69 @@ module Danger
       end
 
       def table(name, emoji, violations, all_previous_violations)
-        content = violations.map { |v| process_markdown(v) }.uniq
+        content = violations.map { |v| process_markdown(v) }
+
         kind = table_kind_from_title(name)
         previous_violations = all_previous_violations[kind] || []
-        messages = content.map(&:message)
-        resolved_violations = previous_violations.uniq - messages
+        resolved_violations = previous_violations.reject do |pv|
+          content.count { |v| messages_are_equivalent(v, pv) } > 0
+        end
+
+        resolved_messages = resolved_violations.map(&:message).uniq
         count = content.count
 
         {
           name: name,
           emoji: emoji,
           content: content,
-          resolved: resolved_violations,
+          resolved: resolved_messages,
           count: count
         }
       end
 
-      def table_kind_from_title(title)
-        if title =~ /error/i
-          :error
-        elsif title =~ /warning/i
-          :warning
-        elsif title =~ /message/i
-          :message
-        end
-      end
-
-      def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {}, danger_id: "danger", template: "github")
+      def apply_template(tables: [], markdowns: [], danger_id: "danger", template: "github")
         require "erb"
 
         md_template = File.join(Danger.gem_path, "lib/danger/comment_generators/#{template}.md.erb")
 
         # erb: http://www.rrn.dk/rubys-erb-templating-system
         # for the extra args: http://stackoverflow.com/questions/4632879/erb-template-removing-the-trailing-line
-        @tables = [
-          table("Error", "no_entry_sign", errors, previous_violations),
-          table("Warning", "warning", warnings, previous_violations),
-          table("Message", "book", messages, previous_violations)
-        ]
-        @markdowns = markdowns
+        @tables = tables
+        @markdowns = markdowns.map(&:message)
         @danger_id = danger_id
 
         return ERB.new(File.read(md_template), 0, "-").result(binding)
       end
 
+      def generate_comment(warnings: [], errors: [], messages: [], markdowns: [], previous_violations: {}, danger_id: "danger", template: "github")
+        apply_template(
+          tables: [
+            table("Error", "no_entry_sign", errors, previous_violations),
+            table("Warning", "warning", warnings, previous_violations),
+            table("Message", "book", messages, previous_violations)
+          ],
+          markdowns: markdowns,
+          danger_id: danger_id,
+          template: template
+        )
+      end
+
+      def generate_inline_comment_body(emoji, message, danger_id: "danger", resolved: false, template: "github")
+        apply_template(
+          tables: [{ content: [message], resolved: resolved, emoji: emoji }],
+          danger_id: danger_id,
+          template: "#{template}_inline"
+        )
+      end
+
+      def generate_inline_markdown_body(markdown, danger_id: "danger", template: "github")
+        apply_template(
+          markdowns: [markdown],
+          danger_id: danger_id,
+          template: "#{template}_inline"
+        )
+      end
+
       def generate_description(warnings: nil, errors: nil)
         if errors.empty? && warnings.empty?
           return "All green. #{random_compliment}"
@@ -98,9 +147,21 @@ module Danger
       end
 
       def random_compliment
-        compliment = ["Well done.", "Congrats.", "Woo!",
-                      "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."]
-        compliment.sample
+        ["Well done.", "Congrats.", "Woo!",
+         "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."].sample
+      end
+
+      def character_from_emoji(emoji)
+        emoji.delete! ":"
+        if emoji == "no_entry_sign"
+          "🚫"
+        elsif emoji == "warning"
+          "⚠️"
+        elsif emoji == "book"
+          "📖"
+        elsif emoji == "white_check_mark"
+          "✅"
+        end
       end
 
       private

data/lib/danger/helpers/comments_parsing_helper.rb

@@ -0,0 +1,52 @@
+module Danger
+  module Helpers
+    module CommentsParsingHelper
+      # !@group Extension points
+      # Produces a message-like from a row in a comment table
+      #
+      # @param [String] row
+      #        The content of the row in the table
+      #
+      # @return [Violation or Markdown] the extracted message
+      def parse_message_from_row(row)
+        Violation.new(row, true, nil, nil)
+      end
+
+      def parse_tables_from_comment(comment)
+        comment.split("</table>")
+      end
+
+      def violations_from_table(table)
+        row_regex = %r{<td data-sticky="true">(?:<del>)?(.*?)(?:</del>)?\s*</td>}im
+        table.scan(row_regex).flatten.map do |row|
+          parse_message_from_row(row.strip)
+        end
+      end
+
+      def parse_comment(comment)
+        tables = parse_tables_from_comment(comment)
+        violations = {}
+        tables.each do |table|
+          next unless table =~ %r{<th width="100%"(.*?)</th>}im
+          title = Regexp.last_match(1)
+          kind = table_kind_from_title(title)
+          next unless kind
+
+          violations[kind] = violations_from_table(table)
+        end
+
+        violations.reject { |_, v| v.empty? }
+      end
+
+      def table_kind_from_title(title)
+        if title =~ /error/i
+          :error
+        elsif title =~ /warning/i
+          :warning
+        elsif title =~ /message/i
+          :message
+        end
+      end
+    end
+  end
+end

data/lib/danger/request_source/bitbucket_server.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+require "danger/helpers/comments_helper"
+
+module Danger
+  module RequestSources
+    class BitbucketServer < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :pr_json
+
+      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_commit = self.pr_json[:toRef][:latestCommit]
+        head_commit = self.pr_json[:fromRef][:latestCommit]
+
+        # Next, we want to ensure that we have a version of the current branch at a known location
+        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. )
+        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")
+        delete_old_comments(danger_id: danger_id)
+
+        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
+    end
+  end
+end

data/lib/danger/request_source/bitbucket_server_api.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+require "danger/helpers/comments_helper"
+
+module Danger
+  module RequestSources
+    class BitbucketServerAPI
+      attr_accessor :host, :pr_api_endpoint
+
+      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.pr_api_endpoint = "https://#{host}/rest/api/1.0/projects/#{project}/repos/#{slug}/pull-requests/#{pull_request_id}"
+      end
+
+      def credentials_given?
+        @username && !@username.empty? && @password && !@password.empty?
+      end
+
+      def fetch_pr_json
+        uri = URI(pr_api_endpoint)
+        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
+
+      private
+
+      def fetch_json(uri)
+        req = Net::HTTP::Get.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth @username, @password
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) 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
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+      end
+
+      def delete(uri)
+        req = Net::HTTP::Delete.new(uri.request_uri, { "Content-Type" => "application/json" })
+        req.basic_auth @username, @password
+        Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(req)
+        end
+      end
+    end
+  end
+end