danger 8.0.3

data/lib/danger/danger_core/dangerfile_dsl.rb

@@ -0,0 +1,29 @@
+module Danger
+  class Dangerfile
+    # Anything inside this module is considered public API, and in the future
+    # documentation will be generated from it via rdoc.
+
+    module DSL
+      # @!group Danger Zone
+      # Provides access to the raw Travis/Circle/Buildkite/GitHub objects, which
+      # you can use to pull out extra bits of information. _Warning_
+      # the interfaces of these objects is **not** considered a part of the Dangerfile public
+      # API, and is viable to change occasionally on the whims of developers.
+      # @return [EnvironmentManager]
+
+      attr_reader :env
+
+      private
+
+      def initialize
+        load_default_plugins
+      end
+
+      def load_default_plugins
+        Dir["./danger_plugins/*.rb"].each do |file|
+          require File.expand_path(file)
+        end
+      end
+    end
+  end
+end

data/lib/danger/danger_core/dangerfile_generator.rb

@@ -0,0 +1,11 @@
+module Danger
+  class DangerfileGenerator
+    # returns the string for a Dangerfile based on a folder's contents'
+    def self.create_dangerfile(_path, _ui)
+      # Use this template for now, but this is a really ripe place to
+      # improve now!
+      dir = Danger.gem_path
+      File.read(File.join(dir, "lib", "assets", "DangerfileTemplate"))
+    end
+  end
+end

data/lib/danger/danger_core/environment_manager.rb

@@ -0,0 +1,123 @@
+require "danger/ci_source/ci_source"
+require "danger/request_sources/request_source"
+
+module Danger
+  class EnvironmentManager
+    attr_accessor :ci_source, :request_source, :scm, :ui, :danger_id
+
+    # Finds a Danger::CI class based on the ENV
+    def self.local_ci_source(env)
+      CI.available_ci_sources.find { |ci| ci.validates_as_ci? env }
+    end
+
+    # Uses the current Danger::CI subclass, and sees if it is a PR
+    def self.pr?(env)
+      local_ci_source(env).validates_as_pr?(env)
+    end
+
+    # @return [String] danger's default head branch
+    def self.danger_head_branch
+      "danger_head".freeze
+    end
+
+    # @return [String] danger's default base branch
+    def self.danger_base_branch
+      "danger_base".freeze
+    end
+
+    def initialize(env, ui = nil, danger_id = "danger")
+      ci_klass = self.class.local_ci_source(env)
+      self.ci_source = ci_klass.new(env)
+      self.ui = ui || Cork::Board.new(silent: false, verbose: false)
+      self.danger_id = danger_id
+
+      RequestSources::RequestSource.available_request_sources.each do |klass|
+        next unless self.ci_source.supports?(klass)
+
+        request_source = klass.new(self.ci_source, env)
+        next unless request_source.validates_as_ci?
+        next unless request_source.validates_as_api_source?
+        self.request_source = request_source
+      end
+
+      raise_error_for_no_request_source(env, self.ui) unless self.request_source
+      self.scm = self.request_source.scm
+    end
+
+    def pr?
+      self.ci_source != nil
+    end
+
+    def fill_environment_vars
+      request_source.fetch_details
+    end
+
+    def ensure_danger_branches_are_setup
+      clean_up
+
+      self.request_source.setup_danger_branches
+    end
+
+    def clean_up
+      [EnvironmentManager.danger_base_branch, EnvironmentManager.danger_head_branch].each do |branch|
+        scm.exec("branch -D #{branch}") unless scm.exec("rev-parse --quiet --verify #{branch}").empty?
+      end
+    end
+
+    def meta_info_for_head
+      scm.exec("--no-pager log #{EnvironmentManager.danger_head_branch} -n1")
+    end
+
+    def meta_info_for_base
+      scm.exec("--no-pager log #{EnvironmentManager.danger_base_branch} -n1")
+    end
+
+    def raise_error_for_no_request_source(env, ui)
+      title, subtitle = extract_title_and_subtitle_from_source(ci_source.repo_url)
+      subtitle += travis_note if env["TRAVIS_SECURE_ENV_VARS"] == "true"
+
+      ui_display_no_request_source_error_message(ui, env, title, subtitle)
+
+      exit(1)
+    end
+
+    private
+
+    def get_repo_source(repo_url)
+      if repo_url =~ /github/i
+        RequestSources::GitHub
+      elsif repo_url =~ /gitlab/i
+        RequestSources::GitLab
+      elsif repo_url =~ /bitbucket\.(org|com)/i
+        RequestSources::BitbucketCloud
+      end
+    end
+
+    def extract_title_and_subtitle_from_source(repo_url)
+      source = get_repo_source(repo_url)
+
+      if source
+        title = "For your #{source.source_name} repo, you need to expose: " + source.env_vars.join(", ").yellow
+        subtitle = "You may also need: #{source.optional_env_vars.join(', ')}" if source.optional_env_vars.any?
+      else
+        title = "For Danger to run on this project, you need to expose a set of following the ENV vars:\n#{RequestSources::RequestSource.available_source_names_and_envs.join("\n")}"
+      end
+
+      [title, (subtitle || "")]
+    end
+
+    def ui_display_no_request_source_error_message(ui, env, title, subtitle)
+      ui.title "Could not set up API to Code Review site for Danger\n".freeze
+      ui.puts title
+      ui.puts subtitle
+      ui.puts "\nFound these keys in your ENV: #{env.keys.join(', '.freeze)}."
+      ui.puts "\nFailing the build, Danger cannot run without API access.".freeze
+      ui.puts "You can see more information at https://danger.systems/guides/getting_started.html".freeze
+    end
+
+    def travis_note
+      "\nTravis note: If you have an open source project, you should ensure 'Display value in build log' enabled for these flags, so that PRs from forks work." \
+      "\nThis also means that people can see this token, so this account should have no write access to repos."
+    end
+  end
+end

data/lib/danger/danger_core/executor.rb

@@ -0,0 +1,92 @@
+module Danger
+  class Executor
+    def initialize(system_env)
+      @system_env = system_env
+    end
+
+    def run(env: nil,
+            dm: nil,
+            cork: nil,
+            base: nil,
+            head: nil,
+            dangerfile_path: nil,
+            danger_id: nil,
+            new_comment: nil,
+            fail_on_errors: nil,
+            fail_if_no_pr: nil,
+            remove_previous_comments: nil)
+      # Create a silent Cork instance if cork is nil, as it's likely a test
+      cork ||= Cork::Board.new(silent: false, verbose: false)
+
+      # Run some validations
+      validate!(cork, fail_if_no_pr: fail_if_no_pr)
+
+      # OK, we now know that Danger can run in this environment
+      env ||= EnvironmentManager.new(system_env, cork, danger_id)
+      dm ||= Dangerfile.new(env, cork)
+
+      ran_status = begin
+        dm.run(
+          base_branch(base),
+          head_branch(head),
+          dangerfile_path,
+          danger_id,
+          new_comment,
+          remove_previous_comments
+        )
+      end
+
+      # By default Danger will use the status API to fail a build,
+      # allowing execution to continue, this behavior isn't always
+      # optimal for everyone.
+      exit(1) if fail_on_errors && ran_status
+    end
+
+    def validate!(cork, fail_if_no_pr: false)
+      validate_ci!
+      validate_pr!(cork, fail_if_no_pr)
+    end
+
+    private
+
+    attr_reader :system_env
+
+    # Could we find a CI source at all?
+    def validate_ci!
+      unless EnvironmentManager.local_ci_source(system_env)
+        abort("Could not find the type of CI for Danger to run on.".red)
+      end
+    end
+
+    # Could we determine that the CI source is inside a PR?
+    def validate_pr!(cork, fail_if_no_pr)
+      unless EnvironmentManager.pr?(system_env)
+        ci_name = EnvironmentManager.local_ci_source(system_env).name.split("::").last
+
+        msg = "Not a #{ci_name} #{commit_request(ci_name)} - skipping `danger` run. "
+        # circle won't run danger properly if the commit is pushed and build runs before the PR exists
+        # https://danger.systems/guides/troubleshooting.html#circle-ci-doesnt-run-my-build-consistently
+        # the best solution is to enable `fail_if_no_pr`, and then re-run the job once the PR is up
+        if ci_name == "CircleCI"
+          msg << "If you only created the PR recently, try re-running your workflow."
+        end
+        cork.puts msg.strip.yellow
+
+        exit(fail_if_no_pr ? 1 : 0)
+      end
+    end
+
+    def base_branch(user_specified_base_branch)
+      user_specified_base_branch || EnvironmentManager.danger_base_branch
+    end
+
+    def head_branch(user_specified_head_branch)
+      user_specified_head_branch || EnvironmentManager.danger_head_branch
+    end
+
+    def commit_request(ci_name)
+      return "Merge Request" if ci_name == 'GitLabCI'
+      return "Pull Request"
+    end
+  end
+end

data/lib/danger/danger_core/message_aggregator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require "danger/danger_core/message_group"
+require "danger/helpers/message_groups_array_helper"
+
+module Danger
+  class MessageAggregator
+    def self.aggregate(*args)
+      new(*args).aggregate
+    end
+
+    def initialize(warnings: [],
+                   errors: [],
+                   messages: [],
+                   markdowns: [],
+                   danger_id: "danger")
+      @messages = warnings + errors + messages + markdowns
+      @danger_id = danger_id
+    end
+
+    # aggregates the messages into an array of MessageGroups
+    # @return [[MessageGroup]]
+    def aggregate
+      # oookay I took some shortcuts with this one.
+      # first, sort messages by file and line
+      @messages.sort! { |a, b| a.compare_by_file_and_line(b) }
+
+      # now create an initial empty message group
+      first_group = MessageGroup.new(file: nil,
+                                     line: nil)
+      @message_groups = @messages.reduce([first_group]) do |groups, msg|
+        # We get to take a shortcut because we sorted the messages earlier - only
+        # have to see if we can append msg to the last group in the list
+        if groups.last << msg
+          # we appended it, so return groups unchanged
+          groups
+        else
+          # have to create a new group since msg wasn't appended to the other
+          # group
+          new_group = MessageGroup.new(file: msg.file,
+                                       line: msg.line)
+          new_group << msg
+          groups << new_group
+        end
+      end
+
+      @message_groups.extend(Helpers::MessageGroupsArrayHelper)
+    end
+  end
+end

data/lib/danger/danger_core/message_group.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Danger
+  class MessageGroup
+    def initialize(file: nil, line: nil)
+      @file = file
+      @line = line
+    end
+
+    # Returns whether this `MessageGroup` is for the same line of code as
+    #   `other`, taking which file they are in to account.
+    # @param other [MessageGroup, Markdown, Violation]
+    # @return [Boolean] whether this `MessageGroup` is for the same line of code
+    def same_line?(other)
+      other.file == file && other.line == line
+    end
+
+    # Merges two `MessageGroup`s that represent the same line of code
+    # In future, perhaps `MessageGroup` will be able to represent a group of
+    # messages for multiple lines.
+    def merge(other)
+      raise ArgumentError, "Cannot merge with MessageGroup for a different line" unless same_line?(other)
+
+      @messages = (messages + other.messages).uniq
+    end
+
+    # Adds a message to the group.
+    # @param message [Markdown, Violation] the message to add
+    def <<(message)
+      # TODO: insertion sort
+      return nil unless same_line?(message)
+
+      inserted = false
+      messages.each.with_index do |other, idx|
+        if (message <=> other) == -1
+          inserted = true
+          messages.insert(idx, message)
+          break
+        end
+      end
+      messages << message unless inserted
+      messages
+    end
+
+    # The list of messages in this group. This list will be sorted in decreasing
+    # order of severity (error, warning, message, markdown)
+    def messages
+      @messages ||= []
+    end
+
+    attr_reader :file, :line
+
+    # @return a hash of statistics. Currently only :warnings_count and
+    # :errors_count
+    def stats
+      stats = { warnings_count: 0, errors_count: 0 }
+      messages.each do |msg|
+        stats[:warnings_count] += 1 if msg.type == :warning
+        stats[:errors_count] += 1 if msg.type == :error
+      end
+      stats
+    end
+
+    def markdowns
+      messages.select { |x| x.type == :markdown }
+    end
+  end
+end

data/lib/danger/danger_core/messages/base.rb

@@ -0,0 +1,56 @@
+module Danger
+  class BaseMessage
+    attr_accessor :message, :file, :line, :type
+
+    def initialize(type:, message:, file: nil, line: nil)
+      @type = type
+      @message = message
+      @file = file
+      @line = line
+    end
+
+    def compare_by_file_and_line(other)
+      order = cmp_nils(file, other.file)
+      return order unless order.nil?
+
+      order = file <=> other.file
+      return order unless order.zero?
+
+      order = cmp_nils(line, other.line)
+      return order unless order.nil?
+
+      line <=> other.line
+    end
+    # compares a and b based entirely on whether one or the other is nil
+    # arguments are in the same order as `a <=> b`
+    # nil is sorted earlier - so cmp_nils(nil, 1) => -1
+    #
+    # If neither are nil, rather than returning `a <=> b` which would seem
+    # like the obvious shortcut, `nil` is returned.
+    # This allows us to distinguish between cmp_nils returning 0 for a
+    # comparison of filenames, which means "a comparison on the lines is
+    # meaningless - you cannot have a line number for a nil file - so they
+    # should be sorted the same", and a <=> b returning 0, which means "the
+    # files are the same, so compare on the lines"
+    #
+    # @return 0, 1, -1, or nil
+    def cmp_nils(a, b)
+      if a.nil? && b.nil?
+        0
+      elsif a.nil?
+        -1
+      elsif b.nil?
+        1
+      end
+    end
+
+    def eql?(other)
+      return self == other
+    end
+
+    # @return [Boolean] returns true if is a file or line, false otherwise
+    def inline?
+      file || line
+    end
+  end
+end

data/lib/danger/danger_core/messages/markdown.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+require "danger/danger_core/messages/base"
+
+module Danger
+  class Markdown < BaseMessage
+
+    def initialize(message, file = nil, line = nil)
+      super(type: :markdown, message: message, file: file, line: line)
+    end
+
+    def ==(other)
+      return false if other.nil?
+      return false unless other.kind_of? self.class
+
+      other.message == message &&
+        other.file == file &&
+        other.line == line
+    end
+
+    def hash
+      h = 1
+      h = h * 31 + message.hash
+      h = h * 17 + file.hash
+      h = h * 17 + line.hash
+      h
+    end
+
+    def to_s
+      extra = []
+      extra << "file: #{file}" unless file
+      extra << "line: #{line}" unless line
+
+      "Markdown #{message} { #{extra.join ', '.freeze} }"
+    end
+
+    def <=>(other)
+      return 1 if other.type != :markdown
+
+      compare_by_file_and_line(other)
+    end
+  end
+end