danger 8.0.3

data/lib/danger/request_sources/local_only.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require "danger/helpers/comments_helper"
+require "danger/helpers/comment"
+
+module Danger
+  module RequestSources
+    class LocalOnly < RequestSource
+      include Danger::Helpers::CommentsHelper
+      attr_accessor :mr_json, :commits_json
+
+      def self.env_vars
+        ["DANGER_LOCAL_ONLY"]
+      end
+
+      def initialize(ci_source, environment)
+        self.ci_source = ci_source
+        self.environment = environment
+      end
+
+      def validates_as_ci?
+        true
+      end
+
+      def validates_as_api_source?
+        true
+      end
+
+      def scm
+        @scm ||= GitRepo.new
+      end
+
+      def setup_danger_branches
+        # Check that discovered values really exists
+        [ci_source.base_commit, ci_source.head_commit].each do |commit|
+          raise "Specified commit '#{commit}' not found" if scm.exec("rev-parse --quiet --verify #{commit}").empty?
+        end
+
+        self.scm.exec "branch #{EnvironmentManager.danger_base_branch} #{ci_source.base_commit}"
+        self.scm.exec "branch #{EnvironmentManager.danger_head_branch} #{ci_source.head_commit}"
+      end
+
+      def fetch_details; end
+
+      def update_pull_request!(_hash_needed); end
+
+      # @return [String] The organisation name, is nil if it can't be detected
+      def organisation
+        nil
+      end
+    end
+  end
+end

data/lib/danger/request_sources/request_source.rb

@@ -0,0 +1,85 @@
+module Danger
+  module RequestSources
+    class RequestSource
+      DANGER_REPO_NAME = "danger".freeze
+
+      attr_accessor :ci_source, :environment, :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::".freeze, "".freeze)
+      end
+
+      def self.available_source_names_and_envs
+        available_request_sources.map do |klass|
+          " - #{klass.source_name}: #{klass.env_vars.join(', '.freeze).yellow}"
+        end
+      end
+
+      def initialize(_ci_source, _environment)
+        raise "Subclass and overwrite initialize"
+      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, _branch: "master", _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
+
+  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,118 @@
+# coding: utf-8
+
+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
+        self.environment = environment
+
+        @is_vsts_git = environment["BUILD_REPOSITORY_PROVIDER"] == "TfsGit"
+
+        project, slug = ci_source.repo_slug.split("/")
+        @api = VSTSAPI.new(project, slug, ci_source.pull_request_id, environment)
+      end
+
+      def validates_as_ci?
+        @is_vsts_git
+      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[: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
+
+        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: "vsts")
+        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}")
+          # 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
+    end
+  end
+end

data/lib/danger/request_sources/vsts_api.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+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(_project, 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
+        minimun_version_for_comments = self.min_api_version_for_comments.split(".").first.to_i
+
+        major_version >= minimun_version_for_comments
+      end
+
+      def inspect
+        inspected = super
+
+        if @token
+          inspected = inspected.sub! @token, "********".freeze
+        end
+
+        inspected
+      end
+
+      def credentials_given?
+        @token && !@token.empty?
+      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 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

data/lib/danger/scm_source/git_repo.rb

@@ -0,0 +1,181 @@
+# For more info see: https://github.com/schacon/ruby-git
+
+require "git"
+
+module Danger
+  class GitRepo
+    attr_accessor :diff, :log, :folder
+
+    def diff_for_folder(folder, from: "master", to: "HEAD", lookup_top_level: false)
+      self.folder = folder
+      git_top_level = folder
+      if lookup_top_level
+        Dir.chdir(folder) do
+          git_top_level = exec("rev-parse --show-toplevel")
+        end
+      end
+      repo = Git.open git_top_level
+
+      ensure_commitish_exists!(from)
+      ensure_commitish_exists!(to)
+
+      merge_base = find_merge_base(repo, from, to)
+      commits_in_branch_count = commits_in_branch_count(from, to)
+
+      self.diff = repo.diff(merge_base, to)
+      self.log = repo.log(commits_in_branch_count).between(from, to)
+    end
+
+    def renamed_files
+      # Get raw diff with --find-renames --diff-filter
+      # We need to pass --find-renames cause
+      # older versions of git don't use this flag as default
+      diff = exec(
+        "diff #{self.diff.from} #{self.diff.to} --find-renames --diff-filter=R"
+      ).lines.map { |line| line.tr("\n", "") }
+
+      before_name_regexp = /^rename from (.*)$/
+      after_name_regexp = /^rename to (.*)$/
+
+      # Extract old and new paths via regexp
+      diff.each_with_index.map do |line, index|
+        before_match = line.match(before_name_regexp)
+        next unless before_match
+
+        after_match = diff.fetch(index + 1, "").match(after_name_regexp)
+        next unless after_match
+
+        {
+          before: before_match.captures.first,
+          after: after_match.captures.first
+        }
+      end.compact
+    end
+
+    def exec(string)
+      require "open3"
+      Dir.chdir(self.folder || ".") do
+        Open3.popen2(default_env, "git #{string}") do |_stdin, stdout, _wait_thr|
+          stdout.read.rstrip
+        end
+      end
+    end
+
+    def head_commit
+      exec("rev-parse HEAD")
+    end
+
+    def tags
+      exec("tag")
+    end
+
+    def origins
+      exec("remote show origin -n").lines.grep(/Fetch URL/)[0].split(": ", 2)[1].chomp
+    end
+
+    def ensure_commitish_exists!(commitish)
+      return ensure_commitish_exists_on_branch!(commitish, commitish) if commit_is_ref?(commitish)
+      return if commit_exists?(commitish)
+
+      git_in_depth_fetch
+      raise_if_we_cannot_find_the_commit(commitish) if commit_not_exists?(commitish)
+    end
+
+    def ensure_commitish_exists_on_branch!(branch, commitish)
+      return if commit_exists?(commitish)
+
+      depth = 0
+      success =
+        (3..6).any? do |factor|
+          depth += Math.exp(factor).to_i
+
+          git_fetch_branch_to_depth(branch, depth)
+          commit_exists?(commitish)
+        end
+
+      return if success
+
+      git_in_depth_fetch
+      raise_if_we_cannot_find_the_commit(commitish) if commit_not_exists?(commitish)
+    end
+
+    private
+
+    def git_in_depth_fetch
+      exec("fetch --depth 1000000")
+    end
+
+    def git_fetch_branch_to_depth(branch, depth)
+      exec("fetch --depth=#{depth} --prune origin +refs/heads/#{branch}:refs/remotes/origin/#{branch}")
+    end
+
+    def default_env
+      { "LANG" => "en_US.UTF-8" }
+    end
+
+    def raise_if_we_cannot_find_the_commit(commitish)
+      raise "Commit #{commitish[0..7]} doesn't exist. Are you running `danger local/pr` against the correct repository? Also this usually happens when you rebase/reset and force-pushed."
+    end
+
+    def commit_exists?(sha1)
+      !commit_not_exists?(sha1)
+    end
+
+    def commit_not_exists?(sha1)
+      exec("rev-parse --quiet --verify #{sha1}^{commit}").empty?
+    end
+
+    def find_merge_base(repo, from, to)
+      possible_merge_base = possible_merge_base(repo, from, to)
+      return possible_merge_base if possible_merge_base
+
+      possible_merge_base = find_merge_base_with_incremental_fetch(repo, from, to)
+      return possible_merge_base if possible_merge_base
+
+      git_in_depth_fetch
+      possible_merge_base = possible_merge_base(repo, from, to)
+
+      raise "Cannot find a merge base between #{from} and #{to}. If you are using shallow clone/fetch, try increasing the --depth" unless possible_merge_base
+
+      possible_merge_base
+    end
+
+    def find_merge_base_with_incremental_fetch(repo, from, to)
+      from_is_ref = commit_is_ref?(from)
+      to_is_ref = commit_is_ref?(to)
+
+      return unless from_is_ref || to_is_ref
+
+      depth = 0
+      (3..6).any? do |factor|
+        depth += Math.exp(factor).to_i
+
+        git_fetch_branch_to_depth(from, depth) if from_is_ref
+        git_fetch_branch_to_depth(to, depth) if to_is_ref
+        possible_merge_base(repo, from, to)
+      end
+    end
+
+    def possible_merge_base(repo, from, to)
+      [repo.merge_base(from, to)].find { |base| commit_exists?(base) }
+    end
+
+    def commits_in_branch_count(from, to)
+      exec("rev-list #{from}..#{to} --count").to_i
+    end
+
+    def commit_is_ref?(commit)
+      /[a-f0-9]{5,40}/ !~ commit
+    end
+  end
+end
+
+module Git
+  class Base
+    # Use git-merge-base https://git-scm.com/docs/git-merge-base to
+    # find as good common ancestors as possible for a merge
+    def merge_base(commit1, commit2, *other_commits)
+      Open3.popen2("git", "merge-base", commit1, commit2, *other_commits) { |_stdin, stdout, _wait_thr| stdout.read.rstrip }
+    end
+  end
+end