danger-additional-logging 0.0.1

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

@@ -0,0 +1,191 @@
+require "danger/plugin_support/plugin"
+
+module Danger
+  # Handles interacting with VSTS inside a Dangerfile. Provides a few functions which wrap `pr_json` and also
+  # through a few standard functions to simplify your code.
+  #
+  # @example Warn when a PR is classed as work in progress
+  #
+  #          warn "PR is classed as Work in Progress" if vsts.pr_title.include? "[WIP]"
+  #
+  # @example Declare a PR to be simple to avoid specific Danger rules
+  #
+  #          declared_trivial = (vsts.pr_title + vsts.pr_body).include?("#trivial")
+  #
+  # @example Ensure there is a summary for a PR
+  #
+  #          failure "Please provide a summary in the Pull Request description" if vsts.pr_body.length < 5
+  #
+  # @example Only accept PRs to the develop branch
+  #
+  #          failure "Please re-submit this PR to develop, we may have already fixed your issue." if vsts.branch_for_base != "develop"
+  #
+  # @example Highlight when a celebrity makes a pull request
+  #
+  #          message "Welcome, Danger." if vsts.pr_author == "dangermcshane"
+  #
+  # @example Ensure that all PRs have an assignee
+  #
+  #          warn "This PR does not have any assignees yet." unless vsts.pr_json["reviewers"].length == 0
+  #
+  # @example Send a message with links to a collection of specific files
+  #
+  #          if git.modified_files.include? "config/*.js"
+  #            config_files = git.modified_files.select { |path| path.include? "config/" }
+  #            message "This PR changes #{ vsts.markdown_link(config_files) }"
+  #          end
+  #
+  # @example Highlight with a clickable link if a Package.json is changed
+  #
+  #         warn "#{vsts.markdown_link("Package.json")} was edited." if git.modified_files.include? "Package.json"
+  #
+  # @example Note an issue with a particular line on a file using the #L[num] syntax, e.g. `#L23`
+  #
+  #         linter_json = `my_linter lint "file"`
+  #         results = JSON.parse linter_json
+  #         unless results.empty?
+  #           file, line, warning = result.first
+  #           warn "#{vsts.markdown_link("#{file}#L#{line}")} has linter issue: #{warning}."
+  #         end
+  #
+  #
+  # @see  danger/danger
+  # @tags core, vsts
+  #
+  class DangerfileVSTSPlugin < Plugin
+    # So that this init can fail.
+    def self.new(dangerfile)
+      return nil if dangerfile.env.request_source.class != Danger::RequestSources::VSTS
+
+      super
+    end
+
+    # The instance name used in the Dangerfile
+    # @return [String]
+    #
+    def self.instance_name
+      "vsts"
+    end
+
+    def initialize(dangerfile)
+      super(dangerfile)
+      @source = dangerfile.env.request_source
+    end
+
+    # @!group VSTS Misc
+    # The hash that represents the PR's JSON. For an example of what this looks like
+    # see the [Danger Fixture'd one](https://raw.githubusercontent.com/danger/danger/master/spec/fixtures/vsts_api/pr_response.json).
+    # @return [Hash]
+    def pr_json
+      @source.pr_json
+    end
+
+    # @!group PR Metadata
+    # The title of the Pull Request.
+    # @return [String]
+    #
+    def pr_title
+      @source.pr_json[:title].to_s
+    end
+
+    # @!group PR Metadata
+    # The body text of the Pull Request.
+    # @return [String]
+    #
+    def pr_description
+      @source.pr_json[:description].to_s
+    end
+    alias pr_body pr_description
+
+    # @!group PR Metadata
+    # The username of the author of the Pull Request.
+    # @return [String]
+    #
+    def pr_author
+      @source.pr_json[:createdBy][:displayName].to_s
+    end
+
+    # @!group PR Commit Metadata
+    # The branch to which the PR is going to be merged into.
+    # @return [String]
+    #
+    def branch_for_base
+      branch_name(:targetRefName)
+    end
+
+    # @!group PR Commit Metadata
+    # A href that represents the current PR
+    # @return [String]
+    #
+    def pr_link
+      repo_path = @source.pr_json[:repository][:remoteUrl].to_s
+      pull_request_id = @source.pr_json[:pullRequestId].to_s
+
+      "#{repo_path}/pullRequest/#{pull_request_id}"
+    end
+
+    # @!group PR Commit Metadata
+    # The branch to which the PR is going to be merged from.
+    # @return [String]
+    #
+    def branch_for_head
+      branch_name(:sourceRefName)
+    end
+
+    # @!group PR Commit Metadata
+    # The base commit to which the PR is going to be merged as a parent.
+    # @return [String]
+    #
+    def base_commit
+      @source.pr_json[:lastMergeTargetCommit][:commitId].to_s
+    end
+
+    # @!group PR Commit Metadata
+    # The head commit to which the PR is requesting to be merged from.
+    # @return [String]
+    #
+    def head_commit
+      @source.pr_json[:lastMergeSourceCommit][:commitId].to_s
+    end
+
+    # @!group VSTS Misc
+    # Returns a list of Markdown links for a file, or files in the head repository.
+    # It returns a string of multiple links if passed an array.
+    # @param    [String or Array<String>] paths
+    #           A list of strings to convert to Markdown links
+    # @param    [Bool] full_path
+    #           Shows the full path as the link's text, defaults to `true`.
+    #
+    # @return [String]
+    #
+    def markdown_link(paths, full_path: true)
+      paths = [paths] unless paths.kind_of?(Array)
+      commit = head_commit
+      repo = pr_json[:repository][:remoteUrl].to_s
+
+      paths = paths.map do |path|
+        path, line = path.split("#L")
+        url_path = path.start_with?("/") ? path : "/#{path}"
+        text = full_path ? path : File.basename(path)
+        url_path.gsub!(" ", "%20")
+        line_ref = line ? "&line=#{line}" : ""
+        create_markdown_link("#{repo}/commit/#{commit}?path=#{url_path}&_a=contents#{line_ref}", text)
+      end
+
+      return paths.first if paths.count < 2
+
+      paths.first(paths.count - 1).join(", ") + " & " + paths.last
+    end
+
+    private
+
+    def create_markdown_link(href, text)
+      "[#{text}](#{href})"
+    end
+
+    def branch_name(key)
+      repo_matches = @source.pr_json[key].to_s.match(%r{refs/heads/(.*)})
+      repo_matches[1] unless repo_matches.nil?
+    end
+  end
+end

data/lib/danger/danger_core/standard_error.rb

@@ -0,0 +1,142 @@
+require "claide"
+require "claide/informative_error"
+
+module Danger
+  # From below here - this entire file was taken verbatim for CocoaPods-Core.
+
+  #-------------------------------------------------------------------------#
+
+  # Wraps an exception raised by a DSL file in order to show to the user the
+  # contents of the line that raised the exception.
+  #
+  class DSLError < StandardError
+    # @return [String] the description that should be presented to the user.
+    #
+    attr_reader :description
+
+    # @return [String] the path of the dsl file that raised the exception.
+    #
+    attr_reader :dsl_path
+
+    # @return [Exception] the backtrace of the exception raised by the
+    #         evaluation of the dsl file.
+    #
+    attr_reader :backtrace
+
+    # @param [Exception] backtrace @see backtrace
+    # @param [String]    dsl_path  @see dsl_path
+    #
+    def initialize(description, dsl_path, backtrace, contents = nil)
+      @description = description
+      @dsl_path    = dsl_path
+      @backtrace   = backtrace
+      @contents    = contents
+    end
+
+    # @return [String] the contents of the DSL that cause the exception to
+    #         be raised.
+    #
+    def contents
+      @contents ||= dsl_path && File.exist?(dsl_path) && File.read(dsl_path)
+    end
+
+    # The message of the exception reports the content of podspec for the
+    # line that generated the original exception.
+    #
+    # @example Output
+    #
+    #   Invalid podspec at `RestKit.podspec` - undefined method
+    #   `exclude_header_search_paths=' for #<Pod::Specification for
+    #   `RestKit/Network (0.9.3)`>
+    #
+    #       from spec-repos/master/RestKit/0.9.3/RestKit.podspec:36
+    #       -------------------------------------------
+    #           # because it would break: #import <CoreData/CoreData.h>
+    #    >      ns.exclude_header_search_paths = 'Code/RestKit.h'
+    #         end
+    #       -------------------------------------------
+    #
+    # @return [String] the message of the exception.
+    #
+    def message
+      @message ||= begin
+        description, stacktrace = parse.values_at(:description, :stacktrace)
+
+        msg = description
+        msg = msg.red if msg.respond_to?(:red)
+        msg << stacktrace if stacktrace
+        msg
+      end
+    end
+
+    def to_markdown
+      @markdown ||= begin
+        description, stacktrace = parse.values_at(:description, :stacktrace)
+
+        # Highlight failed method in markdown
+        description = description.tr("'", "`")
+
+        # Escape markdown brackets
+        description = description.gsub(/<|>/) { |bracket| "\\#{bracket}" }
+
+        md = "## Danger has errored"
+        md << "#{description}\n"
+        md << "```#{stacktrace}```" if stacktrace
+
+        Markdown.new(md, nil, nil)
+      end
+    end
+
+    private
+
+    def parse
+      result = {}
+
+      trace_line, description = parse_line_number_from_description
+      latest_version = Danger.danger_outdated?
+
+      result[:description] = "\n[!] #{description}"
+      result[:description] << upgrade_message(latest_version) if latest_version
+
+      return result unless backtrace && dsl_path && contents
+
+      trace_line = backtrace.find { |l| l.include?(dsl_path.to_s) } || trace_line
+      return result unless trace_line
+
+      line_numer = trace_line.split(":")[1].to_i - 1
+      return result unless line_numer
+
+      lines      = contents.lines
+      indent     = " #  "
+      indicator  = indent.tr("#", ">")
+      first_line = line_numer.zero?
+      last_line  = (line_numer == (lines.count - 1))
+
+      result[:stacktrace] = "\n"
+      result[:stacktrace] << "#{indent}from #{trace_line.gsub(/:in.*$/, '')}\n"
+      result[:stacktrace] << "#{indent}-------------------------------------------\n"
+      result[:stacktrace] << "#{indent}#{lines[line_numer - 1]}" unless first_line
+      result[:stacktrace] << "#{indicator}#{lines[line_numer]}"
+      result[:stacktrace] << "#{indent}#{lines[line_numer + 1]}" unless last_line
+      result[:stacktrace] << "\n" unless result[:stacktrace].end_with?("\n")
+      result[:stacktrace] << "#{indent}-------------------------------------------\n"
+
+      result
+    end
+
+    def parse_line_number_from_description
+      description = self.description
+      if dsl_path && description =~ /((#{Regexp.quote File.expand_path(dsl_path)}|#{Regexp.quote dsl_path.to_s}):\d+)/
+        trace_line = Regexp.last_match[1]
+        description = description.sub(/#{Regexp.quote trace_line}:\s*/, "")
+      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/array_subclass.rb

@@ -0,0 +1,61 @@
+module Danger
+  module Helpers
+    module ArraySubclass
+      include Comparable
+
+      def initialize(array)
+        @__array__ = array
+      end
+
+      def kind_of?(compare_class)
+        return true if compare_class == self.class
+
+        dummy.kind_of?(compare_class)
+      end
+
+      def method_missing(name, *args, &block)
+        super unless __array__.respond_to?(name)
+
+        respond_to_method(name, *args, &block)
+      end
+
+      def respond_to_missing?(name, include_all)
+        __array__.respond_to?(name, include_all) || super
+      end
+
+      def to_a
+        __array__
+      end
+
+      def to_ary
+        __array__
+      end
+
+      def <=>(other)
+        return unless other.kind_of?(self.class)
+
+        __array__ <=> other.instance_variable_get(:@__array__)
+      end
+
+      private
+
+      attr_accessor :__array__
+
+      def dummy
+        Class.new(Array).new
+      end
+
+      def respond_to_method(name, *args, &block)
+        result = __array__.send(name, *args, &block)
+        return result unless result.kind_of?(Array)
+
+        if name =~ /!/
+          __array__ = result
+          self
+        else
+          self.class.new(result)
+        end
+      end
+    end
+  end
+end

data/lib/danger/helpers/comment.rb

@@ -0,0 +1,32 @@
+module Danger
+  class Comment
+    attr_reader :id, :body
+
+    def initialize(id, body, inline = nil)
+      @id = id
+      @body = body
+      @inline = inline
+    end
+
+    def self.from_github(comment)
+      self.new(comment["id"], comment["body"])
+    end
+
+    def self.from_gitlab(comment)
+      if comment.respond_to?(:id) && comment.respond_to?(:body)
+        type = comment.respond_to?(:type) ? comment.type : nil
+        self.new(comment.id, comment.body, type == "DiffNote")
+      else
+        self.new(comment["id"], comment["body"], comment["type"] == "DiffNote")
+      end
+    end
+
+    def generated_by_danger?(danger_id)
+      body.include?("\"generated_by_#{danger_id}\"")
+    end
+
+    def inline?
+      @inline.nil? ? body.include?("") : @inline
+    end
+  end
+end

data/lib/danger/helpers/comments_helper.rb

@@ -0,0 +1,179 @@
+require "kramdown"
+require "danger/helpers/comments_parsing_helper"
+require "danger/helpers/emoji_mapper"
+require "danger/helpers/find_max_num_violations"
+
+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", smart_quotes: %w(apos apos quot quot))
+      end
+
+      # !@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, hide_link)
+        return "" if hide_link
+
+        "#{message.file}#L#{message.line}"
+      end
+
+      # !@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 comparison.
+      #
+      # @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, 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>` and `</p>`.
+        html = html.strip.sub(%r{\A<p>(.*)</p>\z}m, '\1')
+        Violation.new(html, violation.sticky, violation.file, violation.line)
+      end
+
+      def table(name, emoji, violations, all_previous_violations, template: "github")
+        content = violations
+        content = content.map { |v| process_markdown(v) } unless ["bitbucket_server", "vsts"].include?(template)
+
+        kind = table_kind_from_title(name)
+        previous_violations = all_previous_violations[kind] || []
+        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_messages,
+          count: count
+        }
+      end
+
+      def apply_template(tables: [], markdowns: [], danger_id: "danger", template: "github", request_source: template)
+        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 = tables
+        @markdowns = markdowns.map(&:message)
+        @danger_id = danger_id
+        @emoji_mapper = EmojiMapper.new(request_source.sub("_inline", ""))
+
+        return ERB.new(File.read(md_template), trim_mode: "-").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, template: template),
+            table("Warning", "warning", warnings, previous_violations, template: template),
+            table("Message", "book", messages, previous_violations, template: template)
+          ],
+          markdowns: markdowns,
+          danger_id: danger_id,
+          template: template
+        )
+      end
+
+      # resolved is essentially reserved for future use - eventually we might
+      # have some nice generic resolved-thing going :)
+      def generate_message_group_comment(message_group:,
+                                         danger_id: "danger",
+                                         resolved: [],
+                                         template: "github")
+        # cheating a bit - I don't want to alter the apply_template API
+        # so just sneak around behind its back setting some instance variables
+        # to get them to show up in the template
+        @message_group = message_group
+        @resolved = resolved
+        request_source_name = template.sub("_message_group", "")
+
+        apply_template(danger_id: danger_id,
+                       markdowns: message_group.markdowns,
+                       template: template,
+                       request_source: request_source_name)
+          .sub(/\A\n*/, "")
+      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, template: "github")
+        emoji_mapper = EmojiMapper.new(template)
+        if (errors.nil? || errors.empty?) && (warnings.nil? || warnings.empty?)
+          return ENV["DANGER_SUCCESS_MESSAGE"] || "All green. #{random_compliment}"
+        else
+          message = "#{emoji_mapper.map('warning')} "
+          message += "#{'Error'.danger_pluralize(errors.count)}. " unless errors.empty?
+          message += "#{'Warning'.danger_pluralize(warnings.count)}. " unless warnings.empty?
+          message += "Don't worry, everything is fixable."
+          return message
+        end
+      end
+
+      def random_compliment
+        ["Well done.", "Congrats.", "Woo!",
+         "Yay.", "Jolly good show.", "Good on 'ya.", "Nice work."].sample
+      end
+
+      private
+
+      def pluralize(string, count)
+        string.danger_pluralize(count)
+      end
+
+      def truncate(string)
+        max_message_length = 30
+        string.danger_truncate(max_message_length)
+      end
+    end
+  end
+end

data/lib/danger/helpers/comments_parsing_helper.rb

@@ -0,0 +1,71 @@
+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)
+      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|
+          match = danger_table?(table)
+          next unless match
+
+          title = 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
+
+      private
+
+      GITHUB_OLD_REGEX = %r{<th width="100%"(.*?)</th>}im.freeze
+      NEW_REGEX = %r{<th.*data-danger-table="true"(.*?)</th>}im.freeze
+
+      def danger_table?(table)
+        # The old GitHub specific method relied on
+        # the width of a `th` element to find the table
+        # title and determine if it was a danger table.
+        # The new method uses a more robust data-danger-table
+        # tag instead.
+        match = GITHUB_OLD_REGEX.match(table)
+        return match if match
+
+        return NEW_REGEX.match(table)
+      end
+    end
+  end
+end