danger-additional-logging 0.0.1

data/lib/danger/comment_generators/vsts_inline.md.erb

@@ -0,0 +1,17 @@
+<%- @tables.each do |table| -%>
+  <%- if table[:content].any? || table[:resolved].any? -%>
+| | |
+|---|---|
+    <%- table[:content].each do |violation| -%>
+| <%= @emoji_mapper.map(table[:emoji]) %> | <%= "~~" if table[:resolved] %><%= violation.message %><%= "~~" if table[:resolved] %> |
+    <%- end -%>
+
+  <%- end -%>
+<%- end -%>
+
+<%- @markdowns.each do |current| -%>
+<%= current %>
+<%# the previous line has to be aligned far to the left, otherwise markdown can break easily %>
+<%- end -%>
+
+Generated by :no_entry_sign: [Danger](https://danger.systems/ "generated_by_<%= @danger_id %>")

data/lib/danger/core_ext/file_list.rb

@@ -0,0 +1,18 @@
+require "danger/helpers/array_subclass"
+
+module Danger
+  class FileList
+    include Helpers::ArraySubclass
+
+    # Information about pattern: http://ruby-doc.org/core-2.2.0/File.html#method-c-fnmatch
+    # e.g. "**/something.*" for any file called something with any extension
+    def include?(pattern)
+      self.each do |current|
+        if !current.nil? && (File.fnmatch(pattern, current, File::FNM_EXTGLOB) || pattern == current)
+          return true
+        end
+      end
+      return false
+    end
+  end
+end

data/lib/danger/core_ext/string.rb

@@ -0,0 +1,20 @@
+class String
+  # @return [String] the plural form of self determined by count
+  def danger_pluralize(count)
+    "#{count} #{self}#{'s' unless count == 1}"
+  end
+
+  # @return [String] converts to underscored, lowercase form
+  def danger_underscore
+    self.gsub(/::/, "/".freeze).
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2'.freeze).
+      gsub(/([a-z\d])([A-Z])/, '\1_\2'.freeze).
+      tr("-".freeze, "_".freeze).
+      downcase
+  end
+
+  # @return [String] truncates string with ellipsis when exceeding the limit
+  def danger_truncate(limit)
+    length > limit ? "#{self[0...limit]}..." : self
+  end
+end

data/lib/danger/danger_core/dangerfile.rb

@@ -0,0 +1,348 @@
+# So much was ripped direct from CocoaPods-Core - thanks!
+
+require "danger/danger_core/dangerfile_dsl"
+require "danger/danger_core/standard_error"
+require "danger/danger_core/message_aggregator"
+
+require "danger/danger_core/plugins/dangerfile_messaging_plugin"
+require "danger/danger_core/plugins/dangerfile_danger_plugin"
+require "danger/danger_core/plugins/dangerfile_git_plugin"
+require "danger/danger_core/plugins/dangerfile_github_plugin"
+require "danger/danger_core/plugins/dangerfile_gitlab_plugin"
+require "danger/danger_core/plugins/dangerfile_bitbucket_server_plugin"
+require "danger/danger_core/plugins/dangerfile_bitbucket_cloud_plugin"
+require "danger/danger_core/plugins/dangerfile_vsts_plugin"
+require "danger/danger_core/plugins/dangerfile_local_only_plugin"
+
+module Danger
+  class Dangerfile
+    include Danger::Dangerfile::DSL
+
+    attr_accessor :env, :verbose, :plugins, :ui
+
+    # @return [Pathname] the path where the Dangerfile was loaded from. It is nil
+    #         if the Dangerfile was generated programmatically.
+    #
+    attr_accessor :defined_in_file
+
+    # @return [String] a string useful to represent the Dangerfile in a message
+    #         presented to the user.
+    #
+    def to_s
+      "Dangerfile"
+    end
+
+    # These are the classes that are allowed to also use method_missing
+    # in order to provide broader plugin support
+    def self.core_plugin_classes
+      [DangerfileMessagingPlugin]
+    end
+
+    # The ones that everything would break without
+    def self.essential_plugin_classes
+      [DangerfileMessagingPlugin, DangerfileGitPlugin, DangerfileDangerPlugin, DangerfileGitHubPlugin, DangerfileGitLabPlugin, DangerfileBitbucketServerPlugin, DangerfileBitbucketCloudPlugin, DangerfileVSTSPlugin, DangerfileLocalOnlyPlugin]
+    end
+
+    # Both of these methods exist on all objects
+    # http://ruby-doc.org/core-2.2.3/Kernel.html#method-i-warn
+    # http://ruby-doc.org/core-2.2.3/Kernel.html#method-i-fail
+    # However, as we're using using them in the DSL, they won't
+    # get method_missing called correctly without overriding them.
+
+    def warn(*args, **kargs, &blk)
+      method_missing(:warn, *args, **kargs, &blk)
+    end
+
+    def fail(*args, **kargs, &blk)
+      method_missing(:fail, *args, **kargs, &blk)
+    end
+
+    # When an undefined method is called, we check to see if it's something
+    # that the core DSLs have, then starts looking at plugins support.
+
+    def method_missing(method_sym, *arguments, **keyword_arguments, &_block)
+      @core_plugins.each do |plugin|
+        if plugin.public_methods(false).include?(method_sym)
+          if keyword_arguments.empty?
+            return plugin.send(method_sym, *arguments)
+          else
+            return plugin.send(method_sym, *arguments, **keyword_arguments)
+          end
+        end
+      end
+      super
+    end
+
+    # cork_board not being set comes from plugins #585
+    def initialize(env_manager, cork_board = nil)
+      @plugins = {}
+      @core_plugins = []
+      @ui = cork_board || Cork::Board.new(silent: false, verbose: false)
+
+      # Triggers the core plugins
+      @env = env_manager
+
+      # Triggers local plugins from the root of a project
+      Dir["./danger_plugins/*.rb"].each do |file|
+        require File.expand_path(file)
+      end
+
+      refresh_plugins if env_manager.pr?
+    end
+
+    # Iterate through available plugin classes and initialize them with
+    # a reference to this Dangerfile
+    def refresh_plugins
+      plugins = Plugin.all_plugins
+      plugins.each do |klass|
+        next if klass.respond_to?(:singleton_class?) && klass.singleton_class?
+
+        plugin = klass.new(self)
+        next if plugin.nil? || @plugins[klass]
+
+        name = plugin.class.instance_name
+        self.class.send(:attr_reader, name)
+        instance_variable_set("@#{name}", plugin)
+
+        @plugins[klass] = plugin
+        @core_plugins << plugin if self.class.core_plugin_classes.include? klass
+      end
+    end
+    alias init_plugins refresh_plugins
+
+    def core_dsl_attributes
+      @core_plugins.map { |plugin| { plugin: plugin, methods: plugin.public_methods(false) } }
+    end
+
+    def external_dsl_attributes
+      plugins.values.reject { |plugin| @core_plugins.include? plugin }.map { |plugin| { plugin: plugin, methods: plugin.public_methods(false) } }
+    end
+
+    def method_values_for_plugin_hashes(plugin_hashes)
+      plugin_hashes.flat_map do |plugin_hash|
+        plugin = plugin_hash[:plugin]
+        methods = plugin_hash[:methods].select { |name| plugin.method(name).parameters.empty? }
+
+        methods.map do |method|
+          case method
+          when :api
+            value = "Octokit::Client"
+
+          when :pr_json, :mr_json
+            value = "[Skipped JSON]"
+
+          when :pr_diff, :mr_diff
+            value = "[Skipped Diff]"
+
+          else
+            value = plugin.send(method)
+            value = wrap_text(value.encode("utf-8")) if value.kind_of?(String)
+            # So that we either have one value per row
+            # or we have [] for an empty array
+            value = value.join("\n") if value.kind_of?(Array) && value.count > 0
+          end
+
+          [method.to_s, value]
+        end
+      end
+    end
+
+    # Iterates through the DSL's attributes, and table's the output
+    def print_known_info
+      rows = []
+      rows += method_values_for_plugin_hashes(core_dsl_attributes)
+      rows << ["---", "---"]
+      rows += method_values_for_plugin_hashes(external_dsl_attributes)
+      rows << ["---", "---"]
+      rows << ["SCM", env.scm.class]
+      rows << ["Source", env.ci_source.class]
+      rows << ["Requests", env.request_source.class]
+      rows << ["Base Commit", env.meta_info_for_base]
+      rows << ["Head Commit", env.meta_info_for_head]
+
+      params = {}
+      params[:rows] = rows.each { |current| current[0] = current[0].yellow }
+      params[:title] = "Danger v#{Danger::VERSION}\nDSL Attributes".green
+
+      ui.section("Info:") do
+        ui.puts
+        table = Terminal::Table.new(params)
+        table.align_column(0, :right)
+        ui.puts table
+        ui.puts
+      end
+    end
+
+    # Parses the file at a path, optionally takes the content of the file for DI
+    #
+    def parse(path, contents = nil)
+      print_known_info if verbose
+
+      contents ||= File.open(path, "r:utf-8", &:read)
+
+      # Work around for Rubinius incomplete encoding in 1.9 mode
+      if contents.respond_to?(:encoding) && contents.encoding.name != "UTF-8"
+        contents.encode!("UTF-8")
+      end
+
+      if contents.tr!("“”‘’‛", %(""'''))
+        # Changes have been made
+        ui.puts "Your #{path.basename} has had smart quotes sanitised. " \
+          "To avoid issues in the future, you should not use " \
+          "TextEdit for editing it. If you are not using TextEdit, " \
+          "you should turn off smart quotes in your editor of choice.".red
+      end
+
+      if contents.include?("puts")
+        ui.puts "You used `puts` in your Dangerfile. To print out text to GitHub use `message` instead"
+      end
+
+      self.defined_in_file = path
+      instance_eval do
+        # rubocop:disable Lint/RescueException
+
+        eval_file(contents, path)
+      rescue Exception => e
+        message = "Invalid `#{path.basename}` file: #{e.message}"
+        raise DSLError.new(message, path, e.backtrace, contents)
+
+        # rubocop:enable Lint/RescueException
+      end
+    end
+
+    def print_results
+      status = status_report
+      violations = violation_report
+      return if (violations[:errors] + violations[:warnings] + violations[:messages] + status[:markdowns]).count.zero?
+
+      ui.section("Results:") do
+        %i(errors warnings messages).each do |key|
+          formatted = key.to_s.capitalize + ":"
+          title = case key
+                  when :errors
+                    formatted.red
+                  when :warnings
+                    formatted.yellow
+                  else
+                    formatted
+                  end
+          rows = violations[key].uniq
+          print_list(title, rows)
+        end
+
+        if status[:markdowns].count > 0
+          ui.title("Markdown:") do
+            status[:markdowns].each do |current_markdown|
+              ui.puts "#{current_markdown.file}\#L#{current_markdown.line}" if current_markdown.file && current_markdown.line
+              ui.puts current_markdown.message
+            end
+          end
+        end
+      end
+    end
+
+    def failed?
+      violation_report[:errors].count > 0
+    end
+
+    def post_results(danger_id, new_comment, remove_previous_comments)
+      violations = violation_report
+      report = {
+          warnings: violations[:warnings].uniq,
+          errors: violations[:errors].uniq,
+          messages: violations[:messages].uniq,
+          markdowns: status_report[:markdowns].uniq,
+          danger_id: danger_id
+      }
+
+      if env.request_source.respond_to?(:update_pr_by_line!) && ENV["DANGER_MESSAGE_AGGREGATION"]
+        env.request_source.update_pr_by_line!(message_groups: MessageAggregator.aggregate(**report),
+                                              new_comment: new_comment,
+                                              remove_previous_comments: remove_previous_comments,
+                                              danger_id: report[:danger_id])
+      else
+        env.request_source.update_pull_request!(
+          **report,
+          new_comment: new_comment,
+          remove_previous_comments: remove_previous_comments
+        )
+      end
+    end
+
+    def setup_for_running(base_branch, head_branch)
+      env.ensure_danger_branches_are_setup
+      env.scm.diff_for_folder(".".freeze, from: base_branch, to: head_branch, lookup_top_level: true)
+    end
+
+    def run(base_branch, head_branch, dangerfile_path, danger_id, new_comment, remove_previous_comments, report_results = true)
+      # Setup internal state
+      init_plugins
+      env.fill_environment_vars
+
+      begin
+        # Sets up the git environment
+        setup_for_running(base_branch, head_branch)
+
+        # Parse the local Dangerfile
+        parse(Pathname.new(dangerfile_path))
+
+        # Push results to the API
+        # Pass along the details of the run to the request source
+        # to send back to the code review site.
+        post_results(danger_id, new_comment, remove_previous_comments) if report_results
+
+        # Print results in the terminal
+        print_results
+      rescue DSLError => e
+        # Push exception to the API and re-raise
+        post_exception(e, danger_id, new_comment) unless danger_id.nil?
+        raise
+      ensure
+        # Makes sure that Danger specific git branches are cleaned
+        env.clean_up
+      end
+
+      failed?
+    end
+
+    private
+
+    def eval_file(contents, path)
+      eval(contents, nil, path.to_s) # rubocop:disable Security/Eval
+    end
+
+    def print_list(title, rows)
+      unless rows.empty?
+        ui.title(title) do
+          rows.each do |row|
+            if row.file && row.line
+              path = "#{row.file}\#L#{row.line}: "
+            else
+              path = ""
+            end
+
+            ui.puts("- [ ] #{path}#{row.message}")
+          end
+        end
+      end
+    end
+
+    def wrap_text(text, width = 80)
+      text.gsub(/.{,#{width}}/) do |line|
+        line.strip!
+        "#{line}\n"
+      end
+    end
+
+    def post_exception(ex, danger_id, new_comment)
+      return if ENV["DANGER_DO_NOT_POST_INVALID_DANGERFILE_ERROR"]
+      return if danger_id.nil?
+
+      env.request_source.update_pull_request!(
+        danger_id: danger_id,
+        new_comment: new_comment,
+        markdowns: [ex.to_markdown]
+      )
+    end
+  end
+end

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,126 @@
+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
+      elsif repo_url =~ /\.visualstudio\.com/i || repo_url =~ /dev\.azure\.com/i
+        RequestSources::VSTS
+      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,91 @@
+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 = dm.run(
+        base_branch(base),
+        head_branch(head),
+        dangerfile_path,
+        danger_id,
+        new_comment,
+        remove_previous_comments
+      )
+
+      # 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