danger 3.1.1 → 3.2.0

data/lib/danger/request_source/github.rb

@@ -100,16 +100,42 @@ module Danger
           previous_violations = parse_comment(comment)
         end
 
-        if previous_violations.empty? && (warnings + errors + messages + markdowns).empty?
+        main_violations = (warnings + errors + messages + markdowns).reject(&:inline?)
+        if previous_violations.empty? && main_violations.empty?
           # Just remove the comment, if there's nothing to say.
           delete_old_comments!(danger_id: danger_id)
-        else
-          body = generate_comment(warnings: warnings,
-                                    errors: errors,
-                                  messages: messages,
-                                 markdowns: markdowns,
-                       previous_violations: previous_violations,
-                                 danger_id: danger_id,
+        end
+
+        cmp = proc do |a, b|
+          next -1 unless a.file
+          next 1 unless b.file
+
+          next a.line <=> b.line if a.file == b.file
+          next a.file <=> b.file
+        end
+
+        # Sort to group inline comments by file
+        # We copy because we need to mutate this arrays for inlines
+        comment_warnings = warnings.sort(&cmp)
+        comment_errors = errors.sort(&cmp)
+        comment_messages = messages.sort(&cmp)
+        comment_markdowns = markdowns.sort(&cmp)
+
+        submit_inline_comments!(warnings: comment_warnings,
+                                  errors: comment_errors,
+                                messages: comment_messages,
+                                markdowns: comment_markdowns,
+                      previous_violations: previous_violations,
+                                danger_id: danger_id)
+
+        # If there are still violations to show
+        unless main_violations.empty?
+          body = generate_comment(warnings: comment_warnings,
+                                    errors: comment_errors,
+                                  messages: comment_messages,
+                                  markdowns: comment_markdowns,
+                        previous_violations: previous_violations,
+                                  danger_id: danger_id,
                                   template: "github")
 
           if editable_comments.empty?
@@ -124,7 +150,7 @@ module Danger
         # Note: this can terminate the entire process.
         submit_pull_request_status!(warnings: warnings,
                                       errors: errors,
-                                 details_url: comment_result["html_url"])
+                                 details_url: comment_result[:html_url])
       end
 
       def submit_pull_request_status!(warnings: [], errors: [], details_url: [])
@@ -170,6 +196,178 @@ module Danger
         end
       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).select(&:inline?).empty?
+
+        diff_lines = self.pr_diff.lines
+        pr_comments = client.pull_request_comments(ci_source.repo_slug, ci_source.pull_request_id)
+        danger_comments = pr_comments.select { |comment| comment[:body].include?("generated_by_#{danger_id}") }
+        non_danger_comments = pr_comments - danger_comments
+
+        submit_inline_comments_for_kind!("warning", warnings, diff_lines, danger_comments, previous_violations[:warning], danger_id: danger_id)
+        submit_inline_comments_for_kind!("no_entry_sign", errors, diff_lines, danger_comments, previous_violations[:error], danger_id: danger_id)
+        submit_inline_comments_for_kind!("book", messages, diff_lines, danger_comments, previous_violations[:message], danger_id: danger_id)
+        submit_inline_comments_for_kind!(nil, markdowns, diff_lines, danger_comments, [], danger_id: danger_id)
+
+        # submit removes from the array all comments that are still in force
+        # so we strike out all remaining ones
+        danger_comments.each do |comment|
+          violation = violations_from_table(comment[:body]).first
+          if !violation.nil? && violation.sticky
+            body = generate_inline_comment_body("white_check_mark", violation, danger_id: danger_id, resolved: true, template: "github")
+            client.update_pull_request_comment(ci_source.repo_slug, comment[:id], body)
+          else
+            # We remove non-sticky violations that have no replies
+            # Since there's no direct concept of a reply in GH, we simply consider
+            # the existance of non-danger comments in that line as replies
+            replies = non_danger_comments.select do |potential|
+              potential[:path] == comment[:path] &&
+                potential[:position] == comment[:position] &&
+                potential[:commit_id] == comment[:commit_id]
+            end
+
+            client.delete_pull_request_comment(ci_source.repo_slug, comment[:id]) if replies.empty?
+          end
+        end
+      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!(emoji, messages, diff_lines, danger_comments, previous_violations, danger_id: "danger")
+        head_ref = pr_json[:head][:sha]
+        previous_violations ||= []
+        is_markdown_content = emoji.nil?
+
+        submit_inline = proc do |m|
+          next false unless m.file && m.line
+
+          position = find_position_in_diff diff_lines, m
+
+          # Keep the change if it's line is not in the diff
+          next false if position.nil?
+
+          # 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: "github")
+          else
+            # Hide the inline link behind a span
+            m = process_markdown(m, true)
+            body = generate_inline_comment_body(emoji, m, danger_id: danger_id, template: "github")
+            # 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_comments = danger_comments.select do |comment_data|
+            if comment_data[:path] == m.file && comment_data[:commit_id] == head_ref && comment_data[:position] == position
+              # Parse it to avoid problems with strikethrough
+              violation = violations_from_table(comment_data[:body]).first
+              if violation
+                messages_are_equivalent(violation, m)
+              else
+                comment_data[:body] == body
+              end
+            else
+              false
+            end
+          end
+
+          if matching_comments.empty?
+            client.create_pull_request_comment(ci_source.repo_slug, ci_source.pull_request_id,
+                                               body, head_ref, m.file, position)
+          else
+            # Remove the surviving comment so we don't strike it out
+            danger_comments.reject! { |c| matching_comments.include? c }
+
+            # Update the comment to remove the strikethrough if present
+            comment = matching_comments.first
+            client.update_pull_request_comment(ci_source.repo_slug, comment[:id], body)
+          end
+
+          # Remove this element from the array
+          next true
+        end
+
+        messages.reject!(&submit_inline)
+      end
+
+      def find_position_in_diff(diff_lines, message)
+        range_header_regexp = /@@ -([0-9]+),([0-9]+) \+(?<start>[0-9]+)(,(?<end>[0-9]+))? @@.*/
+        file_header_regexp = %r{ a/.*}
+
+        pattern = "+++ b/" + message.file + "\n"
+        file_start = diff_lines.index(pattern)
+
+        return nil if file_start.nil?
+
+        position = -1
+        file_line = nil
+
+        diff_lines.drop(file_start).each do |line|
+          match = line.match range_header_regexp
+
+          # file_line is set once we find the hunk the line is in
+          # we need to count how many lines in new file we have
+          # so we do it one by one ignoring the deleted lines
+          if !file_line.nil? && !line.start_with?("-")
+            break if file_line == message.line
+            file_line += 1
+          end
+
+          # We need to count how many diff lines are between us and
+          # the line we're looking for
+          position += 1
+
+          next unless match
+
+          # If we found the start of another file diff, we went too far
+          break if line.match file_header_regexp
+
+          range_start = match[:start].to_i
+          if match[:end]
+            range_end = match[:end].to_i + range_start
+          else
+            range_end = range_start
+          end
+
+          # We are past the line position, just abort
+          break if message.line < range_start
+          next unless message.line >= range_start && message.line <= range_end
+
+          file_line = range_start
+        end
+
+        position unless file_line.nil?
+      end
+
+      # See the tests for examples of data coming in looks like
+      def parse_message_from_row(row)
+        message_regexp = %r{(<(a |span data-)href="https://github.com/#{ci_source.repo_slug}/blob/[0-9a-z]+/(?<file>[^#]+)#L(?<line>[0-9]+)"(>[^<]*</a> - |/>))?(?<message>.*?)}im
+        match = message_regexp.match(row)
+
+        if match[:line]
+          line = match[:line].to_i
+        else
+          line = nil
+        end
+        Violation.new(row, true, match[:file], line)
+      end
+
+      def markdown_link_to_message(message, hide_link)
+        url = "https://github.com/#{ci_source.repo_slug}/blob/#{pr_json[:head][:sha]}/#{message.file}#L#{message.line}"
+
+        if hide_link
+          "<span data-href=\"#{url}\"/>"
+        else
+          "[#{message.file}#L#{message.line}](#{url}) - "
+        end
+      end
+
       # @return [String] The organisation name, is nil if it can't be detected
       def organisation
         matched = self.issue_json[:repository_url].match(%r{repos\/(.*)\/})

data/lib/danger/scm_source/git_repo.rb

@@ -15,7 +15,10 @@ module Danger
     end
 
     def exec(string)
-      `git #{string}`.strip
+      require "open3"
+      Open3.popen2(default_env, "git #{string}") do |_stdin, stdout, _wait_thr|
+        stdout.read.rstrip
+      end
     end
 
     def head_commit
@@ -25,6 +28,12 @@ module Danger
     def origins
       exec("remote show origin -n").lines.grep(/Fetch URL/)[0].split(": ", 2)[1].chomp
     end
+
+    private
+
+    def default_env
+      { "LANG" => "en_US.UTF-8" }
+    end
   end
 end
 

data/lib/danger/version.rb

@@ -1,4 +1,4 @@
 module Danger
-  VERSION = "3.1.1".freeze
+  VERSION = "3.2.0".freeze
   DESCRIPTION = "Like Unit Tests, but for your Team Culture.".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: danger
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Orta Therox
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-01 00:00:00.000000000 Z
+date: 2016-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -376,6 +376,7 @@ files:
 - lib/danger/ci_source/teamcity.rb
 - lib/danger/ci_source/travis.rb
 - lib/danger/ci_source/xcode_server.rb
+- lib/danger/clients/rubygems_client.rb
 - lib/danger/commands/init.rb
 - lib/danger/commands/init_helpers/interviewer.rb
 - lib/danger/commands/local.rb
@@ -385,7 +386,9 @@ files:
 - lib/danger/commands/plugins/plugin_readme.rb
 - lib/danger/commands/runner.rb
 - lib/danger/commands/systems.rb
+- lib/danger/comment_generators/bitbucket_server.md.erb
 - lib/danger/comment_generators/github.md.erb
+- lib/danger/comment_generators/github_inline.md.erb
 - lib/danger/comment_generators/gitlab.md.erb
 - lib/danger/core_ext/file_list.rb
 - lib/danger/core_ext/string.rb
@@ -393,19 +396,24 @@ files:
 - lib/danger/danger_core/dangerfile_dsl.rb
 - lib/danger/danger_core/environment_manager.rb
 - lib/danger/danger_core/executor.rb
+- lib/danger/danger_core/messages/markdown.rb
+- lib/danger/danger_core/messages/violation.rb
+- lib/danger/danger_core/plugins/dangerfile_bitbucket_server_plugin.rb
 - lib/danger/danger_core/plugins/dangerfile_danger_plugin.rb
 - lib/danger/danger_core/plugins/dangerfile_git_plugin.rb
 - lib/danger/danger_core/plugins/dangerfile_github_plugin.rb
 - lib/danger/danger_core/plugins/dangerfile_gitlab_plugin.rb
 - lib/danger/danger_core/plugins/dangerfile_messaging_plugin.rb
 - lib/danger/danger_core/standard_error.rb
-- lib/danger/danger_core/violation.rb
 - lib/danger/helpers/comments_helper.rb
+- lib/danger/helpers/comments_parsing_helper.rb
 - lib/danger/plugin_support/plugin.rb
 - lib/danger/plugin_support/plugin_file_resolver.rb
 - lib/danger/plugin_support/plugin_linter.rb
 - lib/danger/plugin_support/plugin_parser.rb
 - lib/danger/plugin_support/templates/readme_table.html.erb
+- lib/danger/request_source/bitbucket_server.rb
+- lib/danger/request_source/bitbucket_server_api.rb
 - lib/danger/request_source/github.rb
 - lib/danger/request_source/gitlab.rb
 - lib/danger/request_source/request_source.rb
@@ -431,8 +439,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Like Unit Tests, but for your Team Culture.
 test_files: []
+has_rdoc: 

data/lib/danger/danger_core/violation.rb

@@ -1,10 +0,0 @@
-module Danger
-  class Violation
-    attr_accessor :message, :sticky
-
-    def initialize(message, sticky)
-      self.message = message
-      self.sticky = sticky
-    end
-  end
-end